FEX-Emu/linux
1
0
Fork 0
mirror of https://github.com/FEX-Emu/linux.git synced 2024-12-16 14:02:10 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

[SCSI] qla2xxx: Add OS initialization codes for ISP24xx recognition.

Browse Source 
Add OS initialization codes for ISP24xx recognition.

Signed-off-by: Andrew Vasquez <andrew.vasquez@qlogic.com>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
This commit is contained in:
Andrew Vasquez 2005-07-06 10:31:47 -07:00 committed by James Bottomley
parent 0107109ed6
commit fca2970371
4 changed files with 349 additions and 94 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
drivers/scsi/qla2xxx/Makefile
View File

@ -1,4 +1,6 @@
EXTRA_CFLAGS += -DUNIQUE_FW_NAME
CONFIG_SCSI_QLA24XX=m
EXTRA_CFLAGS += -DCONFIG_SCSI_QLA24XX -DCONFIG_SCSI_QLA24XX_MODULE
qla2xxx-y := qla_os.o qla_init.o qla_mbx.o qla_iocb.o qla_isr.o qla_gs.o \
qla_dbg.o qla_sup.o qla_rscn.o qla_attr.o
@ -14,3 +16,4 @@ obj-$(CONFIG_SCSI_QLA22XX) += qla2xxx.o qla2200.o
obj-$(CONFIG_SCSI_QLA2300) += qla2xxx.o qla2300.o
obj-$(CONFIG_SCSI_QLA2322) += qla2xxx.o qla2322.o
obj-$(CONFIG_SCSI_QLA6312) += qla2xxx.o qla6312.o
obj-$(CONFIG_SCSI_QLA24XX) += qla2xxx.o

22
drivers/scsi/qla2xxx/qla_attr.c
View File

@ -63,23 +63,29 @@ qla2x00_sysfs_write_fw_dump(struct kobject *kobj, char *buf, loff_t off,
ha->host_no);
vfree(ha->fw_dump_buffer);
free_pages((unsigned long)ha->fw_dump,
ha->fw_dump_order);
if (!IS_QLA24XX(ha) && !IS_QLA25XX(ha))
free_pages((unsigned long)ha->fw_dump,
ha->fw_dump_order);
ha->fw_dump_reading = 0;
ha->fw_dump_buffer = NULL;
ha->fw_dump = NULL;
ha->fw_dumped = 0;
}
break;
case 1:
if (ha->fw_dump != NULL && !ha->fw_dump_reading) {
if ((ha->fw_dump || ha->fw_dumped) && !ha->fw_dump_reading) {
ha->fw_dump_reading = 1;
dump_size = FW_DUMP_SIZE_1M;
if (ha->fw_memory_size < 0x20000)
dump_size = FW_DUMP_SIZE_128K;
else if (ha->fw_memory_size < 0x80000)
dump_size = FW_DUMP_SIZE_512K;
if (IS_QLA24XX(ha) || IS_QLA25XX(ha))
dump_size = FW_DUMP_SIZE_24XX;
else {
dump_size = FW_DUMP_SIZE_1M;
if (ha->fw_memory_size < 0x20000)
dump_size = FW_DUMP_SIZE_128K;
else if (ha->fw_memory_size < 0x80000)
dump_size = FW_DUMP_SIZE_512K;
}
ha->fw_dump_buffer = (char *)vmalloc(dump_size);
if (ha->fw_dump_buffer == NULL) {
qla_printk(KERN_WARNING, ha,

3
drivers/scsi/qla2xxx/qla_def.h
View File

@ -1989,7 +1989,8 @@ struct qla_board_info {
char isp_name[8];
struct qla_fw_info *fw_info;
char *fw_fname;;
char *fw_fname;
struct scsi_host_template *sht;
};
/* Return data from MBC_GET_ID_LIST call. */

415
drivers/scsi/qla2xxx/qla_os.c
View File

@ -79,6 +79,11 @@ module_param(ql2xloginretrycount, int, S_IRUGO|S_IRUSR);
MODULE_PARM_DESC(ql2xloginretrycount,
"Specify an alternate value for the NVRAM login retry count.");
int ql2xfwloadbin;
module_param(ql2xfwloadbin, int, S_IRUGO|S_IRUSR);
MODULE_PARM_DESC(ql2xfwloadbin,
"Load ISP2xxx firmware image via hotplug.");
static void qla2x00_free_device(scsi_qla_host_t *);
static void qla2x00_config_dma_addressing(scsi_qla_host_t *ha);
@ -91,6 +96,8 @@ static int qla2xxx_slave_alloc(struct scsi_device *);
static void qla2xxx_slave_destroy(struct scsi_device *);
static int qla2x00_queuecommand(struct scsi_cmnd *cmd,
void (*fn)(struct scsi_cmnd *));
static int qla24xx_queuecommand(struct scsi_cmnd *cmd,
void (*fn)(struct scsi_cmnd *));
static int qla2xxx_eh_abort(struct scsi_cmnd *);
static int qla2xxx_eh_device_reset(struct scsi_cmnd *);
static int qla2xxx_eh_bus_reset(struct scsi_cmnd *);
@ -124,6 +131,28 @@ static struct scsi_host_template qla2x00_driver_template = {
.max_sectors = 0xFFFF,
};
static struct scsi_host_template qla24xx_driver_template = {
.module = THIS_MODULE,
.name = "qla2xxx",
.queuecommand = qla24xx_queuecommand,
.eh_abort_handler = qla2xxx_eh_abort,
.eh_device_reset_handler = qla2xxx_eh_device_reset,
.eh_bus_reset_handler = qla2xxx_eh_bus_reset,
.eh_host_reset_handler = qla2xxx_eh_host_reset,
.slave_configure = qla2xxx_slave_configure,
.slave_alloc = qla2xxx_slave_alloc,
.slave_destroy = qla2xxx_slave_destroy,
.this_id = -1,
.cmd_per_lun = 3,
.use_clustering = ENABLE_CLUSTERING,
.sg_tablesize = SG_ALL,
.max_sectors = 0xFFFF,
};
static struct scsi_transport_template *qla2xxx_transport_template = NULL;
/* TODO Convert to inlines
@ -171,7 +200,6 @@ static uint8_t qla2x00_mem_alloc(scsi_qla_host_t *);
static void qla2x00_mem_free(scsi_qla_host_t *ha);
static int qla2x00_allocate_sp_pool( scsi_qla_host_t *ha);
static void qla2x00_free_sp_pool(scsi_qla_host_t *ha);
static srb_t *qla2x00_get_new_sp(scsi_qla_host_t *);
static void qla2x00_sp_free_dma(scsi_qla_host_t *, srb_t *);
void qla2x00_sp_compl(scsi_qla_host_t *ha, srb_t *);
@ -200,6 +228,54 @@ qla2x00_pci_info_str(struct scsi_qla_host *ha, char *str)
return (str);
}
static char *
qla24xx_pci_info_str(struct scsi_qla_host *ha, char *str)
{
static char *pci_bus_modes[] = { "33", "66", "100", "133", };
uint32_t pci_bus;
int pcie_reg;
pcie_reg = pci_find_capability(ha->pdev, PCI_CAP_ID_EXP);
if (pcie_reg) {
char lwstr[6];
uint16_t pcie_lstat, lspeed, lwidth;
pcie_reg += 0x12;
pci_read_config_word(ha->pdev, pcie_reg, &pcie_lstat);
lspeed = pcie_lstat & (BIT_0 | BIT_1 | BIT_2 | BIT_3);
lwidth = (pcie_lstat &
(BIT_4 | BIT_5 | BIT_6 | BIT_7 | BIT_8 | BIT_9)) >> 4;
strcpy(str, "PCIe (");
if (lspeed == 1)
strcat(str, "2.5Gb/s ");
else
strcat(str, "<unknown> ");
snprintf(lwstr, sizeof(lwstr), "x%d)", lwidth);
strcat(str, lwstr);
return str;
}
strcpy(str, "PCI");
pci_bus = (ha->pci_attr & CSRX_PCIX_BUS_MODE_MASK) >> 8;
if (pci_bus == 0 || pci_bus == 8) {
strcat(str, " (");
strcat(str, pci_bus_modes[pci_bus >> 3]);
} else {
strcat(str, "-X ");
if (pci_bus & BIT_2)
strcat(str, "Mode 2");
else
strcat(str, "Mode 1");
strcat(str, " (");
strcat(str, pci_bus_modes[pci_bus & ~BIT_2]);
}
strcat(str, " MHz)");
return str;
}
char *
qla2x00_fw_version_str(struct scsi_qla_host *ha, char *str)
{
@ -238,25 +314,42 @@ qla2x00_fw_version_str(struct scsi_qla_host *ha, char *str)
return (str);
}
/**************************************************************************
* qla2x00_queuecommand
*
* Description:
* Queue a command to the controller.
*
* Input:
* cmd - pointer to Scsi cmd structure
* fn - pointer to Scsi done function
*
* Returns:
* 0 - Always
*
* Note:
* The mid-level driver tries to ensures that queuecommand never gets invoked
* concurrently with itself or the interrupt handler (although the
* interrupt handler may call this routine as part of request-completion
* handling).
**************************************************************************/
char *
qla24xx_fw_version_str(struct scsi_qla_host *ha, char *str)
{
if (ha->fw_attributes & BIT_0)
strcat(str, "[Class 2] ");
if (ha->fw_attributes & BIT_1)
strcat(str, "[IP] ");
if (ha->fw_attributes & BIT_2)
strcat(str, "[Multi-ID] ");
if (ha->fw_attributes & BIT_13)
strcat(str, "[Experimental]");
return str;
}
static inline srb_t *
qla2x00_get_new_sp(scsi_qla_host_t *ha, fc_port_t *fcport,
struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
{
srb_t *sp;
sp = mempool_alloc(ha->srb_mempool, GFP_ATOMIC);
if (!sp)
return sp;
atomic_set(&sp->ref_count, 1);
sp->ha = ha;
sp->fcport = fcport;
sp->cmd = cmd;
sp->flags = 0;
CMD_SP(cmd) = (void *)sp;
cmd->scsi_done = done;
return sp;
}
static int
qla2x00_queuecommand(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
{
@ -281,18 +374,9 @@ qla2x00_queuecommand(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
spin_unlock_irq(ha->host->host_lock);
/* Allocate a command packet from the "sp" pool. */
if ((sp = qla2x00_get_new_sp(ha)) == NULL) {
sp = qla2x00_get_new_sp(ha, fcport, cmd, done);
if (!sp)
goto qc_host_busy_lock;
}
sp->ha = ha;
sp->fcport = fcport;
sp->cmd = cmd;
sp->flags = 0;
CMD_SP(cmd) = (void *)sp;
cmd->scsi_done = done;
rval = qla2x00_start_scsi(sp);
if (rval != QLA_SUCCESS)
@ -314,7 +398,6 @@ qla2x00_queuecommand(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
qc_host_busy_free_sp:
qla2x00_sp_free_dma(ha, sp);
CMD_SP(cmd) = NULL;
mempool_free(sp, ha->srb_mempool);
qc_host_busy_lock:
@ -329,6 +412,60 @@ qc_fail_command:
return 0;
}
static int
qla24xx_queuecommand(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
{
scsi_qla_host_t *ha = to_qla_host(cmd->device->host);
fc_port_t *fcport = (struct fc_port *) cmd->device->hostdata;
srb_t *sp;
int rval;
if (!fcport) {
cmd->result = DID_NO_CONNECT << 16;
goto qc24_fail_command;
}
if (atomic_read(&fcport->state) != FCS_ONLINE) {
if (atomic_read(&fcport->state) == FCS_DEVICE_DEAD ||
atomic_read(&ha->loop_state) == LOOP_DEAD) {
cmd->result = DID_NO_CONNECT << 16;
goto qc24_fail_command;
}
goto qc24_host_busy;
}
spin_unlock_irq(ha->host->host_lock);
sp = qla2x00_get_new_sp(ha, fcport, cmd, done);
if (!sp)
goto qc24_host_busy_lock;
rval = qla24xx_start_scsi(sp);
if (rval != QLA_SUCCESS)
goto qc24_host_busy_free_sp;
spin_lock_irq(ha->host->host_lock);
return 0;
qc24_host_busy_free_sp:
qla2x00_sp_free_dma(ha, sp);
mempool_free(sp, ha->srb_mempool);
qc24_host_busy_lock:
spin_lock_irq(ha->host->host_lock);
qc24_host_busy:
return SCSI_MLQUEUE_HOST_BUSY;
qc24_fail_command:
done(cmd);
return 0;
}
/*
* qla2x00_eh_wait_on_command
* Waits for the command to be returned by the Firmware for some
@ -385,8 +522,8 @@ qla2x00_eh_wait_on_command(scsi_qla_host_t *ha, struct scsi_cmnd *cmd)
static int
qla2x00_wait_for_hba_online(scsi_qla_host_t *ha)
{
int return_status;
unsigned long wait_online;
int return_status;
unsigned long wait_online;
wait_online = jiffies + (MAX_LOOP_TIMEOUT * HZ);
while (((test_bit(ISP_ABORT_NEEDED, &ha->dpc_flags)) ||
@ -1114,13 +1251,39 @@ qla2x00_disable_intrs(scsi_qla_host_t *ha)
spin_unlock_irqrestore(&ha->hardware_lock, flags);
}
static void
qla24xx_enable_intrs(scsi_qla_host_t *ha)
{
unsigned long flags = 0;
struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
spin_lock_irqsave(&ha->hardware_lock, flags);
ha->interrupts_on = 1;
WRT_REG_DWORD(&reg->ictrl, ICRX_EN_RISC_INT);
RD_REG_DWORD(&reg->ictrl);
spin_unlock_irqrestore(&ha->hardware_lock, flags);
}
static void
qla24xx_disable_intrs(scsi_qla_host_t *ha)
{
unsigned long flags = 0;
struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
spin_lock_irqsave(&ha->hardware_lock, flags);
ha->interrupts_on = 0;
WRT_REG_DWORD(&reg->ictrl, 0);
RD_REG_DWORD(&reg->ictrl);
spin_unlock_irqrestore(&ha->hardware_lock, flags);
}
/*
* PCI driver interface
*/
int qla2x00_probe_one(struct pci_dev *pdev, struct qla_board_info *brd_info)
{
int ret = -ENODEV;
struct device_reg_2xxx __iomem *reg;
device_reg_t __iomem *reg;
struct Scsi_Host *host;
scsi_qla_host_t *ha;
unsigned long flags = 0;
@ -1132,8 +1295,8 @@ int qla2x00_probe_one(struct pci_dev *pdev, struct qla_board_info *brd_info)
if (pci_enable_device(pdev))
goto probe_out;
host = scsi_host_alloc(&qla2x00_driver_template,
sizeof(scsi_qla_host_t));
host = scsi_host_alloc(brd_info->sht ? brd_info->sht:
&qla2x00_driver_template, sizeof(scsi_qla_host_t));
if (host == NULL) {
printk(KERN_WARNING
"qla2xxx: Couldn't allocate host from scsi layer!\n");
@ -1155,17 +1318,15 @@ int qla2x00_probe_one(struct pci_dev *pdev, struct qla_board_info *brd_info)
if (ret)
goto probe_failed;
/* Sanitize the information from PCI BIOS. */
host->irq = pdev->irq;
qla_printk(KERN_INFO, ha,
"Found an %s, irq %d, iobase 0x%p\n", ha->brd_info->isp_name,
host->irq, ha->iobase);
pdev->irq, ha->iobase);
spin_lock_init(&ha->hardware_lock);
ha->prev_topology = 0;
ha->ports = MAX_BUSES;
ha->init_cb_size = sizeof(init_cb_t);
/* Assign ISP specific operations. */
ha->isp_ops.pci_config = qla2100_pci_config;
@ -1207,7 +1368,7 @@ int qla2x00_probe_one(struct pci_dev *pdev, struct qla_board_info *brd_info)
ha->response_q_length = RESPONSE_ENTRY_CNT_2100;
ha->last_loop_id = SNS_LAST_LOOP_ID_2100;
ha->gid_list_info_size = 4;
} else /*if (IS_QLA2300(ha))*/ {
} else if (IS_QLA23XX(ha)) {
host->max_id = MAX_TARGETS_2200;
ha->mbx_count = MAILBOX_REGISTER_COUNT;
ha->request_q_length = REQUEST_ENTRY_CNT_2200;
@ -1218,6 +1379,38 @@ int qla2x00_probe_one(struct pci_dev *pdev, struct qla_board_info *brd_info)
ha->isp_ops.fw_dump = qla2300_fw_dump;
ha->isp_ops.ascii_fw_dump = qla2300_ascii_fw_dump;
ha->gid_list_info_size = 6;
} else if (IS_QLA24XX(ha) || IS_QLA25XX(ha)) {
host->max_id = MAX_TARGETS_2200;
ha->mbx_count = MAILBOX_REGISTER_COUNT;
ha->request_q_length = REQUEST_ENTRY_CNT_24XX;
ha->response_q_length = RESPONSE_ENTRY_CNT_2300;
ha->last_loop_id = SNS_LAST_LOOP_ID_2300;
ha->init_cb_size = sizeof(struct init_cb_24xx);
ha->isp_ops.pci_config = qla24xx_pci_config;
ha->isp_ops.reset_chip = qla24xx_reset_chip;
ha->isp_ops.chip_diag = qla24xx_chip_diag;
ha->isp_ops.config_rings = qla24xx_config_rings;
ha->isp_ops.reset_adapter = qla24xx_reset_adapter;
ha->isp_ops.nvram_config = qla24xx_nvram_config;
ha->isp_ops.update_fw_options = qla24xx_update_fw_options;
ha->isp_ops.load_risc = qla24xx_load_risc_flash;
if (ql2xfwloadbin)
ha->isp_ops.load_risc = qla24xx_load_risc_hotplug;
ha->isp_ops.pci_info_str = qla24xx_pci_info_str;
ha->isp_ops.fw_version_str = qla24xx_fw_version_str;
ha->isp_ops.intr_handler = qla24xx_intr_handler;
ha->isp_ops.enable_intrs = qla24xx_enable_intrs;
ha->isp_ops.disable_intrs = qla24xx_disable_intrs;
ha->isp_ops.abort_command = qla24xx_abort_command;
ha->isp_ops.abort_target = qla24xx_abort_target;
ha->isp_ops.fabric_login = qla24xx_login_fabric;
ha->isp_ops.fabric_logout = qla24xx_fabric_logout;
ha->isp_ops.prep_ms_iocb = qla24xx_prep_ms_iocb;
ha->isp_ops.read_nvram = qla24xx_read_nvram_data;
ha->isp_ops.write_nvram = qla24xx_write_nvram_data;
ha->isp_ops.fw_dump = qla24xx_fw_dump;
ha->isp_ops.ascii_fw_dump = qla24xx_ascii_fw_dump;
ha->gid_list_info_size = 8;
}
host->can_queue = ha->request_q_length + 128;
@ -1288,14 +1481,15 @@ int qla2x00_probe_one(struct pci_dev *pdev, struct qla_board_info *brd_info)
host->max_lun = MAX_LUNS;
host->transportt = qla2xxx_transport_template;
ret = request_irq(host->irq, ha->isp_ops.intr_handler,
ret = request_irq(pdev->irq, ha->isp_ops.intr_handler,
SA_INTERRUPT|SA_SHIRQ, ha->brd_info->drv_name, ha);
if (ret) {
qla_printk(KERN_WARNING, ha,
"Failed to reserve interrupt %d already in use.\n",
host->irq);
pdev->irq);
goto probe_failed;
}
host->irq = pdev->irq;
/* Initialized the timer */
qla2x00_start_timer(ha, qla2x00_timer, WATCH_INTERVAL);
@ -1303,24 +1497,29 @@ int qla2x00_probe_one(struct pci_dev *pdev, struct qla_board_info *brd_info)
DEBUG2(printk("DEBUG: detect hba %ld at address = %p\n",
ha->host_no, ha));
reg = &ha->iobase->isp;
ha->isp_ops.disable_intrs(ha);
/* Ensure mailbox registers are free. */
spin_lock_irqsave(&ha->hardware_lock, flags);
WRT_REG_WORD(&reg->semaphore, 0);
WRT_REG_WORD(&reg->hccr, HCCR_CLR_RISC_INT);
WRT_REG_WORD(&reg->hccr, HCCR_CLR_HOST_INT);
reg = ha->iobase;
if (IS_QLA24XX(ha) || IS_QLA25XX(ha)) {
WRT_REG_DWORD(&reg->isp24.hccr, HCCRX_CLR_HOST_INT);
WRT_REG_DWORD(&reg->isp24.hccr, HCCRX_CLR_RISC_INT);
} else {
WRT_REG_WORD(&reg->isp.semaphore, 0);
WRT_REG_WORD(&reg->isp.hccr, HCCR_CLR_RISC_INT);
WRT_REG_WORD(&reg->isp.hccr, HCCR_CLR_HOST_INT);
/* Enable proper parity */
if (!IS_QLA2100(ha) && !IS_QLA2200(ha)) {
if (IS_QLA2300(ha))
/* SRAM parity */
WRT_REG_WORD(&reg->hccr, (HCCR_ENABLE_PARITY + 0x1));
else
/* SRAM, Instruction RAM and GP RAM parity */
WRT_REG_WORD(&reg->hccr, (HCCR_ENABLE_PARITY + 0x7));
/* Enable proper parity */
if (!IS_QLA2100(ha) && !IS_QLA2200(ha)) {
if (IS_QLA2300(ha))
/* SRAM parity */
WRT_REG_WORD(&reg->isp.hccr,
(HCCR_ENABLE_PARITY + 0x1));
else
/* SRAM, Instruction RAM and GP RAM parity */
WRT_REG_WORD(&reg->isp.hccr,
(HCCR_ENABLE_PARITY + 0x7));
}
}
spin_unlock_irqrestore(&ha->hardware_lock, flags);
@ -1360,7 +1559,7 @@ int qla2x00_probe_one(struct pci_dev *pdev, struct qla_board_info *brd_info)
" %s: %s @ %s hdma%c, host#=%ld, fw=%s\n", qla2x00_version_str,
ha->model_number, ha->model_desc ? ha->model_desc: "",
ha->brd_info->isp_name, ha->isp_ops.pci_info_str(ha, pci_info),
pci_name(ha->pdev), ha->flags.enable_64bit_addressing ? '+': '-',
pci_name(pdev), ha->flags.enable_64bit_addressing ? '+': '-',
ha->host_no, ha->isp_ops.fw_version_str(ha, fw_str));
/* Go with fc_rport registration. */
@ -1629,7 +1828,7 @@ qla2x00_mem_alloc(scsi_qla_host_t *ha)
continue;
}
memset(ha->init_cb, 0, sizeof(init_cb_t));
memset(ha->init_cb, 0, ha->init_cb_size);
/* Get consistent memory allocated for Get Port Database cmd */
ha->iodesc_pd = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL,
@ -1841,10 +2040,13 @@ qla2x00_mem_free(scsi_qla_host_t *ha)
if (ha->fw_dump)
free_pages((unsigned long)ha->fw_dump, ha->fw_dump_order);
if (ha->fw_dump_buffer)
vfree(ha->fw_dump_buffer);
vfree(ha->fw_dump24);
vfree(ha->fw_dump_buffer);
ha->fw_dump = NULL;
ha->fw_dump24 = NULL;
ha->fw_dumped = 0;
ha->fw_dump_reading = 0;
ha->fw_dump_buffer = NULL;
}
@ -2131,25 +2333,6 @@ qla2x00_rst_aen(scsi_qla_host_t *ha)
}
}
/*
* This routine will allocate SP from the free queue
* input:
* scsi_qla_host_t *
* output:
* srb_t * or NULL
*/
static srb_t *
qla2x00_get_new_sp(scsi_qla_host_t *ha)
{
srb_t *sp;
sp = mempool_alloc(ha->srb_mempool, GFP_ATOMIC);
if (sp)
atomic_set(&sp->ref_count, 1);
return (sp);
}
static void
qla2x00_sp_free_dma(scsi_qla_host_t *ha, srb_t *sp)
{
@ -2165,6 +2348,7 @@ qla2x00_sp_free_dma(scsi_qla_host_t *ha, srb_t *sp)
}
sp->flags &= ~SRB_DMA_VALID;
}
CMD_SP(cmd) = NULL;
}
void
@ -2174,7 +2358,6 @@ qla2x00_sp_compl(scsi_qla_host_t *ha, srb_t *sp)
qla2x00_sp_free_dma(ha, sp);
CMD_SP(cmd) = NULL;
mempool_free(sp, ha->srb_mempool);
cmd->scsi_done(cmd);
@ -2219,7 +2402,7 @@ qla2x00_timer(scsi_qla_host_t *ha)
atomic_set(&fcport->state, FCS_DEVICE_DEAD);
DEBUG(printk("scsi(%ld): fcport-%d - port retry count: "
"%d remainning\n",
"%d remaining\n",
ha->host_no,
t, atomic_read(&fcport->port_down_timer)));
}
@ -2282,7 +2465,7 @@ qla2x00_timer(scsi_qla_host_t *ha)
set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
}
}
DEBUG3(printk("scsi(%ld): Loop Down - seconds remainning %d\n",
DEBUG3(printk("scsi(%ld): Loop Down - seconds remaining %d\n",
ha->host_no,
atomic_read(&ha->loop_down_timer)));
}
@ -2319,12 +2502,68 @@ qla2x00_down_timeout(struct semaphore *sema, unsigned long timeout)
return -ETIMEDOUT;
}
static struct qla_board_info qla_board_tbl[] = {
{
.drv_name = "qla2400",
.isp_name = "ISP2422",
.fw_fname = "ql2400_fw.bin",
.sht = &qla24xx_driver_template,
},
{
.drv_name = "qla2400",
.isp_name = "ISP2432",
.fw_fname = "ql2400_fw.bin",
.sht = &qla24xx_driver_template,
},
};
static struct pci_device_id qla2xxx_pci_tbl[] = {
{
.vendor = PCI_VENDOR_ID_QLOGIC,
.device = PCI_DEVICE_ID_QLOGIC_ISP2422,
.subvendor = PCI_ANY_ID,
.subdevice = PCI_ANY_ID,
.driver_data = (unsigned long)&qla_board_tbl[0],
},
{
.vendor = PCI_VENDOR_ID_QLOGIC,
.device = PCI_DEVICE_ID_QLOGIC_ISP2432,
.subvendor = PCI_ANY_ID,
.subdevice = PCI_ANY_ID,
.driver_data = (unsigned long)&qla_board_tbl[1],
},
{0, 0},
};
MODULE_DEVICE_TABLE(pci, qla2xxx_pci_tbl);
static int __devinit
qla2xxx_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
{
return qla2x00_probe_one(pdev,
(struct qla_board_info *)id->driver_data);
}
static void __devexit
qla2xxx_remove_one(struct pci_dev *pdev)
{
qla2x00_remove_one(pdev);
}
static struct pci_driver qla2xxx_pci_driver = {
.name = "qla2xxx",
.id_table = qla2xxx_pci_tbl,
.probe = qla2xxx_probe_one,
.remove = __devexit_p(qla2xxx_remove_one),
};
/**
* qla2x00_module_init - Module initialization.
**/
static int __init
qla2x00_module_init(void)
{
int ret = 0;
/* Allocate cache for SRBs. */
srb_cachep = kmem_cache_create("qla2xxx_srbs", sizeof(srb_t), 0,
SLAB_HWCACHE_ALIGN, NULL, NULL);
@ -2345,7 +2584,12 @@ qla2x00_module_init(void)
return -ENODEV;
printk(KERN_INFO "QLogic Fibre Channel HBA Driver\n");
return 0;
ret = pci_module_init(&qla2xxx_pci_driver);
if (ret) {
kmem_cache_destroy(srb_cachep);
fc_release_transport(qla2xxx_transport_template);
}
return ret;
}
/**
@ -2354,6 +2598,7 @@ qla2x00_module_init(void)
static void __exit
qla2x00_module_exit(void)
{
pci_unregister_driver(&qla2xxx_pci_driver);
kmem_cache_destroy(srb_cachep);
fc_release_transport(qla2xxx_transport_template);
}