MV_U32 mod_get_mem_size(PHBA_Extension pHBA, enum Resource_Type type,
MV_U16 max_io)
{
int i = 0;
unsigned long quota = 0;
unsigned long oneQuota = 0;
for (i=0; i<MAX_MODULE_NUMBER; i++) {
if (module_set[i].get_mem_size != NULL) {
oneQuota = module_set[i].get_mem_size(type, max_io);
quota += ROUNDING(oneQuota, 8);
MV_DBG(DMSG_KERN,
"%s quota for module %d is 0x%lx.\n",
type == RESOURCE_CACHED_MEMORY? "Cached memory" : "Uncached memory",
i,
oneQuota);
if (oneQuota) {
if (type == RESOURCE_UNCACHED_MEMORY) {
MV_PVOID uncached_virtual = NULL;
uncached_virtual = pci_alloc_consistent(pHBA->pcidev,
oneQuota,
&pHBA->uncached_physical[i]);
pHBA->uncached_size[i] = oneQuota;
if (uncached_virtual != NULL)
pHBA->uncached_virtual_address[i] = uncached_virtual;
#ifdef CACHE_MODULE_SUPPORT
else if (i == MODULE_CACHE)
MV_DPRINT(("Module %d asks for uncached memory failed.\n", i));
#endif
else
return -1;
}
}
}
}
/* Each extension needs one extension header which is hidden from module. */
if ( type==RESOURCE_CACHED_MEMORY )
quota += MODULE_HEADER_SIZE * MAX_MODULE_NUMBER;
MV_DBG(DMSG_KERN, "%s quota totally is 0x%lx.\n",
type==RESOURCE_CACHED_MEMORY? "Cached memory" : "Uncached memory",
quota);
return quota;
}
/* Set MV_Request.Cmd_Flag */
MV_BOOLEAN Category_CDB_Type(
IN PDomain_Device pDevice,
IN PMV_Request pReq
)
{
PDomain_Port pPort = pDevice->PPort;
switch ( pReq->Cdb[0] )
{
case SCSI_CMD_READ_10:
case SCSI_CMD_READ_16:
pReq->Cmd_Flag |= CMD_FLAG_DATA_IN;
case SCSI_CMD_WRITE_10:
case SCSI_CMD_WRITE_16:
case SCSI_CMD_VERIFY_10:
/*
*
* CMD_FLAG_DATA_IN
* CMD_FLAG_NON_DATA
* CMD_FLAG_DMA
*/
if ( pDevice->Device_Type&DEVICE_TYPE_ATAPI )
pReq->Cmd_Flag |= CMD_FLAG_PACKET;
if ( pDevice->Capacity&DEVICE_CAPACITY_48BIT_SUPPORTED )
pReq->Cmd_Flag |= CMD_FLAG_48BIT;
if ( pDevice->Capacity&DEVICE_CAPACITY_NCQ_SUPPORTED )
{
// might be a PM - assert is no longer true
//MV_DASSERT( pPort->Type==PORT_TYPE_SATA );
#if 0
if ( (pReq->Cdb[0]==SCSI_CMD_READ_10)
|| (pReq->Cdb[0]==SCSI_CMD_WRITE_10) )
#else
if (SCSI_IS_READ(pReq->Cdb[0]) || SCSI_IS_WRITE(pReq->Cdb[0]))
#endif
{
if ( (pPort->Running_Slot==0)
|| (pPort->Setting&PORT_SETTING_NCQ_RUNNING) )
{
/* hardware workaround:
* don't do NCQ on silicon image PM */
if( !((pPort->Setting & PORT_SETTING_PM_EXISTING) &&
(pPort->PM_Vendor_Id == 0x1095 )) )
{
if ( pReq->Scsi_Status!=REQ_STATUS_RETRY )
pReq->Cmd_Flag |= CMD_FLAG_NCQ;
}
}
}
}
break;
case SCSI_CMD_MARVELL_SPECIFIC:
{
/* This request should be for core module */
if ( pReq->Cdb[1]!=CDB_CORE_MODULE )
return MV_FALSE;
switch ( pReq->Cdb[2] )
{
case CDB_CORE_IDENTIFY:
case CDB_CORE_READ_LOG_EXT:
pReq->Cmd_Flag |= CMD_FLAG_DATA_IN;
break;
case CDB_CORE_SET_UDMA_MODE:
case CDB_CORE_SET_PIO_MODE:
case CDB_CORE_ENABLE_WRITE_CACHE:
case CDB_CORE_DISABLE_WRITE_CACHE:
case CDB_CORE_ENABLE_READ_AHEAD:
case CDB_CORE_DISABLE_READ_AHEAD:
pReq->Cmd_Flag |= CMD_FLAG_NON_DATA;
break;
#ifdef SUPPORT_ATA_SMART
case CDB_CORE_ATA_IDENTIFY_PACKET_DEVICE:
pReq->Cmd_Flag |= (CMD_FLAG_DATA_IN | CMD_FLAG_SMART);
break;
case CDB_CORE_ENABLE_SMART:
case CDB_CORE_DISABLE_SMART:
case CDB_CORE_SMART_RETURN_STATUS:
case CDB_CORE_ATA_SMART_AUTO_OFFLINE:
case CDB_CORE_ATA_SMART_AUTOSAVE:
case CDB_CORE_ATA_SMART_IMMEDIATE_OFFLINE:
pReq->Cmd_Flag |= (CMD_FLAG_NON_DATA | CMD_FLAG_SMART);
break;
case CDB_CORE_ATA_SMART_READ_VALUES:
case CDB_CORE_ATA_SMART_READ_THRESHOLDS:
case CDB_CORE_ATA_SMART_READ_LOG_SECTOR:
pReq->Cmd_Flag |= (CMD_FLAG_DATA_IN | CMD_FLAG_SMART);
break;
case CDB_CORE_ATA_SMART_WRITE_LOG_SECTOR:
pReq->Cmd_Flag |= (CMD_FLAG_DATA_OUT | CMD_FLAG_SMART);
break;
#endif
case CDB_CORE_ATA_IDENTIFY:
pReq->Cmd_Flag |= (CMD_FLAG_DATA_IN | CMD_FLAG_SMART);
break;
case CDB_CORE_ATA_DOWNLOAD_MICROCODE:
break;
case CDB_CORE_SHUTDOWN:
if ( pDevice->Device_Type&DEVICE_TYPE_ATAPI )
return MV_FALSE;
MV_DPRINT(("Shutdown on device %d.\n", pReq->Device_Id));
pReq->Cmd_Flag |= CMD_FLAG_NON_DATA;
break;
#ifdef SUPPORT_ATA_POWER_MANAGEMENT
case CDB_CORE_ATA_SLEEP:
case CDB_CORE_ATA_IDLE:
case CDB_CORE_ATA_STANDBY:
case CDB_CORE_ATA_IDLE_IMMEDIATE:
case CDB_CORE_ATA_CHECK_POWER_MODE:
case CDB_CORE_ATA_STANDBY_IMMEDIATE:
pReq->Cmd_Flag |= CMD_FLAG_NON_DATA;
break;
#endif
case CDB_CORE_OS_SMART_CMD:
if ((pReq->Cdb[3] != ATA_CMD_IDENTIFY_ATA) ||
(pReq->Cdb[3] != ATA_CMD_IDENTIY_ATAPI))
pReq->Cmd_Flag |= CMD_FLAG_SMART;
if (pDevice->Device_Type & DEVICE_TYPE_ATAPI)
pReq->Cmd_Flag |= CMD_FLAG_PACKET;
break;
default:
return MV_FALSE;
}
break;
}
#ifdef SUPPORT_ATA_SECURITY_CMD
case ATA_16:
return MV_TRUE;
break;
#endif
case SCSI_CMD_START_STOP_UNIT:
case SCSI_CMD_SYNCHRONIZE_CACHE_10:
if ( !(pDevice->Device_Type & DEVICE_TYPE_ATAPI )){
if ( pDevice->Capacity&DEVICE_CAPACITY_48BIT_SUPPORTED )
pReq->Cmd_Flag |= CMD_FLAG_48BIT;
pReq->Cmd_Flag |= CMD_FLAG_NON_DATA;
break;
} //We will send this command to CD drive directly if it is ATAPI device.
case SCSI_CMD_SND_DIAG:
pReq->Cmd_Flag |= CMD_FLAG_DATA_OUT;
case SCSI_CMD_INQUIRY:
case SCSI_CMD_READ_CAPACITY_10:
case SCSI_CMD_TEST_UNIT_READY:
case SCSI_CMD_MODE_SENSE_10:
case SCSI_CMD_MODE_SELECT_10:
case SCSI_CMD_PREVENT_MEDIUM_REMOVAL:
case SCSI_CMD_READ_TOC:
case SCSI_CMD_REQUEST_SENSE:
default:
if ( pDevice->Device_Type&DEVICE_TYPE_ATAPI )
{
pReq->Cmd_Flag |= CMD_FLAG_PACKET;
break;
}
else
{
MV_DPRINT(("Error: Unknown request: 0x%x.\n", pReq->Cdb[0]));
return MV_FALSE;
}
}
return MV_TRUE;
}
/* Set MV_Request.Cmd_Flag */
MV_BOOLEAN Category_CDB_Type(
IN PDomain_Device pDevice,
IN PMV_Request pReq
)
{
//pReq->Cmd_Flag = 0;//TBD: Don't set. HBA has set some bits.
PDomain_Port pPort = pDevice->PPort;
switch ( pReq->Cdb[0] )
{
case SCSI_CMD_READ_10:
case SCSI_CMD_READ_12:
case SCSI_CMD_WRITE_10:
case SCSI_CMD_VERIFY_10:
/*
*
* CMD_FLAG_DATA_IN
* CMD_FLAG_NON_DATA
* CMD_FLAG_DMA
*/
if ( pDevice->Device_Type&DEVICE_TYPE_ATAPI )
pReq->Cmd_Flag |= CMD_FLAG_PACKET;
if ( pDevice->Capacity&DEVICE_CAPACITY_48BIT_SUPPORTED )
pReq->Cmd_Flag |= CMD_FLAG_48BIT;
#if 0
if ( pDevice->Capacity&DEVICE_CAPACITY_NCQ_SUPPORTED )
{
if ( ((pReq->Cdb[0]==SCSI_CMD_READ_10) || (pReq->Cdb[0]==SCSI_CMD_READ_12)
|| (pReq->Cdb[0]==SCSI_CMD_WRITE_10))
&& (pReq->SG_Table.Valid_Entry_Count <= 1) /* PRDTL=1 bug */
)
{
if ( (pPort->Running_Slot==0) || (pPort->Setting&PORT_SETTING_NCQ_RUNNING) )
{
/* hardware workaround:
* don't do NCQ on silicon image PM */
if( !((pPort->Setting & PORT_SETTING_PM_EXISTING) &&
(pPort->PM_Vendor_Id == 0x1095 )) )
{
if ( pReq->Scsi_Status!=REQ_STATUS_RETRY )
pReq->Cmd_Flag |= CMD_FLAG_NCQ;
}
}
}
}
#endif
break;
case SCSI_CMD_MARVELL_SPECIFIC:
{
/* This request should be for core module */
if ( pReq->Cdb[1]!=CDB_CORE_MODULE )
return MV_FALSE;
switch ( pReq->Cdb[2] )
{
case CDB_CORE_IDENTIFY:
case CDB_CORE_READ_LOG_EXT:
pReq->Cmd_Flag |= CMD_FLAG_DATA_IN;
break;
case CDB_CORE_SET_UDMA_MODE:
case CDB_CORE_SET_PIO_MODE:
case CDB_CORE_ENABLE_WRITE_CACHE:
case CDB_CORE_DISABLE_WRITE_CACHE:
case CDB_CORE_ENABLE_SMART:
case CDB_CORE_DISABLE_SMART:
case CDB_CORE_SMART_RETURN_STATUS:
case CDB_CORE_ENABLE_READ_AHEAD:
case CDB_CORE_DISABLE_READ_AHEAD:
pReq->Cmd_Flag |= CMD_FLAG_NON_DATA;
break;
case CDB_CORE_SHUTDOWN:
if ( pDevice->Device_Type&DEVICE_TYPE_ATAPI )
return MV_FALSE;
MV_DPRINT(("Shutdown on device %d.\n", pReq->Device_Id));
pReq->Cmd_Flag |= CMD_FLAG_NON_DATA;
break;
default:
return MV_FALSE;
}
break;
}
case SCSI_CMD_START_STOP_UNIT:
case SCSI_CMD_SYNCHRONIZE_CACHE_10:
if ( !(pDevice->Device_Type & DEVICE_TYPE_ATAPI )) {
if ( pDevice->Capacity&DEVICE_CAPACITY_48BIT_SUPPORTED )
pReq->Cmd_Flag |= CMD_FLAG_48BIT;
pReq->Cmd_Flag |= CMD_FLAG_NON_DATA;
break;
}//We will send this command to CD drive directly if it is ATAPI device.
case SCSI_CMD_INQUIRY:
case SCSI_CMD_READ_CAPACITY_10:
case SCSI_CMD_TEST_UNIT_READY:
case SCSI_CMD_MODE_SENSE_10:
case SCSI_CMD_MODE_SELECT_10:
case SCSI_CMD_PREVENT_MEDIUM_REMOVAL:
case SCSI_CMD_READ_TOC:
case SCSI_CMD_REQUEST_SENSE:
default:
if ( pDevice->Device_Type&DEVICE_TYPE_ATAPI )
{
//MV_DPRINT(("Other requests: 0x%x.\n", pReq->Cdb[0]));
pReq->Cmd_Flag |= CMD_FLAG_PACKET;
#if 0 //TBD: Refer to TranslateSCSIRequest
if ( pReq->Data_Transfer_Length==0 )
{
pReq->Cmd_Flag |= CMD_FLAG_NON_DATA;
}
else
{
if ( pReq->Cdb[0]==SCSI_CMD_INQUIRY
|| pReq->Cdb[0]==SCSI_CMD_READ_CAPACITY_10
|| pReq->Cdb[0]==SCSI_CMD_REQUEST_SENSE
|| pReq->Cdb[0]==SCSI_CMD_REPORT_LUN
|| pReq->Cdb[0]==SCSI_CMD_READ_DISC_STRUCTURE
|| pReq->Cdb[0]==SCSI_CMD_READ_TOC
|| pReq->Cdb[0]==SCSI_CMD_READ_SUB_CHANNEL
|| pReq->Cdb[0]==SCSI_CMD_READ_CD
|| pReq->Cdb[0]==SCSI_CMD_GET_EVENT_STATUS_NOTIFICATION
)
{
pReq->Cmd_Flag |= CMD_FLAG_DATA_IN;
}
else if ( pReq->Cdb[0]==SCSI_CMD_MODE_SENSE_10 )
{
/* Data out */
}
else
{
MV_DPRINT(("Should be data-in or data-out: 0x%x.\n", pReq->Cdb[0]));
//MV_ASSERT(MV_FALSE);
}
}
#endif
break;
}
else
{
MV_DPRINT(("Error: Unknown request: 0x%x.\n", pReq->Cdb[0]));
return MV_FALSE;
}
}
return MV_TRUE;
}
MV_BOOLEAN ATA_CDB2TaskFile(
IN PDomain_Device pDevice,
IN PMV_Request pReq,
IN MV_U8 tag,
OUT PATA_TaskFile pTaskFile
)
{
MV_ZeroMemory(pTaskFile, sizeof(ATA_TaskFile));
switch ( pReq->Cdb[0] )
{
case SCSI_CMD_READ_10:
case SCSI_CMD_WRITE_10:
{
/*
* The OS maximum tranfer length is set to 128K.
* For ATA_CMD_READ_DMA and ATA_CMD_WRITE_DMA,
* the max size they can handle is 256 sectors.
* And Sector_Count==0 means 256 sectors.
* If OS request max lenght>128K, for 28 bit device, we have to split requests.
*/
#ifndef _OS_LINUX //Avoid keneral panic
MV_DASSERT( ( (((MV_U16)pReq->Cdb[7])<<8) | (pReq->Cdb[8]) ) <= 256 );
#endif
/*
* 24 bit LBA can express 128GB.
* 4 bytes LBA like SCSI_CMD_READ_10 can express 2TB.
*/
/* Make sure Cmd_Flag has set already. */
#ifdef SUPPORT_ATA_SECURITY_CMD
if ( pReq->Cmd_Flag&CMD_FLAG_NCQ && !((pDevice->Setting&DEVICE_SETTING_SECURITY_LOCKED)==0x10))
#else
if ( pReq->Cmd_Flag&CMD_FLAG_NCQ)
#endif
{
pTaskFile->Features = pReq->Cdb[8];
pTaskFile->Feature_Exp = pReq->Cdb[7];
pTaskFile->Sector_Count = tag<<3;
pTaskFile->LBA_Low = pReq->Cdb[5];
pTaskFile->LBA_Mid = pReq->Cdb[4];
pTaskFile->LBA_High = pReq->Cdb[3];
pTaskFile->LBA_Low_Exp = pReq->Cdb[2];
pTaskFile->Device = MV_BIT(6);
if ( pReq->Cdb[0]==SCSI_CMD_READ_10 )
pTaskFile->Command = ATA_CMD_READ_FPDMA_QUEUED;
else if ( pReq->Cdb[0]==SCSI_CMD_WRITE_10 )
pTaskFile->Command = ATA_CMD_WRITE_FPDMA_QUEUED;
}
else if ( pReq->Cmd_Flag&CMD_FLAG_48BIT )
{
MV_DASSERT( !(pReq->Cmd_Flag&CMD_FLAG_NCQ) );
pTaskFile->Sector_Count = pReq->Cdb[8];
pTaskFile->Sector_Count_Exp = pReq->Cdb[7];
pTaskFile->LBA_Low = pReq->Cdb[5];
pTaskFile->LBA_Mid = pReq->Cdb[4];
pTaskFile->LBA_High = pReq->Cdb[3];
pTaskFile->LBA_Low_Exp = pReq->Cdb[2];
pTaskFile->Device = MV_BIT(6);
if ( pReq->Cdb[0]==SCSI_CMD_READ_10 )
pTaskFile->Command = ATA_CMD_READ_DMA_EXT;
else if ( pReq->Cdb[0]==SCSI_CMD_WRITE_10 )
pTaskFile->Command = ATA_CMD_WRITE_DMA_EXT;
}
else
{
/* 28 bit DMA */
pTaskFile->Sector_Count = pReq->Cdb[8]; /* Could be zero */
pTaskFile->LBA_Low = pReq->Cdb[5];
pTaskFile->LBA_Mid = pReq->Cdb[4];
pTaskFile->LBA_High = pReq->Cdb[3];
pTaskFile->Device = MV_BIT(6) | (pReq->Cdb[2]&0xF);
MV_DASSERT( (pReq->Cdb[2]&0xF0)==0 );
if ( pReq->Cdb[0]==SCSI_CMD_READ_10 )
pTaskFile->Command = ATA_CMD_READ_DMA;
else if ( pReq->Cdb[0]==SCSI_CMD_WRITE_10 )
pTaskFile->Command = ATA_CMD_WRITE_DMA;
}
break;
}
#ifdef SUPPORT_ATA_SECURITY_CMD
case ATA_16:
scsi_ata_passthru_16_fill_taskfile(pReq,pTaskFile);
break;
#endif
case SCSI_CMD_READ_16:
case SCSI_CMD_WRITE_16:
rw16_taskfile(pReq, pTaskFile, tag);
break;
case SCSI_CMD_VERIFY_10:
/*
* For verify command, the size may need use two MV_U8, especially Windows.
* For 28 bit device, we have to split the request.
* For 48 bit device, we use ATA_CMD_VERIFY_EXT.
*/
if ( pDevice->Capacity&DEVICE_CAPACITY_48BIT_SUPPORTED )
{
pTaskFile->Sector_Count = pReq->Cdb[8];
pTaskFile->Sector_Count_Exp = pReq->Cdb[7];
pTaskFile->LBA_Low = pReq->Cdb[5];
pTaskFile->LBA_Mid = pReq->Cdb[4];
pTaskFile->LBA_High = pReq->Cdb[3];
pTaskFile->LBA_Low_Exp = pReq->Cdb[2];
pTaskFile->Device = MV_BIT(6);
pTaskFile->Command = ATA_CMD_VERIFY_EXT;
}
else
{
pTaskFile->Sector_Count = pReq->Cdb[8];
pTaskFile->LBA_Low = pReq->Cdb[5];
pTaskFile->LBA_Mid = pReq->Cdb[4];
pTaskFile->LBA_High = pReq->Cdb[3];
pTaskFile->Device = MV_BIT(6) | (pReq->Cdb[2]&0xF);
MV_DASSERT( (pReq->Cdb[2]&0xF0)==0 );
pTaskFile->Command = ATA_CMD_VERIFY;
}
break;
case SCSI_CMD_MARVELL_SPECIFIC:
{
/* This request should be for core module */
if ( pReq->Cdb[1]!=CDB_CORE_MODULE )
return MV_FALSE;
switch ( pReq->Cdb[2] )
{
case CDB_CORE_IDENTIFY:
pTaskFile->Command = ATA_CMD_IDENTIFY_ATA;
break;
case CDB_CORE_SET_UDMA_MODE:
pTaskFile->Command = ATA_CMD_SET_FEATURES;
pTaskFile->Features = ATA_CMD_SET_TRANSFER_MODE;
pTaskFile->Sector_Count = 0x40 | pReq->Cdb[3];
MV_DASSERT( pReq->Cdb[4]==MV_FALSE ); /* Use UDMA mode */
break;
case CDB_CORE_SET_PIO_MODE:
pTaskFile->Command = ATA_CMD_SET_FEATURES;
pTaskFile->Features = ATA_CMD_SET_TRANSFER_MODE;
pTaskFile->Sector_Count = 0x08 | pReq->Cdb[3];
break;
case CDB_CORE_ENABLE_WRITE_CACHE:
pTaskFile->Command = ATA_CMD_SET_FEATURES;
pTaskFile->Features = ATA_CMD_ENABLE_WRITE_CACHE;
pDevice->Setting |= DEVICE_SETTING_WRITECACHE_ENABLED;
break;
case CDB_CORE_DISABLE_WRITE_CACHE:
pTaskFile->Command = ATA_CMD_SET_FEATURES;
pTaskFile->Features = ATA_CMD_DISABLE_WRITE_CACHE;
pDevice->Setting &= ~DEVICE_SETTING_WRITECACHE_ENABLED;
break;
case CDB_CORE_SHUTDOWN:
if ( pDevice->Capacity&DEVICE_CAPACITY_48BIT_SUPPORTED )
pTaskFile->Command = ATA_CMD_FLUSH_EXT;
else
pTaskFile->Command = ATA_CMD_FLUSH;
break;
#ifdef SUPPORT_ATA_POWER_MANAGEMENT
case CDB_CORE_ATA_IDLE:
pTaskFile->Command = 0xe3;
pTaskFile->Sector_Count = pReq->Cdb[(pReq->Cmd_Flag & CMD_FLAG_ATA_12) ?4:6];
break;
case CDB_CORE_ATA_STANDBY:
pTaskFile->Command = 0xe2;
break;
case CDB_CORE_ATA_IDLE_IMMEDIATE:
pTaskFile->Command = 0xe1;
break;
case CDB_CORE_ATA_STANDBY_IMMEDIATE:
pTaskFile->Command = 0xe0;
break;
case CDB_CORE_ATA_CHECK_POWER_MODE:
pTaskFile->Command = 0xe5;
break;
case CDB_CORE_ATA_SLEEP:
pTaskFile->Command = 0xe6;
break;
#endif
case CDB_CORE_ATA_IDENTIFY:
pTaskFile->Command = 0xec;
break;
case CDB_CORE_ENABLE_READ_AHEAD:
pTaskFile->Command = ATA_CMD_SET_FEATURES;
pTaskFile->Features = ATA_CMD_ENABLE_READ_LOOK_AHEAD;
break;
case CDB_CORE_DISABLE_READ_AHEAD:
pTaskFile->Command = ATA_CMD_SET_FEATURES;
pTaskFile->Features = ATA_CMD_DISABLE_READ_LOOK_AHEAD;
break;
case CDB_CORE_READ_LOG_EXT:
pTaskFile->Command = ATA_CMD_READ_LOG_EXT;
pTaskFile->Sector_Count = 1; /* Read one sector */
pTaskFile->LBA_Low = 0x10; /* Page 10h */
break;
case CDB_CORE_OS_SMART_CMD:
pTaskFile->Command = pReq->Cdb[3];
pTaskFile->Features = pReq->Cdb[4];
pTaskFile->LBA_Low = pReq->Cdb[5];
pTaskFile->LBA_Mid = pReq->Cdb[6];
pTaskFile->LBA_High = pReq->Cdb[7];
pTaskFile->LBA_Low_Exp = pReq->Cdb[9];
pTaskFile->Sector_Count = pReq->Cdb[8];
break;
#ifdef SUPPORT_ATA_SMART
case CDB_CORE_ATA_IDENTIFY_PACKET_DEVICE:
pTaskFile->Command = ATA_IDENTIFY_PACKET_DEVICE;
pTaskFile->Sector_Count = 0x1;
break;
case CDB_CORE_ENABLE_SMART:
pTaskFile->Command = ATA_CMD_SMART;
pTaskFile->Features = ATA_CMD_ENABLE_SMART;
pTaskFile->LBA_Mid = 0x4F;
pTaskFile->LBA_High = 0xC2;
pTaskFile->LBA_Low = 0x1;
break;
case CDB_CORE_DISABLE_SMART:
pTaskFile->Command = ATA_CMD_SMART;
pTaskFile->Features = ATA_CMD_DISABLE_SMART;
pTaskFile->LBA_Mid = 0x4F;
pTaskFile->LBA_High = 0xC2;
pTaskFile->LBA_Low = 0x1;
break;
case CDB_CORE_SMART_RETURN_STATUS:
pTaskFile->Command = ATA_CMD_SMART;
pTaskFile->Features = ATA_CMD_SMART_RETURN_STATUS;
pTaskFile->LBA_Mid = 0x4F;
pTaskFile->LBA_High = 0xC2;
break;
case CDB_CORE_ATA_SMART_READ_VALUES:
pTaskFile->Command = ATA_CMD_SMART;
pTaskFile->Features = ATA_SMART_READ_VALUES;
pTaskFile->LBA_Mid = 0x4F;
pTaskFile->LBA_High = 0xC2;
pTaskFile->LBA_Low = 0x1;
break;
case CDB_CORE_ATA_SMART_READ_THRESHOLDS:
pTaskFile->Command = ATA_CMD_SMART;
pTaskFile->Features = ATA_SMART_READ_THRESHOLDS;
pTaskFile->LBA_Mid = 0x4F;
pTaskFile->LBA_High = 0xC2;
pTaskFile->LBA_Low = 0x1;
break;
case CDB_CORE_ATA_SMART_READ_LOG_SECTOR:
pTaskFile->Command = ATA_CMD_SMART;
pTaskFile->Features = ATA_SMART_READ_LOG_SECTOR;
pTaskFile->LBA_Mid = 0x4F;
pTaskFile->LBA_High = 0xC2;
pTaskFile->Sector_Count = 0x1;
pTaskFile->LBA_Low = pReq->Cdb[(pReq->Cmd_Flag & CMD_FLAG_ATA_12) ?5:8];
break;
case CDB_CORE_ATA_SMART_WRITE_LOG_SECTOR :
pTaskFile->Command = ATA_CMD_SMART;
pTaskFile->Features = ATA_SMART_WRITE_LOG_SECTOR;
pTaskFile->LBA_Mid = 0x4F;
pTaskFile->LBA_High = 0xC2;
pTaskFile->Sector_Count = 0x1;
pTaskFile->LBA_Low = pReq->Cdb[(pReq->Cmd_Flag & CMD_FLAG_ATA_12) ?5:8];
break;
case CDB_CORE_ATA_SMART_AUTO_OFFLINE:
pTaskFile->Command = ATA_CMD_SMART;
pTaskFile->Features = ATA_SMART_AUTO_OFFLINE;
pTaskFile->LBA_Mid = 0x4F;
pTaskFile->LBA_High = 0xC2;
pTaskFile->LBA_Low= pReq->Cdb[(pReq->Cmd_Flag & CMD_FLAG_ATA_12) ?5:8];
pTaskFile->Sector_Count = pReq->Cdb[(pReq->Cmd_Flag & CMD_FLAG_ATA_12) ?4:6];
break;
case CDB_CORE_ATA_SMART_AUTOSAVE:
pTaskFile->Command = ATA_CMD_SMART;
pTaskFile->Features = ATA_SMART_AUTOSAVE;
pTaskFile->LBA_Mid = 0x4F;
pTaskFile->LBA_High = 0xC2;
pTaskFile->Sector_Count = pReq->Cdb[(pReq->Cmd_Flag & CMD_FLAG_ATA_12) ?4 : 6];
break;
case CDB_CORE_ATA_SMART_IMMEDIATE_OFFLINE:
pTaskFile->Command = ATA_CMD_SMART;
pTaskFile->Features = ATA_SMART_IMMEDIATE_OFFLINE;
pTaskFile->LBA_Mid = 0x4F;
pTaskFile->LBA_High = 0xC2;
pTaskFile->LBA_Low= pReq->Cdb[(pReq->Cmd_Flag & CMD_FLAG_ATA_12) ?5:8];
pTaskFile->Sector_Count = pReq->Cdb[(pReq->Cmd_Flag & CMD_FLAG_ATA_12) ?4 : 6];
break;
#endif /*#ifdef SUPPORT_ATA_SMART*/
case CDB_CORE_ATA_DOWNLOAD_MICROCODE:
if(pReq->Cmd_Flag & CMD_FLAG_ATA_12)
scsi_ata_passthru_12_fill_taskfile(pReq,pTaskFile);
else
scsi_ata_passthru_16_fill_taskfile(pReq,pTaskFile);
break;
default:
return MV_FALSE;
}
break;
}
case SCSI_CMD_SYNCHRONIZE_CACHE_10:
if ( pDevice->Capacity&DEVICE_CAPACITY_48BIT_SUPPORTED )
pTaskFile->Command = ATA_CMD_FLUSH_EXT;
else
pTaskFile->Command = ATA_CMD_FLUSH;
pTaskFile->Device = MV_BIT(6);
break;
case SCSI_CMD_START_STOP_UNIT:
if (pReq->Cdb[4] & MV_BIT(0))
{
pTaskFile->Command = ATA_CMD_SEEK;
pTaskFile->Device = MV_BIT(6);
}
else
{
pTaskFile->Command = ATA_CMD_STANDBY_IMMEDIATE;
}
break;
case SCSI_CMD_SND_DIAG:
Core_Fill_SendDiagTaskfile( pDevice,pReq, pTaskFile);
break;
case SCSI_CMD_REQUEST_SENSE:
case SCSI_CMD_MODE_SELECT_10:
case SCSI_CMD_MODE_SENSE_10:
MV_DPRINT(("Error: Unknown request: 0x%x.\n", pReq->Cdb[0]));
default:
return MV_FALSE;
}
/*
* Attention: Never return before this line if your return is MV_TRUE.
* We need set the slave DEV bit here.
*/
if ( pDevice->Is_Slave )
pTaskFile->Device |= MV_BIT(4);
return MV_TRUE;
}
