core_api.c

6440linuxDriver的源代码

#include "core_header.h"

#ifdef CORE_SUPPORT_API

#include "core_api.h"
#include "core_init.h"
#include "com_error.h"
#include "core_spi.h"
#include "core_exp.h"
#include "core_helper.h"
#include "core_extern.h"
#include "core_sata.h"
#include "hba_inter.h"

#if defined(SUPPORT_CSMI)
#   include "csmisas.h"
#endif /* SUPPORT_CSMI */

void CompleteRequest(PCore_Driver_Extension pCore, PMV_Request pReq, MV_U8 RegSet);
#ifdef SUPPORT_PASS_THROUGH_DIRECT
void HBARequestCallback(MV_PVOID This,PMV_Request pReq);
#endif /* SUPPORT_PASS_THROUGH_DIRECT */
typedef MV_BOOLEAN (*CORE_Management_Command_Handler)(PCore_Driver_Extension, PMV_Request);
#ifndef _OS_BIOS
CORE_Management_Command_Handler core_pd_cmd_handler[];
#endif

MV_BOOLEAN
Core_MapHDId(
	IN PCore_Driver_Extension pCore,
	IN MV_U16 HDId,
	OUT MV_PU8 portId,
	OUT MV_PU8 deviceId
	);

MV_VOID
Core_GetHDInformation(
	PCore_Driver_Extension pCore,
	IN PDomain_Device pDevice,
    OUT PHD_Info pHD 
	);

MV_VOID
Core_GetExpInformation(
	PCore_Driver_Extension pCore,
	IN PDomain_Expander pExp,
    OUT PExp_Info pExpInfo,
	IN PMV_Request pReq
	);

MV_VOID
Core_GetPMInformation(
	PCore_Driver_Extension pCore,
	IN PDomain_Port pPort,
    OUT PPM_Info pPM 
	);

#ifndef BIOS_NOT_SUPPORT
MV_VOID
Core_GetHDConfiguration(
	PCore_Driver_Extension pCore,
	IN PDomain_Port pPort,
	IN PDomain_Device pDevice,
    OUT PHD_Config pHD 
	);

MV_VOID
Core_SetHDConfiguration(
	PCore_Driver_Extension pCore,
	IN PDomain_Port pPort,
	IN PDomain_Device pDevice,
    IN PHD_Config pHD 
	);
#endif /* #ifndef BIOS_NOT_SUPPORT */

/*
 * Exposed Functions
 */
MV_VOID
Core_GetHDInfo(
	IN MV_PVOID extension,
	IN MV_U16 HDId,
    OUT PHD_Info pHD 
	)
{
	PCore_Driver_Extension pCore = (PCore_Driver_Extension)extension;
	MV_U16 startId, endId;
	MV_U8 deviceId;
	PDomain_Device pDevice = NULL;
	MV_U16 i;

	if ( HDId==0xFF )	/* Get all the HD information */
	{
		startId = 0; 
		endId = MAX_DEVICE_ID-1;
	}
	else
	{
		startId = HDId;
		endId = HDId;
	}

	for ( i=startId; i<=endId; i++ )
	{
		deviceId = MapDeviceId(pCore, i);
		if ( (i < MAX_DEVICE_ID) && (deviceId != ID_NOT_MAPPED) )
		{
			pDevice = &pCore->Devices[deviceId];
			// don't report enclosures
			if (pDevice->Dev_Type == DT_ENCLOSURE)
			{
				pHD->Link.Self.DevID = i;
				pHD->Link.Self.DevType = DEVICE_TYPE_NONE;
			}
			else
				Core_GetHDInformation( pCore, pDevice, pHD );
		} 
		else
		{
			pHD->Link.Self.DevID = i;
			pHD->Link.Self.DevType = DEVICE_TYPE_NONE;
		}
		//MV_DASSERT( pHD->Id==i );
		pHD++;
	}
}

MV_VOID
Core_GetHDInfo_Ext(
	IN MV_PVOID extension,
	IN MV_U16 HDId,
    OUT PHD_Info pHD 
	)
{
	PCore_Driver_Extension pCore = (PCore_Driver_Extension)extension;
	MV_U16 startId, endId;
	MV_U8 deviceId;
	PDomain_Device pDevice = NULL;
	MV_U16 i;

	if ( HDId==0xFF )	/* Get all the HD information */
	{
		startId = 0; 
		endId = MAX_DEVICE_ID-1;
	}
	else
	{
		startId = HDId;
		endId = HDId;
	}

	for ( i=startId; i<=endId; i++ )
	{
		deviceId = MapDeviceId(pCore, i);
		if ( (i < MAX_DEVICE_ID) && (deviceId != ID_NOT_MAPPED) )
		{
			pDevice = &pCore->Devices[deviceId];
			// we don't report enclosures
			if (pDevice->Dev_Type == DT_ENCLOSURE)
			{
				pHD->Link.Self.DevID = i;
				pHD->Link.Self.DevType = DEVICE_TYPE_NONE;
			}
			else
				Core_GetHDInformation_Ext( pCore, pDevice, pHD );
		} 
		else
		{
			pHD->Link.Self.DevID = i;
			pHD->Link.Self.DevType = DEVICE_TYPE_NONE;
		}
		//MV_DASSERT( pHD->Id==i );
		pHD++;
	}
}

MV_VOID
Core_GetExpInfo(
	IN MV_PVOID extension,
	IN MV_U16 ExpId,
	OUT PExp_Info pExpInfo,
	IN PMV_Request pReq
	)
{
	PCore_Driver_Extension pCore = (PCore_Driver_Extension)extension;
	MV_U16 startId, endId;
	MV_U8 tgtId;
	PDomain_Expander pExp = NULL;
	MV_U16 i;

	if ( ExpId==0xFF )	/* Get all the HD information */
	{
		startId = MIN_EXPANDER_ID; 
		endId = pCore->Expander_Count_Supported - 1 + MIN_EXPANDER_ID;
	}
	else
	{
		startId = ExpId;
		endId = ExpId;
	}

	/* use Scratch_Count1 to keep track of how many expanders we need to get info
	   use Scratch_Count2 to keep track of how many we have already finished */
	pCore->Scratch_Count1 = endId - startId + 1;
	pCore->Scratch_Count2 = 0;

	for ( i=startId; i<=endId; i++ )
	{
		tgtId = MapDeviceId(pCore, i);
		if ( (i < pCore->Expander_Count_Supported + MIN_EXPANDER_ID) && (tgtId != ID_NOT_MAPPED) )
		{
			pExp = &pCore->Expanders[tgtId];
			Core_GetExpInformation( pCore, pExp, pExpInfo, pReq );
		} 
		else
		{
			pExpInfo->Link.Self.DevID = i;
			pExpInfo->Link.Self.DevType = DEVICE_TYPE_NONE;
			pCore->Scratch_Count2++;
		}
		pExpInfo++;
	}
}

#ifdef SUPPORT_PM
MV_VOID
Core_GetPMInfo(
	IN MV_PVOID extension,
	IN MV_U16 PMId,
    OUT PPM_Info pPM 
	)
{
	PCore_Driver_Extension pCore = (PCore_Driver_Extension)extension;
	MV_U16 startId, endId;
	PDomain_Port pPort = NULL;
	MV_U16 i;

	if ( PMId==0xFF )	/* Get all the HD information */
	{
		startId = 0; 
		endId = MAX_PORT_ID - 1;
	}
	else
	{
		startId = PMId;
		endId = PMId;
	}

	for ( i=startId; i<=endId; i++ )
	{
		if(pCore->Port_Map[i]==ID_NOT_MAPPED)
			continue;
		pPort = &pCore->Ports[MapPortEntry(pCore,i)];
		if ( !(pPort->Setting & PORT_SETTING_PM_FUNCTIONAL) )
		{
			if ( PMId != 0xFF )
			{
				// TBD: not a PM, return error
			}
		}
		else 
		{
			Core_GetPMInformation( pCore, pPort, pPM );
			pPM++;
		}
	}
}
#endif /* SUPPORT_PM */

#ifndef BIOS_NOT_SUPPORT
MV_VOID
Core_GetHDConfig(
	IN MV_PVOID extension,
	IN MV_U16 HDId,
    OUT PHD_Config pHD 
	)
{
	PCore_Driver_Extension pCore = (PCore_Driver_Extension)extension;
	MV_U16 startId, endId;
	MV_U8 portId, deviceId;
	PDomain_Port pPort = NULL;
	PDomain_Device pDevice = NULL;
	MV_U16 i;

	if ( HDId==0xFF )	/* Get all the HD configuration */
	{
		startId = 0; 
		endId = MV_MAX_HD_DEVICE_ID-1;
	}
	else
	{
		startId = HDId;
		endId = HDId;
	}

	for ( i=startId; i<=endId; i++ )
	{
		if ( Core_MapHDId(pCore, i, &portId, &deviceId) )
		{
			pPort = &pCore->Ports[MapPortEntry(pCore,portId)];
			pDevice = &pCore->Devices[deviceId];
			Core_GetHDConfiguration( pCore, pPort, pDevice, pHD );
		} 
		else
			pHD->HDID = 0xFF;
		pHD++;
	}
}
#endif	/* #ifndef BIOS_NOT_SUPPORT */
/*
 * Internal Functions
 */
MV_BOOLEAN
Core_MapHDId(
	IN PCore_Driver_Extension pCore,
	IN MV_U16 HDId,
	OUT MV_PU8 portId,
	OUT MV_PU8 deviceId
	)
{
	if ( deviceId ) *deviceId = MapDeviceId(pCore,HDId);
	if ( portId ) *portId = MapPortId(pCore,HDId);

	if ( ((portId)&&(*portId>=MAX_PORT_ID))
		|| ((deviceId)&&(*deviceId>=MAX_DEVICE_ID))
		)
		return MV_FALSE;
	else
		return MV_TRUE;
}

MV_VOID
Core_GetHDInformation(
	PCore_Driver_Extension pCore,
	IN PDomain_Device pDevice,
    OUT PHD_Info pHD 
	)
{
	MV_U8 i;
	MV_U8 count;

	pHD->Link.Self.DevID = pDevice->Id ;	
	if ( !(pDevice->Status&DEVICE_STATUS_FUNCTIONAL) )
	{
		pHD->Link.Self.DevType = DEVICE_TYPE_NONE;
		return;
	}

	// TBD: check if device type is correct; if not, generate sense
	pHD->Link.Self.DevType = DEVICE_TYPE_HD;
	pHD->Link.Self.PhyID[0] = 0;
	pHD->Link.Self.PhyCnt = 1;

	if( pDevice->pExpander != NULL )
	{
		pHD->Link.Parent.DevID = pDevice->pExpander->ExpId;
		pHD->Link.Parent.DevType = DEVICE_TYPE_EXPANDER;
		pHD->Link.Parent.PhyID[0] = pDevice->Phy_Id;
		pHD->Link.Parent.PhyCnt = 1;
		MV_CopyMemory( pHD->Link.Parent.SAS_Address, &pDevice->pExpander->SASAddr.value, 8 );
		MV_CopyMemory( pHD->Link.Self.SAS_Address, &pDevice->SASAddr.value, 8 );
	}
	else if( pDevice->pPort != NULL )
	{
		if( pDevice->pPort->Setting & PORT_SETTING_PM_FUNCTIONAL )
		{
			pHD->Link.Parent.DevID = pDevice->pPort->Id;	/* PM ID */
			pHD->Link.Parent.DevType = DEVICE_TYPE_PM;
			pHD->Link.Parent.PhyID[0] = pDevice->PM_Number;
			pHD->Link.Parent.PhyCnt = 1;
		}
		else
		{
			pHD->Link.Parent.DevID = 0;						/* Utility expect the HBA ID. */
			pHD->Link.Parent.DevType = DEVICE_TYPE_PORT;

			count = 0;
			for( i=0; i<pCore->Phy_Num; i++ )
			{
				if( pDevice->pPort->MemberPhyMap & MV_BIT(i) ) 
				{
					if ( (count==0) && IS_SSP(pDevice) )
					{
						MV_CopyMemory( pHD->Link.Parent.SAS_Address, &pCore->Phy[i].DevSASAddr, 8 );
						MV_CopyMemory( pHD->Link.Self.SAS_Address, &pCore->Phy[i].AttDevSASAddr, 8 );
					}
					MV_DASSERT( count<MAX_WIDEPORT_PHYS );
					pHD->Link.Parent.PhyID[count++] = i;	/* Not pDevice->pPort->Id */
				}
			}
			MV_DASSERT( count>0 );
			pHD->Link.Parent.PhyCnt = count;
		}
	}

	pHD->Status = 0;
	if( IS_STP_OR_SATA(pDevice) )
	{
		pHD->HDType = HD_TYPE_SATA;
		if ( IS_ATAPI(pDevice) )
			pHD->HDType |= HD_TYPE_ATAPI;
	}
	else
	{
		pHD->HDType = HD_TYPE_SAS;
		/* Only change for SAS TAPE case right now. */
		if ( IS_TAPE(pDevice) ) {
			pHD->HDType |= HD_TYPE_TAPE;
		}
	}
	
	mv_swap_bytes(pHD->Link.Parent.SAS_Address, 8);
	mv_swap_bytes(pHD->Link.Self.SAS_Address, 8);

	pHD->PIOMode = pDevice->PIO_Mode;
	pHD->MDMAMode = pDevice->MDMA_Mode;
	pHD->UDMAMode = pDevice->UDMA_Mode;
	pHD->CurrentPIOMode = pDevice->Current_PIO;
	pHD->CurrentMDMAMode = pDevice->Current_MDMA;
	pHD->CurrentUDMAMode = pDevice->Current_UDMA;

	pHD->FeatureSupport = 0;
	if ( pDevice->Capacity & DEVICE_CAPACITY_NCQ_SUPPORTED )
		pHD->FeatureSupport |= HD_FEATURE_NCQ;		
	if ( pDevice->Capacity & DEVICE_CAPACITY_WRITECACHE_SUPPORTED )
		pHD->FeatureSupport |= HD_FEATURE_WRITE_CACHE;		
	if ( pDevice->Capacity & DEVICE_CAPACITY_48BIT_SUPPORTED )
		pHD->FeatureSupport |= HD_FEATURE_48BITS;		
	if ( pDevice->Capacity & DEVICE_CAPACITY_SMART_SUPPORTED )
		pHD->FeatureSupport |= HD_FEATURE_SMART;	

	if ( pDevice->Capacity & DEVICE_CAPACITY_RATE_1_5G )
		pHD->FeatureSupport |= HD_FEATURE_1_5G;
	if ( pDevice->Capacity & DEVICE_CAPACITY_RATE_3G )
		pHD->FeatureSupport |= HD_FEATURE_3G;

	MV_CopyMemory(pHD->Model, pDevice->Model_Number, 40);
#ifndef BIOS_NOT_SUPPORT
	MV_CopyMemory(pHD->SerialNo, pDevice->Serial_Number, 20);
	MV_CopyMemory(pHD->FWVersion, pDevice->Firmware_Revision, 8);
#endif

	if( pHD->HDType == HD_TYPE_SATA )
		MV_CopyMemory( pHD->WWN, &pDevice->WWN.parts.low, 4 );
	else if( pHD->HDType == HD_TYPE_SAS )
		MV_CopyMemory( pHD->WWN, &pDevice->WWN, 8 );

//	pHD->Size = pDevice->Max_LBA;
	pHD->Size = U64_ADD_U32(pDevice->Max_LBA, 1);
}

MV_VOID
Core_GetHDInformation_Ext(
	PCore_Driver_Extension pCore,
	IN PDomain_Device pDevice,
	OUT PHD_Info pHD 
	)
{
	MV_U8 i;
	MV_U8 count;

	pHD->Link.Self.DevID = pDevice->Id ;	
	if ( !(pDevice->Status&DEVICE_STATUS_FUNCTIONAL) )
	{
		pHD->Link.Self.DevType = DEVICE_TYPE_NONE;
		return;
	}

	// TBD: check if device type is correct; if not, generate sense
	pHD->Link.Self.DevType = DEVICE_TYPE_HD;
	pHD->Link.Self.PhyID[0] = 0;
	pHD->Link.Self.PhyCnt = 1;

	if( pDevice->pExpander != NULL )
	{
		pHD->Link.Parent.DevID = pDevice->pExpander->ExpId;
		pHD->Link.Parent.DevType = DEVICE_TYPE_EXPANDER;
		pHD->Link.Parent.PhyID[0] = pDevice->Phy_Id;
		pHD->Link.Parent.PhyCnt = 1;
		MV_CopyMemory( pHD->Link.Parent.SAS_Address, &pDevice->pExpander->SASAddr.value, 8 );
		MV_CopyMemory( pHD->Link.Self.SAS_Address, &pDevice->SASAddr.value, 8 );
	}
	else if( pDevice->pPort != NULL )
	{
		if( pDevice->pPort->Setting & PORT_SETTING_PM_FUNCTIONAL )
		{
			pHD->Link.Parent.DevID = pDevice->pPort->Id;	/* PM ID */
			pHD->Link.Parent.DevType = DEVICE_TYPE_PM;
			pHD->Link.Parent.PhyID[0] = pDevice->PM_Number;
			pHD->Link.Parent.PhyCnt = 1;
		}
		else
		{
			pHD->Link.Parent.DevID = 0;						/* Utility expect the HBA ID. */
			pHD->Link.Parent.DevType = DEVICE_TYPE_PORT;

			count = 0;
			for( i=0; i<pCore->Phy_Num; i++ )
			{
				if( pDevice->pPort->MemberPhyMap & MV_BIT(i) ) 
				{
					if ( (count==0) && IS_SSP(pDevice) )
					{
						MV_CopyMemory( pHD->Link.Parent.SAS_Address, &pCore->Phy[i].DevSASAddr, 8 );
						MV_CopyMemory( pHD->Link.Self.SAS_Address, &pCore->Phy[i].AttDevSASAddr, 8 );
					}
					MV_DASSERT( count<MAX_WIDEPORT_PHYS );
					pHD->Link.Parent.PhyID[count++] = i;	/* Not pDevice->pPort->Id */
				}
			}
			MV_DASSERT( count>0 );
			pHD->Link.Parent.PhyCnt = count;
		}
	}

	pHD->Status = 0;
	pHD->ConnectionType = pDevice->Connection;
	pHD->DeviceType = pDevice->Dev_Type;
	if (pDevice->Dev_Type == DT_SES_DEVICE)
		pHD->DeviceType = DT_DIRECT_ACCESS_BLOCK;
	
	mv_swap_bytes(pHD->Link.Parent.SAS_Address, 8);
	mv_swap_bytes(pHD->Link.Self.SAS_Address, 8);

	pHD->PIOMode = pDevice->PIO_Mode;
	pHD->MDMAMode = pDevice->MDMA_Mode;
	pHD->UDMAMode = pDevice->UDMA_Mode;
	pHD->CurrentPIOMode = pDevice->Current_PIO;
	pHD->CurrentMDMAMode = pDevice->Current_MDMA;
	pHD->CurrentUDMAMode = pDevice->Current_UDMA;

	pHD->FeatureSupport = 0;
	if ( pDevice->Capacity & DEVICE_CAPACITY_NCQ_SUPPORTED )
		pHD->FeatureSupport |= HD_FEATURE_NCQ;		
	if ( pDevice->Capacity & DEVICE_CAPACITY_WRITECACHE_SUPPORTED )
		pHD->FeatureSupport |= HD_FEATURE_WRITE_CACHE;		
	if ( pDevice->Capacity & DEVICE_CAPACITY_48BIT_SUPPORTED )
		pHD->FeatureSupport |= HD_FEATURE_48BITS;		
	if ( pDevice->Capacity & DEVICE_CAPACITY_SMART_SUPPORTED )
		pHD->FeatureSupport |= HD_FEATURE_SMART;	

	if ( pDevice->Capacity & DEVICE_CAPACITY_RATE_1_5G )
		pHD->FeatureSupport |= HD_FEATURE_1_5G;
	if ( pDevice->Capacity & DEVICE_CAPACITY_RATE_3G )
		pHD->FeatureSupport |= HD_FEATURE_3G;

	MV_CopyMemory(pHD->Model, pDevice->Model_Number, 40);
#ifndef BIOS_NOT_SUPPORT
	MV_CopyMemory(pHD->SerialNo, pDevice->Serial_Number, 20);
	MV_CopyMemory(pHD->FWVersion, pDevice->Firmware_Revision, 8);
#endif

	if( IS_STP_OR_SATA(pDevice) )
		MV_CopyMemory( pHD->WWN, &pDevice->WWN.parts.low, 4 );
	else if( IS_SSP(pDevice) )
		MV_CopyMemory( pHD->WWN, &pDevice->WWN, 8 );

//	pHD->Size = pDevice->Max_LBA;
	pHD->Size = U64_ADD_U32(pDevice->Max_LBA, 1);
}

void Core_GetExpInformationHardware(PCore_Driver_Extension pCore, PDomain_Expander pExp,PExp_Info pExpInfo, PMV_Request pReq, MV_U8 requestType, MV_U8 phyIndex);
void Core_GetExpInformationCallback(PCore_Driver_Extension pCore, PMV_Request pReq);

void Core_GetExpInformationCallback(
	PCore_Driver_Extension pCore,
	PMV_Request pReq
	)
{
#ifndef CORE_SAS_SUPPORT_ATA_COMMAND
	PExp_Info pExpInfo = (PExp_Info)pReq->Context[MODULE_CORE];
#else
	PExp_Info pExpInfo = (PExp_Info)(((PCORE_CONTEXT)pReq->Context[MODULE_CORE])->u.cdb.Data_Buffer);
#endif /* CORE_SAS_SUPPORT_ATA_COMMAND */