core_helper.c

来自「6440linuxDriver的源代码」· C语言 代码 · 共 2,385 行 · 第 1/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_PORT_TYPE_SSP)?"SSP ":"",
			(pSMPResp->Response.Discover.TargetBits & FRAME_PORT_TYPE_SMP)?"SMP ":"",
			(pSMPResp->Response.Discover.TargetBits & FRAME_PORT_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, pTgt, 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 );
}

void Expander_SMPRequest_ReportGeneral(
	IN PDomain_Port pPort,
	IN PDomain_Expander pTgt
	)
{
	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->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=REPORT_GENERAL;
	pSMPReq->SMPFrameType=SMP_REQUEST_FRAME;
	pReq->Completion = (void(*)(MV_PVOID,PMV_Request))Expander_SMPReq_Callback;

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

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

void Expander_SMPRequest_Discover(
	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->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=DISCOVER;
	pSMPReq->SMPFrameType=SMP_REQUEST_FRAME;
	pSMPReq->Request.Discover.PhyIdentifier=PhyId;
	pReq->Completion = (void(*)(MV_PVOID,PMV_Request))Expander_SMPReq_Callback;

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

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

void Expander_SMPRequest_PhyControl(
	IN PDomain_Port pPort,
	IN PDomain_Expander pTgt,
	IN MV_U8 PhyId,
	IN MV_U8 PhyOp,
	IN MV_U8 LinkRate
	)
{
	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->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=PhyOp;
	pSMPReq->Request.PhyControl.ProgrammedMaximumPhysicalLinkRate=LinkRate>>4;
	pSMPReq->Request.PhyControl.ProgrammedMinimumPhysicalLinkRate=LinkRate&0x0f;
	pReq->Completion = (void(*)(MV_PVOID,PMV_Request))Expander_SMPReq_Callback;

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

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

void Expander_SMPRequest_ReportPHYSATA( 
	IN PDomain_Port pPort, 
	IN PDomain_Expander pTgt,
	IN MV_U8 PhyId,
	IN PDomain_Device pDevice
	)
{
	PCore_Driver_Extension pCore = pPort->Core_Extension;
	// we use device's internal req, in order to avoid conflict with target's internal req
	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 req */
	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->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=REPORT_PHY_SATA;
	pSMPReq->SMPFrameType=SMP_REQUEST_FRAME;
	pSMPReq->Request.ReportPhySATA.PhyIdentifier = PhyId;
	pReq->Completion = (void(*)(MV_PVOID,PMV_Request))Expander_SMPReq_Callback;

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

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

static void Core_TaskReqCallback(
	 IN PCore_Driver_Extension pCore,
	 IN PMV_Request pReq
	 )
{
	PDomain_Port pPort; 
	PDomain_Device pDevice = NULL; 
	MV_U16 Tag,SlotNo, portId, deviceId;

	portId = MapPortId(pCore, pReq->Device_Id);
	deviceId = MapDeviceId(pCore, pReq->Device_Id);

	if ((portId == ID_NOT_MAPPED) || 
		(MapPortEntry(pCore, portId) == ID_NOT_MAPPED) ||
		(deviceId == ID_NOT_MAPPED))
	{
		FreeInternalReqToPool(pCore, pReq);
		return;
	}

	pPort = &pCore->Ports[MapPortEntry(pCore,portId)];
	pDevice = &pCore->Devices[deviceId];

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

	SlotNo= Tag&0x1ff;
		
	MV_PRINT("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:
		if(	pCore->Running_Req[SlotNo] == pReq->Org_Req)
		{
			MV_DPRINT(("TASKMAN: Reset pPort(0x%x) Req->Device_Id(0x%x) Slot(0x%x)\n",MapPortId(pCore, ((PMV_Request)pReq->Org_Req)->Device_Id),((PMV_Request)pReq->Org_Req)->Device_Id,((PMV_Request)pReq->Org_Req)->SlotNo ));
			pCore->Resetting_Slot[((PMV_Request)pReq->Org_Req)->SlotNo>>5]&=~(1L<<(((PMV_Request)pReq->Org_Req)->SlotNo%32));
			Core_ResetCmdSlot( pPort, ((PMV_Request)pReq->Org_Req)->SlotNo );
		}
		else
		{
			MV_DPRINT(("TASKMAN: Request's command slot has been freed while being aborted\n"));
		}
		break;
	case ABORT_TASK_SET_TMF:
	case CLEAR_TASK_SET_TMF:
	case CLEAR_ACA_TMF:
	case QUERY_TASK_TMF:
		MV_PRINT("Post Task Function 0x%x not Done\n", pReq->Cdb[5]);
	}

	FreeInternalReqToPool( pCore, pReq );
}

#ifndef _OS_BIOS
void Device_MakeRequestTaskRequest(
	IN PDomain_Port pPort,
	IN PMV_Request pOrgReq,
	IN MV_U8 TaskFunction
	)
{
	PCore_Driver_Extension pCore = pPort->Core_Extension;
	PDomain_Device pDevice = &pCore->Devices[pCore->Device_Map[pOrgReq->Device_Id]];
	PMV_Request pReq = GetInternalReqFromPool(pCore);
	PMV_SG_Table pSGTable;
	MV_U16 Tag;

	if(	pCore->Resetting_Slot[pOrgReq->SlotNo>>5]&(1L<<(pOrgReq->SlotNo%32)) )
	{
		MV_DPRINT(("Req Slot 0x%x is being aborted\n",pOrgReq->SlotNo));
		return;
	}

	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] = (MV_U8)(Tag&0xff);
	pReq->Cdb[4] = (MV_U8)(Tag>>8);
	pReq->Cdb[5] = TaskFunction;

	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 = pPort->Core_Extension;
	pReq->Data_Transfer_Length = 0;
	pReq->Data_Buffer = NULL;
	pReq->Completion = (void(*)(MV_PVOID,PMV_Request))Core_TaskReqCallback;

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

	/* Send this internal request */
	Core_ModuleSendRequest(pCore, pReq);
	pCore->Resetting_Slot[pOrgReq->SlotNo>>5]|=1L<<(pOrgReq->SlotNo%32);
}

void Device_MakeReadCapacityTaskRequest(
	PDomain_Device pDevice 
	)
{
	PCore_Driver_Extension pCore = pDevice->pPort->Core_Extension;
	PMV_Request pReq = GetInternalReqFromPool(pCore);
	PSATA_Scratch_Buffer pSATASB;
	PMV_SG_Table pSGTable;

	if( pReq == NULL ) 
	{
		// no internal requests available - wait for now 
		pDevice->Is_Waiting = MV_TRUE;
		return;
	}
	pSATASB = GetSATAScratchFromPool(pCore);
	if( pSATASB == NULL )
	{
		FreeInternalReqToPool(pCore, pReq);
		MV_DPRINT(("ERROR: No more free SATA scratch buffer. Request aborted.\n"));
		return;
	}

	pSGTable = &pReq->SG_Table;

	/* Prepare read capacity */
	pReq->Cdb[0] = SCSI_CMD_READ_CAPACITY_10;

	pReq->Tag = 0xab;

	pReq->Device_Id = pDevice->Id;

	//pReq->Req_Flag;
	pReq->Cmd_Initiator = pCore;
	pReq->Data_Transfer_Length = 8;
	pReq->Cmd_Flag = CMD_FLAG_DATA_IN;
	pReq->Data_Buffer = pSATASB->Scratch_Vir;
	pReq->Sense_Info_Buffer =(MV_PVOID)( (MV_PTR_INTEGER)pReq->Data_Buffer+pReq->Data_Transfer_Length);
	pReq->Sense_Info_Buffer_Length = 0x24;
	pReq->Scratch_Buffer = pSATASB;
	pReq->Completion = (void(*)(MV_PVOID,PMV_Request))SAS_InternalReqCallback;

	/* Make the SG table. */
	SGTable_Init(pSGTable, 0);
	SGTable_Append(
		pSGTable, 
		pSATASB->Scratch_DMA.parts.low,
		pSATASB->Scratch_DMA.parts.high,
		8
		);

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

void Device_MakeReadCapacity16TaskRequest(
	PDomain_Device pDevice 
	)
{
	PCore_Driver_Extension pCore = pDevice->pPort->Core_Extension;
	PMV_Request pReq = GetInternalReqFromPool(pCore);
	PSATA_Scratch_Buffer pSATASB;
	PMV_SG_Table pSGTable;

	if( pReq == NULL ) 
	{
		// no internal requests available - wait for now 
		pDevice->Is_Waiting = MV_TRUE;
		return;
	}
	pSATASB = GetSATAScratchFromPool(pCore);
	if( pSATASB == NULL )
	{
		FreeInternalReqToPool(pCore, pReq);
		MV_DPRINT(("ERROR: No more free SATA scratch buffer. Request aborted.\n"));
		return;
	}

	pSGTable = &pReq->SG_Table;

	/* Prepare read capacity */
	pReq->Cdb[0] = SCSI_CMD_READ_CAPACITY_16;
	pReq->Cdb[1] = 0x10;
	pReq->Cdb[13] = 0x20;

	pReq->Tag = 0xab;

	pReq->Device_Id = pDevice->Id;

	//pReq->Req_Flag;
	pReq->Cmd_Initiator = pCore;
	pReq->Data_Transfer_Length =0x20;
	pReq->Cmd_Flag = CMD_FLAG_DATA_IN;
	pReq->Data_Buffer = pSATASB->Scratch_Vir;
	pReq->Scratch_Buffer = pSATASB;
	pReq->Completion = (void(*)(MV_PVOID,PMV_Request))SAS_InternalReqCallback;

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