core_helper.c

来自「6440linuxDriver的源代码」· C语言 代码 · 共 2,385 行 · 第 1/5 页

			pSMPResp->Response.ReportGeneral.ConfigurableRouteTable));
		MV_DPRINT((" Max Route Entry 0x%02x%02x\n", 
			pSMPResp->Response.ReportGeneral.MaxNumRoutedSASAddr[0],
			pSMPResp->Response.ReportGeneral.MaxNumRoutedSASAddr[1]));
		break;
	case REPORT_MANUFACTURER_INFORMATION:
		MV_DPRINT((" Manufacturer ID %s\n", 
			pSMPResp->Response.ReportManufacturerInformation.ProductIdentification));
		break;
//	case READ_GPIO_REGISTER:
//						break;
	case REPORT_SELF_CONFGRIGRUATION_STATUS:
		break;
	case DISCOVER:
		MV_DPRINT(("Phy ID 0x%x\n", 
			pSMPResp->Response.Discover.PhyIdentifier));
		MV_DPRINT(("  SAS Address 0x%02x%02x%02x%02x%02x%02x%02x%02x\n", 
			pSMPResp->Response.Discover.AttachedSASAddress[0],
			pSMPResp->Response.Discover.AttachedSASAddress[1],
			pSMPResp->Response.Discover.AttachedSASAddress[2],
			pSMPResp->Response.Discover.AttachedSASAddress[3],
			pSMPResp->Response.Discover.AttachedSASAddress[4],
			pSMPResp->Response.Discover.AttachedSASAddress[5],
			pSMPResp->Response.Discover.AttachedSASAddress[6],
			pSMPResp->Response.Discover.AttachedSASAddress[7]));
		MV_DPRINT(("  Device Type 0x%x\n", 
			pSMPResp->Response.Discover.AttachedDeviceType));
		MV_DPRINT(("  Target %s%s%s\n", 
			(pSMPResp->Response.Discover.TargetBits & FRAME_ATT_DEV_TYPE_SSP)?"SSP ":"",
			(pSMPResp->Response.Discover.TargetBits & FRAME_ATT_DEV_TYPE_SMP)?"SMP ":"",
			(pSMPResp->Response.Discover.TargetBits & FRAME_ATT_DEV_TYPE_STP)?"STP ":""));
		break;
	case REPORT_PHY_ERROR_LOG:
		break;

	case REPORT_PHY_SATA:
		MV_DPRINT(("Report_PHY_SATA Callback: parsing info\n"));
		STP_DeviceReset( pPort, pExpander, pSMPResp );
		break;

	case REPORT_ROUTE_INFORMATION:
		break;
	case REPORT_PHY_EVENT_INFORMATION:
		break;
	case REPORT_PHY_BROADCAST_COUNTS:
		break;
	case DISCOVER_LIST:
		break;
	case REPORT_EXPANDER_ROUTE_TABLE:
		break;
	case CONFIGURE_GENERAL:
		break;
	case ENABLE_DISABLE_ZONING:
		break;
//	case WRITE_GPIO_REGISTER:
//						break;
	case ZONED_BROADCAST:
		break;
	case CONFIGURE_ROUTE_INFORMATION:
		break;
	case PHY_CONTROL:
		break;
	case PHY_TEST:
		break;
	case CONFIGURE_PHY_EVENT_INFORMATION:
		break;
	}

	if( pReq->Scratch_Buffer )
		FreeSMPScratchToPool( pCore, (PSMP_Scratch_Buffer)pReq->Scratch_Buffer );
	FreeInternalReqToPool( pCore, pReq );

	pUpperReq->Scsi_Status = REQ_STATUS_SUCCESS;
	pUpperReq->Completion((MV_PVOID)pCore,pUpperReq);
}


void Core_CSMI_SMPRequest_ReportGeneral(
	IN MV_PVOID pUpReq,
	IN PDomain_Port pPort,
	IN PDomain_Expander pExpander
	)
{
	PCore_Driver_Extension pCore = pPort->Core_Extension;
	PMV_Request pReq = GetInternalReqFromPool(pCore);
	PSMP_Scratch_Buffer pSMPSB;
	struct SMPRequest *pSMPReq;
	PMV_SG_Table pSGTable;
	PMV_Request pUpperReq = (PMV_Request)pUpReq;

	if( pReq == NULL ) 
	{
		MV_DPRINT(("ERROR: No more free internal requests. Request aborted.\n"));
		return;
	}
	pSMPSB = GetSMPScratchFromPool(pCore);
	if( pSMPSB == NULL )
	{
		MV_DPRINT(("ERROR: No more free SMP scratch buffer. Request aborted.\n"));
		return;
	}

	pSGTable = &pReq->SG_Table;

	//Upper layer request
	pReq->Org_Req = pUpperReq;

	/* Prepare identify ATA task */
	pReq->Cdb[0] = SCSI_CMD_MARVELL_SPECIFIC;
	pReq->Cdb[1] = CDB_CORE_MODULE;
	pReq->Cdb[2] = CDB_CORE_SMP;

	pReq->Tag = 0xbb;

	pReq->Device_Id = pExpander->ExpId;

	//pReq->Req_Flag;
	pReq->Cmd_Initiator = pPort->Core_Extension;
	pReq->Data_Transfer_Length = sizeof(struct SMPRequest);
	pReq->Data_Buffer = &pSMPSB->SMP_Req;
	MV_CopyMemory(pReq->Data_Buffer, pUpperReq->Data_Buffer, pReq->Data_Transfer_Length);

	pReq->Scratch_Buffer = pSMPSB;
	pSMPReq=(struct SMPRequest *)pReq->Data_Buffer;
	pSMPReq->Function=REPORT_GENERAL;
	pSMPReq->SMPFrameType=SMP_REQUEST_FRAME;
	pReq->Completion = (void(*)(MV_PVOID,PMV_Request))Core_CSMI_SMPReq_Callback;

	/* Make SG table */
	SGTable_Init(pSGTable, 0);

	/* Submit this internal request */
	Core_ModuleSendRequest(pCore, pReq);
}

void Core_CSMI_SMPRequest_Discover(
	IN MV_PVOID pUpReq,
	IN PDomain_Port pPort,
	IN PDomain_Expander pExpander,
	IN MV_U8 PhyId
	)
{
	PCore_Driver_Extension pCore = pPort->Core_Extension;
	PMV_Request pReq = GetInternalReqFromPool(pCore);
	PSMP_Scratch_Buffer pSMPSB;
	struct SMPRequest *pSMPReq;
	PMV_SG_Table pSGTable;
	PMV_Request pUpperReq = (PMV_Request)pUpReq;

	if (pReq == NULL) 
	{
		MV_DPRINT(("ERROR: No more free internal requests. Request aborted.\n"));
		return;
	}
	pSMPSB = GetSMPScratchFromPool(pCore);
	if( pSMPSB == NULL )
	{
		MV_DPRINT(("ERROR: No more free SMP scratch buffer. Request aborted.\n"));
		return;
	}

	pSGTable = &pReq->SG_Table;

	//Upper layer request
	pReq->Org_Req = pUpperReq;

	/* Prepare identify ATA task */
	pReq->Cdb[0] = SCSI_CMD_MARVELL_SPECIFIC;
	pReq->Cdb[1] = CDB_CORE_MODULE;
	pReq->Cdb[2] = CDB_CORE_SMP;

	pReq->Tag = 0xbb;

	pReq->Device_Id = pExpander->ExpId;

	//pReq->Req_Flag;
	pReq->Cmd_Initiator = pPort->Core_Extension;
	pReq->Data_Transfer_Length = sizeof(struct SMPRequest);
	pReq->Data_Buffer = &pSMPSB->SMP_Req;
	MV_CopyMemory(pReq->Data_Buffer, pUpperReq->Data_Buffer, pReq->Data_Transfer_Length);

	pReq->Scratch_Buffer = pSMPSB;
	pSMPReq=(struct SMPRequest *)pReq->Data_Buffer;
	pSMPReq->Function=DISCOVER;
	pSMPReq->SMPFrameType=SMP_REQUEST_FRAME;
	pSMPReq->Request.Discover.PhyIdentifier=PhyId;
	pReq->Completion = (void(*)(MV_PVOID,PMV_Request))Core_CSMI_SMPReq_Callback;

	/* Make SG table */
	SGTable_Init(pSGTable, 0);

	/* Submit this internal request */
	Core_ModuleSendRequest(pCore, pReq);
}

static void Core_CSMI_TaskReqCallback(
	 IN PCore_Driver_Extension pCore,
	 IN PMV_Request pReq
	 )
{
	PDomain_Port pPort; 
	PDomain_Device pDevice = NULL; 
	MV_U16 Tag,SlotNo;
	PMV_Request pOrgReq = (PMV_Request)pReq->Org_Req;

	pPort = &pCore->Ports[MapPortEntry(pCore,MapPortId(pCore, pReq->Device_Id))];
	pDevice = &pCore->Devices[MapDeviceId(pCore, pReq->Device_Id)];

	Tag = (MV_U16)pReq->Cdb[3] + (MV_U16)(pReq->Cdb[4]<<8);

	SlotNo= Tag&0x1ff;
		
	MV_DPRINT(("Task Function 0x%x Done For Tag 0x%x, SlotNo 0x%x\n", pReq->Cdb[5], Tag, SlotNo));

	switch(pReq->Cdb[5])
	{
	case ABORT_TASK_TMF:
	case LOGICAL_UNIT_RESET_TMF:
		((PMV_Request)pReq->Org_Req)->Scsi_Status = REQ_STATUS_ERROR;
		Core_ResetCmdSlot( pPort, ((PMV_Request)pReq->Org_Req)->SlotNo );
		break;
	case ABORT_TASK_SET_TMF:
	case CLEAR_TASK_SET_TMF:
	case CLEAR_ACA_TMF:
	case QUERY_TASK_TMF:
		MV_DPRINT(("Post Task Function 0x%x not Done\n", pReq->Cdb[5]));
	}

	FreeInternalReqToPool( pCore, pReq );
	pOrgReq->Scsi_Status = REQ_STATUS_SUCCESS;
	pOrgReq->Completion((MV_PVOID)pCore,pOrgReq);

}


void Core_CSMI_Device_MakeRequestTask(
	IN PCore_Driver_Extension pCore,
	IN PMV_Request pOrgReq
	)
{
	PDomain_Device pDevice = &pCore->Devices[pCore->Device_Map[pOrgReq->Device_Id]];
	PMV_Request pReq = GetInternalReqFromPool(pCore);
	PMV_SG_Table pSGTable;
	MV_U16 Tag;

	if( pReq == NULL ) 
	{
		MV_DPRINT(("ERROR: No more free internal requests. Request aborted.\n"));
		return;
	}
	pSGTable = &pReq->SG_Table;
	Tag = (pOrgReq->Tag<<pCore->MaxCmdSlotWidth) | pOrgReq->SlotNo;

	/* Prepare identify ATA task */
	pReq->Cdb[0] = SCSI_CMD_MARVELL_SPECIFIC;
	pReq->Cdb[1] = CDB_CORE_MODULE;
	pReq->Cdb[2] = CDB_CORE_TASK_MGMT;
	pReq->Cdb[3] = pOrgReq->Cdb[3];// byte 0
	pReq->Cdb[4] = pOrgReq->Cdb[4];// byte 1
	//pOrgReq->Cdb[5];// byte 2
	//pOrgReq->Cdb[6];// byte 3
	pReq->Cdb[5] = pOrgReq->Cdb[2]; //bTaskManagementFunction

	MV_CopyMemory(&pReq->Cdb[6], pDevice->saslun, 8);

	pReq->Org_Req = pOrgReq;

	pReq->Tag = 0xaa;

	pReq->Device_Id = pDevice->Id;

	//pReq->Req_Flag;
	pReq->Cmd_Initiator = (MV_PVOID)pCore;
	pReq->Data_Transfer_Length = 0;
	pReq->Data_Buffer = NULL;
	pReq->Completion = (void(*)(MV_PVOID,PMV_Request))Core_CSMI_TaskReqCallback;

	/* Make SG table */
	SGTable_Init(pSGTable, 0);

	/* Send this internal request */
	Core_ModuleSendRequest(pCore, pReq);
}

void Core_CSMI_SMPRequest_PhyControl(
	IN PMV_Request pOrgReq,
	IN PDomain_Port pPort,
	IN PDomain_Expander pTgt,
	IN MV_U8 PhyId
	)
{
	PCore_Driver_Extension pCore = pPort->Core_Extension;
	PMV_Request pReq = GetInternalReqFromPool(pCore);
	PSMP_Scratch_Buffer pSMPSB;
	struct SMPRequest *pSMPReq;
	PMV_SG_Table pSGTable;

	if( pReq == NULL ) 
	{
		MV_DPRINT(("ERROR: No more free internal requests. Request aborted.\n"));
		return;
	}
	pSMPSB = GetSMPScratchFromPool(pCore);
	if( pSMPSB == NULL )
	{
		MV_DPRINT(("ERROR: No more free SMP scratch buffer. Request aborted.\n"));
		return;
	}

	pSGTable = &pReq->SG_Table;

	/* Prepare identify ATA task */
	pReq->Cdb[0] = SCSI_CMD_MARVELL_SPECIFIC;
	pReq->Cdb[1] = CDB_CORE_MODULE;
	pReq->Cdb[2] = CDB_CORE_SMP;

	pReq->Tag = 0xbb;

	pReq->Device_Id = pTgt->ExpId;

	pReq->Org_Req = pOrgReq;
	
	//pReq->Req_Flag;
	pReq->Cmd_Initiator = pPort->Core_Extension;
	pReq->Data_Transfer_Length = sizeof(struct SMPRequest);
	pReq->Data_Buffer = &pSMPSB->SMP_Req;
	pReq->Scratch_Buffer = pSMPSB;
	pSMPReq=(struct SMPRequest *)pReq->Data_Buffer;
	pSMPReq->Function=PHY_CONTROL;	
	pSMPReq->SMPFrameType=SMP_REQUEST_FRAME;
	pSMPReq->Request.PhyControl.PhyIdentifier=PhyId;
	pSMPReq->Request.PhyControl.PhyOperation=pOrgReq->Cdb[2];//PhyOp;//function
	pSMPReq->Request.PhyControl.ProgrammedMaximumPhysicalLinkRate=pOrgReq->Cdb[3]>>4;//LinkRate
	pSMPReq->Request.PhyControl.ProgrammedMinimumPhysicalLinkRate=pOrgReq->Cdb[3]&0x0f;
	pReq->Completion = (void(*)(MV_PVOID,PMV_Request))Core_CSMI_SMPReq_Callback;

	/* Make SG table */
	SGTable_Init(pSGTable, 0);

	/* Send this internal request */
	Core_ModuleSendRequest(pCore, pReq);
}

#endif

#ifdef CORE_SAS_SUPPORT_ATA_COMMAND
void CoreSaveOriginalCDB(
	PCore_Driver_Extension pCore,
	PMV_Request pReq
	) 
{
	PCORE_CONTEXT pContext = NULL;
	pContext = pReq->Context[MODULE_CORE];
	/* Internal bootup request doesn' have the context. */
	if ( pContext ) {
		/* Context haven't been used yet. */
		MV_DASSERT( pContext->Context_Type==CORE_CONTEXT_TYPE_NONE );	
		MV_CopyMemory( pContext->u.cdb.Original_CDB, pReq->Cdb, MAX_CDB_SIZE);
		pContext->u.cdb.Data_Buffer = pReq->Data_Buffer;
		pContext->Context_Type = CORE_CONTEXT_TYPE_CDB;
	}
}

void CoreRestoreOriginalCDB(
	PCore_Driver_Extension pCore,
	PMV_Request pReq
	) 
{
	PCORE_CONTEXT pContext = NULL;
	pContext = pReq->Context[MODULE_CORE];
	if ( pContext ) {
		MV_DASSERT( pContext->Context_Type==CORE_CONTEXT_TYPE_CDB );
		MV_CopyMemory( pReq->Cdb, pContext->u.cdb.Original_CDB, MAX_CDB_SIZE );
		pReq->Data_Buffer = pContext->u.cdb.Data_Buffer;
	}
}
#endif

void mvScsiInquiry(PCore_Driver_Extension pCore, PMV_Request pReq)
{
#ifndef _OS_BIOS
	PDomain_Device pDevice = NULL;
	MV_U8 portId, deviceId;

	portId = MapPortId(pCore, pReq->Device_Id);
	deviceId = MapDeviceId(pCore, pReq->Device_Id);
	if ( (portId>=MAX_PORT_ID)||(pReq->Device_Id >= MAX_DEVICE_ID) ) {
		pReq->Scsi_Status = REQ_STATUS_NO_DEVICE;
		return;
	}
	pDevice = &pCore->Devices[deviceId];
	if ( (pDevice->Status & DEVICE_STATUS_FUNCTIONAL) == 0) {
		/* Device is not functional */
		pReq->Scsi_Status = REQ_STATUS_NO_DEVICE;
		return;
	}

	MV_ZeroMemory(pReq->Data_Buffer, pReq->Data_Transfer_Length);

	if ( pReq->Cdb[1] & CDB_INQUIRY_EVPD )
	{
		MV_U8 MV_INQUIRY_VPD_PAGE0_DATA[6] = {0x00, 0x00, 0x00, 0x02, 0x00, 0x80};
		MV_U8 MV_INQUIRY_VPD_PAGE83_DATA[16] = {
			0x00, 0x83, 0x00, 0x0C, 0x01, 0x02, 0x00, 0x08,
			0x00, 0x50, 0x43, 0x00, 0x00, 0x00, 0x00, 0x00};
		MV_U32 tmpLen = 0;
		pReq->Scsi_Status = REQ_STATUS_SUCCESS;

		/* Shall return the specific page of Vital Production Data */
		switch (pReq->Cdb[2]) {
		case 0x00:	/* Supported VPD pages */
			tmpLen = MV_MIN(pReq->Data_Transfer_Length, 6);
			MV_CopyMemory(pReq->Data_Buffer, MV_INQUIRY_VPD_PAGE0_DATA, tmpLen);
			break;
		case 0x80:	/* Unit Serial Number VPD Page */
			if (pReq->Data_Transfer_Length > 1)
				*(((MV_PU8)(pReq->Data_Buffer)) + 1) = 0x80;
			tmpLen = MV_MIN(pReq->Data_Transfer_Length, 4);
			if (tmpLen >= 4) {
				tmpLen = MV_MIN((pReq->Data_Transfer_Length-4), 20);
				MV_CopyMemory(((MV_PU8)(pReq->Data_Buffer)+4), pDevice->Serial_Number, tmpLen);
				*(((MV_PU8)(pReq->Data_Buffer)) + 3) = (MV_U8)tmpLen;
				tmpLen += 4;
			}
			break;
		case 0x83:	/* Device Identification VPD Page */
			tmpLen = MV_MIN(pReq->Data_Transfer_Length, 16);
			MV_CopyMemory(pReq->Data_Buffer, MV_INQUIRY_VPD_PAGE83_DATA, tmpLen);
			break;
		default:
			pReq->Scsi_Status = REQ_STATUS_HAS_SENSE;
			Core_FillSenseData(pReq, SCSI_SK_ILLEGAL_REQUEST, SCSI_ASC_INVALID_FEILD_IN_CDB);
			break;
		}
		pReq->Data_Transfer_Length = tmpLen;
	} 
	else
	{
		/* Standard inquiry */
		if (pReq->Cdb[2]!=0) {
			/* PAGE CODE field must be zero when EVPD is zero for a valid request */
			/* sense key as ILLEGAL REQUEST and additional sense code as INVALID FIELD IN CDB */
			pReq->Scsi_Status = REQ_STATUS_HAS_SENSE;
			Core_FillSenseData(pReq, SCSI_SK_ILLEGAL_REQUEST, SCSI_ASC_INVALID_FEILD_IN_CDB);
			return;
		}
		else {
			MV_U8 Vendor[9],Product[17], temp[24];
			MV_U8 buff[42];
			MV_U32 i, inquiryLen = 42;

			MV_ZeroMemory(buff, inquiryLen);

			buff[0] = (IS_ATAPI(pDevice))?0x5 : 0;
			buff[1] = (IS_ATAPI(pDevice))?MV_BIT(7) : 0;    /* Not Removable disk */
			buff[2] = 0x05;   //TBD 3  /*claim conformance to SPC-3*/
			buff[3] = 0x12;    /* set RESPONSE DATA FORMAT to 2*/
			buff[4] = 42 - 5;
			buff[6] = 0x0;     /* tagged queuing*/
			buff[7] = 0X13;	//TBD 2;

			MV_CopyMemory(temp, pDevice->Model_Number, 24);
			for (i = 0; i < 9; i++)	{
				if (temp[i] == ' ')
					break;
			}
			if (i == 9)	{
				if (((temp[0] == 'I') && (temp[1] == 'C')) ||
					((temp[0] == 'H') && (temp[1] == 'T')) ||
					((temp[0] == 'H') && (temp[1] == 'D')) ||
					((temp[0] == 'D') && (temp[1] == 'K')))
				{ /*Hitachi*/
					Vendor[0] = 'H';
					Vendor[1] = 'i';
					Vendor[2] = 't';
					Vendor[3] = 'a';
					Vendor[4] = 'c