core_ses.c

6440linuxDriver的源代码

#include "core_header.h"


#ifdef SUPPORT_SES
#include "core_exp.h"
/*
 [ ReceiveDiagnostic	]
 SES_PG_CONFIGURATION
 (ConfigurationPageHeader),
	( EnclosureDescriptorHeader	+ EnclosureDescriptor +	TypeDescriptorHeader )
 SES_PG_DEVICE_ELEMENT_STATUS 
 (DeviceElementStatusPage),
	( DeviceElementStatusDescriptorProtocolEIP0	+ DeviceElementStatusDescriptorEIP0	+ (	SasPhyDescriptor...	) )	/
	( DeviceElementStatusDescriptorProtocolEIP1	+ DeviceElementStatusDescriptorEIP1	+ (	SasPhyDescriptor...	) )
 SES_PG_ELEMENT_DESCRIPTOR 
 (ElementDescriptorPage),
	ElementDescriptor
 SES_PG_ENCLOSURE_STATUS	
 (EnclosureStatusPage),
	DeviceElementForEnclosureStatusPage	/ ArrayElementForEnclosureStatusPage

 [ SendDiagnostic ]
 SES_PG_ENCLOSURE_CONTROL 
 (EnclosureControlPage),
	DeviceElementForEnclosureControlPage / ArrayElementForEnclosureControlPage
*/
#ifdef SUPPORT_I2C
extern MV_QUEUE_COMMAND_RESULT I2C_PrepareAndSendCommand(
	IN PCore_Driver_Extension pCore,
	IN PMV_Request pReq
	);
#endif
void Device_MakeSesRcvDiagRequest(PDomain_Device pDevice, MV_U8 PageCode);

#define	Device_MakeSesConfigurationRequest(a)		(Device_MakeSesRcvDiagRequest(a,SES_PG_CONFIGURATION))
#define	Device_MakeSesElementStatusRequest(a)		(Device_MakeSesRcvDiagRequest(a,SES_PG_DEVICE_ELEMENT_STATUS))
#define	Device_MakeSesElementDescriptorRequest(a)	(Device_MakeSesRcvDiagRequest(a,SES_PG_ELEMENT_DESCRIPTOR))
#define	Device_MakeSesEnclosureStatusRequest(a)		(Device_MakeSesRcvDiagRequest(a,SES_PG_ENCLOSURE_STATUS))

void AssignDeviceElementNumber(
	PDomain_Device pSesDevice,
	PSasPhyDescriptor pSasPhyDescriptor,
	MV_U8 ElementIndex
)
{
	PCore_Driver_Extension pCore = pSesDevice->pPort->Core_Extension;
	MV_U8 i;

	for(i=0; i<MAX_DEVICE_ID; i++)
	{
		MV_U8 index;
		index=pCore->Device_Map[i];
		if(index!=ID_NOT_MAPPED)
		{
			MV_U64 Val64;

			U64_ASSIGN(Val64, MV_CPU_TO_BE64(pCore->Devices[index].SASAddr));

			if(MV_Equals((MV_U8	*)&Val64, pSasPhyDescriptor->SASAddress, 8))
			{
				pCore->Devices[index].SesElementIndex=ElementIndex;
				pCore->Devices[index].pSesDevice=pSesDevice;
			}
		}
	}
}

void PostMakeSesElementStatusRequest(
	PDomain_Device pDevice,
	PMV_Request	pReq
)
{
	PDeviceElementStatusPage		pDeviceElementStatusPage;
	PDeviceElementStatusDescriptor	pDeviceElementStatusDescriptor;
	PSasPhyDescriptor				pSasPhyDescriptor;
	MV_U16 PageLength;
	MV_U8 i, ElementCount;

	pDeviceElementStatusPage = (PDeviceElementStatusPage)pReq->Data_Buffer;
	PageLength=	(pDeviceElementStatusPage->PageLength[0]<<8) + pDeviceElementStatusPage->PageLength[1];

	if ( (PageLength+4)> (MV_U16)(pReq->Data_Transfer_Length))
	{
		MV_PRINT("MakeSesElementStatusRequest failed, 0x%x scratch memory is needed.\n", (PageLength+4));
		return;
	}
	pDeviceElementStatusDescriptor = (PDeviceElementStatusDescriptor) ((MV_PTR_INTEGER)pDeviceElementStatusPage	+ 
		sizeof(DeviceElementStatusPage));

	ElementCount=0;
	while( (MV_PTR_INTEGER)pDeviceElementStatusDescriptor<	((MV_PTR_INTEGER)pDeviceElementStatusPage+ PageLength +	4) )
	{
		if (!pDeviceElementStatusDescriptor->EIP0.Invalid)
		{
/* SAS protocol, Device/Array descriptors */
			if((pDeviceElementStatusDescriptor->EIP0.ProtocolID==0x06)&&
				(pDeviceElementStatusDescriptor->EIP0.DescriptorType==0))
			{
				if (pDeviceElementStatusDescriptor->EIP0.bEIP)	  /* EIP1 */
					pSasPhyDescriptor =	(PSasPhyDescriptor)((MV_PTR_INTEGER)pDeviceElementStatusDescriptor + 
															sizeof(DeviceElementStatusDescriptorEIP1));
				else /*	EIP0 */
					pSasPhyDescriptor =	(PSasPhyDescriptor)((MV_PTR_INTEGER)pDeviceElementStatusDescriptor + 
															sizeof(DeviceElementStatusDescriptorEIP0));

				for	(i = 0;	i <	pDeviceElementStatusDescriptor->EIP0.PhyDescriptorCount; i++)
				{
					if (pDeviceElementStatusDescriptor->EIP0.bEIP)
						AssignDeviceElementNumber(pDevice,pSasPhyDescriptor,pDeviceElementStatusDescriptor->EIP1.ElementIndex);
					else
						AssignDeviceElementNumber(pDevice,pSasPhyDescriptor,ElementCount);
				}
			}
		}
		ElementCount++;
		pDeviceElementStatusDescriptor = (PDeviceElementStatusDescriptor) ((MV_PTR_INTEGER)pDeviceElementStatusDescriptor +
				pDeviceElementStatusDescriptor->EIP0.DeviceElementStatusDescriptorLength + 2);
	}
	Device_MakeSesConfigurationRequest(pDevice);
}

void AssignDeviceOverallElementNumber(
	PDomain_Device pSesDevice,
	MV_U8 ElementIndex,
	MV_U8 TypeOverallCount,
	MV_U8 ElementType
)
{
	PCore_Driver_Extension pCore = pSesDevice->pPort->Core_Extension;
	MV_U8 i;

	for(i=0; i<MAX_DEVICE_ID; i++)
	{
		MV_U8 index;
		index=pCore->Device_Map[i];
		if(index!=ID_NOT_MAPPED)
		{
			if( (pCore->Devices[index].SesElementIndex==ElementIndex) &&
				(pCore->Devices[index].pSesDevice==pSesDevice) )
			{
				pCore->Devices[index].SesOverallElementIndex=ElementIndex + TypeOverallCount;
				pCore->Devices[index].SesElementType=ElementType;
			}
		}
	}
}

void PostMakeSesConfigurationRequest(
	PDomain_Device pDevice,
	PMV_Request	pReq
)
{
	PConfigurationPageHeader	pConfigPage;
	PEnclosureDescriptorHeader	pEnclosureDescriptorHeader;
	PEnclosureDescriptor		pEnclosureDescriptor;
	PTypeDescriptorHeader		pTypeDescriptorHeader; 
	MV_U16 PageLength;
	MV_U8 i, ElementTypeCount, ElementCount;

	pConfigPage	= (PConfigurationPageHeader)pReq->Data_Buffer;

	PageLength=	(pConfigPage->PageLength[0]<<8)	+ pConfigPage->PageLength[1];

	if ( (PageLength+4)> (MV_U16)(pReq->Data_Transfer_Length))
	{
		MV_PRINT("MakeSesConfigurationRequest failed, 0x%x scratch memory is needed.\n", (PageLength+4));
		return;
	}

	pEnclosureDescriptorHeader = (PEnclosureDescriptorHeader) ((MV_PTR_INTEGER)	pConfigPage	+ 
		sizeof(ConfigurationPageHeader));
/* total enclosure number =	primary	+ SubEnclosure = 1+	SubEnclosureCount*/
	ElementTypeCount=0;
	for(i=0;i<=pConfigPage->SubEnclosureCount;i++)
	{
		ElementTypeCount+=pEnclosureDescriptorHeader->NumberOfElementTypesSupported;
		pEnclosureDescriptor = (PEnclosureDescriptor) ((MV_PTR_INTEGER)	pEnclosureDescriptorHeader + 
									sizeof(EnclosureDescriptorHeader) ); 

		pEnclosureDescriptorHeader=	(PEnclosureDescriptorHeader) ((MV_PTR_INTEGER)pEnclosureDescriptor +
			pEnclosureDescriptorHeader->EnclosureDescriptorLength );
	}	 

	pTypeDescriptorHeader =	(PTypeDescriptorHeader)	((MV_PTR_INTEGER) pEnclosureDescriptorHeader);
	ElementCount=0;
	for	(i = 0;	i <	ElementTypeCount; i++)
	{
		ElementCount+=pTypeDescriptorHeader->NumberOfPossibleElements;
		/* not include overall control, element 0..n */
		if( (pTypeDescriptorHeader->ElementType==SES_TYPE_DEVICE) ||
			(pTypeDescriptorHeader->ElementType==SES_TYPE_ARRAY_DEVICE) )
			AssignDeviceOverallElementNumber(pDevice,ElementCount,i, pTypeDescriptorHeader->ElementType);
		pTypeDescriptorHeader =	(PTypeDescriptorHeader)	((MV_PTR_INTEGER)pTypeDescriptorHeader +
			sizeof(TypeDescriptorHeader));
	}
	Device_MakeSesElementDescriptorRequest(pDevice);	
}

MV_U8 FindAsciiNumber(MV_U8	*string, MV_U16	Length)
{
	MV_U8 Sum=0xff;
	MV_U16 i;

	for(i=0;i<Length;i++)
	{
		if((*(string+i)<='9')&&(*(string+i)>='0'))
		{
			if(Sum==0xff) Sum=0;
			Sum=Sum*10 + *(string+i) - '0';
		}
		else if(Sum!=0xff)
		{
			break;
		}
	}
	return Sum;
}

void AssignElementSlotNumber(
	PDomain_Device pSesDevice,
	MV_U8 OverallElementIndex,
	MV_U8 SlotNumber
)
{
	PCore_Driver_Extension pCore = pSesDevice->pPort->Core_Extension;
	MV_U8 i;

	for(i=0; i<MAX_DEVICE_ID; i++)
	{
		MV_U8 index;
		index=pCore->Device_Map[i];
		if(index!=ID_NOT_MAPPED)
		{
			if(	(pCore->Devices[index].pSesDevice==pSesDevice)&&
				(pCore->Devices[index].SesOverallElementIndex==OverallElementIndex) )
			{
				pCore->Devices[index].SesSlotNumber=SlotNumber;
				break;
			}
		}
	}
}

void PostMakeSesElementDescriptorRequest(
	PDomain_Device pDevice,
	PMV_Request	pReq
)
{
	PElementDescriptorPage pElementDescriptorPage;
	PElementDescriptor	   pElementDescriptor;
	MV_U16 PageLength, DescPageLength;
	MV_U8 ElementCount, SlotNumber;

	pElementDescriptorPage = (PElementDescriptorPage)pReq->Data_Buffer;
	PageLength=	(pElementDescriptorPage->PageLength[0]<<8) + pElementDescriptorPage->PageLength[1];

	if ( (PageLength+4)> (MV_U16)(pReq->Data_Transfer_Length))
	{
		MV_PRINT("MakeSesElementDescriptorRequest failed, 0x%x scratch memory is needed.\n", (PageLength+4));
		return;
	}
	pElementDescriptor = (PElementDescriptor) ((MV_PTR_INTEGER)pElementDescriptorPage +	
		sizeof(ElementDescriptorPage));

	ElementCount=0;
	while((MV_PTR_INTEGER)pElementDescriptor<	((MV_PTR_INTEGER)pElementDescriptorPage+ PageLength +	4))
	{
		DescPageLength=	(pElementDescriptor->DescriptorLength[0]<<8) + pElementDescriptor->DescriptorLength[1];

		SlotNumber = FindAsciiNumber((MV_U8	*)((MV_PTR_INTEGER)pElementDescriptor +	4),DescPageLength);

		AssignElementSlotNumber(pDevice, ElementCount,	SlotNumber);

		ElementCount++;
		pElementDescriptor = (PElementDescriptor) ((MV_PTR_INTEGER)pElementDescriptor +
			DescPageLength + 4);
	}
}

void PostMakeSesEnclosureStatusRequest(
	PDomain_Device pDevice,
	PMV_Request	pReq
)
{
	PEnclosureStatusPage pEnclosureStatusPage;
	MV_U16 PageLength;

	pEnclosureStatusPage = (PEnclosureStatusPage)pReq->Data_Buffer;
	PageLength=	(pEnclosureStatusPage->PageLength[0]<<8) + pEnclosureStatusPage->PageLength[1];

	if ( (PageLength+4)> (MV_U16)(pReq->Data_Transfer_Length))
	{