Google Git
Sign in
gfiber / kernel / prism / 32248e7f4477323c3e4907e45d089e640068415d / . / drivers / scsi / thor / linux / hba_mod.c
blob: 377573e127d809792a4bb795837bafef5f969475 [file] [log] [blame]
/*
* module management module - module of the modules
*
*
*/
#define IOCTL_TEMPLATE
#ifdef IOCTL_TEMPLATE
#define SECTOR_SIZE 512
#include <linux/hdreg.h>
#endif
#include "hba_header.h"
#include "linux_main.h"
#include "linux_iface.h"
#include "hba_timer.h"
#include "hba_mod.h"
#include "res_mgmt.h"
#include "hba_exp.h"
#include <scsi/scsi_tcq.h>
#include "core_inter.h"
#include "core_sat.h"
#include "core_ata.h"
#include <scsi/scsi_eh.h>
#if 0
static void __dump_hex(const unsigned char *buf, int len)
{
int i;
for (i = 0; i < len; i++) {
if (i && !(i % 8))
printk(YELLOW(" :"));
if (i && !(i % 16))
printk("\n");
printk(" %02X", buf[i]);
}
printk("\n");
}
#endif
void __hba_dump_req_info(MV_U32 id, PMV_Request preq)
{
#if 0
unsigned long lba =0;
char *buf;
struct scsi_cmnd *scmd = NULL;
struct scatterlist *sg = NULL;
switch (preq->Cdb[0]) {
case SCSI_CMD_READ_10:
case SCSI_CMD_WRITE_10:
lba = preq->Cdb[2]<<24 | preq->Cdb[3]<<16 | preq->Cdb[4]<<8 | \
preq->Cdb[5];
break;
case SCSI_CMD_INQUIRY:
if (REQ_STATUS_SUCCESS != preq->Scsi_Status)
break;
scmd = (struct scsi_cmnd *) preq->Org_Req;
sg = (struct scatterlist *) mv_rq_bf(scmd);
/* ignored */
break;
buf = map_sg_page(sg) + sg->offset;
MV_DBG(DMSG_SCSI, BLUE("-- inquiry dump starts -- ")"\n");
__dump_hex((unsigned char *)buf, mv_rq_bf_l(scmd));
MV_DBG(DMSG_SCSI, "-- inquiry dump ends -- \n");
kunmap_atomic(buf, KM_IRQ0);
break;
default:
lba = 0;
break;
}
#if 0
MV_DBG(DMSG_FREQ,
"(%u) req "RED("%p")
" dev %d : cmd %2X : lba %lu - %lu : length %d.\n",
id, preq, preq->Device_Id, preq->Cdb[0], lba,
lba + preq->Data_Transfer_Length/512,
preq->Data_Transfer_Length);
#endif
#endif
}
static void generate_sg_table(struct hba_extension *phba,
struct scsi_cmnd *scmd,
PMV_SG_Table sg_table)
{
struct scatterlist *sg;
unsigned int sg_count = 0;
unsigned int length;
BUS_ADDRESS busaddr = 0;
int i;
//MV_DBG(DMSG_FREQ,"%s : in %s.\n", mv_product_name, __FUNCTION__);
if (mv_rq_bf_l(scmd) > (mv_scmd_host(scmd)->max_sectors << 9)) {
MV_DBG(DMSG_SCSI, "ERROR: request length exceeds "
"the maximum alowed value.\n");
}
if (0 == mv_rq_bf_l(scmd))
return ;
if (mv_use_sg(scmd)) {
MV_DBG(DMSG_SCSI_FREQ, "%s : map %d sg entries.\n",
mv_product_name, mv_use_sg(scmd));
sg = (struct scatterlist *) mv_rq_bf(scmd);
if (MV_SCp(scmd)->mapped == 0){
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 23)
sg_count = pci_map_sg(phba->dev,
sg,
mv_use_sg(scmd),
scsi_to_pci_dma_dir(scmd->sc_data_direction));
#else
sg_count = scsi_dma_map(scmd);
#endif
if (sg_count != mv_use_sg(scmd)) {
MV_PRINT("WARNING sg_count(%d) != scmd->use_sg(%d)\n",
(unsigned int) sg_count, mv_use_sg(scmd));
}
MV_SCp(scmd)->mapped = 1;
}
for (i = 0; i < sg_count; i++) {
busaddr = sg_dma_address(&sg[i]);
length = sg_dma_len(&sg[i]);
#ifdef MV_DEBUG
if(length > 4096)
MV_DPRINT(("Warning: sg[%i] length %d > 4096\n", i, length));
#endif
sgdt_append_pctx(sg_table,
LO_BUSADDR(busaddr),
HI_BUSADDR(busaddr),
length,
sg + i);
}
} else {
MV_DBG(DMSG_SCSI_FREQ, "map kernel addr into bus addr.\n" );
if (MV_SCp(scmd)->mapped == 0) {
busaddr = dma_map_single(&phba->dev->dev,
mv_rq_bf(scmd),
mv_rq_bf_l(scmd),
scsi_to_pci_dma_dir(scmd->sc_data_direction));
MV_SCp(scmd)->bus_address = busaddr;
MV_SCp(scmd)->mapped = 1;
}
#ifdef MV_DEBUG
if(mv_rq_bf_l(scmd) > 4096)
MV_DPRINT(("Warning: single sg request_bufflen %d > 4096\n", mv_rq_bf_l(scmd)));
#endif
sgdt_append_vp(sg_table,
mv_rq_bf(scmd),
mv_rq_bf_l(scmd),
LO_BUSADDR(busaddr),
HI_BUSADDR(busaddr));
}
}
void mv_complete_request(struct hba_extension *phba,
struct scsi_cmnd *scmd,
PMV_Request pReq)
{
PMV_Sense_Data senseBuffer = (PMV_Sense_Data) scmd->sense_buffer;
//MV_POKE();
__hba_dump_req_info(phba->desc->module_id, pReq);
if (mv_rq_bf_l(scmd)) {
MV_DBG(DMSG_SCSI_FREQ, "unmap %d bytes.\n",
mv_rq_bf_l(scmd));
if (MV_SCp(scmd)->mapped) {
if (mv_use_sg(scmd)) {
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 23)
pci_unmap_sg(phba->dev,
mv_rq_bf(scmd),
mv_use_sg(scmd),
scsi_to_pci_dma_dir(scmd->sc_data_direction));
#else
scsi_dma_unmap(scmd);
#endif
} else {
dma_unmap_single(&(phba->dev->dev),
MV_SCp(scmd)->bus_address,
mv_rq_bf_l(scmd),
scsi_to_pci_dma_dir(scmd->sc_data_direction));
}
}
}
MV_DBG(DMSG_SCSI_FREQ,
" pReq->Scsi_Status = %x pcmd = %p.\n",
pReq->Scsi_Status, scmd);
#if 0//def MV_DEBUG
if((pReq->Scsi_Status != REQ_STATUS_SUCCESS) && (SCSI_IS_READ(pReq->Cdb[0]) || SCSI_IS_WRITE(pReq->Cdb[0])))
MV_DPRINT(( "Device %d pReq->Scsi_Status = %x cmd = 0x%x.\n", pReq->Device_Id, pReq->Scsi_Status, pReq->Cdb[0]));
#endif
switch (pReq->Scsi_Status) {
case REQ_STATUS_SUCCESS:
scmd->result = 0x00;
break;
case REQ_STATUS_MEDIA_ERROR:
scmd->result = (DID_BAD_TARGET << 16);
break;
case REQ_STATUS_BUSY:
scmd->result = (DID_BUS_BUSY << 16);
break;
case REQ_STATUS_NO_DEVICE:
scmd->result = (DID_NO_CONNECT << 16);
break;
case REQ_STATUS_HAS_SENSE:
/* Sense buffer data is valid already. */
scmd->result = (DRIVER_SENSE << 24) | (DID_OK << 16) | CONDITION_GOOD;
senseBuffer->Valid = 1;
MV_DBG(DMSG_SCSI, "MV Sense: response %x SK %s length %x "
"ASC %x ASCQ %x.\n", ((MV_PU8) senseBuffer)[0],
MV_DumpSenseKey(((MV_PU8) senseBuffer)[2]),
((MV_PU8) senseBuffer)[7],
((MV_PU8) senseBuffer)[12],
((MV_PU8) senseBuffer)[13]);
break;
default:
scmd->result = (DRIVER_INVALID | DID_ABORT) << 16;
break;
}
scmd->scsi_done(scmd);
}
#ifdef SUPPORT_ATA_POWER_MANAGEMENT
static inline int is_ata_16_passthrough_for_pm(struct scsi_cmnd * scmd)
{
switch(scmd->cmnd[0]){
case ATA_16:
switch(scmd->cmnd[14]){
/* exception*/
#ifndef SUPPORT_ATA_SECURITY_CMD
case ATA_CMD_IDENTIFY_ATA:
return 1;
#endif
case ATA_CMD_DEV_RESET:
case ATA_CMD_STANDBYNOW1:
case ATA_CMD_IDLEIMMEDIATE:
case ATA_CMD_STANDBY:
case ATA_CMD_IDLE :
case ATA_CMD_CHK_POWER:
case ATA_CMD_SLEEP:
case ATA_CMD_SMART:
if(scmd->sc_data_direction == DMA_NONE &&
scmd->cmnd[4] != 0xd4)
return 1;
else
return 0;
default:
return 0;
}
default:
break;
}
return 0;
}
static void mv_pm_ata_16_complete_request(struct hba_extension * phba,
struct scsi_cmnd *scmd,PMV_Request pReq)
{
PDomain_Device pDevice = NULL;
MV_U8 portId, deviceId; /*, temp;*/
PCore_Driver_Extension pCore;
unsigned char *sb = scmd->sense_buffer;
unsigned char *desc = sb + 8;
pCore = (PCore_Driver_Extension)HBA_GetModuleExtension(phba, MODULE_CORE);
if ( pReq->Device_Id != VIRTUAL_DEVICE_ID )
{
portId = PATA_MapPortId(pReq->Device_Id);
deviceId = PATA_MapDeviceId(pReq->Device_Id);
if ( portId < MAX_PORT_NUMBER )
pDevice = &pCore->Ports[portId].Device[deviceId];
}
/* !DMA_NONE */
if (MV_SCp(scmd)->mapped) {
if (mv_use_sg(scmd)){
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 23)
pci_unmap_sg(phba->dev,mv_rq_bf(scmd),mv_use_sg(scmd),
scsi_to_pci_dma_dir(scmd->sc_data_direction));
#else
scsi_dma_unmap(scmd);
#endif
}
else
dma_unmap_single(&(phba->dev->dev),MV_SCp(scmd)->bus_address,
mv_rq_bf_l(scmd),scsi_to_pci_dma_dir(scmd->sc_data_direction));
}
memset(sb,0,SCSI_SENSE_BUFFERSIZE);
scmd->result = (DRIVER_SENSE << 24) | SAM_STAT_CHECK_CONDITION;
switch(scmd->cmnd[14]) {
case ATA_CMD_CHK_POWER:
if(!(pDevice->Status & DEVICE_STATUS_SLEEP))
desc[5] = 0xff;
if(pDevice->Status & DEVICE_STATUS_STANDBY)
desc[5] = 0x0;
if((pDevice->Status & DEVICE_STATUS_IDLE))
desc[5] = 0xff;
break;
case ATA_CMD_STANDBYNOW1:
pDevice->Status |= DEVICE_STATUS_STANDBY;
break;
case ATA_CMD_IDLEIMMEDIATE:
pDevice->Status |= DEVICE_STATUS_IDLE;
break;
case ATA_CMD_SLEEP:
pDevice->Status |= DEVICE_STATUS_SLEEP;
break;
default:
break;
}
/* Sense Data is current and format is descriptor */
sb[0] = 0x72;
desc[0] = 0x09;
/* set length of additional sense data */
sb[7] = 14; // 8+14
desc[1] = 12;
desc[2] = 0x00;
desc[3] = 0; // error register
desc[13] = 0x50; // status register
if(scmd->cmnd[14] == ATA_CMD_SMART){
desc[9] = scmd->cmnd[10];
desc[10] = scmd->cmnd[11];
desc[11] = scmd->cmnd[12];
} else {
desc[12] = scmd->cmnd[13]; //NO_DATA
}
scmd->scsi_done(scmd);
}
#ifdef SUPPORT_ATA_SECURITY_CMD
static void mv_ata_16_complete_request(struct hba_extension * phba,
struct scsi_cmnd *scmd,PMV_Request pReq)
{
PDomain_Device pDevice = NULL;
MV_U8 portId, deviceId; /*, temp;*/
PCore_Driver_Extension pCore;
unsigned char *sb = scmd->sense_buffer;
unsigned char *desc = sb + 8;
pCore = (PCore_Driver_Extension)HBA_GetModuleExtension(phba, MODULE_CORE);
if ( pReq->Device_Id != VIRTUAL_DEVICE_ID )
{
portId = PATA_MapPortId(pReq->Device_Id);
deviceId = PATA_MapDeviceId(pReq->Device_Id);
if ( portId < MAX_PORT_NUMBER )
pDevice = &pCore->Ports[portId].Device[deviceId];
}
if (MV_SCp(scmd)->mapped) {
if (mv_use_sg(scmd)){
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 23)
pci_unmap_sg(phba->dev,mv_rq_bf(scmd),mv_use_sg(scmd),
scsi_to_pci_dma_dir(scmd->sc_data_direction));
#else
scsi_dma_unmap(scmd);
#endif
}
else
dma_unmap_single(&(phba->dev->dev),MV_SCp(scmd)->bus_address,
mv_rq_bf_l(scmd),scsi_to_pci_dma_dir(scmd->sc_data_direction));
}
memset(sb,0,SCSI_SENSE_BUFFERSIZE);
scmd->result = (DRIVER_SENSE << 24) | SAM_STAT_CHECK_CONDITION;
/* Sense Data is current and format is descriptor */
sb[0] = 0x72;
sb[1]=0x0;
desc[0] = 0x09;
/* set length of additional sense data */
sb[7] = 14; // 8+14
desc[1] = 12;
desc[2] = 0x00;
desc[3] = 0; // error register
desc[13] = 0x04; // status register
if(scmd->cmnd[14] == ATA_CMD_SMART){
desc[9] = scmd->cmnd[10];
desc[10] = scmd->cmnd[11];
desc[11] = scmd->cmnd[12];
} else {
desc[12] = scmd->cmnd[13]; //NO_DATA
}
switch(scmd->cmnd[14]) {
case ATA_CMD_SEC_UNLOCK:
case ATA_CMD_SEC_ERASE_UNIT:
if(pReq->Scsi_Status==REQ_STATUS_SUCCESS){
if(pDevice->Capacity & DEVICE_CAPACITY_SECURITY_SUPPORTED){
if(pDevice->Setting & DEVICE_SETTING_SECURITY_LOCKED){
MV_DPRINT(("securiy: unlocked\n"));
pDevice->Setting &= ~DEVICE_SETTING_SECURITY_LOCKED;
}
}
}
break;
case ATA_CMD_IDENTIFY_ATA:
sb[3]=0x1d;
break;
case ATA_CMD_SEC_PASSWORD:
case ATA_CMD_SEC_DISABLE_PASSWORD:
case ATA_CMD_SEC_ERASE_PRE:
default:
break;
}
switch(pReq->Scsi_Status) {
case REQ_STATUS_ABORT:
sb[1]=SCSI_SK_ABORTED_COMMAND;
desc[3]=0x04;
desc[13]=0x51;
break;
default:
break;
}
scmd->scsi_done(scmd);
}
#endif
void mv_clear_device_status(struct hba_extension * phba,PMV_Request pReq)
{
PDomain_Device pDevice = NULL;
MV_U8 portId, deviceId; /*, temp;*/
PCore_Driver_Extension pCore;
pCore = (PCore_Driver_Extension)HBA_GetModuleExtension(phba, MODULE_CORE);
if ( pReq->Device_Id != VIRTUAL_DEVICE_ID )
{
portId = PATA_MapPortId(pReq->Device_Id);
deviceId = PATA_MapDeviceId(pReq->Device_Id);
if ( portId < MAX_PORT_NUMBER )
pDevice = &pCore->Ports[portId].Device[deviceId];
pDevice->Status &= ~(DEVICE_STATUS_IDLE|DEVICE_STATUS_STANDBY);
}
return ;
}
#endif
/* This should be the _only_ os request exit point. */
static void hba_req_callback(MV_PVOID This, PMV_Request pReq)
{
struct hba_extension *phba = (struct hba_extension *)This;
struct scsi_cmnd *scmd = (struct scsi_cmnd *)pReq->Org_Req;
/* Return this request to OS. */
#ifdef SUPPORT_ATA_POWER_MANAGEMENT
if(is_ata_16_passthrough_for_pm(scmd) &&
pReq->Scsi_Status == REQ_STATUS_SUCCESS)
mv_pm_ata_16_complete_request(phba,scmd,pReq);
#endif
#ifdef SUPPORT_ATA_SECURITY_CMD
else if(scmd->cmnd[0]==ATA_16){
mv_ata_16_complete_request(phba,scmd,pReq);
}
#endif
#ifdef SUPPORT_ATA_POWER_MANAGEMENT
else{
mv_clear_device_status(phba,pReq);
#endif
mv_complete_request(phba, scmd, pReq);
#ifdef SUPPORT_ATA_POWER_MANAGEMENT
}
#endif
phba->Io_Count--;
res_free_req_to_pool(phba->req_pool, pReq);
}
static int scsi_cmd_to_req_conv(struct hba_extension *phba,
struct scsi_cmnd *scmd,
PMV_Request pReq)
{
/*
* Set three flags: CMD_FLAG_NON_DATA
* CMD_FLAG_DATA_IN
* CMD_FLAG_DMA
* currently data in/out all go thru DMA
*/
pReq->Cmd_Flag = 0;
switch (scmd->sc_data_direction) {
case DMA_NONE:
pReq->Cmd_Flag |= CMD_FLAG_NON_DATA;
break;
case DMA_FROM_DEVICE:
pReq->Cmd_Flag |= CMD_FLAG_DATA_IN;
case DMA_TO_DEVICE:
pReq->Cmd_Flag |= CMD_FLAG_DMA;
break;
case DMA_BIDIRECTIONAL :
MV_DBG(DMSG_SCSI, "unexpected DMA_BIDIRECTIONAL.\n"
);
break;
default:
break;
}
/* handling of specific cmds */
memset(pReq->Cdb, 0, MAX_CDB_SIZE);
switch (scmd->cmnd[0]){
#if 0
case MODE_SELECT:
pReq->Cdb[0] = MODE_SELECT_10;
pReq->Cdb[1] = scmd->cmnd[1];
pReq->Cdb[8] = scmd->cmnd[4];
break;
#endif
case READ_6:
pReq->Cdb[0] = READ_10;
pReq->Cdb[3] = scmd->cmnd[1]&0x1f;
pReq->Cdb[4] = scmd->cmnd[2];
pReq->Cdb[5] = scmd->cmnd[3];
pReq->Cdb[8] = scmd->cmnd[4];
pReq->Cdb[9] = scmd->cmnd[5];
break;
case WRITE_6:
pReq->Cdb[0] = WRITE_10;
pReq->Cdb[3] = scmd->cmnd[1]&0x1f;
pReq->Cdb[4] = scmd->cmnd[2];
pReq->Cdb[5] = scmd->cmnd[3];
pReq->Cdb[8] = scmd->cmnd[4];
pReq->Cdb[9] = scmd->cmnd[5];
break;
/*0xA1==SCSI_CMD_BLANK== ATA_12 */
case 0xA1:
if(IS_ATA_12_CMD(scmd))
pReq->Cmd_Flag |= CMD_FLAG_SMART_ATA_12;
else{
memcpy(pReq->Cdb, scmd->cmnd, MAX_CDB_SIZE);
break;
}
case ATA_16:
pReq->Cmd_Flag |= CMD_FLAG_SMART_ATA_16;
pReq->Cdb[0] = SCSI_CMD_MARVELL_SPECIFIC;
pReq->Cdb[1] = CDB_CORE_MODULE;
memcpy(&pReq->Cdb[3],&scmd->cmnd[3],13);
switch(scmd->cmnd[ (pReq->Cmd_Flag & CMD_FLAG_SMART_ATA_12) ?9 : 14])
{
#ifdef SUPPORT_ATA_POWER_MANAGEMENT
case 0x08:
pReq->Cdb[2] = CDB_CORE_RESET_DEVICE;
break;
case 0xE0:
pReq->Cdb[2] = CDB_CORE_ATA_STANDBY_IMMEDIATE;
break;
case 0xE1:
pReq->Cdb[2] = CDB_CORE_ATA_IDLE_IMMEDIATE;
break;
case 0xE2:
pReq->Cdb[2] = CDB_CORE_ATA_STANDBY;
break;
case 0xE3:
pReq->Cdb[2] = CDB_CORE_ATA_IDLE;
break;
case 0xE5:
pReq->Cdb[2] = CDB_CORE_ATA_CHECK_POWER_MODE;
break;
case 0xE6:
pReq->Cdb[2] = CDB_CORE_ATA_SLEEP;
break;
#endif
case 0xEC:
pReq->Cdb[2] = CDB_CORE_ATA_IDENTIFY;
break;
#ifdef SUPPORT_ATA_SMART
case ATA_IDENTIFY_PACKET_DEVICE:
pReq->Cdb[2] = CDB_CORE_ATA_IDENTIFY_PACKET_DEVICE;
break;
case ATA_SMART_CMD :
switch(scmd->cmnd[(pReq->Cmd_Flag & CMD_FLAG_SMART_ATA_12) ?3 : 4])
{
case ATA_SMART_ENABLE:
pReq->Cdb[2] = CDB_CORE_ENABLE_SMART;
break;
case ATA_SMART_DISABLE:
pReq->Cdb[2] = CDB_CORE_DISABLE_SMART;
break;
case ATA_SMART_STATUS:
pReq->Cdb[2] = CDB_CORE_SMART_RETURN_STATUS;
break;
case ATA_SMART_READ_VALUES:
pReq->Cdb[2] = CDB_CORE_ATA_SMART_READ_VALUES;
break;
case ATA_SMART_READ_THRESHOLDS:
pReq->Cdb[2] = CDB_CORE_ATA_SMART_READ_THRESHOLDS;
break;
case ATA_SMART_READ_LOG_SECTOR:
pReq->Cdb[2] = CDB_CORE_ATA_SMART_READ_LOG_SECTOR;
break;
case ATA_SMART_WRITE_LOG_SECTOR:
pReq->Cdb[2] = CDB_CORE_ATA_SMART_WRITE_LOG_SECTOR;
break;
case ATA_SMART_AUTO_OFFLINE:
pReq->Cdb[2] = CDB_CORE_ATA_SMART_AUTO_OFFLINE;
break;
case ATA_SMART_AUTOSAVE:
pReq->Cdb[2] = CDB_CORE_ATA_SMART_AUTOSAVE;
break;
case ATA_SMART_IMMEDIATE_OFFLINE:
pReq->Cdb[2] = CDB_CORE_ATA_SMART_IMMEDIATE_OFFLINE;
break;
default:
pReq->Scsi_Status =REQ_STATUS_INVALID_PARAMETER;
MV_PRINT("Unsupported ATA-12 or 16 subcommand =0x%x\n", \
scmd->cmnd[(pReq->Cmd_Flag & CMD_FLAG_SMART_ATA_12) ?3 : 4]);
return -1;
}
break;
case 0xef:
switch(scmd->cmnd[4]){
case 0x2:
pReq->Cdb[2]=CDB_CORE_ENABLE_WRITE_CACHE ;
break;
case 0x82:
pReq->Cdb[2]=CDB_CORE_DISABLE_WRITE_CACHE;
break;
default:
pReq->Scsi_Status =REQ_STATUS_INVALID_PARAMETER;
MV_PRINT("Enable/Disable Write Cache command error: parameter error:%d\n",scmd->cmnd[4]);
return -1;
}
break;
#endif /*#ifdef SUPPORT_ATA_SMART*/
#ifdef SUPPORT_ATA_SECURITY_CMD
case ATA_CMD_SEC_PASSWORD:
case ATA_CMD_SEC_UNLOCK:
if(0){
int i;
char *buf=NULL;
for(i=0;i<16;i++)
printk(" %d:%x ",i,scmd->cmnd[i]);
printk("\n");
buf=NULL;
buf=bio_data(scmd->request->bio);
if(buf){
printk("bio=");
for(i=0;i<16;i++)
printk(" %x ",buf[i]);
printk("\n");
} else
printk("bio is NULL\n");
}
case ATA_CMD_SEC_ERASE_PRE:
case ATA_CMD_SEC_ERASE_UNIT:
case ATA_CMD_SEC_FREEZE_LOCK:
case ATA_CMD_SEC_DISABLE_PASSWORD:
pReq->Cmd_Flag &= ~CMD_FLAG_SMART_ATA_16;
memcpy(&pReq->Cdb[0],&scmd->cmnd[0],16);
break;
#endif
default:
pReq->Scsi_Status =REQ_STATUS_INVALID_PARAMETER;
MV_PRINT("Unsupported ATA-12 or 16 Command=0x%x\n",\
scmd->cmnd[(pReq->Cmd_Flag & CMD_FLAG_SMART_ATA_12) ?9 : 14]);
return -1;
}
break;
default:
memcpy(pReq->Cdb, scmd->cmnd, MAX_CDB_SIZE);
break;
}
pReq->Data_Buffer = mv_rq_bf(scmd);
pReq->Data_Transfer_Length = mv_rq_bf_l(scmd);
pReq->Sense_Info_Buffer = scmd->sense_buffer;
pReq->Sense_Info_Buffer_Length = SCSI_SENSE_BUFFERSIZE;
SGTable_Init(&pReq->SG_Table, 0);
generate_sg_table(phba, scmd, &pReq->SG_Table);
pReq->LBA.value = 0;
pReq->Sector_Count = 0;
MV_SetLBAandSectorCount(pReq);
pReq->Req_Type = REQ_TYPE_OS;
pReq->Org_Req = scmd;
pReq->Tag = scmd->tag;
pReq->Scsi_Status = REQ_STATUS_PENDING;
pReq->Completion = hba_req_callback;
pReq->Cmd_Initiator = phba;
//pReq->Scsi_Status = REQ_STATUS_INVALID_REQUEST;
pReq->Device_Id = __MAKE_DEV_ID(mv_scmd_target(scmd),
mv_scmd_lun(scmd));
return 0;
}
static void hba_shutdown_req_cb(MV_PVOID this, PMV_Request req)
{
struct hba_extension *phba = (struct hba_extension *) this;
#ifdef SUPPORT_REQUEST_TIMER
if(req!=NULL)
{
MV_DBG(DMSG_HBA,"Shutdown HBA timer!\n");
hba_remove_timer_sync(req);
}
#endif
res_free_req_to_pool(phba->req_pool, req);
phba->Io_Count--;
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 11)
atomic_set(&phba->hba_sync, 0);
#else
complete(&phba->cmpl);
#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 11) */
}
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 11)
/* will wait for atomic value atomic to become zero until timed out */
/* return how much 'timeout' is left or 0 if already timed out */
int __hba_wait_for_atomic_timeout(atomic_t *atomic, unsigned long timeout)
{
unsigned intv = HZ/20;
while (timeout) {
if (0 == atomic_read(atomic))
break;
if (timeout < intv)
intv = timeout;
set_current_state(TASK_INTERRUPTIBLE);
timeout -= (intv - schedule_timeout(intv));
}
return timeout;
}
#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 11) */
#ifdef CACHE_MODULE_SUPPORT
static void _hba_send_shutdown_req(PHBA_Extension phba)
{
unsigned long flags;
PMV_Request pReq;
/*Send MV_REQUEST to do something.*/
pReq = res_get_req_from_pool(phba->req_pool);
if (NULL == pReq) {
MV_PRINT("cannot allocate memory for req.\n"
);
return;
}
pReq->Cmd_Initiator = phba;
pReq->Org_Req = NULL;
pReq->Completion = hba_shutdown_req_cb;
pReq->Req_Type = REQ_TYPE_OS;
pReq->Cmd_Flag = 0;
pReq->Cmd_Flag |= CMD_FLAG_NON_DATA;
pReq->Sense_Info_Buffer_Length = 0;
pReq->Data_Transfer_Length = 0;
pReq->Data_Buffer = NULL;
pReq->Sense_Info_Buffer = NULL;
pReq->LBA.value = 0;
pReq->Sector_Count = 0;
pReq->Scsi_Status = REQ_STATUS_SUCCESS;
SGTable_Init(&pReq->SG_Table, 0);
memset(pReq->Context, 0, sizeof(MV_PVOID) * MAX_POSSIBLE_MODULE_NUMBER);
MV_DPRINT(("send SHUTDOWN request to CACHE.\n"));
pReq->Cdb[0] = APICDB0_ADAPTER;
pReq->Cdb[1] = APICDB1_ADAPTER_POWER_STATE_CHANGE;
pReq->Cdb[2] = 0;
spin_lock_irqsave(&phba->desc->hba_desc->global_lock, flags);
phba->Io_Count++;
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 11)
atomic_set(&phba->hba_sync, 1);
#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 11) */
phba->desc->ops->module_sendrequest(phba->desc->extension, pReq);
spin_unlock_irqrestore(&phba->desc->hba_desc->global_lock, flags);
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 11)
__hba_wait_for_atomic_timeout(&phba->hba_sync, 10*HZ);
#else
wait_for_completion_timeout(&phba->cmpl, 10*HZ);
#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 11) */
}
#endif /* CACHE_MODULE_SUPPORT */
void hba_send_shutdown_req(struct hba_extension *phba)
{
unsigned long flags;
PMV_Request pReq;
#ifdef CACHE_MODULE_SUPPORT
_hba_send_shutdown_req(phba);
#endif
pReq = res_get_req_from_pool(phba->req_pool);
if (NULL == pReq) {
MV_PRINT("cannot allocate memory for req.\n");
return;
}
pReq->Cmd_Initiator = phba;
pReq->Org_Req = pReq;
pReq->Req_Type = REQ_TYPE_INTERNAL;
pReq->Scsi_Status = REQ_STATUS_INVALID_REQUEST;
pReq->Completion = hba_shutdown_req_cb;
#ifdef RAID_DRIVER
pReq->Cdb[0] = APICDB0_LD;
pReq->Cdb[1] = APICDB1_LD_SHUTDOWN;
#else
pReq->Device_Id = 0;
pReq->Cmd_Flag = 0;
pReq->Cmd_Flag |= CMD_FLAG_NON_DATA;
pReq->Sense_Info_Buffer_Length = 0;
pReq->Data_Transfer_Length = 0;
pReq->Data_Buffer = NULL;
pReq->Sense_Info_Buffer = NULL;
SGTable_Init(&pReq->SG_Table, 0);
pReq->Cdb[0] = SCSI_CMD_MARVELL_SPECIFIC;
pReq->Cdb[1] = CDB_CORE_MODULE;
pReq->Cdb[2] = CDB_CORE_SHUTDOWN;
pReq->LBA.value = 0;
pReq->Sector_Count = 0;
pReq->Scsi_Status = REQ_STATUS_PENDING;
#endif
spin_lock_irqsave(&phba->desc->hba_desc->global_lock, flags);
phba->Io_Count++;
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 11)
atomic_set(&phba->hba_sync, 1);
#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 11) */
phba->desc->ops->module_sendrequest(phba->desc->extension, pReq);
spin_unlock_irqrestore(&phba->desc->hba_desc->global_lock, flags);
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 11)
__hba_wait_for_atomic_timeout(&phba->hba_sync, 10*HZ);
#else
wait_for_completion_timeout(&phba->cmpl, 10*HZ);
#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 11) */
}
#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 7)
/*openSUSE 11.1 SLES 11 SLED 11*/
#if ((LINUX_VERSION_CODE == KERNEL_VERSION(2, 6, 27))&&(IS_OPENSUSE_SLED_SLES))
static enum blk_eh_timer_return mv_linux_timed_out(struct scsi_cmnd *cmd)
#elif LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 28)
static enum scsi_eh_timer_return mv_linux_timed_out(struct scsi_cmnd *cmd)
#else
static enum blk_eh_timer_return mv_linux_timed_out(struct scsi_cmnd *cmd)
#endif
{
MV_BOOLEAN ret = MV_TRUE;
#if ((LINUX_VERSION_CODE == KERNEL_VERSION(2, 6, 27))&&(IS_OPENSUSE_SLED_SLES))
return (ret)?BLK_EH_RESET_TIMER:BLK_EH_NOT_HANDLED;
#elif LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28)
return (ret)?EH_RESET_TIMER:EH_NOT_HANDLED;
#else
return (ret)?BLK_EH_RESET_TIMER:BLK_EH_NOT_HANDLED;
#endif
}
#endif /* LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 7) */
static inline struct mv_mod_desc *
__get_lowest_module(struct mv_adp_desc *hba_desc)
{
struct mv_mod_desc *p;
/* take a random module, and trace through its child */
p = list_entry(hba_desc->online_module_list.next,
struct mv_mod_desc,
mod_entry);
WARN_ON(NULL == p);
while (p) {
if (NULL == p->child)
break;
p = p->child;
}
return p;
}
static int mv_linux_queue_command(struct scsi_cmnd *scmd,
void (*done) (struct scsi_cmnd *))
{
struct Scsi_Host *host = mv_scmd_host(scmd);
struct hba_extension *hba = *((struct hba_extension * *) host->hostdata);
PMV_Request req;
unsigned long flags;
if (done == NULL) {
MV_PRINT( ": in queuecommand, done function can't be NULL\n");
return 0;
}
#if 1
MV_DBG(DMSG_SCSI_FREQ,
"mv_linux_queue_command %p (%d/%d/%d/%d \
Cdb=(%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x))\n",
scmd, host->host_no, mv_scmd_channel(scmd),
mv_scmd_target(scmd), mv_scmd_lun(scmd),
*(scmd->cmnd), *(scmd->cmnd+1),
*(scmd->cmnd+2), *(scmd->cmnd+3),
*(scmd->cmnd+4), *(scmd->cmnd+5),
*(scmd->cmnd+6), *(scmd->cmnd+7),
*(scmd->cmnd+8), *(scmd->cmnd+9),
*(scmd->cmnd+10), *(scmd->cmnd+11),
*(scmd->cmnd+12), *(scmd->cmnd+13),
*(scmd->cmnd+14),*(scmd->cmnd+15));
#endif
scmd->result = 0;
scmd->scsi_done = done;
MV_SCp(scmd)->bus_address = 0;
MV_SCp(scmd)->mapped = 0;
MV_SCp(scmd)->map_atomic = 0;
#ifdef COMMAND_ISSUE_WORKROUND
{
MV_U8 mv_core_check_is_reseeting(MV_PVOID core_ext);
struct mv_mod_desc *core_desc=__get_lowest_module(hba->desc->hba_desc);
if(mv_core_check_is_reseeting(core_desc->extension)){
//MV_DPRINT(("HOST is resetting, wait..\n"));
return SCSI_MLQUEUE_HOST_BUSY;
}
}
#endif
if (mv_scmd_channel(scmd)) {
scmd->result = DID_BAD_TARGET << 16;
goto done;
}
/*
* Get mv_request resource and translate the scsi_cmnd request
* to mv_request.
*/
req = res_get_req_from_pool(hba->req_pool);
if (req == NULL)
{
MV_DPRINT(("No sufficient request.\n"));
return SCSI_MLQUEUE_HOST_BUSY;
}
if (scsi_cmd_to_req_conv(hba, scmd, req)) {
struct scsi_cmnd *cmd = (struct scsi_cmnd *)req->Org_Req;
/*
* Even TranslateOSRequest failed,
* it still should set some of the variables to the MV_Request
* especially MV_Request.Org_Req and MV_Request.Scsi_Status;
*/
if(!cmd || req->Scsi_Status==REQ_STATUS_INVALID_PARAMETER){
res_free_req_to_pool(hba->req_pool, req);
//scmd->result = (DRIVER_INVALID | SUGGEST_ABORT) << 24;
scmd->result |= DID_ABORT << 16;
scmd->scsi_done(scmd);
return 0;
}
MV_DBG(DMSG_HBA,
"ERROR - Translation from OS Request failed.\n");
hba_req_callback(hba, req);
return 0;
}
spin_lock_irqsave(&hba->desc->hba_desc->global_lock, flags);
hba->Io_Count++;
if (hba->State != DRIVER_STATUS_STARTED) {
MV_ASSERT(0);
/*if ( hba->State==DRIVER_STATUS_IDLE )
{
hba->State = DRIVER_STATUS_STARTING;
Module_StartAll(module_manage, MODULE_CORE);
}*/
} else {
hba->desc->ops->module_sendrequest(hba->desc->extension, req);
}
spin_unlock_irqrestore(&hba->desc->hba_desc->global_lock, flags);
return 0;
done:
scmd->scsi_done(scmd);
return 0;
}
#if 0
static int mv_linux_abort(struct scsi_cmnd *cmd)
{
struct Scsi_Host *host;
struct hba_extension *phba;
int ret = FAILED;
MV_PRINT("__MV__ abort command %p.\n", cmd);
return ret;
}
#endif /* 0 */
#ifdef IOCTL_TEMPLATE
/****************************************************************
* Name: mv_ial_ht_ata_cmd
*
* Description: handles mv_sata ata IOCTL special drive command (HDIO_DRIVE_CMD)
*
* Parameters: scsidev - Device to which we are issuing command
* arg - User provided data for issuing command
*
* Returns: 0 on success, otherwise of failure.
*
****************************************************************/
static int mv_ial_ht_ata_cmd(struct scsi_device *scsidev, void __user *arg)
{
int rc = 0;
u8 scsi_cmd[MAX_COMMAND_SIZE];
u8 args[4] , *argbuf = NULL, *sensebuf = NULL;
int argsize = 0;
enum dma_data_direction data_dir;
int cmd_result;
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 14)
struct scsi_request *sreq;
#endif
if (arg == NULL)
return -EINVAL;
if (copy_from_user(args, arg, sizeof(args)))
return -EFAULT;
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 14)
sensebuf = kmalloc(SCSI_SENSE_BUFFERSIZE, GFP_NOIO);
if (sensebuf) {
memset(sensebuf, 0, SCSI_SENSE_BUFFERSIZE);
}
#else
sensebuf = kzalloc(SCSI_SENSE_BUFFERSIZE, GFP_NOIO);
#endif
if (!sensebuf)
return -ENOMEM;
memset(scsi_cmd, 0, sizeof(scsi_cmd));
if (args[3]) {
argsize = SECTOR_SIZE * args[3];
argbuf = kmalloc(argsize, GFP_KERNEL);
if (argbuf == NULL) {
rc = -ENOMEM;
goto error;
}
scsi_cmd[1] = (4 << 1); /* PIO Data-in */
scsi_cmd[2] = 0x0e; /* no off.line or cc, read from dev,
block count in sector count field */
data_dir = DMA_FROM_DEVICE;
} else {
scsi_cmd[1] = (3 << 1); /* Non-data */
scsi_cmd[2] = 0x20; /* cc but no off.line or data xfer */
data_dir = DMA_NONE;
}
scsi_cmd[0] = ATA_16;
scsi_cmd[4] = args[2];
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 27)
if (args[0] == WIN_SMART) { /* hack -- ide driver does this too... */
#else
if (args[0] == ATA_CMD_SMART) { /* hack -- ide driver does this too... */
#endif
scsi_cmd[6] = args[3];
scsi_cmd[8] = args[1];
scsi_cmd[10] = 0x4f;
scsi_cmd[12] = 0xc2;
} else {
scsi_cmd[6] = args[1];
}
scsi_cmd[14] = args[0];
/* Good values for timeout and retries? Values below
from scsi_ioctl_send_command() for default case... */
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 14)
sreq = scsi_allocate_request(scsidev, GFP_KERNEL);
if (!sreq) {
rc= -EINTR;
goto free_req;
}
sreq->sr_data_direction = data_dir;
scsi_wait_req(sreq, scsi_cmd, argbuf, argsize, (10*HZ), 5);
/*
* If there was an error condition, pass the info back to the user.
*/
cmd_result = sreq->sr_result;
sensebuf = sreq->sr_sense_buffer;
#elif LINUX_VERSION_CODE >=KERNEL_VERSION(2, 6, 29)
cmd_result = scsi_execute(scsidev, scsi_cmd, data_dir, argbuf, argsize,
sensebuf, (10*HZ), 5, 0,0);
#else
cmd_result = scsi_execute(scsidev, scsi_cmd, data_dir, argbuf, argsize,
sensebuf, (10*HZ), 5, 0);
#endif
if (driver_byte(cmd_result) == DRIVER_SENSE) {/* sense data available */
u8 *desc = sensebuf + 8;
cmd_result &= ~(0xFF<<24); /* DRIVER_SENSE is not an error */
/* If we set cc then ATA pass-through will cause a
* check condition even if no error. Filter that. */
if (cmd_result & SAM_STAT_CHECK_CONDITION) {
struct scsi_sense_hdr sshdr;
scsi_normalize_sense(sensebuf, SCSI_SENSE_BUFFERSIZE,
&sshdr);
if (sshdr.sense_key==0 &&
sshdr.asc==0 && sshdr.ascq==0)
cmd_result &= ~SAM_STAT_CHECK_CONDITION;
}
/* Send userspace a few ATA registers (same as drivers/ide) */
if (sensebuf[0] == 0x72 && /* format is "descriptor" */
desc[0] == 0x09 ) { /* code is "ATA Descriptor" */
args[0] = desc[13]; /* status */
args[1] = desc[3]; /* error */
args[2] = desc[5]; /* sector count (0:7) */
if (copy_to_user(arg, args, sizeof(args)))
rc = -EFAULT;
}
}
if (cmd_result) {
rc = -EIO;
goto free_req;
}
if ((argbuf) && copy_to_user(arg + sizeof(args), argbuf, argsize))
rc = -EFAULT;
free_req:
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 14)
scsi_release_request(sreq);
#endif
error:
if (sensebuf) kfree(sensebuf);
if (argbuf) kfree(argbuf);
return rc;
}
#ifdef SUPPORT_ATA_SECURITY_CMD
static int check_dma (__u8 ata_op)
{
switch (ata_op) {
case ATA_CMD_READ_DMA_EXT:
case ATA_CMD_READ_FPDMA_QUEUED:
case ATA_CMD_WRITE_DMA_EXT:
case ATA_CMD_WRITE_FPDMA_QUEUED:
case ATA_CMD_READ_DMA:
case ATA_CMD_WRITE_DMA:
return SG_DMA;
default:
return SG_PIO;
}
}
unsigned char excute_taskfile(struct scsi_device *dev,ide_task_request_t *req_task,u8
rw,char *argbuf,unsigned int buff_size)
{
int rc = 0;
u8 scsi_cmd[MAX_COMMAND_SIZE];
u8 *sensebuf = NULL;
int argsize=0;
enum dma_data_direction data_dir;
int cmd_result;
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 14)
struct scsi_request *sreq;
#endif
argsize=buff_size;
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 14)
sensebuf = kmalloc(SCSI_SENSE_BUFFERSIZE, GFP_NOIO);
if (sensebuf) {
memset(sensebuf, 0, SCSI_SENSE_BUFFERSIZE);
}
#else
sensebuf = kzalloc(SCSI_SENSE_BUFFERSIZE, GFP_NOIO);
#endif
if (!sensebuf)
return -ENOMEM;
memset(scsi_cmd, 0, sizeof(scsi_cmd));
data_dir = DMA_FROM_DEVICE; // need to fixed
scsi_cmd[0] = ATA_16;
scsi_cmd[13] = 0x40;
#if LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 24)
scsi_cmd[14] = ((task_struct_t *)(&req_task->io_ports))->command;
#else
scsi_cmd[14] = ((char *)(&req_task->io_ports))[7];
#endif
if(check_dma(scsi_cmd[14])){
scsi_cmd[1] = argbuf ? SG_ATA_PROTO_DMA : SG_ATA_PROTO_NON_DATA;
} else {
scsi_cmd[1] = argbuf ? (rw ? SG_ATA_PROTO_PIO_OUT : SG_ATA_PROTO_PIO_IN) : SG_ATA_PROTO_NON_DATA;
}
scsi_cmd[ 2] = SG_CDB2_CHECK_COND;
if (argbuf) {
scsi_cmd[2] |= SG_CDB2_TLEN_NSECT | SG_CDB2_TLEN_SECTORS;
scsi_cmd[2] |= rw ? SG_CDB2_TDIR_TO_DEV : SG_CDB2_TDIR_FROM_DEV;
}
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 14)
sreq = scsi_allocate_request(dev, GFP_KERNEL);
if (!sreq) {
rc= -EINTR;
goto free_req;
}
sreq->sr_data_direction = data_dir;
scsi_wait_req(sreq, scsi_cmd, argbuf, argsize, (10*HZ), 5);
/*
* If there was an error condition, pass the info back to the user.
*/
cmd_result = sreq->sr_result;
sensebuf = sreq->sr_sense_buffer;
#elif LINUX_VERSION_CODE >=KERNEL_VERSION(2, 6, 29)
cmd_result = scsi_execute(dev, scsi_cmd, data_dir, argbuf, argsize,
sensebuf, (10*HZ), 5, 0,0);
#else
cmd_result = scsi_execute(dev, scsi_cmd, data_dir, argbuf, argsize,
sensebuf, (10*HZ), 5, 0);
#endif
if (driver_byte(cmd_result) == DRIVER_SENSE) {/* sense data available */
u8 *desc = sensebuf + 8;
cmd_result &= ~(0xFF<<24); /* DRIVER_SENSE is not an error */
/* If we set cc then ATA pass-through will cause a
* check condition even if no error. Filter that. */
if (cmd_result & SAM_STAT_CHECK_CONDITION) {
struct scsi_sense_hdr sshdr;
scsi_normalize_sense(sensebuf, SCSI_SENSE_BUFFERSIZE,
&sshdr);
if (sshdr.sense_key==0 &&
sshdr.asc==0 && sshdr.ascq==0)
cmd_result &= ~SAM_STAT_CHECK_CONDITION;
}
}
if (cmd_result) {
rc = EIO;
MV_PRINT("EIO=%d\n",-EIO);
goto free_req;
}
#if 0
if ( copy_to_user(argbuf,sensebuf, argsize))
rc = -EFAULT;
#endif
free_req:
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 14)
scsi_release_request(sreq);
#endif
if (sensebuf) kfree(sensebuf);
return rc;
}
u8 mv_do_taskfile_ioctl(struct scsi_device *dev,void __user *arg){
ide_task_request_t *req_task=NULL;
char __user *buf = (char __user *)arg;
u8 *outbuf = NULL;
u8 *inbuf = NULL;
int err = 0;
int tasksize = sizeof(ide_task_request_t);
int taskin = 0;
int taskout = 0;
int rw = SG_READ;
req_task = kzalloc(tasksize, GFP_KERNEL);
if (req_task == NULL) return -ENOMEM;
if (copy_from_user(req_task, buf, tasksize)) {
kfree(req_task);
return -EFAULT;
}
switch (req_task->req_cmd) {
case TASKFILE_CMD_REQ_OUT:
case TASKFILE_CMD_REQ_RAW_OUT:
rw = SG_WRITE;
break;
case TASKFILE_CMD_REQ_IN:
break;
}
taskout = (int) req_task->out_size;
taskin = (int) req_task->in_size;
if (taskout) {
int outtotal = tasksize;
outbuf = kzalloc(taskout, GFP_KERNEL);
if (outbuf == NULL) {
err = -ENOMEM;
goto abort;
}
if (copy_from_user(outbuf, buf + outtotal, taskout)) {
err = -EFAULT;
goto abort;
}
}
if (taskin) {
int intotal = tasksize + taskout;
inbuf = kzalloc(taskin, GFP_KERNEL);
if (inbuf == NULL) {
err = -ENOMEM;
goto abort;
}
if (copy_from_user(inbuf, buf + intotal, taskin)) {
err = -EFAULT;
goto abort;
}
}
switch(req_task->data_phase) {
case TASKFILE_DPHASE_PIO_OUT:
err=excute_taskfile(dev,req_task,rw,outbuf,taskout);
default:
err = -EFAULT;
goto abort;
}
if (copy_to_user(buf, req_task, tasksize)) {
err = -EFAULT;
goto abort;
}
if (taskout) {
int outtotal = tasksize;
if (copy_to_user(buf + outtotal, outbuf, taskout)) {
err = -EFAULT;
goto abort;
}
}
if (taskin) {
int intotal = tasksize + taskout;
if (copy_to_user(buf + intotal, inbuf, taskin)) {
err = -EFAULT;
goto abort;
}
}
abort:
kfree(req_task);
kfree(outbuf);
kfree(inbuf);
return err;
}
#endif
/****************************************************************
* Name: mv_ial_ht_ioctl
*
* Description: mv_sata scsi ioctl
*
* Parameters: scsidev - Device to which we are issuing command
* cmd - ioctl command
* arg - User provided data for issuing command
*
* Returns: 0 on success, otherwise of failure.
*
****************************************************************/
static int mv_ial_ht_ioctl(struct scsi_device *scsidev, int cmd, void __user *arg)
{
int rc = -ENOTTY;
/* No idea how this happens.... */
if (!scsidev)
return -ENXIO;
if (arg == NULL)
return -EINVAL;
switch (cmd) {
case HDIO_DRIVE_CMD:
if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
return -EACCES;
rc = mv_ial_ht_ata_cmd(scsidev, arg);
break;
#ifdef SUPPORT_ATA_SECURITY_CMD
case HDIO_DRIVE_TASKFILE:
rc=mv_do_taskfile_ioctl(scsidev,arg);
break;
#endif
default:
rc = -ENOTTY;
}
return rc;
}
#endif
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 19)
static irqreturn_t mv_intr_handler(int irq, void *dev_id, struct pt_regs *regs)
#else
static irqreturn_t mv_intr_handler(int irq, void *dev_id)
#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 19) */
{
/* MV_FALSE should be equal to IRQ_NONE (0) */
irqreturn_t retval = MV_FALSE;
unsigned long flags;
struct hba_extension *hba = (struct hba_extension *) dev_id;
//MV_DBG(DMSG_FREQ, "__MV__ Enter intr handler.\n");
spin_lock_irqsave(&hba->desc->hba_desc->global_lock, flags);
retval = hba->desc->child->ops->module_service_isr(hba->desc->child->extension);
#ifdef SUPPORT_TASKLET
if(retval)
tasklet_schedule(&hba->mv_tasklet);
#endif
spin_unlock_irqrestore(&hba->desc->hba_desc->global_lock, flags);
//MV_DBG(DMSG_FREQ, "__MV__ Exit intr handler retval=0x%x.\n ",retval);
return IRQ_RETVAL(retval);
}
static int mv_linux_reset (struct scsi_cmnd *cmd)
{
MV_PRINT("__MV__ reset handler %p.\n", cmd);
return FAILED;
}
static struct scsi_host_template mv_driver_template = {
.module = THIS_MODULE,
.name = "Marvell Storage Controller",
.proc_name = mv_driver_name,
.proc_info = mv_linux_proc_info,
.queuecommand = mv_linux_queue_command,
#ifdef IOCTL_TEMPLATE
.ioctl = mv_ial_ht_ioctl,
#endif
#if 0
.eh_abort_handler = mv_linux_abort,
.eh_device_reset_handler = mv_linux_reset,
.eh_bus_reset_handler = mv_linux_reset,
#endif /* 0 */
.eh_host_reset_handler = mv_linux_reset,
#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 7) && \
LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 16)
.eh_timed_out = mv_linux_timed_out,
#endif
.can_queue = MV_MAX_REQUEST_DEPTH,
.this_id = MV_SHT_THIS_ID,
.max_sectors = MV_MAX_TRANSFER_SECTOR,
.sg_tablesize = MV_MAX_SG_ENTRY,
.cmd_per_lun = MV_MAX_REQUEST_PER_LUN,
.use_clustering = MV_SHT_USE_CLUSTERING,
.emulated = MV_SHT_EMULATED,
};
#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 15)
static struct scsi_transport_template mv_transport_template = {
.eh_timed_out = mv_linux_timed_out,
};
#endif /* LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 16) */
/* module management & hba module code */
extern struct mv_module_ops *mv_core_register_module(void);
extern struct mv_module_ops *mv_hba_register_module(void);
#ifdef RAID_DRIVER
extern struct mv_module_ops *mv_raid_register_module(void);
#else
static inline struct mv_module_ops *mv_raid_register_module(void)
{
return NULL;
}
#endif /* RAID_DRIVER */
#ifdef CACHE_MODULE_SUPPORT
extern struct mv_module_ops *mv_cache_register_module(void);
#else
static inline struct mv_module_ops *mv_cache_register_module(void)
{
return NULL;
}
#endif /* CACHE_DRIVER */
static LIST_HEAD(mv_online_adapter_list);
int __mv_get_adapter_count(void)
{
struct mv_adp_desc *p;
int i = 0;
list_for_each_entry(p, &mv_online_adapter_list, hba_entry)
i++;
return i;
}
inline struct mv_adp_desc *__dev_to_desc(struct pci_dev *dev)
{
struct mv_adp_desc *p;
list_for_each_entry(p, &mv_online_adapter_list, hba_entry)
if (p->dev == dev)
return p;
return NULL;
}
MV_PVOID *mv_get_hba_extension(struct mv_adp_desc *hba_desc)
{
struct mv_mod_desc *p;
list_for_each_entry(p, &hba_desc->online_module_list, mod_entry)
if (MODULE_HBA == p->module_id)
return p->extension;
return NULL;
}
static inline void __mv_release_hba(struct mv_adp_desc *hba_desc)
{
struct mv_mod_desc *mod_desc, *p;
list_for_each_entry_safe(mod_desc,
p,
&hba_desc->online_module_list,
mod_entry) {
list_del(&mod_desc->mod_entry);
vfree(mod_desc);
}
list_del(&hba_desc->hba_entry);
vfree(hba_desc);
}
static struct mv_adp_desc *mv_hba_init_modmm(struct pci_dev *dev)
{
struct mv_adp_desc *hba_desc;
hba_desc = vmalloc(sizeof(struct mv_adp_desc));
if (NULL == hba_desc) {
printk("Unable to get memory at hba init.\n");
return NULL;
}
memset(hba_desc, 0, sizeof(struct mv_adp_desc));
INIT_LIST_HEAD(&hba_desc->online_module_list);
hba_desc->dev = dev;
list_add(&hba_desc->hba_entry, &mv_online_adapter_list);
return hba_desc;
}
static void mv_hba_release_modmm(struct pci_dev *dev)
{
struct mv_adp_desc *hba_desc;
hba_desc = __dev_to_desc(dev);
if (hba_desc)
__mv_release_hba(hba_desc);
else
printk("Weired! dev %p unassociated with any desc.\n", dev);
}
static inline struct mv_mod_desc *__alloc_mod_desc(void)
{
struct mv_mod_desc *desc;
desc = vmalloc(sizeof(struct mv_mod_desc));
if (desc)
memset(desc, 0, sizeof(struct mv_mod_desc));
return desc;
}
static int register_online_modules(struct mv_adp_desc *hba_desc)
{
struct mv_mod_desc *mod_desc, *prev;
struct mv_module_ops *ops;
/*
* iterate through online_module_list manually , from the lowest(CORE)
* to the highest layer (HBA)
*/
hba_desc->running_mod_num = 0;
/* CORE */
ops = mv_core_register_module();
if (NULL == ops) {
printk("No core no life.\n");
return -1;
}
mod_desc = __alloc_mod_desc();
if (NULL == mod_desc)
goto disaster;
mod_desc->hba_desc = hba_desc;
mod_desc->ops = ops;
mod_desc->status = MV_MOD_REGISTERED;
mod_desc->module_id = MODULE_CORE;
mod_desc->child = NULL;
list_add(&mod_desc->mod_entry, &hba_desc->online_module_list);
hba_desc->running_mod_num++;
#ifdef ODIN_DRIVER
/* when running in non-RAID, both CACHE and RAID must be disabled */
if(!hba_desc->RunAsNonRAID)
{
#endif
#ifdef RAID_DRIVER
/* RAID */
ops = mv_raid_register_module();
if (ops) {
prev = mod_desc;
mod_desc = __alloc_mod_desc();
if (NULL == mod_desc)
goto disaster;
mod_desc->hba_desc = hba_desc;
mod_desc->ops = ops;
mod_desc->status = MV_MOD_REGISTERED;
mod_desc->module_id = MODULE_RAID;
mod_desc->child = prev;
prev->parent = mod_desc;
list_add(&mod_desc->mod_entry, &hba_desc->online_module_list);
hba_desc->running_mod_num++;
}
#endif
#ifdef CACHE_MODULE_SUPPORT
/* CACHE */
ops = mv_cache_register_module();
if (ops) {
prev = mod_desc;
mod_desc = __alloc_mod_desc();
if (NULL == mod_desc)
goto disaster;
mod_desc->hba_desc = hba_desc;
mod_desc->ops = ops;
mod_desc->status = MV_MOD_REGISTERED;
mod_desc->module_id = MODULE_CACHE;
mod_desc->child = prev;
prev->parent = mod_desc;
list_add(&mod_desc->mod_entry, &hba_desc->online_module_list);
hba_desc->running_mod_num++;
}
#endif
#ifdef ODIN_DRIVER
}
#endif
/* HBA */
prev = mod_desc;
mod_desc = __alloc_mod_desc();
if (NULL == mod_desc)
goto disaster;
mod_desc->ops = mv_hba_register_module();
if (NULL == mod_desc->ops) {
printk("No HBA no life.\n");
return -1;
}
mod_desc->hba_desc = hba_desc;
mod_desc->status = MV_MOD_REGISTERED;
mod_desc->module_id = MODULE_HBA;
mod_desc->child = prev;
mod_desc->parent = NULL;
prev->parent = mod_desc;
list_add(&mod_desc->mod_entry, &hba_desc->online_module_list);
hba_desc->running_mod_num++;
return 0;
disaster:
return -1;
}
static void __release_consistent_mem(struct mv_mod_res *mod_res,
struct pci_dev *dev)
{
dma_addr_t dma_addr;
MV_PHYSICAL_ADDR phy_addr;
phy_addr = mod_res->bus_addr;
dma_addr = (dma_addr_t) (phy_addr.parts.low |
((u64) phy_addr.parts.high << 32));
pci_free_consistent(dev,
mod_res->size,
mod_res->virt_addr,
dma_addr);
}
static int __alloc_consistent_mem(struct mv_mod_res *mod_res,
struct pci_dev *dev)
{
unsigned long size;
dma_addr_t dma_addr;
BUS_ADDRESS bus_addr;
MV_PHYSICAL_ADDR phy_addr;
size = mod_res->size;
WARN_ON(size != ROUNDING(size, 8));
size = ROUNDING(size, 8);
mod_res->virt_addr = (MV_PVOID) pci_alloc_consistent(dev,
size,
&dma_addr);
if (NULL == mod_res->virt_addr) {
MV_DBG(DMSG_HBA, "unable to alloc 0x%lx consistent mem.\n",
size);
return -1;
}
memset(mod_res->virt_addr, 0, size);
bus_addr = (BUS_ADDRESS) dma_addr;
phy_addr.parts.low = LO_BUSADDR(bus_addr);
phy_addr.parts.high = HI_BUSADDR(bus_addr);
mod_res->bus_addr = phy_addr;
return 0;
}
int HBA_GetResource(struct mv_mod_desc *mod_desc,
enum Resource_Type type,
MV_U32 size,
Assigned_Uncached_Memory *dma_res)
{
struct mv_mod_res *mod_res;
mod_res = vmalloc(sizeof(struct mv_mod_res));
if (NULL == mod_res) {
printk("unable to allocate memory for resource management.\n");
return -1;
}
memset(mod_res, 0, sizeof(struct mv_mod_res));
mod_res->size = size;
mod_res->type = type;
switch (type) {
case RESOURCE_UNCACHED_MEMORY :
if (__alloc_consistent_mem(mod_res, mod_desc->hba_desc->dev)) {
printk("unable to allocate 0x%x uncached mem.\n", size);
vfree(mod_res);
return -1;
}
list_add(&mod_res->res_entry, &mod_desc->res_list);
memset(mod_res->virt_addr, 0, size);
dma_res->Virtual_Address = mod_res->virt_addr;
dma_res->Physical_Address = mod_res->bus_addr;
dma_res->Byte_Size = size;
break;
case RESOURCE_CACHED_MEMORY :
default:
vfree(mod_res);
printk("unknown resource type %d.\n", type);
return -1;
}
return 0;
}
static void __release_resource(struct mv_adp_desc *hba_desc,
struct mv_mod_desc *mod_desc)
{
struct mv_mod_res *mod_res, *tmp;
list_for_each_entry_safe(mod_res,
tmp,
&mod_desc->res_list,
res_entry) {
switch (mod_res->type) {
case RESOURCE_UNCACHED_MEMORY :
__release_consistent_mem(mod_res, hba_desc->dev);
break;
case RESOURCE_CACHED_MEMORY :
vfree(mod_res->virt_addr);
break;
default:
MV_DBG(DMSG_HBA, "res type %d unknown.\n",
mod_res->type);
break;
}
list_del(&mod_res->res_entry);
vfree(mod_res);
}
}
static void __release_module_resource(struct mv_mod_desc *mod_desc)
{
__release_resource(mod_desc->hba_desc, mod_desc);
}
static int __alloc_module_resource(struct mv_mod_desc *mod_desc,
unsigned int max_io)
{
struct mv_mod_res *mod_res = NULL;
unsigned int size = 0;
/*
* alloc only cached mem at this stage, uncached mem will be alloc'ed
* during mod init.
*/
INIT_LIST_HEAD(&mod_desc->res_list);
mod_res = vmalloc(sizeof(struct mv_mod_res));
if (NULL == mod_res)
return -1;
memset(mod_res, 0, sizeof(sizeof(struct mv_mod_res)));
mod_desc->res_entry = 1;
size = mod_desc->ops->get_res_desc(RESOURCE_CACHED_MEMORY, max_io);
if (size) {
mod_res->virt_addr = vmalloc(size);
if (NULL == mod_res->virt_addr) {
vfree(mod_res);
return -1;
}
memset(mod_res->virt_addr, 0, size);
mod_res->type = RESOURCE_CACHED_MEMORY;
mod_res->size = size;
mod_desc->extension = mod_res->virt_addr;
mod_desc->extension_size = size;
list_add(&mod_res->res_entry, &mod_desc->res_list);
}
return 0;
}
static void mv_release_module_resource(struct mv_adp_desc *hba_desc)
{
struct mv_mod_desc *mod_desc;
list_for_each_entry(mod_desc, &hba_desc->online_module_list,
mod_entry) {
if (mod_desc->status == MV_MOD_INITED) {
__release_module_resource(mod_desc);
mod_desc->status = MV_MOD_REGISTERED;
}
}
}
static int mv_alloc_module_resource(struct mv_adp_desc *hba_desc)
{
struct mv_mod_desc *mod_desc;
int ret;
list_for_each_entry(mod_desc, &hba_desc->online_module_list,
mod_entry) {
ret = __alloc_module_resource(mod_desc, hba_desc->max_io);
if (ret)
goto err_out;
mod_desc->status = MV_MOD_INITED;
}
return 0;
err_out:
MV_DBG(DMSG_HBA, "error %d allocating resource for mod %d.\n",
ret, mod_desc->module_id);
list_for_each_entry(mod_desc, &hba_desc->online_module_list,
mod_entry) {
if (mod_desc->status == MV_MOD_INITED) {
__release_module_resource(mod_desc);
mod_desc->status = MV_MOD_REGISTERED;
}
}
return -1;
}
static inline struct mv_mod_desc *
__get_highest_module(struct mv_adp_desc *hba_desc)
{
struct mv_mod_desc *p;
/* take a random module, and trace through its parent */
p = list_entry(hba_desc->online_module_list.next,
struct mv_mod_desc,
mod_entry);
WARN_ON(NULL == p);
while (p) {
if (NULL == p->parent)
break;
p = p->parent;
}
return p;
}
static void __map_pci_addr(struct pci_dev *dev, MV_PVOID *addr_array)
{
int i;
unsigned long addr;
unsigned long range;
for (i = 0; i < MAX_BASE_ADDRESS; i++) {
addr = pci_resource_start(dev, i);
range = pci_resource_len(dev, i);
if (pci_resource_flags(dev, i) & IORESOURCE_MEM)
addr_array[i] =(MV_PVOID) ioremap(addr, range);
else if (pci_resource_flags(dev, i) & IORESOURCE_IO)
addr_array[i] = (MV_PVOID) ioport_map(addr, range);
MV_DBG(DMSG_HBA, "BAR %d : %p.\n",
i, addr_array[i]);
}
}
static void __unmap_pci_addr(struct pci_dev *dev, MV_PVOID *addr_array)
{
int i;
for (i = 0; i < MAX_BASE_ADDRESS; i++)
if (pci_resource_flags(dev, i) & IORESOURCE_MEM)
iounmap(addr_array[i]);
else if (pci_resource_flags(dev, i) & IORESOURCE_IO)
ioport_unmap(addr_array[i]);
}
int __mv_is_mod_all_started(struct mv_adp_desc *adp_desc)
{
struct mv_mod_desc *mod_desc;
mod_desc = __get_lowest_module(adp_desc);
while (mod_desc) {
if (MV_MOD_STARTED != mod_desc->status)
return 0;
mod_desc = mod_desc->parent;
}
return 1;
}
struct hba_extension *__mv_get_ext_from_adp_id(int id)
{
struct mv_adp_desc *p;
list_for_each_entry(p, &mv_online_adapter_list, hba_entry)
if (p->id == id)
return __get_highest_module(p)->extension;
return NULL;
}
int mv_hba_start(struct pci_dev *dev)
{
struct mv_adp_desc *hba_desc;
struct mv_mod_desc *mod_desc;
hba_desc = __dev_to_desc(dev);
BUG_ON(NULL == hba_desc);
#if 0
mod_desc = __get_lowest_module(hba_desc);
if (NULL == mod_desc)
return -1;
MV_DPRINT(("Start lowest module.\n"));
#ifdef THOR_DRIVER
spin_lock_irq(&hba_desc->global_lock);
#endif
mod_desc->ops->module_start(mod_desc->extension);
#ifdef THOR_DRIVER
spin_unlock_irq(&hba_desc->global_lock);
#endif
#endif
MV_DPRINT(("Start highest module.\n"));
mod_desc = __get_highest_module(hba_desc);
if (NULL == mod_desc)
return -1;
mod_desc->ops->module_start(mod_desc->extension);
return 0;
}
static void __hba_module_stop(struct mv_adp_desc *hba_desc)
{
struct mv_mod_desc *mod_desc;
mod_desc = __get_highest_module(hba_desc);
if (NULL == mod_desc)
return;
/* starting from highest module, unlike module_start */
while (mod_desc) {
if ((MV_MOD_STARTED == mod_desc->status)) {
mod_desc->ops->module_stop(mod_desc->extension);
mod_desc->status = MV_MOD_INITED;
}
mod_desc = mod_desc->child;
}
}
/* stop all HBAs if dev == NULL */
void mv_hba_stop(struct pci_dev *dev)
{
struct mv_adp_desc *hba_desc;
hba_wait_eh();
if (dev) {
hba_desc = __dev_to_desc(dev);
__hba_module_stop(hba_desc);
} else {
list_for_each_entry(hba_desc, &mv_online_adapter_list, hba_entry)
__hba_module_stop(hba_desc);
}
}
void mv_hba_release(struct pci_dev *dev)
{
struct mv_adp_desc *hba_desc;
hba_desc = __dev_to_desc(dev);
if (NULL != hba_desc) {
__unmap_pci_addr(hba_desc->dev, hba_desc->Base_Address);
mv_release_module_resource(hba_desc);
mv_hba_release_modmm(hba_desc->dev);
}
}
int mv_hba_init(struct pci_dev *dev, MV_U32 max_io)
{
struct mv_adp_desc *hba_desc;
struct mv_mod_desc *mod_desc;
int dbg_ret = 0;
hba_desc = mv_hba_init_modmm(dev);
if (NULL == hba_desc)
goto ext_err_init;
hba_desc->max_io = max_io;
hba_desc->id = __mv_get_adapter_count() - 1;
if (pci_read_config_byte(hba_desc->dev,
PCI_REVISION_ID,
&hba_desc->Revision_Id)) {
MV_PRINT("Failed to get hba's revision id.\n");
goto ext_err_pci;
}
hba_desc->vendor = dev->vendor;
hba_desc->device = dev->device;
hba_desc->subsystem_vendor = dev->subsystem_vendor;
hba_desc->subsystem_device = dev->subsystem_device;
__map_pci_addr(dev, hba_desc->Base_Address);
spin_lock_init(&hba_desc->lock);
spin_lock_init(&hba_desc->global_lock);
/* For Odin family, read PCIE configuration space register bit 31:25 [PAD_TEST] (offset=0x60) */
/* to identify different part */
#ifdef ODIN_DRIVER
if (hba_desc->device != DEVICE_ID_6480) {
MV_U32 padTest = 0;
pci_read_config_dword(dev, 0x60, &padTest);
hba_desc->device = SetDeviceID(padTest);
hba_desc->subsystem_device = hba_desc->device;
if (hba_desc->device == DEVICE_ID_6445)
hba_desc->RunAsNonRAID = MV_TRUE;
MV_DBG(DMSG_HBA, "controller device id 0x%x.\n",
hba_desc->device);
}
#endif
MV_DBG(DMSG_HBA, "HBA ext struct init'ed at %p.\n",
hba_desc);
if (register_online_modules(hba_desc))
goto ext_err_modmm;
if (mv_alloc_module_resource(hba_desc))
goto ext_err_modmm;
mod_desc = __get_lowest_module(hba_desc);
if (NULL == mod_desc)
goto ext_err_pci;
while (mod_desc) {
if (MV_MOD_INITED != mod_desc->status)
continue;
mod_desc->ops->module_initialize(mod_desc,
mod_desc->extension_size,
hba_desc->max_io);
/* there's no support for sibling module at the moment */
mod_desc = mod_desc->parent;
}
return 0;
ext_err_pci:
++dbg_ret;
mv_release_module_resource(hba_desc);
ext_err_modmm:
++dbg_ret;
mv_hba_release_modmm(dev);
ext_err_init:
++dbg_ret;
return dbg_ret;
}
static MV_U32 HBA_ModuleGetResourceQuota(enum Resource_Type type, MV_U16 maxIo)
{
MV_U32 size = 0;
if (type == RESOURCE_CACHED_MEMORY) {
/* Fixed memory */
size = OFFSET_OF(HBA_Extension, Memory_Pool);
size = ROUNDING(size, 8);
#ifdef SUPPORT_EVENT
size += sizeof(Driver_Event_Entry) * MAX_EVENTS;
MV_ASSERT(size == ROUNDING(size, 8));
#endif /* SUPPORT_EVENT */
}
return size;
}
#ifdef SUPPORT_TASKLET
MV_BOOLEAN Core_TaskletHandler(MV_PVOID This);
static void run_tasklet(PHBA_Extension phba)
{
struct mv_mod_desc *core_desc=__get_lowest_module(phba->desc->hba_desc);
unsigned long flags;
MV_PVOID pcore=core_desc->extension;
spin_lock_irqsave(&phba->desc->hba_desc->global_lock, flags);
Core_TaskletHandler(pcore);
spin_unlock_irqrestore(&phba->desc->hba_desc->global_lock, flags);
}
#endif
static void HBA_ModuleInitialize(MV_PVOID this,
MV_U32 size,
MV_U16 max_io)
{
struct mv_mod_desc *mod_desc=(struct mv_mod_desc *)this;
PHBA_Extension phba;
MV_PTR_INTEGER temp;
MV_U32 i;
MV_U32 sg_num;
#ifdef SUPPORT_EVENT
PDriver_Event_Entry pEvent = NULL;
#endif /* SUPPORT_EVENT */
phba = (PHBA_Extension) mod_desc->extension;
temp = (MV_PTR_INTEGER) phba->Memory_Pool;
WARN_ON(sizeof(MV_Request) != ROUNDING(sizeof(MV_Request), 8));
/*
* Initialize data structure however following variables have been
* set already.
* Device_Extension
* Is_Dump
*/
phba->State = DRIVER_STATUS_IDLE;
phba->Io_Count = 0;
phba->Max_Io = max_io;
phba->desc = mod_desc;
init_completion(&phba->cmpl);
temp = ROUNDING(((MV_PTR_INTEGER) temp), 8);
if (max_io > 1)
sg_num = MAX_SG_ENTRY;
else
sg_num = MAX_SG_ENTRY_REDUCED;
phba->req_pool = (MV_PVOID) res_reserve_req_pool(MODULE_HBA,
max_io,
sg_num);
BUG_ON(NULL == phba->req_pool);
#ifdef THOR_DRIVER
//spin_lock_init(&phba->lock);
init_timer(&phba->timer);
#endif
#ifdef SUPPORT_TASKLET
tasklet_init(&phba->mv_tasklet,
(void (*)(unsigned long))run_tasklet, (unsigned long)phba);
#endif
#ifdef SUPPORT_EVENT
INIT_LIST_HEAD(&phba->Stored_Events);
INIT_LIST_HEAD(&phba->Free_Events);
phba->Num_Stored_Events = 0;
phba->SequenceNumber = 0; /* Event sequence number */
MV_ASSERT(sizeof(Driver_Event_Entry) ==
ROUNDING(sizeof(Driver_Event_Entry), 8));
temp = ROUNDING(((MV_PTR_INTEGER) temp), 8);
for (i = 0; i < MAX_EVENTS; i++) {
pEvent = (PDriver_Event_Entry) temp;
list_add_tail(&pEvent->Queue_Pointer, &phba->Free_Events);
temp += sizeof(Driver_Event_Entry);
}
#endif /* SUPPORT_EVENT */
}
static void HBA_ModuleStart(MV_PVOID extension)
{
struct Scsi_Host *host = NULL;
struct hba_extension *hba;
int ret;
struct mv_adp_desc *adp_desc;
struct mv_mod_desc *core_desc;
hba = (struct hba_extension *) extension;
host = scsi_host_alloc(&mv_driver_template, sizeof(void *));
if (NULL == host) {
MV_PRINT("Unable to allocate a scsi host.\n" );
goto err_out;
}
*((MV_PVOID *) host->hostdata) = extension;
hba->host = host;
hba->dev = hba->desc->hba_desc->dev;
host->irq = hba->dev->irq;
host->max_id = MV_MAX_TARGET_NUMBER;
host->max_lun = MV_MAX_LUN_NUMBER;
host->max_channel = 0;
host->max_cmd_len = 16;
#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 15)
host->transportt = &mv_transport_template;
#endif /* LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 16) */
#ifdef USE_MSI
pci_enable_msi(hba->dev);
#endif /* USE_MSI */
MV_DBG(DMSG_KERN, "start install request_irq.\n");
#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 19)
ret = request_irq(hba->dev->irq, mv_intr_handler, IRQF_SHARED,
mv_driver_name, hba);
#else
ret = request_irq(hba->dev->irq, mv_intr_handler, SA_SHIRQ,
mv_driver_name, hba);
#endif /* LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 19) */
if (ret < 0) {
MV_PRINT("Error upon requesting IRQ %d.\n",
hba->dev->irq);
goto err_request_irq;
}
MV_DBG(DMSG_KERN, "request_irq has been installed.\n");
hba->desc->status = MV_MOD_STARTED;
/* To start CORE layer */
adp_desc = hba->desc->hba_desc;
core_desc = __get_lowest_module(adp_desc);
if (NULL == core_desc) {
goto err_wait_cmpl;
}
core_desc->ops->module_start(core_desc->extension);
HBA_ModuleStarted(hba->desc);
MV_DBG(DMSG_KERN, "wait_for_completion_timeout.....\n");
/* wait for MODULE(CORE,RAID,HBA) init */
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 11)
atomic_set(&hba->hba_sync, 1);
if (0 == __hba_wait_for_atomic_timeout(&hba->hba_sync, 30 * HZ))
goto err_wait_cmpl;
#else
if (0 == wait_for_completion_timeout(&hba->cmpl, 30 * HZ))
goto err_wait_cmpl;
#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 11) */
hba_house_keeper_run();
if (scsi_add_host(host, &hba->dev->dev))
goto err_wait_cmpl;
MV_DPRINT(("Start scsi_scan_host.\n"));
scsi_scan_host(host);
if (mv_register_chdev(hba))
printk("Unable to register character device interface.\n");
MV_DPRINT(("Finished HBA_ModuleStart.\n"));
return;
err_wait_cmpl:
printk("Timeout waiting for module start.\n");
free_irq(hba->dev->irq, hba);
err_request_irq:
scsi_host_put(host);
hba->host = NULL;
err_out:
return;
}
extern void hba_send_shutdown_req(PHBA_Extension phba);
static void HBA_ModuleShutdown(MV_PVOID extension)
{
PHBA_Extension hba = (PHBA_Extension) extension;
mv_unregister_chdev(hba);
if (DRIVER_STATUS_STARTED == hba->State) {
scsi_remove_host(hba->host);
scsi_host_put(hba->host);
hba->host = NULL;
hba_send_shutdown_req(hba);
while(hba->Io_Count != 0)
mdelay(1);
free_irq(hba->dev->irq, hba);
}
res_release_req_pool(hba->req_pool);
hba->State = DRIVER_STATUS_SHUTDOWN;
}
#ifdef SUPPORT_EVENT
static MV_BOOLEAN add_event(IN MV_PVOID extension,
IN MV_U32 eventID,
IN MV_U16 deviceID,
IN MV_U8 severityLevel,
IN MV_U8 param_cnt,
IN MV_PVOID params)
{
struct hba_extension * hba = (struct hba_extension *) extension;
PDriver_Event_Entry pEvent;
static MV_U32 sequenceNo = 1;
if (param_cnt > MAX_EVENT_PARAMS)
return MV_FALSE;
if (list_empty(&hba->Free_Events)) {
/* No free entry, we need to reuse the oldest entry from
* Stored_Events.
*/
MV_ASSERT(!list_empty(&hba->Stored_Events));
MV_ASSERT(hba->Num_Stored_Events == MAX_EVENTS);
pEvent = List_GetFirstEntry((&hba->Stored_Events), Driver_Event_Entry, Queue_Pointer);
}
else
{
pEvent = List_GetFirstEntry((&hba->Free_Events), Driver_Event_Entry, Queue_Pointer);
hba->Num_Stored_Events++;
MV_ASSERT(hba->Num_Stored_Events <= MAX_EVENTS);
}
pEvent->Event.AdapterID = hba->desc->hba_desc->id;
pEvent->Event.EventID = eventID;
pEvent->Event.SequenceNo = sequenceNo++;
pEvent->Event.Severity = severityLevel;
pEvent->Event.DeviceID = deviceID;
// pEvent->Event.Param_Cnt = param_cnt;
pEvent->Event.TimeStamp = ossw_get_time_in_sec();
if (param_cnt > 0 && params != NULL)
MV_CopyMemory( (MV_PVOID)pEvent->Event.Params, (MV_PVOID)params, param_cnt * 4 );
list_add_tail(&pEvent->Queue_Pointer, &hba->Stored_Events);
return MV_TRUE;
}
static void get_event(MV_PVOID This, PMV_Request pReq)
{
struct hba_extension * hba = (struct hba_extension *) This;
PEventRequest pEventReq = (PEventRequest)pReq->Data_Buffer;
PDriver_Event_Entry pfirst_event;
MV_U8 count = 0;
pEventReq->Count = 0;
if ( hba->Num_Stored_Events > 0 )
{
MV_DASSERT( !list_empty(&hba->Stored_Events) );
while (!list_empty(&hba->Stored_Events) &&
(count < MAX_EVENTS_RETURNED)) {
pfirst_event = List_GetFirstEntry((&hba->Stored_Events), Driver_Event_Entry, Queue_Pointer);
MV_CopyMemory(&pEventReq->Events[count],
&pfirst_event->Event,
sizeof(DriverEvent));
hba->Num_Stored_Events--;
list_add_tail(&pfirst_event->Queue_Pointer,
&hba->Free_Events );
count++;
}
pEventReq->Count = count;
}
pReq->Scsi_Status = REQ_STATUS_SUCCESS;
return;
}
#else /* SUPPORT_EVENT */
static inline MV_BOOLEAN add_event(IN MV_PVOID extension,
IN MV_U32 eventID,
IN MV_U16 deviceID,
IN MV_U8 severityLevel,
IN MV_U8 param_cnt,
IN MV_PVOID params) {}
static inline void get_event(MV_PVOID This, PMV_Request pReq) {}
#endif /* SUPPORT_EVENT */
void HBA_ModuleNotification(MV_PVOID This,
enum Module_Event event,
struct mod_notif_param *event_param)
{
/* "This" passed in is not hba extension, it is caller's extension */
/* has to find own extension like the implementation in HBA */
MV_PVOID hba = HBA_GetModuleExtension(This, MODULE_HBA);
MV_DPRINT(("Enter HBA_ModuleNotification event %x\n",event));
// MV_POKE();
switch (event) {
case EVENT_LOG_GENERATED:
add_event(hba,
event_param->event_id,
event_param->dev_id,
event_param->severity_lvl,
event_param->param_count,
event_param->p_param);
break;
case EVENT_DEVICE_REMOVAL:
case EVENT_DEVICE_ARRIVAL:
hba_msg_insert(hba,
event,
(event_param == NULL)?0:event_param->lo);
break;
case EVENT_HOT_PLUG:
hba_msg_insert(event_param->p_param,
event,
event_param->event_id);
break;
default:
break;
}
}
#if 1//def SUPPORT_SCSI_PASSTHROUGH
/* helper functions related to HBA_ModuleSendRequest */
static void mvGetAdapterInfo( MV_PVOID This, PMV_Request pReq )
{
PHBA_Extension hba = (PHBA_Extension)This;
struct mv_adp_desc *pHBA=hba->desc->hba_desc;
PAdapter_Info pAdInfo;
#ifdef ODIN_DRIVER
PCore_Driver_Extension pCore = (PCore_Driver_Extension)HBA_GetModuleExtension(This,MODULE_CORE);
#endif
/* initialize */
pAdInfo = (PAdapter_Info)pReq->Data_Buffer;
MV_ZeroMemory(pAdInfo, sizeof(Adapter_Info));
pAdInfo->DriverVersion.VerMajor = VER_MAJOR;
pAdInfo->DriverVersion.VerMinor = VER_MINOR;
pAdInfo->DriverVersion.VerOEM = VER_OEM;
pAdInfo->DriverVersion.VerBuild = VER_BUILD;
pAdInfo->SystemIOBusNumber = pHBA->Adapter_Bus_Number;
pAdInfo->SlotNumber = pHBA->Adapter_Device_Number;
pAdInfo->VenID = pHBA->vendor;
pAdInfo->DevID = pHBA->device;
pAdInfo->SubDevID = pHBA->subsystem_device;
pAdInfo->SubVenID = pHBA->subsystem_vendor;
pAdInfo->RevisionID = pHBA->Revision_Id;
if ( pHBA->device == DEVICE_ID_THORLITE_2S1P||pHBA->device == DEVICE_ID_THORLITE_2S1P_WITH_FLASH ){
pAdInfo->PortCount = 3;
}else if ( pHBA->device == DEVICE_ID_THORLITE_0S1P ){
pAdInfo->PortCount = 1;
}else if ( (pHBA->device == DEVICE_ID_6440) ||
(pHBA->device == DEVICE_ID_6445) ||
(pHBA->device == DEVICE_ID_6340) ){
pAdInfo->PortCount = 4;
}else if ( pHBA->device == DEVICE_ID_6480 ){
pAdInfo->PortCount = 8;
}else if ( pHBA->device == DEVICE_ID_6320 ){
pAdInfo->PortCount = 2;
}else {
pAdInfo->PortCount = 5;
}
// pAdInfo->MaxHD = pCore->PD_Count_Supported;
#ifdef SIMULATOR
pAdInfo->MaxHD = MAX_DEVICE_SUPPORTED_PERFORMANCE;
pAdInfo->MaxExpander = 0;
#elif defined(ODIN_DRIVER)
pAdInfo->MaxHD = pCore->PD_Count_Supported;
pAdInfo->MaxExpander = pCore->Expander_Count_Supported;
#else
pAdInfo->MaxHD = 8;
pAdInfo->MaxExpander = MAX_EXPANDER_SUPPORTED;
#endif
pAdInfo->MaxPM = MAX_PM_SUPPORTED; // 4 for now
#ifdef RAID_DRIVER
raid_capability(This, pAdInfo);
#endif /* RAID_DRIVER */
pReq->Scsi_Status = REQ_STATUS_SUCCESS;
}
#endif
static void HBA_ModuleSendRequest(MV_PVOID this, PMV_Request req)
{
PHBA_Extension phba = (PHBA_Extension) this;
switch (req->Cdb[0])
{
case APICDB0_ADAPTER:
if (req->Cdb[1] == APICDB1_ADAPTER_GETINFO)
mvGetAdapterInfo(phba, req);
else
req->Scsi_Status = REQ_STATUS_INVALID_REQUEST;
req->Completion(req->Cmd_Initiator, req);
break;
case APICDB0_EVENT:
if (req->Cdb[1] == APICDB1_EVENT_GETEVENT)
get_event(phba, req);
else
req->Scsi_Status = REQ_STATUS_INVALID_REQUEST;
req->Completion(req->Cmd_Initiator, req);
break;
default:
/* submit to child layer */
phba->desc->child->ops->module_sendrequest(
phba->desc->child->extension,
req);
break;
}
}
static struct mv_module_ops hba_module_interface = {
.module_id = MODULE_HBA,
.get_res_desc = HBA_ModuleGetResourceQuota,
.module_initialize = HBA_ModuleInitialize,
.module_start = HBA_ModuleStart,
.module_stop = HBA_ModuleShutdown,
.module_notification = HBA_ModuleNotification,
.module_sendrequest = HBA_ModuleSendRequest,
};
struct mv_module_ops *mv_hba_register_module(void)
{
return &hba_module_interface;
}