#include <linux/moduleparam.h>
#include <linux/vmalloc.h>
+#include <linux/smp_lock.h>
#include <linux/delay.h>
-#include <linux/kthread.h>
#include <scsi/scsi_tcq.h>
#include <scsi/scsicam.h>
int qlport_down_retry = 30;
module_param(qlport_down_retry, int, S_IRUGO|S_IRUSR);
MODULE_PARM_DESC(qlport_down_retry,
- "Maximum number of command retries to a port that returns "
+ "Maximum number of command retries to a port that returns"
"a PORT-DOWN status.");
int ql2xplogiabsentdevice;
module_param(ql2xplogiabsentdevice, int, S_IRUGO|S_IWUSR);
MODULE_PARM_DESC(ql2xplogiabsentdevice,
"Option to enable PLOGI to devices that are not present after "
- "a Fabric scan. This is needed for several broken switches. "
+ "a Fabric scan. This is needed for several broken switches."
"Default is 0 - no PLOGI. 1 - perfom PLOGI.");
int ql2xloginretrycount = 0;
MODULE_PARM_DESC(ql2xloginretrycount,
"Specify an alternate value for the NVRAM login retry count.");
-int ql2xallocfwdump = 1;
-module_param(ql2xallocfwdump, int, S_IRUGO|S_IRUSR);
-MODULE_PARM_DESC(ql2xallocfwdump,
- "Option to enable allocation of memory for a firmware dump "
- "during HBA initialization. Memory allocation requirements "
- "vary by ISP type. Default is 1 - allocate memory.");
-
-int extended_error_logging;
-module_param(extended_error_logging, int, S_IRUGO|S_IRUSR);
-MODULE_PARM_DESC(extended_error_logging,
- "Option to enable extended error logging, "
- "Default is 0 - no logging. 1 - log errors.");
+#if defined(CONFIG_SCSI_QLA2XXX_EMBEDDED_FIRMWARE)
+int ql2xfwloadflash;
+module_param(ql2xfwloadflash, int, S_IRUGO|S_IRUSR);
+MODULE_PARM_DESC(ql2xfwloadflash,
+ "Load ISP24xx firmware image from FLASH (onboard memory).");
+#endif
static void qla2x00_free_device(scsi_qla_host_t *);
"Enables FDMI registratons "
"Default is 0 - no FDMI. 1 - perfom FDMI.");
+int ql2xprocessrscn;
+module_param(ql2xprocessrscn, int, S_IRUGO|S_IRUSR);
+MODULE_PARM_DESC(ql2xprocessrscn,
+ "Option to enable port RSCN handling via a series of less"
+ "fabric intrusive ADISCs and PLOGIs.");
+
/*
* SCSI host template entry points
*/
static struct scsi_host_template qla2x00_driver_template = {
.module = THIS_MODULE,
- .name = QLA2XXX_DRIVER_NAME,
+ .name = "qla2xxx",
.queuecommand = qla2x00_queuecommand,
.eh_abort_handler = qla2xxx_eh_abort,
static struct scsi_host_template qla24xx_driver_template = {
.module = THIS_MODULE,
- .name = QLA2XXX_DRIVER_NAME,
+ .name = "qla2xxx",
.queuecommand = qla24xx_queuecommand,
.eh_abort_handler = qla2xxx_eh_abort,
if (!sp)
return sp;
+ atomic_set(&sp->ref_count, 1);
sp->ha = ha;
sp->fcport = fcport;
sp->cmd = cmd;
while ((!atomic_read(&ha->loop_down_timer) &&
atomic_read(&ha->loop_state) == LOOP_DOWN) ||
atomic_read(&ha->loop_state) != LOOP_READY) {
- if (atomic_read(&ha->loop_state) == LOOP_DEAD) {
- return_status = QLA_FUNCTION_FAILED;
- break;
- }
msleep(1000);
if (time_after_eq(jiffies, loop_timeout)) {
return_status = QLA_FUNCTION_FAILED;
* Either SUCCESS or FAILED.
*
* Note:
-* Only return FAILED if command not returned by firmware.
**************************************************************************/
int
qla2xxx_eh_abort(struct scsi_cmnd *cmd)
unsigned int id, lun;
unsigned long serial;
unsigned long flags;
- int wait = 0;
if (!CMD_SP(cmd))
- return SUCCESS;
+ return FAILED;
- ret = SUCCESS;
+ ret = FAILED;
id = cmd->device->id;
lun = cmd->device->lun;
if (sp->cmd != cmd)
continue;
- DEBUG2(printk("%s(%ld): aborting sp %p from RISC. pid=%ld.\n",
- __func__, ha->host_no, sp, serial));
- DEBUG3(qla2x00_print_scsi_cmd(cmd));
+ DEBUG2(printk("%s(%ld): aborting sp %p from RISC. pid=%ld "
+ "sp->state=%x\n", __func__, ha->host_no, sp, serial,
+ sp->state));
+ DEBUG3(qla2x00_print_scsi_cmd(cmd);)
spin_unlock_irqrestore(&ha->hardware_lock, flags);
if (ha->isp_ops.abort_command(ha, sp)) {
} else {
DEBUG3(printk("%s(%ld): abort_command "
"mbx success.\n", __func__, ha->host_no));
- wait = 1;
+ ret = SUCCESS;
}
spin_lock_irqsave(&ha->hardware_lock, flags);
spin_unlock_irqrestore(&ha->hardware_lock, flags);
/* Wait for the command to be returned. */
- if (wait) {
+ if (ret == SUCCESS) {
if (qla2x00_eh_wait_on_command(ha, cmd) != QLA_SUCCESS) {
qla_printk(KERN_ERR, ha,
"scsi(%ld:%d:%d): Abort handler timed out -- %lx "
"%x.\n", ha->host_no, id, lun, serial, ret);
- ret = FAILED;
}
}
qla_printk(KERN_INFO, ha,
- "scsi(%ld:%d:%d): Abort command issued -- %d %lx %x.\n",
- ha->host_no, id, lun, wait, serial, ret);
+ "scsi(%ld:%d:%d): Abort command issued -- %lx %x.\n", ha->host_no,
+ id, lun, serial, ret);
return ret;
}
{
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 ret;
unsigned int id, lun;
unsigned long serial;
lun = cmd->device->lun;
serial = cmd->serial_number;
- if (!fcport)
+ sp = (srb_t *) CMD_SP(cmd);
+ if (!sp || !fcport)
return ret;
qla_printk(KERN_INFO, ha,
#endif
} else {
DEBUG2(printk(KERN_INFO
- "%s failed: loop not ready\n",__func__));
+ "%s failed: loop not ready\n",__func__);)
}
if (ret == FAILED) {
{
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 ret;
unsigned int id, lun;
unsigned long serial;
lun = cmd->device->lun;
serial = cmd->serial_number;
- if (!fcport)
+ sp = (srb_t *) CMD_SP(cmd);
+ if (!sp || !fcport)
return ret;
qla_printk(KERN_INFO, ha,
{
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 ret;
unsigned int id, lun;
unsigned long serial;
lun = cmd->device->lun;
serial = cmd->serial_number;
- if (!fcport)
+ sp = (srb_t *) CMD_SP(cmd);
+ if (!sp || !fcport)
return ret;
qla_printk(KERN_INFO, ha,
/* Empty */
DEBUG2_3(printk("%s(%ld): **** FAILED ****\n",
__func__,
- ha->host_no));
+ ha->host_no);)
} else {
/* Empty */
DEBUG3(printk("%s(%ld): exiting normally.\n",
__func__,
- ha->host_no));
+ ha->host_no);)
}
return(status);
pci_set_consistent_dma_mask(ha->pdev, DMA_32BIT_MASK);
}
-static inline void
-qla2x00_set_isp_flags(scsi_qla_host_t *ha)
-{
- ha->device_type = DT_EXTENDED_IDS;
- switch (ha->pdev->device) {
- case PCI_DEVICE_ID_QLOGIC_ISP2100:
- ha->device_type |= DT_ISP2100;
- ha->device_type &= ~DT_EXTENDED_IDS;
- ha->fw_srisc_address = RISC_START_ADDRESS_2100;
- break;
- case PCI_DEVICE_ID_QLOGIC_ISP2200:
- ha->device_type |= DT_ISP2200;
- ha->device_type &= ~DT_EXTENDED_IDS;
- ha->fw_srisc_address = RISC_START_ADDRESS_2100;
- break;
- case PCI_DEVICE_ID_QLOGIC_ISP2300:
- ha->device_type |= DT_ISP2300;
- ha->device_type |= DT_ZIO_SUPPORTED;
- ha->fw_srisc_address = RISC_START_ADDRESS_2300;
- break;
- case PCI_DEVICE_ID_QLOGIC_ISP2312:
- ha->device_type |= DT_ISP2312;
- ha->device_type |= DT_ZIO_SUPPORTED;
- ha->fw_srisc_address = RISC_START_ADDRESS_2300;
- break;
- case PCI_DEVICE_ID_QLOGIC_ISP2322:
- ha->device_type |= DT_ISP2322;
- ha->device_type |= DT_ZIO_SUPPORTED;
- if (ha->pdev->subsystem_vendor == 0x1028 &&
- ha->pdev->subsystem_device == 0x0170)
- ha->device_type |= DT_OEM_001;
- ha->fw_srisc_address = RISC_START_ADDRESS_2300;
- break;
- case PCI_DEVICE_ID_QLOGIC_ISP6312:
- ha->device_type |= DT_ISP6312;
- ha->fw_srisc_address = RISC_START_ADDRESS_2300;
- break;
- case PCI_DEVICE_ID_QLOGIC_ISP6322:
- ha->device_type |= DT_ISP6322;
- ha->fw_srisc_address = RISC_START_ADDRESS_2300;
- break;
- case PCI_DEVICE_ID_QLOGIC_ISP2422:
- ha->device_type |= DT_ISP2422;
- ha->device_type |= DT_ZIO_SUPPORTED;
- ha->fw_srisc_address = RISC_START_ADDRESS_2400;
- break;
- case PCI_DEVICE_ID_QLOGIC_ISP2432:
- ha->device_type |= DT_ISP2432;
- ha->device_type |= DT_ZIO_SUPPORTED;
- ha->fw_srisc_address = RISC_START_ADDRESS_2400;
- break;
- case PCI_DEVICE_ID_QLOGIC_ISP5422:
- ha->device_type |= DT_ISP5422;
- ha->fw_srisc_address = RISC_START_ADDRESS_2400;
- break;
- case PCI_DEVICE_ID_QLOGIC_ISP5432:
- ha->device_type |= DT_ISP5432;
- ha->fw_srisc_address = RISC_START_ADDRESS_2400;
- break;
- }
-}
-
static int
qla2x00_iospace_config(scsi_qla_host_t *ha)
{
goto iospace_error_exit;
}
- if (pci_request_regions(ha->pdev, QLA2XXX_DRIVER_NAME)) {
+ if (pci_request_regions(ha->pdev, ha->brd_info->drv_name)) {
qla_printk(KERN_WARNING, ha,
"Failed to reserve PIO/MMIO regions (%s)\n",
pci_name(ha->pdev));
/*
* PCI driver interface
*/
-static int __devinit
-qla2x00_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
+int qla2x00_probe_one(struct pci_dev *pdev, struct qla_board_info *brd_info)
{
int ret = -ENODEV;
device_reg_t __iomem *reg;
ha->pdev = pdev;
ha->host = host;
ha->host_no = host->host_no;
- sprintf(ha->host_str, "%s_%ld", QLA2XXX_DRIVER_NAME, ha->host_no);
+ ha->brd_info = brd_info;
+ sprintf(ha->host_str, "%s_%ld", ha->brd_info->drv_name, ha->host_no);
- /* Set ISP-type information. */
- qla2x00_set_isp_flags(ha);
+ ha->dpc_pid = -1;
/* Configure PCI I/O space */
ret = qla2x00_iospace_config(ha);
spin_lock_init(&ha->hardware_lock);
ha->prev_topology = 0;
+ ha->ports = MAX_BUSES;
ha->init_cb_size = sizeof(init_cb_t);
ha->mgmt_svr_loop_id = MANAGEMENT_SERVER;
ha->link_data_rate = LDR_UNKNOWN;
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;
ha->isp_ops.read_optrom = qla2x00_read_optrom_data;
ha->isp_ops.write_optrom = qla2x00_write_optrom_data;
if (IS_QLA2100(ha)) {
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->isp_ops.beacon_on = qla2x00_beacon_on;
ha->isp_ops.beacon_off = qla2x00_beacon_off;
ha->isp_ops.beacon_blink = qla2x00_beacon_blink;
ha->gid_list_info_size = 6;
if (IS_QLA2322(ha) || IS_QLA6322(ha))
ha->optrom_size = OPTROM_SIZE_2322;
- } else if (IS_QLA24XX(ha) || IS_QLA54XX(ha)) {
+ } 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->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;
+#if defined(CONFIG_SCSI_QLA2XXX_EMBEDDED_FIRMWARE)
+ if (ql2xfwloadflash)
+ ha->isp_ops.load_risc = qla24xx_load_risc_flash;
+#endif
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.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->isp_ops.read_optrom = qla24xx_read_optrom_data;
ha->isp_ops.write_optrom = qla24xx_write_optrom_data;
ha->isp_ops.beacon_on = qla24xx_beacon_on;
INIT_LIST_HEAD(&ha->list);
INIT_LIST_HEAD(&ha->fcports);
+ INIT_LIST_HEAD(&ha->rscn_fcports);
/*
* These locks are used to prevent more than one CPU
*/
spin_lock_init(&ha->mbx_reg_lock);
+ init_completion(&ha->dpc_inited);
+ init_completion(&ha->dpc_exited);
+
qla2x00_config_dma_addressing(ha);
if (qla2x00_mem_alloc(ha)) {
qla_printk(KERN_WARNING, ha,
/*
* Startup the kernel thread for this host adapter
*/
- ha->dpc_thread = kthread_create(qla2x00_do_dpc, ha,
- "%s_dpc", ha->host_str);
- if (IS_ERR(ha->dpc_thread)) {
+ ha->dpc_should_die = 0;
+ ha->dpc_pid = kernel_thread(qla2x00_do_dpc, ha, 0);
+ if (ha->dpc_pid < 0) {
qla_printk(KERN_WARNING, ha,
"Unable to start DPC thread!\n");
- ret = PTR_ERR(ha->dpc_thread);
+
+ ret = -ENODEV;
goto probe_failed;
}
+ wait_for_completion(&ha->dpc_inited);
host->this_id = 255;
host->cmd_per_lun = 3;
host->unique_id = ha->instance;
host->max_cmd_len = MAX_CMDSZ;
- host->max_channel = MAX_BUSES - 1;
+ 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,
- IRQF_DISABLED|IRQF_SHARED, QLA2XXX_DRIVER_NAME, ha);
+ 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",
spin_lock_irqsave(&ha->hardware_lock, flags);
reg = ha->iobase;
- if (IS_QLA24XX(ha) || IS_QLA54XX(ha)) {
+ 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 {
probe_out:
return ret;
}
+EXPORT_SYMBOL_GPL(qla2x00_probe_one);
-static void __devexit
-qla2x00_remove_one(struct pci_dev *pdev)
+void qla2x00_remove_one(struct pci_dev *pdev)
{
scsi_qla_host_t *ha;
pci_set_drvdata(pdev, NULL);
}
+EXPORT_SYMBOL_GPL(qla2x00_remove_one);
static void
qla2x00_free_device(scsi_qla_host_t *ha)
{
+ int ret;
+
+ /* Abort any outstanding IO descriptors. */
+ if (!IS_QLA2100(ha) && !IS_QLA2200(ha))
+ qla2x00_cancel_io_descriptors(ha);
+
/* Disable timer */
if (ha->timer_active)
qla2x00_stop_timer(ha);
/* Kill the kernel thread for this host */
- if (ha->dpc_thread) {
- struct task_struct *t = ha->dpc_thread;
+ if (ha->dpc_pid >= 0) {
+ ha->dpc_should_die = 1;
+ wmb();
+ ret = kill_proc(ha->dpc_pid, SIGHUP, 1);
+ if (ret) {
+ qla_printk(KERN_ERR, ha,
+ "Unable to signal DPC thread -- (%d)\n", ret);
- /*
- * qla2xxx_wake_dpc checks for ->dpc_thread
- * so we need to zero it out.
- */
- ha->dpc_thread = NULL;
- kthread_stop(t);
+ /* TODO: SOMETHING MORE??? */
+ } else {
+ wait_for_completion(&ha->dpc_exited);
+ }
}
- if (ha->eft)
- qla2x00_trace_control(ha, TC_DISABLE, 0, 0);
-
/* Stop currently executing firmware. */
qla2x00_stop_firmware(ha);
ha->flags.online = 0;
/* Detach interrupts */
- if (ha->host->irq)
- free_irq(ha->host->irq, ha);
+ if (ha->pdev->irq)
+ free_irq(ha->pdev->irq, ha);
/* release io space registers */
if (ha->iobase)
atomic_set(&fcport->state, FCS_DEVICE_LOST);
}
- if (defer)
- qla2xxx_wake_dpc(ha);
+ if (defer && ha->dpc_wait && !ha->dpc_active)
+ up(ha->dpc_wait);
}
/*
continue;
}
- snprintf(name, sizeof(name), "%s_%ld", QLA2XXX_DRIVER_NAME,
- ha->host_no);
+ ha->rlc_rsp = dma_alloc_coherent(&ha->pdev->dev,
+ sizeof(rpt_lun_cmd_rsp_t), &ha->rlc_rsp_dma, GFP_KERNEL);
+ if (ha->rlc_rsp == NULL) {
+ qla_printk(KERN_WARNING, ha,
+ "Memory Allocation failed - rlc");
+
+ qla2x00_mem_free(ha);
+ msleep(100);
+
+ continue;
+ }
+
+ snprintf(name, sizeof(name), "qla2xxx_%ld", ha->host_no);
ha->s_dma_pool = dma_pool_create(name, &ha->pdev->dev,
DMA_POOL_SIZE, 8, 0);
if (ha->s_dma_pool == NULL) {
}
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,
+ &ha->iodesc_pd_dma);
+ if (ha->iodesc_pd == NULL) {
+ /* error */
+ qla_printk(KERN_WARNING, ha,
+ "Memory Allocation failed - iodesc_pd\n");
+
+ qla2x00_mem_free(ha);
+ msleep(100);
+
+ continue;
+ }
+ memset(ha->iodesc_pd, 0, PORT_DATABASE_SIZE);
+
+ /* Allocate ioctl related memory. */
+ if (qla2x00_alloc_ioctl_mem(ha)) {
+ qla_printk(KERN_WARNING, ha,
+ "Memory Allocation failed - ioctl_mem\n");
+
+ qla2x00_mem_free(ha);
+ msleep(100);
+
+ continue;
+ }
+
if (qla2x00_allocate_sp_pool(ha)) {
qla_printk(KERN_WARNING, ha,
"Memory Allocation failed - "
continue;
}
memset(ha->ct_sns, 0, sizeof(struct ct_sns_pkt));
-
- if (IS_QLA24XX(ha) || IS_QLA54XX(ha)) {
- /*
- * Get consistent memory allocated for SFP
- * block.
- */
- ha->sfp_data = dma_pool_alloc(ha->s_dma_pool,
- GFP_KERNEL, &ha->sfp_data_dma);
- if (ha->sfp_data == NULL) {
- qla_printk(KERN_WARNING, ha,
- "Memory Allocation failed - "
- "sfp_data\n");
-
- qla2x00_mem_free(ha);
- msleep(100);
-
- continue;
- }
- memset(ha->sfp_data, 0, SFP_BLOCK_SIZE);
- }
}
/* Done all allocations without any error. */
{
struct list_head *fcpl, *fcptemp;
fc_port_t *fcport;
+ unsigned int wtime;/* max wait time if mbx cmd is busy. */
if (ha == NULL) {
/* error */
return;
}
+ /* Make sure all other threads are stopped. */
+ wtime = 60 * 1000;
+ while (ha->dpc_wait && wtime)
+ wtime = msleep_interruptible(wtime);
+
+ /* free ioctl memory */
+ qla2x00_free_ioctl_mem(ha);
+
/* free sp pool */
qla2x00_free_sp_pool(ha);
- if (ha->fw_dump) {
- if (ha->eft)
- dma_free_coherent(&ha->pdev->dev,
- ntohl(ha->fw_dump->eft_size), ha->eft, ha->eft_dma);
- vfree(ha->fw_dump);
- }
-
if (ha->sns_cmd)
dma_free_coherent(&ha->pdev->dev, sizeof(struct sns_cmd_pkt),
ha->sns_cmd, ha->sns_cmd_dma);
dma_free_coherent(&ha->pdev->dev, sizeof(struct ct_sns_pkt),
ha->ct_sns, ha->ct_sns_dma);
- if (ha->sfp_data)
- dma_pool_free(ha->s_dma_pool, ha->sfp_data, ha->sfp_data_dma);
-
if (ha->ms_iocb)
dma_pool_free(ha->s_dma_pool, ha->ms_iocb, ha->ms_iocb_dma);
+ if (ha->iodesc_pd)
+ dma_pool_free(ha->s_dma_pool, ha->iodesc_pd, ha->iodesc_pd_dma);
+
if (ha->init_cb)
dma_pool_free(ha->s_dma_pool, ha->init_cb, ha->init_cb_dma);
if (ha->s_dma_pool)
dma_pool_destroy(ha->s_dma_pool);
+ if (ha->rlc_rsp)
+ dma_free_coherent(&ha->pdev->dev,
+ sizeof(rpt_lun_cmd_rsp_t), ha->rlc_rsp,
+ ha->rlc_rsp_dma);
+
if (ha->gid_list)
dma_free_coherent(&ha->pdev->dev, GID_LIST_SIZE, ha->gid_list,
ha->gid_list_dma);
(ha->request_q_length + 1) * sizeof(request_t),
ha->request_ring, ha->request_dma);
- ha->eft = NULL;
- ha->eft_dma = 0;
ha->sns_cmd = NULL;
ha->sns_cmd_dma = 0;
ha->ct_sns = NULL;
ha->ct_sns_dma = 0;
ha->ms_iocb = NULL;
ha->ms_iocb_dma = 0;
+ ha->iodesc_pd = NULL;
+ ha->iodesc_pd_dma = 0;
ha->init_cb = NULL;
ha->init_cb_dma = 0;
ha->s_dma_pool = NULL;
+ ha->rlc_rsp = NULL;
+ ha->rlc_rsp_dma = 0;
ha->gid_list = NULL;
ha->gid_list_dma = 0;
}
INIT_LIST_HEAD(&ha->fcports);
+ if (ha->fw_dump)
+ free_pages((unsigned long)ha->fw_dump, ha->fw_dump_order);
+
+ 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;
vfree(ha->optrom_buffer);
}
*
* 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)
int rval;
rval = QLA_SUCCESS;
- ha->srb_mempool = mempool_create_slab_pool(SRB_MIN_REQ, srb_cachep);
+ ha->srb_mempool = mempool_create(SRB_MIN_REQ, mempool_alloc_slab,
+ mempool_free_slab, srb_cachep);
if (ha->srb_mempool == NULL) {
qla_printk(KERN_INFO, ha, "Unable to allocate SRB mempool.\n");
rval = QLA_FUNCTION_FAILED;
static int
qla2x00_do_dpc(void *data)
{
+ DECLARE_MUTEX_LOCKED(sem);
scsi_qla_host_t *ha;
fc_port_t *fcport;
uint8_t status;
ha = (scsi_qla_host_t *)data;
+ lock_kernel();
+
+ daemonize("%s_dpc", ha->host_str);
+ allow_signal(SIGHUP);
+
+ ha->dpc_wait = &sem;
+
set_user_nice(current, -20);
- while (!kthread_should_stop()) {
+ unlock_kernel();
+
+ complete(&ha->dpc_inited);
+
+ while (1) {
DEBUG3(printk("qla2x00: DPC handler sleeping\n"));
- set_current_state(TASK_INTERRUPTIBLE);
- schedule();
- __set_current_state(TASK_RUNNING);
+ if (down_interruptible(&sem))
+ break;
+
+ if (ha->dpc_should_die)
+ break;
DEBUG3(printk("qla2x00: DPC handler waking up\n"));
/* Initialization not yet finished. Don't do anything yet. */
- if (!ha->flags.init_done)
+ if (!ha->flags.init_done || ha->dpc_active)
continue;
DEBUG3(printk("scsi(%ld): DPC handler\n", ha->host_no));
next_loopid = 0;
list_for_each_entry(fcport, &ha->fcports, list) {
+ if (fcport->port_type != FCT_TARGET)
+ continue;
+
/*
* If the port is not ONLINE then try to login
* to it if we haven't run out of retries.
} else
status =
qla2x00_local_device_login(
- ha, fcport);
+ ha, fcport->loop_id);
if (status == QLA_SUCCESS) {
fcport->old_loop_id = fcport->loop_id;
/*
* Make sure that nobody tries to wake us up again.
*/
+ ha->dpc_wait = NULL;
ha->dpc_active = 0;
- return 0;
-}
-
-void
-qla2xxx_wake_dpc(scsi_qla_host_t *ha)
-{
- if (ha->dpc_thread)
- wake_up_process(ha->dpc_thread);
+ complete_and_exit(&ha->dpc_exited, 0);
}
/*
test_bit(LOGIN_RETRY_NEEDED, &ha->dpc_flags) ||
test_bit(RESET_MARKER_NEEDED, &ha->dpc_flags) ||
test_bit(BEACON_BLINK_NEEDED, &ha->dpc_flags) ||
- test_bit(RELOGIN_NEEDED, &ha->dpc_flags)))
- qla2xxx_wake_dpc(ha);
+ test_bit(RELOGIN_NEEDED, &ha->dpc_flags)) &&
+ ha->dpc_wait && !ha->dpc_active) {
+
+ up(ha->dpc_wait);
+ }
qla2x00_restart_timer(ha, WATCH_INTERVAL);
}
return -ETIMEDOUT;
}
+#if defined(CONFIG_SCSI_QLA2XXX_EMBEDDED_FIRMWARE)
+
+#define qla2x00_release_firmware() do { } while (0)
+#define qla2x00_pci_module_init() (0)
+#define qla2x00_pci_module_exit() do { } while (0)
+
+#else /* !defined(CONFIG_SCSI_QLA2XXX_EMBEDDED_FIRMWARE) */
+
/* Firmware interface routines. */
-#define FW_BLOBS 5
+#define FW_BLOBS 6
#define FW_ISP21XX 0
#define FW_ISP22XX 1
#define FW_ISP2300 2
#define FW_ISP2322 3
-#define FW_ISP24XX 4
+#define FW_ISP63XX 4
+#define FW_ISP24XX 5
static DECLARE_MUTEX(qla_fw_lock);
-extern struct firmware ql2100_fw, ql2200_fw, ql2300_fw, ql2322_fw, ql2400_fw;
-
static struct fw_blob qla_fw_blobs[FW_BLOBS] = {
- { .name = "ql2100_fw.bin", .segs = { 0x1000, 0 }, .fw = &ql2100_fw },
- { .name = "ql2200_fw.bin", .segs = { 0x1000, 0 }, .fw = &ql2200_fw },
- { .name = "ql2300_fw.bin", .segs = { 0x800, 0 }, .fw = &ql2300_fw },
- { .name = "ql2322_fw.bin", .segs = { 0x800, 0x1c000, 0x1e000, 0 }, .fw = &ql2322_fw },
- { .name = "ql2400_fw.bin", .fw = &ql2400_fw },
+ { .name = "ql2100_fw.bin", .segs = { 0x1000, 0 }, },
+ { .name = "ql2200_fw.bin", .segs = { 0x1000, 0 }, },
+ { .name = "ql2300_fw.bin", .segs = { 0x800, 0 }, },
+ { .name = "ql2322_fw.bin", .segs = { 0x800, 0x1c000, 0x1e000, 0 }, },
+ { .name = "ql6312_fw.bin", .segs = { 0x800, 0 }, },
+ { .name = "ql2400_fw.bin", },
};
struct fw_blob *
blob = &qla_fw_blobs[FW_ISP21XX];
} else if (IS_QLA2200(ha)) {
blob = &qla_fw_blobs[FW_ISP22XX];
- } else if (IS_QLA2300(ha) || IS_QLA2312(ha) || IS_QLA6312(ha)) {
+ } else if (IS_QLA2300(ha) || IS_QLA2312(ha)) {
blob = &qla_fw_blobs[FW_ISP2300];
- } else if (IS_QLA2322(ha) || IS_QLA6322(ha)) {
+ } else if (IS_QLA2322(ha)) {
blob = &qla_fw_blobs[FW_ISP2322];
- } else if (IS_QLA24XX(ha) || IS_QLA54XX(ha)) {
+ } else if (IS_QLA6312(ha) || IS_QLA6322(ha)) {
+ blob = &qla_fw_blobs[FW_ISP63XX];
+ } else if (IS_QLA24XX(ha)) {
blob = &qla_fw_blobs[FW_ISP24XX];
}
up(&qla_fw_lock);
}
+static struct qla_board_info qla_board_tbl = {
+ .drv_name = "qla2xxx",
+};
+
static struct pci_device_id qla2xxx_pci_tbl[] = {
- { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2100) },
- { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2200) },
- { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2300) },
- { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2312) },
- { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2322) },
- { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP6312) },
- { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP6322) },
- { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2422) },
- { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2432) },
- { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP5422) },
- { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP5432) },
+ { PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2100,
+ PCI_ANY_ID, PCI_ANY_ID, },
+ { PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2200,
+ PCI_ANY_ID, PCI_ANY_ID, },
+ { PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2300,
+ PCI_ANY_ID, PCI_ANY_ID, },
+ { PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2312,
+ PCI_ANY_ID, PCI_ANY_ID, },
+ { PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2322,
+ PCI_ANY_ID, PCI_ANY_ID, },
+ { PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP6312,
+ PCI_ANY_ID, PCI_ANY_ID, },
+ { PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP6322,
+ PCI_ANY_ID, PCI_ANY_ID, },
+ { PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2422,
+ PCI_ANY_ID, PCI_ANY_ID, },
+ { PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2432,
+ PCI_ANY_ID, PCI_ANY_ID, },
{ 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, &qla_board_tbl);
+}
+
+static void __devexit
+qla2xxx_remove_one(struct pci_dev *pdev)
+{
+ qla2x00_remove_one(pdev);
+}
+
static struct pci_driver qla2xxx_pci_driver = {
- .name = QLA2XXX_DRIVER_NAME,
+ .name = "qla2xxx",
.driver = {
.owner = THIS_MODULE,
},
.id_table = qla2xxx_pci_tbl,
- .probe = qla2x00_probe_one,
- .remove = __devexit_p(qla2x00_remove_one),
+ .probe = qla2xxx_probe_one,
+ .remove = __devexit_p(qla2xxx_remove_one),
};
+static inline int
+qla2x00_pci_module_init(void)
+{
+ return pci_module_init(&qla2xxx_pci_driver);
+}
+
+static inline void
+qla2x00_pci_module_exit(void)
+{
+ pci_unregister_driver(&qla2xxx_pci_driver);
+}
+
+#endif
+
/**
* qla2x00_module_init - Module initialization.
**/
/* Derive version string. */
strcpy(qla2x00_version_str, QLA2XXX_VERSION);
- if (extended_error_logging)
- strcat(qla2x00_version_str, "-debug");
-
+#if defined(CONFIG_SCSI_QLA2XXX_EMBEDDED_FIRMWARE)
+ strcat(qla2x00_version_str, "-fw");
+#endif
+#if DEBUG_QLA2100
+ strcat(qla2x00_version_str, "-debug");
+#endif
qla2xxx_transport_template =
fc_attach_transport(&qla2xxx_transport_functions);
if (!qla2xxx_transport_template)
return -ENODEV;
printk(KERN_INFO "QLogic Fibre Channel HBA Driver\n");
- ret = pci_register_driver(&qla2xxx_pci_driver);
+ ret = qla2x00_pci_module_init();
if (ret) {
kmem_cache_destroy(srb_cachep);
fc_release_transport(qla2xxx_transport_template);
static void __exit
qla2x00_module_exit(void)
{
- pci_unregister_driver(&qla2xxx_pci_driver);
- /* qla2x00_release_firmware(); */
+ qla2x00_pci_module_exit();
+ qla2x00_release_firmware();
kmem_cache_destroy(srb_cachep);
fc_release_transport(qla2xxx_transport_template);
}
git://git.onelab.eu / linux-2.6.git / blobdiff