MODULE_PARM_DESC(ql2xlogintimeout,
"Login timeout value in seconds.");
-int qlport_down_retry;
+int qlport_down_retry = 30;
module_param(qlport_down_retry, int, S_IRUGO|S_IRUSR);
MODULE_PARM_DESC(qlport_down_retry,
"Maximum number of command retries to a port that returns"
"Maximum number of mid-layer retries allowed for a command. "
"Default value is 20, ");
-int displayConfig;
-module_param(displayConfig, int, S_IRUGO|S_IWUSR);
-MODULE_PARM_DESC(displayConfig,
- "If 1 then display the configuration used in /etc/modprobe.conf.");
-
int ql2xplogiabsentdevice;
module_param(ql2xplogiabsentdevice, int, S_IRUGO|S_IWUSR);
MODULE_PARM_DESC(ql2xplogiabsentdevice,
"target returns a <NOT READY> status. Default is 10 "
"iterations.");
-int ql2xdoinitscan = 1;
-module_param(ql2xdoinitscan, int, S_IRUGO|S_IWUSR);
-MODULE_PARM_DESC(ql2xdoinitscan,
- "Signal mid-layer to perform scan after driver load: 0 -- no "
- "signal sent to mid-layer.");
-
int ql2xloginretrycount = 0;
module_param(ql2xloginretrycount, int, S_IRUGO|S_IRUSR);
MODULE_PARM_DESC(ql2xloginretrycount,
"Specify an alternate value for the NVRAM login retry count.");
-/*
- * Proc structures and functions
- */
-struct info_str {
- char *buffer;
- int length;
- off_t offset;
- int pos;
-};
-
-static void copy_mem_info(struct info_str *, char *, int);
-static int copy_info(struct info_str *, char *, ...);
-
static void qla2x00_free_device(scsi_qla_host_t *);
static void qla2x00_config_dma_addressing(scsi_qla_host_t *ha);
* SCSI host template entry points
*/
static int qla2xxx_slave_configure(struct scsi_device * device);
+static int qla2xxx_slave_alloc(struct scsi_device *);
+static void qla2xxx_slave_destroy(struct scsi_device *);
static int qla2x00_queuecommand(struct scsi_cmnd *cmd,
void (*fn)(struct scsi_cmnd *));
static int qla2xxx_eh_abort(struct scsi_cmnd *);
static int qla2x00_loop_reset(scsi_qla_host_t *ha);
static int qla2x00_device_reset(scsi_qla_host_t *, fc_port_t *);
-static int qla2x00_proc_info(struct Scsi_Host *, char *, char **,
- off_t, int, int);
-
static struct scsi_host_template qla2x00_driver_template = {
.module = THIS_MODULE,
.name = "qla2xxx",
- .proc_name = "qla2xxx",
- .proc_info = qla2x00_proc_info,
.queuecommand = qla2x00_queuecommand,
.eh_abort_handler = qla2xxx_eh_abort,
.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,
static struct scsi_transport_template *qla2xxx_transport_template = NULL;
-static void qla2x00_display_fc_names(scsi_qla_host_t *);
-
/* TODO Convert to inlines
*
* Timer routines
ha->timer_active = 0;
}
-void qla2x00_cmd_timeout(srb_t *);
-
-static __inline__ void qla2x00_callback(scsi_qla_host_t *, struct scsi_cmnd *);
-static __inline__ void sp_put(struct scsi_qla_host * ha, srb_t *sp);
-static __inline__ void sp_get(struct scsi_qla_host * ha, srb_t *sp);
-static __inline__ void
-qla2x00_delete_from_done_queue(scsi_qla_host_t *, srb_t *);
-
-/*
-* qla2x00_callback
-* Returns the completed SCSI command to LINUX.
-*
-* Input:
-* ha -- Host adapter structure
-* cmd -- SCSI mid-level command structure.
-* Returns:
-* None
-* Note:From failover point of view we always get the sp
-* from vis_ha pool in queuecommand.So when we put it
-* back to the pool it has to be the vis_ha.
-* So rely on struct scsi_cmnd to get the vis_ha and not on sp.
-*/
-static inline void
-qla2x00_callback(scsi_qla_host_t *ha, struct scsi_cmnd *cmd)
-{
- srb_t *sp = (srb_t *) CMD_SP(cmd);
- scsi_qla_host_t *vis_ha;
- os_lun_t *lq;
- int got_sense;
- unsigned long cpu_flags = 0;
-
- cmd->host_scribble = (unsigned char *) NULL;
- vis_ha = (scsi_qla_host_t *) cmd->device->host->hostdata;
-
- if (sp == NULL) {
- qla_printk(KERN_INFO, ha,
- "%s(): **** CMD derives a NULL SP\n",
- __func__);
- DEBUG2(BUG();)
- return;
- }
-
- /*
- * If command status is not DID_BUS_BUSY then go ahead and freed sp.
- */
- /*
- * Cancel command timeout
- */
- qla2x00_delete_timer_from_cmd(sp);
-
- /*
- * Put SP back in the free queue
- */
- sp->cmd = NULL;
- CMD_SP(cmd) = NULL;
- lq = sp->lun_queue;
- got_sense = (sp->flags & SRB_GOT_SENSE)? 1: 0;
- add_to_free_queue(vis_ha, sp);
-
- if (host_byte(cmd->result) == DID_OK) {
- /* device ok */
- ha->total_bytes += cmd->bufflen;
- if (!got_sense) {
- /* If lun was suspended then clear retry count */
- spin_lock_irqsave(&lq->q_lock, cpu_flags);
- if (!test_bit(LUN_EXEC_DELAYED, &lq->q_flag))
- lq->q_state = LUN_STATE_READY;
- spin_unlock_irqrestore(&lq->q_lock, cpu_flags);
- }
- } else if (host_byte(cmd->result) == DID_ERROR) {
- /* device error */
- ha->total_dev_errs++;
- }
-
- /* Call the mid-level driver interrupt handler */
- (*(cmd)->scsi_done)(cmd);
-}
-
-/**************************************************************************
-* sp_put
-*
-* Description:
-* Decrement reference count and call the callback if we're the last
-* owner of the specified sp. Will get the host_lock before calling
-* the callback.
-*
-* Input:
-* ha - pointer to the scsi_qla_host_t where the callback is to occur.
-* sp - pointer to srb_t structure to use.
-*
-* Returns:
-*
-**************************************************************************/
-static inline void
-sp_put(struct scsi_qla_host * ha, srb_t *sp)
-{
- if (atomic_read(&sp->ref_count) == 0) {
- qla_printk(KERN_INFO, ha,
- "%s(): **** SP->ref_count not zero\n",
- __func__);
- DEBUG2(BUG();)
-
- return;
- }
-
- if (!atomic_dec_and_test(&sp->ref_count)) {
- return;
- }
-
- qla2x00_callback(ha, sp->cmd);
-}
-
-/**************************************************************************
-* sp_get
-*
-* Description:
-* Increment reference count of the specified sp.
-*
-* Input:
-* sp - pointer to srb_t structure to use.
-*
-* Returns:
-*
-**************************************************************************/
-static inline void
-sp_get(struct scsi_qla_host * ha, srb_t *sp)
-{
- atomic_inc(&sp->ref_count);
-
- if (atomic_read(&sp->ref_count) > 2) {
- qla_printk(KERN_INFO, ha,
- "%s(): **** SP->ref_count greater than two\n",
- __func__);
- DEBUG2(BUG();)
-
- return;
- }
-}
-
-static inline void
-qla2x00_delete_from_done_queue(scsi_qla_host_t *dest_ha, srb_t *sp)
-{
- /* remove command from done list */
- list_del_init(&sp->list);
- dest_ha->done_q_cnt--;
- sp->state = SRB_NO_QUEUE_STATE;
-
- if (sp->flags & SRB_DMA_VALID) {
- sp->flags &= ~SRB_DMA_VALID;
-
- /* Release memory used for this I/O */
- if (sp->cmd->use_sg) {
- pci_unmap_sg(dest_ha->pdev, sp->cmd->request_buffer,
- sp->cmd->use_sg, sp->cmd->sc_data_direction);
- } else if (sp->cmd->request_bufflen) {
- pci_unmap_page(dest_ha->pdev, sp->dma_handle,
- sp->cmd->request_bufflen,
- sp->cmd->sc_data_direction);
- }
- }
-}
-
static int qla2x00_do_dpc(void *data);
static void qla2x00_rst_aen(scsi_qla_host_t *);
static void qla2x00_mem_free(scsi_qla_host_t *ha);
static int qla2x00_allocate_sp_pool( scsi_qla_host_t *ha);
static void qla2x00_free_sp_pool(scsi_qla_host_t *ha);
-static srb_t *qla2x00_get_new_sp(scsi_qla_host_t *ha);
-
-static ssize_t qla2x00_sysfs_read_fw_dump(struct kobject *, char *, loff_t,
- size_t);
-static ssize_t qla2x00_sysfs_write_fw_dump(struct kobject *, char *, loff_t,
- size_t);
-static struct bin_attribute sysfs_fw_dump_attr = {
- .attr = {
- .name = "fw_dump",
- .mode = S_IRUSR | S_IWUSR,
- .owner = THIS_MODULE,
- },
- .size = 0,
- .read = qla2x00_sysfs_read_fw_dump,
- .write = qla2x00_sysfs_write_fw_dump,
-};
-static ssize_t qla2x00_sysfs_read_nvram(struct kobject *, char *, loff_t,
- size_t);
-static ssize_t qla2x00_sysfs_write_nvram(struct kobject *, char *, loff_t,
- size_t);
-static struct bin_attribute sysfs_nvram_attr = {
- .attr = {
- .name = "nvram",
- .mode = S_IRUSR | S_IWUSR,
- .owner = THIS_MODULE,
- },
- .size = sizeof(nvram_t),
- .read = qla2x00_sysfs_read_nvram,
- .write = qla2x00_sysfs_write_nvram,
-};
+static 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 *);
/* -------------------------------------------------------------------------- */
-
-/* SysFS attributes. */
-static ssize_t qla2x00_sysfs_read_fw_dump(struct kobject *kobj, char *buf,
- loff_t off, size_t count)
-{
- struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj,
- struct device, kobj)));
-
- if (ha->fw_dump_reading == 0)
- return 0;
- if (off > ha->fw_dump_buffer_len)
- return 0;
- if (off + count > ha->fw_dump_buffer_len)
- count = ha->fw_dump_buffer_len - off;
-
- memcpy(buf, &ha->fw_dump_buffer[off], count);
-
- return (count);
-}
-
-static ssize_t qla2x00_sysfs_write_fw_dump(struct kobject *kobj, char *buf,
- loff_t off, size_t count)
-{
- struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj,
- struct device, kobj)));
- int reading;
- uint32_t dump_size;
-
- if (off != 0)
- return (0);
-
- reading = simple_strtol(buf, NULL, 10);
- switch (reading) {
- case 0:
- if (ha->fw_dump_reading == 1) {
- qla_printk(KERN_INFO, ha,
- "Firmware dump cleared on (%ld).\n",
- ha->host_no);
-
- vfree(ha->fw_dump_buffer);
- free_pages((unsigned long)ha->fw_dump,
- ha->fw_dump_order);
-
- ha->fw_dump_reading = 0;
- ha->fw_dump_buffer = NULL;
- ha->fw_dump = NULL;
- }
- break;
- case 1:
- if (ha->fw_dump != NULL && !ha->fw_dump_reading) {
- ha->fw_dump_reading = 1;
-
- dump_size = FW_DUMP_SIZE_1M;
- if (ha->fw_memory_size < 0x20000)
- dump_size = FW_DUMP_SIZE_128K;
- else if (ha->fw_memory_size < 0x80000)
- dump_size = FW_DUMP_SIZE_512K;
- ha->fw_dump_buffer = (char *)vmalloc(dump_size);
- if (ha->fw_dump_buffer == NULL) {
- qla_printk(KERN_WARNING, ha,
- "Unable to allocate memory for firmware "
- "dump buffer (%d).\n", dump_size);
-
- ha->fw_dump_reading = 0;
- return (count);
- }
- qla_printk(KERN_INFO, ha,
- "Firmware dump ready for read on (%ld).\n",
- ha->host_no);
- memset(ha->fw_dump_buffer, 0, dump_size);
- if (IS_QLA2100(ha) || IS_QLA2200(ha))
- qla2100_ascii_fw_dump(ha);
- else
- qla2300_ascii_fw_dump(ha);
- ha->fw_dump_buffer_len = strlen(ha->fw_dump_buffer);
- }
- break;
- }
- return (count);
-}
-
-static ssize_t qla2x00_sysfs_read_nvram(struct kobject *kobj, char *buf,
- loff_t off, size_t count)
-{
- struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj,
- struct device, kobj)));
- uint16_t *witer;
- unsigned long flags;
- uint16_t cnt;
-
- if (!capable(CAP_SYS_ADMIN) || off != 0 || count != sizeof(nvram_t))
- return 0;
-
- /* Read NVRAM. */
- spin_lock_irqsave(&ha->hardware_lock, flags);
- qla2x00_lock_nvram_access(ha);
- witer = (uint16_t *)buf;
- for (cnt = 0; cnt < count / 2; cnt++) {
- *witer = cpu_to_le16(qla2x00_get_nvram_word(ha,
- cnt+ha->nvram_base));
- witer++;
- }
- qla2x00_unlock_nvram_access(ha);
- spin_unlock_irqrestore(&ha->hardware_lock, flags);
-
- return (count);
-}
-
-static ssize_t qla2x00_sysfs_write_nvram(struct kobject *kobj, char *buf,
- loff_t off, size_t count)
-{
- struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj,
- struct device, kobj)));
- uint8_t *iter;
- uint16_t *witer;
- unsigned long flags;
- uint16_t cnt;
- uint8_t chksum;
-
- if (!capable(CAP_SYS_ADMIN) || off != 0 || count != sizeof(nvram_t))
- return 0;
-
- /* Checksum NVRAM. */
- iter = (uint8_t *)buf;
- chksum = 0;
- for (cnt = 0; cnt < count - 1; cnt++)
- chksum += *iter++;
- chksum = ~chksum + 1;
- *iter = chksum;
-
- /* Write NVRAM. */
- spin_lock_irqsave(&ha->hardware_lock, flags);
- qla2x00_lock_nvram_access(ha);
- qla2x00_release_nvram_protection(ha);
- witer = (uint16_t *)buf;
- for (cnt = 0; cnt < count / 2; cnt++) {
- qla2x00_write_nvram_word(ha, cnt+ha->nvram_base,
- cpu_to_le16(*witer));
- witer++;
- }
- qla2x00_unlock_nvram_access(ha);
- spin_unlock_irqrestore(&ha->hardware_lock, flags);
-
- return (count);
-}
-
-/* -------------------------------------------------------------------------- */
static char *
qla2x00_get_pci_info_str(struct scsi_qla_host *ha, char *str)
{
* handling).
**************************************************************************/
static int
-qla2x00_queuecommand(struct scsi_cmnd *cmd, void (*fn)(struct scsi_cmnd *))
+qla2x00_queuecommand(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
{
- fc_port_t *fcport;
- os_lun_t *lq;
- os_tgt_t *tq;
- scsi_qla_host_t *ha, *ha2;
- srb_t *sp;
- struct Scsi_Host *host;
- unsigned int b, t, l;
- unsigned long handle;
- int was_empty;
-
+ 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;
- host = cmd->device->host;
- ha = (scsi_qla_host_t *) host->hostdata;
- was_empty = 1;
+ if (!fcport) {
+ cmd->result = DID_NO_CONNECT << 16;
+ goto qc_fail_command;
+ }
- cmd->scsi_done = fn;
+ if (atomic_read(&fcport->state) != FCS_ONLINE) {
+ if (atomic_read(&fcport->state) == FCS_DEVICE_DEAD ||
+ atomic_read(&ha->loop_state) == LOOP_DEAD) {
+ cmd->result = DID_NO_CONNECT << 16;
+ goto qc_fail_command;
+ }
+ goto qc_host_busy;
+ }
spin_unlock_irq(ha->host->host_lock);
- /*
- * Allocate a command packet from the "sp" pool. If we cant get back
- * one then let scsi layer come back later.
- */
+ /* Allocate a command packet from the "sp" pool. */
if ((sp = qla2x00_get_new_sp(ha)) == NULL) {
- qla_printk(KERN_WARNING, ha,
- "Couldn't allocate memory for sp - retried.\n");
-
- spin_lock_irq(ha->host->host_lock);
-
- return (1);
+ goto qc_host_busy_lock;
}
+ sp->ha = ha;
+ sp->fcport = fcport;
sp->cmd = cmd;
- CMD_SP(cmd) = (void *)sp;
-
sp->flags = 0;
- if (CMD_RESID_LEN(cmd) & SRB_IOCTL) {
- /* Need to set sp->flags */
- sp->flags |= SRB_IOCTL;
- CMD_RESID_LEN(cmd) = 0; /* Clear it since no more use. */
- }
-
- sp->fo_retry_cnt = 0;
sp->err_id = 0;
- /* Generate LU queue on bus, target, LUN */
- b = cmd->device->channel;
- t = cmd->device->id;
- l = cmd->device->lun;
-
- /*
- * Start Command Timer. Typically it will be 2 seconds less than what
- * is requested by the Host such that we can return the IO before
- * aborts are called.
- */
- if ((cmd->timeout_per_command / HZ) > QLA_CMD_TIMER_DELTA)
- qla2x00_add_timer_to_cmd(sp,
- (cmd->timeout_per_command / HZ) - QLA_CMD_TIMER_DELTA);
- else
- qla2x00_add_timer_to_cmd(sp, cmd->timeout_per_command / HZ);
-
- if (l >= ha->max_luns) {
- cmd->result = DID_NO_CONNECT << 16;
- sp->err_id = SRB_ERR_PORT;
-
- spin_lock_irq(ha->host->host_lock);
-
- sp_put(ha, sp);
-
- return (0);
- }
-
- if ((tq = (os_tgt_t *) TGT_Q(ha, t)) != NULL &&
- (lq = (os_lun_t *) LUN_Q(ha, t, l)) != NULL) {
- fcport = lq->fclun->fcport;
- ha2 = fcport->ha;
- } else {
- lq = NULL;
- fcport = NULL;
- ha2 = ha;
- }
-
- /* Set an invalid handle until we issue the command to ISP */
- /* then we will set the real handle value. */
- handle = INVALID_HANDLE;
- cmd->host_scribble = (unsigned char *)handle;
-
- /* Bookkeeping information */
- sp->r_start = jiffies; /* Time the request was recieved. */
- sp->u_start = 0;
-
- /* Setup device queue pointers. */
- sp->tgt_queue = tq;
- sp->lun_queue = lq;
-
- /*
- * NOTE : q is NULL
- *
- * 1. When device is added from persistent binding but has not been
- * discovered yet.The state of loopid == PORT_AVAIL.
- * 2. When device is never found on the bus.(loopid == UNUSED)
- *
- * IF Device Queue is not created, or device is not in a valid state
- * and link down error reporting is enabled, reject IO.
- */
- if (fcport == NULL) {
- DEBUG3(printk("scsi(%ld:%2d:%2d): port unavailable\n",
- ha->host_no,t,l));
-
- cmd->result = DID_NO_CONNECT << 16;
- sp->err_id = SRB_ERR_PORT;
-
- spin_lock_irq(ha->host->host_lock);
+ CMD_SP(cmd) = (void *)sp;
+ cmd->scsi_done = done;
- sp_put(ha, sp);
+ rval = qla2x00_start_scsi(sp);
+ if (rval != QLA_SUCCESS)
+ goto qc_host_busy_free_sp;
- return (0);
- }
+ /* Manage unprocessed RIO/ZIO commands in response queue. */
+ if (ha->flags.online && ha->flags.process_response_queue &&
+ ha->response_ring_ptr->signature != RESPONSE_PROCESSED) {
+ unsigned long flags;
- /* Only modify the allowed count if the target is a *non* tape device */
- if ((fcport->flags & FCF_TAPE_PRESENT) == 0) {
- sp->flags &= ~SRB_TAPE;
- if (cmd->allowed < ql2xretrycount) {
- cmd->allowed = ql2xretrycount;
- }
- } else
- sp->flags |= SRB_TAPE;
-
- DEBUG5(printk("scsi(%ld:%2d:%2d): (queuecmd) queue sp = %p, "
- "flags=0x%x fo retry=%d, pid=%ld\n",
- ha->host_no, t, l, sp, sp->flags, sp->fo_retry_cnt,
- cmd->serial_number));
- DEBUG5(qla2x00_print_scsi_cmd(cmd));
-
- sp->fclun = lq->fclun;
- sp->ha = ha2;
-
- if (cmd->sc_data_direction == DMA_BIDIRECTIONAL &&
- cmd->request_bufflen != 0) {
-
- DEBUG2(printk(KERN_WARNING
- "scsi(%ld): Incorrect data direction - transfer "
- "length=%d, direction=%d, pid=%ld, opcode=%x\n",
- ha->host_no, cmd->request_bufflen, cmd->sc_data_direction,
- cmd->serial_number, cmd->cmnd[0]));
+ spin_lock_irqsave(&ha->hardware_lock, flags);
+ qla2x00_process_response_queue(ha);
+ spin_unlock_irqrestore(&ha->hardware_lock, flags);
}
- /* Final pre-check :
- *
- * Either PORT_DOWN_TIMER OR LINK_DOWN_TIMER Expired.
- */
- if (atomic_read(&fcport->state) == FCS_DEVICE_DEAD ||
- atomic_read(&ha2->loop_state) == LOOP_DEAD) {
- /*
- * Add the command to the done-queue for later failover
- * processing.
- */
- cmd->result = DID_NO_CONNECT << 16;
- if (atomic_read(&ha2->loop_state) == LOOP_DOWN)
- sp->err_id = SRB_ERR_LOOP;
- else
- sp->err_id = SRB_ERR_PORT;
-
- add_to_done_queue(ha, sp);
- qla2x00_done(ha);
-
- spin_lock_irq(ha->host->host_lock);
- return (0);
- }
+ spin_lock_irq(ha->host->host_lock);
- if (tq && test_bit(TQF_SUSPENDED, &tq->flags) &&
- (sp->flags & SRB_TAPE) == 0) {
- /* If target suspended put incoming I/O in retry_q. */
- qla2x00_extend_timeout(sp->cmd, 10);
- add_to_scsi_retry_queue(ha, sp);
- } else
- was_empty = add_to_pending_queue(ha, sp);
+ return 0;
- if ((IS_QLA2100(ha) || IS_QLA2200(ha)) && ha->flags.online) {
- if (ha->response_ring_ptr->signature != RESPONSE_PROCESSED) {
- unsigned long flags;
+qc_host_busy_free_sp:
+ qla2x00_sp_free_dma(ha, sp);
+ CMD_SP(cmd) = NULL;
+ mempool_free(sp, ha->srb_mempool);
- spin_lock_irqsave(&ha->hardware_lock, flags);
- qla2x00_process_response_queue(ha);
- spin_unlock_irqrestore(&ha->hardware_lock, flags);
- }
- }
+qc_host_busy_lock:
+ spin_lock_irq(ha->host->host_lock);
- /* We submit to the hardware if:
- *
- * 1) we're on the cpu the irq's arrive on or
- * 2) there are very few io's outstanding.
- *
- * In all other cases we'll let an irq pick up our IO and submit it
- * to the controller to improve affinity.
- */
- if (_smp_processor_id() == ha->last_irq_cpu || was_empty)
- qla2x00_next(ha);
+qc_host_busy:
+ return SCSI_MLQUEUE_HOST_BUSY;
- spin_lock_irq(ha->host->host_lock);
+qc_fail_command:
+ done(cmd);
- return (0);
+ return 0;
}
/*
qla2x00_eh_wait_on_command(scsi_qla_host_t *ha, struct scsi_cmnd *cmd)
{
#define ABORT_POLLING_PERIOD HZ
-#define ABORT_WAIT_TIME ((10 * HZ) / (ABORT_POLLING_PERIOD))
-
- int found = 0;
- int done = 0;
- srb_t *rp = NULL;
- struct list_head *list, *temp;
- u_long max_wait_time = ABORT_WAIT_TIME;
-
- do {
- /* Check on done queue */
- spin_lock(&ha->list_lock);
- list_for_each_safe(list, temp, &ha->done_queue) {
- rp = list_entry(list, srb_t, list);
-
- /*
- * Found command. Just exit and wait for the cmd sent
- * to OS.
- */
- if (cmd == rp->cmd) {
- found++;
- DEBUG3(printk("%s: found in done queue.\n",
- __func__);)
- break;
- }
- }
- spin_unlock(&ha->list_lock);
-
- /* Complete the cmd right away. */
- if (found) {
- qla2x00_delete_from_done_queue(ha, rp);
- sp_put(ha, rp);
- done++;
- break;
- }
-
- spin_unlock_irq(ha->host->host_lock);
+#define ABORT_WAIT_ITER ((10 * HZ) / (ABORT_POLLING_PERIOD))
+ unsigned long wait_iter = ABORT_WAIT_ITER;
+ int ret = QLA_SUCCESS;
+ while (CMD_SP(cmd)) {
set_current_state(TASK_UNINTERRUPTIBLE);
schedule_timeout(ABORT_POLLING_PERIOD);
- spin_lock_irq(ha->host->host_lock);
-
- } while ((max_wait_time--));
-
- if (done)
- DEBUG2(printk(KERN_INFO "%s: found cmd=%p.\n", __func__, cmd));
+ if (--wait_iter)
+ break;
+ }
+ if (CMD_SP(cmd))
+ ret = QLA_FUNCTION_FAILED;
- return (done);
+ return ret;
}
/*
int
qla2xxx_eh_abort(struct scsi_cmnd *cmd)
{
- int i;
- int return_status = FAILED;
- os_lun_t *q;
- scsi_qla_host_t *ha;
- scsi_qla_host_t *vis_ha;
- srb_t *sp;
- srb_t *rp;
- struct list_head *list, *temp;
- struct Scsi_Host *host;
- uint8_t found = 0;
- unsigned int b, t, l;
+ scsi_qla_host_t *ha = to_qla_host(cmd->device->host);
+ srb_t *sp;
+ int ret, i;
+ unsigned int id, lun;
+ unsigned long serial;
+ unsigned long flags;
- /* Get the SCSI request ptr */
- sp = (srb_t *) CMD_SP(cmd);
+ if (!CMD_SP(cmd))
+ return FAILED;
- /*
- * If sp is NULL, command is already returned.
- * sp is NULLED just before we call back scsi_done
- *
- */
- if ((sp == NULL)) {
- /* no action - we don't have command */
- qla_printk(KERN_INFO, to_qla_host(cmd->device->host),
- "qla2xxx_eh_abort: cmd already done sp=%p\n", sp);
- DEBUG(printk("qla2xxx_eh_abort: cmd already done sp=%p\n", sp);)
- return SUCCESS;
- }
- if (sp) {
- DEBUG(printk("qla2xxx_eh_abort: refcount %i \n",
- atomic_read(&sp->ref_count));)
- }
+ ret = FAILED;
+
+ id = cmd->device->id;
+ lun = cmd->device->lun;
+ serial = cmd->serial_number;
- vis_ha = (scsi_qla_host_t *) cmd->device->host->hostdata;
- ha = (scsi_qla_host_t *)cmd->device->host->hostdata;
+ /* Check active list for command command. */
+ spin_unlock_irq(ha->host->host_lock);
+ spin_lock_irqsave(&ha->hardware_lock, flags);
+ for (i = 1; i < MAX_OUTSTANDING_COMMANDS; i++) {
+ sp = ha->outstanding_cmds[i];
- host = ha->host;
+ if (sp == NULL)
+ continue;
- /* Generate LU queue on bus, target, LUN */
- b = cmd->device->channel;
- t = cmd->device->id;
- l = cmd->device->lun;
- q = GET_LU_Q(vis_ha, t, l);
+ if (sp->cmd != cmd)
+ continue;
- qla_printk(KERN_INFO, ha,
- "%s scsi(%ld:%d:%d:%d): cmd_timeout_in_sec=0x%x.\n", __func__,
- ha->host_no, (int)b, (int)t, (int)l,
- cmd->timeout_per_command / HZ);
+ DEBUG2(printk("%s(%ld): aborting sp %p from RISC. pid=%ld "
+ "sp->state=%x\n", __func__, ha->host_no, sp, serial,
+ sp->state));
+ DEBUG3(qla2x00_print_scsi_cmd(cmd);)
- /*
- * if no LUN queue then something is very wrong!!!
- */
- if (q == NULL) {
- qla_printk(KERN_WARNING, ha,
- "qla2x00: (%x:%x:%x) No LUN queue.\n", b, t, l);
+ spin_unlock_irqrestore(&ha->hardware_lock, flags);
+ if (qla2x00_abort_command(ha, sp)) {
+ DEBUG2(printk("%s(%ld): abort_command "
+ "mbx failed.\n", __func__, ha->host_no));
+ } else {
+ DEBUG3(printk("%s(%ld): abort_command "
+ "mbx success.\n", __func__, ha->host_no));
+ ret = SUCCESS;
+ }
+ spin_lock_irqsave(&ha->hardware_lock, flags);
- /* no action - we don't have command */
- return FAILED;
+ break;
}
+ spin_unlock_irqrestore(&ha->hardware_lock, flags);
- DEBUG2(printk("scsi(%ld): ABORTing cmd=%p sp=%p jiffies = 0x%lx, "
- "timeout=%x, dpc_flags=%lx, vis_ha->dpc_flags=%lx q->flag=%lx\n",
- ha->host_no, cmd, sp, jiffies, cmd->timeout_per_command / HZ,
- ha->dpc_flags, vis_ha->dpc_flags, q->q_flag));
- DEBUG2(qla2x00_print_scsi_cmd(cmd));
-
- spin_unlock_irq(ha->host->host_lock);
- if (qla2x00_wait_for_hba_online(ha) != QLA_SUCCESS) {
- DEBUG2(printk("%s failed:board disabled\n", __func__);)
- spin_lock_irq(ha->host->host_lock);
- return FAILED;
+ /* Wait for the command to be returned. */
+ if (ret == SUCCESS) {
+ if (qla2x00_eh_wait_on_command(ha, cmd) != QLA_SUCCESS) {
+ qla_printk(KERN_ERR, ha,
+ "scsi(%ld:%d:%d): Abort handler timed out -- %lx "
+ "%x.\n", ha->host_no, id, lun, serial, ret);
+ }
}
spin_lock_irq(ha->host->host_lock);
- /* Search done queue */
- spin_lock(&ha->list_lock);
- list_for_each_safe(list, temp, &ha->done_queue) {
- rp = list_entry(list, srb_t, list);
-
- if (cmd != rp->cmd)
- continue;
-
- /*
- * Found command.Remove it from done list.
- * And proceed to post completion to scsi mid layer.
- */
- return_status = SUCCESS;
- found++;
- qla2x00_delete_from_done_queue(ha, sp);
-
- break;
- } /* list_for_each_safe() */
- spin_unlock(&ha->list_lock);
+ qla_printk(KERN_INFO, ha,
+ "scsi(%ld:%d:%d): Abort command issued -- %lx %x.\n", ha->host_no,
+ id, lun, serial, ret);
- /*
- * Return immediately if the aborted command was already in the done
- * queue
- */
- if (found) {
- qla_printk(KERN_INFO, ha,
- "qla2xxx_eh_abort: Returning completed command=%p sp=%p\n",
- cmd, sp);
- sp_put(ha, sp);
- return (return_status);
- }
-
-
- /*
- * See if this command is in the retry queue
- */
- DEBUG3(printk("qla2xxx_eh_abort: searching sp %p in retry "
- "queue.\n", sp);)
-
- spin_lock(&ha->list_lock);
- list_for_each_safe(list, temp, &ha->retry_queue) {
- rp = list_entry(list, srb_t, list);
-
- if (cmd != rp->cmd)
- continue;
-
-
- DEBUG2(printk("qla2xxx_eh_abort: found "
- "in retry queue. SP=%p\n", sp);)
-
- __del_from_retry_queue(ha, rp);
- cmd->result = DID_ABORT << 16;
- __add_to_done_queue(ha, rp);
-
- return_status = SUCCESS;
- found++;
-
- break;
-
- }
- spin_unlock(&ha->list_lock);
-
-
- /*
- * Our SP pointer points at the command we want to remove from the
- * pending queue providing we haven't already sent it to the adapter.
- */
- if (!found) {
- DEBUG3(printk("qla2xxx_eh_abort: searching sp %p "
- "in pending queue.\n", sp);)
-
- spin_lock(&vis_ha->list_lock);
- list_for_each_safe(list, temp, &vis_ha->pending_queue) {
- rp = list_entry(list, srb_t, list);
-
- if (rp->cmd != cmd)
- continue;
-
- /* Remove srb from LUN queue. */
- rp->flags |= SRB_ABORTED;
-
- DEBUG2(printk("qla2xxx_eh_abort: Cmd in pending queue."
- " serial_number %ld.\n",
- sp->cmd->serial_number);)
-
- __del_from_pending_queue(vis_ha, rp);
- cmd->result = DID_ABORT << 16;
-
- __add_to_done_queue(vis_ha, rp);
-
- return_status = SUCCESS;
-
- found++;
- break;
- } /* list_for_each_safe() */
- spin_unlock(&vis_ha->list_lock);
- } /*End of if !found */
-
- if (!found) { /* find the command in our active list */
- DEBUG3(printk("qla2xxx_eh_abort: searching sp %p "
- "in outstanding queue.\n", sp);)
-
- spin_lock(&ha->hardware_lock);
- for (i = 1; i < MAX_OUTSTANDING_COMMANDS; i++) {
- sp = ha->outstanding_cmds[i];
-
- if (sp == NULL)
- continue;
-
- if (sp->cmd != cmd)
- continue;
-
- DEBUG2(printk("qla2xxx_eh_abort(%ld): aborting sp %p "
- "from RISC. pid=%ld sp->state=%x q->q_flag=%lx\n",
- ha->host_no, sp, sp->cmd->serial_number,
- sp->state, q->q_flag);)
- DEBUG(qla2x00_print_scsi_cmd(cmd);)
-
- /* Get a reference to the sp and drop the lock.*/
- sp_get(ha, sp);
-
- spin_unlock(&ha->hardware_lock);
- spin_unlock_irq(ha->host->host_lock);
-
- if (qla2x00_abort_command(ha, sp)) {
- DEBUG2(printk("qla2xxx_eh_abort: abort_command "
- "mbx failed.\n");)
- return_status = FAILED;
- } else {
- DEBUG3(printk("qla2xxx_eh_abort: abort_command "
- " mbx success.\n");)
- return_status = SUCCESS;
- }
-
- sp_put(ha,sp);
-
- spin_lock_irq(ha->host->host_lock);
- spin_lock(&ha->hardware_lock);
-
- /*
- * Regardless of mailbox command status, go check on
- * done queue just in case the sp is already done.
- */
- break;
-
- }/*End of for loop */
- spin_unlock(&ha->hardware_lock);
-
- } /*End of if !found */
-
- /* Waiting for our command in done_queue to be returned to OS.*/
- if (qla2x00_eh_wait_on_command(ha, cmd) != 0) {
- DEBUG2(printk("qla2xxx_eh_abort: cmd returned back to OS.\n");)
- return_status = SUCCESS;
- }
-
- if (return_status == FAILED) {
- qla_printk(KERN_INFO, ha,
- "qla2xxx_eh_abort Exiting: status=Failed\n");
- return FAILED;
- }
-
- DEBUG2(printk("qla2xxx_eh_abort: Exiting. return_status=0x%x.\n",
- return_status));
-
- return return_status;
-}
+ return ret;
+}
/**************************************************************************
* qla2x00_eh_wait_for_pending_target_commands
int status;
srb_t *sp;
struct scsi_cmnd *cmd;
+ unsigned long flags;
status = 0;
* array
*/
for (cnt = 1; cnt < MAX_OUTSTANDING_COMMANDS; cnt++) {
- spin_lock(&ha->hardware_lock);
+ spin_lock_irqsave(&ha->hardware_lock, flags);
sp = ha->outstanding_cmds[cnt];
if (sp) {
cmd = sp->cmd;
- spin_unlock(&ha->hardware_lock);
+ spin_unlock_irqrestore(&ha->hardware_lock, flags);
if (cmd->device->id == t) {
if (!qla2x00_eh_wait_on_command(ha, cmd)) {
status = 1;
break;
}
}
- }
- else {
- spin_unlock(&ha->hardware_lock);
+ } else {
+ spin_unlock_irqrestore(&ha->hardware_lock, flags);
}
}
return (status);
int
qla2xxx_eh_device_reset(struct scsi_cmnd *cmd)
{
- int return_status;
- unsigned int b, t, l;
- scsi_qla_host_t *ha;
- os_tgt_t *tq;
- os_lun_t *lq;
- fc_port_t *fcport_to_reset;
- srb_t *rp;
- struct list_head *list, *temp;
-
- return_status = FAILED;
- if (cmd == NULL) {
- printk(KERN_INFO
- "%s(): **** SCSI mid-layer passing in NULL cmd\n",
- __func__);
-
- return (return_status);
- }
-
- b = cmd->device->channel;
- t = cmd->device->id;
- l = cmd->device->lun;
- ha = (scsi_qla_host_t *)cmd->device->host->hostdata;
-
- tq = TGT_Q(ha, t);
- if (tq == NULL) {
- qla_printk(KERN_INFO, ha,
- "%s(): **** CMD derives a NULL TGT_Q\n", __func__);
+ scsi_qla_host_t *ha = to_qla_host(cmd->device->host);
+ fc_port_t *fcport = (struct fc_port *) cmd->device->hostdata;
+ srb_t *sp;
+ int ret;
+ unsigned int id, lun;
+ unsigned long serial;
- return (return_status);
- }
- lq = (os_lun_t *)LUN_Q(ha, t, l);
- if (lq == NULL) {
- printk(KERN_INFO
- "%s(): **** CMD derives a NULL LUN_Q\n", __func__);
+ ret = FAILED;
- return (return_status);
- }
- fcport_to_reset = lq->fclun->fcport;
+ id = cmd->device->id;
+ lun = cmd->device->lun;
+ serial = cmd->serial_number;
- /* If we are coming in from the back-door, stall I/O until complete. */
- if (!cmd->device->host->eh_active)
- set_bit(TQF_SUSPENDED, &tq->flags);
+ sp = (srb_t *) CMD_SP(cmd);
+ if (!sp || !fcport)
+ return ret;
qla_printk(KERN_INFO, ha,
- "scsi(%ld:%d:%d:%d): DEVICE RESET ISSUED.\n", ha->host_no, b, t, l);
-
- DEBUG2(printk(KERN_INFO
- "scsi(%ld): DEVICE_RESET cmd=%p jiffies = 0x%lx, timeout=%x, "
- "dpc_flags=%lx, status=%x allowed=%d cmd.state=%x\n",
- ha->host_no, cmd, jiffies, cmd->timeout_per_command / HZ,
- ha->dpc_flags, cmd->result, cmd->allowed, cmd->state));
-
- /* Clear commands from the retry queue. */
- spin_lock(&ha->list_lock);
- list_for_each_safe(list, temp, &ha->retry_queue) {
- rp = list_entry(list, srb_t, list);
-
- if (t != rp->cmd->device->id)
- continue;
-
- DEBUG2(printk(KERN_INFO
- "qla2xxx_eh_reset: found in retry queue. SP=%p\n", rp));
-
- __del_from_retry_queue(ha, rp);
- rp->cmd->result = DID_RESET << 16;
- __add_to_done_queue(ha, rp);
- }
- spin_unlock(&ha->list_lock);
+ "scsi(%ld:%d:%d): DEVICE RESET ISSUED.\n", ha->host_no, id, lun);
spin_unlock_irq(ha->host->host_lock);
if (qla2x00_wait_for_hba_online(ha) != QLA_SUCCESS) {
- DEBUG2(printk(KERN_INFO
- "%s failed:board disabled\n",__func__));
-
spin_lock_irq(ha->host->host_lock);
goto eh_dev_reset_done;
}
if (qla2x00_wait_for_loop_ready(ha) == QLA_SUCCESS) {
- if (qla2x00_device_reset(ha, fcport_to_reset) == 0) {
- return_status = SUCCESS;
- }
+ if (qla2x00_device_reset(ha, fcport) == 0)
+ ret = SUCCESS;
#if defined(LOGOUT_AFTER_DEVICE_RESET)
- if (return_status == SUCCESS) {
- if (fcport_to_reset->flags & FC_FABRIC_DEVICE) {
- qla2x00_fabric_logout(ha,
- fcport_to_reset->loop_id);
- qla2x00_mark_device_lost(ha, fcport_to_reset);
+ if (ret == SUCCESS) {
+ if (fcport->flags & FC_FABRIC_DEVICE) {
+ qla2x00_fabric_logout(ha, fcport->loop_id);
+ qla2x00_mark_device_lost(ha, fcport);
}
}
#endif
"%s failed: loop not ready\n",__func__);)
}
- spin_lock_irq(ha->host->host_lock);
-
- if (return_status == FAILED) {
+ if (ret == FAILED) {
DEBUG3(printk("%s(%ld): device reset failed\n",
__func__, ha->host_no));
qla_printk(KERN_INFO, ha, "%s: device reset failed\n",
* complete for the device.
*/
if (cmd->device->host->eh_active) {
- if (qla2x00_eh_wait_for_pending_target_commands(ha, t))
- return_status = FAILED;
+ if (qla2x00_eh_wait_for_pending_target_commands(ha, id))
+ ret = FAILED;
- if (return_status == FAILED) {
+ if (ret == FAILED) {
DEBUG3(printk("%s(%ld): failed while waiting for "
"commands\n", __func__, ha->host_no));
qla_printk(KERN_INFO, ha,
}
qla_printk(KERN_INFO, ha,
- "scsi(%ld:%d:%d:%d): DEVICE RESET SUCCEEDED.\n",
- ha->host_no, b, t, l);
+ "scsi(%ld:%d:%d): DEVICE RESET SUCCEEDED.\n", ha->host_no, id, lun);
eh_dev_reset_done:
+ spin_lock_irq(ha->host->host_lock);
- if (!cmd->device->host->eh_active)
- clear_bit(TQF_SUSPENDED, &tq->flags);
-
- return (return_status);
+ return ret;
}
/**************************************************************************
int status;
srb_t *sp;
struct scsi_cmnd *cmd;
+ unsigned long flags;
status = 1;
* array
*/
for (cnt = 1; cnt < MAX_OUTSTANDING_COMMANDS; cnt++) {
- spin_lock(&ha->hardware_lock);
+ spin_lock_irqsave(&ha->hardware_lock, flags);
sp = ha->outstanding_cmds[cnt];
if (sp) {
cmd = sp->cmd;
- spin_unlock(&ha->hardware_lock);
+ spin_unlock_irqrestore(&ha->hardware_lock, flags);
status = qla2x00_eh_wait_on_command(ha, cmd);
if (status == 0)
break;
}
else {
- spin_unlock(&ha->hardware_lock);
+ spin_unlock_irqrestore(&ha->hardware_lock, flags);
}
}
return (status);
int
qla2xxx_eh_bus_reset(struct scsi_cmnd *cmd)
{
- scsi_qla_host_t *ha;
+ scsi_qla_host_t *ha = to_qla_host(cmd->device->host);
+ fc_port_t *fcport = (struct fc_port *) cmd->device->hostdata;
srb_t *sp;
- int rval = FAILED;
+ int ret;
+ unsigned int id, lun;
+ unsigned long serial;
+
+ ret = FAILED;
+
+ id = cmd->device->id;
+ lun = cmd->device->lun;
+ serial = cmd->serial_number;
- ha = (scsi_qla_host_t *) cmd->device->host->hostdata;
sp = (srb_t *) CMD_SP(cmd);
+ if (!sp || !fcport)
+ return ret;
qla_printk(KERN_INFO, ha,
- "scsi(%ld:%d:%d:%d): LOOP RESET ISSUED.\n", ha->host_no,
- cmd->device->channel, cmd->device->id, cmd->device->lun);
+ "scsi(%ld:%d:%d): LOOP RESET ISSUED.\n", ha->host_no, id, lun);
spin_unlock_irq(ha->host->host_lock);
if (qla2x00_wait_for_hba_online(ha) != QLA_SUCCESS) {
DEBUG2(printk("%s failed:board disabled\n",__func__));
- spin_lock_irq(ha->host->host_lock);
- return FAILED;
+ goto eh_bus_reset_done;
}
if (qla2x00_wait_for_loop_ready(ha) == QLA_SUCCESS) {
- if (qla2x00_loop_reset(ha) == QLA_SUCCESS)
- rval = SUCCESS;
+ if (qla2x00_loop_reset(ha) == QLA_SUCCESS)
+ ret = SUCCESS;
}
-
- spin_lock_irq(ha->host->host_lock);
- if (rval == FAILED)
- goto out;
+ if (ret == FAILED)
+ goto eh_bus_reset_done;
/* Waiting for our command in done_queue to be returned to OS.*/
if (cmd->device->host->eh_active)
if (!qla2x00_eh_wait_for_pending_commands(ha))
- rval = FAILED;
+ ret = FAILED;
- out:
+eh_bus_reset_done:
qla_printk(KERN_INFO, ha, "%s: reset %s\n", __func__,
- (rval == FAILED) ? "failed" : "succeded");
+ (ret == FAILED) ? "failed" : "succeded");
+
+ spin_lock_irq(ha->host->host_lock);
- return rval;
+ return ret;
}
/**************************************************************************
int
qla2xxx_eh_host_reset(struct scsi_cmnd *cmd)
{
- scsi_qla_host_t *ha = (scsi_qla_host_t *)cmd->device->host->hostdata;
- int rval = SUCCESS;
+ scsi_qla_host_t *ha = to_qla_host(cmd->device->host);
+ fc_port_t *fcport = (struct fc_port *) cmd->device->hostdata;
+ srb_t *sp;
+ int ret;
+ unsigned int id, lun;
+ unsigned long serial;
- /* Display which one we're actually resetting for debug. */
- DEBUG(printk("qla2xxx_eh_host_reset:Resetting scsi(%ld).\n",
- ha->host_no));
+ ret = FAILED;
+
+ id = cmd->device->id;
+ lun = cmd->device->lun;
+ serial = cmd->serial_number;
+
+ sp = (srb_t *) CMD_SP(cmd);
+ if (!sp || !fcport)
+ return ret;
- /*
- * Now issue reset.
- */
qla_printk(KERN_INFO, ha,
- "scsi(%ld:%d:%d:%d): ADAPTER RESET issued.\n", ha->host_no,
- cmd->device->channel, cmd->device->id, cmd->device->lun);
+ "scsi(%ld:%d:%d): ADAPTER RESET ISSUED.\n", ha->host_no, id, lun);
spin_unlock_irq(ha->host->host_lock);
if (qla2x00_wait_for_hba_online(ha) != QLA_SUCCESS)
- goto board_disabled;
+ goto eh_host_reset_lock;
/*
* Fixme-may be dpc thread is active and processing
* devices as lost kicking of the port_down_timer
* while dpc is stuck for the mailbox to complete.
*/
- /* Blocking call-Does context switching if loop is Not Ready */
qla2x00_wait_for_loop_ready(ha);
set_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags);
if (qla2x00_abort_isp(ha)) {
set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
if (qla2x00_wait_for_hba_online(ha) != QLA_SUCCESS)
- goto board_disabled;
+ goto eh_host_reset_lock;
}
-
clear_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags);
- spin_lock_irq(ha->host->host_lock);
- if (rval == FAILED)
- goto out;
-
/* Waiting for our command in done_queue to be returned to OS.*/
- if (!qla2x00_eh_wait_for_pending_commands(ha))
- rval = FAILED;
-
- out:
- qla_printk(KERN_INFO, ha, "%s: reset %s\n", __func__,
- (rval == FAILED) ? "failed" : "succeded");
-
- return rval;
+ if (qla2x00_eh_wait_for_pending_commands(ha))
+ ret = SUCCESS;
- board_disabled:
+eh_host_reset_lock:
spin_lock_irq(ha->host->host_lock);
- qla_printk(KERN_INFO, ha, "%s: failed:board disabled\n", __func__);
- return FAILED;
-}
+ qla_printk(KERN_INFO, ha, "%s: reset %s\n", __func__,
+ (ret == FAILED) ? "failed" : "succeded");
+ return ret;
+}
/*
* qla2x00_loop_reset
qla2x00_loop_reset(scsi_qla_host_t *ha)
{
int status = QLA_SUCCESS;
- uint16_t t;
- os_tgt_t *tq;
+ struct fc_port *fcport;
if (ha->flags.enable_lip_reset) {
status = qla2x00_lip_reset(ha);
}
if (status == QLA_SUCCESS && ha->flags.enable_target_reset) {
- for (t = 0; t < MAX_FIBRE_DEVICES; t++) {
- if ((tq = TGT_Q(ha, t)) == NULL)
- continue;
-
- if (tq->fcport == NULL)
+ list_for_each_entry(fcport, &ha->fcports, list) {
+ if (fcport->port_type != FCT_TARGET)
continue;
- status = qla2x00_target_reset(ha, 0, t);
- if (status != QLA_SUCCESS) {
+ status = qla2x00_target_reset(ha, fcport);
+ if (status != QLA_SUCCESS)
break;
- }
}
}
return qla2x00_abort_target(reset_fcport);
}
-/**************************************************************************
-* qla2xxx_slave_configure
-*
-* Description:
-**************************************************************************/
-int
-qla2xxx_slave_configure(struct scsi_device *sdev)
+static int
+qla2xxx_slave_alloc(struct scsi_device *sdev)
{
scsi_qla_host_t *ha = to_qla_host(sdev->host);
- int queue_depth;
+ struct fc_rport *rport = starget_to_rport(scsi_target(sdev));
+ fc_port_t *fcport;
+ int found;
- if (IS_QLA2100(ha) || IS_QLA2200(ha))
- queue_depth = 16;
- else
- queue_depth = 32;
+ if (!rport)
+ return -ENXIO;
- if (sdev->tagged_supported) {
- if (ql2xmaxqdepth != 0 && ql2xmaxqdepth <= 0xffffU)
- queue_depth = ql2xmaxqdepth;
+ found = 0;
+ list_for_each_entry(fcport, &ha->fcports, list) {
+ if (rport->port_name ==
+ be64_to_cpu(*(uint64_t *)fcport->port_name)) {
+ found++;
+ break;
+ }
+ }
+ if (!found)
+ return -ENXIO;
- ql2xmaxqdepth = queue_depth;
+ sdev->hostdata = fcport;
- scsi_activate_tcq(sdev, queue_depth);
+ return 0;
+}
- qla_printk(KERN_INFO, ha,
- "scsi(%d:%d:%d:%d): Enabled tagged queuing, queue "
- "depth %d.\n",
- sdev->host->host_no, sdev->channel, sdev->id, sdev->lun,
- sdev->queue_depth);
- } else {
- scsi_adjust_queue_depth(sdev, 0 /* TCQ off */,
- sdev->host->hostt->cmd_per_lun /* 3 */);
- }
+static int
+qla2xxx_slave_configure(struct scsi_device *sdev)
+{
+ scsi_qla_host_t *ha = to_qla_host(sdev->host);
+ struct fc_rport *rport = starget_to_rport(sdev->sdev_target);
- return (0);
+ if (sdev->tagged_supported)
+ scsi_activate_tcq(sdev, 32);
+ else
+ scsi_deactivate_tcq(sdev, 32);
+
+ rport->dev_loss_tmo = ha->port_down_retry_count + 5;
+
+ return 0;
+}
+
+static void
+qla2xxx_slave_destroy(struct scsi_device *sdev)
+{
+ sdev->hostdata = NULL;
}
/**
if (pio_len < MIN_IOBASE_LEN) {
qla_printk(KERN_WARNING, ha,
"Invalid PCI I/O region size (%s)...\n",
- ha->pdev->slot_name);
+ pci_name(ha->pdev));
pio = 0;
}
} else {
qla_printk(KERN_WARNING, ha,
"region #0 not a PIO resource (%s)...\n",
- ha->pdev->slot_name);
+ pci_name(ha->pdev));
pio = 0;
}
if (!(mmio_flags & IORESOURCE_MEM)) {
qla_printk(KERN_ERR, ha,
"region #0 not an MMIO resource (%s), aborting\n",
- ha->pdev->slot_name);
+ pci_name(ha->pdev));
goto iospace_error_exit;
}
if (mmio_len < MIN_IOBASE_LEN) {
qla_printk(KERN_ERR, ha,
"Invalid PCI mem region size (%s), aborting\n",
- ha->pdev->slot_name);
+ pci_name(ha->pdev));
goto iospace_error_exit;
}
if (pci_request_regions(ha->pdev, ha->brd_info->drv_name)) {
qla_printk(KERN_WARNING, ha,
- "Failed to reserve PIO/MMIO regions (%s)\n",
- ha->pdev->slot_name);
+ "Failed to reserve PIO/MMIO regions (%s)\n",
+ pci_name(ha->pdev));
goto iospace_error_exit;
}
ha->iobase = ioremap(mmio, MIN_IOBASE_LEN);
if (!ha->iobase) {
qla_printk(KERN_ERR, ha,
- "cannot remap MMIO (%s), aborting\n", ha->pdev->slot_name);
+ "cannot remap MMIO (%s), aborting\n", pci_name(ha->pdev));
goto iospace_error_exit;
}
*/
int qla2x00_probe_one(struct pci_dev *pdev, struct qla_board_info *brd_info)
{
- int ret;
+ int ret = -ENODEV;
device_reg_t __iomem *reg;
struct Scsi_Host *host;
scsi_qla_host_t *ha;
unsigned long wait_switch = 0;
char pci_info[20];
char fw_str[30];
+ fc_port_t *fcport;
if (pci_enable_device(pdev))
- return -1;
+ goto probe_out;
host = scsi_host_alloc(&qla2x00_driver_template,
sizeof(scsi_qla_host_t));
/* Configure PCI I/O space */
ret = qla2x00_iospace_config(ha);
- if (ret != 0) {
+ if (ret)
goto probe_failed;
- }
/* Sanitize the information from PCI BIOS. */
host->irq = pdev->irq;
INIT_LIST_HEAD(&ha->list);
INIT_LIST_HEAD(&ha->fcports);
INIT_LIST_HEAD(&ha->rscn_fcports);
- INIT_LIST_HEAD(&ha->done_queue);
- INIT_LIST_HEAD(&ha->retry_queue);
- INIT_LIST_HEAD(&ha->scsi_retry_queue);
- INIT_LIST_HEAD(&ha->pending_queue);
/*
* These locks are used to prevent more than one CPU
* contention for these locks.
*/
spin_lock_init(&ha->mbx_reg_lock);
- spin_lock_init(&ha->list_lock);
ha->dpc_pid = -1;
init_completion(&ha->dpc_inited);
qla_printk(KERN_WARNING, ha,
"[ERROR] Failed to allocate memory for adapter\n");
+ ret = -ENOMEM;
goto probe_failed;
}
"Adapter flags %x.\n",
ha->host_no, ha->device_flags));
+ ret = -ENODEV;
goto probe_failed;
}
qla_printk(KERN_WARNING, ha,
"Unable to start DPC thread!\n");
+ ret = -ENODEV;
goto probe_failed;
}
wait_for_completion(&ha->dpc_inited);
host->this_id = 255;
host->cmd_per_lun = 3;
+ host->unique_id = ha->instance;
host->max_cmd_len = MAX_CMDSZ;
host->max_channel = ha->ports - 1;
- host->max_lun = ha->max_luns;
- BUG_ON(qla2xxx_transport_template == NULL);
+ host->max_lun = MAX_LUNS;
host->transportt = qla2xxx_transport_template;
- host->unique_id = ha->instance;
- host->max_id = ha->max_targets;
if (IS_QLA2100(ha) || IS_QLA2200(ha))
ret = request_irq(host->irq, qla2100_intr_handler,
else
ret = request_irq(host->irq, qla2300_intr_handler,
SA_INTERRUPT|SA_SHIRQ, ha->brd_info->drv_name, ha);
- if (ret != 0) {
+ if (ret) {
qla_printk(KERN_WARNING, ha,
"Failed to reserve interrupt %d already in use.\n",
host->irq);
ha->flags.init_done = 1;
num_hosts++;
- /* List the target we have found */
- if (displayConfig) {
- qla2x00_display_fc_names(ha);
- }
-
- if (scsi_add_host(host, &pdev->dev))
+ ret = scsi_add_host(host, &pdev->dev);
+ if (ret)
goto probe_failed;
- sysfs_create_bin_file(&host->shost_gendev.kobj, &sysfs_fw_dump_attr);
- sysfs_create_bin_file(&host->shost_gendev.kobj, &sysfs_nvram_attr);
+ qla2x00_alloc_sysfs_attr(ha);
+
+ qla2x00_init_host_attr(ha);
qla_printk(KERN_INFO, ha, "\n"
" QLogic Fibre Channel HBA Driver: %s\n"
pci_name(ha->pdev), ha->flags.enable_64bit_addressing ? '+': '-',
ha->host_no, qla2x00_get_fw_version_str(ha, fw_str));
- if (ql2xdoinitscan)
- scsi_scan_host(host);
+ /* Go with fc_rport registration. */
+ list_for_each_entry(fcport, &ha->fcports, list)
+ qla2x00_reg_remote_port(ha, fcport);
return 0;
probe_failed:
+ fc_remove_host(ha->host);
+
qla2x00_free_device(ha);
scsi_host_put(host);
probe_disable_device:
pci_disable_device(pdev);
- return -1;
+probe_out:
+ return ret;
}
EXPORT_SYMBOL_GPL(qla2x00_probe_one);
ha = pci_get_drvdata(pdev);
- sysfs_remove_bin_file(&ha->host->shost_gendev.kobj,
- &sysfs_fw_dump_attr);
- sysfs_remove_bin_file(&ha->host->shost_gendev.kobj, &sysfs_nvram_attr);
+ qla2x00_free_sysfs_attr(ha);
+
+ fc_remove_host(ha->host);
scsi_remove_host(ha->host);
pci_disable_device(ha->pdev);
}
-
/*
- * The following support functions are adopted to handle
- * the re-entrant qla2x00_proc_info correctly.
+ * qla2x00_mark_device_lost Updates fcport state when device goes offline.
+ *
+ * Input: ha = adapter block pointer. fcport = port structure pointer.
+ *
+ * Return: None.
+ *
+ * Context:
*/
-static void
-copy_mem_info(struct info_str *info, char *data, int len)
+void qla2x00_mark_device_lost(scsi_qla_host_t *ha, fc_port_t *fcport,
+ int do_login)
{
- if (info->pos + len > info->offset + info->length)
- len = info->offset + info->length - info->pos;
+ if (atomic_read(&fcport->state) == FCS_ONLINE && fcport->rport)
+ fc_remote_port_block(fcport->rport);
+ /*
+ * We may need to retry the login, so don't change the state of the
+ * port but do the retries.
+ */
+ if (atomic_read(&fcport->state) != FCS_DEVICE_DEAD)
+ atomic_set(&fcport->state, FCS_DEVICE_LOST);
- if (info->pos + len < info->offset) {
- info->pos += len;
+ if (!do_login)
return;
- }
-
- if (info->pos < info->offset) {
- off_t partial;
-
- partial = info->offset - info->pos;
- data += partial;
- info->pos += partial;
- len -= partial;
- }
-
- if (len > 0) {
- memcpy(info->buffer, data, len);
- info->pos += len;
- info->buffer += len;
+
+ if (fcport->login_retry == 0) {
+ fcport->login_retry = ha->login_retry_count;
+ set_bit(RELOGIN_NEEDED, &ha->dpc_flags);
+
+ DEBUG(printk("scsi(%ld): Port login retry: "
+ "%02x%02x%02x%02x%02x%02x%02x%02x, "
+ "id = 0x%04x retry cnt=%d\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],
+ fcport->loop_id,
+ fcport->login_retry));
}
}
-static int
-copy_info(struct info_str *info, char *fmt, ...)
+/*
+ * qla2x00_mark_all_devices_lost
+ * Updates fcport state when device goes offline.
+ *
+ * Input:
+ * ha = adapter block pointer.
+ * fcport = port structure pointer.
+ *
+ * Return:
+ * None.
+ *
+ * Context:
+ */
+void
+qla2x00_mark_all_devices_lost(scsi_qla_host_t *ha)
{
- va_list args;
- char buf[256];
- int len;
-
- va_start(args, fmt);
- len = vsprintf(buf, fmt, args);
- va_end(args);
-
- copy_mem_info(info, buf, len);
-
- return (len);
+ fc_port_t *fcport;
+
+ list_for_each_entry(fcport, &ha->fcports, list) {
+ if (fcport->port_type != FCT_TARGET)
+ continue;
+
+ /*
+ * No point in marking the device as lost, if the device is
+ * already DEAD.
+ */
+ if (atomic_read(&fcport->state) == FCS_DEVICE_DEAD)
+ continue;
+ if (atomic_read(&fcport->state) == FCS_ONLINE && fcport->rport)
+ fc_remote_port_block(fcport->rport);
+ atomic_set(&fcport->state, FCS_DEVICE_LOST);
+ }
}
-/*************************************************************************
-* qla2x00_proc_info
-*
-* Description:
-* Return information to handle /proc support for the driver.
+/*
+* qla2x00_mem_alloc
+* Allocates adapter memory.
*
-* inout : decides the direction of the dataflow and the meaning of the
-* variables
-* buffer: If inout==0 data is being written to it else read from it
-* (ptr to a page buffer)
-* *start: If inout==0 start of the valid data in the buffer
-* offset: If inout==0 starting offset from the beginning of all
-* possible data to return.
-* length: If inout==0 max number of bytes to be written into the buffer
-* else number of bytes in "buffer"
* Returns:
-* < 0: error. errno value.
-* >= 0: sizeof data returned.
-*************************************************************************/
-int
-qla2x00_proc_info(struct Scsi_Host *shost, char *buffer,
- char **start, off_t offset, int length, int inout)
+* 0 = success.
+* 1 = failure.
+*/
+static uint8_t
+qla2x00_mem_alloc(scsi_qla_host_t *ha)
{
- struct info_str info;
- int retval = -EINVAL;
- os_lun_t *up;
- os_tgt_t *tq;
- unsigned int t, l;
- uint32_t tmp_sn;
- uint32_t *flags;
- uint8_t *loop_state;
- scsi_qla_host_t *ha;
- char fw_info[30];
-
- DEBUG3(printk(KERN_INFO
- "Entering proc_info buff_in=%p, offset=0x%lx, length=0x%x\n",
- buffer, offset, length);)
-
- ha = (scsi_qla_host_t *) shost->hostdata;
-
- if (inout) {
- /* Has data been written to the file? */
- DEBUG3(printk(
- "%s: has data been written to the file. \n",
- __func__);)
+ char name[16];
+ uint8_t status = 1;
+ int retry= 10;
- return -ENOSYS;
- }
+ do {
+ /*
+ * This will loop only once if everything goes well, else some
+ * number of retries will be performed to get around a kernel
+ * bug where available mem is not allocated until after a
+ * little delay and a retry.
+ */
+ ha->request_ring = dma_alloc_coherent(&ha->pdev->dev,
+ (ha->request_q_length + 1) * sizeof(request_t),
+ &ha->request_dma, GFP_KERNEL);
+ if (ha->request_ring == NULL) {
+ qla_printk(KERN_WARNING, ha,
+ "Memory Allocation failed - request_ring\n");
- if (start) {
- *start = buffer;
- }
+ qla2x00_mem_free(ha);
+ msleep(100);
- info.buffer = buffer;
- info.length = length;
- info.offset = offset;
- info.pos = 0;
-
- /* start building the print buffer */
- copy_info(&info,
- "QLogic PCI to Fibre Channel Host Adapter for %s:\n"
- " Firmware version %s, ",
- ha->model_number, qla2x00_get_fw_version_str(ha, fw_info));
-
- copy_info(&info, "Driver version %s\n", qla2x00_version_str);
-
- tmp_sn = ((ha->serial0 & 0x1f) << 16) | (ha->serial2 << 8) |
- ha->serial1;
- copy_info(&info, "ISP: %s, Serial# %c%05d\n",
- ha->brd_info->isp_name, ('A' + tmp_sn/100000), (tmp_sn%100000));
-
- copy_info(&info,
- "Request Queue = 0x%llx, Response Queue = 0x%llx\n",
- (unsigned long long)ha->request_dma,
- (unsigned long long)ha->response_dma);
-
- copy_info(&info,
- "Request Queue count = %d, Response Queue count = %d\n",
- ha->request_q_length, ha->response_q_length);
-
- copy_info(&info,
- "Total number of active commands = %ld\n",
- ha->actthreads);
-
- copy_info(&info,
- "Total number of interrupts = %ld\n",
- (long)ha->total_isr_cnt);
-
- copy_info(&info,
- " Device queue depth = 0x%x\n",
- (ql2xmaxqdepth == 0) ? 16 : ql2xmaxqdepth);
-
- copy_info(&info,
- "Number of free request entries = %d\n", ha->req_q_cnt);
-
- copy_info(&info,
- "Number of mailbox timeouts = %ld\n", ha->total_mbx_timeout);
-
- copy_info(&info,
- "Number of ISP aborts = %ld\n", ha->total_isp_aborts);
-
- copy_info(&info,
- "Number of loop resyncs = %ld\n", ha->total_loop_resync);
-
- copy_info(&info,
- "Number of retries for empty slots = %ld\n",
- qla2x00_stats.outarray_full);
-
- copy_info(&info,
- "Number of reqs in pending_q= %ld, retry_q= %d, "
- "done_q= %ld, scsi_retry_q= %d\n",
- ha->qthreads, ha->retry_q_cnt,
- ha->done_q_cnt, ha->scsi_retry_q_cnt);
-
-
- flags = (uint32_t *) &ha->flags;
-
- if (atomic_read(&ha->loop_state) == LOOP_DOWN) {
- loop_state = "DOWN";
- } else if (atomic_read(&ha->loop_state) == LOOP_UP) {
- loop_state = "UP";
- } else if (atomic_read(&ha->loop_state) == LOOP_READY) {
- loop_state = "READY";
- } else if (atomic_read(&ha->loop_state) == LOOP_TIMEOUT) {
- loop_state = "TIMEOUT";
- } else if (atomic_read(&ha->loop_state) == LOOP_UPDATE) {
- loop_state = "UPDATE";
- } else {
- loop_state = "UNKNOWN";
- }
-
- copy_info(&info,
- "Host adapter:loop state = <%s>, flags = 0x%lx\n",
- loop_state , *flags);
-
- copy_info(&info, "Dpc flags = 0x%lx\n", ha->dpc_flags);
-
- copy_info(&info, "MBX flags = 0x%x\n", ha->mbx_flags);
-
- copy_info(&info, "Link down Timeout = %3.3d\n",
- ha->link_down_timeout);
-
- copy_info(&info, "Port down retry = %3.3d\n",
- ha->port_down_retry_count);
-
- copy_info(&info, "Login retry count = %3.3d\n",
- ha->login_retry_count);
-
- copy_info(&info,
- "Commands retried with dropped frame(s) = %d\n",
- ha->dropped_frame_error_cnt);
-
- copy_info(&info,
- "Product ID = %04x %04x %04x %04x\n", ha->product_id[0],
- ha->product_id[1], ha->product_id[2], ha->product_id[3]);
-
- copy_info(&info, "\n");
-
- /* 2.25 node/port display to proc */
- /* Display the node name for adapter */
- copy_info(&info, "\nSCSI Device Information:\n");
- copy_info(&info,
- "scsi-qla%d-adapter-node="
- "%02x%02x%02x%02x%02x%02x%02x%02x;\n",
- (int)ha->instance,
- ha->init_cb->node_name[0],
- ha->init_cb->node_name[1],
- ha->init_cb->node_name[2],
- ha->init_cb->node_name[3],
- ha->init_cb->node_name[4],
- ha->init_cb->node_name[5],
- ha->init_cb->node_name[6],
- ha->init_cb->node_name[7]);
-
- /* display the port name for adapter */
- copy_info(&info,
- "scsi-qla%d-adapter-port="
- "%02x%02x%02x%02x%02x%02x%02x%02x;\n",
- (int)ha->instance,
- ha->init_cb->port_name[0],
- ha->init_cb->port_name[1],
- ha->init_cb->port_name[2],
- ha->init_cb->port_name[3],
- ha->init_cb->port_name[4],
- ha->init_cb->port_name[5],
- ha->init_cb->port_name[6],
- ha->init_cb->port_name[7]);
-
- /* Print out device port names */
- for (t = 0; t < MAX_FIBRE_DEVICES; t++) {
- if ((tq = TGT_Q(ha, t)) == NULL)
- continue;
-
- copy_info(&info,
- "scsi-qla%d-target-%d="
- "%02x%02x%02x%02x%02x%02x%02x%02x;\n",
- (int)ha->instance, t,
- tq->port_name[0], tq->port_name[1],
- tq->port_name[2], tq->port_name[3],
- tq->port_name[4], tq->port_name[5],
- tq->port_name[6], tq->port_name[7]);
- }
-
- copy_info(&info, "\nSCSI LUN Information:\n");
- copy_info(&info,
- "(Id:Lun) * - indicates lun is not registered with the OS.\n");
-
- /* scan for all equipment stats */
- for (t = 0; t < MAX_FIBRE_DEVICES; t++) {
- /* scan all luns */
- for (l = 0; l < ha->max_luns; l++) {
- up = (os_lun_t *) GET_LU_Q(ha, t, l);
-
- if (up == NULL) {
- continue;
- }
- if (up->fclun == NULL) {
- continue;
- }
-
- copy_info(&info,
- "(%2d:%2d): Total reqs %ld,",
- t,l,up->io_cnt);
-
- copy_info(&info,
- " Pending reqs %ld,",
- up->out_cnt);
-
- if (up->io_cnt < 4) {
- copy_info(&info,
- " flags 0x%x*,",
- (int)up->q_flag);
- } else {
- copy_info(&info,
- " flags 0x%x,",
- (int)up->q_flag);
- }
-
- copy_info(&info,
- " %ld:%d:%02x %02x",
- up->fclun->fcport->ha->instance,
- up->fclun->fcport->cur_path,
- up->fclun->fcport->loop_id,
- up->fclun->device_type);
-
- copy_info(&info, "\n");
-
- if (info.pos >= info.offset + info.length) {
- /* No need to continue */
- goto profile_stop;
- }
- }
-
- if (info.pos >= info.offset + info.length) {
- /* No need to continue */
- break;
- }
- }
-
-profile_stop:
-
- retval = info.pos > info.offset ? info.pos - info.offset : 0;
-
- DEBUG3(printk(KERN_INFO
- "Exiting proc_info: info.pos=%d, offset=0x%lx, "
- "length=0x%x\n", info.pos, offset, length);)
-
- return (retval);
-}
-
-/*
-* qla2x00_display_fc_names
-* This routine will the node names of the different devices found
-* after port inquiry.
-*
-* Input:
-* cmd = SCSI command structure
-*
-* Returns:
-* None.
-*/
-static void
-qla2x00_display_fc_names(scsi_qla_host_t *ha)
-{
- uint16_t tgt;
- os_tgt_t *tq;
-
- /* Display the node name for adapter */
- qla_printk(KERN_INFO, ha,
- "scsi-qla%d-adapter-node=%02x%02x%02x%02x%02x%02x%02x%02x\\;\n",
- (int)ha->instance,
- ha->init_cb->node_name[0],
- ha->init_cb->node_name[1],
- ha->init_cb->node_name[2],
- ha->init_cb->node_name[3],
- ha->init_cb->node_name[4],
- ha->init_cb->node_name[5],
- ha->init_cb->node_name[6],
- ha->init_cb->node_name[7]);
-
- /* display the port name for adapter */
- qla_printk(KERN_INFO, ha,
- "scsi-qla%d-adapter-port=%02x%02x%02x%02x%02x%02x%02x%02x\\;\n",
- (int)ha->instance,
- ha->init_cb->port_name[0],
- ha->init_cb->port_name[1],
- ha->init_cb->port_name[2],
- ha->init_cb->port_name[3],
- ha->init_cb->port_name[4],
- ha->init_cb->port_name[5],
- ha->init_cb->port_name[6],
- ha->init_cb->port_name[7]);
-
- /* Print out device port names */
- for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
- if ((tq = ha->otgt[tgt]) == NULL)
- continue;
-
- if (tq->fcport == NULL)
- continue;
-
- switch (ha->binding_type) {
- case BIND_BY_PORT_NAME:
- qla_printk(KERN_INFO, ha,
- "scsi-qla%d-tgt-%d-di-0-port="
- "%02x%02x%02x%02x%02x%02x%02x%02x\\;\n",
- (int)ha->instance,
- tgt,
- tq->port_name[0],
- tq->port_name[1],
- tq->port_name[2],
- tq->port_name[3],
- tq->port_name[4],
- tq->port_name[5],
- tq->port_name[6],
- tq->port_name[7]);
-
- break;
-
- case BIND_BY_PORT_ID:
- qla_printk(KERN_INFO, ha,
- "scsi-qla%d-tgt-%d-di-0-pid="
- "%02x%02x%02x\\;\n",
- (int)ha->instance,
- tgt,
- tq->d_id.b.domain,
- tq->d_id.b.area,
- tq->d_id.b.al_pa);
- break;
- }
-
-#if VSA
- qla_printk(KERN_INFO, ha,
- "scsi-qla%d-target-%d-vsa=01;\n", (int)ha->instance, tgt);
-#endif
- }
-}
-
-/*
- * qla2x00_suspend_lun
- * Suspend lun and start port down timer
- *
- * Input:
- * ha = visable adapter block pointer.
- * lq = lun queue
- * cp = Scsi command pointer
- * time = time in seconds
- * count = number of times to let time expire
- * delay_lun = non-zero, if lun should be delayed rather than suspended
- *
- * Return:
- * QLA_SUCCESS -- suspended lun
- * QLA_FUNCTION_FAILED -- Didn't suspend lun
- *
- * Context:
- * Interrupt context.
- */
-int
-__qla2x00_suspend_lun(scsi_qla_host_t *ha,
- os_lun_t *lq, int time, int count, int delay_lun)
-{
- int rval;
- srb_t *sp;
- struct list_head *list, *temp;
- unsigned long flags;
-
- rval = QLA_SUCCESS;
-
- /* if the lun_q is already suspended then don't do it again */
- if (lq->q_state == LUN_STATE_READY ||lq->q_state == LUN_STATE_RUN) {
-
- spin_lock_irqsave(&lq->q_lock, flags);
- if (lq->q_state == LUN_STATE_READY) {
- lq->q_max = count;
- lq->q_count = 0;
- }
- /* Set the suspend time usually 6 secs */
- atomic_set(&lq->q_timer, time);
-
- /* now suspend the lun */
- lq->q_state = LUN_STATE_WAIT;
-
- if (delay_lun) {
- set_bit(LUN_EXEC_DELAYED, &lq->q_flag);
- DEBUG(printk(KERN_INFO
- "scsi(%ld): Delay lun execution for %d secs, "
- "count=%d, max count=%d, state=%d\n",
- ha->host_no,
- time,
- lq->q_count, lq->q_max, lq->q_state));
- } else {
- DEBUG(printk(KERN_INFO
- "scsi(%ld): Suspend lun for %d secs, count=%d, "
- "max count=%d, state=%d\n",
- ha->host_no,
- time,
- lq->q_count, lq->q_max, lq->q_state));
- }
- spin_unlock_irqrestore(&lq->q_lock, flags);
-
- /*
- * Remove all pending commands from request queue and put them
- * in the scsi_retry queue.
- */
- spin_lock_irqsave(&ha->list_lock, flags);
- list_for_each_safe(list, temp, &ha->pending_queue) {
- sp = list_entry(list, srb_t, list);
- if (sp->lun_queue != lq)
- continue;
-
- __del_from_pending_queue(ha, sp);
-
- if (sp->cmd->allowed < count)
- sp->cmd->allowed = count;
- __add_to_scsi_retry_queue(ha, sp);
-
- } /* list_for_each_safe */
- spin_unlock_irqrestore(&ha->list_lock, flags);
- rval = QLA_SUCCESS;
- } else {
- rval = QLA_FUNCTION_FAILED;
- }
-
- return (rval);
-}
-
-/*
- * qla2x00_mark_device_lost Updates fcport state when device goes offline.
- *
- * Input: ha = adapter block pointer. fcport = port structure pointer.
- *
- * Return: None.
- *
- * Context:
- */
-void qla2x00_mark_device_lost(scsi_qla_host_t *ha, fc_port_t *fcport,
- int do_login)
-{
- /*
- * We may need to retry the login, so don't change the state of the
- * port but do the retries.
- */
- if (atomic_read(&fcport->state) != FCS_DEVICE_DEAD)
- atomic_set(&fcport->state, FCS_DEVICE_LOST);
-
- if (!do_login)
- return;
-
- if (fcport->login_retry == 0) {
- fcport->login_retry = ha->login_retry_count;
- set_bit(RELOGIN_NEEDED, &ha->dpc_flags);
-
- DEBUG(printk("scsi(%ld): Port login retry: "
- "%02x%02x%02x%02x%02x%02x%02x%02x, "
- "id = 0x%04x retry cnt=%d\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],
- fcport->loop_id,
- fcport->login_retry));
- }
-}
-
-/*
- * qla2x00_mark_all_devices_lost
- * Updates fcport state when device goes offline.
- *
- * Input:
- * ha = adapter block pointer.
- * fcport = port structure pointer.
- *
- * Return:
- * None.
- *
- * Context:
- */
-void
-qla2x00_mark_all_devices_lost(scsi_qla_host_t *ha)
-{
- fc_port_t *fcport;
-
- list_for_each_entry(fcport, &ha->fcports, list) {
- if (fcport->port_type != FCT_TARGET)
- continue;
-
- /*
- * No point in marking the device as lost, if the device is
- * already DEAD.
- */
- if (atomic_read(&fcport->state) == FCS_DEVICE_DEAD)
- continue;
-
- atomic_set(&fcport->state, FCS_DEVICE_LOST);
- }
-}
-
-/*
-* qla2x00_mem_alloc
-* Allocates adapter memory.
-*
-* Returns:
-* 0 = success.
-* 1 = failure.
-*/
-static uint8_t
-qla2x00_mem_alloc(scsi_qla_host_t *ha)
-{
- char name[16];
- uint8_t status = 1;
- int retry= 10;
-
- do {
- /*
- * This will loop only once if everything goes well, else some
- * number of retries will be performed to get around a kernel
- * bug where available mem is not allocated until after a
- * little delay and a retry.
- */
- ha->request_ring = dma_alloc_coherent(&ha->pdev->dev,
- (ha->request_q_length + 1) * sizeof(request_t),
- &ha->request_dma, GFP_KERNEL);
- if (ha->request_ring == NULL) {
- qla_printk(KERN_WARNING, ha,
- "Memory Allocation failed - request_ring\n");
-
- qla2x00_mem_free(ha);
- msleep(100);
-
- continue;
- }
+ continue;
+ }
ha->response_ring = dma_alloc_coherent(&ha->pdev->dev,
(ha->response_q_length + 1) * sizeof(response_t),
static void
qla2x00_mem_free(scsi_qla_host_t *ha)
{
- uint32_t t;
struct list_head *fcpl, *fcptemp;
fc_port_t *fcport;
- struct list_head *fcll, *fcltemp;
- fc_lun_t *fclun;
unsigned long wtime;/* max wait time if mbx cmd is busy. */
if (ha == NULL) {
return;
}
- /* Free the target queues */
- for (t = 0; t < MAX_TARGETS; t++) {
- qla2x00_tgt_free(ha, t);
- }
-
/* Make sure all other threads are stopped. */
wtime = 60 * HZ;
while (ha->dpc_wait && wtime) {
list_for_each_safe(fcpl, fcptemp, &ha->fcports) {
fcport = list_entry(fcpl, fc_port_t, list);
- /* fc luns */
- list_for_each_safe(fcll, fcltemp, &fcport->fcluns) {
- fclun = list_entry(fcll, fc_lun_t, list);
-
- list_del_init(&fclun->list);
- kfree(fclun);
- }
-
/* fc ports */
list_del_init(&fcport->list);
kfree(fcport);
DECLARE_MUTEX_LOCKED(sem);
scsi_qla_host_t *ha;
fc_port_t *fcport;
- os_lun_t *q;
- srb_t *sp;
uint8_t status;
- unsigned long flags = 0;
- struct list_head *list, *templist;
- int dead_cnt, online_cnt;
- int retry_cmds = 0;
uint16_t next_loopid;
- int t;
- os_tgt_t *tq;
ha = (scsi_qla_host_t *)data;
ha->dpc_active = 1;
- if (!list_empty(&ha->done_queue))
- qla2x00_done(ha);
-
- /* Process commands in retry queue */
- if (test_and_clear_bit(PORT_RESTART_NEEDED, &ha->dpc_flags)) {
- DEBUG(printk("scsi(%ld): DPC checking retry_q. "
- "total=%d\n",
- ha->host_no, ha->retry_q_cnt));
-
- spin_lock_irqsave(&ha->list_lock, flags);
- dead_cnt = online_cnt = 0;
- list_for_each_safe(list, templist, &ha->retry_queue) {
- sp = list_entry(list, srb_t, list);
- q = sp->lun_queue;
- DEBUG3(printk("scsi(%ld): pid=%ld sp=%p, "
- "spflags=0x%x, q_flag= 0x%lx\n",
- ha->host_no, sp->cmd->serial_number, sp,
- sp->flags, q->q_flag));
-
- if (q == NULL)
- continue;
- fcport = q->fclun->fcport;
-
- if (atomic_read(&fcport->state) ==
- FCS_DEVICE_DEAD ||
- atomic_read(&fcport->ha->loop_state) == LOOP_DEAD) {
-
- __del_from_retry_queue(ha, sp);
- sp->cmd->result = DID_NO_CONNECT << 16;
- if (atomic_read(&fcport->ha->loop_state) ==
- LOOP_DOWN)
- sp->err_id = SRB_ERR_LOOP;
- else
- sp->err_id = SRB_ERR_PORT;
- sp->cmd->host_scribble =
- (unsigned char *) NULL;
- __add_to_done_queue(ha, sp);
- dead_cnt++;
- } else if (atomic_read(&fcport->state) !=
- FCS_DEVICE_LOST) {
-
- __del_from_retry_queue(ha, sp);
- sp->cmd->result = DID_BUS_BUSY << 16;
- sp->cmd->host_scribble =
- (unsigned char *) NULL;
- __add_to_done_queue(ha, sp);
- online_cnt++;
- }
- } /* list_for_each_safe() */
- spin_unlock_irqrestore(&ha->list_lock, flags);
-
- DEBUG(printk("scsi(%ld): done processing retry queue "
- "- dead=%d, online=%d\n ",
- ha->host_no, dead_cnt, online_cnt));
- }
-
- /* Process commands in scsi retry queue */
- if (test_and_clear_bit(SCSI_RESTART_NEEDED, &ha->dpc_flags)) {
- /*
- * Any requests we want to delay for some period is put
- * in the scsi retry queue with a delay added. The
- * timer will schedule a "scsi_restart_needed" every
- * second as long as there are requests in the scsi
- * queue.
- */
- DEBUG(printk("scsi(%ld): DPC checking scsi "
- "retry_q.total=%d\n",
- ha->host_no, ha->scsi_retry_q_cnt));
-
- online_cnt = 0;
- spin_lock_irqsave(&ha->list_lock, flags);
- list_for_each_safe(list, templist,
- &ha->scsi_retry_queue) {
-
- sp = list_entry(list, srb_t, list);
- q = sp->lun_queue;
- tq = sp->tgt_queue;
-
- DEBUG3(printk("scsi(%ld): scsi_retry_q: "
- "pid=%ld sp=%p, spflags=0x%x, "
- "q_flag= 0x%lx,q_state=%d\n",
- ha->host_no, sp->cmd->serial_number,
- sp, sp->flags, q->q_flag, q->q_state));
-
- /* Was this lun suspended */
- if (q->q_state != LUN_STATE_WAIT) {
- online_cnt++;
- __del_from_scsi_retry_queue(ha, sp);
-
- if (test_bit(TQF_RETRY_CMDS,
- &tq->flags)) {
- qla2x00_extend_timeout(sp->cmd,
- (sp->cmd->timeout_per_command / HZ) - QLA_CMD_TIMER_DELTA);
- __add_to_pending_queue(ha, sp);
- retry_cmds++;
- } else
- __add_to_retry_queue(ha, sp);
- }
-
- /* Was this command suspended for N secs */
- if (sp->delay != 0) {
- sp->delay--;
- if (sp->delay == 0) {
- online_cnt++;
- __del_from_scsi_retry_queue(
- ha, sp);
- __add_to_retry_queue(ha,sp);
- }
- }
- }
- spin_unlock_irqrestore(&ha->list_lock, flags);
-
- /* Clear all Target Unsuspended bits */
- for (t = 0; t < ha->max_targets; t++) {
- if ((tq = ha->otgt[t]) == NULL)
- continue;
-
- if (test_bit(TQF_RETRY_CMDS, &tq->flags))
- clear_bit(TQF_RETRY_CMDS, &tq->flags);
- }
- if (retry_cmds)
- qla2x00_next(ha);
-
- DEBUG(if (online_cnt > 0))
- DEBUG(printk("scsi(%ld): dpc() found scsi reqs to "
- "restart= %d\n",
- ha->host_no, online_cnt));
- }
-
if (ha->flags.mbox_busy) {
- if (!list_empty(&ha->done_queue))
- qla2x00_done(ha);
-
ha->dpc_active = 0;
continue;
}
ha->host_no));
}
+ if (test_and_clear_bit(FCPORT_RESCAN_NEEDED, &ha->dpc_flags)) {
- if (test_bit(RESTART_QUEUES_NEEDED, &ha->dpc_flags)) {
- DEBUG(printk("scsi(%ld): qla2x00_restart_queues()\n",
+ DEBUG(printk("scsi(%ld): Rescan flagged fcports...\n",
ha->host_no));
- qla2x00_restart_queues(ha, 0);
+ qla2x00_rescan_fcports(ha);
- DEBUG(printk("scsi(%ld): qla2x00_restart_queues - end\n",
+ DEBUG(printk("scsi(%ld): Rescan flagged fcports..."
+ "end.\n",
ha->host_no));
}
- if (test_bit(ABORT_QUEUES_NEEDED, &ha->dpc_flags)) {
-
- DEBUG(printk("scsi(%ld): qla2x00_abort_queues()\n",
- ha->host_no));
-
- qla2x00_abort_queues(ha, 0);
-
- DEBUG(printk("scsi(%ld): qla2x00_abort_queues - end\n",
- ha->host_no));
- }
-
- if (test_and_clear_bit(FCPORT_RESCAN_NEEDED, &ha->dpc_flags)) {
-
- DEBUG(printk("scsi(%ld): Rescan flagged fcports...\n",
- ha->host_no));
-
- qla2x00_rescan_fcports(ha);
-
- DEBUG(printk("scsi(%ld): Rescan flagged fcports..."
- "end.\n",
- ha->host_no));
- }
-
-
- if (!ha->interrupts_on)
- qla2x00_enable_intrs(ha);
-
- if (!list_empty(&ha->done_queue))
- qla2x00_done(ha);
+ if (!ha->interrupts_on)
+ qla2x00_enable_intrs(ha);
ha->dpc_active = 0;
} /* End of while(1) */
complete_and_exit(&ha->dpc_exited, 0);
}
-/*
- * qla2x00_abort_queues
- * Abort all commands on queues on device
- *
- * Input:
- * ha = adapter block pointer.
- *
- * Context:
- * Interrupt context.
- */
-void
-qla2x00_abort_queues(scsi_qla_host_t *ha, uint8_t doneqflg)
-{
-
- srb_t *sp;
- struct list_head *list, *temp;
- unsigned long flags;
-
- clear_bit(ABORT_QUEUES_NEEDED, &ha->dpc_flags);
-
- /* Return all commands device queues. */
- spin_lock_irqsave(&ha->list_lock,flags);
- list_for_each_safe(list, temp, &ha->pending_queue) {
- sp = list_entry(list, srb_t, list);
-
- if (sp->flags & SRB_ABORTED)
- continue;
-
- /* Remove srb from LUN queue. */
- __del_from_pending_queue(ha, sp);
-
- /* Set ending status. */
- sp->cmd->result = DID_BUS_BUSY << 16;
-
- __add_to_done_queue(ha, sp);
- }
- spin_unlock_irqrestore(&ha->list_lock, flags);
-}
-
/*
* qla2x00_rst_aen
* Processes asynchronous reset.
return (sp);
}
+static void
+qla2x00_sp_free_dma(scsi_qla_host_t *ha, srb_t *sp)
+{
+ struct scsi_cmnd *cmd = sp->cmd;
+
+ if (sp->flags & SRB_DMA_VALID) {
+ if (cmd->use_sg) {
+ dma_unmap_sg(&ha->pdev->dev, cmd->request_buffer,
+ cmd->use_sg, cmd->sc_data_direction);
+ } else if (cmd->request_bufflen) {
+ dma_unmap_single(&ha->pdev->dev, sp->dma_handle,
+ cmd->request_bufflen, cmd->sc_data_direction);
+ }
+ sp->flags &= ~SRB_DMA_VALID;
+ }
+}
+
+void
+qla2x00_sp_compl(scsi_qla_host_t *ha, srb_t *sp)
+{
+ struct scsi_cmnd *cmd = sp->cmd;
+
+ qla2x00_sp_free_dma(ha, sp);
+
+ CMD_SP(cmd) = NULL;
+ mempool_free(sp, ha->srb_mempool);
+
+ cmd->scsi_done(cmd);
+}
+
/**************************************************************************
* qla2x00_timer
*
static void
qla2x00_timer(scsi_qla_host_t *ha)
{
- int t,l;
unsigned long cpu_flags = 0;
fc_port_t *fcport;
- os_lun_t *lq;
- os_tgt_t *tq;
int start_dpc = 0;
int index;
srb_t *sp;
-
- /*
- * We try and restart any request in the retry queue every second.
- */
- if (!list_empty(&ha->retry_queue)) {
- set_bit(PORT_RESTART_NEEDED, &ha->dpc_flags);
- start_dpc++;
- }
-
- /*
- * We try and restart any request in the scsi_retry queue every second.
- */
- if (!list_empty(&ha->scsi_retry_queue)) {
- set_bit(SCSI_RESTART_NEEDED, &ha->dpc_flags);
- start_dpc++;
- }
+ int t;
/*
* Ports - Port down timer.
t++;
} /* End of for fcport */
- /*
- * LUNS - lun suspend timer.
- *
- * Whenever, a lun is suspended the timer starts decrementing its
- * suspend timer every second until it reaches zero. Once it reaches
- * zero the lun retry count is decremented.
- */
-
- /*
- * FIXME(dg) - Need to convert this linear search of luns into a search
- * of a list of suspended luns.
- */
- for (t = 0; t < ha->max_targets; t++) {
- if ((tq = ha->otgt[t]) == NULL)
- continue;
-
- for (l = 0; l < ha->max_luns; l++) {
- if ((lq = (os_lun_t *) tq->olun[l]) == NULL)
- continue;
-
- spin_lock_irqsave(&lq->q_lock, cpu_flags);
- if (lq->q_state == LUN_STATE_WAIT &&
- atomic_read(&lq->q_timer) != 0) {
-
- if (atomic_dec_and_test(&lq->q_timer) != 0) {
- /*
- * A delay should immediately
- * transition to a READY state
- */
- if (test_and_clear_bit(LUN_EXEC_DELAYED,
- &lq->q_flag)) {
- lq->q_state = LUN_STATE_READY;
- }
- else {
- lq->q_count++;
- if (lq->q_count == lq->q_max)
- lq->q_state =
- LUN_STATE_TIMEOUT;
- else
- lq->q_state =
- LUN_STATE_RUN;
- }
- }
- DEBUG3(printk("scsi(%ld): lun%d - timer %d, "
- "count=%d, max=%d, state=%d\n",
- ha->host_no,
- l,
- atomic_read(&lq->q_timer),
- lq->q_count, lq->q_max, lq->q_state));
- }
- spin_unlock_irqrestore(&lq->q_lock, cpu_flags);
- } /* End of for luns */
- } /* End of for targets */
/* Loop down handler. */
if (atomic_read(&ha->loop_down_timer) > 0 &&
spin_lock_irqsave(&ha->hardware_lock, cpu_flags);
for (index = 1; index < MAX_OUTSTANDING_COMMANDS;
index++) {
+ fc_port_t *sfcp;
+
sp = ha->outstanding_cmds[index];
if (!sp)
continue;
- if (!(sp->fclun->fcport->flags &
- FCF_TAPE_PRESENT))
+ sfcp = sp->fcport;
+ if (!(sfcp->flags & FCF_TAPE_PRESENT))
continue;
set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
atomic_read(&ha->loop_down_timer)));
}
- /*
- * Done Q Handler -- dgFIXME This handler will kick off doneq if we
- * haven't process it in 2 seconds.
- */
- if (!list_empty(&ha->done_queue))
- qla2x00_done(ha);
-
-
/* Schedule the DPC routine if needed */
if ((test_bit(ISP_ABORT_NEEDED, &ha->dpc_flags) ||
test_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags) ||
start_dpc ||
test_bit(LOGIN_RETRY_NEEDED, &ha->dpc_flags) ||
+ test_bit(RESET_MARKER_NEEDED, &ha->dpc_flags) ||
test_bit(RELOGIN_NEEDED, &ha->dpc_flags)) &&
ha->dpc_wait && !ha->dpc_active) {
qla2x00_restart_timer(ha, WATCH_INTERVAL);
}
-/*
- * qla2x00_extend_timeout
- * This routine will extend the timeout to the specified value.
- *
- * Input:
- * cmd = SCSI command structure
- *
- * Returns:
- * None.
- */
-void
-qla2x00_extend_timeout(struct scsi_cmnd *cmd, int timeout)
-{
- srb_t *sp = (srb_t *) CMD_SP(cmd);
- u_long our_jiffies = (timeout * HZ) + jiffies;
-
- sp->ext_history= 0;
- sp->e_start = jiffies;
- if (cmd->eh_timeout.function) {
- mod_timer(&cmd->eh_timeout,our_jiffies);
- sp->ext_history |= 1;
- }
- if (sp->timer.function != NULL) {
- /*
- * Our internal timer should timeout before the midlayer has a
- * chance begin the abort process
- */
- mod_timer(&sp->timer,our_jiffies - (QLA_CMD_TIMER_DELTA * HZ));
-
- sp->ext_history |= 2;
- }
-}
-
-/**************************************************************************
-* qla2x00_cmd_timeout
-*
-* Description:
-* Handles the command if it times out in any state.
-*
-* Input:
-* sp - pointer to validate
-*
-* Returns:
-* None.
-* Note:Need to add the support for if( sp->state == SRB_FAILOVER_STATE).
-**************************************************************************/
-void
-qla2x00_cmd_timeout(srb_t *sp)
-{
- int t, l;
- int processed;
- scsi_qla_host_t *vis_ha, *dest_ha;
- struct scsi_cmnd *cmd;
- unsigned long flags, cpu_flags;
- fc_port_t *fcport;
-
- cmd = sp->cmd;
- vis_ha = (scsi_qla_host_t *)cmd->device->host->hostdata;
-
- DEBUG3(printk("cmd_timeout: Entering sp->state = %x\n", sp->state));
-
- t = cmd->device->id;
- l = cmd->device->lun;
- fcport = sp->fclun->fcport;
- dest_ha = sp->ha;
-
- /*
- * If IO is found either in retry Queue
- * OR in Lun Queue
- * Return this IO back to host
- */
- spin_lock_irqsave(&vis_ha->list_lock, flags);
- processed = 0;
- if (sp->state == SRB_PENDING_STATE) {
- __del_from_pending_queue(vis_ha, sp);
- DEBUG2(printk("scsi(%ld): Found in Pending queue pid %ld, "
- "State = %x., fcport state=%d sjiffs=%lx njiffs=%lx\n",
- vis_ha->host_no, cmd->serial_number, sp->state,
- atomic_read(&fcport->state), sp->r_start, jiffies));
-
- /*
- * If FC_DEVICE is marked as dead return the cmd with
- * DID_NO_CONNECT status. Otherwise set the host_byte to
- * DID_BUS_BUSY to let the OS retry this cmd.
- */
- if (atomic_read(&fcport->state) == FCS_DEVICE_DEAD ||
- atomic_read(&fcport->ha->loop_state) == LOOP_DEAD) {
- cmd->result = DID_NO_CONNECT << 16;
- if (atomic_read(&fcport->ha->loop_state) == LOOP_DOWN)
- sp->err_id = SRB_ERR_LOOP;
- else
- sp->err_id = SRB_ERR_PORT;
- } else {
- cmd->result = DID_BUS_BUSY << 16;
- }
- __add_to_done_queue(vis_ha, sp);
- processed++;
- }
- spin_unlock_irqrestore(&vis_ha->list_lock, flags);
-
- if (processed) {
- qla2x00_done(vis_ha);
- return;
- }
-
- spin_lock_irqsave(&dest_ha->list_lock, flags);
- if ((sp->state == SRB_RETRY_STATE) ||
- (sp->state == SRB_SCSI_RETRY_STATE)) {
-
- DEBUG2(printk("scsi(%ld): Found in (Scsi) Retry queue or "
- "failover Q pid %ld, State = %x., fcport state=%d "
- "jiffies=%lx retried=%d\n",
- dest_ha->host_no, cmd->serial_number, sp->state,
- atomic_read(&fcport->state), jiffies, cmd->retries));
-
- if ((sp->state == SRB_RETRY_STATE)) {
- __del_from_retry_queue(dest_ha, sp);
- } else if ((sp->state == SRB_SCSI_RETRY_STATE)) {
- __del_from_scsi_retry_queue(dest_ha, sp);
- }
-
- /*
- * If FC_DEVICE is marked as dead return the cmd with
- * DID_NO_CONNECT status. Otherwise set the host_byte to
- * DID_BUS_BUSY to let the OS retry this cmd.
- */
- if ((atomic_read(&fcport->state) == FCS_DEVICE_DEAD) ||
- atomic_read(&dest_ha->loop_state) == LOOP_DEAD) {
- qla2x00_extend_timeout(cmd, EXTEND_CMD_TIMEOUT);
- cmd->result = DID_NO_CONNECT << 16;
- if (atomic_read(&dest_ha->loop_state) == LOOP_DOWN)
- sp->err_id = SRB_ERR_LOOP;
- else
- sp->err_id = SRB_ERR_PORT;
- } else {
- cmd->result = DID_BUS_BUSY << 16;
- }
-
- __add_to_done_queue(dest_ha, sp);
- processed++;
- }
- spin_unlock_irqrestore(&dest_ha->list_lock, flags);
-
- if (processed) {
- qla2x00_done(dest_ha);
- return;
- }
-
- spin_lock_irqsave(&dest_ha->list_lock, cpu_flags);
- if (sp->state == SRB_DONE_STATE) {
- /* IO in done_q -- leave it */
- DEBUG(printk("scsi(%ld): Found in Done queue pid %ld sp=%p.\n",
- dest_ha->host_no, cmd->serial_number, sp));
- } else if (sp->state == SRB_SUSPENDED_STATE) {
- DEBUG(printk("scsi(%ld): Found SP %p in suspended state "
- "- pid %ld:\n",
- dest_ha->host_no, sp, cmd->serial_number));
- DEBUG(qla2x00_dump_buffer((uint8_t *)sp, sizeof(srb_t));)
- } else if (sp->state == SRB_ACTIVE_STATE) {
- /*
- * IO is with ISP find the command in our active list.
- */
- spin_unlock_irqrestore(&dest_ha->list_lock, cpu_flags);
- spin_lock_irqsave(&dest_ha->hardware_lock, flags);
- if (sp == dest_ha->outstanding_cmds[
- (unsigned long)sp->cmd->host_scribble]) {
-
- DEBUG(printk("cmd_timeout: Found in ISP \n"));
-
- if (sp->flags & SRB_TAPE) {
- /*
- * We cannot allow the midlayer error handler
- * to wakeup and begin the abort process.
- * Extend the timer so that the firmware can
- * properly return the IOCB.
- */
- DEBUG(printk("cmd_timeout: Extending timeout "
- "of FCP2 tape command!\n"));
- qla2x00_extend_timeout(sp->cmd,
- EXTEND_CMD_TIMEOUT);
- }
- sp->state = SRB_ACTIVE_TIMEOUT_STATE;
- spin_unlock_irqrestore(&dest_ha->hardware_lock, flags);
- } else {
- spin_unlock_irqrestore(&dest_ha->hardware_lock, flags);
- printk(KERN_INFO
- "qla_cmd_timeout: State indicates it is with "
- "ISP, But not in active array\n");
- }
- spin_lock_irqsave(&dest_ha->list_lock, cpu_flags);
- } else if (sp->state == SRB_ACTIVE_TIMEOUT_STATE) {
- DEBUG(printk("qla2100%ld: Found in Active timeout state"
- "pid %ld, State = %x., \n",
- dest_ha->host_no,
- sp->cmd->serial_number, sp->state);)
- } else {
- /* EMPTY */
- DEBUG2(printk("cmd_timeout%ld: LOST command state = "
- "0x%x, sp=%p\n",
- vis_ha->host_no, sp->state,sp);)
-
- qla_printk(KERN_INFO, vis_ha,
- "cmd_timeout: LOST command state = 0x%x\n", sp->state);
- }
- spin_unlock_irqrestore(&dest_ha->list_lock, cpu_flags);
-
- DEBUG3(printk("cmd_timeout: Leaving\n");)
-}
-
-/**************************************************************************
-* qla2x00_done
-* Process completed commands.
-*
-* Input:
-* old_ha = adapter block pointer.
-*
-**************************************************************************/
-void
-qla2x00_done(scsi_qla_host_t *old_ha)
-{
- os_lun_t *lq;
- struct scsi_cmnd *cmd;
- unsigned long flags = 0;
- scsi_qla_host_t *ha;
- scsi_qla_host_t *vis_ha;
- int send_marker_once = 0;
- srb_t *sp, *sptemp;
- LIST_HEAD(local_sp_list);
-
- /*
- * Get into local queue such that we do not wind up calling done queue
- * tasklet for the same IOs from DPC or any other place.
- */
- spin_lock_irqsave(&old_ha->list_lock, flags);
- list_splice_init(&old_ha->done_queue, &local_sp_list);
- spin_unlock_irqrestore(&old_ha->list_lock, flags);
-
- /*
- * All done commands are in the local queue, now do the call back.
- */
- list_for_each_entry_safe(sp, sptemp, &local_sp_list, list) {
- old_ha->done_q_cnt--;
- sp->state = SRB_NO_QUEUE_STATE;
-
- /* remove command from local list */
- list_del_init(&sp->list);
-
- cmd = sp->cmd;
- if (cmd == NULL)
- continue;
-
- vis_ha = (scsi_qla_host_t *)cmd->device->host->hostdata;
- lq = sp->lun_queue;
- ha = sp->ha;
-
- if (sp->flags & SRB_DMA_VALID) {
- sp->flags &= ~SRB_DMA_VALID;
-
- /* Release memory used for this I/O */
- if (cmd->use_sg) {
- pci_unmap_sg(ha->pdev, cmd->request_buffer,
- cmd->use_sg, cmd->sc_data_direction);
- } else if (cmd->request_bufflen) {
- pci_unmap_page(ha->pdev, sp->dma_handle,
- cmd->request_bufflen,
- cmd->sc_data_direction);
- }
- }
-
-
- switch (host_byte(cmd->result)) {
- case DID_OK:
- case DID_ERROR:
- break;
-
- case DID_RESET:
- /*
- * Set marker needed, so we don't have to
- * send multiple markers
- */
- if (!send_marker_once) {
- ha->marker_needed = 1;
- send_marker_once++;
- }
-
- /*
- * WORKAROUND
- *
- * A backdoor device-reset requires different
- * error handling. This code differentiates
- * between normal error handling and the
- * backdoor method.
- *
- */
- if (ha->host->eh_active != EH_ACTIVE)
- cmd->result = DID_BUS_BUSY << 16;
- break;
-
-
- case DID_ABORT:
- sp->flags &= ~SRB_ABORT_PENDING;
- sp->flags |= SRB_ABORTED;
-
- if (sp->flags & SRB_TIMEOUT)
- cmd->result = DID_TIME_OUT << 16;
-
- break;
-
- default:
- DEBUG2(printk("scsi(%ld:%d:%d) %s: did_error "
- "= %d, comp-scsi= 0x%x-0x%x pid=%ld.\n",
- vis_ha->host_no,
- cmd->device->id, cmd->device->lun,
- __func__,
- host_byte(cmd->result),
- CMD_COMPL_STATUS(cmd),
- CMD_SCSI_STATUS(cmd), cmd->serial_number));
- break;
- }
-
- /*
- * Call the mid-level driver interrupt handler -- via sp_put()
- */
- sp_put(ha, sp);
- } /* end of while */
-}
-
-/*
- * qla2x00_process_response_queue_in_zio_mode
- * Process response queue completion as fast as possible
- * to achieve Zero Interrupt Opertions-ZIO
- *
- * Input:
- * ha = adapter block pointer.
- *
- * Context:
- * Kernel context.
- */
-static inline void
-qla2x00_process_response_queue_in_zio_mode(scsi_qla_host_t *ha)
-{
- unsigned long flags;
-
- /* Check for unprocessed commands in response queue. */
- if (!ha->flags.process_response_queue)
- return;
- if (!ha->flags.online)
- return;
- if (ha->response_ring_ptr->signature == RESPONSE_PROCESSED)
- return;
-
- spin_lock_irqsave(&ha->hardware_lock,flags);
- qla2x00_process_response_queue(ha);
- spin_unlock_irqrestore(&ha->hardware_lock, flags);
-}
-
-/*
- * qla2x00_next
- * Retrieve and process next job in the LUN queue.
- *
- * Input:
- * tq = SCSI target queue pointer.
- * lq = SCSI LUN queue pointer.
- * TGT_LOCK must be already obtained.
- *
- * Output:
- * Releases TGT_LOCK upon exit.
- *
- * Context:
- * Kernel/Interrupt context.
- *
- * Note: This routine will always try to start I/O from visible HBA.
- */
-void
-qla2x00_next(scsi_qla_host_t *vis_ha)
-{
- int rval;
- unsigned long flags;
- scsi_qla_host_t *dest_ha;
- fc_port_t *fcport;
- srb_t *sp, *sptemp;
- LIST_HEAD(local_sp_list);
-
- dest_ha = NULL;
-
- spin_lock_irqsave(&vis_ha->list_lock, flags);
- list_splice_init(&vis_ha->pending_queue, &local_sp_list);
- vis_ha->qthreads = 0;
- spin_unlock_irqrestore(&vis_ha->list_lock, flags);
-
- list_for_each_entry_safe(sp, sptemp, &local_sp_list, list) {
- list_del_init(&sp->list);
- sp->state = SRB_NO_QUEUE_STATE;
-
- fcport = sp->fclun->fcport;
- dest_ha = fcport->ha;
-
- /* If device is dead then send request back to OS */
- if (atomic_read(&fcport->state) == FCS_DEVICE_DEAD) {
- sp->cmd->result = DID_NO_CONNECT << 16;
- if (atomic_read(&dest_ha->loop_state) == LOOP_DOWN)
- sp->err_id = SRB_ERR_LOOP;
- else
- sp->err_id = SRB_ERR_PORT;
-
- DEBUG3(printk("scsi(%ld): loop/port is down - pid=%ld, "
- "sp=%p err_id=%d loopid=0x%x queued to dest HBA "
- "scsi%ld.\n", dest_ha->host_no,
- sp->cmd->serial_number, sp, sp->err_id,
- fcport->loop_id, dest_ha->host_no));
- /*
- * Initiate a failover - done routine will initiate.
- */
- add_to_done_queue(vis_ha, sp);
-
- continue;
- }
-
- /*
- * SCSI Kluge: Whenever, we need to wait for an event such as
- * loop down (i.e. loop_down_timer ) or port down (i.e. LUN
- * request qeueue is suspended) then we will recycle new
- * commands back to the SCSI layer. We do this because this is
- * normally a temporary condition and we don't want the
- * mid-level scsi.c driver to get upset and start aborting
- * commands. The timeout value is extracted from the command
- * minus 1-second and put on a retry queue (watchdog). Once the
- * command timeout it is returned to the mid-level with a BUSY
- * status, so the mid-level will retry it. This process
- * continues until the LOOP DOWN time expires or the condition
- * goes away.
- */
- if (!(sp->flags & (SRB_IOCTL | SRB_TAPE)) &&
- (atomic_read(&fcport->state) != FCS_ONLINE ||
- test_bit(ABORT_ISP_ACTIVE, &dest_ha->dpc_flags) ||
- atomic_read(&dest_ha->loop_state) != LOOP_READY)) {
-
- DEBUG3(printk("scsi(%ld): pid=%ld port=0x%x state=%d "
- "loop state=%d, loop counter=0x%x "
- "dpc_flags=0x%lx\n", sp->cmd->serial_number,
- dest_ha->host_no, fcport->loop_id,
- atomic_read(&fcport->state),
- atomic_read(&dest_ha->loop_state),
- atomic_read(&dest_ha->loop_down_timer),
- dest_ha->dpc_flags));
-
- qla2x00_extend_timeout(sp->cmd, EXTEND_CMD_TIMEOUT);
- add_to_retry_queue(vis_ha, sp);
-
- continue;
- }
-
- /*
- * If this request's lun is suspended then put the request on
- * the scsi_retry queue.
- */
- if (!(sp->flags & (SRB_IOCTL | SRB_TAPE)) &&
- sp->lun_queue->q_state == LUN_STATE_WAIT) {
- DEBUG3(printk("scsi(%ld): lun wait state - pid=%ld, "
- "opcode=%d, allowed=%d, retries=%d\n",
- dest_ha->host_no,
- sp->cmd->serial_number,
- sp->cmd->cmnd[0],
- sp->cmd->allowed,
- sp->cmd->retries));
-
- add_to_scsi_retry_queue(vis_ha, sp);
-
- continue;
- }
-
- sp->lun_queue->io_cnt++;
-
- rval = qla2x00_start_scsi(sp);
- if (rval != QLA_SUCCESS) {
- /* Place request back on top of device queue */
- /* add to the top of queue */
- add_to_pending_queue_head(vis_ha, sp);
-
- sp->lun_queue->io_cnt--;
- }
- }
-
- if (!IS_QLA2100(vis_ha) && !IS_QLA2200(vis_ha)) {
- /* Process response_queue if ZIO support is enabled*/
- qla2x00_process_response_queue_in_zio_mode(vis_ha);
-
- }
-}
-
/* XXX(hch): crude hack to emulate a down_timeout() */
int
qla2x00_down_timeout(struct semaphore *sema, unsigned long timeout)
return -ETIMEDOUT;
}
-static void
-qla2xxx_get_port_id(struct scsi_target *starget)
-{
- struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
- scsi_qla_host_t *ha = to_qla_host(shost);
- struct fc_port *fc;
-
- list_for_each_entry(fc, &ha->fcports, list) {
- if (fc->os_target_id == starget->id) {
- fc_starget_port_id(starget) = fc->d_id.b.domain << 16 |
- fc->d_id.b.area << 8 |
- fc->d_id.b.al_pa;
- return;
- }
- }
- fc_starget_port_id(starget) = -1;
-}
-
-static void
-qla2xxx_get_port_name(struct scsi_target *starget)
-{
- struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
- scsi_qla_host_t *ha = to_qla_host(shost);
- struct fc_port *fc;
-
- list_for_each_entry(fc, &ha->fcports, list) {
- if (fc->os_target_id == starget->id) {
- fc_starget_port_name(starget) =
- __be64_to_cpu(*(uint64_t *)fc->port_name);
- return;
- }
- }
- fc_starget_port_name(starget) = -1;
-}
-
-static void
-qla2xxx_get_node_name(struct scsi_target *starget)
-{
- struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
- scsi_qla_host_t *ha = to_qla_host(shost);
- struct fc_port *fc;
-
- list_for_each_entry(fc, &ha->fcports, list) {
- if (fc->os_target_id == starget->id) {
- fc_starget_node_name(starget) =
- __be64_to_cpu(*(uint64_t *)fc->node_name);
- return;
- }
- }
- fc_starget_node_name(starget) = -1;
-}
-
-static struct fc_function_template qla2xxx_transport_functions = {
- .get_starget_port_id = qla2xxx_get_port_id,
- .show_starget_port_id = 1,
- .get_starget_port_name = qla2xxx_get_port_name,
- .show_starget_port_name = 1,
- .get_starget_node_name = qla2xxx_get_node_name,
- .show_starget_node_name = 1,
-};
-
/**
* qla2x00_module_init - Module initialization.
**/
#if DEBUG_QLA2100
strcat(qla2x00_version_str, "-debug");
#endif
-
- qla2xxx_transport_template = fc_attach_transport(&qla2xxx_transport_functions);
+ qla2xxx_transport_template =
+ fc_attach_transport(&qla2xxx_transport_functions);
if (!qla2xxx_transport_template)
return -ENODEV;
git://git.onelab.eu / linux-2.6.git / blobdiff