core_helper.c

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

	pPM->Last_Register_Set=ID_NOT_MAPPED;
#endif
	MV_LIST_HEAD_INIT(&pPM->Sent_Req_List);
}

PDomain_PM GetPMFromPool( PCore_Driver_Extension pCore )
{
	MV_U16 index;
	MV_U8 i=0;

	if( Tag_IsEmpty(&pCore->PM_Pool) )
	{
		MV_DPRINT(("PM pool empty!\n"));
		return NULL;
	}
	index = Tag_GetOne(&pCore->PM_Pool);

// for consistant binding, we will try to find the first available ID
		/* this ID is already taken - we need to find another */
		/* should only happen after a lot of hot plugs, so that the 
		   IDs looped around */

	for (i=MIN_PM_ID; i<MAX_PM_ID; i++)
	{
		if( pCore->Device_Map[i] == ID_NOT_MAPPED )
		{
                        /* update the last ID into Current_Device_Id */
			if (pCore->Current_PM_Id < i) 
				pCore->Current_PM_Id = i;
				break;
		}
	}

	if (i == MAX_PM_ID)
	{
		MV_DPRINT(("Ran out of PM IDs!\n"));
			return NULL;
	}

	pCore->Device_Map[i] = (MV_U8) index;
	PreEmptyPM(&pCore->PMs[index]);
	pCore->PMs[index].Id = i;

	/*
	It means after driver started, it happen PM hotplug event
	We need to notify all PM devices
	*/
	if (pCore->State == CORE_STATE_STARTED)
		pCore->PMs[index].PluginNotify = 0xFFFF;
	pCore->PMs[index].State = PM_STATE_IDLE;
	pCore->PMs[index].Status = PM_STATUS_IDLE;

	return &pCore->PMs[index];
}

#endif

void FreePortToPool( PCore_Driver_Extension pCore, PDomain_Port pPort )
{
	MV_U16 index;

	index=pCore->Port_Map[pPort->Id];
	pCore->Port_Map[pPort->Id] = ID_NOT_MAPPED;	
	Tag_ReleaseOne(&pCore->Port_Pool, index);
}

void PreEmptyDevice(PDomain_Device pDevice)
{

	MV_ZeroMemory((MV_U8 *)pDevice,sizeof(Domain_Device));

#ifdef SUPPORT_TIMER
	pDevice->Timer_ID=NO_CURRENT_TIMER;
#endif
#ifdef USE_DYN_REGISTER_SET
	pDevice->Register_Set=ID_NOT_MAPPED;
#endif
	pDevice->Queue_Depth=255;
	MV_LIST_HEAD_INIT(&pDevice->Sent_Req_List);
}

PDomain_Device GetDeviceFromPool( PCore_Driver_Extension pCore )
{
	MV_U16 index;
	MV_U8 i=0;

	if( Tag_IsEmpty(&pCore->Device_Pool) )
	{
		MV_DPRINT(("Device pool empty!\n"));
		return NULL;
	}
	index = Tag_GetOne(&pCore->Device_Pool);

        /* for consistant binding, we will try to find the first available
	 * ID this ID is already taken - we need to find another
	 * should only happen after a lot of hot plugs, so that the 
	 * IDs looped around 
	 */
	for (i = 0; i < MAX_DEVICE_ID; i++)
	{
		if( pCore->Device_Map[i] == ID_NOT_MAPPED )
		{
                        /* update the last ID into Current_Device_Id */
			if (pCore->Current_Device_Id < i) 
				pCore->Current_Device_Id = i;
			break;
		}
	}

	if (i == MAX_DEVICE_ID)
	{
		MV_DPRINT(("Ran out of device IDs!\n"));
		return NULL;
	}

	pCore->Device_Map[i] = (MV_U8) index;
	PreEmptyDevice(&pCore->Devices[index]);
	pCore->Devices[index].Id = i;
	pCore->Devices[index].State = DEVICE_STATE_IDLE;
	

	/* Set some default value. */
	pCore->Devices[index].MDMA_Mode	= 0xFF;
	pCore->Devices[index].PIO_Mode	= 0xFF;
	pCore->Devices[index].UDMA_Mode	= 0xFF;
	pCore->Devices[index].Current_MDMA	= 0xFF;
	pCore->Devices[index].Current_PIO	= 0xFF;
	pCore->Devices[index].Current_UDMA	= 0xFF;
	pCore->Devices[index].NegotiatedLinkRate = 0;

	if (pCore->State == CORE_STATE_STARTED)
		pCore->Devices[index].Need_Notify = MV_TRUE;
	
	return &pCore->Devices[index];
}

PDomain_Expander GetExpanderFromPool( PCore_Driver_Extension pCore )
{
	MV_U16 index;
	MV_U8 i=0;

	if( Tag_IsEmpty(&pCore->Expander_Pool) )
	{
		MV_DPRINT(("Expander pool empty!\n"));
		return NULL;
	}
	index = Tag_GetOne( &pCore->Expander_Pool );

// for consistant binding, we will try to find the first available ID
		/* this ID is already taken - we need to find another */
		/* should only happen after a lot of hot plugs, so that the 
		   IDs looped around */
	for( i=MIN_EXPANDER_ID; i<MAX_EXPANDER_ID; i++ )
	{
		if( pCore->Device_Map[i] == ID_NOT_MAPPED )
		{
// update Current_Expander_Id to the last  
			if(pCore->Current_Expander_Id < i) pCore->Current_Expander_Id = i;
				break;
		}
	}
	if( i == MAX_EXPANDER_ID )
	{
		MV_DPRINT(("Ran out of Expander IDs!\n"));
			return NULL;
	}

	pCore->Device_Map[i] = (MV_U8)index;
	MV_ZeroMemory((MV_U8 *)&pCore->Expanders[index], sizeof(Domain_Expander));
	MV_LIST_HEAD_INIT(&pCore->Expanders[index].pChild);
	MV_LIST_HEAD_INIT(&pCore->Expanders[index].pSibling);
	MV_LIST_HEAD_INIT(&pCore->Expanders[index].Device_List);
	pCore->Expanders[index].ExpId = i;
	
	return &pCore->Expanders[index];
}

PDomain_Port GetPortFromPool( PCore_Driver_Extension pCore )
{
	MV_U16 index;
	MV_U8 i=0;

	if( Tag_IsEmpty(&pCore->Port_Pool) )
	{
		MV_DPRINT(("Port pool empty!\n"));
		return NULL;
	}
	index = Tag_GetOne( &pCore->Port_Pool );

// for consistant binding, we will try to get the first available ID.
		/* this ID is already taken - we need to find another */
		/* should only happen after a lot of hot plugs, so that the */
		/* IDs looped around */
	for( i=0; i<MAX_PORT_ID; i++ )
	{
		if( pCore->Port_Map[i] == ID_NOT_MAPPED )
		{
// update Port_Num to the last  
			if(pCore->Port_Num < i) pCore->Port_Num = i;
				break;
		}
	}
	if( i == MAX_PORT_ID )
	{
		MV_DPRINT(("Ran out of Port IDs!\n"));
		return NULL;
	}

	pCore->Port_Map[i] = (MV_U8)index;
	MV_ZeroMemory((MV_U8 *)&pCore->Ports[index], sizeof(Domain_Port));
	MV_LIST_HEAD_INIT(&pCore->Ports[index].pExpTreeRoot);
	MV_LIST_HEAD_INIT(&pCore->Ports[index].Expander_List);
	MV_LIST_HEAD_INIT(&pCore->Ports[index].Device_List);

	pCore->Ports[index].Id = i;
	
	return &pCore->Ports[index];
}

#ifdef _OS_WINDOWS
PMV_Request GetInternalReqFromPool( PCore_Driver_Extension pCore )
{
	PMV_Request pReq;
	if (List_Empty(&pCore->Internal_Req_List)) 
		return NULL;

	pReq = ((PMV_Request)List_GetFirstEntry(&pCore->Internal_Req_List, MV_Request, Queue_Pointer));
	MV_ZeroMvRequest(pReq);
#ifdef CORE_SAS_SUPPORT_ATA_COMMAND
	pReq->Context[MODULE_CORE] = GetCoreContextFromPool(pCore);
#endif /* CORE_SAS_SUPPORT_ATA_COMMAND */
	return pReq;
}

void FreeInternalReqToPool( PCore_Driver_Extension pCore, PMV_Request pReq)
{
	// TBD: reset requests - what values need to be reset?
	List_AddTail( &pReq->Queue_Pointer, &pCore->Internal_Req_List );	

#ifdef CORE_SAS_SUPPORT_ATA_COMMAND
	if ( pReq->Context[MODULE_CORE] )
		FreeCoreContextToPool(pCore, (PCORE_CONTEXT *) &pReq->Context[MODULE_CORE]);
#endif /* CORE_SAS_SUPPORT_ATA_COMMAND */
}
#else /* _OS_WINDOWS */
PMV_Request GetInternalReqFromPool( PCore_Driver_Extension pCore )
{
	PMV_Request pReq;

	pReq = res_get_req_from_pool(pCore->req_pool);
	if (NULL == pReq) {
		return NULL;
	}
#ifdef CORE_SAS_SUPPORT_ATA_COMMAND
	pReq->Context[MODULE_CORE] = GetCoreContextFromPool(pCore);
#endif /* CORE_SAS_SUPPORT_ATA_COMMAND */
	return pReq;
}

void FreeInternalReqToPool( PCore_Driver_Extension pCore, PMV_Request pReq)
{
	res_free_req_to_pool(pCore->req_pool, pReq);

#ifdef CORE_SAS_SUPPORT_ATA_COMMAND
	if ( pReq->Context[MODULE_CORE] )
		FreeCoreContextToPool(pCore, (PCORE_CONTEXT *) &pReq->Context[MODULE_CORE]);
#endif /* CORE_SAS_SUPPORT_ATA_COMMAND */
}
#endif /* _OS_WINDOWS */
#ifdef CORE_SAS_SUPPORT_ATA_COMMAND
PCORE_CONTEXT GetCoreContextFromPool( PCore_Driver_Extension pCore )
{
	PCORE_CONTEXT pContext;

    if ( List_Empty(&pCore->Context_List) ) return NULL;
	pContext = ((PCORE_CONTEXT)List_GetFirstEntry(&pCore->Context_List, CORE_CONTEXT, Queue_Pointer));
	/* Reset some variables. */
	pContext->Context_Type = CORE_CONTEXT_TYPE_NONE;
	return pContext;
}

void FreeCoreContextToPool( PCore_Driver_Extension pCore, PCORE_CONTEXT *ppContext)
{
	MV_DASSERT( *ppContext!=NULL );

	List_AddTail( &(*ppContext)->Queue_Pointer, &pCore->Context_List );

	*ppContext = NULL;
}
#endif

#ifdef SUPPORT_LARGE_REQUEST
PMV_Request GetSubReqFromPool( PCore_Driver_Extension pCore )
{
	PMV_Request pReq;
	if (List_Empty(&pCore->Sub_Req_List)) 
		return NULL;

	pCore->Sub_Req_Count--;
	pReq = ((PMV_Request)List_GetFirstEntry(&pCore->Sub_Req_List, MV_Request, Queue_Pointer));

	/* Don't zero the whole sub request. */
	MV_ZeroMemory(pReq->Context, sizeof(MV_PVOID)* MAX_POSSIBLE_MODULE_NUMBER);

	/* So far I don't use context for sub request. */
#ifdef CORE_SAS_SUPPORT_ATA_COMMAND
	pReq->Context[MODULE_CORE] = GetCoreContextFromPool(pCore);
#endif /* CORE_SAS_SUPPORT_ATA_COMMAND */
	return pReq;
}

void FreeSubReqToPool( PCore_Driver_Extension pCore, PMV_Request pReq)
{
	List_AddTail( &pReq->Queue_Pointer, &pCore->Sub_Req_List );	

	pCore->Sub_Req_Count++;
	/* Needn't release SG table and sense buffer. They are fixed to the request. */
#ifdef CORE_SAS_SUPPORT_ATA_COMMAND
	if ( pReq->Context[MODULE_CORE] )
		FreeCoreContextToPool(pCore, (PCORE_CONTEXT *) &pReq->Context[MODULE_CORE]);
#endif /* CORE_SAS_SUPPORT_ATA_COMMAND */
}
#endif

#ifdef RAID6_HARDWARE_XOR
PCORE_XOR_CONTEXT GetCoreXORContextFromPool( PCore_Driver_Extension pCore )
{
	PCORE_XOR_CONTEXT pContext;
	if ( List_Empty(&pCore->XOR_Context_List) ) return NULL;

	pContext = (PCORE_XOR_CONTEXT)
		List_GetFirstEntry(&pCore->XOR_Context_List, CORE_XOR_CONTEXT, Queue_Pointer);
	/* Reset some variables. */
	pContext->Context_Type = CORE_XOR_CONTEXT_TYPE_NONE;
	pContext->Table_Wrapper = NULL;
	return pContext;
}

void FreeCoreXORContextToPool( PCore_Driver_Extension pCore, PCORE_XOR_CONTEXT *ppContext)
{
	MV_DASSERT( *ppContext!=NULL );
	List_AddTail( &(*ppContext)->Queue_Pointer, &pCore->XOR_Context_List );
	*ppContext = NULL;
}

PXOR_Table_Wrapper GetXORTableWrapperFromPool( PCore_Driver_Extension pCore )
{
	PXOR_Table_Wrapper pResult;
	if ( List_Empty(&pCore->XOR_Table_List) ) return NULL;

	pResult = (PXOR_Table_Wrapper)
		List_GetFirstEntry(&pCore->XOR_Table_List, XOR_Table_Wrapper, Queue_Pointer);
	pResult->NextBuffer = NULL;
	return pResult;
}

void FreeXORTableWrapperToPool( PCore_Driver_Extension pCore, PXOR_Table_Wrapper* ppXORTableWrapper)
{
	MV_DASSERT( *ppXORTableWrapper!=NULL );
	List_AddTail( &(*ppXORTableWrapper)->Queue_Pointer, &pCore->XOR_Table_List );
	/* To avoid multiple release. */
	*ppXORTableWrapper = NULL;
}
#endif

PSATA_Scratch_Buffer GetSATAScratchFromPool( PCore_Driver_Extension pCore )
{
	if( !List_Empty(&pCore->SATA_Scratch_List) )
		return ((PSATA_Scratch_Buffer)List_GetFirstEntry(&pCore->SATA_Scratch_List, SATA_Scratch_Buffer, Queue_Pointer));
	else
		return NULL;
}

/* Release the buffer and set the pointer to NULL. */
void FreeSATAScratchToPool( PCore_Driver_Extension pCore, PSATA_Scratch_Buffer* ppSATASB)
{	
	MV_DASSERT( *ppSATASB!=NULL );
	List_AddTail( &(*ppSATASB)->Queue_Pointer, &pCore->SATA_Scratch_List );	
	/* To avoid multiple release. */
	*ppSATASB = NULL;
}

PSMP_Scratch_Buffer GetSMPScratchFromPool( PCore_Driver_Extension pCore )
{
	if( !List_Empty(&pCore->SMP_Scratch_List) )
		return ((PSMP_Scratch_Buffer)List_GetFirstEntry(&pCore->SMP_Scratch_List, SMP_Scratch_Buffer, Queue_Pointer));
	else
		return NULL;
}

void FreeSMPScratchToPool( PCore_Driver_Extension pCore, PSMP_Scratch_Buffer pSMPSB)
{						
	// TBD: reset SMP Request - what values need resetting? 
	List_AddTail( &pSMPSB->Queue_Pointer, &pCore->SMP_Scratch_List );	
}

PSG_Buffer GetSGBufferFromPool( PCore_Driver_Extension pCore )
{
	PSG_Buffer pResult;
	if ( List_Empty(&pCore->SG_Buffer_List) ) return NULL;

	pResult = (PSG_Buffer)List_GetFirstEntry(&pCore->SG_Buffer_List, SG_Buffer, Queue_Pointer);
	pResult->NextBuffer = NULL;

	return pResult;
}

/* Release the buffer and set the pointer to NULL. */
void FreeSGBufferToPool( PCore_Driver_Extension pCore, PSG_Buffer* ppSGBuf)
{	
	MV_DASSERT( *ppSGBuf!=NULL );
	List_AddTail( &(*ppSGBuf)->Queue_Pointer, &pCore->SG_Buffer_List );	
	/* To avoid multiple release. */
	*ppSGBuf = NULL;
}

void Expander_SMPReq_Callback(
	 IN PCore_Driver_Extension pCore,
	 IN PMV_Request pReq
	 )
{
	MV_U8 portId, TgtId;
	struct _Domain_Expander *pTgt;
	struct SMPResponse *pSMPResp;
	PDomain_Port pPort; 

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

	pSMPResp= (struct SMPResponse *)pReq->Data_Buffer;
	MV_DPRINT(("SMP Function 0x%x Done For Port[0x%x].Target[0x%x] "
		 "Result 0x%x\n", 
		 pSMPResp->Function, 
		 portId, 
		 TgtId,
		 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", 
			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],