2 * QLogic Fibre Channel HBA Driver
3 * Copyright (c) 2003-2008 QLogic Corporation
5 * See LICENSE.qla2xxx for copyright and licensing details.
9 #include <linux/moduleparam.h>
10 #include <linux/vmalloc.h>
11 #include <linux/delay.h>
12 #include <linux/kthread.h>
13 #include <linux/mutex.h>
15 #include <scsi/scsi_tcq.h>
16 #include <scsi/scsicam.h>
17 #include <scsi/scsi_transport.h>
18 #include <scsi/scsi_transport_fc.h>
23 char qla2x00_version_str
[40];
26 * SRB allocation cache
28 static struct kmem_cache
*srb_cachep
;
30 int ql2xlogintimeout
= 20;
31 module_param(ql2xlogintimeout
, int, S_IRUGO
|S_IRUSR
);
32 MODULE_PARM_DESC(ql2xlogintimeout
,
33 "Login timeout value in seconds.");
35 int qlport_down_retry
;
36 module_param(qlport_down_retry
, int, S_IRUGO
|S_IRUSR
);
37 MODULE_PARM_DESC(qlport_down_retry
,
38 "Maximum number of command retries to a port that returns "
39 "a PORT-DOWN status.");
41 int ql2xplogiabsentdevice
;
42 module_param(ql2xplogiabsentdevice
, int, S_IRUGO
|S_IWUSR
);
43 MODULE_PARM_DESC(ql2xplogiabsentdevice
,
44 "Option to enable PLOGI to devices that are not present after "
45 "a Fabric scan. This is needed for several broken switches. "
46 "Default is 0 - no PLOGI. 1 - perfom PLOGI.");
48 int ql2xloginretrycount
= 0;
49 module_param(ql2xloginretrycount
, int, S_IRUGO
|S_IRUSR
);
50 MODULE_PARM_DESC(ql2xloginretrycount
,
51 "Specify an alternate value for the NVRAM login retry count.");
53 int ql2xallocfwdump
= 1;
54 module_param(ql2xallocfwdump
, int, S_IRUGO
|S_IRUSR
);
55 MODULE_PARM_DESC(ql2xallocfwdump
,
56 "Option to enable allocation of memory for a firmware dump "
57 "during HBA initialization. Memory allocation requirements "
58 "vary by ISP type. Default is 1 - allocate memory.");
60 int ql2xextended_error_logging
;
61 module_param(ql2xextended_error_logging
, int, S_IRUGO
|S_IWUSR
);
62 MODULE_PARM_DESC(ql2xextended_error_logging
,
63 "Option to enable extended error logging, "
64 "Default is 0 - no logging. 1 - log errors.");
66 static void qla2x00_free_device(scsi_qla_host_t
*);
69 module_param(ql2xfdmienable
, int, S_IRUGO
|S_IRUSR
);
70 MODULE_PARM_DESC(ql2xfdmienable
,
71 "Enables FDMI registratons "
72 "Default is 0 - no FDMI. 1 - perfom FDMI.");
74 #define MAX_Q_DEPTH 32
75 static int ql2xmaxqdepth
= MAX_Q_DEPTH
;
76 module_param(ql2xmaxqdepth
, int, S_IRUGO
|S_IWUSR
);
77 MODULE_PARM_DESC(ql2xmaxqdepth
,
78 "Maximum queue depth to report for target devices.");
80 int ql2xqfullrampup
= 120;
81 module_param(ql2xqfullrampup
, int, S_IRUGO
|S_IWUSR
);
82 MODULE_PARM_DESC(ql2xqfullrampup
,
83 "Number of seconds to wait to begin to ramp-up the queue "
84 "depth for a device after a queue-full condition has been "
85 "detected. Default is 120 seconds.");
87 int ql2xiidmaenable
=1;
88 module_param(ql2xiidmaenable
, int, S_IRUGO
|S_IRUSR
);
89 MODULE_PARM_DESC(ql2xiidmaenable
,
90 "Enables iIDMA settings "
91 "Default is 1 - perform iIDMA. 0 - no iIDMA.");
93 int ql2xmaxqueues
= 1;
94 module_param(ql2xmaxqueues
, int, S_IRUGO
|S_IRUSR
);
95 MODULE_PARM_DESC(ql2xmaxqueues
,
96 "Enables MQ settings "
97 "Default is 1 for single queue. Set it to number \
98 of queues in MQ mode.");
100 * SCSI host template entry points
102 static int qla2xxx_slave_configure(struct scsi_device
* device
);
103 static int qla2xxx_slave_alloc(struct scsi_device
*);
104 static int qla2xxx_scan_finished(struct Scsi_Host
*, unsigned long time
);
105 static void qla2xxx_scan_start(struct Scsi_Host
*);
106 static void qla2xxx_slave_destroy(struct scsi_device
*);
107 static int qla2xxx_queuecommand(struct scsi_cmnd
*cmd
,
108 void (*fn
)(struct scsi_cmnd
*));
109 static int qla2xxx_eh_abort(struct scsi_cmnd
*);
110 static int qla2xxx_eh_device_reset(struct scsi_cmnd
*);
111 static int qla2xxx_eh_target_reset(struct scsi_cmnd
*);
112 static int qla2xxx_eh_bus_reset(struct scsi_cmnd
*);
113 static int qla2xxx_eh_host_reset(struct scsi_cmnd
*);
115 static int qla2x00_change_queue_depth(struct scsi_device
*, int);
116 static int qla2x00_change_queue_type(struct scsi_device
*, int);
118 struct scsi_host_template qla2xxx_driver_template
= {
119 .module
= THIS_MODULE
,
120 .name
= QLA2XXX_DRIVER_NAME
,
121 .queuecommand
= qla2xxx_queuecommand
,
123 .eh_abort_handler
= qla2xxx_eh_abort
,
124 .eh_device_reset_handler
= qla2xxx_eh_device_reset
,
125 .eh_target_reset_handler
= qla2xxx_eh_target_reset
,
126 .eh_bus_reset_handler
= qla2xxx_eh_bus_reset
,
127 .eh_host_reset_handler
= qla2xxx_eh_host_reset
,
129 .slave_configure
= qla2xxx_slave_configure
,
131 .slave_alloc
= qla2xxx_slave_alloc
,
132 .slave_destroy
= qla2xxx_slave_destroy
,
133 .scan_finished
= qla2xxx_scan_finished
,
134 .scan_start
= qla2xxx_scan_start
,
135 .change_queue_depth
= qla2x00_change_queue_depth
,
136 .change_queue_type
= qla2x00_change_queue_type
,
139 .use_clustering
= ENABLE_CLUSTERING
,
140 .sg_tablesize
= SG_ALL
,
142 .max_sectors
= 0xFFFF,
143 .shost_attrs
= qla2x00_host_attrs
,
146 static struct scsi_transport_template
*qla2xxx_transport_template
= NULL
;
147 struct scsi_transport_template
*qla2xxx_transport_vport_template
= NULL
;
149 /* TODO Convert to inlines
155 qla2x00_start_timer(scsi_qla_host_t
*vha
, void *func
, unsigned long interval
)
157 init_timer(&vha
->timer
);
158 vha
->timer
.expires
= jiffies
+ interval
* HZ
;
159 vha
->timer
.data
= (unsigned long)vha
;
160 vha
->timer
.function
= (void (*)(unsigned long))func
;
161 add_timer(&vha
->timer
);
162 vha
->timer_active
= 1;
166 qla2x00_restart_timer(scsi_qla_host_t
*vha
, unsigned long interval
)
168 mod_timer(&vha
->timer
, jiffies
+ interval
* HZ
);
171 static __inline__
void
172 qla2x00_stop_timer(scsi_qla_host_t
*vha
)
174 del_timer_sync(&vha
->timer
);
175 vha
->timer_active
= 0;
178 static int qla2x00_do_dpc(void *data
);
180 static void qla2x00_rst_aen(scsi_qla_host_t
*);
182 static int qla2x00_mem_alloc(struct qla_hw_data
*, uint16_t, uint16_t,
183 struct req_que
**, struct rsp_que
**);
184 static void qla2x00_mem_free(struct qla_hw_data
*);
185 static void qla2x00_sp_free_dma(srb_t
*);
187 /* -------------------------------------------------------------------------- */
188 static int qla2x00_alloc_queues(struct qla_hw_data
*ha
)
190 ha
->req_q_map
= kzalloc(sizeof(struct req_que
*) * ha
->max_queues
,
192 if (!ha
->req_q_map
) {
193 qla_printk(KERN_WARNING
, ha
,
194 "Unable to allocate memory for request queue ptrs\n");
198 ha
->rsp_q_map
= kzalloc(sizeof(struct rsp_que
*) * ha
->max_queues
,
200 if (!ha
->rsp_q_map
) {
201 qla_printk(KERN_WARNING
, ha
,
202 "Unable to allocate memory for response queue ptrs\n");
205 set_bit(0, ha
->rsp_qid_map
);
206 set_bit(0, ha
->req_qid_map
);
210 kfree(ha
->req_q_map
);
211 ha
->req_q_map
= NULL
;
216 static void qla2x00_free_que(struct qla_hw_data
*ha
, struct req_que
*req
,
219 if (rsp
&& rsp
->ring
)
220 dma_free_coherent(&ha
->pdev
->dev
,
221 (rsp
->length
+ 1) * sizeof(response_t
),
222 rsp
->ring
, rsp
->dma
);
226 if (req
&& req
->ring
)
227 dma_free_coherent(&ha
->pdev
->dev
,
228 (req
->length
+ 1) * sizeof(request_t
),
229 req
->ring
, req
->dma
);
235 static void qla2x00_free_queues(struct qla_hw_data
*ha
)
241 for (cnt
= 0; cnt
< ha
->max_queues
; cnt
++) {
242 rsp
= ha
->rsp_q_map
[cnt
];
243 req
= ha
->req_q_map
[cnt
];
244 qla2x00_free_que(ha
, req
, rsp
);
246 kfree(ha
->rsp_q_map
);
247 ha
->rsp_q_map
= NULL
;
249 kfree(ha
->req_q_map
);
250 ha
->req_q_map
= NULL
;
254 qla2x00_pci_info_str(struct scsi_qla_host
*vha
, char *str
)
256 struct qla_hw_data
*ha
= vha
->hw
;
257 static char *pci_bus_modes
[] = {
258 "33", "66", "100", "133",
263 pci_bus
= (ha
->pci_attr
& (BIT_9
| BIT_10
)) >> 9;
266 strcat(str
, pci_bus_modes
[pci_bus
]);
268 pci_bus
= (ha
->pci_attr
& BIT_8
) >> 8;
270 strcat(str
, pci_bus_modes
[pci_bus
]);
272 strcat(str
, " MHz)");
278 qla24xx_pci_info_str(struct scsi_qla_host
*vha
, char *str
)
280 static char *pci_bus_modes
[] = { "33", "66", "100", "133", };
281 struct qla_hw_data
*ha
= vha
->hw
;
285 pcie_reg
= pci_find_capability(ha
->pdev
, PCI_CAP_ID_EXP
);
288 uint16_t pcie_lstat
, lspeed
, lwidth
;
291 pci_read_config_word(ha
->pdev
, pcie_reg
, &pcie_lstat
);
292 lspeed
= pcie_lstat
& (BIT_0
| BIT_1
| BIT_2
| BIT_3
);
293 lwidth
= (pcie_lstat
&
294 (BIT_4
| BIT_5
| BIT_6
| BIT_7
| BIT_8
| BIT_9
)) >> 4;
296 strcpy(str
, "PCIe (");
298 strcat(str
, "2.5GT/s ");
299 else if (lspeed
== 2)
300 strcat(str
, "5.0GT/s ");
302 strcat(str
, "<unknown> ");
303 snprintf(lwstr
, sizeof(lwstr
), "x%d)", lwidth
);
310 pci_bus
= (ha
->pci_attr
& CSRX_PCIX_BUS_MODE_MASK
) >> 8;
311 if (pci_bus
== 0 || pci_bus
== 8) {
313 strcat(str
, pci_bus_modes
[pci_bus
>> 3]);
317 strcat(str
, "Mode 2");
319 strcat(str
, "Mode 1");
321 strcat(str
, pci_bus_modes
[pci_bus
& ~BIT_2
]);
323 strcat(str
, " MHz)");
329 qla2x00_fw_version_str(struct scsi_qla_host
*vha
, char *str
)
332 struct qla_hw_data
*ha
= vha
->hw
;
334 sprintf(str
, "%d.%02d.%02d ", ha
->fw_major_version
,
335 ha
->fw_minor_version
,
336 ha
->fw_subminor_version
);
338 if (ha
->fw_attributes
& BIT_9
) {
343 switch (ha
->fw_attributes
& 0xFF) {
357 sprintf(un_str
, "(%x)", ha
->fw_attributes
);
361 if (ha
->fw_attributes
& 0x100)
368 qla24xx_fw_version_str(struct scsi_qla_host
*vha
, char *str
)
370 struct qla_hw_data
*ha
= vha
->hw
;
372 sprintf(str
, "%d.%02d.%02d (%x)", ha
->fw_major_version
,
373 ha
->fw_minor_version
, ha
->fw_subminor_version
, ha
->fw_attributes
);
377 static inline srb_t
*
378 qla2x00_get_new_sp(scsi_qla_host_t
*vha
, fc_port_t
*fcport
,
379 struct scsi_cmnd
*cmd
, void (*done
)(struct scsi_cmnd
*))
382 struct qla_hw_data
*ha
= vha
->hw
;
384 sp
= mempool_alloc(ha
->srb_mempool
, GFP_ATOMIC
);
390 sp
->que
= ha
->req_q_map
[0];
392 CMD_SP(cmd
) = (void *)sp
;
393 cmd
->scsi_done
= done
;
399 qla2xxx_queuecommand(struct scsi_cmnd
*cmd
, void (*done
)(struct scsi_cmnd
*))
401 scsi_qla_host_t
*vha
= shost_priv(cmd
->device
->host
);
402 fc_port_t
*fcport
= (struct fc_port
*) cmd
->device
->hostdata
;
403 struct fc_rport
*rport
= starget_to_rport(scsi_target(cmd
->device
));
404 struct qla_hw_data
*ha
= vha
->hw
;
405 struct scsi_qla_host
*base_vha
= pci_get_drvdata(ha
->pdev
);
409 if (unlikely(pci_channel_offline(ha
->pdev
))) {
410 if (ha
->pdev
->error_state
== pci_channel_io_frozen
)
411 cmd
->result
= DID_REQUEUE
<< 16;
413 cmd
->result
= DID_NO_CONNECT
<< 16;
414 goto qc24_fail_command
;
417 rval
= fc_remote_port_chkready(rport
);
420 goto qc24_fail_command
;
423 /* Close window on fcport/rport state-transitioning. */
425 goto qc24_target_busy
;
427 if (atomic_read(&fcport
->state
) != FCS_ONLINE
) {
428 if (atomic_read(&fcport
->state
) == FCS_DEVICE_DEAD
||
429 atomic_read(&base_vha
->loop_state
) == LOOP_DEAD
) {
430 cmd
->result
= DID_NO_CONNECT
<< 16;
431 goto qc24_fail_command
;
433 goto qc24_target_busy
;
436 spin_unlock_irq(vha
->host
->host_lock
);
438 sp
= qla2x00_get_new_sp(base_vha
, fcport
, cmd
, done
);
440 goto qc24_host_busy_lock
;
442 rval
= ha
->isp_ops
->start_scsi(sp
);
443 if (rval
!= QLA_SUCCESS
)
444 goto qc24_host_busy_free_sp
;
446 spin_lock_irq(vha
->host
->host_lock
);
450 qc24_host_busy_free_sp
:
451 qla2x00_sp_free_dma(sp
);
452 mempool_free(sp
, ha
->srb_mempool
);
455 spin_lock_irq(vha
->host
->host_lock
);
456 return SCSI_MLQUEUE_HOST_BUSY
;
459 return SCSI_MLQUEUE_TARGET_BUSY
;
469 * qla2x00_eh_wait_on_command
470 * Waits for the command to be returned by the Firmware for some
474 * cmd = Scsi Command to wait on.
481 qla2x00_eh_wait_on_command(struct scsi_cmnd
*cmd
)
483 #define ABORT_POLLING_PERIOD 1000
484 #define ABORT_WAIT_ITER ((10 * 1000) / (ABORT_POLLING_PERIOD))
485 unsigned long wait_iter
= ABORT_WAIT_ITER
;
486 int ret
= QLA_SUCCESS
;
488 while (CMD_SP(cmd
)) {
489 msleep(ABORT_POLLING_PERIOD
);
495 ret
= QLA_FUNCTION_FAILED
;
501 * qla2x00_wait_for_hba_online
502 * Wait till the HBA is online after going through
503 * <= MAX_RETRIES_OF_ISP_ABORT or
504 * finally HBA is disabled ie marked offline
507 * ha - pointer to host adapter structure
510 * Does context switching-Release SPIN_LOCK
511 * (if any) before calling this routine.
514 * Success (Adapter is online) : 0
515 * Failed (Adapter is offline/disabled) : 1
518 qla2x00_wait_for_hba_online(scsi_qla_host_t
*vha
)
521 unsigned long wait_online
;
522 struct qla_hw_data
*ha
= vha
->hw
;
523 scsi_qla_host_t
*base_vha
= pci_get_drvdata(ha
->pdev
);
525 wait_online
= jiffies
+ (MAX_LOOP_TIMEOUT
* HZ
);
526 while (((test_bit(ISP_ABORT_NEEDED
, &base_vha
->dpc_flags
)) ||
527 test_bit(ABORT_ISP_ACTIVE
, &base_vha
->dpc_flags
) ||
528 test_bit(ISP_ABORT_RETRY
, &base_vha
->dpc_flags
) ||
529 ha
->dpc_active
) && time_before(jiffies
, wait_online
)) {
533 if (base_vha
->flags
.online
)
534 return_status
= QLA_SUCCESS
;
536 return_status
= QLA_FUNCTION_FAILED
;
538 return (return_status
);
542 qla2x00_wait_for_chip_reset(scsi_qla_host_t
*vha
)
545 unsigned long wait_reset
;
546 struct qla_hw_data
*ha
= vha
->hw
;
547 scsi_qla_host_t
*base_vha
= pci_get_drvdata(ha
->pdev
);
549 wait_reset
= jiffies
+ (MAX_LOOP_TIMEOUT
* HZ
);
550 while (((test_bit(ISP_ABORT_NEEDED
, &base_vha
->dpc_flags
)) ||
551 test_bit(ABORT_ISP_ACTIVE
, &base_vha
->dpc_flags
) ||
552 test_bit(ISP_ABORT_RETRY
, &base_vha
->dpc_flags
) ||
553 ha
->dpc_active
) && time_before(jiffies
, wait_reset
)) {
557 if (!test_bit(ISP_ABORT_NEEDED
, &base_vha
->dpc_flags
) &&
558 ha
->flags
.chip_reset_done
)
561 if (ha
->flags
.chip_reset_done
)
562 return_status
= QLA_SUCCESS
;
564 return_status
= QLA_FUNCTION_FAILED
;
566 return return_status
;
570 * qla2x00_wait_for_loop_ready
571 * Wait for MAX_LOOP_TIMEOUT(5 min) value for loop
572 * to be in LOOP_READY state.
574 * ha - pointer to host adapter structure
577 * Does context switching-Release SPIN_LOCK
578 * (if any) before calling this routine.
582 * Success (LOOP_READY) : 0
583 * Failed (LOOP_NOT_READY) : 1
586 qla2x00_wait_for_loop_ready(scsi_qla_host_t
*vha
)
588 int return_status
= QLA_SUCCESS
;
589 unsigned long loop_timeout
;
590 struct qla_hw_data
*ha
= vha
->hw
;
591 scsi_qla_host_t
*base_vha
= pci_get_drvdata(ha
->pdev
);
593 /* wait for 5 min at the max for loop to be ready */
594 loop_timeout
= jiffies
+ (MAX_LOOP_TIMEOUT
* HZ
);
596 while ((!atomic_read(&base_vha
->loop_down_timer
) &&
597 atomic_read(&base_vha
->loop_state
) == LOOP_DOWN
) ||
598 atomic_read(&base_vha
->loop_state
) != LOOP_READY
) {
599 if (atomic_read(&base_vha
->loop_state
) == LOOP_DEAD
) {
600 return_status
= QLA_FUNCTION_FAILED
;
604 if (time_after_eq(jiffies
, loop_timeout
)) {
605 return_status
= QLA_FUNCTION_FAILED
;
609 return (return_status
);
613 qla2x00_abort_fcport_cmds(fc_port_t
*fcport
)
618 scsi_qla_host_t
*vha
= fcport
->vha
;
619 struct qla_hw_data
*ha
= vha
->hw
;
622 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
623 for (que
= 0; que
< QLA_MAX_HOST_QUES
; que
++) {
624 id
= vha
->req_ques
[que
];
625 req
= ha
->req_q_map
[id
];
628 for (cnt
= 1; cnt
< MAX_OUTSTANDING_COMMANDS
; cnt
++) {
629 sp
= req
->outstanding_cmds
[cnt
];
632 if (sp
->fcport
!= fcport
)
635 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
636 if (ha
->isp_ops
->abort_command(vha
, sp
, req
)) {
637 DEBUG2(qla_printk(KERN_WARNING
, ha
,
638 "Abort failed -- %lx\n",
639 sp
->cmd
->serial_number
));
641 if (qla2x00_eh_wait_on_command(sp
->cmd
) !=
643 DEBUG2(qla_printk(KERN_WARNING
, ha
,
644 "Abort failed while waiting -- %lx\n",
645 sp
->cmd
->serial_number
));
647 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
650 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
654 qla2x00_block_error_handler(struct scsi_cmnd
*cmnd
)
656 struct Scsi_Host
*shost
= cmnd
->device
->host
;
657 struct fc_rport
*rport
= starget_to_rport(scsi_target(cmnd
->device
));
660 spin_lock_irqsave(shost
->host_lock
, flags
);
661 while (rport
->port_state
== FC_PORTSTATE_BLOCKED
) {
662 spin_unlock_irqrestore(shost
->host_lock
, flags
);
664 spin_lock_irqsave(shost
->host_lock
, flags
);
666 spin_unlock_irqrestore(shost
->host_lock
, flags
);
670 /**************************************************************************
674 * The abort function will abort the specified command.
677 * cmd = Linux SCSI command packet to be aborted.
680 * Either SUCCESS or FAILED.
683 * Only return FAILED if command not returned by firmware.
684 **************************************************************************/
686 qla2xxx_eh_abort(struct scsi_cmnd
*cmd
)
688 scsi_qla_host_t
*vha
= shost_priv(cmd
->device
->host
);
691 unsigned int id
, lun
;
692 unsigned long serial
;
695 struct qla_hw_data
*ha
= vha
->hw
;
699 qla2x00_block_error_handler(cmd
);
706 id
= cmd
->device
->id
;
707 lun
= cmd
->device
->lun
;
708 serial
= cmd
->serial_number
;
709 spt
= (srb_t
*) CMD_SP(cmd
);
714 /* Check active list for command command. */
715 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
716 for (i
= 1; i
< MAX_OUTSTANDING_COMMANDS
; i
++) {
717 sp
= req
->outstanding_cmds
[i
];
725 DEBUG2(printk("%s(%ld): aborting sp %p from RISC."
726 " pid=%ld.\n", __func__
, vha
->host_no
, sp
, serial
));
728 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
729 if (ha
->isp_ops
->abort_command(vha
, sp
, req
)) {
730 DEBUG2(printk("%s(%ld): abort_command "
731 "mbx failed.\n", __func__
, vha
->host_no
));
734 DEBUG3(printk("%s(%ld): abort_command "
735 "mbx success.\n", __func__
, vha
->host_no
));
738 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
741 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
743 /* Wait for the command to be returned. */
745 if (qla2x00_eh_wait_on_command(cmd
) != QLA_SUCCESS
) {
746 qla_printk(KERN_ERR
, ha
,
747 "scsi(%ld:%d:%d): Abort handler timed out -- %lx "
748 "%x.\n", vha
->host_no
, id
, lun
, serial
, ret
);
753 qla_printk(KERN_INFO
, ha
,
754 "scsi(%ld:%d:%d): Abort command issued -- %d %lx %x.\n",
755 vha
->host_no
, id
, lun
, wait
, serial
, ret
);
760 enum nexus_wait_type
{
767 qla2x00_eh_wait_for_pending_commands(scsi_qla_host_t
*vha
, unsigned int t
,
768 unsigned int l
, srb_t
*sp
, enum nexus_wait_type type
)
770 int cnt
, match
, status
;
772 struct qla_hw_data
*ha
= vha
->hw
;
775 status
= QLA_SUCCESS
;
779 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
781 for (cnt
= 1; status
== QLA_SUCCESS
&&
782 cnt
< MAX_OUTSTANDING_COMMANDS
; cnt
++) {
783 sp
= req
->outstanding_cmds
[cnt
];
787 if (vha
->vp_idx
!= sp
->fcport
->vha
->vp_idx
)
795 match
= sp
->cmd
->device
->id
== t
;
798 match
= (sp
->cmd
->device
->id
== t
&&
799 sp
->cmd
->device
->lun
== l
);
805 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
806 status
= qla2x00_eh_wait_on_command(sp
->cmd
);
807 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
809 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
814 static char *reset_errors
[] = {
817 "Task management failed",
818 "Waiting for command completions",
822 __qla2xxx_eh_generic_reset(char *name
, enum nexus_wait_type type
,
823 struct scsi_cmnd
*cmd
, int (*do_reset
)(struct fc_port
*, unsigned int))
825 scsi_qla_host_t
*vha
= shost_priv(cmd
->device
->host
);
826 fc_port_t
*fcport
= (struct fc_port
*) cmd
->device
->hostdata
;
829 qla2x00_block_error_handler(cmd
);
834 qla_printk(KERN_INFO
, vha
->hw
, "scsi(%ld:%d:%d): %s RESET ISSUED.\n",
835 vha
->host_no
, cmd
->device
->id
, cmd
->device
->lun
, name
);
838 if (qla2x00_wait_for_hba_online(vha
) != QLA_SUCCESS
)
839 goto eh_reset_failed
;
841 if (qla2x00_wait_for_loop_ready(vha
) != QLA_SUCCESS
)
842 goto eh_reset_failed
;
844 if (do_reset(fcport
, cmd
->device
->lun
) != QLA_SUCCESS
)
845 goto eh_reset_failed
;
847 if (qla2x00_eh_wait_for_pending_commands(vha
, cmd
->device
->id
,
848 cmd
->device
->lun
, (srb_t
*) CMD_SP(cmd
), type
) != QLA_SUCCESS
)
849 goto eh_reset_failed
;
851 qla_printk(KERN_INFO
, vha
->hw
, "scsi(%ld:%d:%d): %s RESET SUCCEEDED.\n",
852 vha
->host_no
, cmd
->device
->id
, cmd
->device
->lun
, name
);
857 qla_printk(KERN_INFO
, vha
->hw
, "scsi(%ld:%d:%d): %s RESET FAILED: %s.\n"
858 , vha
->host_no
, cmd
->device
->id
, cmd
->device
->lun
, name
,
864 qla2xxx_eh_device_reset(struct scsi_cmnd
*cmd
)
866 scsi_qla_host_t
*vha
= shost_priv(cmd
->device
->host
);
867 struct qla_hw_data
*ha
= vha
->hw
;
869 return __qla2xxx_eh_generic_reset("DEVICE", WAIT_LUN
, cmd
,
870 ha
->isp_ops
->lun_reset
);
874 qla2xxx_eh_target_reset(struct scsi_cmnd
*cmd
)
876 scsi_qla_host_t
*vha
= shost_priv(cmd
->device
->host
);
877 struct qla_hw_data
*ha
= vha
->hw
;
879 return __qla2xxx_eh_generic_reset("TARGET", WAIT_TARGET
, cmd
,
880 ha
->isp_ops
->target_reset
);
883 /**************************************************************************
884 * qla2xxx_eh_bus_reset
887 * The bus reset function will reset the bus and abort any executing
891 * cmd = Linux SCSI command packet of the command that cause the
895 * SUCCESS/FAILURE (defined as macro in scsi.h).
897 **************************************************************************/
899 qla2xxx_eh_bus_reset(struct scsi_cmnd
*cmd
)
901 scsi_qla_host_t
*vha
= shost_priv(cmd
->device
->host
);
902 fc_port_t
*fcport
= (struct fc_port
*) cmd
->device
->hostdata
;
904 unsigned int id
, lun
;
905 unsigned long serial
;
906 srb_t
*sp
= (srb_t
*) CMD_SP(cmd
);
908 qla2x00_block_error_handler(cmd
);
910 id
= cmd
->device
->id
;
911 lun
= cmd
->device
->lun
;
912 serial
= cmd
->serial_number
;
917 qla_printk(KERN_INFO
, vha
->hw
,
918 "scsi(%ld:%d:%d): BUS RESET ISSUED.\n", vha
->host_no
, id
, lun
);
920 if (qla2x00_wait_for_hba_online(vha
) != QLA_SUCCESS
) {
921 DEBUG2(printk("%s failed:board disabled\n",__func__
));
922 goto eh_bus_reset_done
;
925 if (qla2x00_wait_for_loop_ready(vha
) == QLA_SUCCESS
) {
926 if (qla2x00_loop_reset(vha
) == QLA_SUCCESS
)
930 goto eh_bus_reset_done
;
932 /* Flush outstanding commands. */
933 if (qla2x00_eh_wait_for_pending_commands(vha
, 0, 0, sp
, WAIT_HOST
) !=
938 qla_printk(KERN_INFO
, vha
->hw
, "%s: reset %s\n", __func__
,
939 (ret
== FAILED
) ? "failed" : "succeded");
944 /**************************************************************************
945 * qla2xxx_eh_host_reset
948 * The reset function will reset the Adapter.
951 * cmd = Linux SCSI command packet of the command that cause the
955 * Either SUCCESS or FAILED.
958 **************************************************************************/
960 qla2xxx_eh_host_reset(struct scsi_cmnd
*cmd
)
962 scsi_qla_host_t
*vha
= shost_priv(cmd
->device
->host
);
963 fc_port_t
*fcport
= (struct fc_port
*) cmd
->device
->hostdata
;
964 struct qla_hw_data
*ha
= vha
->hw
;
966 unsigned int id
, lun
;
967 unsigned long serial
;
968 srb_t
*sp
= (srb_t
*) CMD_SP(cmd
);
969 scsi_qla_host_t
*base_vha
= pci_get_drvdata(ha
->pdev
);
971 qla2x00_block_error_handler(cmd
);
973 id
= cmd
->device
->id
;
974 lun
= cmd
->device
->lun
;
975 serial
= cmd
->serial_number
;
980 qla_printk(KERN_INFO
, ha
,
981 "scsi(%ld:%d:%d): ADAPTER RESET ISSUED.\n", vha
->host_no
, id
, lun
);
983 if (qla2x00_wait_for_hba_online(vha
) != QLA_SUCCESS
)
984 goto eh_host_reset_lock
;
987 * Fixme-may be dpc thread is active and processing
988 * loop_resync,so wait a while for it to
989 * be completed and then issue big hammer.Otherwise
990 * it may cause I/O failure as big hammer marks the
991 * devices as lost kicking of the port_down_timer
992 * while dpc is stuck for the mailbox to complete.
994 qla2x00_wait_for_loop_ready(vha
);
995 if (vha
!= base_vha
) {
996 if (qla2x00_vp_abort_isp(vha
))
997 goto eh_host_reset_lock
;
999 set_bit(ABORT_ISP_ACTIVE
, &base_vha
->dpc_flags
);
1000 if (qla2x00_abort_isp(base_vha
)) {
1001 clear_bit(ABORT_ISP_ACTIVE
, &base_vha
->dpc_flags
);
1002 /* failed. schedule dpc to try */
1003 set_bit(ISP_ABORT_NEEDED
, &base_vha
->dpc_flags
);
1005 if (qla2x00_wait_for_hba_online(vha
) != QLA_SUCCESS
)
1006 goto eh_host_reset_lock
;
1008 clear_bit(ABORT_ISP_ACTIVE
, &base_vha
->dpc_flags
);
1011 /* Waiting for command to be returned to OS.*/
1012 if (qla2x00_eh_wait_for_pending_commands(vha
, 0, 0, sp
, WAIT_HOST
) ==
1017 qla_printk(KERN_INFO
, ha
, "%s: reset %s\n", __func__
,
1018 (ret
== FAILED
) ? "failed" : "succeded");
1024 * qla2x00_loop_reset
1028 * ha = adapter block pointer.
1034 qla2x00_loop_reset(scsi_qla_host_t
*vha
)
1037 struct fc_port
*fcport
;
1038 struct qla_hw_data
*ha
= vha
->hw
;
1040 if (ha
->flags
.enable_lip_full_login
&& !vha
->vp_idx
) {
1041 ret
= qla2x00_full_login_lip(vha
);
1042 if (ret
!= QLA_SUCCESS
) {
1043 DEBUG2_3(printk("%s(%ld): failed: "
1044 "full_login_lip=%d.\n", __func__
, vha
->host_no
,
1047 atomic_set(&vha
->loop_state
, LOOP_DOWN
);
1048 atomic_set(&vha
->loop_down_timer
, LOOP_DOWN_TIME
);
1049 qla2x00_mark_all_devices_lost(vha
, 0);
1050 qla2x00_wait_for_loop_ready(vha
);
1053 if (ha
->flags
.enable_lip_reset
&& !vha
->vp_idx
) {
1054 ret
= qla2x00_lip_reset(vha
);
1055 if (ret
!= QLA_SUCCESS
) {
1056 DEBUG2_3(printk("%s(%ld): failed: "
1057 "lip_reset=%d.\n", __func__
, vha
->host_no
, ret
));
1059 qla2x00_wait_for_loop_ready(vha
);
1062 if (ha
->flags
.enable_target_reset
) {
1063 list_for_each_entry(fcport
, &vha
->vp_fcports
, list
) {
1064 if (fcport
->port_type
!= FCT_TARGET
)
1067 ret
= ha
->isp_ops
->target_reset(fcport
, 0);
1068 if (ret
!= QLA_SUCCESS
) {
1069 DEBUG2_3(printk("%s(%ld): bus_reset failed: "
1070 "target_reset=%d d_id=%x.\n", __func__
,
1071 vha
->host_no
, ret
, fcport
->d_id
.b24
));
1075 /* Issue marker command only when we are going to start the I/O */
1076 vha
->marker_needed
= 1;
1082 qla2x00_abort_all_cmds(scsi_qla_host_t
*vha
, int res
)
1085 unsigned long flags
;
1087 struct qla_hw_data
*ha
= vha
->hw
;
1088 struct req_que
*req
;
1090 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
1091 for (que
= 0; que
< ha
->max_queues
; que
++) {
1092 req
= ha
->req_q_map
[que
];
1095 for (cnt
= 1; cnt
< MAX_OUTSTANDING_COMMANDS
; cnt
++) {
1096 sp
= req
->outstanding_cmds
[cnt
];
1098 req
->outstanding_cmds
[cnt
] = NULL
;
1099 sp
->cmd
->result
= res
;
1100 qla2x00_sp_compl(ha
, sp
);
1104 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
1108 qla2xxx_slave_alloc(struct scsi_device
*sdev
)
1110 struct fc_rport
*rport
= starget_to_rport(scsi_target(sdev
));
1112 if (!rport
|| fc_remote_port_chkready(rport
))
1115 sdev
->hostdata
= *(fc_port_t
**)rport
->dd_data
;
1121 qla2xxx_slave_configure(struct scsi_device
*sdev
)
1123 scsi_qla_host_t
*vha
= shost_priv(sdev
->host
);
1124 struct qla_hw_data
*ha
= vha
->hw
;
1125 struct fc_rport
*rport
= starget_to_rport(sdev
->sdev_target
);
1126 struct req_que
*req
= ha
->req_q_map
[vha
->req_ques
[0]];
1128 if (sdev
->tagged_supported
)
1129 scsi_activate_tcq(sdev
, req
->max_q_depth
);
1131 scsi_deactivate_tcq(sdev
, req
->max_q_depth
);
1133 rport
->dev_loss_tmo
= ha
->port_down_retry_count
;
1139 qla2xxx_slave_destroy(struct scsi_device
*sdev
)
1141 sdev
->hostdata
= NULL
;
1145 qla2x00_change_queue_depth(struct scsi_device
*sdev
, int qdepth
)
1147 scsi_adjust_queue_depth(sdev
, scsi_get_tag_type(sdev
), qdepth
);
1148 return sdev
->queue_depth
;
1152 qla2x00_change_queue_type(struct scsi_device
*sdev
, int tag_type
)
1154 if (sdev
->tagged_supported
) {
1155 scsi_set_tag_type(sdev
, tag_type
);
1157 scsi_activate_tcq(sdev
, sdev
->queue_depth
);
1159 scsi_deactivate_tcq(sdev
, sdev
->queue_depth
);
1167 * qla2x00_config_dma_addressing() - Configure OS DMA addressing method.
1170 * At exit, the @ha's flags.enable_64bit_addressing set to indicated
1171 * supported addressing method.
1174 qla2x00_config_dma_addressing(struct qla_hw_data
*ha
)
1176 /* Assume a 32bit DMA mask. */
1177 ha
->flags
.enable_64bit_addressing
= 0;
1179 if (!dma_set_mask(&ha
->pdev
->dev
, DMA_BIT_MASK(64))) {
1180 /* Any upper-dword bits set? */
1181 if (MSD(dma_get_required_mask(&ha
->pdev
->dev
)) &&
1182 !pci_set_consistent_dma_mask(ha
->pdev
, DMA_BIT_MASK(64))) {
1183 /* Ok, a 64bit DMA mask is applicable. */
1184 ha
->flags
.enable_64bit_addressing
= 1;
1185 ha
->isp_ops
->calc_req_entries
= qla2x00_calc_iocbs_64
;
1186 ha
->isp_ops
->build_iocbs
= qla2x00_build_scsi_iocbs_64
;
1191 dma_set_mask(&ha
->pdev
->dev
, DMA_BIT_MASK(32));
1192 pci_set_consistent_dma_mask(ha
->pdev
, DMA_BIT_MASK(32));
1196 qla2x00_enable_intrs(struct qla_hw_data
*ha
)
1198 unsigned long flags
= 0;
1199 struct device_reg_2xxx __iomem
*reg
= &ha
->iobase
->isp
;
1201 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
1202 ha
->interrupts_on
= 1;
1203 /* enable risc and host interrupts */
1204 WRT_REG_WORD(®
->ictrl
, ICR_EN_INT
| ICR_EN_RISC
);
1205 RD_REG_WORD(®
->ictrl
);
1206 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
1211 qla2x00_disable_intrs(struct qla_hw_data
*ha
)
1213 unsigned long flags
= 0;
1214 struct device_reg_2xxx __iomem
*reg
= &ha
->iobase
->isp
;
1216 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
1217 ha
->interrupts_on
= 0;
1218 /* disable risc and host interrupts */
1219 WRT_REG_WORD(®
->ictrl
, 0);
1220 RD_REG_WORD(®
->ictrl
);
1221 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
1225 qla24xx_enable_intrs(struct qla_hw_data
*ha
)
1227 unsigned long flags
= 0;
1228 struct device_reg_24xx __iomem
*reg
= &ha
->iobase
->isp24
;
1230 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
1231 ha
->interrupts_on
= 1;
1232 WRT_REG_DWORD(®
->ictrl
, ICRX_EN_RISC_INT
);
1233 RD_REG_DWORD(®
->ictrl
);
1234 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
1238 qla24xx_disable_intrs(struct qla_hw_data
*ha
)
1240 unsigned long flags
= 0;
1241 struct device_reg_24xx __iomem
*reg
= &ha
->iobase
->isp24
;
1243 if (IS_NOPOLLING_TYPE(ha
))
1245 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
1246 ha
->interrupts_on
= 0;
1247 WRT_REG_DWORD(®
->ictrl
, 0);
1248 RD_REG_DWORD(®
->ictrl
);
1249 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
1252 static struct isp_operations qla2100_isp_ops
= {
1253 .pci_config
= qla2100_pci_config
,
1254 .reset_chip
= qla2x00_reset_chip
,
1255 .chip_diag
= qla2x00_chip_diag
,
1256 .config_rings
= qla2x00_config_rings
,
1257 .reset_adapter
= qla2x00_reset_adapter
,
1258 .nvram_config
= qla2x00_nvram_config
,
1259 .update_fw_options
= qla2x00_update_fw_options
,
1260 .load_risc
= qla2x00_load_risc
,
1261 .pci_info_str
= qla2x00_pci_info_str
,
1262 .fw_version_str
= qla2x00_fw_version_str
,
1263 .intr_handler
= qla2100_intr_handler
,
1264 .enable_intrs
= qla2x00_enable_intrs
,
1265 .disable_intrs
= qla2x00_disable_intrs
,
1266 .abort_command
= qla2x00_abort_command
,
1267 .target_reset
= qla2x00_abort_target
,
1268 .lun_reset
= qla2x00_lun_reset
,
1269 .fabric_login
= qla2x00_login_fabric
,
1270 .fabric_logout
= qla2x00_fabric_logout
,
1271 .calc_req_entries
= qla2x00_calc_iocbs_32
,
1272 .build_iocbs
= qla2x00_build_scsi_iocbs_32
,
1273 .prep_ms_iocb
= qla2x00_prep_ms_iocb
,
1274 .prep_ms_fdmi_iocb
= qla2x00_prep_ms_fdmi_iocb
,
1275 .read_nvram
= qla2x00_read_nvram_data
,
1276 .write_nvram
= qla2x00_write_nvram_data
,
1277 .fw_dump
= qla2100_fw_dump
,
1280 .beacon_blink
= NULL
,
1281 .read_optrom
= qla2x00_read_optrom_data
,
1282 .write_optrom
= qla2x00_write_optrom_data
,
1283 .get_flash_version
= qla2x00_get_flash_version
,
1284 .start_scsi
= qla2x00_start_scsi
,
1287 static struct isp_operations qla2300_isp_ops
= {
1288 .pci_config
= qla2300_pci_config
,
1289 .reset_chip
= qla2x00_reset_chip
,
1290 .chip_diag
= qla2x00_chip_diag
,
1291 .config_rings
= qla2x00_config_rings
,
1292 .reset_adapter
= qla2x00_reset_adapter
,
1293 .nvram_config
= qla2x00_nvram_config
,
1294 .update_fw_options
= qla2x00_update_fw_options
,
1295 .load_risc
= qla2x00_load_risc
,
1296 .pci_info_str
= qla2x00_pci_info_str
,
1297 .fw_version_str
= qla2x00_fw_version_str
,
1298 .intr_handler
= qla2300_intr_handler
,
1299 .enable_intrs
= qla2x00_enable_intrs
,
1300 .disable_intrs
= qla2x00_disable_intrs
,
1301 .abort_command
= qla2x00_abort_command
,
1302 .target_reset
= qla2x00_abort_target
,
1303 .lun_reset
= qla2x00_lun_reset
,
1304 .fabric_login
= qla2x00_login_fabric
,
1305 .fabric_logout
= qla2x00_fabric_logout
,
1306 .calc_req_entries
= qla2x00_calc_iocbs_32
,
1307 .build_iocbs
= qla2x00_build_scsi_iocbs_32
,
1308 .prep_ms_iocb
= qla2x00_prep_ms_iocb
,
1309 .prep_ms_fdmi_iocb
= qla2x00_prep_ms_fdmi_iocb
,
1310 .read_nvram
= qla2x00_read_nvram_data
,
1311 .write_nvram
= qla2x00_write_nvram_data
,
1312 .fw_dump
= qla2300_fw_dump
,
1313 .beacon_on
= qla2x00_beacon_on
,
1314 .beacon_off
= qla2x00_beacon_off
,
1315 .beacon_blink
= qla2x00_beacon_blink
,
1316 .read_optrom
= qla2x00_read_optrom_data
,
1317 .write_optrom
= qla2x00_write_optrom_data
,
1318 .get_flash_version
= qla2x00_get_flash_version
,
1319 .start_scsi
= qla2x00_start_scsi
,
1322 static struct isp_operations qla24xx_isp_ops
= {
1323 .pci_config
= qla24xx_pci_config
,
1324 .reset_chip
= qla24xx_reset_chip
,
1325 .chip_diag
= qla24xx_chip_diag
,
1326 .config_rings
= qla24xx_config_rings
,
1327 .reset_adapter
= qla24xx_reset_adapter
,
1328 .nvram_config
= qla24xx_nvram_config
,
1329 .update_fw_options
= qla24xx_update_fw_options
,
1330 .load_risc
= qla24xx_load_risc
,
1331 .pci_info_str
= qla24xx_pci_info_str
,
1332 .fw_version_str
= qla24xx_fw_version_str
,
1333 .intr_handler
= qla24xx_intr_handler
,
1334 .enable_intrs
= qla24xx_enable_intrs
,
1335 .disable_intrs
= qla24xx_disable_intrs
,
1336 .abort_command
= qla24xx_abort_command
,
1337 .target_reset
= qla24xx_abort_target
,
1338 .lun_reset
= qla24xx_lun_reset
,
1339 .fabric_login
= qla24xx_login_fabric
,
1340 .fabric_logout
= qla24xx_fabric_logout
,
1341 .calc_req_entries
= NULL
,
1342 .build_iocbs
= NULL
,
1343 .prep_ms_iocb
= qla24xx_prep_ms_iocb
,
1344 .prep_ms_fdmi_iocb
= qla24xx_prep_ms_fdmi_iocb
,
1345 .read_nvram
= qla24xx_read_nvram_data
,
1346 .write_nvram
= qla24xx_write_nvram_data
,
1347 .fw_dump
= qla24xx_fw_dump
,
1348 .beacon_on
= qla24xx_beacon_on
,
1349 .beacon_off
= qla24xx_beacon_off
,
1350 .beacon_blink
= qla24xx_beacon_blink
,
1351 .read_optrom
= qla24xx_read_optrom_data
,
1352 .write_optrom
= qla24xx_write_optrom_data
,
1353 .get_flash_version
= qla24xx_get_flash_version
,
1354 .start_scsi
= qla24xx_start_scsi
,
1357 static struct isp_operations qla25xx_isp_ops
= {
1358 .pci_config
= qla25xx_pci_config
,
1359 .reset_chip
= qla24xx_reset_chip
,
1360 .chip_diag
= qla24xx_chip_diag
,
1361 .config_rings
= qla24xx_config_rings
,
1362 .reset_adapter
= qla24xx_reset_adapter
,
1363 .nvram_config
= qla24xx_nvram_config
,
1364 .update_fw_options
= qla24xx_update_fw_options
,
1365 .load_risc
= qla24xx_load_risc
,
1366 .pci_info_str
= qla24xx_pci_info_str
,
1367 .fw_version_str
= qla24xx_fw_version_str
,
1368 .intr_handler
= qla24xx_intr_handler
,
1369 .enable_intrs
= qla24xx_enable_intrs
,
1370 .disable_intrs
= qla24xx_disable_intrs
,
1371 .abort_command
= qla24xx_abort_command
,
1372 .target_reset
= qla24xx_abort_target
,
1373 .lun_reset
= qla24xx_lun_reset
,
1374 .fabric_login
= qla24xx_login_fabric
,
1375 .fabric_logout
= qla24xx_fabric_logout
,
1376 .calc_req_entries
= NULL
,
1377 .build_iocbs
= NULL
,
1378 .prep_ms_iocb
= qla24xx_prep_ms_iocb
,
1379 .prep_ms_fdmi_iocb
= qla24xx_prep_ms_fdmi_iocb
,
1380 .read_nvram
= qla25xx_read_nvram_data
,
1381 .write_nvram
= qla25xx_write_nvram_data
,
1382 .fw_dump
= qla25xx_fw_dump
,
1383 .beacon_on
= qla24xx_beacon_on
,
1384 .beacon_off
= qla24xx_beacon_off
,
1385 .beacon_blink
= qla24xx_beacon_blink
,
1386 .read_optrom
= qla25xx_read_optrom_data
,
1387 .write_optrom
= qla24xx_write_optrom_data
,
1388 .get_flash_version
= qla24xx_get_flash_version
,
1389 .start_scsi
= qla24xx_start_scsi
,
1392 static struct isp_operations qla81xx_isp_ops
= {
1393 .pci_config
= qla25xx_pci_config
,
1394 .reset_chip
= qla24xx_reset_chip
,
1395 .chip_diag
= qla24xx_chip_diag
,
1396 .config_rings
= qla24xx_config_rings
,
1397 .reset_adapter
= qla24xx_reset_adapter
,
1398 .nvram_config
= qla81xx_nvram_config
,
1399 .update_fw_options
= qla81xx_update_fw_options
,
1400 .load_risc
= qla81xx_load_risc
,
1401 .pci_info_str
= qla24xx_pci_info_str
,
1402 .fw_version_str
= qla24xx_fw_version_str
,
1403 .intr_handler
= qla24xx_intr_handler
,
1404 .enable_intrs
= qla24xx_enable_intrs
,
1405 .disable_intrs
= qla24xx_disable_intrs
,
1406 .abort_command
= qla24xx_abort_command
,
1407 .target_reset
= qla24xx_abort_target
,
1408 .lun_reset
= qla24xx_lun_reset
,
1409 .fabric_login
= qla24xx_login_fabric
,
1410 .fabric_logout
= qla24xx_fabric_logout
,
1411 .calc_req_entries
= NULL
,
1412 .build_iocbs
= NULL
,
1413 .prep_ms_iocb
= qla24xx_prep_ms_iocb
,
1414 .prep_ms_fdmi_iocb
= qla24xx_prep_ms_fdmi_iocb
,
1416 .write_nvram
= NULL
,
1417 .fw_dump
= qla81xx_fw_dump
,
1418 .beacon_on
= qla24xx_beacon_on
,
1419 .beacon_off
= qla24xx_beacon_off
,
1420 .beacon_blink
= qla24xx_beacon_blink
,
1421 .read_optrom
= qla25xx_read_optrom_data
,
1422 .write_optrom
= qla24xx_write_optrom_data
,
1423 .get_flash_version
= qla24xx_get_flash_version
,
1424 .start_scsi
= qla24xx_start_scsi
,
1428 qla2x00_set_isp_flags(struct qla_hw_data
*ha
)
1430 ha
->device_type
= DT_EXTENDED_IDS
;
1431 switch (ha
->pdev
->device
) {
1432 case PCI_DEVICE_ID_QLOGIC_ISP2100
:
1433 ha
->device_type
|= DT_ISP2100
;
1434 ha
->device_type
&= ~DT_EXTENDED_IDS
;
1435 ha
->fw_srisc_address
= RISC_START_ADDRESS_2100
;
1437 case PCI_DEVICE_ID_QLOGIC_ISP2200
:
1438 ha
->device_type
|= DT_ISP2200
;
1439 ha
->device_type
&= ~DT_EXTENDED_IDS
;
1440 ha
->fw_srisc_address
= RISC_START_ADDRESS_2100
;
1442 case PCI_DEVICE_ID_QLOGIC_ISP2300
:
1443 ha
->device_type
|= DT_ISP2300
;
1444 ha
->device_type
|= DT_ZIO_SUPPORTED
;
1445 ha
->fw_srisc_address
= RISC_START_ADDRESS_2300
;
1447 case PCI_DEVICE_ID_QLOGIC_ISP2312
:
1448 ha
->device_type
|= DT_ISP2312
;
1449 ha
->device_type
|= DT_ZIO_SUPPORTED
;
1450 ha
->fw_srisc_address
= RISC_START_ADDRESS_2300
;
1452 case PCI_DEVICE_ID_QLOGIC_ISP2322
:
1453 ha
->device_type
|= DT_ISP2322
;
1454 ha
->device_type
|= DT_ZIO_SUPPORTED
;
1455 if (ha
->pdev
->subsystem_vendor
== 0x1028 &&
1456 ha
->pdev
->subsystem_device
== 0x0170)
1457 ha
->device_type
|= DT_OEM_001
;
1458 ha
->fw_srisc_address
= RISC_START_ADDRESS_2300
;
1460 case PCI_DEVICE_ID_QLOGIC_ISP6312
:
1461 ha
->device_type
|= DT_ISP6312
;
1462 ha
->fw_srisc_address
= RISC_START_ADDRESS_2300
;
1464 case PCI_DEVICE_ID_QLOGIC_ISP6322
:
1465 ha
->device_type
|= DT_ISP6322
;
1466 ha
->fw_srisc_address
= RISC_START_ADDRESS_2300
;
1468 case PCI_DEVICE_ID_QLOGIC_ISP2422
:
1469 ha
->device_type
|= DT_ISP2422
;
1470 ha
->device_type
|= DT_ZIO_SUPPORTED
;
1471 ha
->device_type
|= DT_FWI2
;
1472 ha
->device_type
|= DT_IIDMA
;
1473 ha
->fw_srisc_address
= RISC_START_ADDRESS_2400
;
1475 case PCI_DEVICE_ID_QLOGIC_ISP2432
:
1476 ha
->device_type
|= DT_ISP2432
;
1477 ha
->device_type
|= DT_ZIO_SUPPORTED
;
1478 ha
->device_type
|= DT_FWI2
;
1479 ha
->device_type
|= DT_IIDMA
;
1480 ha
->fw_srisc_address
= RISC_START_ADDRESS_2400
;
1482 case PCI_DEVICE_ID_QLOGIC_ISP8432
:
1483 ha
->device_type
|= DT_ISP8432
;
1484 ha
->device_type
|= DT_ZIO_SUPPORTED
;
1485 ha
->device_type
|= DT_FWI2
;
1486 ha
->device_type
|= DT_IIDMA
;
1487 ha
->fw_srisc_address
= RISC_START_ADDRESS_2400
;
1489 case PCI_DEVICE_ID_QLOGIC_ISP5422
:
1490 ha
->device_type
|= DT_ISP5422
;
1491 ha
->device_type
|= DT_FWI2
;
1492 ha
->fw_srisc_address
= RISC_START_ADDRESS_2400
;
1494 case PCI_DEVICE_ID_QLOGIC_ISP5432
:
1495 ha
->device_type
|= DT_ISP5432
;
1496 ha
->device_type
|= DT_FWI2
;
1497 ha
->fw_srisc_address
= RISC_START_ADDRESS_2400
;
1499 case PCI_DEVICE_ID_QLOGIC_ISP2532
:
1500 ha
->device_type
|= DT_ISP2532
;
1501 ha
->device_type
|= DT_ZIO_SUPPORTED
;
1502 ha
->device_type
|= DT_FWI2
;
1503 ha
->device_type
|= DT_IIDMA
;
1504 ha
->fw_srisc_address
= RISC_START_ADDRESS_2400
;
1506 case PCI_DEVICE_ID_QLOGIC_ISP8001
:
1507 ha
->device_type
|= DT_ISP8001
;
1508 ha
->device_type
|= DT_ZIO_SUPPORTED
;
1509 ha
->device_type
|= DT_FWI2
;
1510 ha
->device_type
|= DT_IIDMA
;
1511 ha
->fw_srisc_address
= RISC_START_ADDRESS_2400
;
1517 qla2x00_iospace_config(struct qla_hw_data
*ha
)
1519 resource_size_t pio
;
1522 if (pci_request_selected_regions(ha
->pdev
, ha
->bars
,
1523 QLA2XXX_DRIVER_NAME
)) {
1524 qla_printk(KERN_WARNING
, ha
,
1525 "Failed to reserve PIO/MMIO regions (%s)\n",
1526 pci_name(ha
->pdev
));
1528 goto iospace_error_exit
;
1530 if (!(ha
->bars
& 1))
1533 /* We only need PIO for Flash operations on ISP2312 v2 chips. */
1534 pio
= pci_resource_start(ha
->pdev
, 0);
1535 if (pci_resource_flags(ha
->pdev
, 0) & IORESOURCE_IO
) {
1536 if (pci_resource_len(ha
->pdev
, 0) < MIN_IOBASE_LEN
) {
1537 qla_printk(KERN_WARNING
, ha
,
1538 "Invalid PCI I/O region size (%s)...\n",
1539 pci_name(ha
->pdev
));
1543 qla_printk(KERN_WARNING
, ha
,
1544 "region #0 not a PIO resource (%s)...\n",
1545 pci_name(ha
->pdev
));
1548 ha
->pio_address
= pio
;
1551 /* Use MMIO operations for all accesses. */
1552 if (!(pci_resource_flags(ha
->pdev
, 1) & IORESOURCE_MEM
)) {
1553 qla_printk(KERN_ERR
, ha
,
1554 "region #1 not an MMIO resource (%s), aborting\n",
1555 pci_name(ha
->pdev
));
1556 goto iospace_error_exit
;
1558 if (pci_resource_len(ha
->pdev
, 1) < MIN_IOBASE_LEN
) {
1559 qla_printk(KERN_ERR
, ha
,
1560 "Invalid PCI mem region size (%s), aborting\n",
1561 pci_name(ha
->pdev
));
1562 goto iospace_error_exit
;
1565 ha
->iobase
= ioremap(pci_resource_start(ha
->pdev
, 1), MIN_IOBASE_LEN
);
1567 qla_printk(KERN_ERR
, ha
,
1568 "cannot remap MMIO (%s), aborting\n", pci_name(ha
->pdev
));
1570 goto iospace_error_exit
;
1573 /* Determine queue resources */
1575 if (ql2xmaxqueues
<= 1 || (!IS_QLA25XX(ha
) && !IS_QLA81XX(ha
)))
1577 ha
->mqiobase
= ioremap(pci_resource_start(ha
->pdev
, 3),
1578 pci_resource_len(ha
->pdev
, 3));
1580 /* Read MSIX vector size of the board */
1581 pci_read_config_word(ha
->pdev
, QLA_PCI_MSIX_CONTROL
, &msix
);
1582 ha
->msix_count
= msix
;
1583 /* Max queues are bounded by available msix vectors */
1584 /* queue 0 uses two msix vectors */
1585 if (ha
->msix_count
- 1 < ql2xmaxqueues
)
1586 ha
->max_queues
= ha
->msix_count
- 1;
1587 else if (ql2xmaxqueues
> QLA_MQ_SIZE
)
1588 ha
->max_queues
= QLA_MQ_SIZE
;
1590 ha
->max_queues
= ql2xmaxqueues
;
1591 qla_printk(KERN_INFO
, ha
,
1592 "MSI-X vector count: %d\n", msix
);
1596 ha
->msix_count
= ha
->max_queues
+ 1;
1604 qla2xxx_scan_start(struct Scsi_Host
*shost
)
1606 scsi_qla_host_t
*vha
= shost_priv(shost
);
1608 set_bit(LOOP_RESYNC_NEEDED
, &vha
->dpc_flags
);
1609 set_bit(LOCAL_LOOP_UPDATE
, &vha
->dpc_flags
);
1610 set_bit(RSCN_UPDATE
, &vha
->dpc_flags
);
1611 set_bit(NPIV_CONFIG_NEEDED
, &vha
->dpc_flags
);
1615 qla2xxx_scan_finished(struct Scsi_Host
*shost
, unsigned long time
)
1617 scsi_qla_host_t
*vha
= shost_priv(shost
);
1621 if (time
> vha
->hw
->loop_reset_delay
* HZ
)
1624 return atomic_read(&vha
->loop_state
) == LOOP_READY
;
1628 * PCI driver interface
1630 static int __devinit
1631 qla2x00_probe_one(struct pci_dev
*pdev
, const struct pci_device_id
*id
)
1634 struct Scsi_Host
*host
;
1635 scsi_qla_host_t
*base_vha
= NULL
;
1636 struct qla_hw_data
*ha
;
1639 struct scsi_host_template
*sht
;
1640 int bars
, max_id
, mem_only
= 0;
1641 uint16_t req_length
= 0, rsp_length
= 0;
1642 struct req_que
*req
= NULL
;
1643 struct rsp_que
*rsp
= NULL
;
1645 bars
= pci_select_bars(pdev
, IORESOURCE_MEM
| IORESOURCE_IO
);
1646 sht
= &qla2xxx_driver_template
;
1647 if (pdev
->device
== PCI_DEVICE_ID_QLOGIC_ISP2422
||
1648 pdev
->device
== PCI_DEVICE_ID_QLOGIC_ISP2432
||
1649 pdev
->device
== PCI_DEVICE_ID_QLOGIC_ISP8432
||
1650 pdev
->device
== PCI_DEVICE_ID_QLOGIC_ISP5422
||
1651 pdev
->device
== PCI_DEVICE_ID_QLOGIC_ISP5432
||
1652 pdev
->device
== PCI_DEVICE_ID_QLOGIC_ISP2532
||
1653 pdev
->device
== PCI_DEVICE_ID_QLOGIC_ISP8001
) {
1654 bars
= pci_select_bars(pdev
, IORESOURCE_MEM
);
1659 if (pci_enable_device_mem(pdev
))
1662 if (pci_enable_device(pdev
))
1666 /* This may fail but that's ok */
1667 pci_enable_pcie_error_reporting(pdev
);
1669 ha
= kzalloc(sizeof(struct qla_hw_data
), GFP_KERNEL
);
1671 DEBUG(printk("Unable to allocate memory for ha\n"));
1676 /* Clear our data area */
1678 ha
->mem_only
= mem_only
;
1679 spin_lock_init(&ha
->hardware_lock
);
1681 /* Set ISP-type information. */
1682 qla2x00_set_isp_flags(ha
);
1683 /* Configure PCI I/O space */
1684 ret
= qla2x00_iospace_config(ha
);
1686 goto probe_hw_failed
;
1688 qla_printk(KERN_INFO
, ha
,
1689 "Found an ISP%04X, irq %d, iobase 0x%p\n", pdev
->device
, pdev
->irq
,
1692 ha
->prev_topology
= 0;
1693 ha
->init_cb_size
= sizeof(init_cb_t
);
1694 ha
->link_data_rate
= PORT_SPEED_UNKNOWN
;
1695 ha
->optrom_size
= OPTROM_SIZE_2300
;
1697 /* Assign ISP specific operations. */
1698 max_id
= MAX_TARGETS_2200
;
1699 if (IS_QLA2100(ha
)) {
1700 max_id
= MAX_TARGETS_2100
;
1701 ha
->mbx_count
= MAILBOX_REGISTER_COUNT_2100
;
1702 req_length
= REQUEST_ENTRY_CNT_2100
;
1703 rsp_length
= RESPONSE_ENTRY_CNT_2100
;
1704 ha
->max_loop_id
= SNS_LAST_LOOP_ID_2100
;
1705 ha
->gid_list_info_size
= 4;
1706 ha
->flash_conf_off
= ~0;
1707 ha
->flash_data_off
= ~0;
1708 ha
->nvram_conf_off
= ~0;
1709 ha
->nvram_data_off
= ~0;
1710 ha
->isp_ops
= &qla2100_isp_ops
;
1711 } else if (IS_QLA2200(ha
)) {
1712 ha
->mbx_count
= MAILBOX_REGISTER_COUNT
;
1713 req_length
= REQUEST_ENTRY_CNT_2200
;
1714 rsp_length
= RESPONSE_ENTRY_CNT_2100
;
1715 ha
->max_loop_id
= SNS_LAST_LOOP_ID_2100
;
1716 ha
->gid_list_info_size
= 4;
1717 ha
->flash_conf_off
= ~0;
1718 ha
->flash_data_off
= ~0;
1719 ha
->nvram_conf_off
= ~0;
1720 ha
->nvram_data_off
= ~0;
1721 ha
->isp_ops
= &qla2100_isp_ops
;
1722 } else if (IS_QLA23XX(ha
)) {
1723 ha
->mbx_count
= MAILBOX_REGISTER_COUNT
;
1724 req_length
= REQUEST_ENTRY_CNT_2200
;
1725 rsp_length
= RESPONSE_ENTRY_CNT_2300
;
1726 ha
->max_loop_id
= SNS_LAST_LOOP_ID_2300
;
1727 ha
->gid_list_info_size
= 6;
1728 if (IS_QLA2322(ha
) || IS_QLA6322(ha
))
1729 ha
->optrom_size
= OPTROM_SIZE_2322
;
1730 ha
->flash_conf_off
= ~0;
1731 ha
->flash_data_off
= ~0;
1732 ha
->nvram_conf_off
= ~0;
1733 ha
->nvram_data_off
= ~0;
1734 ha
->isp_ops
= &qla2300_isp_ops
;
1735 } else if (IS_QLA24XX_TYPE(ha
)) {
1736 ha
->mbx_count
= MAILBOX_REGISTER_COUNT
;
1737 req_length
= REQUEST_ENTRY_CNT_24XX
;
1738 rsp_length
= RESPONSE_ENTRY_CNT_2300
;
1739 ha
->max_loop_id
= SNS_LAST_LOOP_ID_2300
;
1740 ha
->init_cb_size
= sizeof(struct mid_init_cb_24xx
);
1741 ha
->gid_list_info_size
= 8;
1742 ha
->optrom_size
= OPTROM_SIZE_24XX
;
1743 ha
->nvram_npiv_size
= QLA_MAX_VPORTS_QLA24XX
;
1744 ha
->isp_ops
= &qla24xx_isp_ops
;
1745 ha
->flash_conf_off
= FARX_ACCESS_FLASH_CONF
;
1746 ha
->flash_data_off
= FARX_ACCESS_FLASH_DATA
;
1747 ha
->nvram_conf_off
= FARX_ACCESS_NVRAM_CONF
;
1748 ha
->nvram_data_off
= FARX_ACCESS_NVRAM_DATA
;
1749 } else if (IS_QLA25XX(ha
)) {
1750 ha
->mbx_count
= MAILBOX_REGISTER_COUNT
;
1751 req_length
= REQUEST_ENTRY_CNT_24XX
;
1752 rsp_length
= RESPONSE_ENTRY_CNT_2300
;
1753 ha
->max_loop_id
= SNS_LAST_LOOP_ID_2300
;
1754 ha
->init_cb_size
= sizeof(struct mid_init_cb_24xx
);
1755 ha
->gid_list_info_size
= 8;
1756 ha
->optrom_size
= OPTROM_SIZE_25XX
;
1757 ha
->nvram_npiv_size
= QLA_MAX_VPORTS_QLA25XX
;
1758 ha
->isp_ops
= &qla25xx_isp_ops
;
1759 ha
->flash_conf_off
= FARX_ACCESS_FLASH_CONF
;
1760 ha
->flash_data_off
= FARX_ACCESS_FLASH_DATA
;
1761 ha
->nvram_conf_off
= FARX_ACCESS_NVRAM_CONF
;
1762 ha
->nvram_data_off
= FARX_ACCESS_NVRAM_DATA
;
1763 } else if (IS_QLA81XX(ha
)) {
1764 ha
->mbx_count
= MAILBOX_REGISTER_COUNT
;
1765 req_length
= REQUEST_ENTRY_CNT_24XX
;
1766 rsp_length
= RESPONSE_ENTRY_CNT_2300
;
1767 ha
->max_loop_id
= SNS_LAST_LOOP_ID_2300
;
1768 ha
->init_cb_size
= sizeof(struct mid_init_cb_81xx
);
1769 ha
->gid_list_info_size
= 8;
1770 ha
->optrom_size
= OPTROM_SIZE_81XX
;
1771 ha
->isp_ops
= &qla81xx_isp_ops
;
1772 ha
->flash_conf_off
= FARX_ACCESS_FLASH_CONF_81XX
;
1773 ha
->flash_data_off
= FARX_ACCESS_FLASH_DATA_81XX
;
1774 ha
->nvram_conf_off
= ~0;
1775 ha
->nvram_data_off
= ~0;
1778 mutex_init(&ha
->vport_lock
);
1779 init_completion(&ha
->mbx_cmd_comp
);
1780 complete(&ha
->mbx_cmd_comp
);
1781 init_completion(&ha
->mbx_intr_comp
);
1783 set_bit(0, (unsigned long *) ha
->vp_idx_map
);
1785 qla2x00_config_dma_addressing(ha
);
1786 ret
= qla2x00_mem_alloc(ha
, req_length
, rsp_length
, &req
, &rsp
);
1788 qla_printk(KERN_WARNING
, ha
,
1789 "[ERROR] Failed to allocate memory for adapter\n");
1791 goto probe_hw_failed
;
1794 req
->max_q_depth
= MAX_Q_DEPTH
;
1795 if (ql2xmaxqdepth
!= 0 && ql2xmaxqdepth
<= 0xffffU
)
1796 req
->max_q_depth
= ql2xmaxqdepth
;
1799 base_vha
= qla2x00_create_host(sht
, ha
);
1801 qla_printk(KERN_WARNING
, ha
,
1802 "[ERROR] Failed to allocate memory for scsi_host\n");
1805 qla2x00_mem_free(ha
);
1806 qla2x00_free_que(ha
, req
, rsp
);
1807 goto probe_hw_failed
;
1810 pci_set_drvdata(pdev
, base_vha
);
1812 host
= base_vha
->host
;
1813 base_vha
->req_ques
[0] = req
->id
;
1814 host
->can_queue
= req
->length
+ 128;
1815 if (IS_QLA2XXX_MIDTYPE(ha
))
1816 base_vha
->mgmt_svr_loop_id
= 10 + base_vha
->vp_idx
;
1818 base_vha
->mgmt_svr_loop_id
= MANAGEMENT_SERVER
+
1821 host
->sg_tablesize
= 32;
1822 host
->max_id
= max_id
;
1823 host
->this_id
= 255;
1824 host
->cmd_per_lun
= 3;
1825 host
->unique_id
= host
->host_no
;
1826 host
->max_cmd_len
= MAX_CMDSZ
;
1827 host
->max_channel
= MAX_BUSES
- 1;
1828 host
->max_lun
= MAX_LUNS
;
1829 host
->transportt
= qla2xxx_transport_template
;
1831 /* Set up the irqs */
1832 ret
= qla2x00_request_irqs(ha
, rsp
);
1834 goto probe_init_failed
;
1835 /* Alloc arrays of request and response ring ptrs */
1836 if (!qla2x00_alloc_queues(ha
)) {
1837 qla_printk(KERN_WARNING
, ha
,
1838 "[ERROR] Failed to allocate memory for queue"
1840 goto probe_init_failed
;
1842 ha
->rsp_q_map
[0] = rsp
;
1843 ha
->req_q_map
[0] = req
;
1845 /* FWI2-capable only. */
1846 req
->req_q_in
= &ha
->iobase
->isp24
.req_q_in
;
1847 req
->req_q_out
= &ha
->iobase
->isp24
.req_q_out
;
1848 rsp
->rsp_q_in
= &ha
->iobase
->isp24
.rsp_q_in
;
1849 rsp
->rsp_q_out
= &ha
->iobase
->isp24
.rsp_q_out
;
1851 req
->req_q_in
= &ha
->mqiobase
->isp25mq
.req_q_in
;
1852 req
->req_q_out
= &ha
->mqiobase
->isp25mq
.req_q_out
;
1853 rsp
->rsp_q_in
= &ha
->mqiobase
->isp25mq
.rsp_q_in
;
1854 rsp
->rsp_q_out
= &ha
->mqiobase
->isp25mq
.rsp_q_out
;
1857 if (qla2x00_initialize_adapter(base_vha
)) {
1858 qla_printk(KERN_WARNING
, ha
,
1859 "Failed to initialize adapter\n");
1861 DEBUG2(printk("scsi(%ld): Failed to initialize adapter - "
1862 "Adapter flags %x.\n",
1863 base_vha
->host_no
, base_vha
->device_flags
));
1870 * Startup the kernel thread for this host adapter
1872 ha
->dpc_thread
= kthread_create(qla2x00_do_dpc
, ha
,
1873 "%s_dpc", base_vha
->host_str
);
1874 if (IS_ERR(ha
->dpc_thread
)) {
1875 qla_printk(KERN_WARNING
, ha
,
1876 "Unable to start DPC thread!\n");
1877 ret
= PTR_ERR(ha
->dpc_thread
);
1881 list_add_tail(&base_vha
->list
, &ha
->vp_list
);
1882 base_vha
->host
->irq
= ha
->pdev
->irq
;
1884 /* Initialized the timer */
1885 qla2x00_start_timer(base_vha
, qla2x00_timer
, WATCH_INTERVAL
);
1887 DEBUG2(printk("DEBUG: detect hba %ld at address = %p\n",
1888 base_vha
->host_no
, ha
));
1890 base_vha
->flags
.init_done
= 1;
1891 base_vha
->flags
.online
= 1;
1893 ret
= scsi_add_host(host
, &pdev
->dev
);
1897 ha
->isp_ops
->enable_intrs(ha
);
1899 scsi_scan_host(host
);
1901 qla2x00_alloc_sysfs_attr(base_vha
);
1903 qla2x00_init_host_attr(base_vha
);
1905 qla2x00_dfs_setup(base_vha
);
1907 qla_printk(KERN_INFO
, ha
, "\n"
1908 " QLogic Fibre Channel HBA Driver: %s\n"
1910 " ISP%04X: %s @ %s hdma%c, host#=%ld, fw=%s\n",
1911 qla2x00_version_str
, ha
->model_number
,
1912 ha
->model_desc
? ha
->model_desc
: "", pdev
->device
,
1913 ha
->isp_ops
->pci_info_str(base_vha
, pci_info
), pci_name(pdev
),
1914 ha
->flags
.enable_64bit_addressing
? '+' : '-', base_vha
->host_no
,
1915 ha
->isp_ops
->fw_version_str(base_vha
, fw_str
));
1920 qla2x00_free_que(ha
, req
, rsp
);
1924 if (base_vha
->timer_active
)
1925 qla2x00_stop_timer(base_vha
);
1926 base_vha
->flags
.online
= 0;
1927 if (ha
->dpc_thread
) {
1928 struct task_struct
*t
= ha
->dpc_thread
;
1930 ha
->dpc_thread
= NULL
;
1934 qla2x00_free_device(base_vha
);
1936 scsi_host_put(base_vha
->host
);
1940 iounmap(ha
->iobase
);
1942 pci_release_selected_regions(ha
->pdev
, ha
->bars
);
1947 pci_disable_device(pdev
);
1952 qla2x00_remove_one(struct pci_dev
*pdev
)
1954 scsi_qla_host_t
*base_vha
, *vha
, *temp
;
1955 struct qla_hw_data
*ha
;
1957 base_vha
= pci_get_drvdata(pdev
);
1960 list_for_each_entry_safe(vha
, temp
, &ha
->vp_list
, list
) {
1961 if (vha
&& vha
->fc_vport
)
1962 fc_vport_terminate(vha
->fc_vport
);
1965 set_bit(UNLOADING
, &base_vha
->dpc_flags
);
1967 qla2x00_abort_all_cmds(base_vha
, DID_NO_CONNECT
<< 16);
1969 qla2x00_dfs_remove(base_vha
);
1971 qla84xx_put_chip(base_vha
);
1974 if (base_vha
->timer_active
)
1975 qla2x00_stop_timer(base_vha
);
1977 base_vha
->flags
.online
= 0;
1979 /* Kill the kernel thread for this host */
1980 if (ha
->dpc_thread
) {
1981 struct task_struct
*t
= ha
->dpc_thread
;
1984 * qla2xxx_wake_dpc checks for ->dpc_thread
1985 * so we need to zero it out.
1987 ha
->dpc_thread
= NULL
;
1991 qla2x00_free_sysfs_attr(base_vha
);
1993 fc_remove_host(base_vha
->host
);
1995 scsi_remove_host(base_vha
->host
);
1997 qla2x00_free_device(base_vha
);
1999 scsi_host_put(base_vha
->host
);
2002 iounmap(ha
->iobase
);
2005 iounmap(ha
->mqiobase
);
2007 pci_release_selected_regions(ha
->pdev
, ha
->bars
);
2011 pci_disable_device(pdev
);
2012 pci_set_drvdata(pdev
, NULL
);
2016 qla2x00_free_device(scsi_qla_host_t
*vha
)
2018 struct qla_hw_data
*ha
= vha
->hw
;
2020 if (ha
->flags
.fce_enabled
)
2021 qla2x00_disable_fce_trace(vha
, NULL
, NULL
);
2024 qla2x00_disable_eft_trace(vha
);
2026 /* Stop currently executing firmware. */
2027 qla2x00_try_to_stop_firmware(vha
);
2029 /* turn-off interrupts on the card */
2030 if (ha
->interrupts_on
)
2031 ha
->isp_ops
->disable_intrs(ha
);
2033 qla2x00_free_irqs(vha
);
2035 qla2x00_mem_free(ha
);
2037 qla2x00_free_queues(ha
);
2041 qla2x00_schedule_rport_del(struct scsi_qla_host
*vha
, fc_port_t
*fcport
,
2044 struct fc_rport
*rport
;
2049 rport
= fcport
->rport
;
2051 spin_lock_irq(vha
->host
->host_lock
);
2052 fcport
->drport
= rport
;
2053 spin_unlock_irq(vha
->host
->host_lock
);
2054 set_bit(FCPORT_UPDATE_NEEDED
, &vha
->dpc_flags
);
2055 qla2xxx_wake_dpc(vha
);
2057 fc_remote_port_delete(rport
);
2061 * qla2x00_mark_device_lost Updates fcport state when device goes offline.
2063 * Input: ha = adapter block pointer. fcport = port structure pointer.
2069 void qla2x00_mark_device_lost(scsi_qla_host_t
*vha
, fc_port_t
*fcport
,
2070 int do_login
, int defer
)
2072 if (atomic_read(&fcport
->state
) == FCS_ONLINE
&&
2073 vha
->vp_idx
== fcport
->vp_idx
) {
2074 atomic_set(&fcport
->state
, FCS_DEVICE_LOST
);
2075 qla2x00_schedule_rport_del(vha
, fcport
, defer
);
2078 * We may need to retry the login, so don't change the state of the
2079 * port but do the retries.
2081 if (atomic_read(&fcport
->state
) != FCS_DEVICE_DEAD
)
2082 atomic_set(&fcport
->state
, FCS_DEVICE_LOST
);
2087 if (fcport
->login_retry
== 0) {
2088 fcport
->login_retry
= vha
->hw
->login_retry_count
;
2089 set_bit(RELOGIN_NEEDED
, &vha
->dpc_flags
);
2091 DEBUG(printk("scsi(%ld): Port login retry: "
2092 "%02x%02x%02x%02x%02x%02x%02x%02x, "
2093 "id = 0x%04x retry cnt=%d\n",
2095 fcport
->port_name
[0],
2096 fcport
->port_name
[1],
2097 fcport
->port_name
[2],
2098 fcport
->port_name
[3],
2099 fcport
->port_name
[4],
2100 fcport
->port_name
[5],
2101 fcport
->port_name
[6],
2102 fcport
->port_name
[7],
2104 fcport
->login_retry
));
2109 * qla2x00_mark_all_devices_lost
2110 * Updates fcport state when device goes offline.
2113 * ha = adapter block pointer.
2114 * fcport = port structure pointer.
2122 qla2x00_mark_all_devices_lost(scsi_qla_host_t
*vha
, int defer
)
2126 list_for_each_entry(fcport
, &vha
->vp_fcports
, list
) {
2127 if (vha
->vp_idx
!= fcport
->vp_idx
)
2130 * No point in marking the device as lost, if the device is
2133 if (atomic_read(&fcport
->state
) == FCS_DEVICE_DEAD
)
2135 if (atomic_read(&fcport
->state
) == FCS_ONLINE
) {
2136 atomic_set(&fcport
->state
, FCS_DEVICE_LOST
);
2137 qla2x00_schedule_rport_del(vha
, fcport
, defer
);
2139 atomic_set(&fcport
->state
, FCS_DEVICE_LOST
);
2145 * Allocates adapter memory.
2152 qla2x00_mem_alloc(struct qla_hw_data
*ha
, uint16_t req_len
, uint16_t rsp_len
,
2153 struct req_que
**req
, struct rsp_que
**rsp
)
2157 ha
->init_cb
= dma_alloc_coherent(&ha
->pdev
->dev
, ha
->init_cb_size
,
2158 &ha
->init_cb_dma
, GFP_KERNEL
);
2162 ha
->gid_list
= dma_alloc_coherent(&ha
->pdev
->dev
, GID_LIST_SIZE
,
2163 &ha
->gid_list_dma
, GFP_KERNEL
);
2165 goto fail_free_init_cb
;
2167 ha
->srb_mempool
= mempool_create_slab_pool(SRB_MIN_REQ
, srb_cachep
);
2168 if (!ha
->srb_mempool
)
2169 goto fail_free_gid_list
;
2171 /* Get memory for cached NVRAM */
2172 ha
->nvram
= kzalloc(MAX_NVRAM_SIZE
, GFP_KERNEL
);
2174 goto fail_free_srb_mempool
;
2176 snprintf(name
, sizeof(name
), "%s_%d", QLA2XXX_DRIVER_NAME
,
2178 ha
->s_dma_pool
= dma_pool_create(name
, &ha
->pdev
->dev
,
2179 DMA_POOL_SIZE
, 8, 0);
2180 if (!ha
->s_dma_pool
)
2181 goto fail_free_nvram
;
2183 /* Allocate memory for SNS commands */
2184 if (IS_QLA2100(ha
) || IS_QLA2200(ha
)) {
2185 /* Get consistent memory allocated for SNS commands */
2186 ha
->sns_cmd
= dma_alloc_coherent(&ha
->pdev
->dev
,
2187 sizeof(struct sns_cmd_pkt
), &ha
->sns_cmd_dma
, GFP_KERNEL
);
2191 /* Get consistent memory allocated for MS IOCB */
2192 ha
->ms_iocb
= dma_pool_alloc(ha
->s_dma_pool
, GFP_KERNEL
,
2196 /* Get consistent memory allocated for CT SNS commands */
2197 ha
->ct_sns
= dma_alloc_coherent(&ha
->pdev
->dev
,
2198 sizeof(struct ct_sns_pkt
), &ha
->ct_sns_dma
, GFP_KERNEL
);
2200 goto fail_free_ms_iocb
;
2203 /* Allocate memory for request ring */
2204 *req
= kzalloc(sizeof(struct req_que
), GFP_KERNEL
);
2206 DEBUG(printk("Unable to allocate memory for req\n"));
2209 (*req
)->length
= req_len
;
2210 (*req
)->ring
= dma_alloc_coherent(&ha
->pdev
->dev
,
2211 ((*req
)->length
+ 1) * sizeof(request_t
),
2212 &(*req
)->dma
, GFP_KERNEL
);
2213 if (!(*req
)->ring
) {
2214 DEBUG(printk("Unable to allocate memory for req_ring\n"));
2217 /* Allocate memory for response ring */
2218 *rsp
= kzalloc(sizeof(struct rsp_que
), GFP_KERNEL
);
2220 qla_printk(KERN_WARNING
, ha
,
2221 "Unable to allocate memory for rsp\n");
2225 (*rsp
)->length
= rsp_len
;
2226 (*rsp
)->ring
= dma_alloc_coherent(&ha
->pdev
->dev
,
2227 ((*rsp
)->length
+ 1) * sizeof(response_t
),
2228 &(*rsp
)->dma
, GFP_KERNEL
);
2229 if (!(*rsp
)->ring
) {
2230 qla_printk(KERN_WARNING
, ha
,
2231 "Unable to allocate memory for rsp_ring\n");
2236 /* Allocate memory for NVRAM data for vports */
2237 if (ha
->nvram_npiv_size
) {
2238 ha
->npiv_info
= kzalloc(sizeof(struct qla_npiv_entry
) *
2239 ha
->nvram_npiv_size
, GFP_KERNEL
);
2240 if (!ha
->npiv_info
) {
2241 qla_printk(KERN_WARNING
, ha
,
2242 "Unable to allocate memory for npiv info\n");
2243 goto fail_npiv_info
;
2246 ha
->npiv_info
= NULL
;
2248 /* Get consistent memory allocated for EX-INIT-CB. */
2249 if (IS_QLA81XX(ha
)) {
2250 ha
->ex_init_cb
= dma_pool_alloc(ha
->s_dma_pool
, GFP_KERNEL
,
2251 &ha
->ex_init_cb_dma
);
2252 if (!ha
->ex_init_cb
)
2253 goto fail_ex_init_cb
;
2256 INIT_LIST_HEAD(&ha
->vp_list
);
2260 kfree(ha
->npiv_info
);
2262 dma_free_coherent(&ha
->pdev
->dev
, ((*rsp
)->length
+ 1) *
2263 sizeof(response_t
), (*rsp
)->ring
, (*rsp
)->dma
);
2264 (*rsp
)->ring
= NULL
;
2269 dma_free_coherent(&ha
->pdev
->dev
, ((*req
)->length
+ 1) *
2270 sizeof(request_t
), (*req
)->ring
, (*req
)->dma
);
2271 (*req
)->ring
= NULL
;
2276 dma_free_coherent(&ha
->pdev
->dev
, sizeof(struct ct_sns_pkt
),
2277 ha
->ct_sns
, ha
->ct_sns_dma
);
2281 dma_pool_free(ha
->s_dma_pool
, ha
->ms_iocb
, ha
->ms_iocb_dma
);
2283 ha
->ms_iocb_dma
= 0;
2285 dma_pool_destroy(ha
->s_dma_pool
);
2286 ha
->s_dma_pool
= NULL
;
2290 fail_free_srb_mempool
:
2291 mempool_destroy(ha
->srb_mempool
);
2292 ha
->srb_mempool
= NULL
;
2294 dma_free_coherent(&ha
->pdev
->dev
, GID_LIST_SIZE
, ha
->gid_list
,
2296 ha
->gid_list
= NULL
;
2297 ha
->gid_list_dma
= 0;
2299 dma_free_coherent(&ha
->pdev
->dev
, ha
->init_cb_size
, ha
->init_cb
,
2302 ha
->init_cb_dma
= 0;
2304 DEBUG(printk("%s: Memory allocation failure\n", __func__
));
2310 * Frees all adapter allocated memory.
2313 * ha = adapter block pointer.
2316 qla2x00_mem_free(struct qla_hw_data
*ha
)
2318 if (ha
->srb_mempool
)
2319 mempool_destroy(ha
->srb_mempool
);
2322 dma_free_coherent(&ha
->pdev
->dev
, FCE_SIZE
, ha
->fce
,
2327 dma_free_coherent(&ha
->pdev
->dev
,
2328 ntohl(ha
->fw_dump
->eft_size
), ha
->eft
, ha
->eft_dma
);
2333 dma_free_coherent(&ha
->pdev
->dev
, sizeof(struct sns_cmd_pkt
),
2334 ha
->sns_cmd
, ha
->sns_cmd_dma
);
2337 dma_free_coherent(&ha
->pdev
->dev
, sizeof(struct ct_sns_pkt
),
2338 ha
->ct_sns
, ha
->ct_sns_dma
);
2341 dma_pool_free(ha
->s_dma_pool
, ha
->sfp_data
, ha
->sfp_data_dma
);
2344 dma_pool_free(ha
->s_dma_pool
, ha
->edc_data
, ha
->edc_data_dma
);
2347 dma_pool_free(ha
->s_dma_pool
, ha
->ms_iocb
, ha
->ms_iocb_dma
);
2350 dma_pool_free(ha
->s_dma_pool
, ha
->ex_init_cb
, ha
->ex_init_cb_dma
);
2353 dma_pool_destroy(ha
->s_dma_pool
);
2356 dma_free_coherent(&ha
->pdev
->dev
, GID_LIST_SIZE
, ha
->gid_list
,
2360 dma_free_coherent(&ha
->pdev
->dev
, ha
->init_cb_size
,
2361 ha
->init_cb
, ha
->init_cb_dma
);
2362 vfree(ha
->optrom_buffer
);
2364 kfree(ha
->npiv_info
);
2366 ha
->srb_mempool
= NULL
;
2370 ha
->sns_cmd_dma
= 0;
2374 ha
->ms_iocb_dma
= 0;
2376 ha
->init_cb_dma
= 0;
2377 ha
->ex_init_cb
= NULL
;
2378 ha
->ex_init_cb_dma
= 0;
2380 ha
->s_dma_pool
= NULL
;
2382 ha
->gid_list
= NULL
;
2383 ha
->gid_list_dma
= 0;
2387 ha
->fw_dump_reading
= 0;
2390 struct scsi_qla_host
*qla2x00_create_host(struct scsi_host_template
*sht
,
2391 struct qla_hw_data
*ha
)
2393 struct Scsi_Host
*host
;
2394 struct scsi_qla_host
*vha
= NULL
;
2396 host
= scsi_host_alloc(sht
, sizeof(scsi_qla_host_t
));
2399 "qla2xxx: Couldn't allocate host from scsi layer!\n");
2403 /* Clear our data area */
2404 vha
= shost_priv(host
);
2405 memset(vha
, 0, sizeof(scsi_qla_host_t
));
2408 vha
->host_no
= host
->host_no
;
2411 INIT_LIST_HEAD(&vha
->vp_fcports
);
2412 INIT_LIST_HEAD(&vha
->work_list
);
2413 INIT_LIST_HEAD(&vha
->list
);
2415 sprintf(vha
->host_str
, "%s_%ld", QLA2XXX_DRIVER_NAME
, vha
->host_no
);
2422 static struct qla_work_evt
*
2423 qla2x00_alloc_work(struct scsi_qla_host
*vha
, enum qla_work_type type
,
2426 struct qla_work_evt
*e
;
2428 e
= kzalloc(sizeof(struct qla_work_evt
), locked
? GFP_ATOMIC
:
2433 INIT_LIST_HEAD(&e
->list
);
2435 e
->flags
= QLA_EVT_FLAG_FREE
;
2440 qla2x00_post_work(struct scsi_qla_host
*vha
, struct qla_work_evt
*e
, int locked
)
2442 unsigned long uninitialized_var(flags
);
2443 struct qla_hw_data
*ha
= vha
->hw
;
2446 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
2447 list_add_tail(&e
->list
, &vha
->work_list
);
2448 qla2xxx_wake_dpc(vha
);
2450 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
2455 qla2x00_post_aen_work(struct scsi_qla_host
*vha
, enum fc_host_event_code code
,
2458 struct qla_work_evt
*e
;
2460 e
= qla2x00_alloc_work(vha
, QLA_EVT_AEN
, 1);
2462 return QLA_FUNCTION_FAILED
;
2464 e
->u
.aen
.code
= code
;
2465 e
->u
.aen
.data
= data
;
2466 return qla2x00_post_work(vha
, e
, 1);
2470 qla2x00_post_idc_ack_work(struct scsi_qla_host
*vha
, uint16_t *mb
)
2472 struct qla_work_evt
*e
;
2474 e
= qla2x00_alloc_work(vha
, QLA_EVT_IDC_ACK
, 1);
2476 return QLA_FUNCTION_FAILED
;
2478 memcpy(e
->u
.idc_ack
.mb
, mb
, QLA_IDC_ACK_REGS
* sizeof(uint16_t));
2479 return qla2x00_post_work(vha
, e
, 1);
2483 qla2x00_do_work(struct scsi_qla_host
*vha
)
2485 struct qla_work_evt
*e
;
2486 struct qla_hw_data
*ha
= vha
->hw
;
2488 spin_lock_irq(&ha
->hardware_lock
);
2489 while (!list_empty(&vha
->work_list
)) {
2490 e
= list_entry(vha
->work_list
.next
, struct qla_work_evt
, list
);
2491 list_del_init(&e
->list
);
2492 spin_unlock_irq(&ha
->hardware_lock
);
2496 fc_host_post_event(vha
->host
, fc_get_event_number(),
2497 e
->u
.aen
.code
, e
->u
.aen
.data
);
2499 case QLA_EVT_IDC_ACK
:
2500 qla81xx_idc_ack(vha
, e
->u
.idc_ack
.mb
);
2503 if (e
->flags
& QLA_EVT_FLAG_FREE
)
2505 spin_lock_irq(&ha
->hardware_lock
);
2507 spin_unlock_irq(&ha
->hardware_lock
);
2509 /* Relogins all the fcports of a vport
2510 * Context: dpc thread
2512 void qla2x00_relogin(struct scsi_qla_host
*vha
)
2516 uint16_t next_loopid
= 0;
2517 struct qla_hw_data
*ha
= vha
->hw
;
2519 list_for_each_entry(fcport
, &vha
->vp_fcports
, list
) {
2521 * If the port is not ONLINE then try to login
2522 * to it if we haven't run out of retries.
2524 if (atomic_read(&fcport
->state
) !=
2525 FCS_ONLINE
&& fcport
->login_retry
) {
2527 if (fcport
->flags
& FCF_FABRIC_DEVICE
) {
2528 if (fcport
->flags
& FCF_TAPE_PRESENT
)
2529 ha
->isp_ops
->fabric_logout(vha
,
2531 fcport
->d_id
.b
.domain
,
2532 fcport
->d_id
.b
.area
,
2533 fcport
->d_id
.b
.al_pa
);
2535 status
= qla2x00_fabric_login(vha
, fcport
,
2538 status
= qla2x00_local_device_login(vha
,
2541 fcport
->login_retry
--;
2542 if (status
== QLA_SUCCESS
) {
2543 fcport
->old_loop_id
= fcport
->loop_id
;
2545 DEBUG(printk("scsi(%ld): port login OK: logged "
2546 "in ID 0x%x\n", vha
->host_no
, fcport
->loop_id
));
2548 qla2x00_update_fcport(vha
, fcport
);
2550 } else if (status
== 1) {
2551 set_bit(RELOGIN_NEEDED
, &vha
->dpc_flags
);
2552 /* retry the login again */
2553 DEBUG(printk("scsi(%ld): Retrying"
2554 " %d login again loop_id 0x%x\n",
2555 vha
->host_no
, fcport
->login_retry
,
2558 fcport
->login_retry
= 0;
2561 if (fcport
->login_retry
== 0 && status
!= QLA_SUCCESS
)
2562 fcport
->loop_id
= FC_NO_LOOP_ID
;
2564 if (test_bit(LOOP_RESYNC_NEEDED
, &vha
->dpc_flags
))
2569 /**************************************************************************
2571 * This kernel thread is a task that is schedule by the interrupt handler
2572 * to perform the background processing for interrupts.
2575 * This task always run in the context of a kernel thread. It
2576 * is kick-off by the driver's detect code and starts up
2577 * up one per adapter. It immediately goes to sleep and waits for
2578 * some fibre event. When either the interrupt handler or
2579 * the timer routine detects a event it will one of the task
2580 * bits then wake us up.
2581 **************************************************************************/
2583 qla2x00_do_dpc(void *data
)
2586 scsi_qla_host_t
*base_vha
;
2587 struct qla_hw_data
*ha
;
2589 ha
= (struct qla_hw_data
*)data
;
2590 base_vha
= pci_get_drvdata(ha
->pdev
);
2592 set_user_nice(current
, -20);
2594 while (!kthread_should_stop()) {
2595 DEBUG3(printk("qla2x00: DPC handler sleeping\n"));
2597 set_current_state(TASK_INTERRUPTIBLE
);
2599 __set_current_state(TASK_RUNNING
);
2601 DEBUG3(printk("qla2x00: DPC handler waking up\n"));
2603 /* Initialization not yet finished. Don't do anything yet. */
2604 if (!base_vha
->flags
.init_done
)
2607 DEBUG3(printk("scsi(%ld): DPC handler\n", base_vha
->host_no
));
2611 if (ha
->flags
.mbox_busy
) {
2616 qla2x00_do_work(base_vha
);
2618 if (test_and_clear_bit(ISP_ABORT_NEEDED
,
2619 &base_vha
->dpc_flags
)) {
2621 DEBUG(printk("scsi(%ld): dpc: sched "
2622 "qla2x00_abort_isp ha = %p\n",
2623 base_vha
->host_no
, ha
));
2624 if (!(test_and_set_bit(ABORT_ISP_ACTIVE
,
2625 &base_vha
->dpc_flags
))) {
2627 if (qla2x00_abort_isp(base_vha
)) {
2628 /* failed. retry later */
2629 set_bit(ISP_ABORT_NEEDED
,
2630 &base_vha
->dpc_flags
);
2632 clear_bit(ABORT_ISP_ACTIVE
,
2633 &base_vha
->dpc_flags
);
2636 DEBUG(printk("scsi(%ld): dpc: qla2x00_abort_isp end\n",
2637 base_vha
->host_no
));
2640 if (test_bit(FCPORT_UPDATE_NEEDED
, &base_vha
->dpc_flags
)) {
2641 qla2x00_update_fcports(base_vha
);
2642 clear_bit(FCPORT_UPDATE_NEEDED
, &base_vha
->dpc_flags
);
2645 if (test_and_clear_bit(RESET_MARKER_NEEDED
,
2646 &base_vha
->dpc_flags
) &&
2647 (!(test_and_set_bit(RESET_ACTIVE
, &base_vha
->dpc_flags
)))) {
2649 DEBUG(printk("scsi(%ld): qla2x00_reset_marker()\n",
2650 base_vha
->host_no
));
2652 qla2x00_rst_aen(base_vha
);
2653 clear_bit(RESET_ACTIVE
, &base_vha
->dpc_flags
);
2656 /* Retry each device up to login retry count */
2657 if ((test_and_clear_bit(RELOGIN_NEEDED
,
2658 &base_vha
->dpc_flags
)) &&
2659 !test_bit(LOOP_RESYNC_NEEDED
, &base_vha
->dpc_flags
) &&
2660 atomic_read(&base_vha
->loop_state
) != LOOP_DOWN
) {
2662 DEBUG(printk("scsi(%ld): qla2x00_port_login()\n",
2663 base_vha
->host_no
));
2664 qla2x00_relogin(base_vha
);
2666 DEBUG(printk("scsi(%ld): qla2x00_port_login - end\n",
2667 base_vha
->host_no
));
2670 if (test_and_clear_bit(LOOP_RESYNC_NEEDED
,
2671 &base_vha
->dpc_flags
)) {
2673 DEBUG(printk("scsi(%ld): qla2x00_loop_resync()\n",
2674 base_vha
->host_no
));
2676 if (!(test_and_set_bit(LOOP_RESYNC_ACTIVE
,
2677 &base_vha
->dpc_flags
))) {
2679 rval
= qla2x00_loop_resync(base_vha
);
2681 clear_bit(LOOP_RESYNC_ACTIVE
,
2682 &base_vha
->dpc_flags
);
2685 DEBUG(printk("scsi(%ld): qla2x00_loop_resync - end\n",
2686 base_vha
->host_no
));
2689 if (test_bit(NPIV_CONFIG_NEEDED
, &base_vha
->dpc_flags
) &&
2690 atomic_read(&base_vha
->loop_state
) == LOOP_READY
) {
2691 clear_bit(NPIV_CONFIG_NEEDED
, &base_vha
->dpc_flags
);
2692 qla2xxx_flash_npiv_conf(base_vha
);
2695 if (!ha
->interrupts_on
)
2696 ha
->isp_ops
->enable_intrs(ha
);
2698 if (test_and_clear_bit(BEACON_BLINK_NEEDED
,
2699 &base_vha
->dpc_flags
))
2700 ha
->isp_ops
->beacon_blink(base_vha
);
2702 qla2x00_do_dpc_all_vps(base_vha
);
2705 } /* End of while(1) */
2707 DEBUG(printk("scsi(%ld): DPC handler exiting\n", base_vha
->host_no
));
2710 * Make sure that nobody tries to wake us up again.
2718 qla2xxx_wake_dpc(struct scsi_qla_host
*vha
)
2720 struct qla_hw_data
*ha
= vha
->hw
;
2721 struct task_struct
*t
= ha
->dpc_thread
;
2723 if (!test_bit(UNLOADING
, &vha
->dpc_flags
) && t
)
2729 * Processes asynchronous reset.
2732 * ha = adapter block pointer.
2735 qla2x00_rst_aen(scsi_qla_host_t
*vha
)
2737 if (vha
->flags
.online
&& !vha
->flags
.reset_active
&&
2738 !atomic_read(&vha
->loop_down_timer
) &&
2739 !(test_bit(ABORT_ISP_ACTIVE
, &vha
->dpc_flags
))) {
2741 clear_bit(RESET_MARKER_NEEDED
, &vha
->dpc_flags
);
2744 * Issue marker command only when we are going to start
2747 vha
->marker_needed
= 1;
2748 } while (!atomic_read(&vha
->loop_down_timer
) &&
2749 (test_bit(RESET_MARKER_NEEDED
, &vha
->dpc_flags
)));
2754 qla2x00_sp_free_dma(srb_t
*sp
)
2756 struct scsi_cmnd
*cmd
= sp
->cmd
;
2758 if (sp
->flags
& SRB_DMA_VALID
) {
2759 scsi_dma_unmap(cmd
);
2760 sp
->flags
&= ~SRB_DMA_VALID
;
2766 qla2x00_sp_compl(struct qla_hw_data
*ha
, srb_t
*sp
)
2768 struct scsi_cmnd
*cmd
= sp
->cmd
;
2770 qla2x00_sp_free_dma(sp
);
2772 mempool_free(sp
, ha
->srb_mempool
);
2774 cmd
->scsi_done(cmd
);
2777 /**************************************************************************
2783 * Context: Interrupt
2784 ***************************************************************************/
2786 qla2x00_timer(scsi_qla_host_t
*vha
)
2788 unsigned long cpu_flags
= 0;
2794 struct qla_hw_data
*ha
= vha
->hw
;
2795 struct req_que
*req
;
2797 * Ports - Port down timer.
2799 * Whenever, a port is in the LOST state we start decrementing its port
2800 * down timer every second until it reaches zero. Once it reaches zero
2801 * the port it marked DEAD.
2804 list_for_each_entry(fcport
, &vha
->vp_fcports
, list
) {
2805 if (fcport
->port_type
!= FCT_TARGET
)
2808 if (atomic_read(&fcport
->state
) == FCS_DEVICE_LOST
) {
2810 if (atomic_read(&fcport
->port_down_timer
) == 0)
2813 if (atomic_dec_and_test(&fcport
->port_down_timer
) != 0)
2814 atomic_set(&fcport
->state
, FCS_DEVICE_DEAD
);
2816 DEBUG(printk("scsi(%ld): fcport-%d - port retry count: "
2819 t
, atomic_read(&fcport
->port_down_timer
)));
2822 } /* End of for fcport */
2825 /* Loop down handler. */
2826 if (atomic_read(&vha
->loop_down_timer
) > 0 &&
2827 !(test_bit(ABORT_ISP_ACTIVE
, &vha
->dpc_flags
))
2828 && vha
->flags
.online
) {
2830 if (atomic_read(&vha
->loop_down_timer
) ==
2831 vha
->loop_down_abort_time
) {
2833 DEBUG(printk("scsi(%ld): Loop Down - aborting the "
2834 "queues before time expire\n",
2837 if (!IS_QLA2100(ha
) && vha
->link_down_timeout
)
2838 atomic_set(&vha
->loop_state
, LOOP_DEAD
);
2840 /* Schedule an ISP abort to return any tape commands. */
2841 /* NPIV - scan physical port only */
2843 spin_lock_irqsave(&ha
->hardware_lock
,
2845 req
= ha
->req_q_map
[0];
2847 index
< MAX_OUTSTANDING_COMMANDS
;
2851 sp
= req
->outstanding_cmds
[index
];
2855 if (!(sfcp
->flags
& FCF_TAPE_PRESENT
))
2858 set_bit(ISP_ABORT_NEEDED
,
2862 spin_unlock_irqrestore(&ha
->hardware_lock
,
2868 /* if the loop has been down for 4 minutes, reinit adapter */
2869 if (atomic_dec_and_test(&vha
->loop_down_timer
) != 0) {
2870 if (!(vha
->device_flags
& DFLG_NO_CABLE
) &&
2872 DEBUG(printk("scsi(%ld): Loop down - "
2875 qla_printk(KERN_WARNING
, ha
,
2876 "Loop down - aborting ISP.\n");
2878 set_bit(ISP_ABORT_NEEDED
, &vha
->dpc_flags
);
2881 DEBUG3(printk("scsi(%ld): Loop Down - seconds remaining %d\n",
2883 atomic_read(&vha
->loop_down_timer
)));
2886 /* Check if beacon LED needs to be blinked */
2887 if (ha
->beacon_blink_led
== 1) {
2888 set_bit(BEACON_BLINK_NEEDED
, &vha
->dpc_flags
);
2892 /* Process any deferred work. */
2893 if (!list_empty(&vha
->work_list
))
2896 /* Schedule the DPC routine if needed */
2897 if ((test_bit(ISP_ABORT_NEEDED
, &vha
->dpc_flags
) ||
2898 test_bit(LOOP_RESYNC_NEEDED
, &vha
->dpc_flags
) ||
2899 test_bit(FCPORT_UPDATE_NEEDED
, &vha
->dpc_flags
) ||
2901 test_bit(RESET_MARKER_NEEDED
, &vha
->dpc_flags
) ||
2902 test_bit(BEACON_BLINK_NEEDED
, &vha
->dpc_flags
) ||
2903 test_bit(VP_DPC_NEEDED
, &vha
->dpc_flags
) ||
2904 test_bit(RELOGIN_NEEDED
, &vha
->dpc_flags
)))
2905 qla2xxx_wake_dpc(vha
);
2907 qla2x00_restart_timer(vha
, WATCH_INTERVAL
);
2910 /* Firmware interface routines. */
2913 #define FW_ISP21XX 0
2914 #define FW_ISP22XX 1
2915 #define FW_ISP2300 2
2916 #define FW_ISP2322 3
2917 #define FW_ISP24XX 4
2918 #define FW_ISP25XX 5
2919 #define FW_ISP81XX 6
2921 #define FW_FILE_ISP21XX "ql2100_fw.bin"
2922 #define FW_FILE_ISP22XX "ql2200_fw.bin"
2923 #define FW_FILE_ISP2300 "ql2300_fw.bin"
2924 #define FW_FILE_ISP2322 "ql2322_fw.bin"
2925 #define FW_FILE_ISP24XX "ql2400_fw.bin"
2926 #define FW_FILE_ISP25XX "ql2500_fw.bin"
2927 #define FW_FILE_ISP81XX "ql8100_fw.bin"
2929 static DEFINE_MUTEX(qla_fw_lock
);
2931 static struct fw_blob qla_fw_blobs
[FW_BLOBS
] = {
2932 { .name
= FW_FILE_ISP21XX
, .segs
= { 0x1000, 0 }, },
2933 { .name
= FW_FILE_ISP22XX
, .segs
= { 0x1000, 0 }, },
2934 { .name
= FW_FILE_ISP2300
, .segs
= { 0x800, 0 }, },
2935 { .name
= FW_FILE_ISP2322
, .segs
= { 0x800, 0x1c000, 0x1e000, 0 }, },
2936 { .name
= FW_FILE_ISP24XX
, },
2937 { .name
= FW_FILE_ISP25XX
, },
2938 { .name
= FW_FILE_ISP81XX
, },
2942 qla2x00_request_firmware(scsi_qla_host_t
*vha
)
2944 struct qla_hw_data
*ha
= vha
->hw
;
2945 struct fw_blob
*blob
;
2948 if (IS_QLA2100(ha
)) {
2949 blob
= &qla_fw_blobs
[FW_ISP21XX
];
2950 } else if (IS_QLA2200(ha
)) {
2951 blob
= &qla_fw_blobs
[FW_ISP22XX
];
2952 } else if (IS_QLA2300(ha
) || IS_QLA2312(ha
) || IS_QLA6312(ha
)) {
2953 blob
= &qla_fw_blobs
[FW_ISP2300
];
2954 } else if (IS_QLA2322(ha
) || IS_QLA6322(ha
)) {
2955 blob
= &qla_fw_blobs
[FW_ISP2322
];
2956 } else if (IS_QLA24XX_TYPE(ha
)) {
2957 blob
= &qla_fw_blobs
[FW_ISP24XX
];
2958 } else if (IS_QLA25XX(ha
)) {
2959 blob
= &qla_fw_blobs
[FW_ISP25XX
];
2960 } else if (IS_QLA81XX(ha
)) {
2961 blob
= &qla_fw_blobs
[FW_ISP81XX
];
2964 mutex_lock(&qla_fw_lock
);
2968 if (request_firmware(&blob
->fw
, blob
->name
, &ha
->pdev
->dev
)) {
2969 DEBUG2(printk("scsi(%ld): Failed to load firmware image "
2970 "(%s).\n", vha
->host_no
, blob
->name
));
2977 mutex_unlock(&qla_fw_lock
);
2982 qla2x00_release_firmware(void)
2986 mutex_lock(&qla_fw_lock
);
2987 for (idx
= 0; idx
< FW_BLOBS
; idx
++)
2988 if (qla_fw_blobs
[idx
].fw
)
2989 release_firmware(qla_fw_blobs
[idx
].fw
);
2990 mutex_unlock(&qla_fw_lock
);
2993 static pci_ers_result_t
2994 qla2xxx_pci_error_detected(struct pci_dev
*pdev
, pci_channel_state_t state
)
2996 scsi_qla_host_t
*base_vha
= pci_get_drvdata(pdev
);
2999 case pci_channel_io_normal
:
3000 return PCI_ERS_RESULT_CAN_RECOVER
;
3001 case pci_channel_io_frozen
:
3002 pci_disable_device(pdev
);
3003 return PCI_ERS_RESULT_NEED_RESET
;
3004 case pci_channel_io_perm_failure
:
3005 qla2x00_abort_all_cmds(base_vha
, DID_NO_CONNECT
<< 16);
3006 return PCI_ERS_RESULT_DISCONNECT
;
3008 return PCI_ERS_RESULT_NEED_RESET
;
3011 static pci_ers_result_t
3012 qla2xxx_pci_mmio_enabled(struct pci_dev
*pdev
)
3014 int risc_paused
= 0;
3016 unsigned long flags
;
3017 scsi_qla_host_t
*base_vha
= pci_get_drvdata(pdev
);
3018 struct qla_hw_data
*ha
= base_vha
->hw
;
3019 struct device_reg_2xxx __iomem
*reg
= &ha
->iobase
->isp
;
3020 struct device_reg_24xx __iomem
*reg24
= &ha
->iobase
->isp24
;
3022 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
3023 if (IS_QLA2100(ha
) || IS_QLA2200(ha
)){
3024 stat
= RD_REG_DWORD(®
->hccr
);
3025 if (stat
& HCCR_RISC_PAUSE
)
3027 } else if (IS_QLA23XX(ha
)) {
3028 stat
= RD_REG_DWORD(®
->u
.isp2300
.host_status
);
3029 if (stat
& HSR_RISC_PAUSED
)
3031 } else if (IS_FWI2_CAPABLE(ha
)) {
3032 stat
= RD_REG_DWORD(®24
->host_status
);
3033 if (stat
& HSRX_RISC_PAUSED
)
3036 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
3039 qla_printk(KERN_INFO
, ha
, "RISC paused -- mmio_enabled, "
3040 "Dumping firmware!\n");
3041 ha
->isp_ops
->fw_dump(base_vha
, 0);
3043 return PCI_ERS_RESULT_NEED_RESET
;
3045 return PCI_ERS_RESULT_RECOVERED
;
3048 static pci_ers_result_t
3049 qla2xxx_pci_slot_reset(struct pci_dev
*pdev
)
3051 pci_ers_result_t ret
= PCI_ERS_RESULT_DISCONNECT
;
3052 scsi_qla_host_t
*base_vha
= pci_get_drvdata(pdev
);
3053 struct qla_hw_data
*ha
= base_vha
->hw
;
3057 rc
= pci_enable_device_mem(pdev
);
3059 rc
= pci_enable_device(pdev
);
3062 qla_printk(KERN_WARNING
, ha
,
3063 "Can't re-enable PCI device after reset.\n");
3067 pci_set_master(pdev
);
3069 if (ha
->isp_ops
->pci_config(base_vha
))
3072 set_bit(ABORT_ISP_ACTIVE
, &base_vha
->dpc_flags
);
3073 if (qla2x00_abort_isp(base_vha
) == QLA_SUCCESS
)
3074 ret
= PCI_ERS_RESULT_RECOVERED
;
3075 clear_bit(ABORT_ISP_ACTIVE
, &base_vha
->dpc_flags
);
3081 qla2xxx_pci_resume(struct pci_dev
*pdev
)
3083 scsi_qla_host_t
*base_vha
= pci_get_drvdata(pdev
);
3084 struct qla_hw_data
*ha
= base_vha
->hw
;
3087 ret
= qla2x00_wait_for_hba_online(base_vha
);
3088 if (ret
!= QLA_SUCCESS
) {
3089 qla_printk(KERN_ERR
, ha
,
3090 "the device failed to resume I/O "
3091 "from slot/link_reset");
3093 pci_cleanup_aer_uncorrect_error_status(pdev
);
3096 static struct pci_error_handlers qla2xxx_err_handler
= {
3097 .error_detected
= qla2xxx_pci_error_detected
,
3098 .mmio_enabled
= qla2xxx_pci_mmio_enabled
,
3099 .slot_reset
= qla2xxx_pci_slot_reset
,
3100 .resume
= qla2xxx_pci_resume
,
3103 static struct pci_device_id qla2xxx_pci_tbl
[] = {
3104 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC
, PCI_DEVICE_ID_QLOGIC_ISP2100
) },
3105 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC
, PCI_DEVICE_ID_QLOGIC_ISP2200
) },
3106 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC
, PCI_DEVICE_ID_QLOGIC_ISP2300
) },
3107 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC
, PCI_DEVICE_ID_QLOGIC_ISP2312
) },
3108 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC
, PCI_DEVICE_ID_QLOGIC_ISP2322
) },
3109 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC
, PCI_DEVICE_ID_QLOGIC_ISP6312
) },
3110 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC
, PCI_DEVICE_ID_QLOGIC_ISP6322
) },
3111 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC
, PCI_DEVICE_ID_QLOGIC_ISP2422
) },
3112 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC
, PCI_DEVICE_ID_QLOGIC_ISP2432
) },
3113 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC
, PCI_DEVICE_ID_QLOGIC_ISP8432
) },
3114 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC
, PCI_DEVICE_ID_QLOGIC_ISP5422
) },
3115 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC
, PCI_DEVICE_ID_QLOGIC_ISP5432
) },
3116 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC
, PCI_DEVICE_ID_QLOGIC_ISP2532
) },
3117 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC
, PCI_DEVICE_ID_QLOGIC_ISP8001
) },
3120 MODULE_DEVICE_TABLE(pci
, qla2xxx_pci_tbl
);
3122 static struct pci_driver qla2xxx_pci_driver
= {
3123 .name
= QLA2XXX_DRIVER_NAME
,
3125 .owner
= THIS_MODULE
,
3127 .id_table
= qla2xxx_pci_tbl
,
3128 .probe
= qla2x00_probe_one
,
3129 .remove
= qla2x00_remove_one
,
3130 .err_handler
= &qla2xxx_err_handler
,
3134 * qla2x00_module_init - Module initialization.
3137 qla2x00_module_init(void)
3141 /* Allocate cache for SRBs. */
3142 srb_cachep
= kmem_cache_create("qla2xxx_srbs", sizeof(srb_t
), 0,
3143 SLAB_HWCACHE_ALIGN
, NULL
);
3144 if (srb_cachep
== NULL
) {
3146 "qla2xxx: Unable to allocate SRB cache...Failing load!\n");
3150 /* Derive version string. */
3151 strcpy(qla2x00_version_str
, QLA2XXX_VERSION
);
3152 if (ql2xextended_error_logging
)
3153 strcat(qla2x00_version_str
, "-debug");
3155 qla2xxx_transport_template
=
3156 fc_attach_transport(&qla2xxx_transport_functions
);
3157 if (!qla2xxx_transport_template
) {
3158 kmem_cache_destroy(srb_cachep
);
3161 qla2xxx_transport_vport_template
=
3162 fc_attach_transport(&qla2xxx_transport_vport_functions
);
3163 if (!qla2xxx_transport_vport_template
) {
3164 kmem_cache_destroy(srb_cachep
);
3165 fc_release_transport(qla2xxx_transport_template
);
3169 printk(KERN_INFO
"QLogic Fibre Channel HBA Driver: %s\n",
3170 qla2x00_version_str
);
3171 ret
= pci_register_driver(&qla2xxx_pci_driver
);
3173 kmem_cache_destroy(srb_cachep
);
3174 fc_release_transport(qla2xxx_transport_template
);
3175 fc_release_transport(qla2xxx_transport_vport_template
);
3181 * qla2x00_module_exit - Module cleanup.
3184 qla2x00_module_exit(void)
3186 pci_unregister_driver(&qla2xxx_pci_driver
);
3187 qla2x00_release_firmware();
3188 kmem_cache_destroy(srb_cachep
);
3189 fc_release_transport(qla2xxx_transport_template
);
3190 fc_release_transport(qla2xxx_transport_vport_template
);
3193 module_init(qla2x00_module_init
);
3194 module_exit(qla2x00_module_exit
);
3196 MODULE_AUTHOR("QLogic Corporation");
3197 MODULE_DESCRIPTION("QLogic Fibre Channel HBA Driver");
3198 MODULE_LICENSE("GPL");
3199 MODULE_VERSION(QLA2XXX_VERSION
);
3200 MODULE_FIRMWARE(FW_FILE_ISP21XX
);
3201 MODULE_FIRMWARE(FW_FILE_ISP22XX
);
3202 MODULE_FIRMWARE(FW_FILE_ISP2300
);
3203 MODULE_FIRMWARE(FW_FILE_ISP2322
);
3204 MODULE_FIRMWARE(FW_FILE_ISP24XX
);
3205 MODULE_FIRMWARE(FW_FILE_ISP25XX
);
3206 MODULE_FIRMWARE(FW_FILE_ISP81XX
);