core_helper.c

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

		pSATASB->Scratch_DMA.parts.low,
		pSATASB->Scratch_DMA.parts.high,
		0x20);

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

void Device_MakeInquiryTaskRequest(
	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_INQUIRY;
	pReq->Cdb[4] = 0x60;

	pReq->Tag = 0xab;

	pReq->Device_Id = pDevice->Id;

	//pReq->Req_Flag;
	pReq->Cmd_Initiator = pCore;
	pReq->Data_Transfer_Length = 0x60;
	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, 
		pSATASB->Scratch_DMA.parts.low,
		pSATASB->Scratch_DMA.parts.high,
		0x60);

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

void Device_MakeRequestSenseRequest(
	IN PCore_Driver_Extension pCore,
	IN PDomain_Device pDevice,
	IN PMV_Request pNewReq,
	IN PMV_Request pOrgReq
	)
{
	PMV_SG_Table pSGTable = &pNewReq->SG_Table;
	PSATA_Scratch_Buffer pSATASB = GetSATAScratchFromPool(pCore);
	/* MV_U8 senseSize = SATA_SCRATCH_BUFFER_SIZE; */
	MV_U8 senseSize = 18;

	if( pSATASB == NULL )
	{
		MV_DPRINT(("ERROR: No more free SATA scratch buffer. Request aborted.\n"));
		return;
	}

	pNewReq->Device_Id = pDevice->Id;

	pNewReq->Scsi_Status = REQ_STATUS_PENDING;
	pNewReq->Cmd_Initiator = pCore;

	pNewReq->Data_Transfer_Length = senseSize;
	pNewReq->Data_Buffer = pSATASB->Scratch_Vir;
	pNewReq->Scratch_Buffer = pSATASB;
	
	pNewReq->Org_Req = pOrgReq;

	pNewReq->Cmd_Flag = CMD_FLAG_DATA_IN;
#ifdef USE_DMA_FOR_ALL_PACKET_COMMAND	
	pNewReq->Cmd_Flag |=CMD_FLAG_DMA;
#endif

	pNewReq->Completion = NULL;

	/* Make the SG table. */
	SGTable_Init(pSGTable, 0);
	SGTable_Append(
		pSGTable, 
		pSATASB->Scratch_DMA.parts.low,
		pSATASB->Scratch_DMA.parts.high,
		senseSize
		);
	MV_DASSERT( senseSize%2==0 );

	/* Request Sense request */
	pNewReq->Cdb[0]=SCSI_CMD_REQUEST_SENSE;
	pNewReq->Cdb[4]=senseSize;

	/* Fixed sense data format is 18 bytes. */
	MV_ZeroMemory(pNewReq->Data_Buffer, senseSize);
}

#ifdef CORE_SAS_SUPPORT_ATA_COMMAND
void Device_MakeModeSenseRequest(
	PDomain_Device pDevice 
	)
{
	PCore_Driver_Extension pCore = pDevice->pPort->Core_Extension;
	PMV_Request pReq = GetInternalReqFromPool(pCore);
	PSATA_Scratch_Buffer pSATASB;
	PMV_SG_Table pSGTable;
	MV_U16 bufferLength = SATA_SCRATCH_BUFFER_SIZE;

	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;
	}

	bufferLength = bufferLength>=0xFF?0xFF:bufferLength;
	pReq->Cdb[0] = SCSI_CMD_MODE_SENSE_6;
	pReq->Cdb[1] = 0x08;				/* Disable block descriptors */
	pReq->Cdb[2] = 0x08;				/* PC=00b(Current values) Page Code=0x08(caching) */
	pReq->Cdb[3] = 0;					/* Subpage Code */
	pReq->Cdb[4] = (MV_U8)bufferLength;	/* Allocate Length */
	pReq->Cdb[5] = 0;					/* Control */

	pReq->Tag = 0xab;
	pReq->Device_Id = pDevice->Id;
	pReq->Cmd_Initiator = pCore;
	pReq->Data_Transfer_Length = bufferLength;
	pReq->Cmd_Flag = CMD_FLAG_DATA_IN;			/* Data Out */
	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. */
	pSGTable = &pReq->SG_Table;
	SGTable_Init(pSGTable, 0);
	SGTable_Append(
		pSGTable, 
		pSATASB->Scratch_DMA.parts.low,
		pSATASB->Scratch_DMA.parts.high,
		bufferLength);

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

void Device_MakeModeSelectRequest(
	PDomain_Device pDevice 
	)
{
	PCore_Driver_Extension pCore = pDevice->pPort->Core_Extension;
	PMV_Request pReq = GetInternalReqFromPool(pCore);

	if( pReq == NULL ) 
	{
		// no internal requests available - wait for now 
		pDevice->Is_Waiting = MV_TRUE; 
		return;
	}

	pReq->Cdb[0] = SCSI_CMD_MODE_SELECT_6;
	pReq->Tag = 0xab;
	pReq->Device_Id = pDevice->Id;
	pReq->Cmd_Initiator = pCore;
	if ( !SCSI_MakeCacheCommand(pCore, pReq, MV_TRUE, MV_TRUE) ) {
		/* Lack of resource */
		FreeInternalReqToPool(pCore, pReq);
		pDevice->Is_Waiting = MV_TRUE;
		return;
	}

	pReq->Completion = (void(*)(MV_PVOID,PMV_Request))SAS_InternalReqCallback;

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

#endif /* _OS_BIOS */

/* tell core driver to get port sas address and root expander sas address from a dedicated port */
MV_VOID CORE_GetPortAddress(
	IN MV_PVOID PortExtension,
	OUT MV_U8 *SasAddr
	)
{
	PDomain_Port pPort=(PDomain_Port)PortExtension;
	PCore_Driver_Extension pCore = (PCore_Driver_Extension)pPort->Core_Extension;
	int i;
	MV_U64 Val64;

	i=0;
	while( (pPort->MemberPhyMap&(0x1L<<i))==0 )
	{
		i++;
	}
	U64_ASSIGN(Val64, MV_CPU_TO_BE64(pCore->Phy[i].DevSASAddr));

	MV_CopyMemory(SasAddr, &Val64, 8);

}

MV_U32 SMPRespLength(MV_U8 Function)
{
	MV_U32 RespLen;
	RespLen=4;
	switch(Function)
	{
	case REPORT_GENERAL:
		RespLen+= sizeof(struct SMPResponseReportGeneral)-sizeof(MV_U32);
		break;
	case REPORT_MANUFACTURER_INFORMATION:
		RespLen+= sizeof(struct SMPResponseReportManufacturerInformation)-sizeof(MV_U32);
		break;
//	case READ_GPIO_REGISTER:
//		break;
	case REPORT_SELF_CONFGRIGRUATION_STATUS:
		RespLen+= sizeof(struct SMPResponseReportSelfConfigurationStatus)-sizeof(MV_U32);
		break;
	case DISCOVER:
		RespLen+= sizeof(struct SMPResponseDiscover)-sizeof(MV_U32);
		break;
	case REPORT_PHY_ERROR_LOG:
		RespLen+= sizeof(struct SMPResponseReportPhyErrorLog)-sizeof(MV_U32);
		break;
	case REPORT_PHY_SATA:
		RespLen+= sizeof(struct SMPResponseReportPhySATA)-sizeof(MV_U32);
		break;
	case REPORT_ROUTE_INFORMATION:
		RespLen+= sizeof(struct SMPResponseReportRouteInformation)-sizeof(MV_U32);
		break;
	case REPORT_PHY_EVENT_INFORMATION:
		RespLen+= sizeof(struct SMPResponseReportPhyEventInformation)-sizeof(MV_U32);
		break;
	case REPORT_PHY_BROADCAST_COUNTS:
		RespLen+= sizeof(struct SMPResponseReportBroadcastCounts)-sizeof(MV_U32);
		break;
	case DISCOVER_LIST:
		RespLen+= sizeof(struct SMPResponseDiscoverList)-sizeof(MV_U32);
		break;
	case REPORT_EXPANDER_ROUTE_TABLE:
		RespLen+= sizeof(struct SMPResponseReportExpanderTable)-sizeof(MV_U32);
		break;
	case CONFIGURE_GENERAL:
	case ENABLE_DISABLE_ZONING:
//	case WRITE_GPIO_REGISTER:
//		break;
	case ZONED_BROADCAST:
	case CONFIGURE_ROUTE_INFORMATION:
	case PHY_CONTROL:
	case PHY_TEST:
	case CONFIGURE_PHY_EVENT_INFORMATION:
		RespLen+= sizeof(struct SMPResponseConfigureFunction)-sizeof(MV_U32);
		break;
	}
	return RespLen;
}

extern void SATA_HandleDevicePlugin (PCore_Driver_Extension pCore, PDomain_Port pPort);
#ifdef HOT_PLUG_WITH_TIMER
void SATA_WaitForSignature( MV_PVOID This, MV_PVOID temp )
{
	PDomain_Port pPort = (PDomain_Port)This;
	PCore_Driver_Extension pCore = pPort->Core_Extension;
	MV_U8 i;
	MV_PU8 timer = (MV_PU8)temp;

	MV_DPRINT(("timer is %d\n", *timer));
	for(i=0;i<pCore->Phy_Num;i++)
	{
		if(pPort->MemberPhyMap&MV_BIT(i))
			break;
	}

	if (mv_is_sig_fis_received(pCore->Mmio_Base, i)) 
	{
		MV_DPRINT(("hot plug: got signature FIS\n"));
		SATA_HandleDevicePlugin(pCore, pPort);
	}
	else if( *timer >= 40 )
	{
		// we have waited 20 secs for the signature FIS and it still didn't come back
		// trying soft reset
		MV_DPRINT(("no signature FIS is returned, trying soft reset\n"));
		SATA_PortReset(pPort, MV_FALSE);
		return;
	}
	else
	{
		(*timer)++;
		Timer_AddRequest( pCore, 1, SATA_WaitForSignature, pPort, timer );
	}
}
#endif /* HOT_PLUG_WITH_TIMER */

#ifdef USE_DYN_REGISTER_SET
void 
FreeRegisterSet(MV_PVOID This, PDomain_Device pDevice)
{
	PCore_Driver_Extension pCore = (PCore_Driver_Extension)This;

//  not true for hot plug
//	if(pDevice->Outstanding_Req) return;

	mv_disable_register_set(pCore->Mmio_Base, 
					  pDevice->Register_Set);
	pDevice->Register_Set=ID_NOT_MAPPED;
}

void
AssignRegisterSet(MV_PVOID This, PDomain_Device pDevice)
{
	PCore_Driver_Extension pCore = (PCore_Driver_Extension)This;
	MV_U32 tmp;
	MV_U8 i;

	if( IS_SSP(pDevice) ) return;

/* if device is in use, can not change its register set */
	if(pDevice->Register_Set!=ID_NOT_MAPPED)return;

	tmp=MV_REG_READ_DWORD(pCore->Mmio_Base, COMMON_CONTROL);

	for( i=0; i<pCore->MaxRegisterSet; i++ )
	{
		if(i==16) tmp=MV_REG_READ_DWORD(pCore->Mmio_Base, COMMON_CONFIG);

		if( !(tmp & MV_BIT(((i&0x0f)+16))) )
		{
			pDevice->Register_Set = i;
			if(i<16)
				MV_REG_WRITE_DWORD( pCore->Mmio_Base, COMMON_CONTROL, tmp | MV_BIT((i+16)) );
			else
				MV_REG_WRITE_DWORD( pCore->Mmio_Base, COMMON_CONFIG, tmp | MV_BIT(((i&0x0f)+16)) );
			break;
		}
	}
}

#ifdef SUPPORT_PM
void 
PM_FreeRegisterSet(MV_PVOID This, PDomain_PM pPM)
{
	PCore_Driver_Extension pCore = (PCore_Driver_Extension)This;

	mv_disable_register_set(pCore->Mmio_Base, pPM->Register_Set);
	pPM->Register_Set = ID_NOT_MAPPED;
}

MV_U8
PM_AssignRegisterSet(MV_PVOID This, PDomain_PM pPM)
{
	PCore_Driver_Extension pCore = (PCore_Driver_Extension)This;
	MV_U32 tmp;
	MV_U8 i;

	if (pPM->Register_Set != ID_NOT_MAPPED)
		return (pPM->Register_Set);

	tmp = MV_REG_READ_DWORD(pCore->Mmio_Base, COMMON_CONTROL);

	for( i=0; i<pCore->MaxRegisterSet; i++ )
	{
		if(i==16) tmp=MV_REG_READ_DWORD(pCore->Mmio_Base, COMMON_CONFIG);

		if( !(tmp & MV_BIT(((i&0x0f)+16))) )
		{
			pPM->Register_Set = i;
			pPM->Last_Register_Set = i;
			if(i<16)
				MV_REG_WRITE_DWORD( pCore->Mmio_Base, COMMON_CONTROL, tmp | MV_BIT((i+16)) );
			else
				MV_REG_WRITE_DWORD( pCore->Mmio_Base, COMMON_CONFIG, tmp | MV_BIT(((i&0x0f)+16)) );
			break;
		}
	}
	return (pPM->Register_Set);
}
#endif
#endif

void Port_Monitor(PDomain_Port pPort)
{
#ifndef _OS_BIOS
	PCore_Driver_Extension pCore = pPort->Core_Extension;	
	MV_U16 i;
	MV_PRINT("Port_Monitor: Running_Slot[0]=0x%x.\n", pCore->Running_Slot[0]);

	for ( i=0; i<pCore->Slot_Count_Supported; i++ )
	{
		if ( pCore->Running_Req[i]!=NULL )
		{
			if( MapPortId(pCore, pCore->Running_Req[i]->Device_Id) == pPort->Id )
			{
				MV_DumpRequest(pCore->Running_Req[i], MV_FALSE);
				MV_PRINT("pReq(0x%p) tag=0x%x\n",pCore->Running_Req[i],pCore->Running_Req[i]->Tag);
			}
		}
	}
#endif

}

#if defined(SUPPORT_CSMI)

static void Core_CSMI_SMPReq_Callback(
	 IN PCore_Driver_Extension pCore,
	 IN PMV_Request pReq
	 )
{
	MV_U8 portId, expanderId;
	PDomain_Expander pExpander;
	struct SMPResponse *pSMPResp;
	PDomain_Port pPort; 
	PMV_Request pUpperReq;

	portId = MapPortId(pCore, pReq->Device_Id);
	pPort = &pCore->Ports[MapPortEntry(pCore,portId)];
	expanderId = (MV_U8)pReq->Device_Id;
	pExpander = &pCore->Expanders[MapDeviceId(pCore, pReq->Device_Id)];

	pSMPResp= (struct SMPResponse *)pReq->Data_Buffer;

	pUpperReq = (PMV_Request)pReq->Org_Req;
	if(	(pSMPResp->Function == REPORT_GENERAL)&&
		(pSMPResp->Function == DISCOVER)
	){
		pUpperReq->Data_Transfer_Length = pReq->Data_Transfer_Length;
		MV_CopyMemory(pUpperReq->Context[MODULE_CORE], pReq->Data_Buffer, pReq->Data_Transfer_Length);
	}
	MV_DPRINT(("SMP Function 0x%x Done For Port[0x%x].Target[0x%x] "
		 "Result 0x%x\n", 
		 pSMPResp->Function, 
		 portId, 
		 expanderId,
		 pSMPResp->FunctionResult));

	switch(pSMPResp->Function)
	{
	case REPORT_GENERAL:
		MV_DPRINT((" Number of Phy 0x%x\n", 
			pSMPResp->Response.ReportGeneral.NumberOfPhys));
		MV_DPRINT((" Virtual Phy Id 0x%02x%02x%02x%02x%02x%02x%02x%02x\n", 
			pSMPResp->Response.ReportGeneral.EnclosureLogicalIdentifier[0],
			pSMPResp->Response.ReportGeneral.EnclosureLogicalIdentifier[1],
			pSMPResp->Response.ReportGeneral.EnclosureLogicalIdentifier[2],
			pSMPResp->Response.ReportGeneral.EnclosureLogicalIdentifier[3],
			pSMPResp->Response.ReportGeneral.EnclosureLogicalIdentifier[4],
			pSMPResp->Response.ReportGeneral.EnclosureLogicalIdentifier[5],
			pSMPResp->Response.ReportGeneral.EnclosureLogicalIdentifier[6],
			pSMPResp->Response.ReportGeneral.EnclosureLogicalIdentifier[7]));
		MV_DPRINT((" Need Configured 0x%x\n",