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