* QLOGIC LINUX SOFTWARE
*
* QLogic ISP2x00 device driver for Linux 2.6.x
- * Copyright (C) 2003-2004 QLogic Corporation
+ * Copyright (C) 2003-2005 QLogic Corporation
* (www.qlogic.com)
*
* This program is free software; you can redistribute it and/or modify it
int ql2xenablezio = 0;
module_param(ql2xenablezio, int, S_IRUGO|S_IRUSR);
MODULE_PARM_DESC(ql2xenablezio,
- "Option to enable ZIO:If 1 then enable it otherwise"
+ "Option to enable ZIO:If 1 then enable it otherwise"
" use the default set in the NVRAM."
" Default is 0 : disabled");
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);
/*
- * SCSI host template entry points
+ * SCSI host template entry points
*/
static int qla2xxx_slave_configure(struct scsi_device * device);
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 *);
.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
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 *);
/* -------------------------------------------------------------------------- */
static char *
-qla2x00_get_pci_info_str(struct scsi_qla_host *ha, char *str)
+qla2x00_pci_info_str(struct scsi_qla_host *ha, char *str)
{
static char *pci_bus_modes[] = {
"33", "66", "100", "133",
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_get_fw_version_str(struct scsi_qla_host *ha, char *str)
+qla2x00_fw_version_str(struct scsi_qla_host *ha, char *str)
{
char un_str[10];
-
+
sprintf(str, "%d.%02d.%02d ", ha->fw_major_version,
ha->fw_minor_version,
ha->fw_subminor_version);
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)
+{
+ sprintf(str, "%d.%02d.%02d ", ha->fw_major_version,
+ ha->fw_minor_version,
+ ha->fw_subminor_version);
+
+ 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 *))
{
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)
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:
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
/*
* qla2x00_wait_for_hba_online
- * Wait till the HBA is online after going through
+ * Wait till the HBA is online after going through
* <= MAX_RETRIES_OF_ISP_ABORT or
* finally HBA is disabled ie marked offline
*
* Input:
* ha - pointer to host adapter structure
- *
- * Note:
+ *
+ * Note:
* Does context switching-Release SPIN_LOCK
* (if any) before calling this routine.
*
* Success (Adapter is online) : 0
* Failed (Adapter is offline/disabled) : 1
*/
-static int
+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);
+ wait_online = jiffies + (MAX_LOOP_TIMEOUT * HZ);
while (((test_bit(ISP_ABORT_NEEDED, &ha->dpc_flags)) ||
test_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags) ||
test_bit(ISP_ABORT_RETRY, &ha->dpc_flags) ||
msleep(1000);
}
- if (ha->flags.online)
- return_status = QLA_SUCCESS;
+ if (ha->flags.online)
+ return_status = QLA_SUCCESS;
else
return_status = QLA_FUNCTION_FAILED;
/*
* qla2x00_wait_for_loop_ready
* Wait for MAX_LOOP_TIMEOUT(5 min) value for loop
- * to be in LOOP_READY state.
+ * to be in LOOP_READY state.
* Input:
* ha - pointer to host adapter structure
- *
- * Note:
+ *
+ * Note:
* Does context switching-Release SPIN_LOCK
* (if any) before calling this routine.
- *
+ *
*
* Return:
* Success (LOOP_READY) : 0
* Failed (LOOP_NOT_READY) : 1
*/
-static inline int
+static inline int
qla2x00_wait_for_loop_ready(scsi_qla_host_t *ha)
{
int return_status = QLA_SUCCESS;
unsigned long loop_timeout ;
/* wait for 5 min at the max for loop to be ready */
- loop_timeout = jiffies + (MAX_LOOP_TIMEOUT * HZ);
+ loop_timeout = jiffies + (MAX_LOOP_TIMEOUT * HZ);
while ((!atomic_read(&ha->loop_down_timer) &&
atomic_read(&ha->loop_state) == LOOP_DOWN) ||
break;
}
}
- return (return_status);
+ return (return_status);
}
/**************************************************************************
int ret, i;
unsigned int id, lun;
unsigned long serial;
+ unsigned long flags;
if (!CMD_SP(cmd))
return FAILED;
serial = cmd->serial_number;
/* Check active list for command command. */
- spin_unlock_irq(ha->host->host_lock);
- spin_lock(&ha->hardware_lock);
+ spin_lock_irqsave(&ha->hardware_lock, flags);
for (i = 1; i < MAX_OUTSTANDING_COMMANDS; i++) {
sp = ha->outstanding_cmds[i];
sp->state));
DEBUG3(qla2x00_print_scsi_cmd(cmd);)
- spin_unlock(&ha->hardware_lock);
- if (qla2x00_abort_command(ha, sp)) {
+ spin_unlock_irqrestore(&ha->hardware_lock, flags);
+ if (ha->isp_ops.abort_command(ha, sp)) {
DEBUG2(printk("%s(%ld): abort_command "
"mbx failed.\n", __func__, ha->host_no));
} else {
"mbx success.\n", __func__, ha->host_no));
ret = SUCCESS;
}
- spin_lock(&ha->hardware_lock);
+ spin_lock_irqsave(&ha->hardware_lock, flags);
break;
}
+ spin_unlock_irqrestore(&ha->hardware_lock, flags);
/* Wait for the command to be returned. */
if (ret == SUCCESS) {
- spin_unlock(&ha->hardware_lock);
if (qla2x00_eh_wait_on_command(ha, cmd) != QLA_SUCCESS) {
- qla_printk(KERN_ERR, ha,
+ qla_printk(KERN_ERR, ha,
"scsi(%ld:%d:%d): Abort handler timed out -- %lx "
"%x.\n", ha->host_no, id, lun, serial, ret);
}
- spin_lock(&ha->hardware_lock);
}
- spin_lock_irq(ha->host->host_lock);
- qla_printk(KERN_INFO, ha,
+ qla_printk(KERN_INFO, ha,
"scsi(%ld:%d:%d): Abort command issued -- %lx %x.\n", ha->host_no,
id, lun, serial, ret);
*
* Input:
* ha - pointer to scsi_qla_host structure.
-* t - target
+* t - target
* Returns:
* Either SUCCESS or FAILED.
*
int status;
srb_t *sp;
struct scsi_cmnd *cmd;
+ unsigned long flags;
status = 0;
* array
*/
for (cnt = 1; cnt < MAX_OUTSTANDING_COMMANDS; cnt++) {
- spin_lock(&ha->hardware_lock);
+ spin_lock_irqsave(&ha->hardware_lock, flags);
sp = ha->outstanding_cmds[cnt];
if (sp) {
cmd = sp->cmd;
- spin_unlock(&ha->hardware_lock);
+ spin_unlock_irqrestore(&ha->hardware_lock, flags);
if (cmd->device->id == t) {
if (!qla2x00_eh_wait_on_command(ha, cmd)) {
status = 1;
}
}
} else {
- spin_unlock(&ha->hardware_lock);
+ spin_unlock_irqrestore(&ha->hardware_lock, flags);
}
}
return (status);
* executing commands.
*
* NOTE: The use of SP is undefined within this context. Do *NOT*
-* attempt to use this value, even if you determine it is
+* attempt to use this value, even if you determine it is
* non-null.
*
* Input:
qla_printk(KERN_INFO, ha,
"scsi(%ld:%d:%d): DEVICE RESET ISSUED.\n", ha->host_no, id, lun);
- spin_unlock_irq(ha->host->host_lock);
-
- if (qla2x00_wait_for_hba_online(ha) != QLA_SUCCESS) {
- spin_lock_irq(ha->host->host_lock);
+ if (qla2x00_wait_for_hba_online(ha) != QLA_SUCCESS)
goto eh_dev_reset_done;
- }
if (qla2x00_wait_for_loop_ready(ha) == QLA_SUCCESS) {
if (qla2x00_device_reset(ha, fcport) == 0)
#if defined(LOGOUT_AFTER_DEVICE_RESET)
if (ret == SUCCESS) {
if (fcport->flags & FC_FABRIC_DEVICE) {
- qla2x00_fabric_logout(ha, fcport->loop_id);
+ ha->isp_ops.fabric_logout(ha, fcport->loop_id);
qla2x00_mark_device_lost(ha, fcport);
}
}
"commands\n", __func__, ha->host_no));
qla_printk(KERN_INFO, ha,
"%s: failed while waiting for commands\n",
- __func__);
+ __func__);
goto eh_dev_reset_done;
}
"scsi(%ld:%d:%d): DEVICE RESET SUCCEEDED.\n", ha->host_no, id, lun);
eh_dev_reset_done:
- spin_lock_irq(ha->host->host_lock);
-
return ret;
}
int status;
srb_t *sp;
struct scsi_cmnd *cmd;
+ unsigned long flags;
status = 1;
* array
*/
for (cnt = 1; cnt < MAX_OUTSTANDING_COMMANDS; cnt++) {
- spin_lock(&ha->hardware_lock);
+ spin_lock_irqsave(&ha->hardware_lock, flags);
sp = ha->outstanding_cmds[cnt];
if (sp) {
cmd = sp->cmd;
- spin_unlock(&ha->hardware_lock);
+ spin_unlock_irqrestore(&ha->hardware_lock, flags);
status = qla2x00_eh_wait_on_command(ha, cmd);
if (status == 0)
break;
}
else {
- spin_unlock(&ha->hardware_lock);
+ spin_unlock_irqrestore(&ha->hardware_lock, flags);
}
}
return (status);
qla_printk(KERN_INFO, ha,
"scsi(%ld:%d:%d): LOOP RESET ISSUED.\n", ha->host_no, id, lun);
- spin_unlock_irq(ha->host->host_lock);
-
if (qla2x00_wait_for_hba_online(ha) != QLA_SUCCESS) {
DEBUG2(printk("%s failed:board disabled\n",__func__));
goto eh_bus_reset_done;
qla_printk(KERN_INFO, ha, "%s: reset %s\n", __func__,
(ret == FAILED) ? "failed" : "succeded");
- spin_lock_irq(ha->host->host_lock);
-
return ret;
}
qla_printk(KERN_INFO, ha,
"scsi(%ld:%d:%d): ADAPTER RESET ISSUED.\n", ha->host_no, id, lun);
- spin_unlock_irq(ha->host->host_lock);
-
if (qla2x00_wait_for_hba_online(ha) != QLA_SUCCESS)
goto eh_host_reset_lock;
/*
* Fixme-may be dpc thread is active and processing
- * loop_resync,so wait a while for it to
+ * loop_resync,so wait a while for it to
* be completed and then issue big hammer.Otherwise
* it may cause I/O failure as big hammer marks the
* devices as lost kicking of the port_down_timer
if (qla2x00_wait_for_hba_online(ha) != QLA_SUCCESS)
goto eh_host_reset_lock;
- }
+ }
clear_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags);
/* Waiting for our command in done_queue to be returned to OS.*/
ret = SUCCESS;
eh_host_reset_lock:
- spin_lock_irq(ha->host->host_lock);
-
qla_printk(KERN_INFO, ha, "%s: reset %s\n", __func__,
(ret == FAILED) ? "failed" : "succeded");
}
if (status == QLA_SUCCESS &&
- ((!ha->flags.enable_target_reset &&
+ ((!ha->flags.enable_target_reset &&
!ha->flags.enable_lip_reset) ||
ha->flags.enable_lip_full_login)) {
qla2x00_device_reset(scsi_qla_host_t *ha, fc_port_t *reset_fcport)
{
/* Abort Target command will clear Reservation */
- return qla2x00_abort_target(reset_fcport);
+ return ha->isp_ops.abort_target(reset_fcport);
}
static int
qla2xxx_slave_alloc(struct scsi_device *sdev)
{
- scsi_qla_host_t *ha = to_qla_host(sdev->host);
struct fc_rport *rport = starget_to_rport(scsi_target(sdev));
- fc_port_t *fcport;
- int found;
if (!rport)
return -ENXIO;
- found = 0;
- list_for_each_entry(fcport, &ha->fcports, list) {
- if (rport->port_name ==
- be64_to_cpu(*(uint64_t *)fcport->port_name)) {
- found++;
- break;
- }
- }
- if (!found)
- return -ENXIO;
-
- sdev->hostdata = fcport;
+ sdev->hostdata = rport->dd_data;
return 0;
}
{
/* Assume 32bit DMA address */
ha->flags.enable_64bit_addressing = 0;
- ha->calc_request_entries = qla2x00_calc_iocbs_32;
- ha->build_scsi_iocbs = qla2x00_build_scsi_iocbs_32;
/*
* Given the two variants pci_set_dma_mask(), allow the compiler to
if (sizeof(dma_addr_t) > 4) {
if (pci_set_dma_mask(ha->pdev, DMA_64BIT_MASK) == 0) {
ha->flags.enable_64bit_addressing = 1;
- ha->calc_request_entries = qla2x00_calc_iocbs_64;
- ha->build_scsi_iocbs = qla2x00_build_scsi_iocbs_64;
+ ha->isp_ops.calc_req_entries = qla2x00_calc_iocbs_64;
+ ha->isp_ops.build_iocbs = qla2x00_build_scsi_iocbs_64;
if (pci_set_consistent_dma_mask(ha->pdev,
DMA_64BIT_MASK)) {
- qla_printk(KERN_DEBUG, ha,
+ qla_printk(KERN_DEBUG, ha,
"Failed to set 64 bit PCI consistent mask; "
"using 32 bit.\n");
pci_set_consistent_dma_mask(ha->pdev,
return (-ENOMEM);
}
+static void
+qla2x00_enable_intrs(scsi_qla_host_t *ha)
+{
+ unsigned long flags = 0;
+ struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
+
+ spin_lock_irqsave(&ha->hardware_lock, flags);
+ ha->interrupts_on = 1;
+ /* enable risc and host interrupts */
+ WRT_REG_WORD(®->ictrl, ICR_EN_INT | ICR_EN_RISC);
+ RD_REG_WORD(®->ictrl);
+ spin_unlock_irqrestore(&ha->hardware_lock, flags);
+
+}
+
+static void
+qla2x00_disable_intrs(scsi_qla_host_t *ha)
+{
+ unsigned long flags = 0;
+ struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
+
+ spin_lock_irqsave(&ha->hardware_lock, flags);
+ ha->interrupts_on = 0;
+ /* disable risc and host interrupts */
+ WRT_REG_WORD(®->ictrl, 0);
+ RD_REG_WORD(®->ictrl);
+ 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(®->ictrl, ICRX_EN_RISC_INT);
+ RD_REG_DWORD(®->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(®->ictrl, 0);
+ RD_REG_DWORD(®->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;
+ int ret = -ENODEV;
device_reg_t __iomem *reg;
struct Scsi_Host *host;
scsi_qla_host_t *ha;
fc_port_t *fcport;
if (pci_enable_device(pdev))
- return -1;
+ 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");
/* Configure PCI I/O space */
ret = qla2x00_iospace_config(ha);
- if (ret != 0) {
- goto probe_alloc_failed;
- }
-
- /* Sanitize the information from PCI BIOS. */
- host->irq = pdev->irq;
+ if (ret)
+ goto probe_failed;
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;
+ ha->isp_ops.reset_chip = qla2x00_reset_chip;
+ ha->isp_ops.chip_diag = qla2x00_chip_diag;
+ ha->isp_ops.config_rings = qla2x00_config_rings;
+ ha->isp_ops.reset_adapter = qla2x00_reset_adapter;
+ ha->isp_ops.nvram_config = qla2x00_nvram_config;
+ ha->isp_ops.update_fw_options = qla2x00_update_fw_options;
+ ha->isp_ops.load_risc = qla2x00_load_risc;
+ ha->isp_ops.pci_info_str = qla2x00_pci_info_str;
+ ha->isp_ops.fw_version_str = qla2x00_fw_version_str;
+ ha->isp_ops.intr_handler = qla2100_intr_handler;
+ ha->isp_ops.enable_intrs = qla2x00_enable_intrs;
+ ha->isp_ops.disable_intrs = qla2x00_disable_intrs;
+ ha->isp_ops.abort_command = qla2x00_abort_command;
+ ha->isp_ops.abort_target = qla2x00_abort_target;
+ ha->isp_ops.fabric_login = qla2x00_login_fabric;
+ ha->isp_ops.fabric_logout = qla2x00_fabric_logout;
+ ha->isp_ops.calc_req_entries = qla2x00_calc_iocbs_32;
+ ha->isp_ops.build_iocbs = qla2x00_build_scsi_iocbs_32;
+ ha->isp_ops.prep_ms_iocb = qla2x00_prep_ms_iocb;
+ ha->isp_ops.read_nvram = qla2x00_read_nvram_data;
+ ha->isp_ops.write_nvram = qla2x00_write_nvram_data;
+ ha->isp_ops.fw_dump = qla2100_fw_dump;
+ ha->isp_ops.ascii_fw_dump = qla2100_ascii_fw_dump;
if (IS_QLA2100(ha)) {
host->max_id = MAX_TARGETS_2100;
ha->mbx_count = MAILBOX_REGISTER_COUNT_2100;
ha->response_q_length = RESPONSE_ENTRY_CNT_2100;
ha->last_loop_id = SNS_LAST_LOOP_ID_2100;
host->sg_tablesize = 32;
+ ha->gid_list_info_size = 4;
} else if (IS_QLA2200(ha)) {
host->max_id = MAX_TARGETS_2200;
ha->mbx_count = MAILBOX_REGISTER_COUNT;
ha->request_q_length = REQUEST_ENTRY_CNT_2200;
ha->response_q_length = RESPONSE_ENTRY_CNT_2100;
ha->last_loop_id = SNS_LAST_LOOP_ID_2100;
- } else /*if (IS_QLA2300(ha))*/ {
+ ha->gid_list_info_size = 4;
+ } 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;
ha->response_q_length = RESPONSE_ENTRY_CNT_2300;
ha->last_loop_id = SNS_LAST_LOOP_ID_2300;
+ ha->isp_ops.pci_config = qla2300_pci_config;
+ ha->isp_ops.intr_handler = qla2300_intr_handler;
+ 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;
qla_printk(KERN_WARNING, ha,
"[ERROR] Failed to allocate memory for adapter\n");
- goto probe_alloc_failed;
+ ret = -ENOMEM;
+ goto probe_failed;
}
- pci_set_drvdata(pdev, ha);
- host->this_id = 255;
- host->cmd_per_lun = 3;
- host->unique_id = ha->instance;
- host->max_cmd_len = MAX_CMDSZ;
- host->max_channel = ha->ports - 1;
- host->max_lun = MAX_LUNS;
- host->transportt = qla2xxx_transport_template;
- if (scsi_add_host(host, &pdev->dev))
- goto probe_alloc_failed;
-
- qla2x00_alloc_sysfs_attr(ha);
-
if (qla2x00_initialize_adapter(ha) &&
!(ha->device_flags & DFLG_NO_CABLE)) {
"Adapter flags %x.\n",
ha->host_no, ha->device_flags));
+ ret = -ENODEV;
goto probe_failed;
}
- qla2x00_init_host_attr(ha);
-
/*
* Startup the kernel thread for this host adapter
*/
qla_printk(KERN_WARNING, ha,
"Unable to start DPC thread!\n");
+ ret = -ENODEV;
goto probe_failed;
}
wait_for_completion(&ha->dpc_inited);
- if (IS_QLA2100(ha) || IS_QLA2200(ha))
- ret = request_irq(host->irq, qla2100_intr_handler,
- SA_INTERRUPT|SA_SHIRQ, ha->brd_info->drv_name, ha);
- else
- ret = request_irq(host->irq, qla2300_intr_handler,
- SA_INTERRUPT|SA_SHIRQ, ha->brd_info->drv_name, ha);
- if (ret != 0) {
+ host->this_id = 255;
+ host->cmd_per_lun = 3;
+ host->unique_id = ha->instance;
+ host->max_cmd_len = MAX_CMDSZ;
+ host->max_channel = ha->ports - 1;
+ host->max_lun = MAX_LUNS;
+ host->transportt = qla2xxx_transport_template;
+
+ 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);
DEBUG2(printk("DEBUG: detect hba %ld at address = %p\n",
ha->host_no, ha));
- reg = ha->iobase;
+ ha->isp_ops.disable_intrs(ha);
- /* Disable ISP interrupts. */
- qla2x00_disable_intrs(ha);
-
- /* Ensure mailbox registers are free. */
spin_lock_irqsave(&ha->hardware_lock, flags);
- WRT_REG_WORD(®->semaphore, 0);
- WRT_REG_WORD(®->hccr, HCCR_CLR_RISC_INT);
- WRT_REG_WORD(®->hccr, HCCR_CLR_HOST_INT);
-
- /* Enable proper parity */
- if (!IS_QLA2100(ha) && !IS_QLA2200(ha)) {
- if (IS_QLA2300(ha))
- /* SRAM parity */
- WRT_REG_WORD(®->hccr, (HCCR_ENABLE_PARITY + 0x1));
- else
- /* SRAM, Instruction RAM and GP RAM parity */
- WRT_REG_WORD(®->hccr, (HCCR_ENABLE_PARITY + 0x7));
+ reg = ha->iobase;
+ if (IS_QLA24XX(ha) || IS_QLA25XX(ha)) {
+ WRT_REG_DWORD(®->isp24.hccr, HCCRX_CLR_HOST_INT);
+ WRT_REG_DWORD(®->isp24.hccr, HCCRX_CLR_RISC_INT);
+ } else {
+ WRT_REG_WORD(®->isp.semaphore, 0);
+ WRT_REG_WORD(®->isp.hccr, HCCR_CLR_RISC_INT);
+ WRT_REG_WORD(®->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(®->isp.hccr,
+ (HCCR_ENABLE_PARITY + 0x1));
+ else
+ /* SRAM, Instruction RAM and GP RAM parity */
+ WRT_REG_WORD(®->isp.hccr,
+ (HCCR_ENABLE_PARITY + 0x7));
+ }
}
spin_unlock_irqrestore(&ha->hardware_lock, flags);
- /* Enable chip interrupts. */
- qla2x00_enable_intrs(ha);
+ ha->isp_ops.enable_intrs(ha);
/* v2.19.5b6 */
/*
msleep(10);
}
+ pci_set_drvdata(pdev, ha);
ha->flags.init_done = 1;
num_hosts++;
+ ret = scsi_add_host(host, &pdev->dev);
+ if (ret)
+ goto probe_failed;
+
+ qla2x00_alloc_sysfs_attr(ha);
+
+ qla2x00_init_host_attr(ha);
+
qla_printk(KERN_INFO, ha, "\n"
" QLogic Fibre Channel HBA Driver: %s\n"
" QLogic %s - %s\n"
" %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, qla2x00_get_pci_info_str(ha, pci_info),
- pci_name(ha->pdev), ha->flags.enable_64bit_addressing ? '+': '-',
- ha->host_no, qla2x00_get_fw_version_str(ha, fw_str));
+ ha->brd_info->isp_name, ha->isp_ops.pci_info_str(ha, pci_info),
+ 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. */
list_for_each_entry(fcport, &ha->fcports, list)
probe_failed:
fc_remove_host(ha->host);
- scsi_remove_host(host);
-
-probe_alloc_failed:
qla2x00_free_device(ha);
scsi_host_put(host);
probe_disable_device:
pci_disable_device(pdev);
- return -1;
+probe_out:
+ return ret;
}
EXPORT_SYMBOL_GPL(qla2x00_probe_one);
/* turn-off interrupts on the card */
if (ha->interrupts_on)
- qla2x00_disable_intrs(ha);
+ ha->isp_ops.disable_intrs(ha);
/* Disable timer */
if (ha->timer_active)
{
if (atomic_read(&fcport->state) == FCS_ONLINE && fcport->rport)
fc_remote_port_block(fcport->rport);
- /*
+ /*
* We may need to retry the login, so don't change the state of the
* port but do the retries.
*/
* Context:
*/
void
-qla2x00_mark_all_devices_lost(scsi_qla_host_t *ha)
+qla2x00_mark_all_devices_lost(scsi_qla_host_t *ha)
{
fc_port_t *fcport;
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,
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;
}
*
* Context:
* Kernel context.
- *
+ *
* Note: Sets the ref_count for non Null sp to one.
*/
static int
-qla2x00_allocate_sp_pool(scsi_qla_host_t *ha)
+qla2x00_allocate_sp_pool(scsi_qla_host_t *ha)
{
int rval;
/*
* This routine frees all adapter allocated memory.
- *
+ *
*/
static void
-qla2x00_free_sp_pool( scsi_qla_host_t *ha)
+qla2x00_free_sp_pool( scsi_qla_host_t *ha)
{
if (ha->srb_mempool) {
mempool_destroy(ha->srb_mempool);
if (fcport->flags & FCF_FABRIC_DEVICE) {
if (fcport->flags &
FCF_TAPE_PRESENT)
- qla2x00_fabric_logout(
- ha,
- fcport->loop_id);
+ ha->isp_ops.fabric_logout(
+ ha, fcport->loop_id,
+ fcport->d_id.b.domain,
+ fcport->d_id.b.area,
+ fcport->d_id.b.al_pa);
status = qla2x00_fabric_login(
ha, fcport, &next_loopid);
} else
DEBUG(printk("scsi(%ld): port login OK: logged in ID 0x%x\n",
ha->host_no, fcport->loop_id));
-
+
fcport->port_login_retry_count =
ha->port_down_retry_count * PORT_RETRY_TIME;
atomic_set(&fcport->state, FCS_ONLINE);
clear_bit(LOGIN_RETRY_NEEDED, &ha->dpc_flags);
DEBUG(printk("scsi(%ld): qla2x00_login_retry()\n",
ha->host_no));
-
+
set_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags);
DEBUG(printk("scsi(%ld): qla2x00_login_retry - end\n",
}
if (!ha->interrupts_on)
- qla2x00_enable_intrs(ha);
+ ha->isp_ops.enable_intrs(ha);
ha->dpc_active = 0;
} /* End of while(1) */
* ha = adapter block pointer.
*/
static void
-qla2x00_rst_aen(scsi_qla_host_t *ha)
+qla2x00_rst_aen(scsi_qla_host_t *ha)
{
if (ha->flags.online && !ha->flags.reset_active &&
!atomic_read(&ha->loop_down_timer) &&
}
}
-
-/*
- * 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)
{
}
sp->flags &= ~SRB_DMA_VALID;
}
+ CMD_SP(cmd) = NULL;
}
void
qla2x00_sp_free_dma(ha, sp);
- CMD_SP(cmd) = NULL;
mempool_free(sp, ha->srb_mempool);
cmd->scsi_done(cmd);
*
* Whenever, a port is in the LOST state we start decrementing its port
* down timer every second until it reaches zero. Once it reaches zero
- * the port it marked DEAD.
+ * the port it marked DEAD.
*/
t = 0;
list_for_each_entry(fcport, &ha->fcports, list) {
if (atomic_read(&fcport->port_down_timer) == 0)
continue;
- if (atomic_dec_and_test(&fcport->port_down_timer) != 0)
+ if (atomic_dec_and_test(&fcport->port_down_timer) != 0)
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)));
}
ha->host_no));
if (!IS_QLA2100(ha) && ha->link_down_timeout)
- atomic_set(&ha->loop_state, LOOP_DEAD);
+ atomic_set(&ha->loop_state, LOOP_DEAD);
/* Schedule an ISP abort to return any tape commands. */
spin_lock_irqsave(&ha->hardware_lock, cpu_flags);
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)));
}
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);
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;
}
/**
static void __exit
qla2x00_module_exit(void)
{
+ pci_unregister_driver(&qla2xxx_pci_driver);
kmem_cache_destroy(srb_cachep);
fc_release_transport(qla2xxx_transport_template);
}