renegade-project/linux-next
2
0
Fork 0
mirror of https://github.com/edk2-porting/linux-next.git synced 2024-12-15 16:53:54 +08:00
Code

[SCSI] stex: use config struct for parameters of different controllers

Browse Source 
Use config struct (st_card_info) for parameters of different controllers

Signed-off-by: Ed Lin <ed.lin@promise.com>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
This commit is contained in:
Ed Lin 2009-03-31 17:30:31 -08:00 committed by James Bottomley
parent 99946f8141
commit 591a3a5f60
1 changed files with 125 additions and 76 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

201
drivers/scsi/stex.c
View File

@ -95,19 +95,8 @@ enum {
TASK_ATTRIBUTE_ORDERED = 0x2, TASK_ATTRIBUTE_ORDERED = 0x2,
TASK_ATTRIBUTE_ACA = 0x4, TASK_ATTRIBUTE_ACA = 0x4,
/* request count, etc. */
MU_MAX_REQUEST = 32,
/* one message wasted, use MU_MAX_REQUEST+1
to handle MU_MAX_REQUEST messages */
MU_REQ_COUNT = (MU_MAX_REQUEST + 1),
MU_STATUS_COUNT = (MU_MAX_REQUEST + 1),
STEX_CDB_LENGTH = 16, STEX_CDB_LENGTH = 16,
REQ_VARIABLE_LEN = 1024,
STATUS_VAR_LEN = 128, STATUS_VAR_LEN = 128,
ST_CAN_QUEUE = MU_MAX_REQUEST,
ST_CMD_PER_LUN = MU_MAX_REQUEST,
ST_MAX_SG = 32, ST_MAX_SG = 32,
/* sg flags */ /* sg flags */
@ -120,9 +109,8 @@ enum {
st_shasta = 0, st_shasta = 0,
st_vsc = 1, st_vsc = 1,
st_vsc1 = 2, st_yosemite = 2,
st_yosemite = 3, st_seq = 3,
st_seq = 4,
PASSTHRU_REQ_TYPE = 0x00000001, PASSTHRU_REQ_TYPE = 0x00000001,
PASSTHRU_REQ_NO_WAKEUP = 0x00000100, PASSTHRU_REQ_NO_WAKEUP = 0x00000100,
@ -196,7 +184,7 @@ struct req_msg {
u8 data_dir; u8 data_dir;
u8 payload_sz; /* payload size in 4-byte, not used */ u8 payload_sz; /* payload size in 4-byte, not used */
u8 cdb[STEX_CDB_LENGTH]; u8 cdb[STEX_CDB_LENGTH];
u8 variable[REQ_VARIABLE_LEN]; u32 variable[0];
}; };
struct status_msg { struct status_msg {
@ -252,12 +240,6 @@ struct st_drvver {
u32 reserved[3]; u32 reserved[3];
}; };
#define MU_REQ_BUFFER_SIZE (MU_REQ_COUNT * sizeof(struct req_msg))
#define MU_STATUS_BUFFER_SIZE (MU_STATUS_COUNT * sizeof(struct status_msg))
#define MU_BUFFER_SIZE (MU_REQ_BUFFER_SIZE + MU_STATUS_BUFFER_SIZE)
#define STEX_EXTRA_SIZE sizeof(struct st_frame)
#define STEX_BUFFER_SIZE (MU_BUFFER_SIZE + STEX_EXTRA_SIZE)
struct st_ccb { struct st_ccb {
struct req_msg *req; struct req_msg *req;
struct scsi_cmnd *cmd; struct scsi_cmnd *cmd;
@ -288,13 +270,26 @@ struct st_hba {
struct status_msg *status_buffer; struct status_msg *status_buffer;
void *copy_buffer; /* temp buffer for driver-handled commands */ void *copy_buffer; /* temp buffer for driver-handled commands */
struct st_ccb ccb[MU_MAX_REQUEST]; struct st_ccb *ccb;
struct st_ccb *wait_ccb; struct st_ccb *wait_ccb;
unsigned int mu_status; unsigned int mu_status;
unsigned int cardtype; unsigned int cardtype;
int msi_enabled; int msi_enabled;
int out_req_cnt; int out_req_cnt;
u32 extra_offset;
u16 rq_count;
u16 rq_size;
u16 sts_count;
};
struct st_card_info {
unsigned int max_id;
unsigned int max_lun;
unsigned int max_channel;
u16 rq_count;
u16 rq_size;
u16 sts_count;
}; };
static int msi; static int msi;
@ -331,7 +326,7 @@ static struct status_msg *stex_get_status(struct st_hba *hba)
struct status_msg *status = hba->status_buffer + hba->status_tail; struct status_msg *status = hba->status_buffer + hba->status_tail;
++hba->status_tail; ++hba->status_tail;
hba->status_tail %= MU_STATUS_COUNT; hba->status_tail %= hba->sts_count+1;
return status; return status;
} }
@ -349,11 +344,10 @@ static void stex_invalid_field(struct scsi_cmnd *cmd,
static struct req_msg *stex_alloc_req(struct st_hba *hba) static struct req_msg *stex_alloc_req(struct st_hba *hba)
{ {
struct req_msg *req = ((struct req_msg *)hba->dma_mem) + struct req_msg *req = hba->dma_mem + hba->req_head * hba->rq_size;
hba->req_head;
++hba->req_head; ++hba->req_head;
hba->req_head %= MU_REQ_COUNT; hba->req_head %= hba->rq_count+1;
return req; return req;
} }
@ -653,7 +647,7 @@ static void stex_mu_intr(struct st_hba *hba, u32 doorbell)
/* status payloads */ /* status payloads */
hba->status_head = readl(base + OMR1); hba->status_head = readl(base + OMR1);
if (unlikely(hba->status_head >= MU_STATUS_COUNT)) { if (unlikely(hba->status_head > hba->sts_count)) {
printk(KERN_WARNING DRV_NAME "(%s): invalid status head\n", printk(KERN_WARNING DRV_NAME "(%s): invalid status head\n",
pci_name(hba->pdev)); pci_name(hba->pdev));
return; return;
@ -789,19 +783,19 @@ static int stex_handshake(struct st_hba *hba)
h = (struct handshake_frame *)hba->status_buffer; h = (struct handshake_frame *)hba->status_buffer;
h->rb_phy = cpu_to_le64(hba->dma_handle); h->rb_phy = cpu_to_le64(hba->dma_handle);
h->req_sz = cpu_to_le16(sizeof(struct req_msg)); h->req_sz = cpu_to_le16(hba->rq_size);
h->req_cnt = cpu_to_le16(MU_REQ_COUNT); h->req_cnt = cpu_to_le16(hba->rq_count+1);
h->status_sz = cpu_to_le16(sizeof(struct status_msg)); h->status_sz = cpu_to_le16(sizeof(struct status_msg));
h->status_cnt = cpu_to_le16(MU_STATUS_COUNT); h->status_cnt = cpu_to_le16(hba->sts_count+1);
stex_gettime(&h->hosttime); stex_gettime(&h->hosttime);
h->partner_type = HMU_PARTNER_TYPE; h->partner_type = HMU_PARTNER_TYPE;
if (hba->dma_size > STEX_BUFFER_SIZE) { if (hba->extra_offset) {
h->extra_offset = cpu_to_le32(STEX_BUFFER_SIZE); h->extra_offset = cpu_to_le32(hba->extra_offset);
h->extra_size = cpu_to_le32(ST_ADDITIONAL_MEM); h->extra_size = cpu_to_le32(ST_ADDITIONAL_MEM);
} else } else
h->extra_offset = h->extra_size = 0; h->extra_offset = h->extra_size = 0;
status_phys = hba->dma_handle + MU_REQ_BUFFER_SIZE; status_phys = hba->dma_handle + (hba->rq_count+1) * hba->rq_size;
writel(status_phys, base + IMR0); writel(status_phys, base + IMR0);
readl(base + IMR0); readl(base + IMR0);
writel((status_phys >> 16) >> 16, base + IMR1); writel((status_phys >> 16) >> 16, base + IMR1);
@ -1026,10 +1020,72 @@ static struct scsi_host_template driver_template = {
.slave_destroy = stex_slave_destroy, .slave_destroy = stex_slave_destroy,
.eh_abort_handler = stex_abort, .eh_abort_handler = stex_abort,
.eh_host_reset_handler = stex_reset, .eh_host_reset_handler = stex_reset,
.can_queue = ST_CAN_QUEUE,
.this_id = -1, .this_id = -1,
.sg_tablesize = ST_MAX_SG, .sg_tablesize = ST_MAX_SG,
.cmd_per_lun = ST_CMD_PER_LUN, };
static struct pci_device_id stex_pci_tbl[] = {
/* st_shasta */
{ 0x105a, 0x8350, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
st_shasta }, /* SuperTrak EX8350/8300/16350/16300 */
{ 0x105a, 0xc350, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
st_shasta }, /* SuperTrak EX12350 */
{ 0x105a, 0x4302, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
st_shasta }, /* SuperTrak EX4350 */
{ 0x105a, 0xe350, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
st_shasta }, /* SuperTrak EX24350 */
/* st_vsc */
{ 0x105a, 0x7250, PCI_ANY_ID, PCI_ANY_ID, 0, 0, st_vsc },
/* st_yosemite */
{ 0x105a, 0x8650, PCI_ANY_ID, PCI_ANY_ID, 0, 0, st_yosemite },
/* st_seq */
{ 0x105a, 0x3360, PCI_ANY_ID, PCI_ANY_ID, 0, 0, st_seq },
{ } /* terminate list */
};
static struct st_card_info stex_card_info[] = {
/* st_shasta */
{
.max_id = 17,
.max_lun = 8,
.max_channel = 0,
.rq_count = 32,
.rq_size = 1048,
.sts_count = 32,
},
/* st_vsc */
{
.max_id = 129,
.max_lun = 1,
.max_channel = 0,
.rq_count = 32,
.rq_size = 1048,
.sts_count = 32,
},
/* st_yosemite */
{
.max_id = 2,
.max_lun = 256,
.max_channel = 0,
.rq_count = 256,
.rq_size = 1048,
.sts_count = 256,
},
/* st_seq */
{
.max_id = 129,
.max_lun = 1,
.max_channel = 0,
.rq_count = 32,
.rq_size = 1048,
.sts_count = 32,
},
}; };
static int stex_set_dma_mask(struct pci_dev * pdev) static int stex_set_dma_mask(struct pci_dev * pdev)
@ -1084,6 +1140,8 @@ stex_probe(struct pci_dev *pdev, const struct pci_device_id *id)
{ {
struct st_hba *hba; struct st_hba *hba;
struct Scsi_Host *host; struct Scsi_Host *host;
const struct st_card_info *ci = NULL;
u32 sts_offset, cp_offset;
int err; int err;
err = pci_enable_device(pdev); err = pci_enable_device(pdev);
@ -1127,10 +1185,15 @@ stex_probe(struct pci_dev *pdev, const struct pci_device_id *id)
} }
hba->cardtype = (unsigned int) id->driver_data; hba->cardtype = (unsigned int) id->driver_data;
if (hba->cardtype == st_vsc && (pdev->subsystem_device & 1)) ci = &stex_card_info[hba->cardtype];
hba->cardtype = st_vsc1; sts_offset = (ci->rq_count+1) * ci->rq_size;
hba->dma_size = (hba->cardtype == st_vsc1 || hba->cardtype == st_seq) ? cp_offset = sts_offset + (ci->sts_count+1) * sizeof(struct status_msg);
(STEX_BUFFER_SIZE + ST_ADDITIONAL_MEM) : (STEX_BUFFER_SIZE); hba->dma_size = cp_offset + sizeof(struct st_frame);
if (hba->cardtype == st_seq ||
(hba->cardtype == st_vsc && (pdev->subsystem_device & 1))) {
hba->extra_offset = hba->dma_size;
hba->dma_size += ST_ADDITIONAL_MEM;
}
hba->dma_mem = dma_alloc_coherent(&pdev->dev, hba->dma_mem = dma_alloc_coherent(&pdev->dev,
hba->dma_size, &hba->dma_handle, GFP_KERNEL); hba->dma_size, &hba->dma_handle, GFP_KERNEL);
if (!hba->dma_mem) { if (!hba->dma_mem) {
@ -1140,23 +1203,26 @@ stex_probe(struct pci_dev *pdev, const struct pci_device_id *id)
goto out_iounmap; goto out_iounmap;
} }
hba->status_buffer = hba->ccb = kcalloc(ci->rq_count, sizeof(struct st_ccb), GFP_KERNEL);
(struct status_msg *)(hba->dma_mem + MU_REQ_BUFFER_SIZE); if (!hba->ccb) {
hba->copy_buffer = hba->dma_mem + MU_BUFFER_SIZE; err = -ENOMEM;
printk(KERN_ERR DRV_NAME "(%s): ccb alloc failed\n",
pci_name(pdev));
goto out_pci_free;
}
hba->status_buffer = (struct status_msg *)(hba->dma_mem + sts_offset);
hba->copy_buffer = hba->dma_mem + cp_offset;
hba->rq_count = ci->rq_count;
hba->rq_size = ci->rq_size;
hba->sts_count = ci->sts_count;
hba->mu_status = MU_STATE_STARTING; hba->mu_status = MU_STATE_STARTING;
if (hba->cardtype == st_shasta) { host->can_queue = ci->rq_count;
host->max_lun = 8; host->cmd_per_lun = ci->rq_count;
host->max_id = 16 + 1; host->max_id = ci->max_id;
} else if (hba->cardtype == st_yosemite) { host->max_lun = ci->max_lun;
host->max_lun = 256; host->max_channel = ci->max_channel;
host->max_id = 1 + 1;
} else {
/* st_vsc , st_vsc1 and st_seq */
host->max_lun = 1;
host->max_id = 128 + 1;
}
host->max_channel = 0;
host->unique_id = host->host_no; host->unique_id = host->host_no;
host->max_cmd_len = STEX_CDB_LENGTH; host->max_cmd_len = STEX_CDB_LENGTH;
@ -1167,7 +1233,7 @@ stex_probe(struct pci_dev *pdev, const struct pci_device_id *id)
if (err) { if (err) {
printk(KERN_ERR DRV_NAME "(%s): request irq failed\n", printk(KERN_ERR DRV_NAME "(%s): request irq failed\n",
pci_name(pdev)); pci_name(pdev));
goto out_pci_free; goto out_ccb_free;
} }
err = stex_handshake(hba); err = stex_handshake(hba);
@ -1196,6 +1262,8 @@ stex_probe(struct pci_dev *pdev, const struct pci_device_id *id)
out_free_irq: out_free_irq:
stex_free_irq(hba); stex_free_irq(hba);
out_ccb_free:
kfree(hba->ccb);
out_pci_free: out_pci_free:
dma_free_coherent(&pdev->dev, hba->dma_size, dma_free_coherent(&pdev->dev, hba->dma_size,
hba->dma_mem, hba->dma_handle); hba->dma_mem, hba->dma_handle);
@ -1260,6 +1328,8 @@ static void stex_hba_free(struct st_hba *hba)
pci_release_regions(hba->pdev); pci_release_regions(hba->pdev);
kfree(hba->ccb);
dma_free_coherent(&hba->pdev->dev, hba->dma_size, dma_free_coherent(&hba->pdev->dev, hba->dma_size,
hba->dma_mem, hba->dma_handle); hba->dma_mem, hba->dma_handle);
} }
@ -1288,27 +1358,6 @@ static void stex_shutdown(struct pci_dev *pdev)
stex_hba_stop(hba); stex_hba_stop(hba);
} }
static struct pci_device_id stex_pci_tbl[] = {
/* st_shasta */
{ 0x105a, 0x8350, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
st_shasta }, /* SuperTrak EX8350/8300/16350/16300 */
{ 0x105a, 0xc350, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
st_shasta }, /* SuperTrak EX12350 */
{ 0x105a, 0x4302, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
st_shasta }, /* SuperTrak EX4350 */
{ 0x105a, 0xe350, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
st_shasta }, /* SuperTrak EX24350 */
/* st_vsc */
{ 0x105a, 0x7250, PCI_ANY_ID, PCI_ANY_ID, 0, 0, st_vsc },
/* st_yosemite */
{ 0x105a, 0x8650, PCI_ANY_ID, PCI_ANY_ID, 0, 0, st_yosemite },
/* st_seq */
{ 0x105a, 0x3360, PCI_ANY_ID, PCI_ANY_ID, 0, 0, st_seq },
{ } /* terminate list */
};
MODULE_DEVICE_TABLE(pci, stex_pci_tbl); MODULE_DEVICE_TABLE(pci, stex_pci_tbl);
static struct pci_driver stex_pci_driver = { static struct pci_driver stex_pci_driver = {