drivers/scsi/thor/core/thor/core_api.c - kernel/prism - Git at Google

 #include "mv_include.h"

 #ifdef CORE_SUPPORT_API

 #include "core_api.h"
 #include "core_exp.h"
 #include "core_inter.h"
 #include "core_init.h"
 #include "com_error.h"

 typedef MV_BOOLEAN (*CORE_Management_Command_Handler)(PCore_Driver_Extension, PMV_Request);
 CORE_Management_Command_Handler core_pd_cmd_handler[];

 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_Port pPort,
 	IN PDomain_Device pDevice,
 	OUT PHD_Info pHD
 	);

 MV_VOID
 Core_GetExpInformation(
 	PCore_Driver_Extension pCore,
 	IN PDomain_Port pPort,
 	IN PDomain_Device pDevice,
 	OUT PExp_Info pExp
 	);

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

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

 /*
  * 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 portId, deviceId;
 	PDomain_Port pPort = NULL;
 	PDomain_Device pDevice = NULL;
 	MV_U16 i;

 	if ( HDId==0xFF )	/* Get all the HD information */
 	{
 		/* First set invalid flag in buffer */
 		for (i=0; i<MAX_DEVICE_SUPPORTED; i++) {
 			pHD[i].Link.Self.DevID = i;
 			pHD[i].Link.Self.DevType = DEVICE_TYPE_NONE;
 		}
 		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[portId];
 			pDevice = &pPort->Device[deviceId];
 			Core_GetHDInformation( pCore, pPort, pDevice, pHD );
 		}
 /*
 		else
 		{
 			pHD->ID = i;
 			pHD->Type = DEVICE_TYPE_NONE;
 		}
 */
 		//MV_DASSERT( pHD->Id==i );
 		pHD++;
 	}
 }

 #ifdef SUPPORT_PM
 MV_VOID
 Core_GetExpInfo(
 	IN MV_PVOID extension,
 	IN MV_U16 ExpId,
 	OUT PExp_Info pExp
 	)
 {
 	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 ( ExpId==0xFF )
 	{
 		/* Get all the HD information */
 		startId = 0;
 		if (MAX_EXPANDER_SUPPORTED > 0)
 			endId = MAX_EXPANDER_SUPPORTED-1;
 		else
 			endId = 0;
 	}
 	else
 	{
 		startId = ExpId;
 		endId = ExpId;
 	}

 	for ( i=startId; i<=endId; i++ )
 	{
 		if ( Core_MapHDId(pCore, i, &portId, &deviceId) )
 		{
 			pPort = &pCore->Ports[portId];
 			pDevice = &pPort->Device[deviceId];
 			Core_GetExpInformation( pCore, pPort, pDevice, pExp );
 		}
 		else
 		{
 			pExp->Link.Self.DevID = i;
 			pExp->Link.Self.DevType = DEVICE_TYPE_NONE;
 		}
 		pExp++;
 	}
 }

 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 PM information */
 		startId = 0;
 		endId = pCore->Port_Num - 1;
 	}
 	else
 	{
 		startId = PMId;
 		endId = PMId;
 	}

 	for ( i=startId; i<=endId; i++ )
 	{
 		pPort = &pCore->Ports[i];
 		if ( pPort->Type != PORT_TYPE_PM )
 		{
 			if ( PMId != 0xFF )
 			{
 				// not a PM, return error
 			}
 		}
 		else
 		{
 			Core_GetPMInformation( pCore, pPort, pPM );
 			pPM++;
 		}
 	}
 }
 #endif	/* #ifdef SUPPORT_PM */

 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;

 	/* Get all the HD configuration */
 	if ( HDId==0xFF )
 	{
 		/* First set invalid flag in buffer */
 		for (i=0; i<MAX_DEVICE_SUPPORTED; i++)
 			pHD[i].HDID = 0xFF;
 		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[portId];
 			pDevice = &pPort->Device[deviceId];
 			Core_GetHDConfiguration( pCore, pPort, pDevice, pHD );
 		}
 		pHD++;
 	}
 }
 /*
  * Internal Functions
  */
 MV_BOOLEAN
 Core_MapHDId(
 	IN PCore_Driver_Extension pCore,
 	IN MV_U16 HDId,
 	OUT MV_PU8 portId,
 	OUT MV_PU8 deviceId
 	)
 {
 	if ( portId ) *portId = PATA_MapPortId(HDId);
 	if ( deviceId ) *deviceId = PATA_MapDeviceId(HDId);

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

 MV_VOID
 Core_GetHDInformation(
 	PCore_Driver_Extension pCore,
 	IN PDomain_Port pPort,
 	IN PDomain_Device pDevice,
 	OUT PHD_Info pHD
 	)
 {
 	pHD->Link.Self.DevID = pDevice->Id ;
 	if ( !(pDevice->Status&DEVICE_STATUS_FUNCTIONAL) )
 	{
 		pHD->Link.Self.DevType = DEVICE_TYPE_NONE;
 		return;
 	}

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

 	pHD->Link.Parent.DevID = pPort->Id;
 	pHD->Link.Parent.PhyCnt = 1;
 	if ( pPort->Type==PORT_TYPE_PM )
 	{
 		pHD->Link.Parent.DevType = DEVICE_TYPE_PM;
 		pHD->Link.Parent.PhyID[0] = pDevice->PM_Number;
 	}
 	else
 	{
 		pHD->Link.Parent.DevType = DEVICE_TYPE_PORT;
 		pHD->Link.Parent.PhyID[0] = pPort->Id;
 	}

 	pHD->Status = 0;
 	if ( pPort->Type==PORT_TYPE_PATA )
 		pHD->HDType = HD_TYPE_PATA;
 	else
 		pHD->HDType = HD_TYPE_SATA;
 	if ( pDevice->Device_Type&DEVICE_TYPE_ATAPI )
 		pHD->HDType |= HD_TYPE_ATAPI;

 	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;

 	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;
 	else if ( pDevice->Capacity & DEVICE_CAPACITY_RATE_3G )
 		pHD->FeatureSupport |= HD_FEATURE_3G;

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

 	*(MV_PU32)pHD->WWN = pDevice->WWN;
 	pHD->Size = U64_ADD_U32(pDevice->Max_LBA, 1);
 }

 #ifdef SUPPORT_PM
 MV_VOID
 Core_GetExpInformation(
 	PCore_Driver_Extension pCore,
 	IN PDomain_Port pPort,
 	IN PDomain_Device pDevice,
 	OUT PExp_Info pExp
 	)
 {
 }

 MV_VOID
 Core_GetPMInformation(
 	PCore_Driver_Extension pCore,
 	IN PDomain_Port pPort,
 	OUT PPM_Info pPM
 	)
 {
 #ifndef RAID_SIMULATE_CONFIGURATION
 	pPM->Link.Self.DevType = DEVICE_TYPE_PM;
 	pPM->Link.Self.DevID = pPort->Id;
 	pPM->Link.Self.PhyCnt = 1;
 	pPM->Link.Self.PhyID[0] = 0;

 	pPM->Link.Parent.DevType = DEVICE_TYPE_PORT;
 	pPM->Link.Parent.DevID = 0;
 	pPM->Link.Parent.PhyCnt = 1;
 	pPM->Link.Parent.PhyID[0] = pPort->Id;

 	pPM->VendorId = pPort->PM_Vendor_Id;
 	pPM->DeviceId = pPort->PM_Device_Id;
 	pPM->ProductRevision = pPort->PM_Product_Revision;
 	pPM->PMSpecRevision = pPort->PM_Spec_Revision;
 	pPM->NumberOfPorts = pPort->PM_Num_Ports;
 #endif
 }
 #endif	/* #ifdef SUPPORT_PM */

 MV_VOID
 Core_GetHDConfiguration(
 	PCore_Driver_Extension pCore,
 	IN PDomain_Port pPort,
 	IN PDomain_Device pDevice,
 	OUT PHD_Config pHD
 	)
 {
 	if ( !(pDevice->Status & DEVICE_STATUS_FUNCTIONAL) )
 	{
 		pHD->HDID = 0xFF;
 		return;
 	}

 	pHD->HDID = pDevice->Id ;

 	if (pDevice->Setting & DEVICE_SETTING_WRITECACHE_ENABLED)
 		pHD->WriteCacheOn = MV_TRUE;
 	else
 		pHD->WriteCacheOn = MV_FALSE;

 	if ( pDevice->Setting & DEVICE_SETTING_SMART_ENABLED )
 		pHD->SMARTOn = MV_TRUE;
 	else
 		pHD->SMARTOn = MV_FALSE;

 	if (pDevice->Capacity & DEVICE_CAPACITY_RATE_3G)
 		pHD->DriveSpeed = HD_SPEED_3G;
 	else
 		pHD->DriveSpeed = HD_SPEED_1_5G;

 }

 MV_BOOLEAN core_pd_request_get_HD_info(PCore_Driver_Extension pCore, PMV_Request pMvReq)
 {
 	PHD_Info pHDInfo = (PHD_Info)pMvReq->Data_Buffer;
 	MV_U16 HDID;

 	MV_CopyMemory(&HDID, &pMvReq->Cdb[2], 2);
 	Core_GetHDInfo( pCore, HDID, pHDInfo );
 	if (HDID != 0xFF && pHDInfo->Link.Self.DevType == DEVICE_TYPE_NONE)
 	{
 		if (pMvReq->Sense_Info_Buffer != NULL)
 			((MV_PU8)pMvReq->Sense_Info_Buffer)[0] = ERR_INVALID_HD_ID;
 		pMvReq->Scsi_Status = REQ_STATUS_ERROR_WITH_SENSE;
 	}
 	else
 		pMvReq->Scsi_Status = REQ_STATUS_SUCCESS;
 	return MV_TRUE;
 }

 #ifdef SUPPORT_PM
 MV_BOOLEAN core_pd_request_get_expander_info( PCore_Driver_Extension pCore, PMV_Request pMvReq )
 {
 	PExp_Info pExpInfo = (PExp_Info)pMvReq->Data_Buffer;
 	MV_U16 ExpID;
 	MV_U8	status = REQ_STATUS_SUCCESS;

 	MV_CopyMemory(&ExpID, &pMvReq->Cdb[2], 2);
 	if (ExpID != 0xFF && ExpID > MAX_EXPANDER_SUPPORTED)
 	{
 		status = ERR_INVALID_EXP_ID;
 	}
 	else
 	{
 		Core_GetExpInfo( pCore, ExpID, pExpInfo );

 		if (ExpID != 0xFF && pExpInfo->Link.Self.DevType == DEVICE_TYPE_NONE)
 		{
 			status = ERR_INVALID_EXP_ID;
 		}
 	}

 	if (status != REQ_STATUS_SUCCESS)
 	{
 		if (pMvReq->Sense_Info_Buffer != NULL)
 			((MV_PU8)pMvReq->Sense_Info_Buffer)[0] = status;
 		pMvReq->Scsi_Status = REQ_STATUS_ERROR_WITH_SENSE;
 	}
 	else
 		pMvReq->Scsi_Status = REQ_STATUS_SUCCESS;

 	return MV_TRUE;
 }

 MV_BOOLEAN core_pd_request_get_PM_info( PCore_Driver_Extension pCore, PMV_Request pMvReq )
 {
 	PPM_Info pPMInfo = (PPM_Info)pMvReq->Data_Buffer;
 	MV_U16 PMID;

 	MV_CopyMemory(&PMID, &pMvReq->Cdb[2], 2);
 	if (PMID != 0xFF && PMID > MAX_PM_SUPPORTED)
 	{
 		if (pMvReq->Sense_Info_Buffer != NULL)
 			((MV_PU8)pMvReq->Sense_Info_Buffer)[0] = ERR_INVALID_PM_ID;
 		pMvReq->Scsi_Status = REQ_STATUS_ERROR_WITH_SENSE;
 		return MV_TRUE;
 	}

 	Core_GetPMInfo( pCore, PMID, pPMInfo );

 	pMvReq->Scsi_Status = REQ_STATUS_SUCCESS;
 	return MV_TRUE;
 }
 #endif	/*#ifdef SUPPORT_PM */

 MV_BOOLEAN core_pd_request_get_HD_config( PCore_Driver_Extension pCore, PMV_Request pMvReq )
 {
 	PHD_Config pHDConfig = (PHD_Config)pMvReq->Data_Buffer;
 	MV_U16 ConfigID;

 	MV_CopyMemory(&ConfigID, &pMvReq->Cdb[2], 2);
 	Core_GetHDConfig( pCore, ConfigID, pHDConfig );

 	if (ConfigID != 0xFF && pHDConfig->HDID == 0xFF)
 	{
 		if (pMvReq->Sense_Info_Buffer != NULL)
 			((MV_PU8)pMvReq->Sense_Info_Buffer)[0] = ERR_INVALID_HD_ID;
 		pMvReq->Scsi_Status = REQ_STATUS_ERROR_WITH_SENSE;
 	}
 	else
 		pMvReq->Scsi_Status = REQ_STATUS_SUCCESS;

 	return MV_TRUE;
 }

 MV_BOOLEAN core_pd_request_get_HD_status( PCore_Driver_Extension pCore, PMV_Request pMvReq )
 {
 	PHD_Status pHDStatus = (PHD_Status)pMvReq->Data_Buffer;
 	PDomain_Port pPort = NULL;
 	PDomain_Device pDevice = NULL;
 	MV_U8 portId, deviceId;
 	MV_U16 HDId;
 	MV_U8	cacheMode = 0;
 	MV_U8 status = REQ_STATUS_SUCCESS;

 	MV_CopyMemory(&HDId, &pMvReq->Cdb[2], 2);

 	if ( Core_MapHDId(pCore, HDId, &portId, &deviceId) )
 	{
 		pPort = &pCore->Ports[portId];
 		pDevice = &pPort->Device[deviceId];

 		if (pDevice->Setting & DEVICE_SETTING_SMART_ENABLED)
 		{
 			if ( !(pDevice->Status & DEVICE_STATUS_FUNCTIONAL) )
 			{
 				status = ERR_INVALID_HD_ID;
 			}
 			else
 			{
 				if (pMvReq->Cdb[4] == APICDB4_PD_SMART_RETURN_STATUS)
 				{
 					cacheMode = CDB_CORE_SMART_RETURN_STATUS;
 				}
 				else
 					status = ERR_INVALID_REQUEST;
 			}

 			if (status == REQ_STATUS_SUCCESS)
 			{
 				// Convert it into SCSI_CMD_MARVELL_SPECIFIC request.
 				pMvReq->Cdb[0] = SCSI_CMD_MARVELL_SPECIFIC;
 				pMvReq->Cdb[1] = CDB_CORE_MODULE;
 				pMvReq->Cdb[2] = cacheMode;
 				pMvReq->Device_Id = pDevice->Id;
 				if (pHDStatus)
 					pHDStatus->HDID = pDevice->Id;
 			}
 		}
 		else
 			status = ERR_INVALID_REQUEST;
 	}
 	else
 	{
 		status = ERR_INVALID_HD_ID;
 	}

 	if (status != REQ_STATUS_SUCCESS)
 	{
 		if (pMvReq->Sense_Info_Buffer != NULL)
 			((MV_PU8)pMvReq->Sense_Info_Buffer)[0] = status;
 		pMvReq->Scsi_Status = REQ_STATUS_ERROR_WITH_SENSE;
 		return MV_TRUE;
 	}
 	else
 	{
 		pMvReq->Scsi_Status = REQ_STATUS_SUCCESS;
 		return MV_FALSE;	// Need to access hardware.
 	}
 }

 MV_BOOLEAN core_pd_request_set_HD_config( PCore_Driver_Extension pCore, PMV_Request pMvReq )
 {
 	//PHD_Config pHDConfig = (PHD_Config)pMvReq->Data_Buffer;
 	PDomain_Port pPort = NULL;
 	PDomain_Device pDevice = NULL;
 	MV_U8 portId, deviceId;
 	MV_U16 HDId;
 	MV_U8	cacheMode = 0;
 	MV_U8 status = REQ_STATUS_PENDING;

 	MV_CopyMemory(&HDId, &pMvReq->Cdb[2], 2);

 	if ( Core_MapHDId(pCore, HDId, &portId, &deviceId) )
 	{
 		pPort = &pCore->Ports[portId];
 		pDevice = &pPort->Device[deviceId];

 		if ( !(pDevice->Status & DEVICE_STATUS_FUNCTIONAL) )
 		{
 			status = ERR_INVALID_HD_ID;
 		}
 		else if ( pDevice->Device_Type & DEVICE_TYPE_ATAPI )
 		{
 			status = ERR_INVALID_REQUEST;
 		}
 		else
 		{
 			if (pMvReq->Cdb[4] == APICDB4_PD_SET_WRITE_CACHE_OFF)
 			{
 				cacheMode = CDB_CORE_DISABLE_WRITE_CACHE;
 			}
 			else if (pMvReq->Cdb[4] == APICDB4_PD_SET_WRITE_CACHE_ON)
 			{
 				cacheMode = CDB_CORE_ENABLE_WRITE_CACHE;
 			}
 			else if (pMvReq->Cdb[4] == APICDB4_PD_SET_SMART_OFF)
 			{
 				if ( !(pDevice->Setting&DEVICE_SETTING_SMART_ENABLED) )
 					status = REQ_STATUS_SUCCESS;
 				cacheMode = CDB_CORE_DISABLE_SMART;
 			}
 			else if (pMvReq->Cdb[4] == APICDB4_PD_SET_SMART_ON)
 			{
 				if ( pDevice->Setting&DEVICE_SETTING_SMART_ENABLED )
 					status = REQ_STATUS_SUCCESS;
 				cacheMode = CDB_CORE_ENABLE_SMART;
 			}
 			else
 			{
 				status = ERR_INVALID_REQUEST;
 			}
 		}

 		if (status == REQ_STATUS_PENDING)
 		{
 			// Convert it into SCSI_CMD_MARVELL_SPECIFIC request.
 			pMvReq->Cdb[0] = SCSI_CMD_MARVELL_SPECIFIC;
 			pMvReq->Cdb[1] = CDB_CORE_MODULE;
 			pMvReq->Cdb[2] = cacheMode;
 			pMvReq->Device_Id = pDevice->Id;
 		}
 	}
 	else
 	{
 		status = ERR_INVALID_HD_ID;
 	}

 	if (status == REQ_STATUS_SUCCESS)
 	{
 		pMvReq->Scsi_Status = status;
 		return MV_TRUE;
 	}
 	else if (status == REQ_STATUS_PENDING)
 	{
 		//pMvReq->Scsi_Status = REQ_STATUS_SUCCESS;
 		return MV_FALSE;	// Need to access hardware.
 	}
 	else
 	{
 		if (pMvReq->Sense_Info_Buffer != NULL)
 			((MV_PU8)pMvReq->Sense_Info_Buffer)[0] = status;
 		pMvReq->Scsi_Status = REQ_STATUS_ERROR_WITH_SENSE;
 		return MV_TRUE;
 	}
 }

 MV_BOOLEAN core_pd_request_BSL_dump( PCore_Driver_Extension pCore, PMV_Request pMvReq )
 {
 	pMvReq->Scsi_Status = REQ_STATUS_ERROR;
 	return MV_TRUE;
 }

 MV_BOOLEAN core_pd_request_HD_MP_check( PCore_Driver_Extension pCore, PMV_Request pMvReq )
 {
 	pMvReq->Scsi_Status = REQ_STATUS_ERROR;
 	return MV_TRUE;
 }

 MV_BOOLEAN core_pd_request_HD_get_MP_status( PCore_Driver_Extension pCore, PMV_Request pMvReq )
 {
 	pMvReq->Scsi_Status = REQ_STATUS_ERROR;
 	return MV_TRUE;
 }

 CORE_Management_Command_Handler BASEATTR core_pd_cmd_handler[APICDB1_PD_MAX] =
 {
 	core_pd_request_get_HD_info,
 #ifdef SUPPORT_PM
 	core_pd_request_get_expander_info,
 	core_pd_request_get_PM_info,
 #else
 	NULL,
 	NULL,
 #endif
 	core_pd_request_get_HD_config,
 	core_pd_request_set_HD_config,
 	core_pd_request_BSL_dump,
 	core_pd_request_HD_MP_check,
 	core_pd_request_HD_get_MP_status,
 	core_pd_request_get_HD_status,
 	NULL
 };

 MV_BOOLEAN
 Core_pd_command(
 	IN MV_PVOID extension,
 	IN PMV_Request pReq
 	)
 {
 	PCore_Driver_Extension pCore = (PCore_Driver_Extension)extension;

 	if ( pReq->Cdb[1] >= APICDB1_PD_MAX )
 	{
 		pReq->Scsi_Status = REQ_STATUS_INVALID_PARAMETER;
 		return MV_TRUE;
 	}
 	if (core_pd_cmd_handler[pReq->Cdb[1]] == NULL)
 	{
 		pReq->Scsi_Status = REQ_STATUS_INVALID_PARAMETER;
 		return MV_TRUE;
 	}
 	return core_pd_cmd_handler[pReq->Cdb[1]](pCore, pReq);
 }
 #endif
	#include "mv_include.h"

	#ifdef CORE_SUPPORT_API

	#include "core_api.h"
	#include "core_exp.h"
	#include "core_inter.h"
	#include "core_init.h"
	#include "com_error.h"

	typedef MV_BOOLEAN (*CORE_Management_Command_Handler)(PCore_Driver_Extension, PMV_Request);
	CORE_Management_Command_Handler core_pd_cmd_handler[];

	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_Port pPort,
	IN PDomain_Device pDevice,
	OUT PHD_Info pHD
	);

	MV_VOID
	Core_GetExpInformation(
	PCore_Driver_Extension pCore,
	IN PDomain_Port pPort,
	IN PDomain_Device pDevice,
	OUT PExp_Info pExp
	);

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

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

	/*
	* 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 portId, deviceId;
	PDomain_Port pPort = NULL;
	PDomain_Device pDevice = NULL;
	MV_U16 i;

	if ( HDId==0xFF ) /* Get all the HD information */
	{
	/* First set invalid flag in buffer */
	for (i=0; i<MAX_DEVICE_SUPPORTED; i++) {
	pHD[i].Link.Self.DevID = i;
	pHD[i].Link.Self.DevType = DEVICE_TYPE_NONE;
	}
	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[portId];
	pDevice = &pPort->Device[deviceId];
	Core_GetHDInformation( pCore, pPort, pDevice, pHD );
	}
	/*
	else
	{
	pHD->ID = i;
	pHD->Type = DEVICE_TYPE_NONE;
	}
	*/
	//MV_DASSERT( pHD->Id==i );
	pHD++;
	}
	}

	#ifdef SUPPORT_PM
	MV_VOID
	Core_GetExpInfo(
	IN MV_PVOID extension,
	IN MV_U16 ExpId,
	OUT PExp_Info pExp
	)
	{
	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 ( ExpId==0xFF )
	{
	/* Get all the HD information */
	startId = 0;
	if (MAX_EXPANDER_SUPPORTED > 0)
	endId = MAX_EXPANDER_SUPPORTED-1;
	else
	endId = 0;
	}
	else
	{
	startId = ExpId;
	endId = ExpId;
	}

	for ( i=startId; i<=endId; i++ )
	{
	if ( Core_MapHDId(pCore, i, &portId, &deviceId) )
	{
	pPort = &pCore->Ports[portId];
	pDevice = &pPort->Device[deviceId];
	Core_GetExpInformation( pCore, pPort, pDevice, pExp );
	}
	else
	{
	pExp->Link.Self.DevID = i;
	pExp->Link.Self.DevType = DEVICE_TYPE_NONE;
	}
	pExp++;
	}
	}

	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 PM information */
	startId = 0;
	endId = pCore->Port_Num - 1;
	}
	else
	{
	startId = PMId;
	endId = PMId;
	}

	for ( i=startId; i<=endId; i++ )
	{
	pPort = &pCore->Ports[i];
	if ( pPort->Type != PORT_TYPE_PM )
	{
	if ( PMId != 0xFF )
	{
	// not a PM, return error
	}
	}
	else
	{
	Core_GetPMInformation( pCore, pPort, pPM );
	pPM++;
	}
	}
	}
	#endif /* #ifdef SUPPORT_PM */

	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;

	/* Get all the HD configuration */
	if ( HDId==0xFF )
	{
	/* First set invalid flag in buffer */
	for (i=0; i<MAX_DEVICE_SUPPORTED; i++)
	pHD[i].HDID = 0xFF;
	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[portId];
	pDevice = &pPort->Device[deviceId];
	Core_GetHDConfiguration( pCore, pPort, pDevice, pHD );
	}
	pHD++;
	}
	}
	/*
	* Internal Functions
	*/
	MV_BOOLEAN
	Core_MapHDId(
	IN PCore_Driver_Extension pCore,
	IN MV_U16 HDId,
	OUT MV_PU8 portId,
	OUT MV_PU8 deviceId
	)
	{
	if ( portId ) *portId = PATA_MapPortId(HDId);
	if ( deviceId ) *deviceId = PATA_MapDeviceId(HDId);

	if ( ((portId)&&(*portId>=MAX_PORT_NUMBER))
	\|\| ((deviceId)&&(*deviceId>=MAX_DEVICE_PER_PORT))
	)
	return MV_FALSE;
	else
	return MV_TRUE;
	}

	MV_VOID
	Core_GetHDInformation(
	PCore_Driver_Extension pCore,
	IN PDomain_Port pPort,
	IN PDomain_Device pDevice,
	OUT PHD_Info pHD
	)
	{
	pHD->Link.Self.DevID = pDevice->Id ;
	if ( !(pDevice->Status&DEVICE_STATUS_FUNCTIONAL) )
	{
	pHD->Link.Self.DevType = DEVICE_TYPE_NONE;
	return;
	}

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

	pHD->Link.Parent.DevID = pPort->Id;
	pHD->Link.Parent.PhyCnt = 1;
	if ( pPort->Type==PORT_TYPE_PM )
	{
	pHD->Link.Parent.DevType = DEVICE_TYPE_PM;
	pHD->Link.Parent.PhyID[0] = pDevice->PM_Number;
	}
	else
	{
	pHD->Link.Parent.DevType = DEVICE_TYPE_PORT;
	pHD->Link.Parent.PhyID[0] = pPort->Id;
	}

	pHD->Status = 0;
	if ( pPort->Type==PORT_TYPE_PATA )
	pHD->HDType = HD_TYPE_PATA;
	else
	pHD->HDType = HD_TYPE_SATA;
	if ( pDevice->Device_Type&DEVICE_TYPE_ATAPI )
	pHD->HDType \|= HD_TYPE_ATAPI;

	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;

	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;
	else if ( pDevice->Capacity & DEVICE_CAPACITY_RATE_3G )
	pHD->FeatureSupport \|= HD_FEATURE_3G;

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

	*(MV_PU32)pHD->WWN = pDevice->WWN;
	pHD->Size = U64_ADD_U32(pDevice->Max_LBA, 1);
	}

	#ifdef SUPPORT_PM
	MV_VOID
	Core_GetExpInformation(
	PCore_Driver_Extension pCore,
	IN PDomain_Port pPort,
	IN PDomain_Device pDevice,
	OUT PExp_Info pExp
	)
	{
	}

	MV_VOID
	Core_GetPMInformation(
	PCore_Driver_Extension pCore,
	IN PDomain_Port pPort,
	OUT PPM_Info pPM
	)
	{
	#ifndef RAID_SIMULATE_CONFIGURATION
	pPM->Link.Self.DevType = DEVICE_TYPE_PM;
	pPM->Link.Self.DevID = pPort->Id;
	pPM->Link.Self.PhyCnt = 1;
	pPM->Link.Self.PhyID[0] = 0;

	pPM->Link.Parent.DevType = DEVICE_TYPE_PORT;
	pPM->Link.Parent.DevID = 0;
	pPM->Link.Parent.PhyCnt = 1;
	pPM->Link.Parent.PhyID[0] = pPort->Id;

	pPM->VendorId = pPort->PM_Vendor_Id;
	pPM->DeviceId = pPort->PM_Device_Id;
	pPM->ProductRevision = pPort->PM_Product_Revision;
	pPM->PMSpecRevision = pPort->PM_Spec_Revision;
	pPM->NumberOfPorts = pPort->PM_Num_Ports;
	#endif
	}
	#endif /* #ifdef SUPPORT_PM */

	MV_VOID
	Core_GetHDConfiguration(
	PCore_Driver_Extension pCore,
	IN PDomain_Port pPort,
	IN PDomain_Device pDevice,
	OUT PHD_Config pHD
	)
	{
	if ( !(pDevice->Status & DEVICE_STATUS_FUNCTIONAL) )
	{
	pHD->HDID = 0xFF;
	return;
	}

	pHD->HDID = pDevice->Id ;

	if (pDevice->Setting & DEVICE_SETTING_WRITECACHE_ENABLED)
	pHD->WriteCacheOn = MV_TRUE;
	else
	pHD->WriteCacheOn = MV_FALSE;

	if ( pDevice->Setting & DEVICE_SETTING_SMART_ENABLED )
	pHD->SMARTOn = MV_TRUE;
	else
	pHD->SMARTOn = MV_FALSE;

	if (pDevice->Capacity & DEVICE_CAPACITY_RATE_3G)
	pHD->DriveSpeed = HD_SPEED_3G;
	else
	pHD->DriveSpeed = HD_SPEED_1_5G;

	}

	MV_BOOLEAN core_pd_request_get_HD_info(PCore_Driver_Extension pCore, PMV_Request pMvReq)
	{
	PHD_Info pHDInfo = (PHD_Info)pMvReq->Data_Buffer;
	MV_U16 HDID;

	MV_CopyMemory(&HDID, &pMvReq->Cdb[2], 2);
	Core_GetHDInfo( pCore, HDID, pHDInfo );
	if (HDID != 0xFF && pHDInfo->Link.Self.DevType == DEVICE_TYPE_NONE)
	{
	if (pMvReq->Sense_Info_Buffer != NULL)
	((MV_PU8)pMvReq->Sense_Info_Buffer)[0] = ERR_INVALID_HD_ID;
	pMvReq->Scsi_Status = REQ_STATUS_ERROR_WITH_SENSE;
	}
	else
	pMvReq->Scsi_Status = REQ_STATUS_SUCCESS;
	return MV_TRUE;
	}

	#ifdef SUPPORT_PM
	MV_BOOLEAN core_pd_request_get_expander_info( PCore_Driver_Extension pCore, PMV_Request pMvReq )
	{
	PExp_Info pExpInfo = (PExp_Info)pMvReq->Data_Buffer;
	MV_U16 ExpID;
	MV_U8 status = REQ_STATUS_SUCCESS;

	MV_CopyMemory(&ExpID, &pMvReq->Cdb[2], 2);
	if (ExpID != 0xFF && ExpID > MAX_EXPANDER_SUPPORTED)
	{
	status = ERR_INVALID_EXP_ID;
	}
	else
	{
	Core_GetExpInfo( pCore, ExpID, pExpInfo );

	if (ExpID != 0xFF && pExpInfo->Link.Self.DevType == DEVICE_TYPE_NONE)
	{
	status = ERR_INVALID_EXP_ID;
	}
	}

	if (status != REQ_STATUS_SUCCESS)
	{
	if (pMvReq->Sense_Info_Buffer != NULL)
	((MV_PU8)pMvReq->Sense_Info_Buffer)[0] = status;
	pMvReq->Scsi_Status = REQ_STATUS_ERROR_WITH_SENSE;
	}
	else
	pMvReq->Scsi_Status = REQ_STATUS_SUCCESS;

	return MV_TRUE;
	}

	MV_BOOLEAN core_pd_request_get_PM_info( PCore_Driver_Extension pCore, PMV_Request pMvReq )
	{
	PPM_Info pPMInfo = (PPM_Info)pMvReq->Data_Buffer;
	MV_U16 PMID;

	MV_CopyMemory(&PMID, &pMvReq->Cdb[2], 2);
	if (PMID != 0xFF && PMID > MAX_PM_SUPPORTED)
	{
	if (pMvReq->Sense_Info_Buffer != NULL)
	((MV_PU8)pMvReq->Sense_Info_Buffer)[0] = ERR_INVALID_PM_ID;
	pMvReq->Scsi_Status = REQ_STATUS_ERROR_WITH_SENSE;
	return MV_TRUE;
	}

	Core_GetPMInfo( pCore, PMID, pPMInfo );

	pMvReq->Scsi_Status = REQ_STATUS_SUCCESS;
	return MV_TRUE;
	}
	#endif /#ifdef SUPPORT_PM /

	MV_BOOLEAN core_pd_request_get_HD_config( PCore_Driver_Extension pCore, PMV_Request pMvReq )
	{
	PHD_Config pHDConfig = (PHD_Config)pMvReq->Data_Buffer;
	MV_U16 ConfigID;

	MV_CopyMemory(&ConfigID, &pMvReq->Cdb[2], 2);
	Core_GetHDConfig( pCore, ConfigID, pHDConfig );

	if (ConfigID != 0xFF && pHDConfig->HDID == 0xFF)
	{
	if (pMvReq->Sense_Info_Buffer != NULL)
	((MV_PU8)pMvReq->Sense_Info_Buffer)[0] = ERR_INVALID_HD_ID;
	pMvReq->Scsi_Status = REQ_STATUS_ERROR_WITH_SENSE;
	}
	else
	pMvReq->Scsi_Status = REQ_STATUS_SUCCESS;

	return MV_TRUE;
	}

	MV_BOOLEAN core_pd_request_get_HD_status( PCore_Driver_Extension pCore, PMV_Request pMvReq )
	{
	PHD_Status pHDStatus = (PHD_Status)pMvReq->Data_Buffer;
	PDomain_Port pPort = NULL;
	PDomain_Device pDevice = NULL;
	MV_U8 portId, deviceId;
	MV_U16 HDId;
	MV_U8 cacheMode = 0;
	MV_U8 status = REQ_STATUS_SUCCESS;

	MV_CopyMemory(&HDId, &pMvReq->Cdb[2], 2);

	if ( Core_MapHDId(pCore, HDId, &portId, &deviceId) )
	{
	pPort = &pCore->Ports[portId];
	pDevice = &pPort->Device[deviceId];

	if (pDevice->Setting & DEVICE_SETTING_SMART_ENABLED)
	{
	if ( !(pDevice->Status & DEVICE_STATUS_FUNCTIONAL) )
	{
	status = ERR_INVALID_HD_ID;
	}
	else
	{
	if (pMvReq->Cdb[4] == APICDB4_PD_SMART_RETURN_STATUS)
	{
	cacheMode = CDB_CORE_SMART_RETURN_STATUS;
	}
	else
	status = ERR_INVALID_REQUEST;
	}

	if (status == REQ_STATUS_SUCCESS)
	{
	// Convert it into SCSI_CMD_MARVELL_SPECIFIC request.
	pMvReq->Cdb[0] = SCSI_CMD_MARVELL_SPECIFIC;
	pMvReq->Cdb[1] = CDB_CORE_MODULE;
	pMvReq->Cdb[2] = cacheMode;
	pMvReq->Device_Id = pDevice->Id;
	if (pHDStatus)
	pHDStatus->HDID = pDevice->Id;
	}
	}
	else
	status = ERR_INVALID_REQUEST;
	}
	else
	{
	status = ERR_INVALID_HD_ID;
	}

	if (status != REQ_STATUS_SUCCESS)
	{
	if (pMvReq->Sense_Info_Buffer != NULL)
	((MV_PU8)pMvReq->Sense_Info_Buffer)[0] = status;
	pMvReq->Scsi_Status = REQ_STATUS_ERROR_WITH_SENSE;
	return MV_TRUE;
	}
	else
	{
	pMvReq->Scsi_Status = REQ_STATUS_SUCCESS;
	return MV_FALSE; // Need to access hardware.
	}
	}

	MV_BOOLEAN core_pd_request_set_HD_config( PCore_Driver_Extension pCore, PMV_Request pMvReq )
	{
	//PHD_Config pHDConfig = (PHD_Config)pMvReq->Data_Buffer;
	PDomain_Port pPort = NULL;
	PDomain_Device pDevice = NULL;
	MV_U8 portId, deviceId;
	MV_U16 HDId;
	MV_U8 cacheMode = 0;
	MV_U8 status = REQ_STATUS_PENDING;

	MV_CopyMemory(&HDId, &pMvReq->Cdb[2], 2);

	if ( Core_MapHDId(pCore, HDId, &portId, &deviceId) )
	{
	pPort = &pCore->Ports[portId];
	pDevice = &pPort->Device[deviceId];

	if ( !(pDevice->Status & DEVICE_STATUS_FUNCTIONAL) )
	{
	status = ERR_INVALID_HD_ID;
	}
	else if ( pDevice->Device_Type & DEVICE_TYPE_ATAPI )
	{
	status = ERR_INVALID_REQUEST;
	}
	else
	{
	if (pMvReq->Cdb[4] == APICDB4_PD_SET_WRITE_CACHE_OFF)
	{
	cacheMode = CDB_CORE_DISABLE_WRITE_CACHE;
	}
	else if (pMvReq->Cdb[4] == APICDB4_PD_SET_WRITE_CACHE_ON)
	{
	cacheMode = CDB_CORE_ENABLE_WRITE_CACHE;
	}
	else if (pMvReq->Cdb[4] == APICDB4_PD_SET_SMART_OFF)
	{
	if ( !(pDevice->Setting&DEVICE_SETTING_SMART_ENABLED) )
	status = REQ_STATUS_SUCCESS;
	cacheMode = CDB_CORE_DISABLE_SMART;
	}
	else if (pMvReq->Cdb[4] == APICDB4_PD_SET_SMART_ON)
	{
	if ( pDevice->Setting&DEVICE_SETTING_SMART_ENABLED )
	status = REQ_STATUS_SUCCESS;
	cacheMode = CDB_CORE_ENABLE_SMART;
	}
	else
	{
	status = ERR_INVALID_REQUEST;
	}
	}

	if (status == REQ_STATUS_PENDING)
	{
	// Convert it into SCSI_CMD_MARVELL_SPECIFIC request.
	pMvReq->Cdb[0] = SCSI_CMD_MARVELL_SPECIFIC;
	pMvReq->Cdb[1] = CDB_CORE_MODULE;
	pMvReq->Cdb[2] = cacheMode;
	pMvReq->Device_Id = pDevice->Id;
	}
	}
	else
	{
	status = ERR_INVALID_HD_ID;
	}

	if (status == REQ_STATUS_SUCCESS)
	{
	pMvReq->Scsi_Status = status;
	return MV_TRUE;
	}
	else if (status == REQ_STATUS_PENDING)
	{
	//pMvReq->Scsi_Status = REQ_STATUS_SUCCESS;
	return MV_FALSE; // Need to access hardware.
	}
	else
	{
	if (pMvReq->Sense_Info_Buffer != NULL)
	((MV_PU8)pMvReq->Sense_Info_Buffer)[0] = status;
	pMvReq->Scsi_Status = REQ_STATUS_ERROR_WITH_SENSE;
	return MV_TRUE;
	}
	}

	MV_BOOLEAN core_pd_request_BSL_dump( PCore_Driver_Extension pCore, PMV_Request pMvReq )
	{
	pMvReq->Scsi_Status = REQ_STATUS_ERROR;
	return MV_TRUE;
	}

	MV_BOOLEAN core_pd_request_HD_MP_check( PCore_Driver_Extension pCore, PMV_Request pMvReq )
	{
	pMvReq->Scsi_Status = REQ_STATUS_ERROR;
	return MV_TRUE;
	}

	MV_BOOLEAN core_pd_request_HD_get_MP_status( PCore_Driver_Extension pCore, PMV_Request pMvReq )
	{
	pMvReq->Scsi_Status = REQ_STATUS_ERROR;
	return MV_TRUE;
	}

	CORE_Management_Command_Handler BASEATTR core_pd_cmd_handler[APICDB1_PD_MAX] =
	{
	core_pd_request_get_HD_info,
	#ifdef SUPPORT_PM
	core_pd_request_get_expander_info,
	core_pd_request_get_PM_info,
	#else
	NULL,
	NULL,
	#endif
	core_pd_request_get_HD_config,
	core_pd_request_set_HD_config,
	core_pd_request_BSL_dump,
	core_pd_request_HD_MP_check,
	core_pd_request_HD_get_MP_status,
	core_pd_request_get_HD_status,
	NULL
	};

	MV_BOOLEAN
	Core_pd_command(
	IN MV_PVOID extension,
	IN PMV_Request pReq
	)
	{
	PCore_Driver_Extension pCore = (PCore_Driver_Extension)extension;

	if ( pReq->Cdb[1] >= APICDB1_PD_MAX )
	{
	pReq->Scsi_Status = REQ_STATUS_INVALID_PARAMETER;
	return MV_TRUE;
	}
	if (core_pd_cmd_handler[pReq->Cdb[1]] == NULL)
	{
	pReq->Scsi_Status = REQ_STATUS_INVALID_PARAMETER;
	return MV_TRUE;
	}
	return core_pd_cmd_handler[pReq->Cdb[1]](pCore, pReq);
	}
	#endif