X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=drivers%2Fscsi%2Fqla2xxx%2Fqla_os.c;h=584fe5d8e50789312776a50125d76464e6be2e9b;hb=43bc926fffd92024b46cafaf7350d669ba9ca884;hp=22bdb841c8e4753b85a3fb6b57aa92fbf6ff22d8;hpb=6a77f38946aaee1cd85eeec6cf4229b204c15071;p=linux-2.6.git diff --git a/drivers/scsi/qla2xxx/qla_os.c b/drivers/scsi/qla2xxx/qla_os.c index 22bdb841c..584fe5d8e 100644 --- a/drivers/scsi/qla2xxx/qla_os.c +++ b/drivers/scsi/qla2xxx/qla_os.c @@ -1,27 +1,15 @@ /* - * QLOGIC LINUX SOFTWARE - * - * QLogic ISP2x00 device driver for Linux 2.6.x - * Copyright (C) 2003-2004 QLogic Corporation - * (www.qlogic.com) - * - * This program is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License as published by the - * Free Software Foundation; either version 2, or (at your option) any - * later version. - * - * This program is distributed in the hope that it will be useful, but - * WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * General Public License for more details. + * QLogic Fibre Channel HBA Driver + * Copyright (c) 2003-2005 QLogic Corporation * + * See LICENSE.qla2xxx for copyright and licensing details. */ #include "qla_def.h" #include #include -#include #include +#include #include #include @@ -36,50 +24,24 @@ char qla2x00_version_str[40]; /* * SRB allocation cache */ -char srb_cachep_name[16]; -kmem_cache_t *srb_cachep; - -/* - * Stats for all adpaters. - */ -struct _qla2x00stats qla2x00_stats; +static kmem_cache_t *srb_cachep; /* * Ioctl related information. */ -int num_hosts; -int apiHBAInstance; - -/* - * Module parameter information and variables - */ -int ql2xmaxqdepth; -module_param(ql2xmaxqdepth, int, S_IRUGO|S_IWUSR); -MODULE_PARM_DESC(ql2xmaxqdepth, - "Maximum queue depth to report for target devices."); +static int num_hosts; int ql2xlogintimeout = 20; module_param(ql2xlogintimeout, int, S_IRUGO|S_IRUSR); MODULE_PARM_DESC(ql2xlogintimeout, "Login timeout value in seconds."); -int qlport_down_retry; +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" "a PORT-DOWN status."); -int ql2xretrycount = 20; -module_param(ql2xretrycount, int, S_IRUGO|S_IWUSR); -MODULE_PARM_DESC(ql2xretrycount, - "Maximum number of mid-layer retries allowed for a command. " - "Default value is 20, "); - -int displayConfig; -module_param(displayConfig, int, S_IRUGO|S_IWUSR); -MODULE_PARM_DESC(displayConfig, - "If 1 then display the configuration used in /etc/modprobe.conf."); - int ql2xplogiabsentdevice; module_param(ql2xplogiabsentdevice, int, S_IRUGO|S_IWUSR); MODULE_PARM_DESC(ql2xplogiabsentdevice, @@ -87,72 +49,44 @@ MODULE_PARM_DESC(ql2xplogiabsentdevice, "a Fabric scan. This is needed for several broken switches." "Default is 0 - no PLOGI. 1 - perfom PLOGI."); -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" - " use the default set in the NVRAM." - " Default is 0 : disabled"); - -int ql2xintrdelaytimer = 10; -module_param(ql2xintrdelaytimer, int, S_IRUGO|S_IRUSR); -MODULE_PARM_DESC(ql2xintrdelaytimer, - "ZIO: Waiting time for Firmware before it generates an " - "interrupt to the host to notify completion of request."); - -int ConfigRequired; -module_param(ConfigRequired, int, S_IRUGO|S_IRUSR); -MODULE_PARM_DESC(ConfigRequired, - "If 1, then only configured devices passed in through the" - "ql2xopts parameter will be presented to the OS"); - -int Bind = BIND_BY_PORT_NAME; -module_param(Bind, int, S_IRUGO|S_IRUSR); -MODULE_PARM_DESC(Bind, - "Target persistent binding method: " - "0 by Portname (default); 1 by PortID; 2 by Nodename. "); - -int ql2xsuspendcount = SUSPEND_COUNT; -module_param(ql2xsuspendcount, int, S_IRUGO|S_IWUSR); -MODULE_PARM_DESC(ql2xsuspendcount, - "Number of 6-second suspend iterations to perform while a " - "target returns a status. Default is 10 " - "iterations."); - -int ql2xdoinitscan = 1; -module_param(ql2xdoinitscan, int, S_IRUGO|S_IWUSR); -MODULE_PARM_DESC(ql2xdoinitscan, - "Signal mid-layer to perform scan after driver load: 0 -- no " - "signal sent to mid-layer."); - int ql2xloginretrycount = 0; module_param(ql2xloginretrycount, int, S_IRUGO|S_IRUSR); MODULE_PARM_DESC(ql2xloginretrycount, "Specify an alternate value for the NVRAM login retry count."); -/* - * Proc structures and functions - */ -struct info_str { - char *buffer; - int length; - off_t offset; - int pos; -}; - -static void copy_mem_info(struct info_str *, char *, int); -static int copy_info(struct info_str *, char *, ...); +#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 *); static void qla2x00_config_dma_addressing(scsi_qla_host_t *ha); +int ql2xfdmienable; +module_param(ql2xfdmienable, int, S_IRUGO|S_IRUSR); +MODULE_PARM_DESC(ql2xfdmienable, + "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 + * 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 *); @@ -160,14 +94,12 @@ static int qla2xxx_eh_host_reset(struct scsi_cmnd *); static int qla2x00_loop_reset(scsi_qla_host_t *ha); static int qla2x00_device_reset(scsi_qla_host_t *, fc_port_t *); -static int qla2x00_proc_info(struct Scsi_Host *, char *, char **, - off_t, int, int); +static int qla2x00_change_queue_depth(struct scsi_device *, int); +static int qla2x00_change_queue_type(struct scsi_device *, int); static struct scsi_host_template qla2x00_driver_template = { .module = THIS_MODULE, .name = "qla2xxx", - .proc_name = "qla2xxx", - .proc_info = qla2x00_proc_info, .queuecommand = qla2x00_queuecommand, .eh_abort_handler = qla2xxx_eh_abort, @@ -177,6 +109,10 @@ static struct scsi_host_template qla2x00_driver_template = { .slave_configure = qla2xxx_slave_configure, + .slave_alloc = qla2xxx_slave_alloc, + .slave_destroy = qla2xxx_slave_destroy, + .change_queue_depth = qla2x00_change_queue_depth, + .change_queue_type = qla2x00_change_queue_type, .this_id = -1, .cmd_per_lun = 3, .use_clustering = ENABLE_CLUSTERING, @@ -187,11 +123,35 @@ static struct scsi_host_template qla2x00_driver_template = { * which equates to 0x800000 sectors. */ .max_sectors = 0xFFFF, + .shost_attrs = qla2x00_host_attrs, }; -static struct scsi_transport_template *qla2xxx_transport_template = NULL; +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, + .change_queue_depth = qla2x00_change_queue_depth, + .change_queue_type = qla2x00_change_queue_type, + .this_id = -1, + .cmd_per_lun = 3, + .use_clustering = ENABLE_CLUSTERING, + .sg_tablesize = SG_ALL, + + .max_sectors = 0xFFFF, + .shost_attrs = qla2x00_host_attrs, +}; -static void qla2x00_display_fc_names(scsi_qla_host_t *); +static struct scsi_transport_template *qla2xxx_transport_template = NULL; /* TODO Convert to inlines * @@ -230,168 +190,6 @@ qla2x00_stop_timer(scsi_qla_host_t *ha) ha->timer_active = 0; } -void qla2x00_cmd_timeout(srb_t *); - -static __inline__ void qla2x00_callback(scsi_qla_host_t *, struct scsi_cmnd *); -static __inline__ void sp_put(struct scsi_qla_host * ha, srb_t *sp); -static __inline__ void sp_get(struct scsi_qla_host * ha, srb_t *sp); -static __inline__ void -qla2x00_delete_from_done_queue(scsi_qla_host_t *, srb_t *); - -/* -* qla2x00_callback -* Returns the completed SCSI command to LINUX. -* -* Input: -* ha -- Host adapter structure -* cmd -- SCSI mid-level command structure. -* Returns: -* None -* Note:From failover point of view we always get the sp -* from vis_ha pool in queuecommand.So when we put it -* back to the pool it has to be the vis_ha. -* So rely on struct scsi_cmnd to get the vis_ha and not on sp. -*/ -static inline void -qla2x00_callback(scsi_qla_host_t *ha, struct scsi_cmnd *cmd) -{ - srb_t *sp = (srb_t *) CMD_SP(cmd); - scsi_qla_host_t *vis_ha; - os_lun_t *lq; - int got_sense; - unsigned long cpu_flags = 0; - - cmd->host_scribble = (unsigned char *) NULL; - vis_ha = (scsi_qla_host_t *) cmd->device->host->hostdata; - - if (sp == NULL) { - qla_printk(KERN_INFO, ha, - "%s(): **** CMD derives a NULL SP\n", - __func__); - DEBUG2(BUG();) - return; - } - - /* - * If command status is not DID_BUS_BUSY then go ahead and freed sp. - */ - /* - * Cancel command timeout - */ - qla2x00_delete_timer_from_cmd(sp); - - /* - * Put SP back in the free queue - */ - sp->cmd = NULL; - CMD_SP(cmd) = NULL; - lq = sp->lun_queue; - got_sense = (sp->flags & SRB_GOT_SENSE)? 1: 0; - add_to_free_queue(vis_ha, sp); - - if (host_byte(cmd->result) == DID_OK) { - /* device ok */ - ha->total_bytes += cmd->bufflen; - if (!got_sense) { - /* If lun was suspended then clear retry count */ - spin_lock_irqsave(&lq->q_lock, cpu_flags); - if (!test_bit(LUN_EXEC_DELAYED, &lq->q_flag)) - lq->q_state = LUN_STATE_READY; - spin_unlock_irqrestore(&lq->q_lock, cpu_flags); - } - } else if (host_byte(cmd->result) == DID_ERROR) { - /* device error */ - ha->total_dev_errs++; - } - - /* Call the mid-level driver interrupt handler */ - (*(cmd)->scsi_done)(cmd); -} - -/************************************************************************** -* sp_put -* -* Description: -* Decrement reference count and call the callback if we're the last -* owner of the specified sp. Will get the host_lock before calling -* the callback. -* -* Input: -* ha - pointer to the scsi_qla_host_t where the callback is to occur. -* sp - pointer to srb_t structure to use. -* -* Returns: -* -**************************************************************************/ -static inline void -sp_put(struct scsi_qla_host * ha, srb_t *sp) -{ - if (atomic_read(&sp->ref_count) == 0) { - qla_printk(KERN_INFO, ha, - "%s(): **** SP->ref_count not zero\n", - __func__); - DEBUG2(BUG();) - - return; - } - - if (!atomic_dec_and_test(&sp->ref_count)) { - return; - } - - qla2x00_callback(ha, sp->cmd); -} - -/************************************************************************** -* sp_get -* -* Description: -* Increment reference count of the specified sp. -* -* Input: -* sp - pointer to srb_t structure to use. -* -* Returns: -* -**************************************************************************/ -static inline void -sp_get(struct scsi_qla_host * ha, srb_t *sp) -{ - atomic_inc(&sp->ref_count); - - if (atomic_read(&sp->ref_count) > 2) { - qla_printk(KERN_INFO, ha, - "%s(): **** SP->ref_count greater than two\n", - __func__); - DEBUG2(BUG();) - - return; - } -} - -static inline void -qla2x00_delete_from_done_queue(scsi_qla_host_t *dest_ha, srb_t *sp) -{ - /* remove command from done list */ - list_del_init(&sp->list); - dest_ha->done_q_cnt--; - sp->state = SRB_NO_QUEUE_STATE; - - if (sp->flags & SRB_DMA_VALID) { - sp->flags &= ~SRB_DMA_VALID; - - /* Release memory used for this I/O */ - if (sp->cmd->use_sg) { - pci_unmap_sg(dest_ha->pdev, sp->cmd->request_buffer, - sp->cmd->use_sg, sp->cmd->sc_data_direction); - } else if (sp->cmd->request_bufflen) { - pci_unmap_page(dest_ha->pdev, sp->dma_handle, - sp->cmd->request_bufflen, - sp->cmd->sc_data_direction); - } - } -} - static int qla2x00_do_dpc(void *data); static void qla2x00_rst_aen(scsi_qla_host_t *); @@ -400,188 +198,13 @@ 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 *ha); - -static ssize_t qla2x00_sysfs_read_fw_dump(struct kobject *, char *, loff_t, - size_t); -static ssize_t qla2x00_sysfs_write_fw_dump(struct kobject *, char *, loff_t, - size_t); -static struct bin_attribute sysfs_fw_dump_attr = { - .attr = { - .name = "fw_dump", - .mode = S_IRUSR | S_IWUSR, - .owner = THIS_MODULE, - }, - .size = 0, - .read = qla2x00_sysfs_read_fw_dump, - .write = qla2x00_sysfs_write_fw_dump, -}; -static ssize_t qla2x00_sysfs_read_nvram(struct kobject *, char *, loff_t, - size_t); -static ssize_t qla2x00_sysfs_write_nvram(struct kobject *, char *, loff_t, - size_t); -static struct bin_attribute sysfs_nvram_attr = { - .attr = { - .name = "nvram", - .mode = S_IRUSR | S_IWUSR, - .owner = THIS_MODULE, - }, - .size = sizeof(nvram_t), - .read = qla2x00_sysfs_read_nvram, - .write = qla2x00_sysfs_write_nvram, -}; +static void qla2x00_sp_free_dma(scsi_qla_host_t *, srb_t *); +void qla2x00_sp_compl(scsi_qla_host_t *ha, srb_t *); /* -------------------------------------------------------------------------- */ - -/* SysFS attributes. */ -static ssize_t qla2x00_sysfs_read_fw_dump(struct kobject *kobj, char *buf, - loff_t off, size_t count) -{ - struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj, - struct device, kobj))); - - if (ha->fw_dump_reading == 0) - return 0; - if (off > ha->fw_dump_buffer_len) - return 0; - if (off + count > ha->fw_dump_buffer_len) - count = ha->fw_dump_buffer_len - off; - - memcpy(buf, &ha->fw_dump_buffer[off], count); - - return (count); -} - -static ssize_t qla2x00_sysfs_write_fw_dump(struct kobject *kobj, char *buf, - loff_t off, size_t count) -{ - struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj, - struct device, kobj))); - int reading; - uint32_t dump_size; - - if (off != 0) - return (0); - - reading = simple_strtol(buf, NULL, 10); - switch (reading) { - case 0: - if (ha->fw_dump_reading == 1) { - qla_printk(KERN_INFO, ha, - "Firmware dump cleared on (%ld).\n", - ha->host_no); - - vfree(ha->fw_dump_buffer); - 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; - } - break; - case 1: - if (ha->fw_dump != NULL && !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; - ha->fw_dump_buffer = (char *)vmalloc(dump_size); - if (ha->fw_dump_buffer == NULL) { - qla_printk(KERN_WARNING, ha, - "Unable to allocate memory for firmware " - "dump buffer (%d).\n", dump_size); - - ha->fw_dump_reading = 0; - return (count); - } - qla_printk(KERN_INFO, ha, - "Firmware dump ready for read on (%ld).\n", - ha->host_no); - memset(ha->fw_dump_buffer, 0, dump_size); - if (IS_QLA2100(ha) || IS_QLA2200(ha)) - qla2100_ascii_fw_dump(ha); - else - qla2300_ascii_fw_dump(ha); - ha->fw_dump_buffer_len = strlen(ha->fw_dump_buffer); - } - break; - } - return (count); -} - -static ssize_t qla2x00_sysfs_read_nvram(struct kobject *kobj, char *buf, - loff_t off, size_t count) -{ - struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj, - struct device, kobj))); - uint16_t *witer; - unsigned long flags; - uint16_t cnt; - - if (!capable(CAP_SYS_ADMIN) || off != 0 || count != sizeof(nvram_t)) - return 0; - - /* Read NVRAM. */ - spin_lock_irqsave(&ha->hardware_lock, flags); - qla2x00_lock_nvram_access(ha); - witer = (uint16_t *)buf; - for (cnt = 0; cnt < count / 2; cnt++) { - *witer = cpu_to_le16(qla2x00_get_nvram_word(ha, - cnt+ha->nvram_base)); - witer++; - } - qla2x00_unlock_nvram_access(ha); - spin_unlock_irqrestore(&ha->hardware_lock, flags); - - return (count); -} - -static ssize_t qla2x00_sysfs_write_nvram(struct kobject *kobj, char *buf, - loff_t off, size_t count) -{ - struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj, - struct device, kobj))); - uint8_t *iter; - uint16_t *witer; - unsigned long flags; - uint16_t cnt; - uint8_t chksum; - - if (!capable(CAP_SYS_ADMIN) || off != 0 || count != sizeof(nvram_t)) - return 0; - - /* Checksum NVRAM. */ - iter = (uint8_t *)buf; - chksum = 0; - for (cnt = 0; cnt < count - 1; cnt++) - chksum += *iter++; - chksum = ~chksum + 1; - *iter = chksum; - - /* Write NVRAM. */ - spin_lock_irqsave(&ha->hardware_lock, flags); - qla2x00_lock_nvram_access(ha); - qla2x00_release_nvram_protection(ha); - witer = (uint16_t *)buf; - for (cnt = 0; cnt < count / 2; cnt++) { - qla2x00_write_nvram_word(ha, cnt+ha->nvram_base, - cpu_to_le16(*witer)); - witer++; - } - qla2x00_unlock_nvram_access(ha); - spin_unlock_irqrestore(&ha->hardware_lock, flags); - - return (count); -} - -/* -------------------------------------------------------------------------- */ 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", @@ -603,11 +226,59 @@ qla2x00_get_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, " "); + 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); @@ -641,231 +312,166 @@ qla2x00_get_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). -**************************************************************************/ -static int -qla2x00_queuecommand(struct scsi_cmnd *cmd, void (*fn)(struct scsi_cmnd *)) +char * +qla24xx_fw_version_str(struct scsi_qla_host *ha, char *str) { - fc_port_t *fcport; - os_lun_t *lq; - os_tgt_t *tq; - scsi_qla_host_t *ha, *ha2; - srb_t *sp; - struct Scsi_Host *host; - unsigned int b, t, l; - unsigned long handle; - int was_empty; + 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; +} - host = cmd->device->host; - ha = (scsi_qla_host_t *) host->hostdata; - was_empty = 1; +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; - cmd->scsi_done = fn; + sp = mempool_alloc(ha->srb_mempool, GFP_ATOMIC); + if (!sp) + return sp; - spin_unlock_irq(ha->host->host_lock); + 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; - /* - * Allocate a command packet from the "sp" pool. If we cant get back - * one then let scsi layer come back later. - */ - if ((sp = qla2x00_get_new_sp(ha)) == NULL) { - qla_printk(KERN_WARNING, ha, - "Couldn't allocate memory for sp - retried.\n"); + return sp; +} - spin_lock_irq(ha->host->host_lock); +static int +qla2x00_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; + struct fc_rport *rport = starget_to_rport(scsi_target(cmd->device)); + srb_t *sp; + int rval; - return (1); + rval = fc_remote_port_chkready(rport); + if (rval) { + cmd->result = rval; + goto qc_fail_command; } - sp->cmd = cmd; - CMD_SP(cmd) = (void *)sp; - - sp->flags = 0; - if (CMD_RESID_LEN(cmd) & SRB_IOCTL) { - /* Need to set sp->flags */ - sp->flags |= SRB_IOCTL; - CMD_RESID_LEN(cmd) = 0; /* Clear it since no more use. */ + /* Close window on fcport/rport state-transitioning. */ + if (!*(fc_port_t **)rport->dd_data) { + cmd->result = DID_IMM_RETRY << 16; + goto qc_fail_command; } - sp->fo_retry_cnt = 0; - sp->err_id = 0; - - /* Generate LU queue on bus, target, LUN */ - b = cmd->device->channel; - t = cmd->device->id; - l = cmd->device->lun; + 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 qc_fail_command; + } + goto qc_host_busy; + } - /* - * Start Command Timer. Typically it will be 2 seconds less than what - * is requested by the Host such that we can return the IO before - * aborts are called. - */ - if ((cmd->timeout_per_command / HZ) > QLA_CMD_TIMER_DELTA) - qla2x00_add_timer_to_cmd(sp, - (cmd->timeout_per_command / HZ) - QLA_CMD_TIMER_DELTA); - else - qla2x00_add_timer_to_cmd(sp, cmd->timeout_per_command / HZ); + spin_unlock_irq(ha->host->host_lock); - if (l >= ha->max_luns) { - cmd->result = DID_NO_CONNECT << 16; - sp->err_id = SRB_ERR_PORT; + sp = qla2x00_get_new_sp(ha, fcport, cmd, done); + if (!sp) + goto qc_host_busy_lock; - spin_lock_irq(ha->host->host_lock); + rval = qla2x00_start_scsi(sp); + if (rval != QLA_SUCCESS) + goto qc_host_busy_free_sp; - sp_put(ha, sp); + spin_lock_irq(ha->host->host_lock); - return (0); - } + return 0; - if ((tq = (os_tgt_t *) TGT_Q(ha, t)) != NULL && - (lq = (os_lun_t *) LUN_Q(ha, t, l)) != NULL) { - fcport = lq->fclun->fcport; - ha2 = fcport->ha; - } else { - lq = NULL; - fcport = NULL; - ha2 = ha; - } +qc_host_busy_free_sp: + qla2x00_sp_free_dma(ha, sp); + mempool_free(sp, ha->srb_mempool); - /* Set an invalid handle until we issue the command to ISP */ - /* then we will set the real handle value. */ - handle = INVALID_HANDLE; - cmd->host_scribble = (unsigned char *)handle; +qc_host_busy_lock: + spin_lock_irq(ha->host->host_lock); - /* Bookkeeping information */ - sp->r_start = jiffies; /* Time the request was recieved. */ - sp->u_start = 0; +qc_host_busy: + return SCSI_MLQUEUE_HOST_BUSY; - /* Setup device queue pointers. */ - sp->tgt_queue = tq; - sp->lun_queue = lq; +qc_fail_command: + done(cmd); - /* - * NOTE : q is NULL - * - * 1. When device is added from persistent binding but has not been - * discovered yet.The state of loopid == PORT_AVAIL. - * 2. When device is never found on the bus.(loopid == UNUSED) - * - * IF Device Queue is not created, or device is not in a valid state - * and link down error reporting is enabled, reject IO. - */ - if (fcport == NULL) { - DEBUG3(printk("scsi(%ld:%2d:%2d): port unavailable\n", - ha->host_no,t,l)); + return 0; +} - cmd->result = DID_NO_CONNECT << 16; - sp->err_id = SRB_ERR_PORT; - spin_lock_irq(ha->host->host_lock); +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; + struct fc_rport *rport = starget_to_rport(scsi_target(cmd->device)); + srb_t *sp; + int rval; - sp_put(ha, sp); + rval = fc_remote_port_chkready(rport); + if (rval) { + cmd->result = rval; + goto qc24_fail_command; + } - return (0); + /* Close window on fcport/rport state-transitioning. */ + if (!*(fc_port_t **)rport->dd_data) { + cmd->result = DID_IMM_RETRY << 16; + goto qc24_fail_command; } - /* Only modify the allowed count if the target is a *non* tape device */ - if ((fcport->flags & FCF_TAPE_PRESENT) == 0) { - sp->flags &= ~SRB_TAPE; - if (cmd->allowed < ql2xretrycount) { - cmd->allowed = ql2xretrycount; + 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; } - } else - sp->flags |= SRB_TAPE; + goto qc24_host_busy; + } - DEBUG5(printk("scsi(%ld:%2d:%2d): (queuecmd) queue sp = %p, " - "flags=0x%x fo retry=%d, pid=%ld\n", - ha->host_no, t, l, sp, sp->flags, sp->fo_retry_cnt, - cmd->serial_number)); - DEBUG5(qla2x00_print_scsi_cmd(cmd)); + spin_unlock_irq(ha->host->host_lock); - sp->fclun = lq->fclun; - sp->ha = ha2; + sp = qla2x00_get_new_sp(ha, fcport, cmd, done); + if (!sp) + goto qc24_host_busy_lock; - if (cmd->sc_data_direction == DMA_BIDIRECTIONAL && - cmd->request_bufflen != 0) { + rval = qla24xx_start_scsi(sp); + if (rval != QLA_SUCCESS) + goto qc24_host_busy_free_sp; - DEBUG2(printk(KERN_WARNING - "scsi(%ld): Incorrect data direction - transfer " - "length=%d, direction=%d, pid=%ld, opcode=%x\n", - ha->host_no, cmd->request_bufflen, cmd->sc_data_direction, - cmd->serial_number, cmd->cmnd[0])); - } + spin_lock_irq(ha->host->host_lock); - /* Final pre-check : - * - * Either PORT_DOWN_TIMER OR LINK_DOWN_TIMER Expired. - */ - if (atomic_read(&fcport->state) == FCS_DEVICE_DEAD || - atomic_read(&ha2->loop_state) == LOOP_DEAD) { - /* - * Add the command to the done-queue for later failover - * processing. - */ - cmd->result = DID_NO_CONNECT << 16; - if (atomic_read(&ha2->loop_state) == LOOP_DOWN) - sp->err_id = SRB_ERR_LOOP; - else - sp->err_id = SRB_ERR_PORT; + return 0; - add_to_done_queue(ha, sp); - qla2x00_done(ha); +qc24_host_busy_free_sp: + qla2x00_sp_free_dma(ha, sp); + mempool_free(sp, ha->srb_mempool); - spin_lock_irq(ha->host->host_lock); - return (0); - } +qc24_host_busy_lock: + spin_lock_irq(ha->host->host_lock); - if (tq && test_bit(TQF_SUSPENDED, &tq->flags) && - (sp->flags & SRB_TAPE) == 0) { - /* If target suspended put incoming I/O in retry_q. */ - qla2x00_extend_timeout(sp->cmd, 10); - add_to_scsi_retry_queue(ha, sp); - } else - was_empty = add_to_pending_queue(ha, sp); +qc24_host_busy: + return SCSI_MLQUEUE_HOST_BUSY; - if ((IS_QLA2100(ha) || IS_QLA2200(ha)) && ha->flags.online) { - if (ha->response_ring_ptr->signature != RESPONSE_PROCESSED) { - unsigned long flags; +qc24_fail_command: + done(cmd); - spin_lock_irqsave(&ha->hardware_lock, flags); - qla2x00_process_response_queue(ha); - spin_unlock_irqrestore(&ha->hardware_lock, flags); - } - } + return 0; +} - /* We submit to the hardware if: - * - * 1) we're on the cpu the irq's arrive on or - * 2) there are very few io's outstanding. - * - * In all other cases we'll let an irq pick up our IO and submit it - * to the controller to improve affinity. - */ - if (_smp_processor_id() == ha->last_irq_cpu || was_empty) - qla2x00_next(ha); - - spin_lock_irq(ha->host->host_lock); - - return (0); -} /* * qla2x00_eh_wait_on_command @@ -885,67 +491,33 @@ qla2x00_queuecommand(struct scsi_cmnd *cmd, void (*fn)(struct scsi_cmnd *)) static int qla2x00_eh_wait_on_command(scsi_qla_host_t *ha, struct scsi_cmnd *cmd) { -#define ABORT_POLLING_PERIOD HZ -#define ABORT_WAIT_TIME ((10 * HZ) / (ABORT_POLLING_PERIOD)) +#define ABORT_POLLING_PERIOD 1000 +#define ABORT_WAIT_ITER ((10 * 1000) / (ABORT_POLLING_PERIOD)) + unsigned long wait_iter = ABORT_WAIT_ITER; + int ret = QLA_SUCCESS; - int found = 0; - int done = 0; - srb_t *rp = NULL; - struct list_head *list, *temp; - u_long max_wait_time = ABORT_WAIT_TIME; - - do { - /* Check on done queue */ - spin_lock(&ha->list_lock); - list_for_each_safe(list, temp, &ha->done_queue) { - rp = list_entry(list, srb_t, list); - - /* - * Found command. Just exit and wait for the cmd sent - * to OS. - */ - if (cmd == rp->cmd) { - found++; - DEBUG3(printk("%s: found in done queue.\n", - __func__);) - break; - } - } - spin_unlock(&ha->list_lock); + while (CMD_SP(cmd)) { + msleep(ABORT_POLLING_PERIOD); - /* Complete the cmd right away. */ - if (found) { - qla2x00_delete_from_done_queue(ha, rp); - sp_put(ha, rp); - done++; + if (--wait_iter) break; - } - - spin_unlock_irq(ha->host->host_lock); - - set_current_state(TASK_UNINTERRUPTIBLE); - schedule_timeout(ABORT_POLLING_PERIOD); - - spin_lock_irq(ha->host->host_lock); - - } while ((max_wait_time--)); - - if (done) - DEBUG2(printk(KERN_INFO "%s: found cmd=%p.\n", __func__, cmd)); + } + if (CMD_SP(cmd)) + ret = QLA_FUNCTION_FAILED; - return (done); + return ret; } /* * 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. * @@ -953,13 +525,13 @@ qla2x00_eh_wait_on_command(scsi_qla_host_t *ha, struct scsi_cmnd *cmd) * Success (Adapter is online) : 0 * Failed (Adapter is offline/disabled) : 1 */ -static int +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) || @@ -967,8 +539,8 @@ qla2x00_wait_for_hba_online(scsi_qla_host_t *ha) msleep(1000); } - if (ha->flags.online) - return_status = QLA_SUCCESS; + if (ha->flags.online) + return_status = QLA_SUCCESS; else return_status = QLA_FUNCTION_FAILED; @@ -980,31 +552,30 @@ qla2x00_wait_for_hba_online(scsi_qla_host_t *ha) /* * 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) || - test_bit(CFG_ACTIVE, &ha->cfg_flags) || atomic_read(&ha->loop_state) != LOOP_READY) { msleep(1000); if (time_after_eq(jiffies, loop_timeout)) { @@ -1012,7 +583,7 @@ qla2x00_wait_for_loop_ready(scsi_qla_host_t *ha) break; } } - return (return_status); + return (return_status); } /************************************************************************** @@ -1028,249 +599,74 @@ qla2x00_wait_for_loop_ready(scsi_qla_host_t *ha) * Either SUCCESS or FAILED. * * Note: +* Only return FAILED if command not returned by firmware. **************************************************************************/ int qla2xxx_eh_abort(struct scsi_cmnd *cmd) { - int i; - int return_status = FAILED; - os_lun_t *q; - scsi_qla_host_t *ha; - scsi_qla_host_t *vis_ha; - srb_t *sp; - srb_t *rp; - struct list_head *list, *temp; - struct Scsi_Host *host; - uint8_t found = 0; - unsigned int b, t, l; - - /* Get the SCSI request ptr */ - sp = (srb_t *) CMD_SP(cmd); + scsi_qla_host_t *ha = to_qla_host(cmd->device->host); + srb_t *sp; + int ret, i; + unsigned int id, lun; + unsigned long serial; + unsigned long flags; + int wait = 0; - /* - * If sp is NULL, command is already returned. - * sp is NULLED just before we call back scsi_done - * - */ - if ((sp == NULL)) { - /* no action - we don't have command */ - qla_printk(KERN_INFO, to_qla_host(cmd->device->host), - "qla2xxx_eh_abort: cmd already done sp=%p\n", sp); - DEBUG(printk("qla2xxx_eh_abort: cmd already done sp=%p\n", sp);) + if (!CMD_SP(cmd)) return SUCCESS; - } - if (sp) { - DEBUG(printk("qla2xxx_eh_abort: refcount %i \n", - atomic_read(&sp->ref_count));) - } - - vis_ha = (scsi_qla_host_t *) cmd->device->host->hostdata; - ha = (scsi_qla_host_t *)cmd->device->host->hostdata; - - host = ha->host; - - /* Generate LU queue on bus, target, LUN */ - b = cmd->device->channel; - t = cmd->device->id; - l = cmd->device->lun; - q = GET_LU_Q(vis_ha, t, l); - - qla_printk(KERN_INFO, ha, - "%s scsi(%ld:%d:%d:%d): cmd_timeout_in_sec=0x%x.\n", __func__, - ha->host_no, (int)b, (int)t, (int)l, - cmd->timeout_per_command / HZ); - /* - * if no LUN queue then something is very wrong!!! - */ - if (q == NULL) { - qla_printk(KERN_WARNING, ha, - "qla2x00: (%x:%x:%x) No LUN queue.\n", b, t, l); - - /* no action - we don't have command */ - return FAILED; - } - - DEBUG2(printk("scsi(%ld): ABORTing cmd=%p sp=%p jiffies = 0x%lx, " - "timeout=%x, dpc_flags=%lx, vis_ha->dpc_flags=%lx q->flag=%lx\n", - ha->host_no, cmd, sp, jiffies, cmd->timeout_per_command / HZ, - ha->dpc_flags, vis_ha->dpc_flags, q->q_flag)); - DEBUG2(qla2x00_print_scsi_cmd(cmd)); + ret = SUCCESS; - spin_unlock_irq(ha->host->host_lock); - if (qla2x00_wait_for_hba_online(ha) != QLA_SUCCESS) { - DEBUG2(printk("%s failed:board disabled\n", __func__);) - spin_lock_irq(ha->host->host_lock); - return FAILED; - } - spin_lock_irq(ha->host->host_lock); + id = cmd->device->id; + lun = cmd->device->lun; + serial = cmd->serial_number; - /* Search done queue */ - spin_lock(&ha->list_lock); - list_for_each_safe(list, temp, &ha->done_queue) { - rp = list_entry(list, srb_t, list); + /* Check active list for command command. */ + spin_lock_irqsave(&ha->hardware_lock, flags); + for (i = 1; i < MAX_OUTSTANDING_COMMANDS; i++) { + sp = ha->outstanding_cmds[i]; - if (cmd != rp->cmd) + if (sp == NULL) continue; - /* - * Found command.Remove it from done list. - * And proceed to post completion to scsi mid layer. - */ - return_status = SUCCESS; - found++; - qla2x00_delete_from_done_queue(ha, sp); - - break; - } /* list_for_each_safe() */ - spin_unlock(&ha->list_lock); - - /* - * Return immediately if the aborted command was already in the done - * queue - */ - if (found) { - qla_printk(KERN_INFO, ha, - "qla2xxx_eh_abort: Returning completed command=%p sp=%p\n", - cmd, sp); - sp_put(ha, sp); - return (return_status); - } - - - /* - * See if this command is in the retry queue - */ - DEBUG3(printk("qla2xxx_eh_abort: searching sp %p in retry " - "queue.\n", sp);) - - spin_lock(&ha->list_lock); - list_for_each_safe(list, temp, &ha->retry_queue) { - rp = list_entry(list, srb_t, list); - - if (cmd != rp->cmd) + if (sp->cmd != cmd) continue; + 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);) - DEBUG2(printk("qla2xxx_eh_abort: found " - "in retry queue. SP=%p\n", sp);) - - __del_from_retry_queue(ha, rp); - cmd->result = DID_ABORT << 16; - __add_to_done_queue(ha, rp); - - return_status = SUCCESS; - found++; + 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 { + DEBUG3(printk("%s(%ld): abort_command " + "mbx success.\n", __func__, ha->host_no)); + wait = 1; + } + spin_lock_irqsave(&ha->hardware_lock, flags); break; - - } - spin_unlock(&ha->list_lock); - - - /* - * Our SP pointer points at the command we want to remove from the - * pending queue providing we haven't already sent it to the adapter. - */ - if (!found) { - DEBUG3(printk("qla2xxx_eh_abort: searching sp %p " - "in pending queue.\n", sp);) - - spin_lock(&vis_ha->list_lock); - list_for_each_safe(list, temp, &vis_ha->pending_queue) { - rp = list_entry(list, srb_t, list); - - if (rp->cmd != cmd) - continue; - - /* Remove srb from LUN queue. */ - rp->flags |= SRB_ABORTED; - - DEBUG2(printk("qla2xxx_eh_abort: Cmd in pending queue." - " serial_number %ld.\n", - sp->cmd->serial_number);) - - __del_from_pending_queue(vis_ha, rp); - cmd->result = DID_ABORT << 16; - - __add_to_done_queue(vis_ha, rp); - - return_status = SUCCESS; - - found++; - break; - } /* list_for_each_safe() */ - spin_unlock(&vis_ha->list_lock); - } /*End of if !found */ - - if (!found) { /* find the command in our active list */ - DEBUG3(printk("qla2xxx_eh_abort: searching sp %p " - "in outstanding queue.\n", sp);) - - spin_lock(&ha->hardware_lock); - for (i = 1; i < MAX_OUTSTANDING_COMMANDS; i++) { - sp = ha->outstanding_cmds[i]; - - if (sp == NULL) - continue; - - if (sp->cmd != cmd) - continue; - - DEBUG2(printk("qla2xxx_eh_abort(%ld): aborting sp %p " - "from RISC. pid=%ld sp->state=%x q->q_flag=%lx\n", - ha->host_no, sp, sp->cmd->serial_number, - sp->state, q->q_flag);) - DEBUG(qla2x00_print_scsi_cmd(cmd);) - - /* Get a reference to the sp and drop the lock.*/ - sp_get(ha, sp); - - spin_unlock(&ha->hardware_lock); - spin_unlock_irq(ha->host->host_lock); - - if (qla2x00_abort_command(ha, sp)) { - DEBUG2(printk("qla2xxx_eh_abort: abort_command " - "mbx failed.\n");) - return_status = FAILED; - } else { - DEBUG3(printk("qla2xxx_eh_abort: abort_command " - " mbx success.\n");) - return_status = SUCCESS; - } - - sp_put(ha,sp); - - spin_lock_irq(ha->host->host_lock); - spin_lock(&ha->hardware_lock); - - /* - * Regardless of mailbox command status, go check on - * done queue just in case the sp is already done. - */ - break; - - }/*End of for loop */ - spin_unlock(&ha->hardware_lock); - - } /*End of if !found */ - - /* Waiting for our command in done_queue to be returned to OS.*/ - if (qla2x00_eh_wait_on_command(ha, cmd) != 0) { - DEBUG2(printk("qla2xxx_eh_abort: cmd returned back to OS.\n");) - return_status = SUCCESS; } + spin_unlock_irqrestore(&ha->hardware_lock, flags); - if (return_status == FAILED) { - qla_printk(KERN_INFO, ha, - "qla2xxx_eh_abort Exiting: status=Failed\n"); - return FAILED; + /* Wait for the command to be returned. */ + if (wait) { + 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; + } } - DEBUG2(printk("qla2xxx_eh_abort: Exiting. return_status=0x%x.\n", - return_status)); + qla_printk(KERN_INFO, ha, + "scsi(%ld:%d:%d): Abort command issued -- %d %lx %x.\n", + ha->host_no, id, lun, wait, serial, ret); - return return_status; + return ret; } /************************************************************************** @@ -1281,7 +677,7 @@ qla2xxx_eh_abort(struct scsi_cmnd *cmd) * * Input: * ha - pointer to scsi_qla_host structure. -* t - target +* t - target * Returns: * Either SUCCESS or FAILED. * @@ -1294,6 +690,7 @@ qla2x00_eh_wait_for_pending_target_commands(scsi_qla_host_t *ha, unsigned int t) int status; srb_t *sp; struct scsi_cmnd *cmd; + unsigned long flags; status = 0; @@ -1302,20 +699,19 @@ qla2x00_eh_wait_for_pending_target_commands(scsi_qla_host_t *ha, unsigned int t) * 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; break; } } - } - else { - spin_unlock(&ha->hardware_lock); + } else { + spin_unlock_irqrestore(&ha->hardware_lock, flags); } } return (status); @@ -1330,7 +726,7 @@ qla2x00_eh_wait_for_pending_target_commands(scsi_qla_host_t *ha, unsigned int t) * 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: @@ -1344,96 +740,38 @@ qla2x00_eh_wait_for_pending_target_commands(scsi_qla_host_t *ha, unsigned int t) int qla2xxx_eh_device_reset(struct scsi_cmnd *cmd) { - int return_status; - unsigned int b, t, l; - scsi_qla_host_t *ha; - os_tgt_t *tq; - os_lun_t *lq; - fc_port_t *fcport_to_reset; - srb_t *rp; - struct list_head *list, *temp; - - return_status = FAILED; - if (cmd == NULL) { - printk(KERN_INFO - "%s(): **** SCSI mid-layer passing in NULL cmd\n", - __func__); - - return (return_status); - } - - b = cmd->device->channel; - t = cmd->device->id; - l = cmd->device->lun; - ha = (scsi_qla_host_t *)cmd->device->host->hostdata; - - tq = TGT_Q(ha, t); - if (tq == NULL) { - qla_printk(KERN_INFO, ha, - "%s(): **** CMD derives a NULL TGT_Q\n", __func__); + 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; - return (return_status); - } - lq = (os_lun_t *)LUN_Q(ha, t, l); - if (lq == NULL) { - printk(KERN_INFO - "%s(): **** CMD derives a NULL LUN_Q\n", __func__); + ret = FAILED; - return (return_status); - } - fcport_to_reset = lq->fclun->fcport; + id = cmd->device->id; + lun = cmd->device->lun; + serial = cmd->serial_number; - /* If we are coming in from the back-door, stall I/O until complete. */ - if (!cmd->device->host->eh_active) - set_bit(TQF_SUSPENDED, &tq->flags); + sp = (srb_t *) CMD_SP(cmd); + if (!sp || !fcport) + return ret; qla_printk(KERN_INFO, ha, - "scsi(%ld:%d:%d:%d): DEVICE RESET ISSUED.\n", ha->host_no, b, t, l); - - DEBUG2(printk(KERN_INFO - "scsi(%ld): DEVICE_RESET cmd=%p jiffies = 0x%lx, timeout=%x, " - "dpc_flags=%lx, status=%x allowed=%d cmd.state=%x\n", - ha->host_no, cmd, jiffies, cmd->timeout_per_command / HZ, - ha->dpc_flags, cmd->result, cmd->allowed, cmd->state)); - - /* Clear commands from the retry queue. */ - spin_lock(&ha->list_lock); - list_for_each_safe(list, temp, &ha->retry_queue) { - rp = list_entry(list, srb_t, list); - - if (t != rp->cmd->device->id) - continue; - - DEBUG2(printk(KERN_INFO - "qla2xxx_eh_reset: found in retry queue. SP=%p\n", rp)); - - __del_from_retry_queue(ha, rp); - rp->cmd->result = DID_RESET << 16; - __add_to_done_queue(ha, rp); - } - spin_unlock(&ha->list_lock); - - spin_unlock_irq(ha->host->host_lock); - - if (qla2x00_wait_for_hba_online(ha) != QLA_SUCCESS) { - DEBUG2(printk(KERN_INFO - "%s failed:board disabled\n",__func__)); + "scsi(%ld:%d:%d): DEVICE RESET ISSUED.\n", ha->host_no, id, lun); - 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_to_reset) == 0) { - return_status = SUCCESS; - } + if (qla2x00_device_reset(ha, fcport) == 0) + ret = SUCCESS; #if defined(LOGOUT_AFTER_DEVICE_RESET) - if (return_status == SUCCESS) { - if (fcport_to_reset->flags & FC_FABRIC_DEVICE) { - qla2x00_fabric_logout(ha, - fcport_to_reset->loop_id); - qla2x00_mark_device_lost(ha, fcport_to_reset); + if (ret == SUCCESS) { + if (fcport->flags & FC_FABRIC_DEVICE) { + ha->isp_ops.fabric_logout(ha, fcport->loop_id); + qla2x00_mark_device_lost(ha, fcport, 0, 0); } } #endif @@ -1442,9 +780,7 @@ qla2xxx_eh_device_reset(struct scsi_cmnd *cmd) "%s failed: loop not ready\n",__func__);) } - spin_lock_irq(ha->host->host_lock); - - if (return_status == FAILED) { + if (ret == FAILED) { DEBUG3(printk("%s(%ld): device reset failed\n", __func__, ha->host_no)); qla_printk(KERN_INFO, ha, "%s: device reset failed\n", @@ -1453,35 +789,20 @@ qla2xxx_eh_device_reset(struct scsi_cmnd *cmd) goto eh_dev_reset_done; } - /* - * If we are coming down the EH path, wait for all commands to - * complete for the device. - */ - if (cmd->device->host->eh_active) { - if (qla2x00_eh_wait_for_pending_target_commands(ha, t)) - return_status = FAILED; - - if (return_status == FAILED) { - DEBUG3(printk("%s(%ld): failed while waiting for " - "commands\n", __func__, ha->host_no)); - qla_printk(KERN_INFO, ha, - "%s: failed while waiting for commands\n", - __func__); - - goto eh_dev_reset_done; - } - } - - qla_printk(KERN_INFO, ha, - "scsi(%ld:%d:%d:%d): DEVICE RESET SUCCEEDED.\n", - ha->host_no, b, t, l); - -eh_dev_reset_done: - - if (!cmd->device->host->eh_active) - clear_bit(TQF_SUSPENDED, &tq->flags); - - return (return_status); + /* Flush outstanding commands. */ + if (qla2x00_eh_wait_for_pending_target_commands(ha, id)) + ret = FAILED; + if (ret == FAILED) { + DEBUG3(printk("%s(%ld): failed while waiting for commands\n", + __func__, ha->host_no)); + qla_printk(KERN_INFO, ha, + "%s: failed while waiting for commands\n", __func__); + } else + qla_printk(KERN_INFO, ha, + "scsi(%ld:%d:%d): DEVICE RESET SUCCEEDED.\n", ha->host_no, + id, lun); + eh_dev_reset_done: + return ret; } /************************************************************************** @@ -1506,6 +827,7 @@ qla2x00_eh_wait_for_pending_commands(scsi_qla_host_t *ha) int status; srb_t *sp; struct scsi_cmnd *cmd; + unsigned long flags; status = 1; @@ -1514,17 +836,17 @@ qla2x00_eh_wait_for_pending_commands(scsi_qla_host_t *ha) * 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); @@ -1549,44 +871,47 @@ qla2x00_eh_wait_for_pending_commands(scsi_qla_host_t *ha) int qla2xxx_eh_bus_reset(struct scsi_cmnd *cmd) { - scsi_qla_host_t *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 rval = FAILED; + int ret; + unsigned int id, lun; + unsigned long serial; + + ret = FAILED; + + id = cmd->device->id; + lun = cmd->device->lun; + serial = cmd->serial_number; - ha = (scsi_qla_host_t *) cmd->device->host->hostdata; sp = (srb_t *) CMD_SP(cmd); + if (!sp || !fcport) + return ret; qla_printk(KERN_INFO, ha, - "scsi(%ld:%d:%d:%d): LOOP RESET ISSUED.\n", ha->host_no, - cmd->device->channel, cmd->device->id, cmd->device->lun); - - spin_unlock_irq(ha->host->host_lock); + "scsi(%ld:%d:%d): LOOP RESET ISSUED.\n", ha->host_no, id, lun); if (qla2x00_wait_for_hba_online(ha) != QLA_SUCCESS) { DEBUG2(printk("%s failed:board disabled\n",__func__)); - spin_lock_irq(ha->host->host_lock); - return FAILED; + goto eh_bus_reset_done; } if (qla2x00_wait_for_loop_ready(ha) == QLA_SUCCESS) { - if (qla2x00_loop_reset(ha) == QLA_SUCCESS) - rval = SUCCESS; + if (qla2x00_loop_reset(ha) == QLA_SUCCESS) + ret = SUCCESS; } + if (ret == FAILED) + goto eh_bus_reset_done; - spin_lock_irq(ha->host->host_lock); - if (rval == FAILED) - goto out; - - /* Waiting for our command in done_queue to be returned to OS.*/ - if (cmd->device->host->eh_active) - if (!qla2x00_eh_wait_for_pending_commands(ha)) - rval = FAILED; + /* Flush outstanding commands. */ + if (!qla2x00_eh_wait_for_pending_commands(ha)) + ret = FAILED; - out: +eh_bus_reset_done: qla_printk(KERN_INFO, ha, "%s: reset %s\n", __func__, - (rval == FAILED) ? "failed" : "succeded"); + (ret == FAILED) ? "failed" : "succeded"); - return rval; + return ret; } /************************************************************************** @@ -1607,34 +932,37 @@ qla2xxx_eh_bus_reset(struct scsi_cmnd *cmd) int qla2xxx_eh_host_reset(struct scsi_cmnd *cmd) { - scsi_qla_host_t *ha = (scsi_qla_host_t *)cmd->device->host->hostdata; - int rval = SUCCESS; + 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; - /* Display which one we're actually resetting for debug. */ - DEBUG(printk("qla2xxx_eh_host_reset:Resetting scsi(%ld).\n", - ha->host_no)); + ret = FAILED; - /* - * Now issue reset. - */ - qla_printk(KERN_INFO, ha, - "scsi(%ld:%d:%d:%d): ADAPTER RESET issued.\n", ha->host_no, - cmd->device->channel, cmd->device->id, cmd->device->lun); + id = cmd->device->id; + lun = cmd->device->lun; + serial = cmd->serial_number; - spin_unlock_irq(ha->host->host_lock); + sp = (srb_t *) CMD_SP(cmd); + if (!sp || !fcport) + return ret; + + qla_printk(KERN_INFO, ha, + "scsi(%ld:%d:%d): ADAPTER RESET ISSUED.\n", ha->host_no, id, lun); if (qla2x00_wait_for_hba_online(ha) != QLA_SUCCESS) - goto board_disabled; + 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 * while dpc is stuck for the mailbox to complete. */ - /* Blocking call-Does context switching if loop is Not Ready */ qla2x00_wait_for_loop_ready(ha); set_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags); if (qla2x00_abort_isp(ha)) { @@ -1643,33 +971,21 @@ qla2xxx_eh_host_reset(struct scsi_cmnd *cmd) set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags); if (qla2x00_wait_for_hba_online(ha) != QLA_SUCCESS) - goto board_disabled; - } - + goto eh_host_reset_lock; + } clear_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags); - spin_lock_irq(ha->host->host_lock); - if (rval == FAILED) - goto out; - /* Waiting for our command in done_queue to be returned to OS.*/ - if (!qla2x00_eh_wait_for_pending_commands(ha)) - rval = FAILED; + if (qla2x00_eh_wait_for_pending_commands(ha)) + ret = SUCCESS; - out: +eh_host_reset_lock: qla_printk(KERN_INFO, ha, "%s: reset %s\n", __func__, - (rval == FAILED) ? "failed" : "succeded"); - - return rval; - - board_disabled: - spin_lock_irq(ha->host->host_lock); + (ret == FAILED) ? "failed" : "succeded"); - qla_printk(KERN_INFO, ha, "%s: failed:board disabled\n", __func__); - return FAILED; + return ret; } - /* * qla2x00_loop_reset * Issue loop reset. @@ -1684,30 +1000,25 @@ static int qla2x00_loop_reset(scsi_qla_host_t *ha) { int status = QLA_SUCCESS; - uint16_t t; - os_tgt_t *tq; + struct fc_port *fcport; if (ha->flags.enable_lip_reset) { status = qla2x00_lip_reset(ha); } if (status == QLA_SUCCESS && ha->flags.enable_target_reset) { - for (t = 0; t < MAX_FIBRE_DEVICES; t++) { - if ((tq = TGT_Q(ha, t)) == NULL) - continue; - - if (tq->fcport == NULL) + list_for_each_entry(fcport, &ha->fcports, list) { + if (fcport->port_type != FCT_TARGET) continue; - status = qla2x00_target_reset(ha, 0, t); - if (status != QLA_SUCCESS) { + status = qla2x00_device_reset(ha, fcport); + if (status != QLA_SUCCESS) break; - } } } 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)) { @@ -1749,44 +1060,64 @@ static int 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); } -/************************************************************************** -* qla2xxx_slave_configure -* -* Description: -**************************************************************************/ -int +static int +qla2xxx_slave_alloc(struct scsi_device *sdev) +{ + struct fc_rport *rport = starget_to_rport(scsi_target(sdev)); + + if (!rport || fc_remote_port_chkready(rport)) + return -ENXIO; + + sdev->hostdata = *(fc_port_t **)rport->dd_data; + + return 0; +} + +static int qla2xxx_slave_configure(struct scsi_device *sdev) { scsi_qla_host_t *ha = to_qla_host(sdev->host); - int queue_depth; + struct fc_rport *rport = starget_to_rport(sdev->sdev_target); - if (IS_QLA2100(ha) || IS_QLA2200(ha)) - queue_depth = 16; + if (sdev->tagged_supported) + scsi_activate_tcq(sdev, 32); else - queue_depth = 32; + scsi_deactivate_tcq(sdev, 32); - if (sdev->tagged_supported) { - if (ql2xmaxqdepth != 0 && ql2xmaxqdepth <= 0xffffU) - queue_depth = ql2xmaxqdepth; + rport->dev_loss_tmo = ha->port_down_retry_count + 5; - ql2xmaxqdepth = queue_depth; + return 0; +} - scsi_activate_tcq(sdev, queue_depth); +static void +qla2xxx_slave_destroy(struct scsi_device *sdev) +{ + sdev->hostdata = NULL; +} - qla_printk(KERN_INFO, ha, - "scsi(%d:%d:%d:%d): Enabled tagged queuing, queue " - "depth %d.\n", - sdev->host->host_no, sdev->channel, sdev->id, sdev->lun, - sdev->queue_depth); - } else { - scsi_adjust_queue_depth(sdev, 0 /* TCQ off */, - sdev->host->hostt->cmd_per_lun /* 3 */); - } +static int +qla2x00_change_queue_depth(struct scsi_device *sdev, int qdepth) +{ + scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), qdepth); + return sdev->queue_depth; +} - return (0); +static int +qla2x00_change_queue_type(struct scsi_device *sdev, int tag_type) +{ + if (sdev->tagged_supported) { + scsi_set_tag_type(sdev, tag_type); + if (tag_type) + scsi_activate_tcq(sdev, sdev->queue_depth); + else + scsi_deactivate_tcq(sdev, sdev->queue_depth); + } else + tag_type = 0; + + return tag_type; } /** @@ -1799,37 +1130,73 @@ qla2xxx_slave_configure(struct scsi_device *sdev) static void qla2x00_config_dma_addressing(scsi_qla_host_t *ha) { - /* Assume 32bit DMA address */ + /* Assume a 32bit DMA mask. */ 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 - * assist in setting the proper dma mask. - */ - if (sizeof(dma_addr_t) > 4) { - if (pci_set_dma_mask(ha->pdev, DMA_64BIT_MASK) == 0) { + if (!dma_set_mask(&ha->pdev->dev, DMA_64BIT_MASK)) { + /* Any upper-dword bits set? */ + if (MSD(dma_get_required_mask(&ha->pdev->dev)) && + !pci_set_consistent_dma_mask(ha->pdev, DMA_64BIT_MASK)) { + /* Ok, a 64bit DMA mask is applicable. */ ha->flags.enable_64bit_addressing = 1; - ha->calc_request_entries = qla2x00_calc_iocbs_64; - ha->build_scsi_iocbs = qla2x00_build_scsi_iocbs_64; - - if (pci_set_consistent_dma_mask(ha->pdev, - DMA_64BIT_MASK)) { - qla_printk(KERN_DEBUG, ha, - "Failed to set 64 bit PCI consistent mask; " - "using 32 bit.\n"); - pci_set_consistent_dma_mask(ha->pdev, - DMA_32BIT_MASK); - } - } else { - qla_printk(KERN_DEBUG, ha, - "Failed to set 64 bit PCI DMA mask, falling back " - "to 32 bit MASK.\n"); - pci_set_dma_mask(ha->pdev, DMA_32BIT_MASK); + ha->isp_ops.calc_req_entries = qla2x00_calc_iocbs_64; + ha->isp_ops.build_iocbs = qla2x00_build_scsi_iocbs_64; + return; } - } else { - pci_set_dma_mask(ha->pdev, DMA_32BIT_MASK); + } + + dma_set_mask(&ha->pdev->dev, DMA_32BIT_MASK); + 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; + break; + case PCI_DEVICE_ID_QLOGIC_ISP2200: + ha->device_type |= DT_ISP2200; + ha->device_type &= ~DT_EXTENDED_IDS; + break; + case PCI_DEVICE_ID_QLOGIC_ISP2300: + ha->device_type |= DT_ISP2300; + ha->device_type |= DT_ZIO_SUPPORTED; + break; + case PCI_DEVICE_ID_QLOGIC_ISP2312: + ha->device_type |= DT_ISP2312; + ha->device_type |= DT_ZIO_SUPPORTED; + 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; + break; + case PCI_DEVICE_ID_QLOGIC_ISP6312: + ha->device_type |= DT_ISP6312; + break; + case PCI_DEVICE_ID_QLOGIC_ISP6322: + ha->device_type |= DT_ISP6322; + break; + case PCI_DEVICE_ID_QLOGIC_ISP2422: + ha->device_type |= DT_ISP2422; + ha->device_type |= DT_ZIO_SUPPORTED; + break; + case PCI_DEVICE_ID_QLOGIC_ISP2432: + ha->device_type |= DT_ISP2432; + ha->device_type |= DT_ZIO_SUPPORTED; + break; + case PCI_DEVICE_ID_QLOGIC_ISP5422: + ha->device_type |= DT_ISP5422; + break; + case PCI_DEVICE_ID_QLOGIC_ISP5432: + ha->device_type |= DT_ISP5432; + break; } } @@ -1847,13 +1214,13 @@ qla2x00_iospace_config(scsi_qla_host_t *ha) if (pio_len < MIN_IOBASE_LEN) { qla_printk(KERN_WARNING, ha, "Invalid PCI I/O region size (%s)...\n", - ha->pdev->slot_name); + pci_name(ha->pdev)); pio = 0; } } else { qla_printk(KERN_WARNING, ha, "region #0 not a PIO resource (%s)...\n", - ha->pdev->slot_name); + pci_name(ha->pdev)); pio = 0; } @@ -1865,20 +1232,20 @@ qla2x00_iospace_config(scsi_qla_host_t *ha) if (!(mmio_flags & IORESOURCE_MEM)) { qla_printk(KERN_ERR, ha, "region #0 not an MMIO resource (%s), aborting\n", - ha->pdev->slot_name); + pci_name(ha->pdev)); goto iospace_error_exit; } if (mmio_len < MIN_IOBASE_LEN) { qla_printk(KERN_ERR, ha, "Invalid PCI mem region size (%s), aborting\n", - ha->pdev->slot_name); + pci_name(ha->pdev)); goto iospace_error_exit; } if (pci_request_regions(ha->pdev, ha->brd_info->drv_name)) { qla_printk(KERN_WARNING, ha, - "Failed to reserve PIO/MMIO regions (%s)\n", - ha->pdev->slot_name); + "Failed to reserve PIO/MMIO regions (%s)\n", + pci_name(ha->pdev)); goto iospace_error_exit; } @@ -1888,7 +1255,7 @@ qla2x00_iospace_config(scsi_qla_host_t *ha) ha->iobase = ioremap(mmio, MIN_IOBASE_LEN); if (!ha->iobase) { qla_printk(KERN_ERR, ha, - "cannot remap MMIO (%s), aborting\n", ha->pdev->slot_name); + "cannot remap MMIO (%s), aborting\n", pci_name(ha->pdev)); goto iospace_error_exit; } @@ -1899,26 +1266,86 @@ iospace_error_exit: return (-ENOMEM); } -/* - * PCI driver interface - */ -int qla2x00_probe_one(struct pci_dev *pdev, struct qla_board_info *brd_info) +static void +qla2x00_enable_intrs(scsi_qla_host_t *ha) { - int ret; - device_reg_t __iomem *reg; - struct Scsi_Host *host; - scsi_qla_host_t *ha; - unsigned long flags = 0; - unsigned long wait_switch = 0; - char pci_info[20]; - char fw_str[30]; + unsigned long flags = 0; + struct device_reg_2xxx __iomem *reg = &ha->iobase->isp; - if (pci_enable_device(pdev)) - return -1; + 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); - host = scsi_host_alloc(&qla2x00_driver_template, - sizeof(scsi_qla_host_t)); - if (host == NULL) { +} + +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 = -ENODEV; + device_reg_t __iomem *reg; + struct Scsi_Host *host; + scsi_qla_host_t *ha; + unsigned long flags = 0; + unsigned long wait_switch = 0; + char pci_info[20]; + char fw_str[30]; + fc_port_t *fcport; + struct scsi_host_template *sht; + + if (pci_enable_device(pdev)) + goto probe_out; + + sht = &qla2x00_driver_template; + if (pdev->device == PCI_DEVICE_ID_QLOGIC_ISP2422 || + pdev->device == PCI_DEVICE_ID_QLOGIC_ISP2432) + sht = &qla24xx_driver_template; + host = scsi_host_alloc(sht, sizeof(scsi_qla_host_t)); + if (host == NULL) { printk(KERN_WARNING "qla2xxx: Couldn't allocate host from scsi layer!\n"); goto probe_disable_device; @@ -1934,53 +1361,128 @@ int qla2x00_probe_one(struct pci_dev *pdev, struct qla_board_info *brd_info) 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); + /* Configure PCI I/O space */ ret = qla2x00_iospace_config(ha); - if (ret != 0) { + 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); + "Found an ISP%04X, irq %d, iobase 0x%p\n", pdev->device, pdev->irq, + ha->iobase); spin_lock_init(&ha->hardware_lock); - /* 4.23 Initialize /proc/scsi/qla2x00 counters */ - ha->actthreads = 0; - ha->qthreads = 0; - ha->total_isr_cnt = 0; - ha->total_isp_aborts = 0; - ha->total_lip_cnt = 0; - ha->total_dev_errs = 0; - ha->total_ios = 0; - ha->total_bytes = 0; - 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->optrom_size = OPTROM_SIZE_2300; + + /* 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.prep_ms_fdmi_iocb = qla2x00_prep_ms_fdmi_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; + ha->isp_ops.read_optrom = qla2x00_read_optrom_data; + ha->isp_ops.write_optrom = qla2x00_write_optrom_data; if (IS_QLA2100(ha)) { - ha->max_targets = MAX_TARGETS_2100; + host->max_id = MAX_TARGETS_2100; ha->mbx_count = MAILBOX_REGISTER_COUNT_2100; ha->request_q_length = REQUEST_ENTRY_CNT_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)) { - ha->max_targets = MAX_TARGETS_2200; + 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->max_targets = MAX_TARGETS_2200; + 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->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)) { + 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->mgmt_svr_loop_id = 10; + 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; +#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.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.prep_ms_fdmi_iocb = qla24xx_prep_ms_fdmi_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->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; + ha->isp_ops.beacon_off = qla24xx_beacon_off; + ha->isp_ops.beacon_blink = qla24xx_beacon_blink; + ha->gid_list_info_size = 8; + ha->optrom_size = OPTROM_SIZE_24XX; } host->can_queue = ha->request_q_length + 128; @@ -1993,10 +1495,6 @@ int qla2x00_probe_one(struct pci_dev *pdev, struct qla_board_info *brd_info) INIT_LIST_HEAD(&ha->list); INIT_LIST_HEAD(&ha->fcports); INIT_LIST_HEAD(&ha->rscn_fcports); - INIT_LIST_HEAD(&ha->done_queue); - INIT_LIST_HEAD(&ha->retry_queue); - INIT_LIST_HEAD(&ha->scsi_retry_queue); - INIT_LIST_HEAD(&ha->pending_queue); /* * These locks are used to prevent more than one CPU @@ -2005,17 +1503,13 @@ int qla2x00_probe_one(struct pci_dev *pdev, struct qla_board_info *brd_info) * contention for these locks. */ spin_lock_init(&ha->mbx_reg_lock); - spin_lock_init(&ha->list_lock); - - ha->dpc_pid = -1; - 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, "[ERROR] Failed to allocate memory for adapter\n"); + ret = -ENOMEM; goto probe_failed; } @@ -2029,44 +1523,39 @@ int qla2x00_probe_one(struct pci_dev *pdev, struct qla_board_info *brd_info) "Adapter flags %x.\n", ha->host_no, ha->device_flags)); + ret = -ENODEV; goto probe_failed; } /* * Startup the kernel thread for this host adapter */ - ha->dpc_should_die = 0; - ha->dpc_pid = kernel_thread(qla2x00_do_dpc, ha, 0); - if (ha->dpc_pid < 0) { + ha->dpc_thread = kthread_create(qla2x00_do_dpc, ha, + "%s_dpc", ha->host_str); + if (IS_ERR(ha->dpc_thread)) { qla_printk(KERN_WARNING, ha, "Unable to start DPC thread!\n"); - + ret = PTR_ERR(ha->dpc_thread); 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 = ha->ports - 1; - host->max_lun = ha->max_luns; - BUG_ON(qla2xxx_transport_template == NULL); + host->max_lun = MAX_LUNS; host->transportt = qla2xxx_transport_template; - host->unique_id = ha->instance; - host->max_id = ha->max_targets; - 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) { + 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); @@ -2074,30 +1563,33 @@ 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; - - /* Disable ISP interrupts. */ - qla2x00_disable_intrs(ha); + ha->isp_ops.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_QLA54XX(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 */ /* @@ -2119,28 +1611,27 @@ int qla2x00_probe_one(struct pci_dev *pdev, struct qla_board_info *brd_info) ha->flags.init_done = 1; num_hosts++; - /* List the target we have found */ - if (displayConfig) { - qla2x00_display_fc_names(ha); - } - - if (scsi_add_host(host, &pdev->dev)) + ret = scsi_add_host(host, &pdev->dev); + if (ret) goto probe_failed; - sysfs_create_bin_file(&host->shost_gendev.kobj, &sysfs_fw_dump_attr); - sysfs_create_bin_file(&host->shost_gendev.kobj, &sysfs_nvram_attr); + 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)); + " ISP%04X: %s @ %s hdma%c, host#=%ld, fw=%s\n", + qla2x00_version_str, ha->model_number, + ha->model_desc ? ha->model_desc: "", pdev->device, + 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)); - if (ql2xdoinitscan) - scsi_scan_host(host); + /* Go with fc_rport registration. */ + list_for_each_entry(fcport, &ha->fcports, list) + qla2x00_reg_remote_port(ha, fcport); return 0; @@ -2152,7 +1643,8 @@ probe_failed: probe_disable_device: pci_disable_device(pdev); - return -1; +probe_out: + return ret; } EXPORT_SYMBOL_GPL(qla2x00_probe_one); @@ -2162,9 +1654,9 @@ void qla2x00_remove_one(struct pci_dev *pdev) ha = pci_get_drvdata(pdev); - sysfs_remove_bin_file(&ha->host->shost_gendev.kobj, - &sysfs_fw_dump_attr); - sysfs_remove_bin_file(&ha->host->shost_gendev.kobj, &sysfs_nvram_attr); + qla2x00_free_sysfs_attr(ha); + + fc_remove_host(ha->host); scsi_remove_host(ha->host); @@ -2179,43 +1671,40 @@ 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); - /* turn-off interrupts on the card */ - if (ha->interrupts_on) - qla2x00_disable_intrs(ha); - /* Disable timer */ if (ha->timer_active) qla2x00_stop_timer(ha); /* Kill the kernel thread for this host */ - 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); + if (ha->dpc_thread) { + struct task_struct *t = ha->dpc_thread; - /* TODO: SOMETHING MORE??? */ - } else { - wait_for_completion(&ha->dpc_exited); - } + /* + * qla2xxx_wake_dpc checks for ->dpc_thread + * so we need to zero it out. + */ + ha->dpc_thread = NULL; + kthread_stop(t); } - qla2x00_mem_free(ha); + /* Stop currently executing firmware. */ + qla2x00_stop_firmware(ha); + + /* turn-off interrupts on the card */ + if (ha->interrupts_on) + ha->isp_ops.disable_intrs(ha); + qla2x00_mem_free(ha); ha->flags.online = 0; /* Detach interrupts */ - if (ha->pdev->irq) - free_irq(ha->pdev->irq, ha); + if (ha->host->irq) + free_irq(ha->host->irq, ha); /* release io space registers */ if (ha->iobase) @@ -2225,498 +1714,31 @@ qla2x00_free_device(scsi_qla_host_t *ha) pci_disable_device(ha->pdev); } - -/* - * The following support functions are adopted to handle - * the re-entrant qla2x00_proc_info correctly. - */ -static void -copy_mem_info(struct info_str *info, char *data, int len) -{ - if (info->pos + len > info->offset + info->length) - len = info->offset + info->length - info->pos; - - if (info->pos + len < info->offset) { - info->pos += len; - return; - } - - if (info->pos < info->offset) { - off_t partial; - - partial = info->offset - info->pos; - data += partial; - info->pos += partial; - len -= partial; - } - - if (len > 0) { - memcpy(info->buffer, data, len); - info->pos += len; - info->buffer += len; - } -} - -static int -copy_info(struct info_str *info, char *fmt, ...) -{ - va_list args; - char buf[256]; - int len; - - va_start(args, fmt); - len = vsprintf(buf, fmt, args); - va_end(args); - - copy_mem_info(info, buf, len); - - return (len); -} - -/************************************************************************* -* qla2x00_proc_info -* -* Description: -* Return information to handle /proc support for the driver. -* -* inout : decides the direction of the dataflow and the meaning of the -* variables -* buffer: If inout==0 data is being written to it else read from it -* (ptr to a page buffer) -* *start: If inout==0 start of the valid data in the buffer -* offset: If inout==0 starting offset from the beginning of all -* possible data to return. -* length: If inout==0 max number of bytes to be written into the buffer -* else number of bytes in "buffer" -* Returns: -* < 0: error. errno value. -* >= 0: sizeof data returned. -*************************************************************************/ -int -qla2x00_proc_info(struct Scsi_Host *shost, char *buffer, - char **start, off_t offset, int length, int inout) -{ - struct info_str info; - int retval = -EINVAL; - os_lun_t *up; - os_tgt_t *tq; - unsigned int t, l; - uint32_t tmp_sn; - uint32_t *flags; - uint8_t *loop_state; - scsi_qla_host_t *ha; - char fw_info[30]; - - DEBUG3(printk(KERN_INFO - "Entering proc_info buff_in=%p, offset=0x%lx, length=0x%x\n", - buffer, offset, length);) - - ha = (scsi_qla_host_t *) shost->hostdata; - - if (inout) { - /* Has data been written to the file? */ - DEBUG3(printk( - "%s: has data been written to the file. \n", - __func__);) - - return -ENOSYS; - } - - if (start) { - *start = buffer; - } - - info.buffer = buffer; - info.length = length; - info.offset = offset; - info.pos = 0; - - /* start building the print buffer */ - copy_info(&info, - "QLogic PCI to Fibre Channel Host Adapter for %s:\n" - " Firmware version %s, ", - ha->model_number, qla2x00_get_fw_version_str(ha, fw_info)); - - copy_info(&info, "Driver version %s\n", qla2x00_version_str); - - tmp_sn = ((ha->serial0 & 0x1f) << 16) | (ha->serial2 << 8) | - ha->serial1; - copy_info(&info, "ISP: %s, Serial# %c%05d\n", - ha->brd_info->isp_name, ('A' + tmp_sn/100000), (tmp_sn%100000)); - - copy_info(&info, - "Request Queue = 0x%llx, Response Queue = 0x%llx\n", - (unsigned long long)ha->request_dma, - (unsigned long long)ha->response_dma); - - copy_info(&info, - "Request Queue count = %d, Response Queue count = %d\n", - ha->request_q_length, ha->response_q_length); - - copy_info(&info, - "Total number of active commands = %ld\n", - ha->actthreads); - - copy_info(&info, - "Total number of interrupts = %ld\n", - (long)ha->total_isr_cnt); - - copy_info(&info, - " Device queue depth = 0x%x\n", - (ql2xmaxqdepth == 0) ? 16 : ql2xmaxqdepth); - - copy_info(&info, - "Number of free request entries = %d\n", ha->req_q_cnt); - - copy_info(&info, - "Number of mailbox timeouts = %ld\n", ha->total_mbx_timeout); - - copy_info(&info, - "Number of ISP aborts = %ld\n", ha->total_isp_aborts); - - copy_info(&info, - "Number of loop resyncs = %ld\n", ha->total_loop_resync); - - copy_info(&info, - "Number of retries for empty slots = %ld\n", - qla2x00_stats.outarray_full); - - copy_info(&info, - "Number of reqs in pending_q= %ld, retry_q= %d, " - "done_q= %ld, scsi_retry_q= %d\n", - ha->qthreads, ha->retry_q_cnt, - ha->done_q_cnt, ha->scsi_retry_q_cnt); - - - flags = (uint32_t *) &ha->flags; - - if (atomic_read(&ha->loop_state) == LOOP_DOWN) { - loop_state = "DOWN"; - } else if (atomic_read(&ha->loop_state) == LOOP_UP) { - loop_state = "UP"; - } else if (atomic_read(&ha->loop_state) == LOOP_READY) { - loop_state = "READY"; - } else if (atomic_read(&ha->loop_state) == LOOP_TIMEOUT) { - loop_state = "TIMEOUT"; - } else if (atomic_read(&ha->loop_state) == LOOP_UPDATE) { - loop_state = "UPDATE"; - } else { - loop_state = "UNKNOWN"; - } - - copy_info(&info, - "Host adapter:loop state = <%s>, flags = 0x%lx\n", - loop_state , *flags); - - copy_info(&info, "Dpc flags = 0x%lx\n", ha->dpc_flags); - - copy_info(&info, "MBX flags = 0x%x\n", ha->mbx_flags); - - copy_info(&info, "Link down Timeout = %3.3d\n", - ha->link_down_timeout); - - copy_info(&info, "Port down retry = %3.3d\n", - ha->port_down_retry_count); - - copy_info(&info, "Login retry count = %3.3d\n", - ha->login_retry_count); - - copy_info(&info, - "Commands retried with dropped frame(s) = %d\n", - ha->dropped_frame_error_cnt); - - copy_info(&info, - "Product ID = %04x %04x %04x %04x\n", ha->product_id[0], - ha->product_id[1], ha->product_id[2], ha->product_id[3]); - - copy_info(&info, "\n"); - - /* 2.25 node/port display to proc */ - /* Display the node name for adapter */ - copy_info(&info, "\nSCSI Device Information:\n"); - copy_info(&info, - "scsi-qla%d-adapter-node=" - "%02x%02x%02x%02x%02x%02x%02x%02x;\n", - (int)ha->instance, - ha->init_cb->node_name[0], - ha->init_cb->node_name[1], - ha->init_cb->node_name[2], - ha->init_cb->node_name[3], - ha->init_cb->node_name[4], - ha->init_cb->node_name[5], - ha->init_cb->node_name[6], - ha->init_cb->node_name[7]); - - /* display the port name for adapter */ - copy_info(&info, - "scsi-qla%d-adapter-port=" - "%02x%02x%02x%02x%02x%02x%02x%02x;\n", - (int)ha->instance, - ha->init_cb->port_name[0], - ha->init_cb->port_name[1], - ha->init_cb->port_name[2], - ha->init_cb->port_name[3], - ha->init_cb->port_name[4], - ha->init_cb->port_name[5], - ha->init_cb->port_name[6], - ha->init_cb->port_name[7]); - - /* Print out device port names */ - for (t = 0; t < MAX_FIBRE_DEVICES; t++) { - if ((tq = TGT_Q(ha, t)) == NULL) - continue; - - copy_info(&info, - "scsi-qla%d-target-%d=" - "%02x%02x%02x%02x%02x%02x%02x%02x;\n", - (int)ha->instance, t, - tq->port_name[0], tq->port_name[1], - tq->port_name[2], tq->port_name[3], - tq->port_name[4], tq->port_name[5], - tq->port_name[6], tq->port_name[7]); - } - - copy_info(&info, "\nSCSI LUN Information:\n"); - copy_info(&info, - "(Id:Lun) * - indicates lun is not registered with the OS.\n"); - - /* scan for all equipment stats */ - for (t = 0; t < MAX_FIBRE_DEVICES; t++) { - /* scan all luns */ - for (l = 0; l < ha->max_luns; l++) { - up = (os_lun_t *) GET_LU_Q(ha, t, l); - - if (up == NULL) { - continue; - } - if (up->fclun == NULL) { - continue; - } - - copy_info(&info, - "(%2d:%2d): Total reqs %ld,", - t,l,up->io_cnt); - - copy_info(&info, - " Pending reqs %ld,", - up->out_cnt); - - if (up->io_cnt < 4) { - copy_info(&info, - " flags 0x%x*,", - (int)up->q_flag); - } else { - copy_info(&info, - " flags 0x%x,", - (int)up->q_flag); - } - - copy_info(&info, - " %ld:%d:%02x %02x", - up->fclun->fcport->ha->instance, - up->fclun->fcport->cur_path, - up->fclun->fcport->loop_id, - up->fclun->device_type); - - copy_info(&info, "\n"); - - if (info.pos >= info.offset + info.length) { - /* No need to continue */ - goto profile_stop; - } - } - - if (info.pos >= info.offset + info.length) { - /* No need to continue */ - break; - } - } - -profile_stop: - - retval = info.pos > info.offset ? info.pos - info.offset : 0; - - DEBUG3(printk(KERN_INFO - "Exiting proc_info: info.pos=%d, offset=0x%lx, " - "length=0x%x\n", info.pos, offset, length);) - - return (retval); -} - -/* -* qla2x00_display_fc_names -* This routine will the node names of the different devices found -* after port inquiry. -* -* Input: -* cmd = SCSI command structure -* -* Returns: -* None. -*/ -static void -qla2x00_display_fc_names(scsi_qla_host_t *ha) -{ - uint16_t tgt; - os_tgt_t *tq; - - /* Display the node name for adapter */ - qla_printk(KERN_INFO, ha, - "scsi-qla%d-adapter-node=%02x%02x%02x%02x%02x%02x%02x%02x\\;\n", - (int)ha->instance, - ha->init_cb->node_name[0], - ha->init_cb->node_name[1], - ha->init_cb->node_name[2], - ha->init_cb->node_name[3], - ha->init_cb->node_name[4], - ha->init_cb->node_name[5], - ha->init_cb->node_name[6], - ha->init_cb->node_name[7]); - - /* display the port name for adapter */ - qla_printk(KERN_INFO, ha, - "scsi-qla%d-adapter-port=%02x%02x%02x%02x%02x%02x%02x%02x\\;\n", - (int)ha->instance, - ha->init_cb->port_name[0], - ha->init_cb->port_name[1], - ha->init_cb->port_name[2], - ha->init_cb->port_name[3], - ha->init_cb->port_name[4], - ha->init_cb->port_name[5], - ha->init_cb->port_name[6], - ha->init_cb->port_name[7]); - - /* Print out device port names */ - for (tgt = 0; tgt < MAX_TARGETS; tgt++) { - if ((tq = ha->otgt[tgt]) == NULL) - continue; - - if (tq->fcport == NULL) - continue; - - switch (ha->binding_type) { - case BIND_BY_PORT_NAME: - qla_printk(KERN_INFO, ha, - "scsi-qla%d-tgt-%d-di-0-port=" - "%02x%02x%02x%02x%02x%02x%02x%02x\\;\n", - (int)ha->instance, - tgt, - tq->port_name[0], - tq->port_name[1], - tq->port_name[2], - tq->port_name[3], - tq->port_name[4], - tq->port_name[5], - tq->port_name[6], - tq->port_name[7]); - - break; - - case BIND_BY_PORT_ID: - qla_printk(KERN_INFO, ha, - "scsi-qla%d-tgt-%d-di-0-pid=" - "%02x%02x%02x\\;\n", - (int)ha->instance, - tgt, - tq->d_id.b.domain, - tq->d_id.b.area, - tq->d_id.b.al_pa); - break; - } - -#if VSA - qla_printk(KERN_INFO, ha, - "scsi-qla%d-target-%d-vsa=01;\n", (int)ha->instance, tgt); -#endif - } -} - -/* - * qla2x00_suspend_lun - * Suspend lun and start port down timer - * - * Input: - * ha = visable adapter block pointer. - * lq = lun queue - * cp = Scsi command pointer - * time = time in seconds - * count = number of times to let time expire - * delay_lun = non-zero, if lun should be delayed rather than suspended - * - * Return: - * QLA_SUCCESS -- suspended lun - * QLA_FUNCTION_FAILED -- Didn't suspend lun - * - * Context: - * Interrupt context. - */ -int -__qla2x00_suspend_lun(scsi_qla_host_t *ha, - os_lun_t *lq, int time, int count, int delay_lun) +static inline void +qla2x00_schedule_rport_del(struct scsi_qla_host *ha, fc_port_t *fcport, + int defer) { - int rval; - srb_t *sp; - struct list_head *list, *temp; unsigned long flags; + struct fc_rport *rport; - rval = QLA_SUCCESS; - - /* if the lun_q is already suspended then don't do it again */ - if (lq->q_state == LUN_STATE_READY ||lq->q_state == LUN_STATE_RUN) { - - spin_lock_irqsave(&lq->q_lock, flags); - if (lq->q_state == LUN_STATE_READY) { - lq->q_max = count; - lq->q_count = 0; - } - /* Set the suspend time usually 6 secs */ - atomic_set(&lq->q_timer, time); - - /* now suspend the lun */ - lq->q_state = LUN_STATE_WAIT; - - if (delay_lun) { - set_bit(LUN_EXEC_DELAYED, &lq->q_flag); - DEBUG(printk(KERN_INFO - "scsi(%ld): Delay lun execution for %d secs, " - "count=%d, max count=%d, state=%d\n", - ha->host_no, - time, - lq->q_count, lq->q_max, lq->q_state)); - } else { - DEBUG(printk(KERN_INFO - "scsi(%ld): Suspend lun for %d secs, count=%d, " - "max count=%d, state=%d\n", - ha->host_no, - time, - lq->q_count, lq->q_max, lq->q_state)); - } - spin_unlock_irqrestore(&lq->q_lock, flags); - - /* - * Remove all pending commands from request queue and put them - * in the scsi_retry queue. - */ - spin_lock_irqsave(&ha->list_lock, flags); - list_for_each_safe(list, temp, &ha->pending_queue) { - sp = list_entry(list, srb_t, list); - if (sp->lun_queue != lq) - continue; - - __del_from_pending_queue(ha, sp); - - if (sp->cmd->allowed < count) - sp->cmd->allowed = count; - __add_to_scsi_retry_queue(ha, sp); + if (!fcport->rport) + return; - } /* list_for_each_safe */ - spin_unlock_irqrestore(&ha->list_lock, flags); - rval = QLA_SUCCESS; + rport = fcport->rport; + if (defer) { + spin_lock_irqsave(&fcport->rport_lock, flags); + fcport->drport = rport; + fcport->rport = NULL; + *(fc_port_t **)rport->dd_data = NULL; + spin_unlock_irqrestore(&fcport->rport_lock, flags); + set_bit(FCPORT_UPDATE_NEEDED, &ha->dpc_flags); } else { - rval = QLA_FUNCTION_FAILED; + spin_lock_irqsave(&fcport->rport_lock, flags); + fcport->rport = NULL; + *(fc_port_t **)rport->dd_data = NULL; + spin_unlock_irqrestore(&fcport->rport_lock, flags); + fc_remote_port_delete(rport); } - - return (rval); } /* @@ -2729,9 +1751,12 @@ __qla2x00_suspend_lun(scsi_qla_host_t *ha, * Context: */ void qla2x00_mark_device_lost(scsi_qla_host_t *ha, fc_port_t *fcport, - int do_login) + int do_login, int defer) { - /* + if (atomic_read(&fcport->state) == FCS_ONLINE) + qla2x00_schedule_rport_del(ha, fcport, defer); + + /* * We may need to retry the login, so don't change the state of the * port but do the retries. */ @@ -2776,7 +1801,7 @@ void qla2x00_mark_device_lost(scsi_qla_host_t *ha, fc_port_t *fcport, * Context: */ void -qla2x00_mark_all_devices_lost(scsi_qla_host_t *ha) +qla2x00_mark_all_devices_lost(scsi_qla_host_t *ha, int defer) { fc_port_t *fcport; @@ -2790,9 +1815,13 @@ qla2x00_mark_all_devices_lost(scsi_qla_host_t *ha) */ if (atomic_read(&fcport->state) == FCS_DEVICE_DEAD) continue; - + if (atomic_read(&fcport->state) == FCS_ONLINE) + qla2x00_schedule_rport_del(ha, fcport, defer); atomic_set(&fcport->state, FCS_DEVICE_LOST); } + + if (defer) + qla2xxx_wake_dpc(ha); } /* @@ -2892,7 +1921,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, @@ -3007,12 +2036,8 @@ qla2x00_mem_alloc(scsi_qla_host_t *ha) static void qla2x00_mem_free(scsi_qla_host_t *ha) { - uint32_t t; struct list_head *fcpl, *fcptemp; fc_port_t *fcport; - struct list_head *fcll, *fcltemp; - fc_lun_t *fclun; - unsigned long wtime;/* max wait time if mbx cmd is busy. */ if (ha == NULL) { /* error */ @@ -3020,18 +2045,6 @@ qla2x00_mem_free(scsi_qla_host_t *ha) return; } - /* Free the target queues */ - for (t = 0; t < MAX_TARGETS; t++) { - qla2x00_tgt_free(ha, t); - } - - /* Make sure all other threads are stopped. */ - wtime = 60 * HZ; - while (ha->dpc_wait && wtime) { - set_current_state(TASK_INTERRUPTIBLE); - wtime = schedule_timeout(wtime); - } - /* free ioctl memory */ qla2x00_free_ioctl_mem(ha); @@ -3103,14 +2116,6 @@ qla2x00_mem_free(scsi_qla_host_t *ha) list_for_each_safe(fcpl, fcptemp, &ha->fcports) { fcport = list_entry(fcpl, fc_port_t, list); - /* fc luns */ - list_for_each_safe(fcll, fcltemp, &fcport->fcluns) { - fclun = list_entry(fcll, fc_lun_t, list); - - list_del_init(&fclun->list); - kfree(fclun); - } - /* fc ports */ list_del_init(&fcport->list); kfree(fcport); @@ -3120,12 +2125,17 @@ 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; + + vfree(ha->optrom_buffer); } /* @@ -3138,17 +2148,16 @@ qla2x00_mem_free(scsi_qla_host_t *ha) * * 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; rval = QLA_SUCCESS; - ha->srb_mempool = mempool_create(SRB_MIN_REQ, mempool_alloc_slab, - mempool_free_slab, srb_cachep); + ha->srb_mempool = mempool_create_slab_pool(SRB_MIN_REQ, srb_cachep); if (ha->srb_mempool == NULL) { qla_printk(KERN_INFO, ha, "Unable to allocate SRB mempool.\n"); rval = QLA_FUNCTION_FAILED; @@ -3158,10 +2167,10 @@ qla2x00_allocate_sp_pool(scsi_qla_host_t *ha) /* * 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); @@ -3185,192 +2194,38 @@ qla2x00_free_sp_pool( scsi_qla_host_t *ha) static int qla2x00_do_dpc(void *data) { - DECLARE_MUTEX_LOCKED(sem); scsi_qla_host_t *ha; fc_port_t *fcport; - os_lun_t *q; - srb_t *sp; uint8_t status; - unsigned long flags = 0; - struct list_head *list, *templist; - int dead_cnt, online_cnt; - int retry_cmds = 0; uint16_t next_loopid; - int t; - os_tgt_t *tq; 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); - unlock_kernel(); - - complete(&ha->dpc_inited); - - while (1) { + while (!kthread_should_stop()) { DEBUG3(printk("qla2x00: DPC handler sleeping\n")); - if (down_interruptible(&sem)) - break; - - if (ha->dpc_should_die) - break; + set_current_state(TASK_INTERRUPTIBLE); + schedule(); + __set_current_state(TASK_RUNNING); DEBUG3(printk("qla2x00: DPC handler waking up\n")); /* Initialization not yet finished. Don't do anything yet. */ - if (!ha->flags.init_done || ha->dpc_active) + if (!ha->flags.init_done) continue; DEBUG3(printk("scsi(%ld): DPC handler\n", ha->host_no)); ha->dpc_active = 1; - if (!list_empty(&ha->done_queue)) - qla2x00_done(ha); - - /* Process commands in retry queue */ - if (test_and_clear_bit(PORT_RESTART_NEEDED, &ha->dpc_flags)) { - DEBUG(printk("scsi(%ld): DPC checking retry_q. " - "total=%d\n", - ha->host_no, ha->retry_q_cnt)); - - spin_lock_irqsave(&ha->list_lock, flags); - dead_cnt = online_cnt = 0; - list_for_each_safe(list, templist, &ha->retry_queue) { - sp = list_entry(list, srb_t, list); - q = sp->lun_queue; - DEBUG3(printk("scsi(%ld): pid=%ld sp=%p, " - "spflags=0x%x, q_flag= 0x%lx\n", - ha->host_no, sp->cmd->serial_number, sp, - sp->flags, q->q_flag)); - - if (q == NULL) - continue; - fcport = q->fclun->fcport; - - if (atomic_read(&fcport->state) == - FCS_DEVICE_DEAD || - atomic_read(&fcport->ha->loop_state) == LOOP_DEAD) { - - __del_from_retry_queue(ha, sp); - sp->cmd->result = DID_NO_CONNECT << 16; - if (atomic_read(&fcport->ha->loop_state) == - LOOP_DOWN) - sp->err_id = SRB_ERR_LOOP; - else - sp->err_id = SRB_ERR_PORT; - sp->cmd->host_scribble = - (unsigned char *) NULL; - __add_to_done_queue(ha, sp); - dead_cnt++; - } else if (atomic_read(&fcport->state) != - FCS_DEVICE_LOST) { - - __del_from_retry_queue(ha, sp); - sp->cmd->result = DID_BUS_BUSY << 16; - sp->cmd->host_scribble = - (unsigned char *) NULL; - __add_to_done_queue(ha, sp); - online_cnt++; - } - } /* list_for_each_safe() */ - spin_unlock_irqrestore(&ha->list_lock, flags); - - DEBUG(printk("scsi(%ld): done processing retry queue " - "- dead=%d, online=%d\n ", - ha->host_no, dead_cnt, online_cnt)); + if (ha->flags.mbox_busy) { + ha->dpc_active = 0; + continue; } - /* Process commands in scsi retry queue */ - if (test_and_clear_bit(SCSI_RESTART_NEEDED, &ha->dpc_flags)) { - /* - * Any requests we want to delay for some period is put - * in the scsi retry queue with a delay added. The - * timer will schedule a "scsi_restart_needed" every - * second as long as there are requests in the scsi - * queue. - */ - DEBUG(printk("scsi(%ld): DPC checking scsi " - "retry_q.total=%d\n", - ha->host_no, ha->scsi_retry_q_cnt)); - - online_cnt = 0; - spin_lock_irqsave(&ha->list_lock, flags); - list_for_each_safe(list, templist, - &ha->scsi_retry_queue) { - - sp = list_entry(list, srb_t, list); - q = sp->lun_queue; - tq = sp->tgt_queue; - - DEBUG3(printk("scsi(%ld): scsi_retry_q: " - "pid=%ld sp=%p, spflags=0x%x, " - "q_flag= 0x%lx,q_state=%d\n", - ha->host_no, sp->cmd->serial_number, - sp, sp->flags, q->q_flag, q->q_state)); - - /* Was this lun suspended */ - if (q->q_state != LUN_STATE_WAIT) { - online_cnt++; - __del_from_scsi_retry_queue(ha, sp); - - if (test_bit(TQF_RETRY_CMDS, - &tq->flags)) { - qla2x00_extend_timeout(sp->cmd, - (sp->cmd->timeout_per_command / HZ) - QLA_CMD_TIMER_DELTA); - __add_to_pending_queue(ha, sp); - retry_cmds++; - } else - __add_to_retry_queue(ha, sp); - } - - /* Was this command suspended for N secs */ - if (sp->delay != 0) { - sp->delay--; - if (sp->delay == 0) { - online_cnt++; - __del_from_scsi_retry_queue( - ha, sp); - __add_to_retry_queue(ha,sp); - } - } - } - spin_unlock_irqrestore(&ha->list_lock, flags); - - /* Clear all Target Unsuspended bits */ - for (t = 0; t < ha->max_targets; t++) { - if ((tq = ha->otgt[t]) == NULL) - continue; - - if (test_bit(TQF_RETRY_CMDS, &tq->flags)) - clear_bit(TQF_RETRY_CMDS, &tq->flags); - } - if (retry_cmds) - qla2x00_next(ha); - - DEBUG(if (online_cnt > 0)) - DEBUG(printk("scsi(%ld): dpc() found scsi reqs to " - "restart= %d\n", - ha->host_no, online_cnt)); - } - - if (ha->flags.mbox_busy) { - if (!list_empty(&ha->done_queue)) - qla2x00_done(ha); - - ha->dpc_active = 0; - continue; - } - - if (test_and_clear_bit(ISP_ABORT_NEEDED, &ha->dpc_flags)) { + if (test_and_clear_bit(ISP_ABORT_NEEDED, &ha->dpc_flags)) { DEBUG(printk("scsi(%ld): dpc: sched " "qla2x00_abort_isp ha = %p\n", @@ -3389,6 +2244,15 @@ qla2x00_do_dpc(void *data) ha->host_no)); } + if (test_and_clear_bit(FCPORT_UPDATE_NEEDED, &ha->dpc_flags)) + qla2x00_update_fcports(ha); + + if (test_and_clear_bit(LOOP_RESET_NEEDED, &ha->dpc_flags)) { + DEBUG(printk("scsi(%ld): dpc: sched loop_reset()\n", + ha->host_no)); + qla2x00_loop_reset(ha); + } + if (test_and_clear_bit(RESET_MARKER_NEEDED, &ha->dpc_flags) && (!(test_and_set_bit(RESET_ACTIVE, &ha->dpc_flags)))) { @@ -3423,29 +2287,26 @@ qla2x00_do_dpc(void *data) 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 status = qla2x00_local_device_login( - ha, fcport->loop_id); + ha, fcport); if (status == QLA_SUCCESS) { fcport->old_loop_id = fcport->loop_id; 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); - atomic_set(&fcport->port_down_timer, - ha->port_down_retry_count * PORT_RETRY_TIME); - fcport->login_retry = 0; + qla2x00_update_fcport(ha, + fcport); } else if (status == 1) { set_bit(RELOGIN_NEEDED, &ha->dpc_flags); /* retry the login again */ @@ -3469,7 +2330,7 @@ qla2x00_do_dpc(void *data) 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", @@ -3493,28 +2354,6 @@ qla2x00_do_dpc(void *data) ha->host_no)); } - - if (test_bit(RESTART_QUEUES_NEEDED, &ha->dpc_flags)) { - DEBUG(printk("scsi(%ld): qla2x00_restart_queues()\n", - ha->host_no)); - - qla2x00_restart_queues(ha, 0); - - DEBUG(printk("scsi(%ld): qla2x00_restart_queues - end\n", - ha->host_no)); - } - - if (test_bit(ABORT_QUEUES_NEEDED, &ha->dpc_flags)) { - - DEBUG(printk("scsi(%ld): qla2x00_abort_queues()\n", - ha->host_no)); - - qla2x00_abort_queues(ha, 0); - - DEBUG(printk("scsi(%ld): qla2x00_abort_queues - end\n", - ha->host_no)); - } - if (test_and_clear_bit(FCPORT_RESCAN_NEEDED, &ha->dpc_flags)) { DEBUG(printk("scsi(%ld): Rescan flagged fcports...\n", @@ -3527,12 +2366,11 @@ qla2x00_do_dpc(void *data) ha->host_no)); } - if (!ha->interrupts_on) - qla2x00_enable_intrs(ha); + ha->isp_ops.enable_intrs(ha); - if (!list_empty(&ha->done_queue)) - qla2x00_done(ha); + if (test_and_clear_bit(BEACON_BLINK_NEEDED, &ha->dpc_flags)) + ha->isp_ops.beacon_blink(ha); ha->dpc_active = 0; } /* End of while(1) */ @@ -3542,49 +2380,16 @@ qla2x00_do_dpc(void *data) /* * Make sure that nobody tries to wake us up again. */ - ha->dpc_wait = NULL; ha->dpc_active = 0; - complete_and_exit(&ha->dpc_exited, 0); + return 0; } -/* - * qla2x00_abort_queues - * Abort all commands on queues on device - * - * Input: - * ha = adapter block pointer. - * - * Context: - * Interrupt context. - */ void -qla2x00_abort_queues(scsi_qla_host_t *ha, uint8_t doneqflg) +qla2xxx_wake_dpc(scsi_qla_host_t *ha) { - - srb_t *sp; - struct list_head *list, *temp; - unsigned long flags; - - clear_bit(ABORT_QUEUES_NEEDED, &ha->dpc_flags); - - /* Return all commands device queues. */ - spin_lock_irqsave(&ha->list_lock,flags); - list_for_each_safe(list, temp, &ha->pending_queue) { - sp = list_entry(list, srb_t, list); - - if (sp->flags & SRB_ABORTED) - continue; - - /* Remove srb from LUN queue. */ - __del_from_pending_queue(ha, sp); - - /* Set ending status. */ - sp->cmd->result = DID_BUS_BUSY << 16; - - __add_to_done_queue(ha, sp); - } - spin_unlock_irqrestore(&ha->list_lock, flags); + if (ha->dpc_thread) + wake_up_process(ha->dpc_thread); } /* @@ -3595,7 +2400,7 @@ qla2x00_abort_queues(scsi_qla_host_t *ha, uint8_t doneqflg) * 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) && @@ -3613,23 +2418,34 @@ qla2x00_rst_aen(scsi_qla_host_t *ha) } } +static void +qla2x00_sp_free_dma(scsi_qla_host_t *ha, srb_t *sp) +{ + struct scsi_cmnd *cmd = sp->cmd; -/* - * 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) + if (sp->flags & SRB_DMA_VALID) { + if (cmd->use_sg) { + dma_unmap_sg(&ha->pdev->dev, cmd->request_buffer, + cmd->use_sg, cmd->sc_data_direction); + } else if (cmd->request_bufflen) { + dma_unmap_single(&ha->pdev->dev, sp->dma_handle, + cmd->request_bufflen, cmd->sc_data_direction); + } + sp->flags &= ~SRB_DMA_VALID; + } + CMD_SP(cmd) = NULL; +} + +void +qla2x00_sp_compl(scsi_qla_host_t *ha, srb_t *sp) { - srb_t *sp; + struct scsi_cmnd *cmd = sp->cmd; - sp = mempool_alloc(ha->srb_mempool, GFP_ATOMIC); - if (sp) - atomic_set(&sp->ref_count, 1); - return (sp); + qla2x00_sp_free_dma(ha, sp); + + mempool_free(sp, ha->srb_mempool); + + cmd->scsi_done(cmd); } /************************************************************************** @@ -3643,37 +2459,19 @@ qla2x00_get_new_sp(scsi_qla_host_t *ha) static void qla2x00_timer(scsi_qla_host_t *ha) { - int t,l; unsigned long cpu_flags = 0; fc_port_t *fcport; - os_lun_t *lq; - os_tgt_t *tq; int start_dpc = 0; int index; srb_t *sp; - - /* - * We try and restart any request in the retry queue every second. - */ - if (!list_empty(&ha->retry_queue)) { - set_bit(PORT_RESTART_NEEDED, &ha->dpc_flags); - start_dpc++; - } - - /* - * We try and restart any request in the scsi_retry queue every second. - */ - if (!list_empty(&ha->scsi_retry_queue)) { - set_bit(SCSI_RESTART_NEEDED, &ha->dpc_flags); - start_dpc++; - } + int t; /* * Ports - Port down timer. * * 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) { @@ -3685,70 +2483,17 @@ qla2x00_timer(scsi_qla_host_t *ha) 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))); } t++; } /* End of for fcport */ - /* - * LUNS - lun suspend timer. - * - * Whenever, a lun is suspended the timer starts decrementing its - * suspend timer every second until it reaches zero. Once it reaches - * zero the lun retry count is decremented. - */ - - /* - * FIXME(dg) - Need to convert this linear search of luns into a search - * of a list of suspended luns. - */ - for (t = 0; t < ha->max_targets; t++) { - if ((tq = ha->otgt[t]) == NULL) - continue; - - for (l = 0; l < ha->max_luns; l++) { - if ((lq = (os_lun_t *) tq->olun[l]) == NULL) - continue; - - spin_lock_irqsave(&lq->q_lock, cpu_flags); - if (lq->q_state == LUN_STATE_WAIT && - atomic_read(&lq->q_timer) != 0) { - - if (atomic_dec_and_test(&lq->q_timer) != 0) { - /* - * A delay should immediately - * transition to a READY state - */ - if (test_and_clear_bit(LUN_EXEC_DELAYED, - &lq->q_flag)) { - lq->q_state = LUN_STATE_READY; - } - else { - lq->q_count++; - if (lq->q_count == lq->q_max) - lq->q_state = - LUN_STATE_TIMEOUT; - else - lq->q_state = - LUN_STATE_RUN; - } - } - DEBUG3(printk("scsi(%ld): lun%d - timer %d, " - "count=%d, max=%d, state=%d\n", - ha->host_no, - l, - atomic_read(&lq->q_timer), - lq->q_count, lq->q_max, lq->q_state)); - } - spin_unlock_irqrestore(&lq->q_lock, cpu_flags); - } /* End of for luns */ - } /* End of for targets */ /* Loop down handler. */ if (atomic_read(&ha->loop_down_timer) > 0 && @@ -3762,17 +2507,19 @@ qla2x00_timer(scsi_qla_host_t *ha) 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); for (index = 1; index < MAX_OUTSTANDING_COMMANDS; index++) { + fc_port_t *sfcp; + sp = ha->outstanding_cmds[index]; if (!sp) continue; - if (!(sp->fclun->fcport->flags & - FCF_TAPE_PRESENT)) + sfcp = sp->fcport; + if (!(sfcp->flags & FCF_TAPE_PRESENT)) continue; set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags); @@ -3803,600 +2550,189 @@ 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))); } - /* - * Done Q Handler -- dgFIXME This handler will kick off doneq if we - * haven't process it in 2 seconds. - */ - if (!list_empty(&ha->done_queue)) - qla2x00_done(ha); - + /* Check if beacon LED needs to be blinked */ + if (ha->beacon_blink_led == 1) { + set_bit(BEACON_BLINK_NEEDED, &ha->dpc_flags); + start_dpc++; + } /* Schedule the DPC routine if needed */ if ((test_bit(ISP_ABORT_NEEDED, &ha->dpc_flags) || test_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags) || + test_bit(LOOP_RESET_NEEDED, &ha->dpc_flags) || + test_bit(FCPORT_UPDATE_NEEDED, &ha->dpc_flags) || start_dpc || test_bit(LOGIN_RETRY_NEEDED, &ha->dpc_flags) || - test_bit(RELOGIN_NEEDED, &ha->dpc_flags)) && - ha->dpc_wait && !ha->dpc_active) { - - up(ha->dpc_wait); - } + 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); qla2x00_restart_timer(ha, WATCH_INTERVAL); } -/* - * qla2x00_extend_timeout - * This routine will extend the timeout to the specified value. - * - * Input: - * cmd = SCSI command structure - * - * Returns: - * None. - */ -void -qla2x00_extend_timeout(struct scsi_cmnd *cmd, int timeout) -{ - srb_t *sp = (srb_t *) CMD_SP(cmd); - u_long our_jiffies = (timeout * HZ) + jiffies; - - sp->ext_history= 0; - sp->e_start = jiffies; - if (cmd->eh_timeout.function) { - mod_timer(&cmd->eh_timeout,our_jiffies); - sp->ext_history |= 1; - } - if (sp->timer.function != NULL) { - /* - * Our internal timer should timeout before the midlayer has a - * chance begin the abort process - */ - mod_timer(&sp->timer,our_jiffies - (QLA_CMD_TIMER_DELTA * HZ)); - - sp->ext_history |= 2; - } -} - -/************************************************************************** -* qla2x00_cmd_timeout -* -* Description: -* Handles the command if it times out in any state. -* -* Input: -* sp - pointer to validate -* -* Returns: -* None. -* Note:Need to add the support for if( sp->state == SRB_FAILOVER_STATE). -**************************************************************************/ -void -qla2x00_cmd_timeout(srb_t *sp) +/* XXX(hch): crude hack to emulate a down_timeout() */ +int +qla2x00_down_timeout(struct semaphore *sema, unsigned long timeout) { - int t, l; - int processed; - scsi_qla_host_t *vis_ha, *dest_ha; - struct scsi_cmnd *cmd; - unsigned long flags, cpu_flags; - fc_port_t *fcport; - - cmd = sp->cmd; - vis_ha = (scsi_qla_host_t *)cmd->device->host->hostdata; + const unsigned int step = 100; /* msecs */ + unsigned int iterations = jiffies_to_msecs(timeout)/100; - DEBUG3(printk("cmd_timeout: Entering sp->state = %x\n", sp->state)); + do { + if (!down_trylock(sema)) + return 0; + if (msleep_interruptible(step)) + break; + } while (--iterations >= 0); - t = cmd->device->id; - l = cmd->device->lun; - fcport = sp->fclun->fcport; - dest_ha = sp->ha; + return -ETIMEDOUT; +} - /* - * If IO is found either in retry Queue - * OR in Lun Queue - * Return this IO back to host - */ - spin_lock_irqsave(&vis_ha->list_lock, flags); - processed = 0; - if (sp->state == SRB_PENDING_STATE) { - __del_from_pending_queue(vis_ha, sp); - DEBUG2(printk("scsi(%ld): Found in Pending queue pid %ld, " - "State = %x., fcport state=%d sjiffs=%lx njiffs=%lx\n", - vis_ha->host_no, cmd->serial_number, sp->state, - atomic_read(&fcport->state), sp->r_start, jiffies)); +#if defined(CONFIG_SCSI_QLA2XXX_EMBEDDED_FIRMWARE) - /* - * If FC_DEVICE is marked as dead return the cmd with - * DID_NO_CONNECT status. Otherwise set the host_byte to - * DID_BUS_BUSY to let the OS retry this cmd. - */ - if (atomic_read(&fcport->state) == FCS_DEVICE_DEAD || - atomic_read(&fcport->ha->loop_state) == LOOP_DEAD) { - cmd->result = DID_NO_CONNECT << 16; - if (atomic_read(&fcport->ha->loop_state) == LOOP_DOWN) - sp->err_id = SRB_ERR_LOOP; - else - sp->err_id = SRB_ERR_PORT; - } else { - cmd->result = DID_BUS_BUSY << 16; - } - __add_to_done_queue(vis_ha, sp); - processed++; - } - spin_unlock_irqrestore(&vis_ha->list_lock, flags); +#define qla2x00_release_firmware() do { } while (0) +#define qla2x00_pci_module_init() (0) +#define qla2x00_pci_module_exit() do { } while (0) - if (processed) { - qla2x00_done(vis_ha); - return; - } +#else /* !defined(CONFIG_SCSI_QLA2XXX_EMBEDDED_FIRMWARE) */ - spin_lock_irqsave(&dest_ha->list_lock, flags); - if ((sp->state == SRB_RETRY_STATE) || - (sp->state == SRB_SCSI_RETRY_STATE)) { +/* Firmware interface routines. */ - DEBUG2(printk("scsi(%ld): Found in (Scsi) Retry queue or " - "failover Q pid %ld, State = %x., fcport state=%d " - "jiffies=%lx retried=%d\n", - dest_ha->host_no, cmd->serial_number, sp->state, - atomic_read(&fcport->state), jiffies, cmd->retries)); +#define FW_BLOBS 5 +#define FW_ISP21XX 0 +#define FW_ISP22XX 1 +#define FW_ISP2300 2 +#define FW_ISP2322 3 +#define FW_ISP24XX 4 - if ((sp->state == SRB_RETRY_STATE)) { - __del_from_retry_queue(dest_ha, sp); - } else if ((sp->state == SRB_SCSI_RETRY_STATE)) { - __del_from_scsi_retry_queue(dest_ha, sp); - } +static DECLARE_MUTEX(qla_fw_lock); - /* - * If FC_DEVICE is marked as dead return the cmd with - * DID_NO_CONNECT status. Otherwise set the host_byte to - * DID_BUS_BUSY to let the OS retry this cmd. - */ - if ((atomic_read(&fcport->state) == FCS_DEVICE_DEAD) || - atomic_read(&dest_ha->loop_state) == LOOP_DEAD) { - qla2x00_extend_timeout(cmd, EXTEND_CMD_TIMEOUT); - cmd->result = DID_NO_CONNECT << 16; - if (atomic_read(&dest_ha->loop_state) == LOOP_DOWN) - sp->err_id = SRB_ERR_LOOP; - else - sp->err_id = SRB_ERR_PORT; - } else { - cmd->result = DID_BUS_BUSY << 16; - } +static struct fw_blob qla_fw_blobs[FW_BLOBS] = { + { .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 = "ql2400_fw.bin", }, +}; - __add_to_done_queue(dest_ha, sp); - processed++; - } - spin_unlock_irqrestore(&dest_ha->list_lock, flags); +struct fw_blob * +qla2x00_request_firmware(scsi_qla_host_t *ha) +{ + struct fw_blob *blob; - if (processed) { - qla2x00_done(dest_ha); - return; + blob = NULL; + if (IS_QLA2100(ha)) { + 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)) { + blob = &qla_fw_blobs[FW_ISP2300]; + } else if (IS_QLA2322(ha) || IS_QLA6322(ha)) { + blob = &qla_fw_blobs[FW_ISP2322]; + } else if (IS_QLA24XX(ha) || IS_QLA54XX(ha)) { + blob = &qla_fw_blobs[FW_ISP24XX]; } - spin_lock_irqsave(&dest_ha->list_lock, cpu_flags); - if (sp->state == SRB_DONE_STATE) { - /* IO in done_q -- leave it */ - DEBUG(printk("scsi(%ld): Found in Done queue pid %ld sp=%p.\n", - dest_ha->host_no, cmd->serial_number, sp)); - } else if (sp->state == SRB_SUSPENDED_STATE) { - DEBUG(printk("scsi(%ld): Found SP %p in suspended state " - "- pid %ld:\n", - dest_ha->host_no, sp, cmd->serial_number)); - DEBUG(qla2x00_dump_buffer((uint8_t *)sp, sizeof(srb_t));) - } else if (sp->state == SRB_ACTIVE_STATE) { - /* - * IO is with ISP find the command in our active list. - */ - spin_unlock_irqrestore(&dest_ha->list_lock, cpu_flags); - spin_lock_irqsave(&dest_ha->hardware_lock, flags); - if (sp == dest_ha->outstanding_cmds[ - (unsigned long)sp->cmd->host_scribble]) { - - DEBUG(printk("cmd_timeout: Found in ISP \n")); - - if (sp->flags & SRB_TAPE) { - /* - * We cannot allow the midlayer error handler - * to wakeup and begin the abort process. - * Extend the timer so that the firmware can - * properly return the IOCB. - */ - DEBUG(printk("cmd_timeout: Extending timeout " - "of FCP2 tape command!\n")); - qla2x00_extend_timeout(sp->cmd, - EXTEND_CMD_TIMEOUT); - } - sp->state = SRB_ACTIVE_TIMEOUT_STATE; - spin_unlock_irqrestore(&dest_ha->hardware_lock, flags); - } else { - spin_unlock_irqrestore(&dest_ha->hardware_lock, flags); - printk(KERN_INFO - "qla_cmd_timeout: State indicates it is with " - "ISP, But not in active array\n"); - } - spin_lock_irqsave(&dest_ha->list_lock, cpu_flags); - } else if (sp->state == SRB_ACTIVE_TIMEOUT_STATE) { - DEBUG(printk("qla2100%ld: Found in Active timeout state" - "pid %ld, State = %x., \n", - dest_ha->host_no, - sp->cmd->serial_number, sp->state);) - } else { - /* EMPTY */ - DEBUG2(printk("cmd_timeout%ld: LOST command state = " - "0x%x, sp=%p\n", - vis_ha->host_no, sp->state,sp);) + down(&qla_fw_lock); + if (blob->fw) + goto out; - qla_printk(KERN_INFO, vis_ha, - "cmd_timeout: LOST command state = 0x%x\n", sp->state); + if (request_firmware(&blob->fw, blob->name, &ha->pdev->dev)) { + DEBUG2(printk("scsi(%ld): Failed to load firmware image " + "(%s).\n", ha->host_no, blob->name)); + blob->fw = NULL; + blob = NULL; + goto out; } - spin_unlock_irqrestore(&dest_ha->list_lock, cpu_flags); - DEBUG3(printk("cmd_timeout: Leaving\n");) +out: + up(&qla_fw_lock); + return blob; } -/************************************************************************** -* qla2x00_done -* Process completed commands. -* -* Input: -* old_ha = adapter block pointer. -* -**************************************************************************/ -void -qla2x00_done(scsi_qla_host_t *old_ha) +static void +qla2x00_release_firmware(void) { - os_lun_t *lq; - struct scsi_cmnd *cmd; - unsigned long flags = 0; - scsi_qla_host_t *ha; - scsi_qla_host_t *vis_ha; - int send_marker_once = 0; - srb_t *sp, *sptemp; - LIST_HEAD(local_sp_list); - - /* - * Get into local queue such that we do not wind up calling done queue - * tasklet for the same IOs from DPC or any other place. - */ - spin_lock_irqsave(&old_ha->list_lock, flags); - list_splice_init(&old_ha->done_queue, &local_sp_list); - spin_unlock_irqrestore(&old_ha->list_lock, flags); - - /* - * All done commands are in the local queue, now do the call back. - */ - list_for_each_entry_safe(sp, sptemp, &local_sp_list, list) { - old_ha->done_q_cnt--; - sp->state = SRB_NO_QUEUE_STATE; - - /* remove command from local list */ - list_del_init(&sp->list); - - cmd = sp->cmd; - if (cmd == NULL) - continue; - - vis_ha = (scsi_qla_host_t *)cmd->device->host->hostdata; - lq = sp->lun_queue; - ha = sp->ha; - - if (sp->flags & SRB_DMA_VALID) { - sp->flags &= ~SRB_DMA_VALID; - - /* Release memory used for this I/O */ - if (cmd->use_sg) { - pci_unmap_sg(ha->pdev, cmd->request_buffer, - cmd->use_sg, cmd->sc_data_direction); - } else if (cmd->request_bufflen) { - pci_unmap_page(ha->pdev, sp->dma_handle, - cmd->request_bufflen, - cmd->sc_data_direction); - } - } - - - switch (host_byte(cmd->result)) { - case DID_OK: - case DID_ERROR: - break; + int idx; - case DID_RESET: - /* - * Set marker needed, so we don't have to - * send multiple markers - */ - if (!send_marker_once) { - ha->marker_needed = 1; - send_marker_once++; - } - - /* - * WORKAROUND - * - * A backdoor device-reset requires different - * error handling. This code differentiates - * between normal error handling and the - * backdoor method. - * - */ - if (ha->host->eh_active != EH_ACTIVE) - cmd->result = DID_BUS_BUSY << 16; - break; - - - case DID_ABORT: - sp->flags &= ~SRB_ABORT_PENDING; - sp->flags |= SRB_ABORTED; - - if (sp->flags & SRB_TIMEOUT) - cmd->result = DID_TIME_OUT << 16; - - break; - - default: - DEBUG2(printk("scsi(%ld:%d:%d) %s: did_error " - "= %d, comp-scsi= 0x%x-0x%x pid=%ld.\n", - vis_ha->host_no, - cmd->device->id, cmd->device->lun, - __func__, - host_byte(cmd->result), - CMD_COMPL_STATUS(cmd), - CMD_SCSI_STATUS(cmd), cmd->serial_number)); - break; - } - - /* - * Call the mid-level driver interrupt handler -- via sp_put() - */ - sp_put(ha, sp); - } /* end of while */ + down(&qla_fw_lock); + for (idx = 0; idx < FW_BLOBS; idx++) + if (qla_fw_blobs[idx].fw) + release_firmware(qla_fw_blobs[idx].fw); + up(&qla_fw_lock); } -/* - * qla2x00_process_response_queue_in_zio_mode - * Process response queue completion as fast as possible - * to achieve Zero Interrupt Opertions-ZIO - * - * Input: - * ha = adapter block pointer. - * - * Context: - * Kernel context. - */ -static inline void -qla2x00_process_response_queue_in_zio_mode(scsi_qla_host_t *ha) -{ - unsigned long flags; +static struct qla_board_info qla_board_tbl = { + .drv_name = "qla2xxx", +}; - /* Check for unprocessed commands in response queue. */ - if (!ha->flags.process_response_queue) - return; - if (!ha->flags.online) - return; - if (ha->response_ring_ptr->signature == RESPONSE_PROCESSED) - return; - - spin_lock_irqsave(&ha->hardware_lock,flags); - qla2x00_process_response_queue(ha); - spin_unlock_irqrestore(&ha->hardware_lock, flags); -} +static struct pci_device_id qla2xxx_pci_tbl[] = { + { 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, }, + { PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP5422, + PCI_ANY_ID, PCI_ANY_ID, }, + { PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP5432, + PCI_ANY_ID, PCI_ANY_ID, }, + { 0 }, +}; +MODULE_DEVICE_TABLE(pci, qla2xxx_pci_tbl); -/* - * qla2x00_next - * Retrieve and process next job in the LUN queue. - * - * Input: - * tq = SCSI target queue pointer. - * lq = SCSI LUN queue pointer. - * TGT_LOCK must be already obtained. - * - * Output: - * Releases TGT_LOCK upon exit. - * - * Context: - * Kernel/Interrupt context. - * - * Note: This routine will always try to start I/O from visible HBA. - */ -void -qla2x00_next(scsi_qla_host_t *vis_ha) +static int __devinit +qla2xxx_probe_one(struct pci_dev *pdev, const struct pci_device_id *id) { - int rval; - unsigned long flags; - scsi_qla_host_t *dest_ha; - fc_port_t *fcport; - srb_t *sp, *sptemp; - LIST_HEAD(local_sp_list); - - dest_ha = NULL; - - spin_lock_irqsave(&vis_ha->list_lock, flags); - list_splice_init(&vis_ha->pending_queue, &local_sp_list); - vis_ha->qthreads = 0; - spin_unlock_irqrestore(&vis_ha->list_lock, flags); - - list_for_each_entry_safe(sp, sptemp, &local_sp_list, list) { - list_del_init(&sp->list); - sp->state = SRB_NO_QUEUE_STATE; - - fcport = sp->fclun->fcport; - dest_ha = fcport->ha; - - /* If device is dead then send request back to OS */ - if (atomic_read(&fcport->state) == FCS_DEVICE_DEAD) { - sp->cmd->result = DID_NO_CONNECT << 16; - if (atomic_read(&dest_ha->loop_state) == LOOP_DOWN) - sp->err_id = SRB_ERR_LOOP; - else - sp->err_id = SRB_ERR_PORT; - - DEBUG3(printk("scsi(%ld): loop/port is down - pid=%ld, " - "sp=%p err_id=%d loopid=0x%x queued to dest HBA " - "scsi%ld.\n", dest_ha->host_no, - sp->cmd->serial_number, sp, sp->err_id, - fcport->loop_id, dest_ha->host_no)); - /* - * Initiate a failover - done routine will initiate. - */ - add_to_done_queue(vis_ha, sp); - - continue; - } - - /* - * SCSI Kluge: Whenever, we need to wait for an event such as - * loop down (i.e. loop_down_timer ) or port down (i.e. LUN - * request qeueue is suspended) then we will recycle new - * commands back to the SCSI layer. We do this because this is - * normally a temporary condition and we don't want the - * mid-level scsi.c driver to get upset and start aborting - * commands. The timeout value is extracted from the command - * minus 1-second and put on a retry queue (watchdog). Once the - * command timeout it is returned to the mid-level with a BUSY - * status, so the mid-level will retry it. This process - * continues until the LOOP DOWN time expires or the condition - * goes away. - */ - if (!(sp->flags & (SRB_IOCTL | SRB_TAPE)) && - (atomic_read(&fcport->state) != FCS_ONLINE || - test_bit(ABORT_ISP_ACTIVE, &dest_ha->dpc_flags) || - atomic_read(&dest_ha->loop_state) != LOOP_READY)) { - - DEBUG3(printk("scsi(%ld): pid=%ld port=0x%x state=%d " - "loop state=%d, loop counter=0x%x " - "dpc_flags=0x%lx\n", sp->cmd->serial_number, - dest_ha->host_no, fcport->loop_id, - atomic_read(&fcport->state), - atomic_read(&dest_ha->loop_state), - atomic_read(&dest_ha->loop_down_timer), - dest_ha->dpc_flags)); - - qla2x00_extend_timeout(sp->cmd, EXTEND_CMD_TIMEOUT); - add_to_retry_queue(vis_ha, sp); - - continue; - } - - /* - * If this request's lun is suspended then put the request on - * the scsi_retry queue. - */ - if (!(sp->flags & (SRB_IOCTL | SRB_TAPE)) && - sp->lun_queue->q_state == LUN_STATE_WAIT) { - DEBUG3(printk("scsi(%ld): lun wait state - pid=%ld, " - "opcode=%d, allowed=%d, retries=%d\n", - dest_ha->host_no, - sp->cmd->serial_number, - sp->cmd->cmnd[0], - sp->cmd->allowed, - sp->cmd->retries)); - - add_to_scsi_retry_queue(vis_ha, sp); - - continue; - } - - sp->lun_queue->io_cnt++; - - rval = qla2x00_start_scsi(sp); - if (rval != QLA_SUCCESS) { - /* Place request back on top of device queue */ - /* add to the top of queue */ - add_to_pending_queue_head(vis_ha, sp); - - sp->lun_queue->io_cnt--; - } - } - - if (!IS_QLA2100(vis_ha) && !IS_QLA2200(vis_ha)) { - /* Process response_queue if ZIO support is enabled*/ - qla2x00_process_response_queue_in_zio_mode(vis_ha); - - } + return qla2x00_probe_one(pdev, &qla_board_tbl); } -/* XXX(hch): crude hack to emulate a down_timeout() */ -int -qla2x00_down_timeout(struct semaphore *sema, unsigned long timeout) +static void __devexit +qla2xxx_remove_one(struct pci_dev *pdev) { - const unsigned int step = HZ/10; - - do { - if (!down_trylock(sema)) - return 0; - set_current_state(TASK_INTERRUPTIBLE); - if (schedule_timeout(step)) - break; - } while ((timeout -= step) > 0); - - return -ETIMEDOUT; + qla2x00_remove_one(pdev); } -static void -qla2xxx_get_port_id(struct scsi_target *starget) -{ - struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); - scsi_qla_host_t *ha = to_qla_host(shost); - struct fc_port *fc; - - list_for_each_entry(fc, &ha->fcports, list) { - if (fc->os_target_id == starget->id) { - fc_starget_port_id(starget) = fc->d_id.b.domain << 16 | - fc->d_id.b.area << 8 | - fc->d_id.b.al_pa; - return; - } - } - fc_starget_port_id(starget) = -1; -} +static struct pci_driver qla2xxx_pci_driver = { + .name = "qla2xxx", + .driver = { + .owner = THIS_MODULE, + }, + .id_table = qla2xxx_pci_tbl, + .probe = qla2xxx_probe_one, + .remove = __devexit_p(qla2xxx_remove_one), +}; -static void -qla2xxx_get_port_name(struct scsi_target *starget) +static inline int +qla2x00_pci_module_init(void) { - struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); - scsi_qla_host_t *ha = to_qla_host(shost); - struct fc_port *fc; - - list_for_each_entry(fc, &ha->fcports, list) { - if (fc->os_target_id == starget->id) { - fc_starget_port_name(starget) = - __be64_to_cpu(*(uint64_t *)fc->port_name); - return; - } - } - fc_starget_port_name(starget) = -1; + return pci_module_init(&qla2xxx_pci_driver); } -static void -qla2xxx_get_node_name(struct scsi_target *starget) +static inline void +qla2x00_pci_module_exit(void) { - struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); - scsi_qla_host_t *ha = to_qla_host(shost); - struct fc_port *fc; - - list_for_each_entry(fc, &ha->fcports, list) { - if (fc->os_target_id == starget->id) { - fc_starget_node_name(starget) = - __be64_to_cpu(*(uint64_t *)fc->node_name); - return; - } - } - fc_starget_node_name(starget) = -1; + pci_unregister_driver(&qla2xxx_pci_driver); } -static struct fc_function_template qla2xxx_transport_functions = { - .get_starget_port_id = qla2xxx_get_port_id, - .show_starget_port_id = 1, - .get_starget_port_name = qla2xxx_get_port_name, - .show_starget_port_name = 1, - .get_starget_node_name = qla2xxx_get_node_name, - .show_starget_node_name = 1, -}; +#endif /** * qla2x00_module_init - Module initialization. @@ -4404,9 +2740,10 @@ static struct fc_function_template qla2xxx_transport_functions = { static int __init qla2x00_module_init(void) { + int ret = 0; + /* Allocate cache for SRBs. */ - sprintf(srb_cachep_name, "qla2xxx_srbs"); - srb_cachep = kmem_cache_create(srb_cachep_name, sizeof(srb_t), 0, + srb_cachep = kmem_cache_create("qla2xxx_srbs", sizeof(srb_t), 0, SLAB_HWCACHE_ALIGN, NULL, NULL); if (srb_cachep == NULL) { printk(KERN_ERR @@ -4416,16 +2753,24 @@ qla2x00_module_init(void) /* Derive version string. */ strcpy(qla2x00_version_str, QLA2XXX_VERSION); +#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); + qla2xxx_transport_template = + fc_attach_transport(&qla2xxx_transport_functions); if (!qla2xxx_transport_template) return -ENODEV; printk(KERN_INFO "QLogic Fibre Channel HBA Driver\n"); - return 0; + ret = qla2x00_pci_module_init(); + if (ret) { + kmem_cache_destroy(srb_cachep); + fc_release_transport(qla2xxx_transport_template); + } + return ret; } /** @@ -4434,16 +2779,9 @@ qla2x00_module_init(void) static void __exit qla2x00_module_exit(void) { - /* Free SRBs cache. */ - if (srb_cachep != NULL) { - if (kmem_cache_destroy(srb_cachep) != 0) { - printk(KERN_ERR - "qla2xxx: Unable to free SRB cache...Memory pools " - "still active?\n"); - } - srb_cachep = NULL; - } - + qla2x00_pci_module_exit(); + qla2x00_release_firmware(); + kmem_cache_destroy(srb_cachep); fc_release_transport(qla2xxx_transport_template); }