MV_VOID Tag_Init( PTag_Stack pTagStack, MV_U8 size ) { MV_U8 i; MV_DASSERT( size <= MAX_TAG_NUMBER ); #ifdef _OS_LINUX if ( pTagStack->Top && pTagStack->Top < size ) MV_DBG(DMSG_CORE, "__MV__ Init an in-use tag pool " "curr_size:init_size - %d:%d.\n", pTagStack->Top, size); #endif /* _OS_LINUX */ pTagStack->Top = size; for ( i=0; i<size; i++ ) { pTagStack->Stack[i] = size-1-i; } }
static void rw16_taskfile(PMV_Request req, PATA_TaskFile tf, int tag) { if (req->Cmd_Flag & CMD_FLAG_NCQ) { tf->Features = req->Cdb[13]; tf->Feature_Exp = req->Cdb[12]; tf->Sector_Count = tag<<3; tf->LBA_Low = req->Cdb[9]; tf->LBA_Mid = req->Cdb[8]; tf->LBA_High = req->Cdb[7]; tf->LBA_Low_Exp = req->Cdb[6]; tf->LBA_Mid_Exp = req->Cdb[5]; tf->LBA_High_Exp = req->Cdb[4]; tf->Device = MV_BIT(6); if (req->Cdb[0] == SCSI_CMD_READ_16) tf->Command = ATA_CMD_READ_FPDMA_QUEUED; else if (req->Cdb[0] == SCSI_CMD_WRITE_16) tf->Command = ATA_CMD_WRITE_FPDMA_QUEUED; } else if (req->Cmd_Flag & CMD_FLAG_48BIT) { MV_DASSERT(!(req->Cmd_Flag&CMD_FLAG_NCQ)); tf->Sector_Count = req->Cdb[13]; tf->Sector_Count_Exp = req->Cdb[12]; tf->LBA_Low = req->Cdb[9]; tf->LBA_Mid = req->Cdb[8]; tf->LBA_High = req->Cdb[7]; tf->LBA_Low_Exp = req->Cdb[6]; tf->LBA_Mid_Exp = req->Cdb[5]; tf->LBA_High_Exp = req->Cdb[4]; tf->Device = MV_BIT(6); if (req->Cdb[0] == SCSI_CMD_READ_16) tf->Command = ATA_CMD_READ_DMA_EXT; else if (req->Cdb[0] == SCSI_CMD_WRITE_16) tf->Command = ATA_CMD_WRITE_DMA_EXT; } }
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. */ MV_DASSERT( ( (((MV_U16)pReq->Cdb[7])<<8) | (pReq->Cdb[8]) ) <= 256 ); #if 1 { if ( ( (((MV_U16)pReq->Cdb[7])<<8) | (pReq->Cdb[8]) ) > MV_MAX_TRANSFER_SECTOR ) { printk("READ10/WRITE10 error: sector count 0x%xlimited.\n", (((MV_U16)pReq->Cdb[7])<<8) | (pReq->Cdb[8])); } } #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. */ if ( pReq->Cmd_Flag&CMD_FLAG_NCQ ) { //MV_DASSERT( pReq->Cmd_Flag&CMD_FLAG_48BIT ); //TBD: Do we need set 48bit for NCQ 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; } 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 { //TBD: If the device doesn't support 48 bit LBA. We have to split this request. //ATA_CMD_VERIFY //MV_ASSERT(MV_FALSE); //Sorry here I didn't do the verify exact as the OS required. //It need effort to split request. Currently I just pretect I've fulfilled the request. 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 */ //TBD: Check the 80-conductor cable in order to enable UDMA greater than 2. 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; break; case CDB_CORE_DISABLE_WRITE_CACHE: pTaskFile->Command = ATA_CMD_SET_FEATURES; pTaskFile->Features = ATA_CMD_DISABLE_WRITE_CACHE; 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; 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; 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_SHUTDOWN: if ( pDevice->Capacity&DEVICE_CAPACITY_48BIT_SUPPORTED ) pTaskFile->Command = ATA_CMD_FLUSH_EXT; else pTaskFile->Command = ATA_CMD_FLUSH; 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; 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_REQUEST_SENSE: case SCSI_CMD_MODE_SELECT_10: case SCSI_CMD_MODE_SENSE_10: default: MV_PRINT("[Galois]ATA_CDB2TaskFile 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; }
MV_VOID Tag_ReleaseOne(PTag_Stack pTagStack, MV_U8 tag) { MV_DASSERT( pTagStack->Top<MAX_TAG_NUMBER ); pTagStack->Stack[pTagStack->Top++] = tag; }
MV_U8 Tag_GetOne(PTag_Stack pTagStack) { MV_DASSERT( pTagStack->Top>0 ); return pTagStack->Stack[--pTagStack->Top]; }