/*
- * 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 <linux/delay.h>
+#include <linux/vmalloc.h>
#include "qla_devtbl.h"
/*
* QLogic ISP2x00 Hardware Support Function Prototypes.
*/
-static int qla2x00_pci_config(scsi_qla_host_t *);
static int qla2x00_isp_firmware(scsi_qla_host_t *);
-static void qla2x00_reset_chip(scsi_qla_host_t *);
-static int qla2x00_chip_diag(scsi_qla_host_t *);
+static void qla2x00_resize_request_q(scsi_qla_host_t *);
static int qla2x00_setup_chip(scsi_qla_host_t *);
static void qla2x00_init_response_q_entries(scsi_qla_host_t *);
static int qla2x00_init_rings(scsi_qla_host_t *);
static int qla2x00_fw_ready(scsi_qla_host_t *);
static int qla2x00_configure_hba(scsi_qla_host_t *);
-static int qla2x00_nvram_config(scsi_qla_host_t *);
-static void qla2x00_init_tgt_map(scsi_qla_host_t *);
static int qla2x00_configure_loop(scsi_qla_host_t *);
static int qla2x00_configure_local_loop(scsi_qla_host_t *);
-static void qla2x00_update_fcport(scsi_qla_host_t *, fc_port_t *);
-static void qla2x00_lun_discovery(scsi_qla_host_t *, fc_port_t *);
-static int qla2x00_rpt_lun_discovery(scsi_qla_host_t *, fc_port_t *,
- inq_cmd_rsp_t *, dma_addr_t);
-static int qla2x00_report_lun(scsi_qla_host_t *, fc_port_t *,
- rpt_lun_cmd_rsp_t *, dma_addr_t);
-static fc_lun_t *qla2x00_cfg_lun(scsi_qla_host_t *, fc_port_t *, uint16_t,
- inq_cmd_rsp_t *, dma_addr_t);
-static fc_lun_t * qla2x00_add_lun(fc_port_t *, uint16_t);
-static int qla2x00_inquiry(scsi_qla_host_t *, fc_port_t *, uint16_t,
- inq_cmd_rsp_t *, dma_addr_t);
static int qla2x00_configure_fabric(scsi_qla_host_t *);
static int qla2x00_find_all_fabric_devs(scsi_qla_host_t *, struct list_head *);
static int qla2x00_device_resync(scsi_qla_host_t *);
static int qla2x00_fabric_dev_login(scsi_qla_host_t *, fc_port_t *,
uint16_t *);
-static void qla2x00_config_os(scsi_qla_host_t *ha);
-static uint16_t qla2x00_fcport_bind(scsi_qla_host_t *ha, fc_port_t *fcport);
-static os_lun_t * qla2x00_fclun_bind(scsi_qla_host_t *, fc_port_t *,
- fc_lun_t *);
-static void qla2x00_lun_free(scsi_qla_host_t *, uint16_t, uint16_t);
-
-static int qla2x00_bstr_to_hex(char *, uint8_t *, int);
-static int qla2x00_find_propname(scsi_qla_host_t *,
- char *, char *, char *, int);
-#if 0
-static void qla2x00_get_lun_mask_from_config(scsi_qla_host_t *, fc_port_t *,
- uint16_t, uint16_t);
-static int qla2x00_get_prop_16chars(scsi_qla_host_t *,
- char *, char *, char *);
-static void qla2x00_get_properties(scsi_qla_host_t *, char *);
-
-static void qla2x00_cfg_persistent_binding(scsi_qla_host_t *);
-static os_tgt_t *qla2x00_persistent_bind(scsi_qla_host_t *, uint8_t *,
- uint8_t *, port_id_t *, uint16_t);
-#endif
static int qla2x00_restart_isp(scsi_qla_host_t *);
-static void qla2x00_reset_adapter(scsi_qla_host_t *);
+
+static int qla2x00_find_new_loop_id(scsi_qla_host_t *ha, fc_port_t *dev);
/****************************************************************************/
/* QLogic ISP2x00 Hardware Support Functions. */
qla2x00_initialize_adapter(scsi_qla_host_t *ha)
{
int rval;
- uint8_t restart_risc = 0;
- uint8_t retry;
- uint32_t wait_time;
/* Clear adapter flags. */
ha->flags.online = 0;
atomic_set(&ha->loop_down_timer, LOOP_DOWN_TIME);
atomic_set(&ha->loop_state, LOOP_DOWN);
ha->device_flags = 0;
- ha->sns_retry_cnt = 0;
ha->dpc_flags = 0;
- ha->failback_delay = 0;
ha->flags.management_server_logged_in = 0;
ha->marker_needed = 0;
ha->mbx_flags = 0;
ha->isp_abort_cnt = 0;
ha->beacon_blink_led = 0;
+ set_bit(REGISTER_FDMI_NEEDED, &ha->dpc_flags);
- rval = qla2x00_pci_config(ha);
+ qla_printk(KERN_INFO, ha, "Configuring PCI space...\n");
+ rval = ha->isp_ops.pci_config(ha);
if (rval) {
DEBUG2(printk("scsi(%ld): Unable to configure PCI space=n",
ha->host_no));
return (rval);
}
- qla2x00_reset_chip(ha);
-
- /* Initialize target map database. */
- qla2x00_init_tgt_map(ha);
+ ha->isp_ops.reset_chip(ha);
qla_printk(KERN_INFO, ha, "Configure NVRAM parameters...\n");
- qla2x00_nvram_config(ha);
- qla_printk(KERN_INFO, ha, "Verifying loaded RISC code...\n");
+ ha->isp_ops.nvram_config(ha);
-#if 0
- /*
- * If the user specified a device configuration on the command line
- * then use it as the configuration. Otherwise, we scan for all
- * devices.
- */
- if (ql2xdevconf) {
- ha->cmdline = ql2xdevconf;
- qla2x00_get_properties(ha, ql2xdevconf);
+ if (ha->flags.disable_serdes) {
+ /* Mask HBA via NVRAM settings? */
+ qla_printk(KERN_INFO, ha, "Masking HBA WWPN "
+ "%02x%02x%02x%02x%02x%02x%02x%02x (via NVRAM).\n",
+ ha->port_name[0], ha->port_name[1],
+ ha->port_name[2], ha->port_name[3],
+ ha->port_name[4], ha->port_name[5],
+ ha->port_name[6], ha->port_name[7]);
+ return QLA_FUNCTION_FAILED;
}
-#endif
-
- retry = 10;
- /*
- * Try to configure the loop.
- */
- do {
- restart_risc = 0;
- /* If firmware needs to be loaded */
- if (qla2x00_isp_firmware(ha) != QLA_SUCCESS) {
- if ((rval = qla2x00_chip_diag(ha)) == QLA_SUCCESS) {
- rval = qla2x00_setup_chip(ha);
- }
- }
+ qla_printk(KERN_INFO, ha, "Verifying loaded RISC code...\n");
- if (rval == QLA_SUCCESS &&
- (rval = qla2x00_init_rings(ha)) == QLA_SUCCESS) {
-check_fw_ready_again:
- /*
- * Wait for a successful LIP up to a maximum
- * of (in seconds): RISC login timeout value,
- * RISC retry count value, and port down retry
- * value OR a minimum of 4 seconds OR If no
- * cable, only 5 seconds.
- */
- rval = qla2x00_fw_ready(ha);
- if (rval == QLA_SUCCESS) {
- clear_bit(RESET_MARKER_NEEDED, &ha->dpc_flags);
+ if (qla2x00_isp_firmware(ha) != QLA_SUCCESS) {
+ rval = ha->isp_ops.chip_diag(ha);
+ if (rval)
+ return (rval);
+ rval = qla2x00_setup_chip(ha);
+ if (rval)
+ return (rval);
+ }
+ rval = qla2x00_init_rings(ha);
- /*
- * Wait at most MAX_TARGET RSCNs for a stable
- * link.
- */
- wait_time = 256;
- do {
- clear_bit(LOOP_RESYNC_NEEDED,
- &ha->dpc_flags);
- rval = qla2x00_configure_loop(ha);
+ return (rval);
+}
- if (test_and_clear_bit(ISP_ABORT_NEEDED,
- &ha->dpc_flags)) {
- restart_risc = 1;
- break;
- }
+/**
+ * qla2100_pci_config() - Setup ISP21xx PCI configuration registers.
+ * @ha: HA context
+ *
+ * Returns 0 on success.
+ */
+int
+qla2100_pci_config(scsi_qla_host_t *ha)
+{
+ uint16_t w, mwi;
+ uint32_t d;
+ unsigned long flags;
+ struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
- /*
- * If loop state change while we were
- * discoverying devices then wait for
- * LIP to complete
- */
+ pci_set_master(ha->pdev);
+ mwi = 0;
+ if (pci_set_mwi(ha->pdev))
+ mwi = PCI_COMMAND_INVALIDATE;
- if (atomic_read(&ha->loop_state) ==
- LOOP_DOWN && retry--) {
- goto check_fw_ready_again;
- }
- wait_time--;
- } while (!atomic_read(&ha->loop_down_timer) &&
- retry &&
- wait_time &&
- (test_bit(LOOP_RESYNC_NEEDED,
- &ha->dpc_flags)));
-
- if (wait_time == 0)
- rval = QLA_FUNCTION_FAILED;
- if (ha->mem_err)
- restart_risc = 1;
- }
- }
- } while (restart_risc && retry--);
+ pci_read_config_word(ha->pdev, PCI_COMMAND, &w);
+ w |= mwi | (PCI_COMMAND_PARITY | PCI_COMMAND_SERR);
+ pci_write_config_word(ha->pdev, PCI_COMMAND, w);
- if (rval == QLA_SUCCESS) {
- clear_bit(RESET_MARKER_NEEDED, &ha->dpc_flags);
- ha->marker_needed = 1;
- qla2x00_marker(ha, 0, 0, MK_SYNC_ALL);
- ha->marker_needed = 0;
+ /* Reset expansion ROM address decode enable */
+ pci_read_config_dword(ha->pdev, PCI_ROM_ADDRESS, &d);
+ d &= ~PCI_ROM_ADDRESS_ENABLE;
+ pci_write_config_dword(ha->pdev, PCI_ROM_ADDRESS, d);
- ha->flags.online = 1;
- } else {
- DEBUG2_3(printk("%s(): **** FAILED ****\n", __func__));
- }
+ /* Get PCI bus information. */
+ spin_lock_irqsave(&ha->hardware_lock, flags);
+ ha->pci_attr = RD_REG_WORD(®->ctrl_status);
+ spin_unlock_irqrestore(&ha->hardware_lock, flags);
- return (rval);
+ return QLA_SUCCESS;
}
/**
- * qla2x00_pci_config() - Setup device PCI configuration registers.
+ * qla2300_pci_config() - Setup ISP23xx PCI configuration registers.
* @ha: HA context
*
* Returns 0 on success.
*/
-static int
-qla2x00_pci_config(scsi_qla_host_t *ha)
+int
+qla2300_pci_config(scsi_qla_host_t *ha)
{
uint16_t w, mwi;
+ uint32_t d;
unsigned long flags = 0;
uint32_t cnt;
+ struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
- qla_printk(KERN_INFO, ha, "Configuring PCI space...\n");
-
- /*
- * Turn on PCI master; for system BIOSes that don't turn it on by
- * default.
- */
pci_set_master(ha->pdev);
mwi = 0;
if (pci_set_mwi(ha->pdev))
mwi = PCI_COMMAND_INVALIDATE;
- pci_read_config_word(ha->pdev, PCI_REVISION_ID, &ha->revision);
- if (!ha->iobase)
- return (QLA_FUNCTION_FAILED);
+ pci_read_config_word(ha->pdev, PCI_COMMAND, &w);
+ w |= mwi | (PCI_COMMAND_PARITY | PCI_COMMAND_SERR);
+
+ if (IS_QLA2322(ha) || IS_QLA6322(ha))
+ w &= ~PCI_COMMAND_INTX_DISABLE;
/*
- * We want to respect framework's setting of PCI configuration space
- * command register and also want to make sure that all bits of
- * interest to us are properly set in command register.
+ * If this is a 2300 card and not 2312, reset the
+ * COMMAND_INVALIDATE due to a bug in the 2300. Unfortunately,
+ * the 2310 also reports itself as a 2300 so we need to get the
+ * fb revision level -- a 6 indicates it really is a 2300 and
+ * not a 2310.
*/
- pci_read_config_word(ha->pdev, PCI_COMMAND, &w);
- w |= mwi | (PCI_COMMAND_PARITY | PCI_COMMAND_SERR);
+ if (IS_QLA2300(ha)) {
+ spin_lock_irqsave(&ha->hardware_lock, flags);
+
+ /* Pause RISC. */
+ WRT_REG_WORD(®->hccr, HCCR_PAUSE_RISC);
+ for (cnt = 0; cnt < 30000; cnt++) {
+ if ((RD_REG_WORD(®->hccr) & HCCR_RISC_PAUSE) != 0)
+ break;
+
+ udelay(10);
+ }
+
+ /* Select FPM registers. */
+ WRT_REG_WORD(®->ctrl_status, 0x20);
+ RD_REG_WORD(®->ctrl_status);
+
+ /* Get the fb rev level */
+ ha->fb_rev = RD_FB_CMD_REG(ha, reg);
+
+ if (ha->fb_rev == FPM_2300)
+ w &= ~PCI_COMMAND_INVALIDATE;
+
+ /* Deselect FPM registers. */
+ WRT_REG_WORD(®->ctrl_status, 0x0);
+ RD_REG_WORD(®->ctrl_status);
+
+ /* Release RISC module. */
+ WRT_REG_WORD(®->hccr, HCCR_RELEASE_RISC);
+ for (cnt = 0; cnt < 30000; cnt++) {
+ if ((RD_REG_WORD(®->hccr) & HCCR_RISC_PAUSE) == 0)
+ break;
+
+ udelay(10);
+ }
+
+ spin_unlock_irqrestore(&ha->hardware_lock, flags);
+ }
+ pci_write_config_word(ha->pdev, PCI_COMMAND, w);
+
+ pci_write_config_byte(ha->pdev, PCI_LATENCY_TIMER, 0x80);
+
+ /* Reset expansion ROM address decode enable */
+ pci_read_config_dword(ha->pdev, PCI_ROM_ADDRESS, &d);
+ d &= ~PCI_ROM_ADDRESS_ENABLE;
+ pci_write_config_dword(ha->pdev, PCI_ROM_ADDRESS, d);
/* Get PCI bus information. */
spin_lock_irqsave(&ha->hardware_lock, flags);
- ha->pci_attr = RD_REG_WORD(&ha->iobase->ctrl_status);
+ ha->pci_attr = RD_REG_WORD(®->ctrl_status);
spin_unlock_irqrestore(&ha->hardware_lock, flags);
- if (!IS_QLA2100(ha) && !IS_QLA2200(ha)) {
- pci_write_config_byte(ha->pdev, PCI_LATENCY_TIMER, 0x80);
-
- /* PCI Specification Revision 2.3 changes */
- if (IS_QLA2322(ha) || IS_QLA6322(ha))
- /* Command Register - Reset Interrupt Disable. */
- w &= ~PCI_COMMAND_INTX_DISABLE;
+ return QLA_SUCCESS;
+}
- /*
- * If this is a 2300 card and not 2312, reset the
- * COMMAND_INVALIDATE due to a bug in the 2300. Unfortunately,
- * the 2310 also reports itself as a 2300 so we need to get the
- * fb revision level -- a 6 indicates it really is a 2300 and
- * not a 2310.
- */
- if (IS_QLA2300(ha)) {
- spin_lock_irqsave(&ha->hardware_lock, flags);
+/**
+ * qla24xx_pci_config() - Setup ISP24xx PCI configuration registers.
+ * @ha: HA context
+ *
+ * Returns 0 on success.
+ */
+int
+qla24xx_pci_config(scsi_qla_host_t *ha)
+{
+ uint16_t w, mwi;
+ uint32_t d;
+ unsigned long flags = 0;
+ struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
+ int pcix_cmd_reg, pcie_dctl_reg;
- /* Pause RISC. */
- WRT_REG_WORD(&ha->iobase->hccr, HCCR_PAUSE_RISC);
- for (cnt = 0; cnt < 30000; cnt++) {
- if ((RD_REG_WORD(&ha->iobase->hccr) &
- HCCR_RISC_PAUSE) != 0)
- break;
-
- udelay(10);
- }
+ pci_set_master(ha->pdev);
+ mwi = 0;
+ if (pci_set_mwi(ha->pdev))
+ mwi = PCI_COMMAND_INVALIDATE;
- /* Select FPM registers. */
- WRT_REG_WORD(&ha->iobase->ctrl_status, 0x20);
+ pci_read_config_word(ha->pdev, PCI_COMMAND, &w);
+ w |= mwi | (PCI_COMMAND_PARITY | PCI_COMMAND_SERR);
+ w &= ~PCI_COMMAND_INTX_DISABLE;
+ pci_write_config_word(ha->pdev, PCI_COMMAND, w);
- /* Get the fb rev level */
- ha->fb_rev = RD_FB_CMD_REG(ha, ha->iobase);
+ pci_write_config_byte(ha->pdev, PCI_LATENCY_TIMER, 0x80);
- if (ha->fb_rev == FPM_2300)
- w &= ~PCI_COMMAND_INVALIDATE;
+ /* PCI-X -- adjust Maximum Memory Read Byte Count (2048). */
+ pcix_cmd_reg = pci_find_capability(ha->pdev, PCI_CAP_ID_PCIX);
+ if (pcix_cmd_reg) {
+ uint16_t pcix_cmd;
- /* Deselect FPM registers. */
- WRT_REG_WORD(&ha->iobase->ctrl_status, 0x0);
+ pcix_cmd_reg += PCI_X_CMD;
+ pci_read_config_word(ha->pdev, pcix_cmd_reg, &pcix_cmd);
+ pcix_cmd &= ~PCI_X_CMD_MAX_READ;
+ pcix_cmd |= 0x0008;
+ pci_write_config_word(ha->pdev, pcix_cmd_reg, pcix_cmd);
+ }
- /* Release RISC module. */
- WRT_REG_WORD(&ha->iobase->hccr, HCCR_RELEASE_RISC);
- for (cnt = 0; cnt < 30000; cnt++) {
- if ((RD_REG_WORD(&ha->iobase->hccr) &
- HCCR_RISC_PAUSE) == 0)
- break;
-
- udelay(10);
- }
+ /* PCIe -- adjust Maximum Read Request Size (2048). */
+ pcie_dctl_reg = pci_find_capability(ha->pdev, PCI_CAP_ID_EXP);
+ if (pcie_dctl_reg) {
+ uint16_t pcie_dctl;
- spin_unlock_irqrestore(&ha->hardware_lock, flags);
- }
+ pcie_dctl_reg += PCI_EXP_DEVCTL;
+ pci_read_config_word(ha->pdev, pcie_dctl_reg, &pcie_dctl);
+ pcie_dctl &= ~PCI_EXP_DEVCTL_READRQ;
+ pcie_dctl |= 0x4000;
+ pci_write_config_word(ha->pdev, pcie_dctl_reg, pcie_dctl);
}
- pci_write_config_word(ha->pdev, PCI_COMMAND, w);
-
/* Reset expansion ROM address decode enable */
- pci_read_config_word(ha->pdev, PCI_ROM_ADDRESS, &w);
- w &= ~PCI_ROM_ADDRESS_ENABLE;
- pci_write_config_word(ha->pdev, PCI_ROM_ADDRESS, w);
+ pci_read_config_dword(ha->pdev, PCI_ROM_ADDRESS, &d);
+ d &= ~PCI_ROM_ADDRESS_ENABLE;
+ pci_write_config_dword(ha->pdev, PCI_ROM_ADDRESS, d);
+
+ /* Get PCI bus information. */
+ spin_lock_irqsave(&ha->hardware_lock, flags);
+ ha->pci_attr = RD_REG_DWORD(®->ctrl_status);
+ spin_unlock_irqrestore(&ha->hardware_lock, flags);
- return (QLA_SUCCESS);
+ return QLA_SUCCESS;
}
/**
int rval;
/* Assume loading risc code */
- rval = QLA_FUNCTION_FAILED;
+ rval = QLA_FUNCTION_FAILED;
if (ha->flags.disable_risc_code_load) {
DEBUG2(printk("scsi(%ld): RISC CODE NOT loaded\n",
qla_printk(KERN_INFO, ha, "RISC CODE NOT loaded\n");
/* Verify checksum of loaded RISC code. */
- rval = qla2x00_verify_checksum(ha);
+ rval = qla2x00_verify_checksum(ha, ha->fw_srisc_address);
}
if (rval) {
*
* Returns 0 on success.
*/
-static void
-qla2x00_reset_chip(scsi_qla_host_t *ha)
+void
+qla2x00_reset_chip(scsi_qla_host_t *ha)
{
unsigned long flags = 0;
- device_reg_t *reg = ha->iobase;
+ struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
uint32_t cnt;
- unsigned long mbx_flags = 0;
uint16_t cmd;
- /* Disable ISP interrupts. */
- qla2x00_disable_intrs(ha);
+ ha->isp_ops.disable_intrs(ha);
spin_lock_irqsave(&ha->hardware_lock, flags);
udelay(100);
}
} else {
+ RD_REG_WORD(®->hccr); /* PCI Posting. */
udelay(10);
}
/* Select FPM registers. */
WRT_REG_WORD(®->ctrl_status, 0x20);
+ RD_REG_WORD(®->ctrl_status); /* PCI Posting. */
/* FPM Soft Reset. */
WRT_REG_WORD(®->fpm_diag_config, 0x100);
+ RD_REG_WORD(®->fpm_diag_config); /* PCI Posting. */
/* Toggle Fpm Reset. */
- if (!IS_QLA2200(ha))
+ if (!IS_QLA2200(ha)) {
WRT_REG_WORD(®->fpm_diag_config, 0x0);
+ RD_REG_WORD(®->fpm_diag_config); /* PCI Posting. */
+ }
/* Select frame buffer registers. */
WRT_REG_WORD(®->ctrl_status, 0x10);
+ RD_REG_WORD(®->ctrl_status); /* PCI Posting. */
/* Reset frame buffer FIFOs. */
if (IS_QLA2200(ha)) {
WRT_FB_CMD_REG(ha, reg, 0xa000);
+ RD_FB_CMD_REG(ha, reg); /* PCI Posting. */
} else {
WRT_FB_CMD_REG(ha, reg, 0x00fc);
/* Select RISC module registers. */
WRT_REG_WORD(®->ctrl_status, 0);
+ RD_REG_WORD(®->ctrl_status); /* PCI Posting. */
/* Reset RISC processor. */
WRT_REG_WORD(®->hccr, HCCR_RESET_RISC);
+ RD_REG_WORD(®->hccr); /* PCI Posting. */
/* Release RISC processor. */
WRT_REG_WORD(®->hccr, HCCR_RELEASE_RISC);
+ RD_REG_WORD(®->hccr); /* PCI Posting. */
}
WRT_REG_WORD(®->hccr, HCCR_CLR_RISC_INT);
/* Release RISC processor. */
WRT_REG_WORD(®->hccr, HCCR_RELEASE_RISC);
- RD_REG_WORD(®->hccr); /* PCI Posting. */
+ RD_REG_WORD(®->hccr); /* PCI Posting. */
if (IS_QLA2100(ha) || IS_QLA2200(ha) || IS_QLA2300(ha)) {
for (cnt = 0; cnt < 30000; cnt++) {
- if (!(test_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags)))
- spin_lock_irqsave(&ha->mbx_reg_lock, mbx_flags);
-
- if (RD_MAILBOX_REG(ha, reg, 0) != MBS_BUSY) {
- if (!(test_bit(ABORT_ISP_ACTIVE,
- &ha->dpc_flags)))
- spin_unlock_irqrestore(
- &ha->mbx_reg_lock, mbx_flags);
+ if (RD_MAILBOX_REG(ha, reg, 0) != MBS_BUSY)
break;
- }
-
- if (!(test_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags)))
- spin_unlock_irqrestore(&ha->mbx_reg_lock,
- mbx_flags);
udelay(100);
}
pci_write_config_word(ha->pdev, PCI_COMMAND, cmd);
/* Disable RISC pause on FPM parity error. */
- if (!IS_QLA2100(ha))
+ if (!IS_QLA2100(ha)) {
WRT_REG_WORD(®->hccr, HCCR_DISABLE_PARITY_PAUSE);
+ RD_REG_WORD(®->hccr); /* PCI Posting. */
+ }
+
+ spin_unlock_irqrestore(&ha->hardware_lock, flags);
+}
+
+/**
+ * qla24xx_reset_risc() - Perform full reset of ISP24xx RISC.
+ * @ha: HA context
+ *
+ * Returns 0 on success.
+ */
+static inline void
+qla24xx_reset_risc(scsi_qla_host_t *ha)
+{
+ unsigned long flags = 0;
+ struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
+ uint32_t cnt, d2;
+ uint16_t wd;
+
+ spin_lock_irqsave(&ha->hardware_lock, flags);
+
+ /* Reset RISC. */
+ WRT_REG_DWORD(®->ctrl_status, CSRX_DMA_SHUTDOWN|MWB_4096_BYTES);
+ for (cnt = 0; cnt < 30000; cnt++) {
+ if ((RD_REG_DWORD(®->ctrl_status) & CSRX_DMA_ACTIVE) == 0)
+ break;
+
+ udelay(10);
+ }
+
+ WRT_REG_DWORD(®->ctrl_status,
+ CSRX_ISP_SOFT_RESET|CSRX_DMA_SHUTDOWN|MWB_4096_BYTES);
+ pci_read_config_word(ha->pdev, PCI_COMMAND, &wd);
+
+ udelay(100);
+ /* Wait for firmware to complete NVRAM accesses. */
+ d2 = (uint32_t) RD_REG_WORD(®->mailbox0);
+ for (cnt = 10000 ; cnt && d2; cnt--) {
+ udelay(5);
+ d2 = (uint32_t) RD_REG_WORD(®->mailbox0);
+ barrier();
+ }
+
+ /* Wait for soft-reset to complete. */
+ d2 = RD_REG_DWORD(®->ctrl_status);
+ for (cnt = 6000000 ; cnt && (d2 & CSRX_ISP_SOFT_RESET); cnt--) {
+ udelay(5);
+ d2 = RD_REG_DWORD(®->ctrl_status);
+ barrier();
+ }
+
+ WRT_REG_DWORD(®->hccr, HCCRX_SET_RISC_RESET);
+ RD_REG_DWORD(®->hccr);
+
+ WRT_REG_DWORD(®->hccr, HCCRX_REL_RISC_PAUSE);
+ RD_REG_DWORD(®->hccr);
+
+ WRT_REG_DWORD(®->hccr, HCCRX_CLR_RISC_RESET);
+ RD_REG_DWORD(®->hccr);
+
+ d2 = (uint32_t) RD_REG_WORD(®->mailbox0);
+ for (cnt = 6000000 ; cnt && d2; cnt--) {
+ udelay(5);
+ d2 = (uint32_t) RD_REG_WORD(®->mailbox0);
+ barrier();
+ }
spin_unlock_irqrestore(&ha->hardware_lock, flags);
}
+/**
+ * qla24xx_reset_chip() - Reset ISP24xx chip.
+ * @ha: HA context
+ *
+ * Returns 0 on success.
+ */
+void
+qla24xx_reset_chip(scsi_qla_host_t *ha)
+{
+ ha->isp_ops.disable_intrs(ha);
+
+ /* Perform RISC reset. */
+ qla24xx_reset_risc(ha);
+}
+
/**
* qla2x00_chip_diag() - Test chip for proper operation.
* @ha: HA context
*
* Returns 0 on success.
*/
-static int
+int
qla2x00_chip_diag(scsi_qla_host_t *ha)
{
int rval;
- device_reg_t *reg = ha->iobase;
+ struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
unsigned long flags = 0;
uint16_t data;
uint32_t cnt;
/* Reset ISP chip. */
WRT_REG_WORD(®->ctrl_status, CSR_ISP_SOFT_RESET);
+
/*
* We need to have a delay here since the card will not respond while
* in reset causing an MCA on some architectures.
for (cnt = 6000000; cnt && (data == MBS_BUSY); cnt--) {
udelay(5);
data = RD_MAILBOX_REG(ha, reg, 0);
- barrier();
+ barrier();
}
} else
udelay(10);
DEBUG3(printk("scsi(%ld): Found QLA2200A chip.\n",
ha->host_no));
+ ha->device_type |= DT_ISP2200A;
ha->fw_transfer_size = 128;
}
}
/**
- * qla2x00_setup_chip() - Load and start RISC firmware.
+ * qla24xx_chip_diag() - Test ISP24xx for proper operation.
* @ha: HA context
*
* Returns 0 on success.
*/
-static int
-qla2x00_setup_chip(scsi_qla_host_t *ha)
+int
+qla24xx_chip_diag(scsi_qla_host_t *ha)
{
- int rval;
- uint16_t cnt;
- uint16_t *risc_code;
- unsigned long risc_address;
- unsigned long risc_code_size;
- int num;
- int i;
- uint16_t *req_ring;
- struct qla_fw_info *fw_iter;
-
- rval = QLA_SUCCESS;
-
- /* Load firmware sequences */
- fw_iter = ha->brd_info->fw_info;
- while (fw_iter->addressing != FW_INFO_ADDR_NOMORE) {
- risc_code = fw_iter->fwcode;
- risc_code_size = *fw_iter->fwlen;
+ int rval;
- if (fw_iter->addressing == FW_INFO_ADDR_NORMAL) {
- risc_address = *fw_iter->fwstart;
- } else {
- /* Extended address */
- risc_address = *fw_iter->lfwstart;
- }
+ /* Perform RISC reset. */
+ qla24xx_reset_risc(ha);
- num = 0;
- rval = 0;
- while (risc_code_size > 0 && !rval) {
- cnt = (uint16_t)(ha->fw_transfer_size >> 1);
- if (cnt > risc_code_size)
- cnt = risc_code_size;
+ ha->fw_transfer_size = REQUEST_ENTRY_SIZE * 1024;
- DEBUG7(printk("scsi(%ld): Loading risc segment@ "
- "addr %p, number of bytes 0x%x, offset 0x%lx.\n",
- ha->host_no, risc_code, cnt, risc_address));
+ rval = qla2x00_mbx_reg_test(ha);
+ if (rval) {
+ DEBUG(printk("scsi(%ld): Failed mailbox send register test\n",
+ ha->host_no));
+ qla_printk(KERN_WARNING, ha,
+ "Failed mailbox send register test\n");
+ } else {
+ /* Flag a successful rval */
+ rval = QLA_SUCCESS;
+ }
- req_ring = (uint16_t *)ha->request_ring;
- for (i = 0; i < cnt; i++)
- req_ring[i] = cpu_to_le16(risc_code[i]);
+ return rval;
+}
- if (fw_iter->addressing == FW_INFO_ADDR_NORMAL) {
- rval = qla2x00_load_ram(ha,
- ha->request_dma, risc_address, cnt);
- } else {
- rval = qla2x00_load_ram_ext(ha,
- ha->request_dma, risc_address, cnt);
- }
- if (rval) {
- DEBUG(printk("scsi(%ld): [ERROR] Failed to "
- "load segment %d of firmware\n",
- ha->host_no, num));
- qla_printk(KERN_WARNING, ha,
- "[ERROR] Failed to load "
- "segment %d of firmware\n", num);
+void
+qla2x00_alloc_fw_dump(scsi_qla_host_t *ha)
+{
+ int rval;
+ uint32_t dump_size, fixed_size, mem_size, req_q_size, rsp_q_size,
+ eft_size;
+ dma_addr_t eft_dma;
+ void *eft;
- qla2x00_dump_regs(ha);
- break;
- }
+ if (ha->fw_dump) {
+ qla_printk(KERN_WARNING, ha,
+ "Firmware dump previously allocated.\n");
+ return;
+ }
- risc_code += cnt;
- risc_address += cnt;
- risc_code_size -= cnt;
- num++;
+ ha->fw_dumped = 0;
+ fixed_size = mem_size = eft_size = 0;
+ if (IS_QLA2100(ha) || IS_QLA2200(ha)) {
+ fixed_size = sizeof(struct qla2100_fw_dump);
+ } else if (IS_QLA23XX(ha)) {
+ fixed_size = offsetof(struct qla2300_fw_dump, data_ram);
+ mem_size = (ha->fw_memory_size - 0x11000 + 1) *
+ sizeof(uint16_t);
+ } else if (IS_QLA24XX(ha) || IS_QLA54XX(ha)) {
+ fixed_size = offsetof(struct qla24xx_fw_dump, ext_mem);
+ mem_size = (ha->fw_memory_size - 0x100000 + 1) *
+ sizeof(uint32_t);
+
+ /* Allocate memory for Extended Trace Buffer. */
+ eft = dma_alloc_coherent(&ha->pdev->dev, EFT_SIZE, &eft_dma,
+ GFP_KERNEL);
+ if (!eft) {
+ qla_printk(KERN_WARNING, ha, "Unable to allocate "
+ "(%d KB) for EFT.\n", EFT_SIZE / 1024);
+ goto cont_alloc;
+ }
+
+ rval = qla2x00_trace_control(ha, TC_ENABLE, eft_dma,
+ EFT_NUM_BUFFERS);
+ if (rval) {
+ qla_printk(KERN_WARNING, ha, "Unable to initialize "
+ "EFT (%d).\n", rval);
+ dma_free_coherent(&ha->pdev->dev, EFT_SIZE, eft,
+ eft_dma);
+ goto cont_alloc;
+ }
+
+ qla_printk(KERN_INFO, ha, "Allocated (%d KB) for EFT...\n",
+ EFT_SIZE / 1024);
+
+ eft_size = EFT_SIZE;
+ memset(eft, 0, eft_size);
+ ha->eft_dma = eft_dma;
+ ha->eft = eft;
+ }
+cont_alloc:
+ req_q_size = ha->request_q_length * sizeof(request_t);
+ rsp_q_size = ha->response_q_length * sizeof(response_t);
+
+ dump_size = offsetof(struct qla2xxx_fw_dump, isp);
+ dump_size += fixed_size + mem_size + req_q_size + rsp_q_size +
+ eft_size;
+
+ ha->fw_dump = vmalloc(dump_size);
+ if (!ha->fw_dump) {
+ qla_printk(KERN_WARNING, ha, "Unable to allocate (%d KB) for "
+ "firmware dump!!!\n", dump_size / 1024);
+
+ if (ha->eft) {
+ dma_free_coherent(&ha->pdev->dev, eft_size, ha->eft,
+ ha->eft_dma);
+ ha->eft = NULL;
+ ha->eft_dma = 0;
}
-
- /* Next firmware sequence */
- fw_iter++;
+ return;
}
- /* Verify checksum of loaded RISC code. */
- if (!rval) {
- DEBUG(printk("scsi(%ld): Verifying Checksum of loaded RISC "
- "code.\n", ha->host_no));
+ qla_printk(KERN_INFO, ha, "Allocated (%d KB) for firmware dump...\n",
+ dump_size / 1024);
- rval = qla2x00_verify_checksum(ha);
- if (rval == QLA_SUCCESS) {
- /* Start firmware execution. */
- DEBUG(printk("scsi(%ld): Checksum OK, start "
- "firmware.\n", ha->host_no));
+ ha->fw_dump_len = dump_size;
+ ha->fw_dump->signature[0] = 'Q';
+ ha->fw_dump->signature[1] = 'L';
+ ha->fw_dump->signature[2] = 'G';
+ ha->fw_dump->signature[3] = 'C';
+ ha->fw_dump->version = __constant_htonl(1);
- rval = qla2x00_execute_fw(ha);
- /* Retrieve firmware information. */
- if (rval == QLA_SUCCESS && ha->fw_major_version == 0) {
- qla2x00_get_fw_version(ha,
- &ha->fw_major_version,
- &ha->fw_minor_version,
- &ha->fw_subminor_version,
- &ha->fw_attributes, &ha->fw_memory_size);
- }
- }
- else {
- DEBUG2(printk(KERN_INFO
- "scsi(%ld): ISP Firmware failed checksum.\n",
- ha->host_no));
- }
- }
+ ha->fw_dump->fixed_size = htonl(fixed_size);
+ ha->fw_dump->mem_size = htonl(mem_size);
+ ha->fw_dump->req_q_size = htonl(req_q_size);
+ ha->fw_dump->rsp_q_size = htonl(rsp_q_size);
- if (rval) {
- DEBUG2_3(printk("scsi(%ld): Setup chip **** FAILED ****.\n",
- ha->host_no));
- }
+ ha->fw_dump->eft_size = htonl(eft_size);
+ ha->fw_dump->eft_addr_l = htonl(LSD(ha->eft_dma));
+ ha->fw_dump->eft_addr_h = htonl(MSD(ha->eft_dma));
- return (rval);
+ ha->fw_dump->header_size =
+ htonl(offsetof(struct qla2xxx_fw_dump, isp));
}
/**
- * qla2x00_init_response_q_entries() - Initializes response queue entries.
+ * qla2x00_resize_request_q() - Resize request queue given available ISP memory.
* @ha: HA context
*
- * Beginning of request ring has initialization control block already built
+ * Returns 0 on success.
+ */
+static void
+qla2x00_resize_request_q(scsi_qla_host_t *ha)
+{
+ int rval;
+ uint16_t fw_iocb_cnt = 0;
+ uint16_t request_q_length = REQUEST_ENTRY_CNT_2XXX_EXT_MEM;
+ dma_addr_t request_dma;
+ request_t *request_ring;
+
+ /* Valid only on recent ISPs. */
+ if (IS_QLA2100(ha) || IS_QLA2200(ha))
+ return;
+
+ /* Retrieve IOCB counts available to the firmware. */
+ rval = qla2x00_get_resource_cnts(ha, NULL, NULL, NULL, &fw_iocb_cnt);
+ if (rval)
+ return;
+ /* No point in continuing if current settings are sufficient. */
+ if (fw_iocb_cnt < 1024)
+ return;
+ if (ha->request_q_length >= request_q_length)
+ return;
+
+ /* Attempt to claim larger area for request queue. */
+ request_ring = dma_alloc_coherent(&ha->pdev->dev,
+ (request_q_length + 1) * sizeof(request_t), &request_dma,
+ GFP_KERNEL);
+ if (request_ring == NULL)
+ return;
+
+ /* Resize successful, report extensions. */
+ qla_printk(KERN_INFO, ha, "Extended memory detected (%d KB)...\n",
+ (ha->fw_memory_size + 1) / 1024);
+ qla_printk(KERN_INFO, ha, "Resizing request queue depth "
+ "(%d -> %d)...\n", ha->request_q_length, request_q_length);
+
+ /* Clear old allocations. */
+ dma_free_coherent(&ha->pdev->dev,
+ (ha->request_q_length + 1) * sizeof(request_t), ha->request_ring,
+ ha->request_dma);
+
+ /* Begin using larger queue. */
+ ha->request_q_length = request_q_length;
+ ha->request_ring = request_ring;
+ ha->request_dma = request_dma;
+}
+
+/**
+ * qla2x00_setup_chip() - Load and start RISC firmware.
+ * @ha: HA context
+ *
+ * Returns 0 on success.
+ */
+static int
+qla2x00_setup_chip(scsi_qla_host_t *ha)
+{
+ int rval;
+ uint32_t srisc_address = 0;
+
+ /* Load firmware sequences */
+ rval = ha->isp_ops.load_risc(ha, &srisc_address);
+ if (rval == QLA_SUCCESS) {
+ DEBUG(printk("scsi(%ld): Verifying Checksum of loaded RISC "
+ "code.\n", ha->host_no));
+
+ rval = qla2x00_verify_checksum(ha, srisc_address);
+ if (rval == QLA_SUCCESS) {
+ /* Start firmware execution. */
+ DEBUG(printk("scsi(%ld): Checksum OK, start "
+ "firmware.\n", ha->host_no));
+
+ rval = qla2x00_execute_fw(ha, srisc_address);
+ /* Retrieve firmware information. */
+ if (rval == QLA_SUCCESS && ha->fw_major_version == 0) {
+ qla2x00_get_fw_version(ha,
+ &ha->fw_major_version,
+ &ha->fw_minor_version,
+ &ha->fw_subminor_version,
+ &ha->fw_attributes, &ha->fw_memory_size);
+ qla2x00_resize_request_q(ha);
+
+ if (ql2xallocfwdump)
+ qla2x00_alloc_fw_dump(ha);
+ }
+ } else {
+ DEBUG2(printk(KERN_INFO
+ "scsi(%ld): ISP Firmware failed checksum.\n",
+ ha->host_no));
+ }
+ }
+
+ if (rval) {
+ DEBUG2_3(printk("scsi(%ld): Setup chip **** FAILED ****.\n",
+ ha->host_no));
+ }
+
+ return (rval);
+}
+
+/**
+ * qla2x00_init_response_q_entries() - Initializes response queue entries.
+ * @ha: HA context
+ *
+ * Beginning of request ring has initialization control block already built
* by nvram config routine.
*
* Returns 0 on success.
*
* Returns 0 on success.
*/
-static void
+void
qla2x00_update_fw_options(scsi_qla_host_t *ha)
{
- /* Setup seriallink options */
- uint16_t swing, emphasis;
+ uint16_t swing, emphasis, tx_sens, rx_sens;
memset(ha->fw_options, 0, sizeof(ha->fw_options));
qla2x00_get_fw_options(ha, ha->fw_options);
sizeof(ha->fw_seriallink_options)));
ha->fw_options[1] &= ~FO1_SET_EMPHASIS_SWING;
- if (ha->fw_seriallink_options[1] & BIT_2)
+ if (ha->fw_seriallink_options[3] & BIT_2) {
ha->fw_options[1] |= FO1_SET_EMPHASIS_SWING;
- /* 1G settings */
- swing = ha->fw_seriallink_options[0] & (BIT_2 | BIT_1 | BIT_0);
- emphasis = ha->fw_seriallink_options[0] & (BIT_4 | BIT_3);
- emphasis >>= 3;
- ha->fw_options[10] = (emphasis << 14) | (swing << 8) | 0x3;
-
- /* 2G settings */
- swing = ha->fw_seriallink_options[0] & (BIT_7 | BIT_6 | BIT_5);
- swing >>= 5;
- emphasis = ha->fw_seriallink_options[1] & (BIT_1 | BIT_0);
- ha->fw_options[11] = (emphasis << 14) | (swing << 8) | 0x3;
+ /* 1G settings */
+ swing = ha->fw_seriallink_options[2] & (BIT_2 | BIT_1 | BIT_0);
+ emphasis = (ha->fw_seriallink_options[2] &
+ (BIT_4 | BIT_3)) >> 3;
+ tx_sens = ha->fw_seriallink_options[0] &
+ (BIT_3 | BIT_2 | BIT_1 | BIT_0);
+ rx_sens = (ha->fw_seriallink_options[0] &
+ (BIT_7 | BIT_6 | BIT_5 | BIT_4)) >> 4;
+ ha->fw_options[10] = (emphasis << 14) | (swing << 8);
+ if (IS_QLA2300(ha) || IS_QLA2312(ha) || IS_QLA6312(ha)) {
+ if (rx_sens == 0x0)
+ rx_sens = 0x3;
+ ha->fw_options[10] |= (tx_sens << 4) | rx_sens;
+ } else if (IS_QLA2322(ha) || IS_QLA6322(ha))
+ ha->fw_options[10] |= BIT_5 |
+ ((rx_sens & (BIT_1 | BIT_0)) << 2) |
+ (tx_sens & (BIT_1 | BIT_0));
+
+ /* 2G settings */
+ swing = (ha->fw_seriallink_options[2] &
+ (BIT_7 | BIT_6 | BIT_5)) >> 5;
+ emphasis = ha->fw_seriallink_options[3] & (BIT_1 | BIT_0);
+ tx_sens = ha->fw_seriallink_options[1] &
+ (BIT_3 | BIT_2 | BIT_1 | BIT_0);
+ rx_sens = (ha->fw_seriallink_options[1] &
+ (BIT_7 | BIT_6 | BIT_5 | BIT_4)) >> 4;
+ ha->fw_options[11] = (emphasis << 14) | (swing << 8);
+ if (IS_QLA2300(ha) || IS_QLA2312(ha) || IS_QLA6312(ha)) {
+ if (rx_sens == 0x0)
+ rx_sens = 0x3;
+ ha->fw_options[11] |= (tx_sens << 4) | rx_sens;
+ } else if (IS_QLA2322(ha) || IS_QLA6322(ha))
+ ha->fw_options[11] |= BIT_5 |
+ ((rx_sens & (BIT_1 | BIT_0)) << 2) |
+ (tx_sens & (BIT_1 | BIT_0));
+ }
/* FCP2 options. */
/* Return command IOCBs without waiting for an ABTS to complete. */
ha->fw_options[3] |= BIT_13;
- /* Update Serial Link options. */
+ /* LED scheme. */
+ if (ha->flags.enable_led_scheme)
+ ha->fw_options[2] |= BIT_12;
+
+ /* Detect ISP6312. */
+ if (IS_QLA6312(ha))
+ ha->fw_options[2] |= BIT_13;
+
+ /* Update firmware options. */
qla2x00_set_fw_options(ha, ha->fw_options);
}
+void
+qla24xx_update_fw_options(scsi_qla_host_t *ha)
+{
+ int rval;
+
+ /* Update Serial Link options. */
+ if ((le16_to_cpu(ha->fw_seriallink_options24[0]) & BIT_0) == 0)
+ return;
+
+ rval = qla2x00_set_serdes_params(ha,
+ le16_to_cpu(ha->fw_seriallink_options24[1]),
+ le16_to_cpu(ha->fw_seriallink_options24[2]),
+ le16_to_cpu(ha->fw_seriallink_options24[3]));
+ if (rval != QLA_SUCCESS) {
+ qla_printk(KERN_WARNING, ha,
+ "Unable to update Serial Link options (%x).\n", rval);
+ }
+}
+
+void
+qla2x00_config_rings(struct scsi_qla_host *ha)
+{
+ struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
+
+ /* Setup ring parameters in initialization control block. */
+ ha->init_cb->request_q_outpointer = __constant_cpu_to_le16(0);
+ ha->init_cb->response_q_inpointer = __constant_cpu_to_le16(0);
+ ha->init_cb->request_q_length = cpu_to_le16(ha->request_q_length);
+ ha->init_cb->response_q_length = cpu_to_le16(ha->response_q_length);
+ ha->init_cb->request_q_address[0] = cpu_to_le32(LSD(ha->request_dma));
+ ha->init_cb->request_q_address[1] = cpu_to_le32(MSD(ha->request_dma));
+ ha->init_cb->response_q_address[0] = cpu_to_le32(LSD(ha->response_dma));
+ ha->init_cb->response_q_address[1] = cpu_to_le32(MSD(ha->response_dma));
+
+ WRT_REG_WORD(ISP_REQ_Q_IN(ha, reg), 0);
+ WRT_REG_WORD(ISP_REQ_Q_OUT(ha, reg), 0);
+ WRT_REG_WORD(ISP_RSP_Q_IN(ha, reg), 0);
+ WRT_REG_WORD(ISP_RSP_Q_OUT(ha, reg), 0);
+ RD_REG_WORD(ISP_RSP_Q_OUT(ha, reg)); /* PCI Posting. */
+}
+
+void
+qla24xx_config_rings(struct scsi_qla_host *ha)
+{
+ struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
+ struct init_cb_24xx *icb;
+
+ /* Setup ring parameters in initialization control block. */
+ icb = (struct init_cb_24xx *)ha->init_cb;
+ icb->request_q_outpointer = __constant_cpu_to_le16(0);
+ icb->response_q_inpointer = __constant_cpu_to_le16(0);
+ icb->request_q_length = cpu_to_le16(ha->request_q_length);
+ icb->response_q_length = cpu_to_le16(ha->response_q_length);
+ icb->request_q_address[0] = cpu_to_le32(LSD(ha->request_dma));
+ icb->request_q_address[1] = cpu_to_le32(MSD(ha->request_dma));
+ icb->response_q_address[0] = cpu_to_le32(LSD(ha->response_dma));
+ icb->response_q_address[1] = cpu_to_le32(MSD(ha->response_dma));
+
+ WRT_REG_DWORD(®->req_q_in, 0);
+ WRT_REG_DWORD(®->req_q_out, 0);
+ WRT_REG_DWORD(®->rsp_q_in, 0);
+ WRT_REG_DWORD(®->rsp_q_out, 0);
+ RD_REG_DWORD(®->rsp_q_out);
+}
+
/**
* qla2x00_init_rings() - Initializes firmware.
* @ha: HA context
int rval;
unsigned long flags = 0;
int cnt;
- device_reg_t *reg = ha->iobase;
spin_lock_irqsave(&ha->hardware_lock, flags);
/* Clear outstanding commands array. */
for (cnt = 0; cnt < MAX_OUTSTANDING_COMMANDS; cnt++)
- ha->outstanding_cmds[cnt] = 0;
+ ha->outstanding_cmds[cnt] = NULL;
ha->current_outstanding_cmd = 0;
/* Initialize response queue entries */
qla2x00_init_response_q_entries(ha);
- WRT_REG_WORD(ISP_REQ_Q_IN(ha, reg), 0);
- WRT_REG_WORD(ISP_REQ_Q_OUT(ha, reg), 0);
- WRT_REG_WORD(ISP_RSP_Q_IN(ha, reg), 0);
- WRT_REG_WORD(ISP_RSP_Q_OUT(ha, reg), 0);
- RD_REG_WORD(ISP_RSP_Q_OUT(ha, reg));
+ ha->isp_ops.config_rings(ha);
spin_unlock_irqrestore(&ha->hardware_lock, flags);
+ /* Update any ISP specific firmware options before initialization. */
+ ha->isp_ops.update_fw_options(ha);
+
DEBUG(printk("scsi(%ld): Issue init firmware.\n", ha->host_no));
- rval = qla2x00_init_firmware(ha, sizeof(init_cb_t));
+ rval = qla2x00_init_firmware(ha, ha->init_cb_size);
if (rval) {
DEBUG2_3(printk("scsi(%ld): Init firmware **** FAILED ****.\n",
ha->host_no));
} else {
- /* Update any ISP specific firmware options. */
- qla2x00_update_fw_options(ha);
-
DEBUG3(printk("scsi(%ld): Init firmware -- success.\n",
ha->host_no));
}
rval = QLA_SUCCESS;
/* 20 seconds for loop down. */
- min_wait = 20;
+ min_wait = 20;
/*
* Firmware should take at most one RATOV to login, plus 5 seconds for
rval = QLA_FUNCTION_FAILED;
if (atomic_read(&ha->loop_down_timer) &&
- (fw_state >= FSTATE_LOSS_OF_SYNC ||
- fw_state == FSTATE_WAIT_AL_PA)) {
+ fw_state != FSTATE_READY) {
/* Loop down. Timeout on min_wait for states
- * other than Wait for Login.
- */
+ * other than Wait for Login.
+ */
if (time_after_eq(jiffies, mtime)) {
qla_printk(KERN_INFO, ha,
"Cable is unplugged...\n");
break;
/* Delay for a while */
- set_current_state(TASK_UNINTERRUPTIBLE);
- schedule_timeout(HZ / 2);
+ msleep(500);
DEBUG3(printk("scsi(%ld): fw_state=%x curr time=%lx.\n",
ha->host_no, fw_state, jiffies));
rval = qla2x00_get_adapter_id(ha,
&loop_id, &al_pa, &area, &domain, &topo);
if (rval != QLA_SUCCESS) {
- qla_printk(KERN_WARNING, ha,
- "ERROR -- Unable to get host loop ID.\n");
+ if (LOOP_TRANSITION(ha) || atomic_read(&ha->loop_down_timer) ||
+ (rval == QLA_COMMAND_ERROR && loop_id == 0x7)) {
+ DEBUG2(printk("%s(%ld) Loop is in a transition state\n",
+ __func__, ha->host_no));
+ } else {
+ qla_printk(KERN_WARNING, ha,
+ "ERROR -- Unable to get host loop ID.\n");
+ set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
+ }
return (rval);
}
* Returns:
* 0 = success.
*/
-static int
+int
qla2x00_nvram_config(scsi_qla_host_t *ha)
{
- int rval;
- uint8_t chksum = 0;
- uint16_t cnt;
- uint8_t *dptr1, *dptr2;
- init_cb_t *icb = ha->init_cb;
- nvram_t *nv = (nvram_t *)ha->request_ring;
- uint16_t *wptr = (uint16_t *)ha->request_ring;
- device_reg_t *reg = ha->iobase;
- uint8_t timer_mode;
+ int rval;
+ uint8_t chksum = 0;
+ uint16_t cnt;
+ uint8_t *dptr1, *dptr2;
+ init_cb_t *icb = ha->init_cb;
+ nvram_t *nv = (nvram_t *)ha->request_ring;
+ uint8_t *ptr = (uint8_t *)ha->request_ring;
+ struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
rval = QLA_SUCCESS;
- if (ha->flags.init_done)
- return (rval);
-
/* Determine NVRAM starting address. */
+ ha->nvram_size = sizeof(nvram_t);
ha->nvram_base = 0;
if (!IS_QLA2100(ha) && !IS_QLA2200(ha) && !IS_QLA2300(ha))
if ((RD_REG_WORD(®->ctrl_status) >> 14) == 1)
ha->nvram_base = 0x80;
/* Get NVRAM data and calculate checksum. */
- qla2x00_lock_nvram_access(ha);
- for (cnt = 0; cnt < sizeof(nvram_t)/2; cnt++) {
- *wptr = cpu_to_le16(qla2x00_get_nvram_word(ha,
- (cnt+ha->nvram_base)));
- chksum += (uint8_t)*wptr;
- chksum += (uint8_t)(*wptr >> 8);
- wptr++;
- }
- qla2x00_unlock_nvram_access(ha);
+ ha->isp_ops.read_nvram(ha, ptr, ha->nvram_base, ha->nvram_size);
+ for (cnt = 0, chksum = 0; cnt < ha->nvram_size; cnt++)
+ chksum += *ptr++;
DEBUG5(printk("scsi(%ld): Contents of NVRAM\n", ha->host_no));
DEBUG5(qla2x00_dump_buffer((uint8_t *)ha->request_ring,
- sizeof(nvram_t)));
+ ha->nvram_size));
/* Bad NVRAM data, set defaults parameters. */
if (chksum || nv->id[0] != 'I' || nv->id[1] != 'S' ||
/*
* Set default initialization control block.
*/
- memset(nv, 0, sizeof(nvram_t));
+ memset(nv, 0, ha->nvram_size);
nv->parameter_block_version = ICB_VERSION;
if (IS_QLA23XX(ha)) {
#endif
/* Reset Initialization control block */
- memset(icb, 0, sizeof(init_cb_t));
+ memset(icb, 0, ha->init_cb_size);
/*
* Setup driver NVRAM options.
if (IS_QLA23XX(ha)) {
nv->firmware_options[0] |= BIT_2;
nv->firmware_options[0] &= ~BIT_3;
+ nv->add_firmware_options[1] |= BIT_5 | BIT_4;
if (IS_QLA2300(ha)) {
if (ha->fb_rev == FPM_2310) {
index = (ha->pdev->subsystem_device & 0xff);
if (index < QLA_MODEL_NAMES) {
strcpy(ha->model_number,
- qla2x00_model_name[index]);
+ qla2x00_model_name[index * 2]);
ha->model_desc =
- qla2x00_model_desc[index];
+ qla2x00_model_name[index * 2 + 1];
} else {
strcpy(ha->model_number, "QLA23xx");
}
while (cnt--)
*dptr1++ = *dptr2++;
+ /* Use alternate WWN? */
+ if (nv->host_p[1] & BIT_7) {
+ memcpy(icb->node_name, nv->alternate_node_name, WWN_SIZE);
+ memcpy(icb->port_name, nv->alternate_port_name, WWN_SIZE);
+ }
+
/* Prepare nodename */
if ((icb->firmware_options[1] & BIT_6) == 0) {
/*
/*
* Set host adapter parameters.
*/
- ha->nvram_version = nv->nvram_version;
-
+ if (nv->host_p[0] & BIT_7)
+ ql2xextended_error_logging = 1;
ha->flags.disable_risc_code_load = ((nv->host_p[0] & BIT_4) ? 1 : 0);
/* Always load RISC code on non ISP2[12]00 chips. */
if (!IS_QLA2100(ha) && !IS_QLA2200(ha))
ha->flags.enable_lip_reset = ((nv->host_p[1] & BIT_1) ? 1 : 0);
ha->flags.enable_lip_full_login = ((nv->host_p[1] & BIT_2) ? 1 : 0);
ha->flags.enable_target_reset = ((nv->host_p[1] & BIT_3) ? 1 : 0);
+ ha->flags.enable_led_scheme = (nv->special_options[1] & BIT_4) ? 1 : 0;
+ ha->flags.disable_serdes = 0;
ha->operating_mode =
(icb->add_firmware_options[0] & (BIT_6 | BIT_5 | BIT_4)) >> 4;
- ha->fw_seriallink_options[0] = nv->seriallink_options[0];
- ha->fw_seriallink_options[1] = nv->seriallink_options[1];
+ memcpy(ha->fw_seriallink_options, nv->seriallink_options,
+ sizeof(ha->fw_seriallink_options));
/* save HBA serial number */
ha->serial0 = icb->port_name[5];
ha->serial1 = icb->port_name[6];
ha->serial2 = icb->port_name[7];
- memcpy(ha->node_name, icb->node_name, WWN_SIZE);
+ ha->node_name = icb->node_name;
+ ha->port_name = icb->port_name;
icb->execution_throttle = __constant_cpu_to_le16(0xFFFF);
/* Set minimum RATOV to 200 tenths of a second. */
ha->r_a_tov = 200;
- ha->minimum_timeout =
- (ha->login_timeout * ha->retry_count) + nv->port_down_retry_count;
ha->loop_reset_delay = nv->reset_delay;
- /* Will get the value from NVRAM. */
- ha->loop_down_timeout = LOOP_DOWN_TIMEOUT;
-
/* Link Down Timeout = 0:
*
* When Port Down timer expires we will start returning
*
* The driver waits for the link to come up after link down
* before returning I/Os to OS with "DID_NO_CONNECT".
- */
+ */
if (nv->link_down_timeout == 0) {
ha->loop_down_abort_time =
- (LOOP_DOWN_TIME - ha->loop_down_timeout);
+ (LOOP_DOWN_TIME - LOOP_DOWN_TIMEOUT);
} else {
ha->link_down_timeout = nv->link_down_timeout;
ha->loop_down_abort_time =
(LOOP_DOWN_TIME - ha->link_down_timeout);
- }
-
- ha->max_luns = MAX_LUNS;
- ha->max_probe_luns = le16_to_cpu(nv->max_luns_per_target);
- if (ha->max_probe_luns == 0)
- ha->max_probe_luns = MIN_LUNS;
+ }
/*
* Need enough time to try and get the port back.
if (ql2xloginretrycount)
ha->login_retry_count = ql2xloginretrycount;
- ha->binding_type = Bind;
- if (ha->binding_type != BIND_BY_PORT_NAME &&
- ha->binding_type != BIND_BY_PORT_ID) {
- qla_printk(KERN_WARNING, ha,
- "Invalid binding type specified (%d), "
- "defaulting to BIND_BY_PORT_NAME!!!\n", ha->binding_type);
-
- ha->binding_type = BIND_BY_PORT_NAME;
- }
-
- /*
- * Setup ring parameters in initialization control block
- */
- icb->request_q_outpointer = __constant_cpu_to_le16(0);
- icb->response_q_inpointer = __constant_cpu_to_le16(0);
- icb->request_q_length = cpu_to_le16(ha->request_q_length);
- icb->response_q_length = cpu_to_le16(ha->response_q_length);
- icb->request_q_address[0] = cpu_to_le32(LSD(ha->request_dma));
- icb->request_q_address[1] = cpu_to_le32(MSD(ha->request_dma));
- icb->response_q_address[0] = cpu_to_le32(LSD(ha->response_dma));
- icb->response_q_address[1] = cpu_to_le32(MSD(ha->response_dma));
-
icb->lun_enables = __constant_cpu_to_le16(0);
icb->command_resource_count = 0;
icb->immediate_notify_resource_count = 0;
ha->flags.process_response_queue = 1;
} else {
- /* Enable ZIO -- Support mode 5 only. */
- timer_mode = icb->add_firmware_options[0] &
- (BIT_3 | BIT_2 | BIT_1 | BIT_0);
+ /* Enable ZIO. */
+ if (!ha->flags.init_done) {
+ ha->zio_mode = icb->add_firmware_options[0] &
+ (BIT_3 | BIT_2 | BIT_1 | BIT_0);
+ ha->zio_timer = icb->interrupt_delay_timer ?
+ icb->interrupt_delay_timer: 2;
+ }
icb->add_firmware_options[0] &=
~(BIT_3 | BIT_2 | BIT_1 | BIT_0);
- if (ql2xenablezio)
- timer_mode = BIT_2 | BIT_0;
- if (timer_mode == (BIT_2 | BIT_0)) {
- DEBUG2(printk("scsi(%ld): ZIO enabled; timer delay "
- "(%d).\n", ha->host_no, ql2xintrdelaytimer));
+ ha->flags.process_response_queue = 0;
+ if (ha->zio_mode != QLA_ZIO_DISABLED) {
+ ha->zio_mode = QLA_ZIO_MODE_6;
+
+ DEBUG2(printk("scsi(%ld): ZIO mode %d enabled; timer "
+ "delay (%d us).\n", ha->host_no, ha->zio_mode,
+ ha->zio_timer * 100));
qla_printk(KERN_INFO, ha,
- "ZIO enabled; timer delay (%d).\n",
- ql2xintrdelaytimer);
+ "ZIO mode %d enabled; timer delay (%d us).\n",
+ ha->zio_mode, ha->zio_timer * 100);
- icb->add_firmware_options[0] |= timer_mode;
- icb->interrupt_delay_timer = ql2xintrdelaytimer;
+ icb->add_firmware_options[0] |= (uint8_t)ha->zio_mode;
+ icb->interrupt_delay_timer = (uint8_t)ha->zio_timer;
ha->flags.process_response_queue = 1;
}
}
return (rval);
}
-/*
-* qla2x00_init_tgt_map
-* Initializes target map.
-*
-* Input:
-* ha = adapter block pointer.
-*
-* Output:
-* TGT_Q initialized
-*/
static void
-qla2x00_init_tgt_map(scsi_qla_host_t *ha)
+qla2x00_rport_del(void *data)
{
- uint32_t t;
+ fc_port_t *fcport = data;
+ struct fc_rport *rport;
+ unsigned long flags;
+
+ spin_lock_irqsave(&fcport->rport_lock, flags);
+ rport = fcport->drport;
+ fcport->drport = NULL;
+ spin_unlock_irqrestore(&fcport->rport_lock, flags);
+ if (rport)
+ fc_remote_port_delete(rport);
- for (t = 0; t < MAX_TARGETS; t++)
- TGT_Q(ha, t) = (os_tgt_t *)NULL;
}
/**
*
* Returns a pointer to the allocated fcport, or NULL, if none available.
*/
-fc_port_t *
-qla2x00_alloc_fcport(scsi_qla_host_t *ha, int flags)
+static fc_port_t *
+qla2x00_alloc_fcport(scsi_qla_host_t *ha, gfp_t flags)
{
fc_port_t *fcport;
fcport->ha = ha;
fcport->port_type = FCT_UNKNOWN;
fcport->loop_id = FC_NO_LOOP_ID;
- fcport->iodesc_idx_sent = IODESC_INVALID_INDEX;
atomic_set(&fcport->state, FCS_UNCONFIGURED);
fcport->flags = FCF_RLC_SUPPORT;
- INIT_LIST_HEAD(&fcport->fcluns);
+ fcport->supported_classes = FC_COS_UNSPECIFIED;
+ spin_lock_init(&fcport->rport_lock);
return (fcport);
}
* 2 = database was full and device was not configured.
*/
static int
-qla2x00_configure_loop(scsi_qla_host_t *ha)
+qla2x00_configure_loop(scsi_qla_host_t *ha)
{
int rval;
unsigned long flags, save_flags;
*/
clear_bit(LOCAL_LOOP_UPDATE, &ha->dpc_flags);
clear_bit(RSCN_UPDATE, &ha->dpc_flags);
- ha->mem_err = 0 ;
/* Determine what we need to do */
if (ha->current_topology == ISP_CFG_FL &&
set_bit(RSCN_UPDATE, &flags);
clear_bit(LOCAL_LOOP_UPDATE, &flags);
+ } else if (ha->current_topology == ISP_CFG_N) {
+ clear_bit(RSCN_UPDATE, &flags);
+
} else if (!ha->flags.online ||
(test_bit(ABORT_ISP_ACTIVE, &flags))) {
}
if (rval == QLA_SUCCESS && test_bit(RSCN_UPDATE, &flags)) {
- if (test_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags)) {
+ if (LOOP_TRANSITION(ha)) {
rval = QLA_FUNCTION_FAILED;
} else {
rval = qla2x00_configure_fabric(ha);
test_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags)) {
rval = QLA_FUNCTION_FAILED;
} else {
- qla2x00_config_os(ha);
atomic_set(&ha->loop_state, LOOP_READY);
DEBUG(printk("scsi(%ld): LOOP READY\n", ha->host_no));
* 0 = success.
*/
static int
-qla2x00_configure_local_loop(scsi_qla_host_t *ha)
+qla2x00_configure_local_loop(scsi_qla_host_t *ha)
{
int rval, rval2;
int found_devs;
uint16_t index;
uint16_t entries;
- struct dev_id {
- uint8_t al_pa;
- uint8_t area;
- uint8_t domain;
- uint8_t loop_id_2100; /* ISP2100/ISP2200 -- 4 bytes. */
- uint16_t loop_id; /* ISP23XX -- 6 bytes. */
- } *id_list;
-#define MAX_ID_LIST_SIZE (sizeof(struct dev_id) * MAX_FIBRE_DEVICES)
- dma_addr_t id_list_dma;
char *id_iter;
uint16_t loop_id;
uint8_t domain, area, al_pa;
found_devs = 0;
new_fcport = NULL;
-
entries = MAX_FIBRE_DEVICES;
- id_list = pci_alloc_consistent(ha->pdev, MAX_ID_LIST_SIZE,
- &id_list_dma);
- if (id_list == NULL) {
- DEBUG2(printk("scsi(%ld): Failed to allocate memory, No local "
- "loop\n", ha->host_no));
-
- qla_printk(KERN_WARNING, ha,
- "Memory Allocation failed - port_list");
-
- ha->mem_err++;
- return (QLA_MEMORY_ALLOC_FAILED);
- }
- memset(id_list, 0, MAX_ID_LIST_SIZE);
DEBUG3(printk("scsi(%ld): Getting FCAL position map\n", ha->host_no));
DEBUG3(qla2x00_get_fcal_position_map(ha, NULL));
/* Get list of logged in devices. */
- rval = qla2x00_get_id_list(ha, id_list, id_list_dma, &entries);
- if (rval != QLA_SUCCESS) {
+ memset(ha->gid_list, 0, GID_LIST_SIZE);
+ rval = qla2x00_get_id_list(ha, ha->gid_list, ha->gid_list_dma,
+ &entries);
+ if (rval != QLA_SUCCESS)
goto cleanup_allocation;
- }
DEBUG3(printk("scsi(%ld): Entries in ID list (%d)\n",
ha->host_no, entries));
- DEBUG3(qla2x00_dump_buffer((uint8_t *)id_list,
- entries * sizeof(struct dev_id)));
+ DEBUG3(qla2x00_dump_buffer((uint8_t *)ha->gid_list,
+ entries * sizeof(struct gid_list_info)));
/* Allocate temporary fcport for any new fcports discovered. */
new_fcport = qla2x00_alloc_fcport(ha, GFP_KERNEL);
}
/* Add devices to port list. */
- id_iter = (char *)id_list;
+ id_iter = (char *)ha->gid_list;
for (index = 0; index < entries; index++) {
- domain = ((struct dev_id *)id_iter)->domain;
- area = ((struct dev_id *)id_iter)->area;
- al_pa = ((struct dev_id *)id_iter)->al_pa;
- if (IS_QLA2100(ha) || IS_QLA2200(ha)) {
- loop_id =
- (uint16_t)((struct dev_id *)id_iter)->loop_id_2100;
- id_iter += 4;
- } else {
- loop_id =
- le16_to_cpu(((struct dev_id *)id_iter)->loop_id);
- id_iter += 6;
- }
+ domain = ((struct gid_list_info *)id_iter)->domain;
+ area = ((struct gid_list_info *)id_iter)->area;
+ al_pa = ((struct gid_list_info *)id_iter)->al_pa;
+ if (IS_QLA2100(ha) || IS_QLA2200(ha))
+ loop_id = (uint16_t)
+ ((struct gid_list_info *)id_iter)->loop_id_2100;
+ else
+ loop_id = le16_to_cpu(
+ ((struct gid_list_info *)id_iter)->loop_id);
+ id_iter += ha->gid_list_info_size;
/* Bypass reserved domain fields. */
if ((domain & 0xf0) == 0xf0)
continue;
/* Bypass if not same domain and area of adapter. */
- if (area != ha->d_id.b.area || domain != ha->d_id.b.domain)
+ if (area && domain &&
+ (area != ha->d_id.b.area || domain != ha->d_id.b.domain))
continue;
/* Bypass invalid local loop ID. */
"information -- get_port_database=%x, "
"loop_id=0x%04x\n",
ha->host_no, rval2, new_fcport->loop_id));
+ DEBUG2(printk("scsi(%ld): Scheduling resync...\n",
+ ha->host_no));
+ set_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags);
continue;
}
new_fcport->flags &= ~FCF_FABRIC_DEVICE;
}
+ /* Base iIDMA settings on HBA port speed. */
+ switch (ha->link_data_rate) {
+ case PORT_SPEED_1GB:
+ fcport->fp_speed = cpu_to_be16(BIT_15);
+ break;
+ case PORT_SPEED_2GB:
+ fcport->fp_speed = cpu_to_be16(BIT_14);
+ break;
+ case PORT_SPEED_4GB:
+ fcport->fp_speed = cpu_to_be16(BIT_13);
+ break;
+ }
+
qla2x00_update_fcport(ha, fcport);
found_devs++;
}
cleanup_allocation:
- pci_free_consistent(ha->pdev, MAX_ID_LIST_SIZE, id_list, id_list_dma);
-
- if (new_fcport)
- kfree(new_fcport);
+ kfree(new_fcport);
if (rval != QLA_SUCCESS) {
DEBUG2(printk("scsi(%ld): Configure local loop error exit: "
}
static void
-qla2x00_probe_for_all_luns(scsi_qla_host_t *ha)
+qla2x00_probe_for_all_luns(scsi_qla_host_t *ha)
{
fc_port_t *fcport;
- qla2x00_mark_all_devices_lost(ha);
+ qla2x00_mark_all_devices_lost(ha, 0);
list_for_each_entry(fcport, &ha->fcports, list) {
if (fcport->port_type != FCT_TARGET)
continue;
- qla2x00_update_fcport(ha, fcport);
+ qla2x00_update_fcport(ha, fcport);
+ }
+}
+
+static void
+qla2x00_iidma_fcport(scsi_qla_host_t *ha, fc_port_t *fcport)
+{
+#define LS_UNKNOWN 2
+ static char *link_speeds[5] = { "1", "2", "?", "4" };
+ int rval;
+ uint16_t port_speed, mb[6];
+
+ if (!IS_QLA24XX(ha))
+ return;
+
+ switch (be16_to_cpu(fcport->fp_speed)) {
+ case BIT_15:
+ port_speed = PORT_SPEED_1GB;
+ break;
+ case BIT_14:
+ port_speed = PORT_SPEED_2GB;
+ break;
+ case BIT_13:
+ port_speed = PORT_SPEED_4GB;
+ break;
+ default:
+ DEBUG2(printk("scsi(%ld): %02x%02x%02x%02x%02x%02x%02x%02x -- "
+ "unsupported FM port operating speed (%04x).\n",
+ ha->host_no, fcport->port_name[0], fcport->port_name[1],
+ fcport->port_name[2], fcport->port_name[3],
+ fcport->port_name[4], fcport->port_name[5],
+ fcport->port_name[6], fcport->port_name[7],
+ be16_to_cpu(fcport->fp_speed)));
+ port_speed = PORT_SPEED_UNKNOWN;
+ break;
+ }
+ if (port_speed == PORT_SPEED_UNKNOWN)
+ return;
+
+ rval = qla2x00_set_idma_speed(ha, fcport->loop_id, port_speed, mb);
+ if (rval != QLA_SUCCESS) {
+ DEBUG2(printk("scsi(%ld): Unable to adjust iIDMA "
+ "%02x%02x%02x%02x%02x%02x%02x%02x -- %04x %x %04x %04x.\n",
+ ha->host_no, fcport->port_name[0], fcport->port_name[1],
+ fcport->port_name[2], fcport->port_name[3],
+ fcport->port_name[4], fcport->port_name[5],
+ fcport->port_name[6], fcport->port_name[7], rval,
+ port_speed, mb[0], mb[1]));
+ } else {
+ DEBUG2(qla_printk(KERN_INFO, ha,
+ "iIDMA adjusted to %s GB/s on "
+ "%02x%02x%02x%02x%02x%02x%02x%02x.\n",
+ link_speeds[port_speed], fcport->port_name[0],
+ fcport->port_name[1], fcport->port_name[2],
+ fcport->port_name[3], fcport->port_name[4],
+ fcport->port_name[5], fcport->port_name[6],
+ fcport->port_name[7]));
+ }
+}
+
+static void
+qla2x00_reg_remote_port(scsi_qla_host_t *ha, fc_port_t *fcport)
+{
+ struct fc_rport_identifiers rport_ids;
+ struct fc_rport *rport;
+ unsigned long flags;
+
+ if (fcport->drport)
+ qla2x00_rport_del(fcport);
+ if (fcport->rport)
+ return;
+
+ rport_ids.node_name = wwn_to_u64(fcport->node_name);
+ rport_ids.port_name = wwn_to_u64(fcport->port_name);
+ rport_ids.port_id = fcport->d_id.b.domain << 16 |
+ fcport->d_id.b.area << 8 | fcport->d_id.b.al_pa;
+ rport_ids.roles = FC_RPORT_ROLE_UNKNOWN;
+ rport = fc_remote_port_add(ha->host, 0, &rport_ids);
+ if (!rport) {
+ qla_printk(KERN_WARNING, ha,
+ "Unable to allocate fc remote port!\n");
+ return;
}
+ spin_lock_irqsave(&fcport->rport_lock, flags);
+ fcport->rport = rport;
+ *((fc_port_t **)rport->dd_data) = fcport;
+ spin_unlock_irqrestore(&fcport->rport_lock, flags);
+
+ rport->supported_classes = fcport->supported_classes;
+
+ rport_ids.roles = FC_RPORT_ROLE_UNKNOWN;
+ if (fcport->port_type == FCT_INITIATOR)
+ rport_ids.roles |= FC_RPORT_ROLE_FCP_INITIATOR;
+ if (fcport->port_type == FCT_TARGET)
+ rport_ids.roles |= FC_RPORT_ROLE_FCP_TARGET;
+ fc_remote_port_rolechg(rport, rport_ids.roles);
+
+ if (rport->scsi_target_id != -1 &&
+ rport->scsi_target_id < ha->host->max_id)
+ fcport->os_target_id = rport->scsi_target_id;
}
/*
* Context:
* Kernel context.
*/
-static void
+void
qla2x00_update_fcport(scsi_qla_host_t *ha, fc_port_t *fcport)
{
- uint16_t index;
- unsigned long flags;
- srb_t *sp;
-
fcport->ha = ha;
fcport->login_retry = 0;
fcport->port_login_retry_count = ha->port_down_retry_count *
PORT_RETRY_TIME);
fcport->flags &= ~FCF_LOGIN_NEEDED;
- /*
- * Check for outstanding cmd on tape Bypass LUN discovery if active
- * command on tape.
- */
- if (fcport->flags & FCF_TAPE_PRESENT) {
- spin_lock_irqsave(&ha->hardware_lock, flags);
- for (index = 1; index < MAX_OUTSTANDING_COMMANDS; index++) {
- if ((sp = ha->outstanding_cmds[index]) != 0) {
- if (sp->fclun->fcport == fcport) {
- atomic_set(&fcport->state, FCS_ONLINE);
- spin_unlock_irqrestore(
- &ha->hardware_lock, flags);
- return;
- }
- }
- }
- spin_unlock_irqrestore(&ha->hardware_lock, flags);
- }
+ qla2x00_iidma_fcport(ha, fcport);
- /* Do LUN discovery. */
- if (fcport->port_type == FCT_INITIATOR ||
- fcport->port_type == FCT_BROADCAST) {
- fcport->device_type = TYPE_PROCESSOR;
- } else {
- qla2x00_lun_discovery(ha, fcport);
- }
atomic_set(&fcport->state, FCS_ONLINE);
+
+ qla2x00_reg_remote_port(ha, fcport);
}
/*
- * qla2x00_lun_discovery
- * Issue SCSI inquiry command for LUN discovery.
+ * qla2x00_configure_fabric
+ * Setup SNS devices with loop ID's.
*
* Input:
- * ha: adapter state pointer.
- * fcport: FC port structure pointer.
+ * ha = adapter block pointer.
*
- * Context:
- * Kernel context.
+ * Returns:
+ * 0 = success.
+ * BIT_0 = error
*/
-static void
-qla2x00_lun_discovery(scsi_qla_host_t *ha, fc_port_t *fcport)
+static int
+qla2x00_configure_fabric(scsi_qla_host_t *ha)
{
- inq_cmd_rsp_t *inq;
- dma_addr_t inq_dma;
- uint16_t lun;
+ int rval, rval2;
+ fc_port_t *fcport, *fcptemp;
+ uint16_t next_loopid;
+ uint16_t mb[MAILBOX_REGISTER_COUNT];
+ uint16_t loop_id;
+ LIST_HEAD(new_fcports);
- inq = pci_alloc_consistent(ha->pdev, sizeof(inq_cmd_rsp_t), &inq_dma);
- if (inq == NULL) {
- qla_printk(KERN_WARNING, ha,
- "Memory Allocation failed - INQ\n");
- return;
- }
+ /* If FL port exists, then SNS is present */
+ if (IS_QLA24XX(ha) || IS_QLA54XX(ha))
+ loop_id = NPH_F_PORT;
+ else
+ loop_id = SNS_FL_PORT;
+ rval = qla2x00_get_port_name(ha, loop_id, ha->fabric_node_name, 1);
+ if (rval != QLA_SUCCESS) {
+ DEBUG2(printk("scsi(%ld): MBC_GET_PORT_NAME Failed, No FL "
+ "Port\n", ha->host_no));
- /* If report LUN works, exit. */
- if (qla2x00_rpt_lun_discovery(ha, fcport, inq, inq_dma) !=
- QLA_SUCCESS) {
- for (lun = 0; lun < ha->max_probe_luns; lun++) {
- /* Configure LUN. */
- qla2x00_cfg_lun(ha, fcport, lun, inq, inq_dma);
- }
- }
-
- pci_free_consistent(ha->pdev, sizeof(inq_cmd_rsp_t), inq, inq_dma);
-}
-
-/*
- * qla2x00_rpt_lun_discovery
- * Issue SCSI report LUN command for LUN discovery.
- *
- * Input:
- * ha: adapter state pointer.
- * fcport: FC port structure pointer.
- *
- * Returns:
- * qla2x00 local function return status code.
- *
- * Context:
- * Kernel context.
- */
-static int
-qla2x00_rpt_lun_discovery(scsi_qla_host_t *ha, fc_port_t *fcport,
- inq_cmd_rsp_t *inq, dma_addr_t inq_dma)
-{
- int rval;
- uint32_t len, cnt;
- uint16_t lun;
- rpt_lun_cmd_rsp_t *rlc;
- dma_addr_t rlc_dma;
-
- /* Assume a failed status */
- rval = QLA_FUNCTION_FAILED;
-
- /* No point in continuing if the device doesn't support RLC */
- if ((fcport->flags & FCF_RLC_SUPPORT) == 0)
- return (rval);
-
- rlc = pci_alloc_consistent(ha->pdev, sizeof(rpt_lun_cmd_rsp_t),
- &rlc_dma);
- if (rlc == NULL) {
- qla_printk(KERN_WARNING, ha,
- "Memory Allocation failed - RLC");
- return QLA_MEMORY_ALLOC_FAILED;
- }
-
- rval = qla2x00_report_lun(ha, fcport, rlc, rlc_dma);
- if (rval != QLA_SUCCESS) {
- pci_free_consistent(ha->pdev, sizeof(rpt_lun_cmd_rsp_t), rlc,
- rlc_dma);
- return (rval);
- }
-
- /* Always add a fc_lun_t structure for lun 0 -- mid-layer requirement */
- qla2x00_add_lun(fcport, 0);
-
- /* Configure LUN list. */
- len = be32_to_cpu(rlc->list.hdr.len);
- len /= 8;
- for (cnt = 0; cnt < len; cnt++) {
- lun = CHAR_TO_SHORT(rlc->list.lst[cnt].lsb,
- rlc->list.lst[cnt].msb.b);
-
- DEBUG3(printk("scsi(%ld): RLC lun = (%d)\n", ha->host_no, lun));
-
- /* We only support 0 through MAX_LUNS-1 range */
- if (lun < MAX_LUNS) {
- qla2x00_cfg_lun(ha, fcport, lun, inq, inq_dma);
- }
- }
- atomic_set(&fcport->state, FCS_ONLINE);
-
- pci_free_consistent(ha->pdev, sizeof(rpt_lun_cmd_rsp_t), rlc, rlc_dma);
-
- return (rval);
-}
-
-/*
- * qla2x00_report_lun
- * Issue SCSI report LUN command.
- *
- * Input:
- * ha: adapter state pointer.
- * fcport: FC port structure pointer.
- * mem: pointer to dma memory object for report LUN IOCB
- * packet.
- *
- * Returns:
- * qla2x00 local function return status code.
- *
- * Context:
- * Kernel context.
- */
-static int
-qla2x00_report_lun(scsi_qla_host_t *ha,
- fc_port_t *fcport, rpt_lun_cmd_rsp_t *rlc, dma_addr_t rlc_dma)
-{
- int rval;
- uint16_t retries;
- uint16_t comp_status;
- uint16_t scsi_status;
-
- rval = QLA_FUNCTION_FAILED;
-
- for (retries = 3; retries; retries--) {
- memset(rlc, 0, sizeof(rpt_lun_cmd_rsp_t));
- rlc->p.cmd.entry_type = COMMAND_A64_TYPE;
- rlc->p.cmd.entry_count = 1;
- SET_TARGET_ID(ha, rlc->p.cmd.target, fcport->loop_id);
- rlc->p.cmd.control_flags =
- __constant_cpu_to_le16(CF_READ | CF_SIMPLE_TAG);
- rlc->p.cmd.scsi_cdb[0] = REPORT_LUNS;
- rlc->p.cmd.scsi_cdb[8] = MSB(sizeof(rpt_lun_lst_t));
- rlc->p.cmd.scsi_cdb[9] = LSB(sizeof(rpt_lun_lst_t));
- rlc->p.cmd.dseg_count = __constant_cpu_to_le16(1);
- rlc->p.cmd.timeout = __constant_cpu_to_le16(10);
- rlc->p.cmd.byte_count =
- __constant_cpu_to_le32(sizeof(rpt_lun_lst_t));
- rlc->p.cmd.dseg_0_address[0] = cpu_to_le32(
- LSD(rlc_dma + sizeof(sts_entry_t)));
- rlc->p.cmd.dseg_0_address[1] = cpu_to_le32(
- MSD(rlc_dma + sizeof(sts_entry_t)));
- rlc->p.cmd.dseg_0_length =
- __constant_cpu_to_le32(sizeof(rpt_lun_lst_t));
-
- rval = qla2x00_issue_iocb(ha, rlc, rlc_dma,
- sizeof(rpt_lun_cmd_rsp_t));
-
- comp_status = le16_to_cpu(rlc->p.rsp.comp_status);
- scsi_status = le16_to_cpu(rlc->p.rsp.scsi_status);
-
- if (rval != QLA_SUCCESS || comp_status != CS_COMPLETE ||
- scsi_status & SS_CHECK_CONDITION) {
-
- /* Device underrun, treat as OK. */
- if (rval == QLA_SUCCESS &&
- comp_status == CS_DATA_UNDERRUN &&
- scsi_status & SS_RESIDUAL_UNDER) {
-
- rval = QLA_SUCCESS;
- break;
- }
-
- DEBUG(printk("scsi(%ld): RLC failed to issue iocb! "
- "fcport=[%04x/%p] rval=%x cs=%x ss=%x\n",
- ha->host_no, fcport->loop_id, fcport, rval,
- comp_status, scsi_status));
-
- rval = QLA_FUNCTION_FAILED;
- if (scsi_status & SS_CHECK_CONDITION) {
- DEBUG2(printk("scsi(%ld): RLC "
- "SS_CHECK_CONDITION Sense Data "
- "%02x %02x %02x %02x %02x %02x %02x %02x\n",
- ha->host_no,
- rlc->p.rsp.req_sense_data[0],
- rlc->p.rsp.req_sense_data[1],
- rlc->p.rsp.req_sense_data[2],
- rlc->p.rsp.req_sense_data[3],
- rlc->p.rsp.req_sense_data[4],
- rlc->p.rsp.req_sense_data[5],
- rlc->p.rsp.req_sense_data[6],
- rlc->p.rsp.req_sense_data[7]));
- if (rlc->p.rsp.req_sense_data[2] ==
- ILLEGAL_REQUEST) {
- fcport->flags &= ~(FCF_RLC_SUPPORT);
- break;
- }
- }
- } else {
- break;
- }
- }
-
- return (rval);
-}
-
-/*
- * qla2x00_cfg_lun
- * Configures LUN into fcport LUN list.
- *
- * Input:
- * fcport: FC port structure pointer.
- * lun: LUN number.
- *
- * Context:
- * Kernel context.
- */
-static fc_lun_t *
-qla2x00_cfg_lun(scsi_qla_host_t *ha, fc_port_t *fcport, uint16_t lun,
- inq_cmd_rsp_t *inq, dma_addr_t inq_dma)
-{
- fc_lun_t *fclun;
-
- /* Bypass LUNs that failed. */
- if (qla2x00_inquiry(ha, fcport, lun, inq, inq_dma) != QLA_SUCCESS) {
- DEBUG2(printk("scsi(%ld): Failed inquiry - loop id=0x%04x "
- "lun=%d\n", ha->host_no, fcport->loop_id, lun));
-
- return (NULL);
- }
-
- switch (inq->inq[0]) {
- case TYPE_DISK:
- case TYPE_PROCESSOR:
- case TYPE_WORM:
- case TYPE_ROM:
- case TYPE_SCANNER:
- case TYPE_MOD:
- case TYPE_MEDIUM_CHANGER:
- case TYPE_ENCLOSURE:
- case 0x20:
- case 0x0C:
- break;
- case TYPE_TAPE:
- fcport->flags |= FCF_TAPE_PRESENT;
- break;
- default:
- DEBUG2(printk("scsi(%ld): Unsupported lun type -- "
- "loop id=0x%04x lun=%d type=%x\n",
- ha->host_no, fcport->loop_id, lun, inq->inq[0]));
- return (NULL);
- }
-
- fcport->device_type = inq->inq[0];
- fclun = qla2x00_add_lun(fcport, lun);
-
- if (fclun != NULL) {
- atomic_set(&fcport->state, FCS_ONLINE);
- }
-
- return (fclun);
-}
-
-/*
- * qla2x00_add_lun
- * Adds LUN to database
- *
- * Input:
- * fcport: FC port structure pointer.
- * lun: LUN number.
- *
- * Context:
- * Kernel context.
- */
-static fc_lun_t *
-qla2x00_add_lun(fc_port_t *fcport, uint16_t lun)
-{
- int found;
- fc_lun_t *fclun;
-
- if (fcport == NULL) {
- DEBUG(printk("scsi: Unable to add lun to NULL port\n"));
- return (NULL);
- }
-
- /* Allocate LUN if not already allocated. */
- found = 0;
- list_for_each_entry(fclun, &fcport->fcluns, list) {
- if (fclun->lun == lun) {
- found++;
- break;
- }
- }
- if (found)
- return (NULL);
-
- fclun = kmalloc(sizeof(fc_lun_t), GFP_ATOMIC);
- if (fclun == NULL) {
- printk(KERN_WARNING
- "%s(): Memory Allocation failed - FCLUN\n",
- __func__);
- return (NULL);
- }
-
- /* Setup LUN structure. */
- memset(fclun, 0, sizeof(fc_lun_t));
- fclun->lun = lun;
- fclun->fcport = fcport;
- fclun->o_fcport = fcport;
- fclun->device_type = fcport->device_type;
- atomic_set(&fcport->state, FCS_UNCONFIGURED);
-
- list_add_tail(&fclun->list, &fcport->fcluns);
-
- return (fclun);
-}
-
-/*
- * qla2x00_inquiry
- * Issue SCSI inquiry command.
- *
- * Input:
- * ha = adapter block pointer.
- * fcport = FC port structure pointer.
- *
- * Return:
- * 0 - Success
- * BIT_0 - error
- *
- * Context:
- * Kernel context.
- */
-static int
-qla2x00_inquiry(scsi_qla_host_t *ha,
- fc_port_t *fcport, uint16_t lun, inq_cmd_rsp_t *inq, dma_addr_t inq_dma)
-{
- int rval;
- uint16_t retries;
- uint16_t comp_status;
- uint16_t scsi_status;
-
- rval = QLA_FUNCTION_FAILED;
-
- for (retries = 3; retries; retries--) {
- memset(inq, 0, sizeof(inq_cmd_rsp_t));
- inq->p.cmd.entry_type = COMMAND_A64_TYPE;
- inq->p.cmd.entry_count = 1;
- inq->p.cmd.lun = cpu_to_le16(lun);
- SET_TARGET_ID(ha, inq->p.cmd.target, fcport->loop_id);
- inq->p.cmd.control_flags =
- __constant_cpu_to_le16(CF_READ | CF_SIMPLE_TAG);
- inq->p.cmd.scsi_cdb[0] = INQUIRY;
- inq->p.cmd.scsi_cdb[4] = INQ_DATA_SIZE;
- inq->p.cmd.dseg_count = __constant_cpu_to_le16(1);
- inq->p.cmd.timeout = __constant_cpu_to_le16(10);
- inq->p.cmd.byte_count =
- __constant_cpu_to_le32(INQ_DATA_SIZE);
- inq->p.cmd.dseg_0_address[0] = cpu_to_le32(
- LSD(inq_dma + sizeof(sts_entry_t)));
- inq->p.cmd.dseg_0_address[1] = cpu_to_le32(
- MSD(inq_dma + sizeof(sts_entry_t)));
- inq->p.cmd.dseg_0_length =
- __constant_cpu_to_le32(INQ_DATA_SIZE);
-
- DEBUG5(printk("scsi(%ld): Lun Inquiry - fcport=[%04x/%p],"
- " lun (%d)\n",
- ha->host_no, fcport->loop_id, fcport, lun));
-
- rval = qla2x00_issue_iocb(ha, inq, inq_dma,
- sizeof(inq_cmd_rsp_t));
-
- comp_status = le16_to_cpu(inq->p.rsp.comp_status);
- scsi_status = le16_to_cpu(inq->p.rsp.scsi_status);
-
- DEBUG5(printk("scsi(%ld): lun (%d) inquiry - "
- "inq[0]= 0x%x, comp status 0x%x, scsi status 0x%x, "
- "rval=%d\n",
- ha->host_no, lun, inq->inq[0], comp_status, scsi_status,
- rval));
-
- if (rval != QLA_SUCCESS || comp_status != CS_COMPLETE ||
- scsi_status & SS_CHECK_CONDITION) {
-
- DEBUG(printk("scsi(%ld): INQ failed to issue iocb! "
- "fcport=[%04x/%p] rval=%x cs=%x ss=%x\n",
- ha->host_no, fcport->loop_id, fcport, rval,
- comp_status, scsi_status));
-
- if (rval == QLA_SUCCESS)
- rval = QLA_FUNCTION_FAILED;
-
- if (scsi_status & SS_CHECK_CONDITION) {
- DEBUG2(printk("scsi(%ld): INQ "
- "SS_CHECK_CONDITION Sense Data "
- "%02x %02x %02x %02x %02x %02x %02x %02x\n",
- ha->host_no,
- inq->p.rsp.req_sense_data[0],
- inq->p.rsp.req_sense_data[1],
- inq->p.rsp.req_sense_data[2],
- inq->p.rsp.req_sense_data[3],
- inq->p.rsp.req_sense_data[4],
- inq->p.rsp.req_sense_data[5],
- inq->p.rsp.req_sense_data[6],
- inq->p.rsp.req_sense_data[7]));
- }
-
- /* Device underrun drop LUN. */
- if (comp_status == CS_DATA_UNDERRUN &&
- scsi_status & SS_RESIDUAL_UNDER) {
- break;
- }
- } else {
- break;
- }
- }
-
- return (rval);
-}
-
-
-/*
- * qla2x00_configure_fabric
- * Setup SNS devices with loop ID's.
- *
- * Input:
- * ha = adapter block pointer.
- *
- * Returns:
- * 0 = success.
- * BIT_0 = error
- */
-static int
-qla2x00_configure_fabric(scsi_qla_host_t *ha)
-{
- int rval, rval2;
- fc_port_t *fcport, *fcptemp;
- uint16_t next_loopid;
- uint16_t mb[MAILBOX_REGISTER_COUNT];
- LIST_HEAD(new_fcports);
-
- /* If FL port exists, then SNS is present */
- rval = qla2x00_get_port_name(ha, SNS_FL_PORT, NULL, 0);
- if (rval != QLA_SUCCESS) {
- DEBUG2(printk("scsi(%ld): MBC_GET_PORT_NAME Failed, No FL "
- "Port\n", ha->host_no));
-
- ha->device_flags &= ~SWITCH_FOUND;
- return (QLA_SUCCESS);
+ ha->device_flags &= ~SWITCH_FOUND;
+ return (QLA_SUCCESS);
}
+ ha->device_flags |= SWITCH_FOUND;
/* Mark devices that need re-synchronization. */
rval2 = qla2x00_device_resync(ha);
return (QLA_SUCCESS);
}
do {
+ /* FDMI support. */
+ if (ql2xfdmienable &&
+ test_and_clear_bit(REGISTER_FDMI_NEEDED, &ha->dpc_flags))
+ qla2x00_fdmi_register(ha);
+
/* Ensure we are logged into the SNS. */
- qla2x00_login_fabric(ha, SIMPLE_NAME_SERVER, 0xff, 0xff, 0xfc,
- mb, BIT_1 | BIT_0);
+ if (IS_QLA24XX(ha) || IS_QLA54XX(ha))
+ loop_id = NPH_SNS;
+ else
+ loop_id = SIMPLE_NAME_SERVER;
+ ha->isp_ops.fabric_login(ha, loop_id, 0xff, 0xff,
+ 0xfc, mb, BIT_1 | BIT_0);
if (mb[0] != MBS_COMMAND_COMPLETE) {
DEBUG2(qla_printk(KERN_INFO, ha,
"Failed SNS login: loop_id=%x mb[0]=%x mb[1]=%x "
- "mb[2]=%x mb[6]=%x mb[7]=%x\n", SIMPLE_NAME_SERVER,
+ "mb[2]=%x mb[6]=%x mb[7]=%x\n", loop_id,
mb[0], mb[1], mb[2], mb[6], mb[7]));
return (QLA_SUCCESS);
}
if (atomic_read(&fcport->state) == FCS_DEVICE_LOST) {
qla2x00_mark_device_lost(ha, fcport,
- ql2xplogiabsentdevice);
+ ql2xplogiabsentdevice, 0);
if (fcport->loop_id != FC_NO_LOOP_ID &&
(fcport->flags & FCF_TAPE_PRESENT) == 0 &&
fcport->port_type != FCT_INITIATOR &&
fcport->port_type != FCT_BROADCAST) {
-
- 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);
fcport->loop_id = FC_NO_LOOP_ID;
}
}
break;
}
}
-
/* Login and update database */
qla2x00_fabric_dev_login(ha, fcport, &next_loopid);
}
break;
}
+ /* Remove device from the new list and add it to DB */
+ list_move_tail(&fcport->list, &ha->fcports);
+
/* Login and update database */
qla2x00_fabric_dev_login(ha, fcport, &next_loopid);
-
- /* Remove device from the new list and add it to DB */
- list_del(&fcport->list);
- list_add_tail(&fcport->list, &ha->fcports);
}
} while (0);
{
int rval;
uint16_t loop_id;
- fc_port_t *fcport, *new_fcport;
+ fc_port_t *fcport, *new_fcport, *fcptemp;
int found;
sw_info_t *swl;
} else if (qla2x00_gnn_id(ha, swl) != QLA_SUCCESS) {
kfree(swl);
swl = NULL;
+ } else if (qla2x00_gfpn_id(ha, swl) == QLA_SUCCESS) {
+ qla2x00_gpsc(ha, swl);
}
}
swl_idx = 0;
/* Allocate temporary fcport for any new fcports discovered. */
new_fcport = qla2x00_alloc_fcport(ha, GFP_KERNEL);
if (new_fcport == NULL) {
- if (swl)
- kfree(swl);
+ kfree(swl);
return (QLA_MEMORY_ALLOC_FAILED);
}
new_fcport->flags |= (FCF_FABRIC_DEVICE | FCF_LOGIN_NEEDED);
/* Starting free loop ID. */
loop_id = ha->min_external_loopid;
-
for (; loop_id <= ha->last_loop_id; loop_id++) {
- if (RESERVED_LOOP_ID(loop_id))
+ if (qla2x00_is_reserved_id(ha, loop_id))
continue;
- if (atomic_read(&ha->loop_down_timer) ||
- test_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags))
+ if (atomic_read(&ha->loop_down_timer) || LOOP_TRANSITION(ha))
break;
if (swl != NULL) {
swl[swl_idx].node_name, WWN_SIZE);
memcpy(new_fcport->port_name,
swl[swl_idx].port_name, WWN_SIZE);
+ memcpy(new_fcport->fabric_port_name,
+ swl[swl_idx].fabric_port_name, WWN_SIZE);
+ new_fcport->fp_speed = swl[swl_idx].fp_speed;
if (swl[swl_idx].d_id.b.rsvd_1 != 0) {
last_dev = 1;
/* Send GA_NXT to the switch */
rval = qla2x00_ga_nxt(ha, new_fcport);
if (rval != QLA_SUCCESS) {
+ qla_printk(KERN_WARNING, ha,
+ "SNS scan failed -- assuming zero-entry "
+ "result...\n");
+ list_for_each_entry_safe(fcport, fcptemp,
+ new_fcports, list) {
+ list_del(&fcport->list);
+ kfree(fcport);
+ }
+ rval = QLA_SUCCESS;
break;
}
}
if (new_fcport->d_id.b24 == ha->d_id.b24)
continue;
+ /* Bypass if same domain and area of adapter. */
+ if (((new_fcport->d_id.b24 & 0xffff00) ==
+ (ha->d_id.b24 & 0xffff00)) && ha->current_topology ==
+ ISP_CFG_FL)
+ continue;
+
/* Bypass reserved domain fields. */
if ((new_fcport->d_id.b.domain & 0xf0) == 0xf0)
continue;
found++;
+ /* Update port state. */
+ memcpy(fcport->fabric_port_name,
+ new_fcport->fabric_port_name, WWN_SIZE);
+ fcport->fp_speed = new_fcport->fp_speed;
+
/*
* If address the same and state FCS_ONLINE, nothing
* changed.
(fcport->flags & FCF_TAPE_PRESENT) == 0 &&
fcport->port_type != FCT_INITIATOR &&
fcport->port_type != FCT_BROADCAST) {
- 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);
fcport->loop_id = FC_NO_LOOP_ID;
}
nxt_d_id.b24 = new_fcport->d_id.b24;
new_fcport = qla2x00_alloc_fcport(ha, GFP_KERNEL);
if (new_fcport == NULL) {
- if (swl)
- kfree(swl);
+ kfree(swl);
return (QLA_MEMORY_ALLOC_FAILED);
}
new_fcport->flags |= (FCF_FABRIC_DEVICE | FCF_LOGIN_NEEDED);
new_fcport->d_id.b24 = nxt_d_id.b24;
}
- if (swl)
- kfree(swl);
-
- if (new_fcport)
- kfree(new_fcport);
+ kfree(swl);
+ kfree(new_fcport);
if (!list_empty(new_fcports))
ha->device_flags |= DFLG_FABRIC_DEVICES;
* Context:
* Kernel context.
*/
-int
+static int
qla2x00_find_new_loop_id(scsi_qla_host_t *ha, fc_port_t *dev)
{
int rval;
}
/* Skip reserved loop IDs. */
- while (RESERVED_LOOP_ID(dev->loop_id)) {
+ while (qla2x00_is_reserved_id(ha, dev->loop_id)) {
dev->loop_id++;
}
* Kernel context.
*/
static int
-qla2x00_device_resync(scsi_qla_host_t *ha)
+qla2x00_device_resync(scsi_qla_host_t *ha)
{
int rval;
- int rval2;
uint32_t mask;
fc_port_t *fcport;
uint32_t rscn_entry;
switch (format) {
case 0:
- if (!IS_QLA2100(ha) && !IS_QLA2200(ha) &&
- !IS_QLA6312(ha) && !IS_QLA6322(ha) &&
- ha->flags.init_done) {
- /* Handle port RSCN via asyncronous IOCBs */
- rval2 = qla2x00_handle_port_rscn(ha, rscn_entry,
- NULL, 0);
- if (rval2 == QLA_SUCCESS)
- continue;
- }
mask = 0xffffff;
break;
case 1:
rval = QLA_SUCCESS;
- /* Abort any outstanding IO descriptors. */
- if (!IS_QLA2100(ha) && !IS_QLA2200(ha))
- qla2x00_cancel_io_descriptors(ha);
-
list_for_each_entry(fcport, &ha->fcports, list) {
if ((fcport->flags & FCF_FABRIC_DEVICE) == 0 ||
(fcport->d_id.b24 & mask) != d_id.b24 ||
if (atomic_read(&fcport->state) == FCS_ONLINE) {
if (format != 3 ||
fcport->port_type != FCT_INITIATOR) {
- atomic_set(&fcport->state,
- FCS_DEVICE_LOST);
+ qla2x00_mark_device_lost(ha, fcport,
+ 0, 0);
}
}
fcport->flags &= ~FCF_FARP_DONE;
{
int rval;
int retry;
+ uint8_t opts;
rval = QLA_SUCCESS;
retry = 0;
rval = qla2x00_fabric_login(ha, fcport, next_loopid);
if (rval == QLA_SUCCESS) {
- rval = qla2x00_get_port_database(ha, fcport, 0);
+ /* Send an ADISC to tape devices.*/
+ opts = 0;
+ if (fcport->flags & FCF_TAPE_PRESENT)
+ opts |= BIT_1;
+ rval = qla2x00_get_port_database(ha, fcport, opts);
if (rval != QLA_SUCCESS) {
- 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);
+ qla2x00_mark_device_lost(ha, fcport, 1, 0);
} else {
qla2x00_update_fcport(ha, fcport);
}
fcport->d_id.b.area, fcport->d_id.b.al_pa));
/* Login fcport on switch. */
- qla2x00_login_fabric(ha, fcport->loop_id,
+ ha->isp_ops.fabric_login(ha, fcport->loop_id,
fcport->d_id.b.domain, fcport->d_id.b.area,
fcport->d_id.b.al_pa, mb, BIT_0);
if (mb[0] == MBS_PORT_ID_USED) {
/*
* Device has another loop ID. The firmware team
- * recommends us to perform an implicit login with the
- * specified ID again. The ID we just used is save here
- * so we return with an ID that can be tried by the
- * next login.
+ * recommends the driver perform an implicit login with
+ * the specified ID again. The ID we just used is save
+ * here so we return with an ID that can be tried by
+ * the next login.
*/
retry++;
tmp_loopid = fcport->loop_id;
}
}
+ if (mb[10] & BIT_0)
+ fcport->supported_classes |= FC_COS_CLASS2;
+ if (mb[10] & BIT_1)
+ fcport->supported_classes |= FC_COS_CLASS3;
+
rval = QLA_SUCCESS;
break;
} else if (mb[0] == MBS_LOOP_ID_USED) {
* dead.
*/
*next_loopid = fcport->loop_id;
- qla2x00_fabric_logout(ha, fcport->loop_id);
- fcport->loop_id = FC_NO_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);
+ qla2x00_mark_device_lost(ha, fcport, 1, 0);
- rval = 3;
+ rval = 1;
break;
} else {
/*
* unrecoverable / not handled error
*/
DEBUG2(printk("%s(%ld): failed=%x port_id=%02x%02x%02x "
- "loop_id=%x jiffies=%lx.\n",
- __func__, ha->host_no, mb[0],
+ "loop_id=%x jiffies=%lx.\n",
+ __func__, ha->host_no, mb[0],
fcport->d_id.b.domain, fcport->d_id.b.area,
fcport->d_id.b.al_pa, fcport->loop_id, jiffies));
*next_loopid = fcport->loop_id;
- 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);
fcport->loop_id = FC_NO_LOOP_ID;
- atomic_set(&fcport->state, FCS_DEVICE_DEAD);
+ fcport->login_retry = 0;
- rval = 1;
+ rval = 3;
break;
}
}
* 3 - Fatal error
*/
int
-qla2x00_local_device_login(scsi_qla_host_t *ha, uint16_t loop_id)
+qla2x00_local_device_login(scsi_qla_host_t *ha, fc_port_t *fcport)
{
int rval;
uint16_t mb[MAILBOX_REGISTER_COUNT];
memset(mb, 0, sizeof(mb));
- rval = qla2x00_login_local_device(ha, loop_id, mb, BIT_0);
+ rval = qla2x00_login_local_device(ha, fcport, mb, BIT_0);
if (rval == QLA_SUCCESS) {
/* Interrogate mailbox registers for any errors */
if (mb[0] == MBS_COMMAND_ERROR)
* 0 = success
*/
int
-qla2x00_loop_resync(scsi_qla_host_t *ha)
+qla2x00_loop_resync(scsi_qla_host_t *ha)
{
int rval;
uint32_t wait_time;
rval = QLA_SUCCESS;
atomic_set(&ha->loop_state, LOOP_UPDATE);
- qla2x00_stats.loop_resync++;
clear_bit(ISP_ABORT_RETRY, &ha->dpc_flags);
if (ha->flags.online) {
if (!(rval = qla2x00_fw_ready(ha))) {
/* Wait at most MAX_TARGET RSCNs for a stable link. */
wait_time = 256;
do {
- /* v2.19.05b6 */
atomic_set(&ha->loop_state, LOOP_UPDATE);
- /*
- * Issue marker command only when we are going
- * to start the I/O .
- */
- ha->marker_needed = 1;
+ /* Issue a marker after FW becomes ready. */
+ qla2x00_marker(ha, 0, 0, MK_SYNC_ALL);
+ ha->marker_needed = 0;
/* Remap devices on Loop. */
clear_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags);
wait_time &&
(test_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags)));
}
- qla2x00_restart_queues(ha, 1);
}
if (test_bit(ISP_ABORT_NEEDED, &ha->dpc_flags)) {
return (rval);
}
-/*
- * qla2x00_restart_queues
- * Restart device queues.
- *
- * Input:
- * ha = adapter block pointer.
- *
- * Context:
- * Kernel/Interrupt context.
- */
-void
-qla2x00_restart_queues(scsi_qla_host_t *ha, uint8_t flush)
-{
- srb_t *sp;
- int retry_q_cnt = 0;
- int pending_q_cnt = 0;
- struct list_head *list, *temp;
- unsigned long flags = 0;
-
- clear_bit(RESTART_QUEUES_NEEDED, &ha->dpc_flags);
-
- /* start pending queue */
- pending_q_cnt = ha->qthreads;
- if (flush) {
- 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_TAPE))
- continue;
-
- /*
- * When time expire return request back to OS as BUSY
- */
- __del_from_pending_queue(ha, sp);
- sp->cmd->result = DID_BUS_BUSY << 16;
- sp->cmd->host_scribble = (unsigned char *)NULL;
- __add_to_done_queue(ha, sp);
- }
- spin_unlock_irqrestore(&ha->list_lock, flags);
- } else {
- if (!list_empty(&ha->pending_queue))
- qla2x00_next(ha);
- }
-
- /*
- * Clear out our retry queue
- */
- if (flush) {
- spin_lock_irqsave(&ha->list_lock, flags);
- retry_q_cnt = ha->retry_q_cnt;
- list_for_each_safe(list, temp, &ha->retry_queue) {
- sp = list_entry(list, srb_t, list);
- /* when time expire return request back to OS as BUSY */
- __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);
- }
- spin_unlock_irqrestore(&ha->list_lock, flags);
-
- DEBUG2(printk("%s(%ld): callback %d commands.\n",
- __func__,
- ha->host_no,
- retry_q_cnt);)
- }
-
- DEBUG2(printk("%s(%ld): active=%ld, retry=%d, pending=%d, "
- "done=%ld, scsi retry=%d commands.\n",
- __func__,
- ha->host_no,
- ha->actthreads,
- ha->retry_q_cnt,
- pending_q_cnt,
- ha->done_q_cnt,
- ha->scsi_retry_q_cnt);)
-
- if (!list_empty(&ha->done_queue))
- qla2x00_done(ha);
-}
-
void
qla2x00_rescan_fcports(scsi_qla_host_t *ha)
{
rescan_done = 1;
}
- qla2x00_probe_for_all_luns(ha);
-
- /* Update OS target and lun structures if necessary. */
- if (rescan_done) {
- qla2x00_config_os(ha);
- }
+ qla2x00_probe_for_all_luns(ha);
}
-
-/*
- * qla2x00_config_os
- * Setup OS target and LUN structures.
- *
- * Input:
- * ha = adapter state pointer.
- *
- * Context:
- * Kernel context.
- */
-static void
-qla2x00_config_os(scsi_qla_host_t *ha)
-{
- fc_port_t *fcport;
- fc_lun_t *fclun;
- os_tgt_t *tq;
- uint16_t tgt;
-
-
- for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
- if ((tq = TGT_Q(ha, tgt)) == NULL)
- continue;
-
- clear_bit(TQF_ONLINE, &tq->flags);
- }
-
- list_for_each_entry(fcport, &ha->fcports, list) {
- if (atomic_read(&fcport->state) != FCS_ONLINE ||
- fcport->port_type == FCT_INITIATOR ||
- fcport->port_type == FCT_BROADCAST) {
- fcport->os_target_id = MAX_TARGETS;
- continue;
- }
-
- if (fcport->flags & FCF_FO_MASKED) {
- continue;
- }
-
- /* Bind FC port to OS target number. */
- if (qla2x00_fcport_bind(ha, fcport) == MAX_TARGETS) {
- continue;
- }
-
- /* Bind FC LUN to OS LUN number. */
- list_for_each_entry(fclun, &fcport->fcluns, list) {
- qla2x00_fclun_bind(ha, fcport, fclun);
- }
- }
-}
-
-/*
- * qla2x00_fcport_bind
- * Locates a target number for FC port.
- *
- * Input:
- * ha = adapter state pointer.
- * fcport = FC port structure pointer.
- *
- * Returns:
- * target number
- *
- * Context:
- * Kernel context.
- */
-static uint16_t
-qla2x00_fcport_bind(scsi_qla_host_t *ha, fc_port_t *fcport)
-{
- int found;
- uint16_t tgt;
- os_tgt_t *tq;
-
- /* Check for persistent binding. */
- for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
- if ((tq = TGT_Q(ha, tgt)) == NULL)
- continue;
-
- found = 0;
- switch (ha->binding_type) {
- case BIND_BY_PORT_ID:
- if (fcport->d_id.b24 == tq->d_id.b24) {
- memcpy(tq->node_name, fcport->node_name,
- WWN_SIZE);
- memcpy(tq->port_name, fcport->port_name,
- WWN_SIZE);
- found++;
- }
- break;
- case BIND_BY_PORT_NAME:
- if (memcmp(fcport->port_name, tq->port_name,
- WWN_SIZE) == 0) {
- /*
- * In case of persistent binding, update the
- * WWNN.
- */
- memcpy(tq->node_name, fcport->node_name,
- WWN_SIZE);
- found++;
- }
- break;
- }
- if (found)
- break;
- }
-
- /* TODO: honor the ConfigRequired flag */
- if (tgt == MAX_TARGETS) {
- /* Check if targetID 0 available. */
- tgt = 0;
-
- if (TGT_Q(ha, tgt) != NULL) {
- /* Locate first free target for device. */
- for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
- if (TGT_Q(ha, tgt) == NULL) {
- break;
- }
- }
- }
- if (tgt != MAX_TARGETS) {
- if ((tq = qla2x00_tgt_alloc(ha, tgt)) != NULL) {
- memcpy(tq->node_name, fcport->node_name,
- WWN_SIZE);
- memcpy(tq->port_name, fcport->port_name,
- WWN_SIZE);
- tq->d_id.b24 = fcport->d_id.b24;
- }
- }
- }
-
- /* Reset target numbers incase it changed. */
- fcport->os_target_id = tgt;
- if (tgt != MAX_TARGETS && tq != NULL) {
- DEBUG2(printk("scsi(%ld): Assigning target ID=%02d @ %p to "
- "loop id=0x%04x, port state=0x%x, port down retry=%d\n",
- ha->host_no, tgt, tq, fcport->loop_id,
- atomic_read(&fcport->state),
- atomic_read(&fcport->port_down_timer)));
-
- fcport->tgt_queue = tq;
- fcport->flags |= FCF_PERSISTENT_BOUND;
- tq->fcport = fcport;
- set_bit(TQF_ONLINE, &tq->flags);
- tq->port_down_retry_count = ha->port_down_retry_count;
-
-#if 0
- qla2x00_get_lun_mask_from_config(ha, fcport, tgt, 0);
-#endif
- }
-
- if (tgt == MAX_TARGETS) {
- qla_printk(KERN_WARNING, ha,
- "Unable to bind fcport, loop_id=%x\n", fcport->loop_id);
- }
-
- return (tgt);
-}
-
-/*
- * qla2x00_fclun_bind
- * Binds all FC device LUNS to OS LUNS.
- *
- * Input:
- * ha: adapter state pointer.
- * fcport: FC port structure pointer.
- *
- * Returns:
- * target number
- *
- * Context:
- * Kernel context.
- */
-static os_lun_t *
-qla2x00_fclun_bind(scsi_qla_host_t *ha, fc_port_t *fcport, fc_lun_t *fclun)
-{
- os_lun_t *lq;
- uint16_t tgt;
- uint16_t lun;
-
- tgt = fcport->os_target_id;
- lun = fclun->lun;
-
- /* Allocate LUNs */
- if (lun >= MAX_LUNS) {
- DEBUG2(printk("scsi(%ld): Unable to bind lun, invalid "
- "lun=(%x).\n", ha->host_no, lun));
- return (NULL);
- }
-
- /* Always alloc LUN 0 so kernel will scan past LUN 0. */
- if (lun != 0 && (EXT_IS_LUN_BIT_SET(&(fcport->lun_mask), lun))) {
- return (NULL);
- }
-
- if ((lq = qla2x00_lun_alloc(ha, tgt, lun)) == NULL) {
- qla_printk(KERN_WARNING, ha,
- "Unable to bind fclun, loop_id=%x lun=%x\n",
- fcport->loop_id, lun);
- return (NULL);
- }
-
- lq->fclun = fclun;
-
- return (lq);
-}
-
-/*
- * qla2x00_tgt_alloc
- * Allocate and pre-initialize target queue.
- *
- * Input:
- * ha = adapter block pointer.
- * t = SCSI target number.
- *
- * Returns:
- * NULL = failure
- *
- * Context:
- * Kernel context.
- */
-os_tgt_t *
-qla2x00_tgt_alloc(scsi_qla_host_t *ha, uint16_t tgt)
-{
- os_tgt_t *tq;
-
- /*
- * If SCSI addressing OK, allocate TGT queue and lock.
- */
- if (tgt >= MAX_TARGETS) {
- DEBUG2(printk("scsi(%ld): Unable to allocate target, invalid "
- "target number %d.\n", ha->host_no, tgt));
- return (NULL);
- }
-
- tq = TGT_Q(ha, tgt);
- if (tq == NULL) {
- tq = kmalloc(sizeof(os_tgt_t), GFP_ATOMIC);
- if (tq != NULL) {
- DEBUG2(printk("scsi(%ld): Alloc Target %d @ %p\n",
- ha->host_no, tgt, tq));
-
- memset(tq, 0, sizeof(os_tgt_t));
- tq->ha = ha;
-
- TGT_Q(ha, tgt) = tq;
- }
- }
- if (tq != NULL) {
- tq->port_down_retry_count = ha->port_down_retry_count;
- } else {
- qla_printk(KERN_WARNING, ha,
- "Unable to allocate target.\n");
- ha->mem_err++;
- }
-
- return (tq);
-}
-
-/*
- * qla2x00_tgt_free
- * Frees target and LUN queues.
- *
- * Input:
- * ha = adapter block pointer.
- * t = SCSI target number.
- *
- * Context:
- * Kernel context.
- */
-void
-qla2x00_tgt_free(scsi_qla_host_t *ha, uint16_t tgt)
-{
- os_tgt_t *tq;
- uint16_t lun;
-
- /*
- * If SCSI addressing OK, allocate TGT queue and lock.
- */
- if (tgt >= MAX_TARGETS) {
- DEBUG2(printk("scsi(%ld): Unable to de-allocate target, "
- "invalid target number %d.\n", ha->host_no, tgt));
-
- return;
- }
-
- tq = TGT_Q(ha, tgt);
- if (tq != NULL) {
- TGT_Q(ha, tgt) = NULL;
-
- /* Free LUN structures. */
- for (lun = 0; lun < MAX_LUNS; lun++)
- qla2x00_lun_free(ha, tgt, lun);
-
- kfree(tq);
- }
-
- return;
-}
-
-/*
- * qla2x00_lun_alloc
- * Allocate and initialize LUN queue.
- *
- * Input:
- * ha = adapter block pointer.
- * t = SCSI target number.
- * l = LUN number.
- *
- * Returns:
- * NULL = failure
- *
- * Context:
- * Kernel context.
- */
-os_lun_t *
-qla2x00_lun_alloc(scsi_qla_host_t *ha, uint16_t tgt, uint16_t lun)
-{
- os_lun_t *lq;
-
- /*
- * If SCSI addressing OK, allocate LUN queue.
- */
- if (tgt >= MAX_TARGETS || lun >= MAX_LUNS || TGT_Q(ha, tgt) == NULL) {
- DEBUG2(printk("scsi(%ld): Unable to allocate lun, invalid "
- "parameter.\n", ha->host_no));
-
- return (NULL);
- }
-
- lq = LUN_Q(ha, tgt, lun);
- if (lq == NULL) {
- lq = kmalloc(sizeof(os_lun_t), GFP_ATOMIC);
- if (lq != NULL) {
- DEBUG2(printk("scsi(%ld): Alloc Lun %d @ tgt %d.\n",
- ha->host_no, lun, tgt));
-
- memset(lq, 0, sizeof (os_lun_t));
- LUN_Q(ha, tgt, lun) = lq;
-
- /*
- * The following lun queue initialization code
- * must be duplicated in alloc_ioctl_mem function
- * for ioctl_lq.
- */
- lq->q_state = LUN_STATE_READY;
- spin_lock_init(&lq->q_lock);
- }
- }
-
- if (lq == NULL) {
- qla_printk(KERN_WARNING, ha, "Unable to allocate lun.\n");
- }
-
- return (lq);
-}
-
-/*
- * qla2x00_lun_free
- * Frees LUN queue.
- *
- * Input:
- * ha = adapter block pointer.
- * t = SCSI target number.
- *
- * Context:
- * Kernel context.
- */
-static void
-qla2x00_lun_free(scsi_qla_host_t *ha, uint16_t tgt, uint16_t lun)
-{
- os_lun_t *lq;
-
- /*
- * If SCSI addressing OK, allocate TGT queue and lock.
- */
- if (tgt >= MAX_TARGETS || lun >= MAX_LUNS) {
- DEBUG2(printk("scsi(%ld): Unable to deallocate lun, invalid "
- "parameter.\n", ha->host_no));
-
- return;
- }
-
- if (TGT_Q(ha, tgt) != NULL && (lq = LUN_Q(ha, tgt, lun)) != NULL) {
- LUN_Q(ha, tgt, lun) = NULL;
- kfree(lq);
- }
-
- return;
-}
-
-
-#if 0
-/*
- * qla2x00_get_lun_mask_from_config
- * Get lun mask from the configuration parameters.
- * Bit order is little endian.
- *
- * Input:
- * ha -- Host adapter
- * tgt -- target/device number
- * port -- pointer to port
- */
-static void
-qla2x00_get_lun_mask_from_config(scsi_qla_host_t *ha,
- fc_port_t *fcport, uint16_t tgt, uint16_t dev_no)
-{
- char propbuf[60]; /* size of search string */
- int rval, lun, bit;
- lun_bit_mask_t lun_mask, *mask_ptr = &lun_mask;
-
- /* Get "target-N-device-N-lun-mask" as a 256 bit lun_mask*/
- sprintf(propbuf, "scsi-qla%ld-tgt-%d-di-%d-lun-disabled",
- ha->instance, tgt, dev_no);
-
- rval = qla2x00_get_prop_xstr(ha, propbuf,
- (uint8_t *)&lun_mask, sizeof(lun_bit_mask_t));
- if (rval == sizeof(lun_bit_mask_t)) {
- memset(&fcport->lun_mask, 0, sizeof(lun_bit_mask_t));
- for (lun = 8 * sizeof(lun_bit_mask_t) - 1, bit = 0;
- lun >= 0; lun--, bit++) {
- if (EXT_IS_LUN_BIT_SET(mask_ptr, lun))
- EXT_SET_LUN_BIT((&fcport->lun_mask), bit);
- }
-
- DEBUG3(printk("scsi(%ld): returning lun mask for fcport "
- "%02x%02x%02x%02x%02x%02x%02x%02x:\n",
- ha->host_no,
- fcport->port_name[0], fcport->port_name[1],
- fcport->port_name[2], fcport->port_name[3],
- fcport->port_name[4], fcport->port_name[5],
- fcport->port_name[6], fcport->port_name[7]));
- DEBUG3(qla2x00_dump_buffer((uint8_t *)&fcport->lun_mask,
- sizeof(lun_bit_mask_t));)
- }
-}
-#endif
-
-/*
- * qla2x00_bstr_to_hex
- * Convert hex byte string to number.
- *
- * Input:
- * s = byte string pointer.
- * bp = byte pointer for number.
- * size = number of bytes.
- *
- * Context:
- * Kernel/Interrupt context.
- */
-static int
-qla2x00_bstr_to_hex(char *s, uint8_t *bp, int size)
-{
- int cnt;
- uint8_t n;
-
- for (cnt = 0; *s != '\0' && cnt / 2 < size; cnt++) {
- if (*s >= 'A' && *s <= 'F') {
- n = (*s++ - 'A') + 10;
- } else if (*s >= 'a' && *s <= 'f') {
- n = (*s++ - 'a') + 10;
- } else if (*s >= '0' && *s <= '9') {
- n = *s++ - '0';
- } else {
- cnt = 0;
- break;
- }
-
- if (cnt & BIT_0)
- *bp++ |= n;
- else
- *bp = n << 4;
- }
-
- /* fixme(dg) Need to swap data little endian */
-
- return (cnt / 2);
-}
-
-/*
- * qla2x00_get_prop_xstr
- * Get a string property value for the specified property name and
- * convert from the property string found in the configuration file,
- * which are ASCII characters representing nibbles, 2 characters represent
- * the hexdecimal value for a byte in the byte array.
- * The byte array is initialized to zero.
- * The resulting converted value is in big endian format (MSB at byte0).
- *
- * Input:
- * ha = adapter state pointer.
- * propname = property name pointer.
- * propval = pointer where to store converted property val.
- * size = max or expected size of 'propval' array.
- *
- * Returns:
- * 0 = empty value string or invalid character in string
- * >0 = count of characters converted
- * -1 = property not found
- *
- * Context:
- * Kernel context.
- */
-int
-qla2x00_get_prop_xstr(scsi_qla_host_t *ha,
- char *propname, uint8_t *propval, int size)
-{
- char *propstr;
- int rval = -1;
- static char buf[LINESIZE];
-
- /* Get the requested property string */
- rval = qla2x00_find_propname(ha, propname, buf, ha->cmdline, size*2);
- DEBUG3(printk("%s(): Ret rval from find propname = %d\n",
- __func__,
- rval);)
-
- propstr = &buf[0];
- if (*propstr == '=')
- propstr++; /* ignore equal sign */
-
- if (rval == 0) { /* not found */
- return (-1);
- }
-
- rval = qla2x00_bstr_to_hex(propstr, (uint8_t *)propval, size);
- if (rval == 0) {
- /* Invalid character in value string */
- qla_printk(KERN_INFO, ha,
- "%s(): %s Invalid hex string for property\n",
- __func__,
- propname);
- qla_printk(KERN_INFO, ha,
- " Invalid string - %s\n",
- propstr);
- }
-
- return (rval);
-}
-
-/*
- * qla2x00_find_propname
- * Get property in database.
- *
- * Input:
- * ha = adapter structure pointer.
- * db = pointer to database
- * propstr = pointer to dest array for string
- * propname = name of property to search for.
- * siz = size of property
- *
- * Returns:
- * 0 = no property
- * size = index of property
- *
- * Context:
- * Kernel context.
- */
-static int
-qla2x00_find_propname(scsi_qla_host_t *ha,
- char *propname, char *propstr,
- char *db, int siz)
-{
- char *cp;
-
- /* find the specified string */
- if (db) {
- /* find the property name */
- if ((cp = strstr(db,propname)) != NULL) {
- while ((*cp) && *cp != '=')
- cp++;
- if (*cp) {
- strncpy(propstr, cp, siz+1);
- propstr[siz+1] = '\0';
- DEBUG(printk("qla2x00_find_propname: found "
- "property = {%s}\n",
- propstr);)
- return (siz); /* match */
- }
- }
- }
-
- return (0);
-}
-
-#if 0
-/*
- * qla2x00_get_prop_16chars
- * Get an 8-byte property value for the specified property name by
- * converting from the property string found in the configuration file.
- * The resulting converted value is in big endian format (MSB at byte0).
- *
- * Input:
- * ha = adapter state pointer.
- * propname = property name pointer.
- * propval = pointer to location for the converted property val.
- * db = pointer to database
- *
- * Returns:
- * 0 = value returned successfully.
- *
- * Context:
- * Kernel context.
- */
-static int
-qla2x00_get_prop_16chars(scsi_qla_host_t *ha,
- char *propname, char *propval, char *db)
-{
- char *propstr;
- int i, k;
- int rval;
- uint8_t nval;
- uint8_t *pchar;
- uint8_t *ret_byte;
- uint8_t *tmp_byte;
- uint8_t *retval = (uint8_t*)propval;
- uint8_t tmpval[8] = {0, 0, 0, 0, 0, 0, 0, 0};
- uint16_t max_byte_cnt = 8; /* 16 chars = 8 bytes */
- uint16_t max_strlen = 16;
- static char buf[LINESIZE];
-
- rval = qla2x00_find_propname(ha, propname, buf, db, max_strlen);
-
- propstr = &buf[0];
- if (*propstr == '=')
- propstr++; /* ignore equal sign */
-
- if (rval == 0) {
- return (1);
- }
-
- /* Convert string to numbers. */
- pchar = (uint8_t *)propstr;
- tmp_byte = (uint8_t *)tmpval;
-
- rval = 0;
- for (i = 0; i < max_strlen; i++) {
- /*
- * Check for invalid character, two at a time,
- * then convert them starting with first byte.
- */
-
- if ((pchar[i] >= '0') && (pchar[i] <= '9')) {
- nval = pchar[i] - '0';
- } else if ((pchar[i] >= 'A') && (pchar[i] <= 'F')) {
- nval = pchar[i] - 'A' + 10;
- } else if ((pchar[i] >= 'a') && (pchar[i] <= 'f')) {
- nval = pchar[i] - 'a' + 10;
- } else {
- /* invalid character */
- rval = 1;
- break;
- }
-
- if (i & BIT_0) {
- *tmp_byte = *tmp_byte | nval;
- tmp_byte++;
- } else {
- *tmp_byte = *tmp_byte | nval << 4;
- }
- }
-
- if (rval != 0) {
- /* Encountered invalid character. */
- return (rval);
- }
-
- /* Copy over the converted value. */
- ret_byte = retval;
- tmp_byte = tmpval;
-
- i = max_byte_cnt;
- k = 0;
- while (i--) {
- *ret_byte++ = *tmp_byte++;
- }
-
- /* big endian retval[0]; */
- return (0);
-}
-
-/*
-* qla2x00_get_properties
-* Find all properties for the specified adapeter in
-* command line.
-*
-* Input:
-* ha = adapter block pointer.
-* cmdline = pointer to command line string
-*
-* Context:
-* Kernel context.
-*/
-static void
-qla2x00_get_properties(scsi_qla_host_t *ha, char *cmdline)
-{
- int rval;
- static char propbuf[LINESIZE];
- uint8_t fc_name[8];
-
- /* Adapter FC node names. */
- sprintf(propbuf, "scsi-qla%d-adapter-node", (int) ha->instance);
- rval = qla2x00_get_prop_16chars(ha, propbuf, fc_name, cmdline);
- if (rval == QLA_SUCCESS)
- memcpy(ha->init_cb->node_name, fc_name, WWN_SIZE);
-
- /* DG 04/07 check portname of adapter */
- sprintf(propbuf, "scsi-qla%d-adapter-port", (int)ha->instance);
- rval = qla2x00_get_prop_16chars(ha, propbuf, fc_name, cmdline);
- if (rval == QLA_SUCCESS &&
- memcmp(ha->init_cb->port_name, fc_name, WWN_SIZE)) {
- /*
- * Adapter port name is WWN, and cannot be changed.
- * Inform users of the mismatch, then just continue driver
- * loading using the original adapter port name in NVRAM.
- */
- qla_printk(KERN_WARNING, ha,
- "Found mismatch in adapter port names.\n");
- qla_printk(KERN_INFO, ha,
- " qla%ld port name found in NVRAM -> "
- "%02x%02x%02x%02x%02x%02x%02x%02x\n",
- 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]);
- qla_printk(KERN_INFO, ha,
- " qla%ld port name found on command line -> "
- "%02x%02x%02x%02x%02x%02x%02x%02x\n",
- ha->instance,
- fc_name[0], fc_name[1], fc_name[2], fc_name[3],
- fc_name[4], fc_name[5], fc_name[6], fc_name[7]);
- qla_printk(KERN_INFO, ha,
- " Using port name from NVRAM.\n");
- }
-
- qla2x00_cfg_persistent_binding(ha);
-}
-
-/*
- * qla2x00_cfg_persistent_binding
- * Get driver configuration file target persistent binding entries.
- *
- * Input:
- * ha = adapter block pointer.
- *
- * Context:
- * Kernel context.
- */
-static void
-qla2x00_cfg_persistent_binding(scsi_qla_host_t *ha)
-{
- int rval;
- static char propbuf[LINESIZE];
- char *cmdline = ha->cmdline;
- uint16_t tgt;
- port_id_t d_id;
- uint8_t portid[3];
- uint8_t port_name[8];
-
- for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
- if (ha->binding_type == BIND_BY_PORT_ID) {
- sprintf(propbuf, "scsi-qla%d-tgt-%d-di-0-pid",
- (int)ha->instance, tgt);
- rval = qla2x00_get_prop_xstr(ha,
- propbuf, portid, sizeof(portid));
- if (rval != sizeof(portid))
- continue;
-
- memset(&d_id, 0, sizeof(port_id_t));
- d_id.r.d_id[0] = portid[2];
- d_id.r.d_id[1] = portid[1];
- d_id.r.d_id[2] = portid[0];
- } else {
- sprintf(propbuf, "scsi-qla%d-tgt-%d-di-0-port",
- (int)ha->instance, tgt);
- rval = qla2x00_get_prop_16chars(ha,
- propbuf, port_name, cmdline);
- if (rval != QLA_SUCCESS)
- continue;
-
- /* Fallthru since port_name already populated */
- }
-
- /*
- * Create target context for device.
- */
- if (ha->binding_type == BIND_BY_PORT_ID) {
- qla2x00_persistent_bind(ha, NULL, NULL, &d_id, tgt);
- } else {
- qla2x00_persistent_bind(ha, NULL, port_name, NULL, tgt);
- }
- }
-}
-
-/*
- * qla2x00_persistent_bind
- * Allocates target and fcport.
- *
- * Input:
- * ha: adapter state pointer.
- * node_name: node name pointer.
- * port_name: port name pointer.
- * d_id: port ID pointer.
- * tgt: OS target number.
- *
- * Returns:
- * success = target queue pointer.
- * failure = NULL.
- *
- * Context:
- * Kernel context.
- */
-static os_tgt_t *
-qla2x00_persistent_bind(scsi_qla_host_t *ha, uint8_t *node_name,
- uint8_t *port_name, port_id_t *d_id, uint16_t tgt)
-{
- os_tgt_t *tq;
- uint16_t tgt2;
-
- /*
- * Check for duplicates.
- */
- for (tgt2 = 0; tgt2 < MAX_TARGETS; tgt2++) {
- if ((tq = TGT_Q(ha, tgt2)) == NULL) {
- continue;
- }
-
- if (ha->binding_type == BIND_BY_PORT_ID) {
- if (tq->d_id.b24 != d_id->b24) {
- continue;
- }
- } else if (memcmp(tq->port_name, port_name, WWN_SIZE) != 0) {
- continue;
- }
-
- qla_printk(KERN_WARNING, ha,
- "Duplicate persistent bindings found for "
- "WWPN: %02x%02x%02x%02x%02x%02x%02x%02x.\n",
- port_name[0], port_name[1], port_name[2], port_name[3],
- port_name[4], port_name[5], port_name[6], port_name[7]);
-
- return (tq);
- }
-
- tq = qla2x00_tgt_alloc(ha, tgt);
- if (tq == NULL) {
- return (NULL);
- }
-
- if (node_name != NULL) {
- memcpy(tq->node_name, node_name, WWN_SIZE);
- }
- if (port_name != NULL) {
- memcpy(tq->port_name, port_name, WWN_SIZE);
- }
- if (d_id != NULL) {
- tq->d_id.b24 = d_id->b24;
- }
-
- return (tq);
-}
-#endif
+void
+qla2x00_update_fcports(scsi_qla_host_t *ha)
+{
+ fc_port_t *fcport;
+
+ /* Go with deferred removal of rport references. */
+ list_for_each_entry(fcport, &ha->fcports, list)
+ if (fcport->drport)
+ qla2x00_rport_del(fcport);
+}
/*
* qla2x00_abort_isp
int
qla2x00_abort_isp(scsi_qla_host_t *ha)
{
+ int rval;
unsigned long flags = 0;
uint16_t cnt;
srb_t *sp;
if (ha->flags.online) {
ha->flags.online = 0;
clear_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
- qla2x00_stats.ispAbort++;
- ha->total_isp_aborts++; /* used by ioctl */
- ha->sns_retry_cnt = 0;
qla_printk(KERN_INFO, ha,
"Performing ISP error recovery - ha= %p.\n", ha);
- qla2x00_reset_chip(ha);
+ ha->isp_ops.reset_chip(ha);
atomic_set(&ha->loop_down_timer, LOOP_DOWN_TIME);
if (atomic_read(&ha->loop_state) != LOOP_DOWN) {
atomic_set(&ha->loop_state, LOOP_DOWN);
- qla2x00_mark_all_devices_lost(ha);
+ qla2x00_mark_all_devices_lost(ha, 0);
} else {
if (!atomic_read(&ha->loop_down_timer))
atomic_set(&ha->loop_down_timer,
for (cnt = 1; cnt < MAX_OUTSTANDING_COMMANDS; cnt++) {
sp = ha->outstanding_cmds[cnt];
if (sp) {
- ha->outstanding_cmds[cnt] = 0;
- if (ha->actthreads)
- ha->actthreads--;
- sp->lun_queue->out_cnt--;
-
- /*
- * Set the cmd host_byte status depending on
- * whether the scsi_error_handler is
- * active or not.
- */
- if (sp->flags & SRB_TAPE) {
- sp->cmd->result = DID_NO_CONNECT << 16;
- } else {
- if (ha->host->eh_active != EH_ACTIVE)
- sp->cmd->result =
- DID_BUS_BUSY << 16;
- else
- sp->cmd->result =
- DID_RESET << 16;
- }
+ ha->outstanding_cmds[cnt] = NULL;
sp->flags = 0;
+ sp->cmd->result = DID_RESET << 16;
sp->cmd->host_scribble = (unsigned char *)NULL;
- add_to_done_queue(ha, sp);
+ qla2x00_sp_compl(ha, sp);
}
}
spin_unlock_irqrestore(&ha->hardware_lock, flags);
- qla2x00_nvram_config(ha);
+ ha->isp_ops.nvram_config(ha);
if (!qla2x00_restart_isp(ha)) {
clear_bit(RESET_MARKER_NEEDED, &ha->dpc_flags);
ha->flags.online = 1;
- /* Enable ISP interrupts. */
- qla2x00_enable_intrs(ha);
+ ha->isp_ops.enable_intrs(ha);
- /* v2.19.5b6 Return all commands */
- qla2x00_abort_queues(ha, 1);
-
- /* Restart queues that may have been stopped. */
- qla2x00_restart_queues(ha, 1);
- ha->isp_abort_cnt = 0;
+ ha->isp_abort_cnt = 0;
clear_bit(ISP_ABORT_RETRY, &ha->dpc_flags);
+
+ if (ha->eft) {
+ rval = qla2x00_trace_control(ha, TC_ENABLE,
+ ha->eft_dma, EFT_NUM_BUFFERS);
+ if (rval) {
+ qla_printk(KERN_WARNING, ha,
+ "Unable to reinitialize EFT "
+ "(%d).\n", rval);
+ }
+ }
} else { /* failed the ISP abort */
ha->flags.online = 1;
if (test_bit(ISP_ABORT_RETRY, &ha->dpc_flags)) {
qla_printk(KERN_WARNING, ha,
"ISP error recovery failed - "
"board disabled\n");
- /*
+ /*
* The next call disables the board
* completely.
*/
- qla2x00_reset_adapter(ha);
- qla2x00_abort_queues(ha, 0);
+ ha->isp_ops.reset_adapter(ha);
ha->flags.online = 0;
clear_bit(ISP_ABORT_RETRY,
&ha->dpc_flags);
} else { /* schedule another ISP abort */
ha->isp_abort_cnt--;
DEBUG(printk("qla%ld: ISP abort - "
- "retry remainning %d\n",
- ha->host_no, ha->isp_abort_cnt);)
+ "retry remaining %d\n",
+ ha->host_no, ha->isp_abort_cnt));
status = 1;
}
} else {
ha->isp_abort_cnt = MAX_RETRIES_OF_ISP_ABORT;
DEBUG(printk("qla2x00(%ld): ISP error recovery "
"- retrying (%d) more times\n",
- ha->host_no, ha->isp_abort_cnt);)
+ ha->host_no, ha->isp_abort_cnt));
set_bit(ISP_ABORT_RETRY, &ha->dpc_flags);
status = 1;
}
}
-
+
}
if (status) {
} else {
DEBUG(printk(KERN_INFO
"qla2x00_abort_isp(%ld): exiting.\n",
- ha->host_no);)
+ ha->host_no));
}
return(status);
qla2x00_restart_isp(scsi_qla_host_t *ha)
{
uint8_t status = 0;
- device_reg_t *reg;
+ struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
unsigned long flags = 0;
uint32_t wait_time;
/* If firmware needs to be loaded */
if (qla2x00_isp_firmware(ha)) {
ha->flags.online = 0;
- if (!(status = qla2x00_chip_diag(ha))) {
+ if (!(status = ha->isp_ops.chip_diag(ha))) {
if (IS_QLA2100(ha) || IS_QLA2200(ha)) {
status = qla2x00_setup_chip(ha);
goto done;
}
- reg = ha->iobase;
spin_lock_irqsave(&ha->hardware_lock, flags);
- /* Disable SRAM, Instruction RAM and GP RAM parity. */
- WRT_REG_WORD(®->hccr, (HCCR_ENABLE_PARITY + 0x0));
+
+ if (!IS_QLA24XX(ha) && !IS_QLA54XX(ha)) {
+ /*
+ * Disable SRAM, Instruction RAM and GP RAM
+ * parity.
+ */
+ WRT_REG_WORD(®->hccr,
+ (HCCR_ENABLE_PARITY + 0x0));
+ RD_REG_WORD(®->hccr);
+ }
+
spin_unlock_irqrestore(&ha->hardware_lock, flags);
-
+
status = qla2x00_setup_chip(ha);
spin_lock_irqsave(&ha->hardware_lock, flags);
-
- /* Enable proper parity */
- 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));
+
+ if (!IS_QLA24XX(ha) && !IS_QLA54XX(ha)) {
+ /* Enable proper parity */
+ 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));
+ RD_REG_WORD(®->hccr);
+ }
spin_unlock_irqrestore(&ha->hardware_lock, flags);
}
clear_bit(RESET_MARKER_NEEDED, &ha->dpc_flags);
if (!(status = qla2x00_fw_ready(ha))) {
DEBUG(printk("%s(): Start configure loop, "
- "status = %d\n",
- __func__,
- status);)
+ "status = %d\n", __func__, status));
+
+ /* Issue a marker after FW becomes ready. */
+ qla2x00_marker(ha, 0, 0, MK_SYNC_ALL);
+
ha->flags.online = 1;
/* Wait at most MAX_TARGET RSCNs for a stable link. */
wait_time = 256;
}
/* if no cable then assume it's good */
- if ((ha->device_flags & DFLG_NO_CABLE))
+ if ((ha->device_flags & DFLG_NO_CABLE))
status = 0;
DEBUG(printk("%s(): Configure loop done, status = 0x%x\n",
__func__,
- status);)
+ status));
}
return (status);
}
* Input:
* ha = adapter block pointer.
*/
-static void
+void
qla2x00_reset_adapter(scsi_qla_host_t *ha)
{
unsigned long flags = 0;
- device_reg_t *reg = ha->iobase;
+ struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
ha->flags.online = 0;
- qla2x00_disable_intrs(ha);
- /* Reset RISC processor. */
+ ha->isp_ops.disable_intrs(ha);
+
spin_lock_irqsave(&ha->hardware_lock, flags);
WRT_REG_WORD(®->hccr, HCCR_RESET_RISC);
+ RD_REG_WORD(®->hccr); /* PCI Posting. */
WRT_REG_WORD(®->hccr, HCCR_RELEASE_RISC);
+ RD_REG_WORD(®->hccr); /* PCI Posting. */
+ spin_unlock_irqrestore(&ha->hardware_lock, flags);
+}
+
+void
+qla24xx_reset_adapter(scsi_qla_host_t *ha)
+{
+ unsigned long flags = 0;
+ struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
+
+ ha->flags.online = 0;
+ ha->isp_ops.disable_intrs(ha);
+
+ spin_lock_irqsave(&ha->hardware_lock, flags);
+ WRT_REG_DWORD(®->hccr, HCCRX_SET_RISC_RESET);
+ RD_REG_DWORD(®->hccr);
+ WRT_REG_DWORD(®->hccr, HCCRX_REL_RISC_PAUSE);
+ RD_REG_DWORD(®->hccr);
spin_unlock_irqrestore(&ha->hardware_lock, flags);
}
+
+int
+qla24xx_nvram_config(scsi_qla_host_t *ha)
+{
+ int rval;
+ struct init_cb_24xx *icb;
+ struct nvram_24xx *nv;
+ uint32_t *dptr;
+ uint8_t *dptr1, *dptr2;
+ uint32_t chksum;
+ uint16_t cnt;
+
+ rval = QLA_SUCCESS;
+ icb = (struct init_cb_24xx *)ha->init_cb;
+ nv = (struct nvram_24xx *)ha->request_ring;
+
+ /* Determine NVRAM starting address. */
+ ha->nvram_size = sizeof(struct nvram_24xx);
+ ha->nvram_base = FA_NVRAM_FUNC0_ADDR;
+ ha->vpd_size = FA_NVRAM_VPD_SIZE;
+ ha->vpd_base = FA_NVRAM_VPD0_ADDR;
+ if (PCI_FUNC(ha->pdev->devfn)) {
+ ha->nvram_base = FA_NVRAM_FUNC1_ADDR;
+ ha->vpd_base = FA_NVRAM_VPD1_ADDR;
+ }
+
+ /* Get NVRAM data and calculate checksum. */
+ dptr = (uint32_t *)nv;
+ ha->isp_ops.read_nvram(ha, (uint8_t *)dptr, ha->nvram_base,
+ ha->nvram_size);
+ for (cnt = 0, chksum = 0; cnt < ha->nvram_size >> 2; cnt++)
+ chksum += le32_to_cpu(*dptr++);
+
+ DEBUG5(printk("scsi(%ld): Contents of NVRAM\n", ha->host_no));
+ DEBUG5(qla2x00_dump_buffer((uint8_t *)ha->request_ring,
+ ha->nvram_size));
+
+ /* Bad NVRAM data, set defaults parameters. */
+ if (chksum || nv->id[0] != 'I' || nv->id[1] != 'S' || nv->id[2] != 'P'
+ || nv->id[3] != ' ' ||
+ nv->nvram_version < __constant_cpu_to_le16(ICB_VERSION)) {
+ /* Reset NVRAM data. */
+ qla_printk(KERN_WARNING, ha, "Inconsistent NVRAM detected: "
+ "checksum=0x%x id=%c version=0x%x.\n", chksum, nv->id[0],
+ le16_to_cpu(nv->nvram_version));
+ qla_printk(KERN_WARNING, ha, "Falling back to functioning (yet "
+ "invalid -- WWPN) defaults.\n");
+
+ /*
+ * Set default initialization control block.
+ */
+ memset(nv, 0, ha->nvram_size);
+ nv->nvram_version = __constant_cpu_to_le16(ICB_VERSION);
+ nv->version = __constant_cpu_to_le16(ICB_VERSION);
+ nv->frame_payload_size = __constant_cpu_to_le16(2048);
+ nv->execution_throttle = __constant_cpu_to_le16(0xFFFF);
+ nv->exchange_count = __constant_cpu_to_le16(0);
+ nv->hard_address = __constant_cpu_to_le16(124);
+ nv->port_name[0] = 0x21;
+ nv->port_name[1] = 0x00 + PCI_FUNC(ha->pdev->devfn);
+ nv->port_name[2] = 0x00;
+ nv->port_name[3] = 0xe0;
+ nv->port_name[4] = 0x8b;
+ nv->port_name[5] = 0x1c;
+ nv->port_name[6] = 0x55;
+ nv->port_name[7] = 0x86;
+ nv->node_name[0] = 0x20;
+ nv->node_name[1] = 0x00;
+ nv->node_name[2] = 0x00;
+ nv->node_name[3] = 0xe0;
+ nv->node_name[4] = 0x8b;
+ nv->node_name[5] = 0x1c;
+ nv->node_name[6] = 0x55;
+ nv->node_name[7] = 0x86;
+ nv->login_retry_count = __constant_cpu_to_le16(8);
+ nv->interrupt_delay_timer = __constant_cpu_to_le16(0);
+ nv->login_timeout = __constant_cpu_to_le16(0);
+ nv->firmware_options_1 =
+ __constant_cpu_to_le32(BIT_14|BIT_13|BIT_2|BIT_1);
+ nv->firmware_options_2 = __constant_cpu_to_le32(2 << 4);
+ nv->firmware_options_2 |= __constant_cpu_to_le32(BIT_12);
+ nv->firmware_options_3 = __constant_cpu_to_le32(2 << 13);
+ nv->host_p = __constant_cpu_to_le32(BIT_11|BIT_10);
+ nv->efi_parameters = __constant_cpu_to_le32(0);
+ nv->reset_delay = 5;
+ nv->max_luns_per_target = __constant_cpu_to_le16(128);
+ nv->port_down_retry_count = __constant_cpu_to_le16(30);
+ nv->link_down_timeout = __constant_cpu_to_le16(30);
+
+ rval = 1;
+ }
+
+ /* Reset Initialization control block */
+ memset(icb, 0, sizeof(struct init_cb_24xx));
+
+ /* Copy 1st segment. */
+ dptr1 = (uint8_t *)icb;
+ dptr2 = (uint8_t *)&nv->version;
+ cnt = (uint8_t *)&icb->response_q_inpointer - (uint8_t *)&icb->version;
+ while (cnt--)
+ *dptr1++ = *dptr2++;
+
+ icb->login_retry_count = nv->login_retry_count;
+ icb->link_down_on_nos = nv->link_down_on_nos;
+
+ /* Copy 2nd segment. */
+ dptr1 = (uint8_t *)&icb->interrupt_delay_timer;
+ dptr2 = (uint8_t *)&nv->interrupt_delay_timer;
+ cnt = (uint8_t *)&icb->reserved_3 -
+ (uint8_t *)&icb->interrupt_delay_timer;
+ while (cnt--)
+ *dptr1++ = *dptr2++;
+
+ /*
+ * Setup driver NVRAM options.
+ */
+ if (memcmp(nv->model_name, BINZERO, sizeof(nv->model_name)) != 0) {
+ char *st, *en;
+ uint16_t index;
+
+ strncpy(ha->model_number, nv->model_name,
+ sizeof(nv->model_name));
+ st = en = ha->model_number;
+ en += sizeof(nv->model_name) - 1;
+ while (en > st) {
+ if (*en != 0x20 && *en != 0x00)
+ break;
+ *en-- = '\0';
+ }
+
+ index = (ha->pdev->subsystem_device & 0xff);
+ if (index < QLA_MODEL_NAMES)
+ ha->model_desc = qla2x00_model_name[index * 2 + 1];
+ } else
+ strcpy(ha->model_number, "QLA2462");
+
+ /* Use alternate WWN? */
+ if (nv->host_p & __constant_cpu_to_le32(BIT_15)) {
+ memcpy(icb->node_name, nv->alternate_node_name, WWN_SIZE);
+ memcpy(icb->port_name, nv->alternate_port_name, WWN_SIZE);
+ }
+
+ /* Prepare nodename */
+ if ((icb->firmware_options_1 & __constant_cpu_to_le32(BIT_14)) == 0) {
+ /*
+ * Firmware will apply the following mask if the nodename was
+ * not provided.
+ */
+ memcpy(icb->node_name, icb->port_name, WWN_SIZE);
+ icb->node_name[0] &= 0xF0;
+ }
+
+ /* Set host adapter parameters. */
+ ha->flags.disable_risc_code_load = 0;
+ ha->flags.enable_lip_reset = 0;
+ ha->flags.enable_lip_full_login =
+ le32_to_cpu(nv->host_p) & BIT_10 ? 1: 0;
+ ha->flags.enable_target_reset =
+ le32_to_cpu(nv->host_p) & BIT_11 ? 1: 0;
+ ha->flags.enable_led_scheme = 0;
+ ha->flags.disable_serdes = le32_to_cpu(nv->host_p) & BIT_5 ? 1: 0;
+
+ ha->operating_mode = (le32_to_cpu(icb->firmware_options_2) &
+ (BIT_6 | BIT_5 | BIT_4)) >> 4;
+
+ memcpy(ha->fw_seriallink_options24, nv->seriallink_options,
+ sizeof(ha->fw_seriallink_options24));
+
+ /* save HBA serial number */
+ ha->serial0 = icb->port_name[5];
+ ha->serial1 = icb->port_name[6];
+ ha->serial2 = icb->port_name[7];
+ ha->node_name = icb->node_name;
+ ha->port_name = icb->port_name;
+
+ icb->execution_throttle = __constant_cpu_to_le16(0xFFFF);
+
+ ha->retry_count = le16_to_cpu(nv->login_retry_count);
+
+ /* Set minimum login_timeout to 4 seconds. */
+ if (le16_to_cpu(nv->login_timeout) < ql2xlogintimeout)
+ nv->login_timeout = cpu_to_le16(ql2xlogintimeout);
+ if (le16_to_cpu(nv->login_timeout) < 4)
+ nv->login_timeout = __constant_cpu_to_le16(4);
+ ha->login_timeout = le16_to_cpu(nv->login_timeout);
+ icb->login_timeout = cpu_to_le16(nv->login_timeout);
+
+ /* Set minimum RATOV to 200 tenths of a second. */
+ ha->r_a_tov = 200;
+
+ ha->loop_reset_delay = nv->reset_delay;
+
+ /* Link Down Timeout = 0:
+ *
+ * When Port Down timer expires we will start returning
+ * I/O's to OS with "DID_NO_CONNECT".
+ *
+ * Link Down Timeout != 0:
+ *
+ * The driver waits for the link to come up after link down
+ * before returning I/Os to OS with "DID_NO_CONNECT".
+ */
+ if (le16_to_cpu(nv->link_down_timeout) == 0) {
+ ha->loop_down_abort_time =
+ (LOOP_DOWN_TIME - LOOP_DOWN_TIMEOUT);
+ } else {
+ ha->link_down_timeout = le16_to_cpu(nv->link_down_timeout);
+ ha->loop_down_abort_time =
+ (LOOP_DOWN_TIME - ha->link_down_timeout);
+ }
+
+ /* Need enough time to try and get the port back. */
+ ha->port_down_retry_count = le16_to_cpu(nv->port_down_retry_count);
+ if (qlport_down_retry)
+ ha->port_down_retry_count = qlport_down_retry;
+
+ /* Set login_retry_count */
+ ha->login_retry_count = le16_to_cpu(nv->login_retry_count);
+ if (ha->port_down_retry_count ==
+ le16_to_cpu(nv->port_down_retry_count) &&
+ ha->port_down_retry_count > 3)
+ ha->login_retry_count = ha->port_down_retry_count;
+ else if (ha->port_down_retry_count > (int)ha->login_retry_count)
+ ha->login_retry_count = ha->port_down_retry_count;
+ if (ql2xloginretrycount)
+ ha->login_retry_count = ql2xloginretrycount;
+
+ /* Enable ZIO. */
+ if (!ha->flags.init_done) {
+ ha->zio_mode = le32_to_cpu(icb->firmware_options_2) &
+ (BIT_3 | BIT_2 | BIT_1 | BIT_0);
+ ha->zio_timer = le16_to_cpu(icb->interrupt_delay_timer) ?
+ le16_to_cpu(icb->interrupt_delay_timer): 2;
+ }
+ icb->firmware_options_2 &= __constant_cpu_to_le32(
+ ~(BIT_3 | BIT_2 | BIT_1 | BIT_0));
+ ha->flags.process_response_queue = 0;
+ if (ha->zio_mode != QLA_ZIO_DISABLED) {
+ ha->zio_mode = QLA_ZIO_MODE_6;
+
+ DEBUG2(printk("scsi(%ld): ZIO mode %d enabled; timer delay "
+ "(%d us).\n", ha->host_no, ha->zio_mode,
+ ha->zio_timer * 100));
+ qla_printk(KERN_INFO, ha,
+ "ZIO mode %d enabled; timer delay (%d us).\n",
+ ha->zio_mode, ha->zio_timer * 100);
+
+ icb->firmware_options_2 |= cpu_to_le32(
+ (uint32_t)ha->zio_mode);
+ icb->interrupt_delay_timer = cpu_to_le16(ha->zio_timer);
+ ha->flags.process_response_queue = 1;
+ }
+
+ if (rval) {
+ DEBUG2_3(printk(KERN_WARNING
+ "scsi(%ld): NVRAM configuration failed!\n", ha->host_no));
+ }
+ return (rval);
+}
+
+static int
+qla24xx_load_risc_flash(scsi_qla_host_t *ha, uint32_t *srisc_addr)
+{
+ int rval;
+ int segments, fragment;
+ uint32_t faddr;
+ uint32_t *dcode, dlen;
+ uint32_t risc_addr;
+ uint32_t risc_size;
+ uint32_t i;
+
+ rval = QLA_SUCCESS;
+
+ segments = FA_RISC_CODE_SEGMENTS;
+ faddr = FA_RISC_CODE_ADDR;
+ dcode = (uint32_t *)ha->request_ring;
+ *srisc_addr = 0;
+
+ /* Validate firmware image by checking version. */
+ qla24xx_read_flash_data(ha, dcode, faddr + 4, 4);
+ for (i = 0; i < 4; i++)
+ dcode[i] = be32_to_cpu(dcode[i]);
+ if ((dcode[0] == 0xffffffff && dcode[1] == 0xffffffff &&
+ dcode[2] == 0xffffffff && dcode[3] == 0xffffffff) ||
+ (dcode[0] == 0 && dcode[1] == 0 && dcode[2] == 0 &&
+ dcode[3] == 0)) {
+ qla_printk(KERN_WARNING, ha,
+ "Unable to verify integrity of flash firmware image!\n");
+ qla_printk(KERN_WARNING, ha,
+ "Firmware data: %08x %08x %08x %08x!\n", dcode[0],
+ dcode[1], dcode[2], dcode[3]);
+
+ return QLA_FUNCTION_FAILED;
+ }
+
+ while (segments && rval == QLA_SUCCESS) {
+ /* Read segment's load information. */
+ qla24xx_read_flash_data(ha, dcode, faddr, 4);
+
+ risc_addr = be32_to_cpu(dcode[2]);
+ *srisc_addr = *srisc_addr == 0 ? risc_addr : *srisc_addr;
+ risc_size = be32_to_cpu(dcode[3]);
+
+ fragment = 0;
+ while (risc_size > 0 && rval == QLA_SUCCESS) {
+ dlen = (uint32_t)(ha->fw_transfer_size >> 2);
+ if (dlen > risc_size)
+ dlen = risc_size;
+
+ DEBUG7(printk("scsi(%ld): Loading risc segment@ risc "
+ "addr %x, number of dwords 0x%x, offset 0x%x.\n",
+ ha->host_no, risc_addr, dlen, faddr));
+
+ qla24xx_read_flash_data(ha, dcode, faddr, dlen);
+ for (i = 0; i < dlen; i++)
+ dcode[i] = swab32(dcode[i]);
+
+ rval = qla2x00_load_ram(ha, ha->request_dma, risc_addr,
+ dlen);
+ if (rval) {
+ DEBUG(printk("scsi(%ld):[ERROR] Failed to load "
+ "segment %d of firmware\n", ha->host_no,
+ fragment));
+ qla_printk(KERN_WARNING, ha,
+ "[ERROR] Failed to load segment %d of "
+ "firmware\n", fragment);
+ break;
+ }
+
+ faddr += dlen;
+ risc_addr += dlen;
+ risc_size -= dlen;
+ fragment++;
+ }
+
+ /* Next segment. */
+ segments--;
+ }
+
+ return rval;
+}
+
+#define QLA_FW_URL "ftp://ftp.qlogic.com/outgoing/linux/firmware/"
+
+int
+qla2x00_load_risc(scsi_qla_host_t *ha, uint32_t *srisc_addr)
+{
+ int rval;
+ int i, fragment;
+ uint16_t *wcode, *fwcode;
+ uint32_t risc_addr, risc_size, fwclen, wlen, *seg;
+ struct fw_blob *blob;
+
+ /* Load firmware blob. */
+ blob = qla2x00_request_firmware(ha);
+ if (!blob) {
+ qla_printk(KERN_ERR, ha, "Firmware image unavailable.\n");
+ qla_printk(KERN_ERR, ha, "Firmware images can be retrieved "
+ "from: " QLA_FW_URL ".\n");
+ return QLA_FUNCTION_FAILED;
+ }
+
+ rval = QLA_SUCCESS;
+
+ wcode = (uint16_t *)ha->request_ring;
+ *srisc_addr = 0;
+ fwcode = (uint16_t *)blob->fw->data;
+ fwclen = 0;
+
+ /* Validate firmware image by checking version. */
+ if (blob->fw->size < 8 * sizeof(uint16_t)) {
+ qla_printk(KERN_WARNING, ha,
+ "Unable to verify integrity of firmware image (%Zd)!\n",
+ blob->fw->size);
+ goto fail_fw_integrity;
+ }
+ for (i = 0; i < 4; i++)
+ wcode[i] = be16_to_cpu(fwcode[i + 4]);
+ if ((wcode[0] == 0xffff && wcode[1] == 0xffff && wcode[2] == 0xffff &&
+ wcode[3] == 0xffff) || (wcode[0] == 0 && wcode[1] == 0 &&
+ wcode[2] == 0 && wcode[3] == 0)) {
+ qla_printk(KERN_WARNING, ha,
+ "Unable to verify integrity of firmware image!\n");
+ qla_printk(KERN_WARNING, ha,
+ "Firmware data: %04x %04x %04x %04x!\n", wcode[0],
+ wcode[1], wcode[2], wcode[3]);
+ goto fail_fw_integrity;
+ }
+
+ seg = blob->segs;
+ while (*seg && rval == QLA_SUCCESS) {
+ risc_addr = *seg;
+ *srisc_addr = *srisc_addr == 0 ? *seg : *srisc_addr;
+ risc_size = be16_to_cpu(fwcode[3]);
+
+ /* Validate firmware image size. */
+ fwclen += risc_size * sizeof(uint16_t);
+ if (blob->fw->size < fwclen) {
+ qla_printk(KERN_WARNING, ha,
+ "Unable to verify integrity of firmware image "
+ "(%Zd)!\n", blob->fw->size);
+ goto fail_fw_integrity;
+ }
+
+ fragment = 0;
+ while (risc_size > 0 && rval == QLA_SUCCESS) {
+ wlen = (uint16_t)(ha->fw_transfer_size >> 1);
+ if (wlen > risc_size)
+ wlen = risc_size;
+
+ DEBUG7(printk("scsi(%ld): Loading risc segment@ risc "
+ "addr %x, number of words 0x%x.\n", ha->host_no,
+ risc_addr, wlen));
+
+ for (i = 0; i < wlen; i++)
+ wcode[i] = swab16(fwcode[i]);
+
+ rval = qla2x00_load_ram(ha, ha->request_dma, risc_addr,
+ wlen);
+ if (rval) {
+ DEBUG(printk("scsi(%ld):[ERROR] Failed to load "
+ "segment %d of firmware\n", ha->host_no,
+ fragment));
+ qla_printk(KERN_WARNING, ha,
+ "[ERROR] Failed to load segment %d of "
+ "firmware\n", fragment);
+ break;
+ }
+
+ fwcode += wlen;
+ risc_addr += wlen;
+ risc_size -= wlen;
+ fragment++;
+ }
+
+ /* Next segment. */
+ seg++;
+ }
+ return rval;
+
+fail_fw_integrity:
+ return QLA_FUNCTION_FAILED;
+}
+
+int
+qla24xx_load_risc(scsi_qla_host_t *ha, uint32_t *srisc_addr)
+{
+ int rval;
+ int segments, fragment;
+ uint32_t *dcode, dlen;
+ uint32_t risc_addr;
+ uint32_t risc_size;
+ uint32_t i;
+ struct fw_blob *blob;
+ uint32_t *fwcode, fwclen;
+
+ /* Load firmware blob. */
+ blob = qla2x00_request_firmware(ha);
+ if (!blob) {
+ qla_printk(KERN_ERR, ha, "Firmware image unavailable.\n");
+ qla_printk(KERN_ERR, ha, "Firmware images can be retrieved "
+ "from: " QLA_FW_URL ".\n");
+
+ /* Try to load RISC code from flash. */
+ qla_printk(KERN_ERR, ha, "Attempting to load (potentially "
+ "outdated) firmware from flash.\n");
+ return qla24xx_load_risc_flash(ha, srisc_addr);
+ }
+
+ rval = QLA_SUCCESS;
+
+ segments = FA_RISC_CODE_SEGMENTS;
+ dcode = (uint32_t *)ha->request_ring;
+ *srisc_addr = 0;
+ fwcode = (uint32_t *)blob->fw->data;
+ fwclen = 0;
+
+ /* Validate firmware image by checking version. */
+ if (blob->fw->size < 8 * sizeof(uint32_t)) {
+ qla_printk(KERN_WARNING, ha,
+ "Unable to verify integrity of firmware image (%Zd)!\n",
+ blob->fw->size);
+ goto fail_fw_integrity;
+ }
+ for (i = 0; i < 4; i++)
+ dcode[i] = be32_to_cpu(fwcode[i + 4]);
+ if ((dcode[0] == 0xffffffff && dcode[1] == 0xffffffff &&
+ dcode[2] == 0xffffffff && dcode[3] == 0xffffffff) ||
+ (dcode[0] == 0 && dcode[1] == 0 && dcode[2] == 0 &&
+ dcode[3] == 0)) {
+ qla_printk(KERN_WARNING, ha,
+ "Unable to verify integrity of firmware image!\n");
+ qla_printk(KERN_WARNING, ha,
+ "Firmware data: %08x %08x %08x %08x!\n", dcode[0],
+ dcode[1], dcode[2], dcode[3]);
+ goto fail_fw_integrity;
+ }
+
+ while (segments && rval == QLA_SUCCESS) {
+ risc_addr = be32_to_cpu(fwcode[2]);
+ *srisc_addr = *srisc_addr == 0 ? risc_addr : *srisc_addr;
+ risc_size = be32_to_cpu(fwcode[3]);
+
+ /* Validate firmware image size. */
+ fwclen += risc_size * sizeof(uint32_t);
+ if (blob->fw->size < fwclen) {
+ qla_printk(KERN_WARNING, ha,
+ "Unable to verify integrity of firmware image "
+ "(%Zd)!\n", blob->fw->size);
+
+ goto fail_fw_integrity;
+ }
+
+ fragment = 0;
+ while (risc_size > 0 && rval == QLA_SUCCESS) {
+ dlen = (uint32_t)(ha->fw_transfer_size >> 2);
+ if (dlen > risc_size)
+ dlen = risc_size;
+
+ DEBUG7(printk("scsi(%ld): Loading risc segment@ risc "
+ "addr %x, number of dwords 0x%x.\n", ha->host_no,
+ risc_addr, dlen));
+
+ for (i = 0; i < dlen; i++)
+ dcode[i] = swab32(fwcode[i]);
+
+ rval = qla2x00_load_ram(ha, ha->request_dma, risc_addr,
+ dlen);
+ if (rval) {
+ DEBUG(printk("scsi(%ld):[ERROR] Failed to load "
+ "segment %d of firmware\n", ha->host_no,
+ fragment));
+ qla_printk(KERN_WARNING, ha,
+ "[ERROR] Failed to load segment %d of "
+ "firmware\n", fragment);
+ break;
+ }
+
+ fwcode += dlen;
+ risc_addr += dlen;
+ risc_size -= dlen;
+ fragment++;
+ }
+
+ /* Next segment. */
+ segments--;
+ }
+ return rval;
+
+fail_fw_integrity:
+ return QLA_FUNCTION_FAILED;
+}
+
+void
+qla2x00_try_to_stop_firmware(scsi_qla_host_t *ha)
+{
+ int ret, retries;
+
+ if (!IS_QLA24XX(ha) && !IS_QLA54XX(ha))
+ return;
+
+ ret = qla2x00_stop_firmware(ha);
+ for (retries = 5; ret != QLA_SUCCESS && retries ; retries--) {
+ qla2x00_reset_chip(ha);
+ if (qla2x00_chip_diag(ha) != QLA_SUCCESS)
+ continue;
+ if (qla2x00_setup_chip(ha) != QLA_SUCCESS)
+ continue;
+ qla_printk(KERN_INFO, ha,
+ "Attempting retry of stop-firmware command...\n");
+ ret = qla2x00_stop_firmware(ha);
+ }
+}