2 * QLogic Fibre Channel HBA Driver
3 * Copyright (c) 2003-2012 QLogic Corporation
5 * See LICENSE.qla2xxx for copyright and licensing details.
8 #include "qla_target.h"
10 #include <linux/delay.h>
11 #include <linux/slab.h>
12 #include <scsi/scsi_tcq.h>
13 #include <scsi/scsi_bsg_fc.h>
14 #include <scsi/scsi_eh.h>
16 #include "qla_target.h"
18 static void qla2x00_mbx_completion(scsi_qla_host_t
*, uint16_t);
19 static void qla2x00_process_completed_request(struct scsi_qla_host
*,
20 struct req_que
*, uint32_t);
21 static void qla2x00_status_entry(scsi_qla_host_t
*, struct rsp_que
*, void *);
22 static void qla2x00_status_cont_entry(struct rsp_que
*, sts_cont_entry_t
*);
23 static void qla2x00_error_entry(scsi_qla_host_t
*, struct rsp_que
*,
27 * qla2100_intr_handler() - Process interrupts for the ISP2100 and ISP2200.
29 * @dev_id: SCSI driver HA context
31 * Called by system whenever the host adapter generates an interrupt.
33 * Returns handled flag.
36 qla2100_intr_handler(int irq
, void *dev_id
)
39 struct qla_hw_data
*ha
;
40 struct device_reg_2xxx __iomem
*reg
;
48 rsp
= (struct rsp_que
*) dev_id
;
50 ql_log(ql_log_info
, NULL
, 0x505d,
51 "%s: NULL response queue pointer.\n", __func__
);
56 reg
= &ha
->iobase
->isp
;
59 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
60 vha
= pci_get_drvdata(ha
->pdev
);
61 for (iter
= 50; iter
--; ) {
62 hccr
= RD_REG_WORD(®
->hccr
);
63 if (hccr
& HCCR_RISC_PAUSE
) {
64 if (pci_channel_offline(ha
->pdev
))
68 * Issue a "HARD" reset in order for the RISC interrupt
69 * bit to be cleared. Schedule a big hammer to get
70 * out of the RISC PAUSED state.
72 WRT_REG_WORD(®
->hccr
, HCCR_RESET_RISC
);
73 RD_REG_WORD(®
->hccr
);
75 ha
->isp_ops
->fw_dump(vha
, 1);
76 set_bit(ISP_ABORT_NEEDED
, &vha
->dpc_flags
);
78 } else if ((RD_REG_WORD(®
->istatus
) & ISR_RISC_INT
) == 0)
81 if (RD_REG_WORD(®
->semaphore
) & BIT_0
) {
82 WRT_REG_WORD(®
->hccr
, HCCR_CLR_RISC_INT
);
83 RD_REG_WORD(®
->hccr
);
85 /* Get mailbox data. */
86 mb
[0] = RD_MAILBOX_REG(ha
, reg
, 0);
87 if (mb
[0] > 0x3fff && mb
[0] < 0x8000) {
88 qla2x00_mbx_completion(vha
, mb
[0]);
89 status
|= MBX_INTERRUPT
;
90 } else if (mb
[0] > 0x7fff && mb
[0] < 0xc000) {
91 mb
[1] = RD_MAILBOX_REG(ha
, reg
, 1);
92 mb
[2] = RD_MAILBOX_REG(ha
, reg
, 2);
93 mb
[3] = RD_MAILBOX_REG(ha
, reg
, 3);
94 qla2x00_async_event(vha
, rsp
, mb
);
97 ql_dbg(ql_dbg_async
, vha
, 0x5025,
98 "Unrecognized interrupt type (%d).\n",
101 /* Release mailbox registers. */
102 WRT_REG_WORD(®
->semaphore
, 0);
103 RD_REG_WORD(®
->semaphore
);
105 qla2x00_process_response_queue(rsp
);
107 WRT_REG_WORD(®
->hccr
, HCCR_CLR_RISC_INT
);
108 RD_REG_WORD(®
->hccr
);
111 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
113 if (test_bit(MBX_INTR_WAIT
, &ha
->mbx_cmd_flags
) &&
114 (status
& MBX_INTERRUPT
) && ha
->flags
.mbox_int
) {
115 set_bit(MBX_INTERRUPT
, &ha
->mbx_cmd_flags
);
116 complete(&ha
->mbx_intr_comp
);
119 return (IRQ_HANDLED
);
123 * qla2300_intr_handler() - Process interrupts for the ISP23xx and ISP63xx.
125 * @dev_id: SCSI driver HA context
127 * Called by system whenever the host adapter generates an interrupt.
129 * Returns handled flag.
132 qla2300_intr_handler(int irq
, void *dev_id
)
134 scsi_qla_host_t
*vha
;
135 struct device_reg_2xxx __iomem
*reg
;
142 struct qla_hw_data
*ha
;
145 rsp
= (struct rsp_que
*) dev_id
;
147 ql_log(ql_log_info
, NULL
, 0x5058,
148 "%s: NULL response queue pointer.\n", __func__
);
153 reg
= &ha
->iobase
->isp
;
156 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
157 vha
= pci_get_drvdata(ha
->pdev
);
158 for (iter
= 50; iter
--; ) {
159 stat
= RD_REG_DWORD(®
->u
.isp2300
.host_status
);
160 if (stat
& HSR_RISC_PAUSED
) {
161 if (unlikely(pci_channel_offline(ha
->pdev
)))
164 hccr
= RD_REG_WORD(®
->hccr
);
165 if (hccr
& (BIT_15
| BIT_13
| BIT_11
| BIT_8
))
166 ql_log(ql_log_warn
, vha
, 0x5026,
167 "Parity error -- HCCR=%x, Dumping "
168 "firmware.\n", hccr
);
170 ql_log(ql_log_warn
, vha
, 0x5027,
171 "RISC paused -- HCCR=%x, Dumping "
172 "firmware.\n", hccr
);
175 * Issue a "HARD" reset in order for the RISC
176 * interrupt bit to be cleared. Schedule a big
177 * hammer to get out of the RISC PAUSED state.
179 WRT_REG_WORD(®
->hccr
, HCCR_RESET_RISC
);
180 RD_REG_WORD(®
->hccr
);
182 ha
->isp_ops
->fw_dump(vha
, 1);
183 set_bit(ISP_ABORT_NEEDED
, &vha
->dpc_flags
);
185 } else if ((stat
& HSR_RISC_INT
) == 0)
188 switch (stat
& 0xff) {
193 qla2x00_mbx_completion(vha
, MSW(stat
));
194 status
|= MBX_INTERRUPT
;
196 /* Release mailbox registers. */
197 WRT_REG_WORD(®
->semaphore
, 0);
201 mb
[1] = RD_MAILBOX_REG(ha
, reg
, 1);
202 mb
[2] = RD_MAILBOX_REG(ha
, reg
, 2);
203 mb
[3] = RD_MAILBOX_REG(ha
, reg
, 3);
204 qla2x00_async_event(vha
, rsp
, mb
);
207 qla2x00_process_response_queue(rsp
);
210 mb
[0] = MBA_CMPLT_1_16BIT
;
212 qla2x00_async_event(vha
, rsp
, mb
);
215 mb
[0] = MBA_SCSI_COMPLETION
;
217 mb
[2] = RD_MAILBOX_REG(ha
, reg
, 2);
218 qla2x00_async_event(vha
, rsp
, mb
);
221 ql_dbg(ql_dbg_async
, vha
, 0x5028,
222 "Unrecognized interrupt type (%d).\n", stat
& 0xff);
225 WRT_REG_WORD(®
->hccr
, HCCR_CLR_RISC_INT
);
226 RD_REG_WORD_RELAXED(®
->hccr
);
228 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
230 if (test_bit(MBX_INTR_WAIT
, &ha
->mbx_cmd_flags
) &&
231 (status
& MBX_INTERRUPT
) && ha
->flags
.mbox_int
) {
232 set_bit(MBX_INTERRUPT
, &ha
->mbx_cmd_flags
);
233 complete(&ha
->mbx_intr_comp
);
236 return (IRQ_HANDLED
);
240 * qla2x00_mbx_completion() - Process mailbox command completions.
241 * @ha: SCSI driver HA context
242 * @mb0: Mailbox0 register
245 qla2x00_mbx_completion(scsi_qla_host_t
*vha
, uint16_t mb0
)
249 uint16_t __iomem
*wptr
;
250 struct qla_hw_data
*ha
= vha
->hw
;
251 struct device_reg_2xxx __iomem
*reg
= &ha
->iobase
->isp
;
253 /* Read all mbox registers? */
254 mboxes
= (1 << ha
->mbx_count
) - 1;
256 ql_dbg(ql_dbg_async
, vha
, 0x5001, "MBX pointer ERROR.\n");
258 mboxes
= ha
->mcp
->in_mb
;
260 /* Load return mailbox registers. */
261 ha
->flags
.mbox_int
= 1;
262 ha
->mailbox_out
[0] = mb0
;
264 wptr
= (uint16_t __iomem
*)MAILBOX_REG(ha
, reg
, 1);
266 for (cnt
= 1; cnt
< ha
->mbx_count
; cnt
++) {
267 if (IS_QLA2200(ha
) && cnt
== 8)
268 wptr
= (uint16_t __iomem
*)MAILBOX_REG(ha
, reg
, 8);
269 if ((cnt
== 4 || cnt
== 5) && (mboxes
& BIT_0
))
270 ha
->mailbox_out
[cnt
] = qla2x00_debounce_register(wptr
);
271 else if (mboxes
& BIT_0
)
272 ha
->mailbox_out
[cnt
] = RD_REG_WORD(wptr
);
280 qla81xx_idc_event(scsi_qla_host_t
*vha
, uint16_t aen
, uint16_t descr
)
282 static char *event
[] =
283 { "Complete", "Request Notification", "Time Extension" };
285 struct device_reg_24xx __iomem
*reg24
= &vha
->hw
->iobase
->isp24
;
286 uint16_t __iomem
*wptr
;
287 uint16_t cnt
, timeout
, mb
[QLA_IDC_ACK_REGS
];
289 /* Seed data -- mailbox1 -> mailbox7. */
290 wptr
= (uint16_t __iomem
*)®24
->mailbox1
;
291 for (cnt
= 0; cnt
< QLA_IDC_ACK_REGS
; cnt
++, wptr
++)
292 mb
[cnt
] = RD_REG_WORD(wptr
);
294 ql_dbg(ql_dbg_async
, vha
, 0x5021,
295 "Inter-Driver Communication %s -- "
296 "%04x %04x %04x %04x %04x %04x %04x.\n",
297 event
[aen
& 0xff], mb
[0], mb
[1], mb
[2], mb
[3],
298 mb
[4], mb
[5], mb
[6]);
299 if ((aen
== MBA_IDC_COMPLETE
&& mb
[1] >> 15)) {
300 vha
->hw
->flags
.idc_compl_status
= 1;
301 if (vha
->hw
->notify_dcbx_comp
)
302 complete(&vha
->hw
->dcbx_comp
);
305 /* Acknowledgement needed? [Notify && non-zero timeout]. */
306 timeout
= (descr
>> 8) & 0xf;
307 if (aen
!= MBA_IDC_NOTIFY
|| !timeout
)
310 ql_dbg(ql_dbg_async
, vha
, 0x5022,
311 "%lu Inter-Driver Communication %s -- ACK timeout=%d.\n",
312 vha
->host_no
, event
[aen
& 0xff], timeout
);
314 rval
= qla2x00_post_idc_ack_work(vha
, mb
);
315 if (rval
!= QLA_SUCCESS
)
316 ql_log(ql_log_warn
, vha
, 0x5023,
317 "IDC failed to post ACK.\n");
322 qla2x00_get_link_speed_str(struct qla_hw_data
*ha
, uint16_t speed
)
324 static const char * const link_speeds
[] = {
325 "1", "2", "?", "4", "8", "16", "10"
328 if (IS_QLA2100(ha
) || IS_QLA2200(ha
))
329 return link_speeds
[0];
330 else if (speed
== 0x13)
331 return link_speeds
[6];
333 return link_speeds
[speed
];
335 return link_speeds
[LS_UNKNOWN
];
339 qla83xx_handle_8200_aen(scsi_qla_host_t
*vha
, uint16_t *mb
)
341 struct qla_hw_data
*ha
= vha
->hw
;
344 * 8200 AEN Interpretation:
346 * mb[1] = AEN Reason code
347 * mb[2] = LSW of Peg-Halt Status-1 Register
348 * mb[6] = MSW of Peg-Halt Status-1 Register
349 * mb[3] = LSW of Peg-Halt Status-2 register
350 * mb[7] = MSW of Peg-Halt Status-2 register
351 * mb[4] = IDC Device-State Register value
352 * mb[5] = IDC Driver-Presence Register value
354 ql_dbg(ql_dbg_async
, vha
, 0x506b, "AEN Code: mb[0] = 0x%x AEN reason: "
355 "mb[1] = 0x%x PH-status1: mb[2] = 0x%x PH-status1: mb[6] = 0x%x.\n",
356 mb
[0], mb
[1], mb
[2], mb
[6]);
357 ql_dbg(ql_dbg_async
, vha
, 0x506c, "PH-status2: mb[3] = 0x%x "
358 "PH-status2: mb[7] = 0x%x Device-State: mb[4] = 0x%x "
359 "Drv-Presence: mb[5] = 0x%x.\n", mb
[3], mb
[7], mb
[4], mb
[5]);
361 if (mb
[1] & (IDC_PEG_HALT_STATUS_CHANGE
| IDC_NIC_FW_REPORTED_FAILURE
|
362 IDC_HEARTBEAT_FAILURE
)) {
363 ha
->flags
.nic_core_hung
= 1;
364 ql_log(ql_log_warn
, vha
, 0x5060,
365 "83XX: F/W Error Reported: Check if reset required.\n");
367 if (mb
[1] & IDC_PEG_HALT_STATUS_CHANGE
) {
368 uint32_t protocol_engine_id
, fw_err_code
, err_level
;
371 * IDC_PEG_HALT_STATUS_CHANGE interpretation:
372 * - PEG-Halt Status-1 Register:
373 * (LSW = mb[2], MSW = mb[6])
374 * Bits 0-7 = protocol-engine ID
375 * Bits 8-28 = f/w error code
376 * Bits 29-31 = Error-level
377 * Error-level 0x1 = Non-Fatal error
378 * Error-level 0x2 = Recoverable Fatal error
379 * Error-level 0x4 = UnRecoverable Fatal error
380 * - PEG-Halt Status-2 Register:
381 * (LSW = mb[3], MSW = mb[7])
383 protocol_engine_id
= (mb
[2] & 0xff);
384 fw_err_code
= (((mb
[2] & 0xff00) >> 8) |
385 ((mb
[6] & 0x1fff) << 8));
386 err_level
= ((mb
[6] & 0xe000) >> 13);
387 ql_log(ql_log_warn
, vha
, 0x5061, "PegHalt Status-1 "
388 "Register: protocol_engine_id=0x%x "
389 "fw_err_code=0x%x err_level=0x%x.\n",
390 protocol_engine_id
, fw_err_code
, err_level
);
391 ql_log(ql_log_warn
, vha
, 0x5062, "PegHalt Status-2 "
392 "Register: 0x%x%x.\n", mb
[7], mb
[3]);
393 if (err_level
== ERR_LEVEL_NON_FATAL
) {
394 ql_log(ql_log_warn
, vha
, 0x5063,
395 "Not a fatal error, f/w has recovered "
397 } else if (err_level
== ERR_LEVEL_RECOVERABLE_FATAL
) {
398 ql_log(ql_log_fatal
, vha
, 0x5064,
399 "Recoverable Fatal error: Chip reset "
401 qla83xx_schedule_work(vha
,
402 QLA83XX_NIC_CORE_RESET
);
403 } else if (err_level
== ERR_LEVEL_UNRECOVERABLE_FATAL
) {
404 ql_log(ql_log_fatal
, vha
, 0x5065,
405 "Unrecoverable Fatal error: Set FAILED "
406 "state, reboot required.\n");
407 qla83xx_schedule_work(vha
,
408 QLA83XX_NIC_CORE_UNRECOVERABLE
);
412 if (mb
[1] & IDC_NIC_FW_REPORTED_FAILURE
) {
413 uint16_t peg_fw_state
, nw_interface_link_up
;
414 uint16_t nw_interface_signal_detect
, sfp_status
;
415 uint16_t htbt_counter
, htbt_monitor_enable
;
416 uint16_t sfp_additonal_info
, sfp_multirate
;
417 uint16_t sfp_tx_fault
, link_speed
, dcbx_status
;
420 * IDC_NIC_FW_REPORTED_FAILURE interpretation:
421 * - PEG-to-FC Status Register:
422 * (LSW = mb[2], MSW = mb[6])
423 * Bits 0-7 = Peg-Firmware state
424 * Bit 8 = N/W Interface Link-up
425 * Bit 9 = N/W Interface signal detected
426 * Bits 10-11 = SFP Status
427 * SFP Status 0x0 = SFP+ transceiver not expected
428 * SFP Status 0x1 = SFP+ transceiver not present
429 * SFP Status 0x2 = SFP+ transceiver invalid
430 * SFP Status 0x3 = SFP+ transceiver present and
432 * Bits 12-14 = Heartbeat Counter
433 * Bit 15 = Heartbeat Monitor Enable
434 * Bits 16-17 = SFP Additional Info
435 * SFP info 0x0 = Unregocnized transceiver for
437 * SFP info 0x1 = SFP+ brand validation failed
438 * SFP info 0x2 = SFP+ speed validation failed
439 * SFP info 0x3 = SFP+ access error
440 * Bit 18 = SFP Multirate
441 * Bit 19 = SFP Tx Fault
442 * Bits 20-22 = Link Speed
443 * Bits 23-27 = Reserved
444 * Bits 28-30 = DCBX Status
445 * DCBX Status 0x0 = DCBX Disabled
446 * DCBX Status 0x1 = DCBX Enabled
447 * DCBX Status 0x2 = DCBX Exchange error
450 peg_fw_state
= (mb
[2] & 0x00ff);
451 nw_interface_link_up
= ((mb
[2] & 0x0100) >> 8);
452 nw_interface_signal_detect
= ((mb
[2] & 0x0200) >> 9);
453 sfp_status
= ((mb
[2] & 0x0c00) >> 10);
454 htbt_counter
= ((mb
[2] & 0x7000) >> 12);
455 htbt_monitor_enable
= ((mb
[2] & 0x8000) >> 15);
456 sfp_additonal_info
= (mb
[6] & 0x0003);
457 sfp_multirate
= ((mb
[6] & 0x0004) >> 2);
458 sfp_tx_fault
= ((mb
[6] & 0x0008) >> 3);
459 link_speed
= ((mb
[6] & 0x0070) >> 4);
460 dcbx_status
= ((mb
[6] & 0x7000) >> 12);
462 ql_log(ql_log_warn
, vha
, 0x5066,
463 "Peg-to-Fc Status Register:\n"
464 "peg_fw_state=0x%x, nw_interface_link_up=0x%x, "
465 "nw_interface_signal_detect=0x%x"
466 "\nsfp_statis=0x%x.\n ", peg_fw_state
,
467 nw_interface_link_up
, nw_interface_signal_detect
,
469 ql_log(ql_log_warn
, vha
, 0x5067,
470 "htbt_counter=0x%x, htbt_monitor_enable=0x%x, "
471 "sfp_additonal_info=0x%x, sfp_multirate=0x%x.\n ",
472 htbt_counter
, htbt_monitor_enable
,
473 sfp_additonal_info
, sfp_multirate
);
474 ql_log(ql_log_warn
, vha
, 0x5068,
475 "sfp_tx_fault=0x%x, link_state=0x%x, "
476 "dcbx_status=0x%x.\n", sfp_tx_fault
, link_speed
,
479 qla83xx_schedule_work(vha
, QLA83XX_NIC_CORE_RESET
);
482 if (mb
[1] & IDC_HEARTBEAT_FAILURE
) {
483 ql_log(ql_log_warn
, vha
, 0x5069,
484 "Heartbeat Failure encountered, chip reset "
487 qla83xx_schedule_work(vha
, QLA83XX_NIC_CORE_RESET
);
491 if (mb
[1] & IDC_DEVICE_STATE_CHANGE
) {
492 ql_log(ql_log_info
, vha
, 0x506a,
493 "IDC Device-State changed = 0x%x.\n", mb
[4]);
494 qla83xx_schedule_work(vha
, MBA_IDC_AEN
);
499 * qla2x00_async_event() - Process aynchronous events.
500 * @ha: SCSI driver HA context
501 * @mb: Mailbox registers (0 - 3)
504 qla2x00_async_event(scsi_qla_host_t
*vha
, struct rsp_que
*rsp
, uint16_t *mb
)
509 struct qla_hw_data
*ha
= vha
->hw
;
510 struct device_reg_2xxx __iomem
*reg
= &ha
->iobase
->isp
;
511 struct device_reg_24xx __iomem
*reg24
= &ha
->iobase
->isp24
;
512 struct device_reg_82xx __iomem
*reg82
= &ha
->iobase
->isp82
;
513 uint32_t rscn_entry
, host_pid
;
516 /* Setup to process RIO completion. */
518 if (IS_CNA_CAPABLE(ha
))
521 case MBA_SCSI_COMPLETION
:
522 handles
[0] = le32_to_cpu((uint32_t)((mb
[2] << 16) | mb
[1]));
525 case MBA_CMPLT_1_16BIT
:
528 mb
[0] = MBA_SCSI_COMPLETION
;
530 case MBA_CMPLT_2_16BIT
:
534 mb
[0] = MBA_SCSI_COMPLETION
;
536 case MBA_CMPLT_3_16BIT
:
541 mb
[0] = MBA_SCSI_COMPLETION
;
543 case MBA_CMPLT_4_16BIT
:
547 handles
[3] = (uint32_t)RD_MAILBOX_REG(ha
, reg
, 6);
549 mb
[0] = MBA_SCSI_COMPLETION
;
551 case MBA_CMPLT_5_16BIT
:
555 handles
[3] = (uint32_t)RD_MAILBOX_REG(ha
, reg
, 6);
556 handles
[4] = (uint32_t)RD_MAILBOX_REG(ha
, reg
, 7);
558 mb
[0] = MBA_SCSI_COMPLETION
;
560 case MBA_CMPLT_2_32BIT
:
561 handles
[0] = le32_to_cpu((uint32_t)((mb
[2] << 16) | mb
[1]));
562 handles
[1] = le32_to_cpu(
563 ((uint32_t)(RD_MAILBOX_REG(ha
, reg
, 7) << 16)) |
564 RD_MAILBOX_REG(ha
, reg
, 6));
566 mb
[0] = MBA_SCSI_COMPLETION
;
573 case MBA_SCSI_COMPLETION
: /* Fast Post */
574 if (!vha
->flags
.online
)
577 for (cnt
= 0; cnt
< handle_cnt
; cnt
++)
578 qla2x00_process_completed_request(vha
, rsp
->req
,
582 case MBA_RESET
: /* Reset */
583 ql_dbg(ql_dbg_async
, vha
, 0x5002,
584 "Asynchronous RESET.\n");
586 set_bit(RESET_MARKER_NEEDED
, &vha
->dpc_flags
);
589 case MBA_SYSTEM_ERR
: /* System Error */
590 mbx
= (IS_QLA81XX(ha
) || IS_QLA83XX(ha
)) ?
591 RD_REG_WORD(®24
->mailbox7
) : 0;
592 ql_log(ql_log_warn
, vha
, 0x5003,
593 "ISP System Error - mbx1=%xh mbx2=%xh mbx3=%xh "
594 "mbx7=%xh.\n", mb
[1], mb
[2], mb
[3], mbx
);
596 ha
->isp_ops
->fw_dump(vha
, 1);
598 if (IS_FWI2_CAPABLE(ha
)) {
599 if (mb
[1] == 0 && mb
[2] == 0) {
600 ql_log(ql_log_fatal
, vha
, 0x5004,
601 "Unrecoverable Hardware Error: adapter "
602 "marked OFFLINE!\n");
603 vha
->flags
.online
= 0;
604 vha
->device_flags
|= DFLG_DEV_FAILED
;
606 /* Check to see if MPI timeout occurred */
607 if ((mbx
& MBX_3
) && (ha
->flags
.port0
))
608 set_bit(MPI_RESET_NEEDED
,
611 set_bit(ISP_ABORT_NEEDED
, &vha
->dpc_flags
);
613 } else if (mb
[1] == 0) {
614 ql_log(ql_log_fatal
, vha
, 0x5005,
615 "Unrecoverable Hardware Error: adapter marked "
617 vha
->flags
.online
= 0;
618 vha
->device_flags
|= DFLG_DEV_FAILED
;
620 set_bit(ISP_ABORT_NEEDED
, &vha
->dpc_flags
);
623 case MBA_REQ_TRANSFER_ERR
: /* Request Transfer Error */
624 ql_log(ql_log_warn
, vha
, 0x5006,
625 "ISP Request Transfer Error (%x).\n", mb
[1]);
627 set_bit(ISP_ABORT_NEEDED
, &vha
->dpc_flags
);
630 case MBA_RSP_TRANSFER_ERR
: /* Response Transfer Error */
631 ql_log(ql_log_warn
, vha
, 0x5007,
632 "ISP Response Transfer Error.\n");
634 set_bit(ISP_ABORT_NEEDED
, &vha
->dpc_flags
);
637 case MBA_WAKEUP_THRES
: /* Request Queue Wake-up */
638 ql_dbg(ql_dbg_async
, vha
, 0x5008,
639 "Asynchronous WAKEUP_THRES.\n");
642 case MBA_LIP_OCCURRED
: /* Loop Initialization Procedure */
643 ql_dbg(ql_dbg_async
, vha
, 0x5009,
644 "LIP occurred (%x).\n", mb
[1]);
646 if (atomic_read(&vha
->loop_state
) != LOOP_DOWN
) {
647 atomic_set(&vha
->loop_state
, LOOP_DOWN
);
648 atomic_set(&vha
->loop_down_timer
, LOOP_DOWN_TIME
);
649 qla2x00_mark_all_devices_lost(vha
, 1);
653 atomic_set(&vha
->vp_state
, VP_FAILED
);
654 fc_vport_set_state(vha
->fc_vport
, FC_VPORT_FAILED
);
657 set_bit(REGISTER_FC4_NEEDED
, &vha
->dpc_flags
);
658 set_bit(REGISTER_FDMI_NEEDED
, &vha
->dpc_flags
);
660 vha
->flags
.management_server_logged_in
= 0;
661 qla2x00_post_aen_work(vha
, FCH_EVT_LIP
, mb
[1]);
664 case MBA_LOOP_UP
: /* Loop Up Event */
665 if (IS_QLA2100(ha
) || IS_QLA2200(ha
))
666 ha
->link_data_rate
= PORT_SPEED_1GB
;
668 ha
->link_data_rate
= mb
[1];
670 ql_dbg(ql_dbg_async
, vha
, 0x500a,
671 "LOOP UP detected (%s Gbps).\n",
672 qla2x00_get_link_speed_str(ha
, ha
->link_data_rate
));
674 vha
->flags
.management_server_logged_in
= 0;
675 qla2x00_post_aen_work(vha
, FCH_EVT_LINKUP
, ha
->link_data_rate
);
678 case MBA_LOOP_DOWN
: /* Loop Down Event */
679 mbx
= (IS_QLA81XX(ha
) || IS_QLA8031(ha
))
680 ? RD_REG_WORD(®24
->mailbox4
) : 0;
681 mbx
= IS_QLA82XX(ha
) ? RD_REG_WORD(®82
->mailbox_out
[4]) : mbx
;
682 ql_dbg(ql_dbg_async
, vha
, 0x500b,
683 "LOOP DOWN detected (%x %x %x %x).\n",
684 mb
[1], mb
[2], mb
[3], mbx
);
686 if (atomic_read(&vha
->loop_state
) != LOOP_DOWN
) {
687 atomic_set(&vha
->loop_state
, LOOP_DOWN
);
688 atomic_set(&vha
->loop_down_timer
, LOOP_DOWN_TIME
);
689 vha
->device_flags
|= DFLG_NO_CABLE
;
690 qla2x00_mark_all_devices_lost(vha
, 1);
694 atomic_set(&vha
->vp_state
, VP_FAILED
);
695 fc_vport_set_state(vha
->fc_vport
, FC_VPORT_FAILED
);
698 vha
->flags
.management_server_logged_in
= 0;
699 ha
->link_data_rate
= PORT_SPEED_UNKNOWN
;
700 qla2x00_post_aen_work(vha
, FCH_EVT_LINKDOWN
, 0);
703 case MBA_LIP_RESET
: /* LIP reset occurred */
704 ql_dbg(ql_dbg_async
, vha
, 0x500c,
705 "LIP reset occurred (%x).\n", mb
[1]);
707 if (atomic_read(&vha
->loop_state
) != LOOP_DOWN
) {
708 atomic_set(&vha
->loop_state
, LOOP_DOWN
);
709 atomic_set(&vha
->loop_down_timer
, LOOP_DOWN_TIME
);
710 qla2x00_mark_all_devices_lost(vha
, 1);
714 atomic_set(&vha
->vp_state
, VP_FAILED
);
715 fc_vport_set_state(vha
->fc_vport
, FC_VPORT_FAILED
);
718 set_bit(RESET_MARKER_NEEDED
, &vha
->dpc_flags
);
720 ha
->operating_mode
= LOOP
;
721 vha
->flags
.management_server_logged_in
= 0;
722 qla2x00_post_aen_work(vha
, FCH_EVT_LIPRESET
, mb
[1]);
725 /* case MBA_DCBX_COMPLETE: */
726 case MBA_POINT_TO_POINT
: /* Point-to-Point */
730 if (IS_QLA81XX(ha
) || IS_QLA82XX(ha
) || IS_QLA8031(ha
)) {
731 ql_dbg(ql_dbg_async
, vha
, 0x500d,
732 "DCBX Completed -- %04x %04x %04x.\n",
733 mb
[1], mb
[2], mb
[3]);
734 if (ha
->notify_dcbx_comp
)
735 complete(&ha
->dcbx_comp
);
738 ql_dbg(ql_dbg_async
, vha
, 0x500e,
739 "Asynchronous P2P MODE received.\n");
742 * Until there's a transition from loop down to loop up, treat
743 * this as loop down only.
745 if (atomic_read(&vha
->loop_state
) != LOOP_DOWN
) {
746 atomic_set(&vha
->loop_state
, LOOP_DOWN
);
747 if (!atomic_read(&vha
->loop_down_timer
))
748 atomic_set(&vha
->loop_down_timer
,
750 qla2x00_mark_all_devices_lost(vha
, 1);
754 atomic_set(&vha
->vp_state
, VP_FAILED
);
755 fc_vport_set_state(vha
->fc_vport
, FC_VPORT_FAILED
);
758 if (!(test_bit(ABORT_ISP_ACTIVE
, &vha
->dpc_flags
)))
759 set_bit(RESET_MARKER_NEEDED
, &vha
->dpc_flags
);
761 set_bit(REGISTER_FC4_NEEDED
, &vha
->dpc_flags
);
762 set_bit(REGISTER_FDMI_NEEDED
, &vha
->dpc_flags
);
764 ha
->flags
.gpsc_supported
= 1;
765 vha
->flags
.management_server_logged_in
= 0;
768 case MBA_CHG_IN_CONNECTION
: /* Change in connection mode */
772 ql_dbg(ql_dbg_async
, vha
, 0x500f,
773 "Configuration change detected: value=%x.\n", mb
[1]);
775 if (atomic_read(&vha
->loop_state
) != LOOP_DOWN
) {
776 atomic_set(&vha
->loop_state
, LOOP_DOWN
);
777 if (!atomic_read(&vha
->loop_down_timer
))
778 atomic_set(&vha
->loop_down_timer
,
780 qla2x00_mark_all_devices_lost(vha
, 1);
784 atomic_set(&vha
->vp_state
, VP_FAILED
);
785 fc_vport_set_state(vha
->fc_vport
, FC_VPORT_FAILED
);
788 set_bit(LOOP_RESYNC_NEEDED
, &vha
->dpc_flags
);
789 set_bit(LOCAL_LOOP_UPDATE
, &vha
->dpc_flags
);
792 case MBA_PORT_UPDATE
: /* Port database update */
794 * Handle only global and vn-port update events
797 * mb[1] = N_Port handle of changed port
798 * OR 0xffff for global event
799 * mb[2] = New login state
800 * 7 = Port logged out
801 * mb[3] = LSB is vp_idx, 0xff = all vps
803 * Skip processing if:
804 * Event is global, vp_idx is NOT all vps,
805 * vp_idx does not match
806 * Event is not global, vp_idx does not match
808 if (IS_QLA2XXX_MIDTYPE(ha
) &&
809 ((mb
[1] == 0xffff && (mb
[3] & 0xff) != 0xff) ||
810 (mb
[1] != 0xffff)) && vha
->vp_idx
!= (mb
[3] & 0xff))
813 /* Global event -- port logout or port unavailable. */
814 if (mb
[1] == 0xffff && mb
[2] == 0x7) {
815 ql_dbg(ql_dbg_async
, vha
, 0x5010,
816 "Port unavailable %04x %04x %04x.\n",
817 mb
[1], mb
[2], mb
[3]);
818 ql_log(ql_log_warn
, vha
, 0x505e,
819 "Link is offline.\n");
821 if (atomic_read(&vha
->loop_state
) != LOOP_DOWN
) {
822 atomic_set(&vha
->loop_state
, LOOP_DOWN
);
823 atomic_set(&vha
->loop_down_timer
,
825 vha
->device_flags
|= DFLG_NO_CABLE
;
826 qla2x00_mark_all_devices_lost(vha
, 1);
830 atomic_set(&vha
->vp_state
, VP_FAILED
);
831 fc_vport_set_state(vha
->fc_vport
,
833 qla2x00_mark_all_devices_lost(vha
, 1);
836 vha
->flags
.management_server_logged_in
= 0;
837 ha
->link_data_rate
= PORT_SPEED_UNKNOWN
;
842 * If PORT UPDATE is global (received LIP_OCCURRED/LIP_RESET
843 * event etc. earlier indicating loop is down) then process
844 * it. Otherwise ignore it and Wait for RSCN to come in.
846 atomic_set(&vha
->loop_down_timer
, 0);
847 if (mb
[1] != 0xffff || (mb
[2] != 0x6 && mb
[2] != 0x4)) {
848 ql_dbg(ql_dbg_async
, vha
, 0x5011,
849 "Asynchronous PORT UPDATE ignored %04x/%04x/%04x.\n",
850 mb
[1], mb
[2], mb
[3]);
852 qlt_async_event(mb
[0], vha
, mb
);
856 ql_dbg(ql_dbg_async
, vha
, 0x5012,
857 "Port database changed %04x %04x %04x.\n",
858 mb
[1], mb
[2], mb
[3]);
859 ql_log(ql_log_warn
, vha
, 0x505f,
860 "Link is operational (%s Gbps).\n",
861 qla2x00_get_link_speed_str(ha
, ha
->link_data_rate
));
864 * Mark all devices as missing so we will login again.
866 atomic_set(&vha
->loop_state
, LOOP_UP
);
868 qla2x00_mark_all_devices_lost(vha
, 1);
870 if (vha
->vp_idx
== 0 && !qla_ini_mode_enabled(vha
))
871 set_bit(SCR_PENDING
, &vha
->dpc_flags
);
873 set_bit(LOOP_RESYNC_NEEDED
, &vha
->dpc_flags
);
874 set_bit(LOCAL_LOOP_UPDATE
, &vha
->dpc_flags
);
876 qlt_async_event(mb
[0], vha
, mb
);
879 case MBA_RSCN_UPDATE
: /* State Change Registration */
880 /* Check if the Vport has issued a SCR */
881 if (vha
->vp_idx
&& test_bit(VP_SCR_NEEDED
, &vha
->vp_flags
))
883 /* Only handle SCNs for our Vport index. */
884 if (ha
->flags
.npiv_supported
&& vha
->vp_idx
!= (mb
[3] & 0xff))
887 ql_dbg(ql_dbg_async
, vha
, 0x5013,
888 "RSCN database changed -- %04x %04x %04x.\n",
889 mb
[1], mb
[2], mb
[3]);
891 rscn_entry
= ((mb
[1] & 0xff) << 16) | mb
[2];
892 host_pid
= (vha
->d_id
.b
.domain
<< 16) | (vha
->d_id
.b
.area
<< 8)
894 if (rscn_entry
== host_pid
) {
895 ql_dbg(ql_dbg_async
, vha
, 0x5014,
896 "Ignoring RSCN update to local host "
897 "port ID (%06x).\n", host_pid
);
901 /* Ignore reserved bits from RSCN-payload. */
902 rscn_entry
= ((mb
[1] & 0x3ff) << 16) | mb
[2];
904 atomic_set(&vha
->loop_down_timer
, 0);
905 vha
->flags
.management_server_logged_in
= 0;
907 set_bit(LOOP_RESYNC_NEEDED
, &vha
->dpc_flags
);
908 set_bit(RSCN_UPDATE
, &vha
->dpc_flags
);
909 qla2x00_post_aen_work(vha
, FCH_EVT_RSCN
, rscn_entry
);
912 /* case MBA_RIO_RESPONSE: */
913 case MBA_ZIO_RESPONSE
:
914 ql_dbg(ql_dbg_async
, vha
, 0x5015,
915 "[R|Z]IO update completion.\n");
917 if (IS_FWI2_CAPABLE(ha
))
918 qla24xx_process_response_queue(vha
, rsp
);
920 qla2x00_process_response_queue(rsp
);
923 case MBA_DISCARD_RND_FRAME
:
924 ql_dbg(ql_dbg_async
, vha
, 0x5016,
925 "Discard RND Frame -- %04x %04x %04x.\n",
926 mb
[1], mb
[2], mb
[3]);
929 case MBA_TRACE_NOTIFICATION
:
930 ql_dbg(ql_dbg_async
, vha
, 0x5017,
931 "Trace Notification -- %04x %04x.\n", mb
[1], mb
[2]);
934 case MBA_ISP84XX_ALERT
:
935 ql_dbg(ql_dbg_async
, vha
, 0x5018,
936 "ISP84XX Alert Notification -- %04x %04x %04x.\n",
937 mb
[1], mb
[2], mb
[3]);
939 spin_lock_irqsave(&ha
->cs84xx
->access_lock
, flags
);
941 case A84_PANIC_RECOVERY
:
942 ql_log(ql_log_info
, vha
, 0x5019,
943 "Alert 84XX: panic recovery %04x %04x.\n",
946 case A84_OP_LOGIN_COMPLETE
:
947 ha
->cs84xx
->op_fw_version
= mb
[3] << 16 | mb
[2];
948 ql_log(ql_log_info
, vha
, 0x501a,
949 "Alert 84XX: firmware version %x.\n",
950 ha
->cs84xx
->op_fw_version
);
952 case A84_DIAG_LOGIN_COMPLETE
:
953 ha
->cs84xx
->diag_fw_version
= mb
[3] << 16 | mb
[2];
954 ql_log(ql_log_info
, vha
, 0x501b,
955 "Alert 84XX: diagnostic firmware version %x.\n",
956 ha
->cs84xx
->diag_fw_version
);
958 case A84_GOLD_LOGIN_COMPLETE
:
959 ha
->cs84xx
->diag_fw_version
= mb
[3] << 16 | mb
[2];
960 ha
->cs84xx
->fw_update
= 1;
961 ql_log(ql_log_info
, vha
, 0x501c,
962 "Alert 84XX: gold firmware version %x.\n",
963 ha
->cs84xx
->gold_fw_version
);
966 ql_log(ql_log_warn
, vha
, 0x501d,
967 "Alert 84xx: Invalid Alert %04x %04x %04x.\n",
968 mb
[1], mb
[2], mb
[3]);
970 spin_unlock_irqrestore(&ha
->cs84xx
->access_lock
, flags
);
973 ql_dbg(ql_dbg_async
, vha
, 0x501e,
974 "DCBX Started -- %04x %04x %04x.\n",
975 mb
[1], mb
[2], mb
[3]);
977 case MBA_DCBX_PARAM_UPDATE
:
978 ql_dbg(ql_dbg_async
, vha
, 0x501f,
979 "DCBX Parameters Updated -- %04x %04x %04x.\n",
980 mb
[1], mb
[2], mb
[3]);
982 case MBA_FCF_CONF_ERR
:
983 ql_dbg(ql_dbg_async
, vha
, 0x5020,
984 "FCF Configuration Error -- %04x %04x %04x.\n",
985 mb
[1], mb
[2], mb
[3]);
988 if (IS_QLA8031(vha
->hw
)) {
989 mb
[4] = RD_REG_WORD(®24
->mailbox4
);
990 if (((mb
[2] & 0x7fff) == MBC_PORT_RESET
||
991 (mb
[2] & 0x7fff) == MBC_SET_PORT_CONFIG
) &&
992 (mb
[4] & INTERNAL_LOOPBACK_MASK
) != 0) {
993 set_bit(ISP_QUIESCE_NEEDED
, &vha
->dpc_flags
);
995 * Extend loop down timer since port is active.
997 if (atomic_read(&vha
->loop_state
) == LOOP_DOWN
)
998 atomic_set(&vha
->loop_down_timer
,
1000 qla2xxx_wake_dpc(vha
);
1003 case MBA_IDC_COMPLETE
:
1004 case MBA_IDC_TIME_EXT
:
1005 if (IS_QLA81XX(vha
->hw
) || IS_QLA8031(vha
->hw
))
1006 qla81xx_idc_event(vha
, mb
[0], mb
[1]);
1010 mb
[4] = RD_REG_WORD(®24
->mailbox4
);
1011 mb
[5] = RD_REG_WORD(®24
->mailbox5
);
1012 mb
[6] = RD_REG_WORD(®24
->mailbox6
);
1013 mb
[7] = RD_REG_WORD(®24
->mailbox7
);
1014 qla83xx_handle_8200_aen(vha
, mb
);
1018 ql_dbg(ql_dbg_async
, vha
, 0x5057,
1019 "Unknown AEN:%04x %04x %04x %04x\n",
1020 mb
[0], mb
[1], mb
[2], mb
[3]);
1023 qlt_async_event(mb
[0], vha
, mb
);
1025 if (!vha
->vp_idx
&& ha
->num_vhosts
)
1026 qla2x00_alert_all_vps(rsp
, mb
);
1030 * qla2x00_process_completed_request() - Process a Fast Post response.
1031 * @ha: SCSI driver HA context
1035 qla2x00_process_completed_request(struct scsi_qla_host
*vha
,
1036 struct req_que
*req
, uint32_t index
)
1039 struct qla_hw_data
*ha
= vha
->hw
;
1041 /* Validate handle. */
1042 if (index
>= req
->num_outstanding_cmds
) {
1043 ql_log(ql_log_warn
, vha
, 0x3014,
1044 "Invalid SCSI command index (%x).\n", index
);
1047 set_bit(FCOE_CTX_RESET_NEEDED
, &vha
->dpc_flags
);
1049 set_bit(ISP_ABORT_NEEDED
, &vha
->dpc_flags
);
1053 sp
= req
->outstanding_cmds
[index
];
1055 /* Free outstanding command slot. */
1056 req
->outstanding_cmds
[index
] = NULL
;
1058 /* Save ISP completion status */
1059 sp
->done(ha
, sp
, DID_OK
<< 16);
1061 ql_log(ql_log_warn
, vha
, 0x3016, "Invalid SCSI SRB.\n");
1064 set_bit(FCOE_CTX_RESET_NEEDED
, &vha
->dpc_flags
);
1066 set_bit(ISP_ABORT_NEEDED
, &vha
->dpc_flags
);
1071 qla2x00_get_sp_from_handle(scsi_qla_host_t
*vha
, const char *func
,
1072 struct req_que
*req
, void *iocb
)
1074 struct qla_hw_data
*ha
= vha
->hw
;
1075 sts_entry_t
*pkt
= iocb
;
1079 index
= LSW(pkt
->handle
);
1080 if (index
>= req
->num_outstanding_cmds
) {
1081 ql_log(ql_log_warn
, vha
, 0x5031,
1082 "Invalid command index (%x).\n", index
);
1084 set_bit(FCOE_CTX_RESET_NEEDED
, &vha
->dpc_flags
);
1086 set_bit(ISP_ABORT_NEEDED
, &vha
->dpc_flags
);
1089 sp
= req
->outstanding_cmds
[index
];
1091 ql_log(ql_log_warn
, vha
, 0x5032,
1092 "Invalid completion handle (%x) -- timed-out.\n", index
);
1095 if (sp
->handle
!= index
) {
1096 ql_log(ql_log_warn
, vha
, 0x5033,
1097 "SRB handle (%x) mismatch %x.\n", sp
->handle
, index
);
1101 req
->outstanding_cmds
[index
] = NULL
;
1108 qla2x00_mbx_iocb_entry(scsi_qla_host_t
*vha
, struct req_que
*req
,
1109 struct mbx_entry
*mbx
)
1111 const char func
[] = "MBX-IOCB";
1115 struct srb_iocb
*lio
;
1119 sp
= qla2x00_get_sp_from_handle(vha
, func
, req
, mbx
);
1123 lio
= &sp
->u
.iocb_cmd
;
1125 fcport
= sp
->fcport
;
1126 data
= lio
->u
.logio
.data
;
1128 data
[0] = MBS_COMMAND_ERROR
;
1129 data
[1] = lio
->u
.logio
.flags
& SRB_LOGIN_RETRIED
?
1130 QLA_LOGIO_LOGIN_RETRIED
: 0;
1131 if (mbx
->entry_status
) {
1132 ql_dbg(ql_dbg_async
, vha
, 0x5043,
1133 "Async-%s error entry - hdl=%x portid=%02x%02x%02x "
1134 "entry-status=%x status=%x state-flag=%x "
1135 "status-flags=%x.\n", type
, sp
->handle
,
1136 fcport
->d_id
.b
.domain
, fcport
->d_id
.b
.area
,
1137 fcport
->d_id
.b
.al_pa
, mbx
->entry_status
,
1138 le16_to_cpu(mbx
->status
), le16_to_cpu(mbx
->state_flags
),
1139 le16_to_cpu(mbx
->status_flags
));
1141 ql_dump_buffer(ql_dbg_async
+ ql_dbg_buffer
, vha
, 0x5029,
1142 (uint8_t *)mbx
, sizeof(*mbx
));
1147 status
= le16_to_cpu(mbx
->status
);
1148 if (status
== 0x30 && sp
->type
== SRB_LOGIN_CMD
&&
1149 le16_to_cpu(mbx
->mb0
) == MBS_COMMAND_COMPLETE
)
1151 if (!status
&& le16_to_cpu(mbx
->mb0
) == MBS_COMMAND_COMPLETE
) {
1152 ql_dbg(ql_dbg_async
, vha
, 0x5045,
1153 "Async-%s complete - hdl=%x portid=%02x%02x%02x mbx1=%x.\n",
1154 type
, sp
->handle
, fcport
->d_id
.b
.domain
,
1155 fcport
->d_id
.b
.area
, fcport
->d_id
.b
.al_pa
,
1156 le16_to_cpu(mbx
->mb1
));
1158 data
[0] = MBS_COMMAND_COMPLETE
;
1159 if (sp
->type
== SRB_LOGIN_CMD
) {
1160 fcport
->port_type
= FCT_TARGET
;
1161 if (le16_to_cpu(mbx
->mb1
) & BIT_0
)
1162 fcport
->port_type
= FCT_INITIATOR
;
1163 else if (le16_to_cpu(mbx
->mb1
) & BIT_1
)
1164 fcport
->flags
|= FCF_FCP2_DEVICE
;
1169 data
[0] = le16_to_cpu(mbx
->mb0
);
1171 case MBS_PORT_ID_USED
:
1172 data
[1] = le16_to_cpu(mbx
->mb1
);
1174 case MBS_LOOP_ID_USED
:
1177 data
[0] = MBS_COMMAND_ERROR
;
1181 ql_log(ql_log_warn
, vha
, 0x5046,
1182 "Async-%s failed - hdl=%x portid=%02x%02x%02x status=%x "
1183 "mb0=%x mb1=%x mb2=%x mb6=%x mb7=%x.\n", type
, sp
->handle
,
1184 fcport
->d_id
.b
.domain
, fcport
->d_id
.b
.area
, fcport
->d_id
.b
.al_pa
,
1185 status
, le16_to_cpu(mbx
->mb0
), le16_to_cpu(mbx
->mb1
),
1186 le16_to_cpu(mbx
->mb2
), le16_to_cpu(mbx
->mb6
),
1187 le16_to_cpu(mbx
->mb7
));
1190 sp
->done(vha
, sp
, 0);
1194 qla2x00_ct_entry(scsi_qla_host_t
*vha
, struct req_que
*req
,
1195 sts_entry_t
*pkt
, int iocb_type
)
1197 const char func
[] = "CT_IOCB";
1200 struct fc_bsg_job
*bsg_job
;
1201 uint16_t comp_status
;
1204 sp
= qla2x00_get_sp_from_handle(vha
, func
, req
, pkt
);
1208 bsg_job
= sp
->u
.bsg_job
;
1210 type
= "ct pass-through";
1212 comp_status
= le16_to_cpu(pkt
->comp_status
);
1214 /* return FC_CTELS_STATUS_OK and leave the decoding of the ELS/CT
1215 * fc payload to the caller
1217 bsg_job
->reply
->reply_data
.ctels_reply
.status
= FC_CTELS_STATUS_OK
;
1218 bsg_job
->reply_len
= sizeof(struct fc_bsg_reply
);
1220 if (comp_status
!= CS_COMPLETE
) {
1221 if (comp_status
== CS_DATA_UNDERRUN
) {
1223 bsg_job
->reply
->reply_payload_rcv_len
=
1224 le16_to_cpu(((sts_entry_t
*)pkt
)->rsp_info_len
);
1226 ql_log(ql_log_warn
, vha
, 0x5048,
1227 "CT pass-through-%s error "
1228 "comp_status-status=0x%x total_byte = 0x%x.\n",
1230 bsg_job
->reply
->reply_payload_rcv_len
);
1232 ql_log(ql_log_warn
, vha
, 0x5049,
1233 "CT pass-through-%s error "
1234 "comp_status-status=0x%x.\n", type
, comp_status
);
1235 res
= DID_ERROR
<< 16;
1236 bsg_job
->reply
->reply_payload_rcv_len
= 0;
1238 ql_dump_buffer(ql_dbg_async
+ ql_dbg_buffer
, vha
, 0x5035,
1239 (uint8_t *)pkt
, sizeof(*pkt
));
1242 bsg_job
->reply
->reply_payload_rcv_len
=
1243 bsg_job
->reply_payload
.payload_len
;
1244 bsg_job
->reply_len
= 0;
1247 sp
->done(vha
, sp
, res
);
1251 qla24xx_els_ct_entry(scsi_qla_host_t
*vha
, struct req_que
*req
,
1252 struct sts_entry_24xx
*pkt
, int iocb_type
)
1254 const char func
[] = "ELS_CT_IOCB";
1257 struct fc_bsg_job
*bsg_job
;
1258 uint16_t comp_status
;
1259 uint32_t fw_status
[3];
1260 uint8_t* fw_sts_ptr
;
1263 sp
= qla2x00_get_sp_from_handle(vha
, func
, req
, pkt
);
1266 bsg_job
= sp
->u
.bsg_job
;
1270 case SRB_ELS_CMD_RPT
:
1271 case SRB_ELS_CMD_HST
:
1275 type
= "ct pass-through";
1278 ql_dbg(ql_dbg_user
, vha
, 0x503e,
1279 "Unrecognized SRB: (%p) type=%d.\n", sp
, sp
->type
);
1283 comp_status
= fw_status
[0] = le16_to_cpu(pkt
->comp_status
);
1284 fw_status
[1] = le16_to_cpu(((struct els_sts_entry_24xx
*)pkt
)->error_subcode_1
);
1285 fw_status
[2] = le16_to_cpu(((struct els_sts_entry_24xx
*)pkt
)->error_subcode_2
);
1287 /* return FC_CTELS_STATUS_OK and leave the decoding of the ELS/CT
1288 * fc payload to the caller
1290 bsg_job
->reply
->reply_data
.ctels_reply
.status
= FC_CTELS_STATUS_OK
;
1291 bsg_job
->reply_len
= sizeof(struct fc_bsg_reply
) + sizeof(fw_status
);
1293 if (comp_status
!= CS_COMPLETE
) {
1294 if (comp_status
== CS_DATA_UNDERRUN
) {
1296 bsg_job
->reply
->reply_payload_rcv_len
=
1297 le16_to_cpu(((struct els_sts_entry_24xx
*)pkt
)->total_byte_count
);
1299 ql_dbg(ql_dbg_user
, vha
, 0x503f,
1300 "ELS-CT pass-through-%s error hdl=%x comp_status-status=0x%x "
1301 "error subcode 1=0x%x error subcode 2=0x%x total_byte = 0x%x.\n",
1302 type
, sp
->handle
, comp_status
, fw_status
[1], fw_status
[2],
1303 le16_to_cpu(((struct els_sts_entry_24xx
*)
1304 pkt
)->total_byte_count
));
1305 fw_sts_ptr
= ((uint8_t*)bsg_job
->req
->sense
) + sizeof(struct fc_bsg_reply
);
1306 memcpy( fw_sts_ptr
, fw_status
, sizeof(fw_status
));
1309 ql_dbg(ql_dbg_user
, vha
, 0x5040,
1310 "ELS-CT pass-through-%s error hdl=%x comp_status-status=0x%x "
1311 "error subcode 1=0x%x error subcode 2=0x%x.\n",
1312 type
, sp
->handle
, comp_status
,
1313 le16_to_cpu(((struct els_sts_entry_24xx
*)
1314 pkt
)->error_subcode_1
),
1315 le16_to_cpu(((struct els_sts_entry_24xx
*)
1316 pkt
)->error_subcode_2
));
1317 res
= DID_ERROR
<< 16;
1318 bsg_job
->reply
->reply_payload_rcv_len
= 0;
1319 fw_sts_ptr
= ((uint8_t*)bsg_job
->req
->sense
) + sizeof(struct fc_bsg_reply
);
1320 memcpy( fw_sts_ptr
, fw_status
, sizeof(fw_status
));
1322 ql_dump_buffer(ql_dbg_user
+ ql_dbg_buffer
, vha
, 0x5056,
1323 (uint8_t *)pkt
, sizeof(*pkt
));
1327 bsg_job
->reply
->reply_payload_rcv_len
= bsg_job
->reply_payload
.payload_len
;
1328 bsg_job
->reply_len
= 0;
1331 sp
->done(vha
, sp
, res
);
1335 qla24xx_logio_entry(scsi_qla_host_t
*vha
, struct req_que
*req
,
1336 struct logio_entry_24xx
*logio
)
1338 const char func
[] = "LOGIO-IOCB";
1342 struct srb_iocb
*lio
;
1346 sp
= qla2x00_get_sp_from_handle(vha
, func
, req
, logio
);
1350 lio
= &sp
->u
.iocb_cmd
;
1352 fcport
= sp
->fcport
;
1353 data
= lio
->u
.logio
.data
;
1355 data
[0] = MBS_COMMAND_ERROR
;
1356 data
[1] = lio
->u
.logio
.flags
& SRB_LOGIN_RETRIED
?
1357 QLA_LOGIO_LOGIN_RETRIED
: 0;
1358 if (logio
->entry_status
) {
1359 ql_log(ql_log_warn
, fcport
->vha
, 0x5034,
1360 "Async-%s error entry - hdl=%x"
1361 "portid=%02x%02x%02x entry-status=%x.\n",
1362 type
, sp
->handle
, fcport
->d_id
.b
.domain
,
1363 fcport
->d_id
.b
.area
, fcport
->d_id
.b
.al_pa
,
1364 logio
->entry_status
);
1365 ql_dump_buffer(ql_dbg_async
+ ql_dbg_buffer
, vha
, 0x504d,
1366 (uint8_t *)logio
, sizeof(*logio
));
1371 if (le16_to_cpu(logio
->comp_status
) == CS_COMPLETE
) {
1372 ql_dbg(ql_dbg_async
, fcport
->vha
, 0x5036,
1373 "Async-%s complete - hdl=%x portid=%02x%02x%02x "
1374 "iop0=%x.\n", type
, sp
->handle
, fcport
->d_id
.b
.domain
,
1375 fcport
->d_id
.b
.area
, fcport
->d_id
.b
.al_pa
,
1376 le32_to_cpu(logio
->io_parameter
[0]));
1378 data
[0] = MBS_COMMAND_COMPLETE
;
1379 if (sp
->type
!= SRB_LOGIN_CMD
)
1382 iop
[0] = le32_to_cpu(logio
->io_parameter
[0]);
1383 if (iop
[0] & BIT_4
) {
1384 fcport
->port_type
= FCT_TARGET
;
1386 fcport
->flags
|= FCF_FCP2_DEVICE
;
1387 } else if (iop
[0] & BIT_5
)
1388 fcport
->port_type
= FCT_INITIATOR
;
1391 fcport
->flags
|= FCF_CONF_COMP_SUPPORTED
;
1393 if (logio
->io_parameter
[7] || logio
->io_parameter
[8])
1394 fcport
->supported_classes
|= FC_COS_CLASS2
;
1395 if (logio
->io_parameter
[9] || logio
->io_parameter
[10])
1396 fcport
->supported_classes
|= FC_COS_CLASS3
;
1401 iop
[0] = le32_to_cpu(logio
->io_parameter
[0]);
1402 iop
[1] = le32_to_cpu(logio
->io_parameter
[1]);
1404 case LSC_SCODE_PORTID_USED
:
1405 data
[0] = MBS_PORT_ID_USED
;
1406 data
[1] = LSW(iop
[1]);
1408 case LSC_SCODE_NPORT_USED
:
1409 data
[0] = MBS_LOOP_ID_USED
;
1412 data
[0] = MBS_COMMAND_ERROR
;
1416 ql_dbg(ql_dbg_async
, fcport
->vha
, 0x5037,
1417 "Async-%s failed - hdl=%x portid=%02x%02x%02x comp=%x "
1418 "iop0=%x iop1=%x.\n", type
, sp
->handle
, fcport
->d_id
.b
.domain
,
1419 fcport
->d_id
.b
.area
, fcport
->d_id
.b
.al_pa
,
1420 le16_to_cpu(logio
->comp_status
),
1421 le32_to_cpu(logio
->io_parameter
[0]),
1422 le32_to_cpu(logio
->io_parameter
[1]));
1425 sp
->done(vha
, sp
, 0);
1429 qla24xx_tm_iocb_entry(scsi_qla_host_t
*vha
, struct req_que
*req
,
1430 struct tsk_mgmt_entry
*tsk
)
1432 const char func
[] = "TMF-IOCB";
1436 struct srb_iocb
*iocb
;
1437 struct sts_entry_24xx
*sts
= (struct sts_entry_24xx
*)tsk
;
1440 sp
= qla2x00_get_sp_from_handle(vha
, func
, req
, tsk
);
1444 iocb
= &sp
->u
.iocb_cmd
;
1446 fcport
= sp
->fcport
;
1448 if (sts
->entry_status
) {
1449 ql_log(ql_log_warn
, fcport
->vha
, 0x5038,
1450 "Async-%s error - hdl=%x entry-status(%x).\n",
1451 type
, sp
->handle
, sts
->entry_status
);
1452 } else if (sts
->comp_status
!= __constant_cpu_to_le16(CS_COMPLETE
)) {
1453 ql_log(ql_log_warn
, fcport
->vha
, 0x5039,
1454 "Async-%s error - hdl=%x completion status(%x).\n",
1455 type
, sp
->handle
, sts
->comp_status
);
1456 } else if (!(le16_to_cpu(sts
->scsi_status
) &
1457 SS_RESPONSE_INFO_LEN_VALID
)) {
1458 ql_log(ql_log_warn
, fcport
->vha
, 0x503a,
1459 "Async-%s error - hdl=%x no response info(%x).\n",
1460 type
, sp
->handle
, sts
->scsi_status
);
1461 } else if (le32_to_cpu(sts
->rsp_data_len
) < 4) {
1462 ql_log(ql_log_warn
, fcport
->vha
, 0x503b,
1463 "Async-%s error - hdl=%x not enough response(%d).\n",
1464 type
, sp
->handle
, sts
->rsp_data_len
);
1465 } else if (sts
->data
[3]) {
1466 ql_log(ql_log_warn
, fcport
->vha
, 0x503c,
1467 "Async-%s error - hdl=%x response(%x).\n",
1468 type
, sp
->handle
, sts
->data
[3]);
1474 iocb
->u
.tmf
.data
= error
;
1475 ql_dump_buffer(ql_dbg_async
+ ql_dbg_buffer
, vha
, 0x5055,
1476 (uint8_t *)sts
, sizeof(*sts
));
1479 sp
->done(vha
, sp
, 0);
1483 * qla2x00_process_response_queue() - Process response queue entries.
1484 * @ha: SCSI driver HA context
1487 qla2x00_process_response_queue(struct rsp_que
*rsp
)
1489 struct scsi_qla_host
*vha
;
1490 struct qla_hw_data
*ha
= rsp
->hw
;
1491 struct device_reg_2xxx __iomem
*reg
= &ha
->iobase
->isp
;
1493 uint16_t handle_cnt
;
1496 vha
= pci_get_drvdata(ha
->pdev
);
1498 if (!vha
->flags
.online
)
1501 while (rsp
->ring_ptr
->signature
!= RESPONSE_PROCESSED
) {
1502 pkt
= (sts_entry_t
*)rsp
->ring_ptr
;
1505 if (rsp
->ring_index
== rsp
->length
) {
1506 rsp
->ring_index
= 0;
1507 rsp
->ring_ptr
= rsp
->ring
;
1512 if (pkt
->entry_status
!= 0) {
1513 qla2x00_error_entry(vha
, rsp
, pkt
);
1514 ((response_t
*)pkt
)->signature
= RESPONSE_PROCESSED
;
1519 switch (pkt
->entry_type
) {
1521 qla2x00_status_entry(vha
, rsp
, pkt
);
1523 case STATUS_TYPE_21
:
1524 handle_cnt
= ((sts21_entry_t
*)pkt
)->handle_count
;
1525 for (cnt
= 0; cnt
< handle_cnt
; cnt
++) {
1526 qla2x00_process_completed_request(vha
, rsp
->req
,
1527 ((sts21_entry_t
*)pkt
)->handle
[cnt
]);
1530 case STATUS_TYPE_22
:
1531 handle_cnt
= ((sts22_entry_t
*)pkt
)->handle_count
;
1532 for (cnt
= 0; cnt
< handle_cnt
; cnt
++) {
1533 qla2x00_process_completed_request(vha
, rsp
->req
,
1534 ((sts22_entry_t
*)pkt
)->handle
[cnt
]);
1537 case STATUS_CONT_TYPE
:
1538 qla2x00_status_cont_entry(rsp
, (sts_cont_entry_t
*)pkt
);
1541 qla2x00_mbx_iocb_entry(vha
, rsp
->req
,
1542 (struct mbx_entry
*)pkt
);
1545 qla2x00_ct_entry(vha
, rsp
->req
, pkt
, CT_IOCB_TYPE
);
1548 /* Type Not Supported. */
1549 ql_log(ql_log_warn
, vha
, 0x504a,
1550 "Received unknown response pkt type %x "
1551 "entry status=%x.\n",
1552 pkt
->entry_type
, pkt
->entry_status
);
1555 ((response_t
*)pkt
)->signature
= RESPONSE_PROCESSED
;
1559 /* Adjust ring index */
1560 WRT_REG_WORD(ISP_RSP_Q_OUT(ha
, reg
), rsp
->ring_index
);
1564 qla2x00_handle_sense(srb_t
*sp
, uint8_t *sense_data
, uint32_t par_sense_len
,
1565 uint32_t sense_len
, struct rsp_que
*rsp
, int res
)
1567 struct scsi_qla_host
*vha
= sp
->fcport
->vha
;
1568 struct scsi_cmnd
*cp
= GET_CMD_SP(sp
);
1569 uint32_t track_sense_len
;
1571 if (sense_len
>= SCSI_SENSE_BUFFERSIZE
)
1572 sense_len
= SCSI_SENSE_BUFFERSIZE
;
1574 SET_CMD_SENSE_LEN(sp
, sense_len
);
1575 SET_CMD_SENSE_PTR(sp
, cp
->sense_buffer
);
1576 track_sense_len
= sense_len
;
1578 if (sense_len
> par_sense_len
)
1579 sense_len
= par_sense_len
;
1581 memcpy(cp
->sense_buffer
, sense_data
, sense_len
);
1583 SET_CMD_SENSE_PTR(sp
, cp
->sense_buffer
+ sense_len
);
1584 track_sense_len
-= sense_len
;
1585 SET_CMD_SENSE_LEN(sp
, track_sense_len
);
1587 if (track_sense_len
!= 0) {
1588 rsp
->status_srb
= sp
;
1593 ql_dbg(ql_dbg_io
+ ql_dbg_buffer
, vha
, 0x301c,
1594 "Check condition Sense data, nexus%ld:%d:%d cmd=%p.\n",
1595 sp
->fcport
->vha
->host_no
, cp
->device
->id
, cp
->device
->lun
,
1597 ql_dump_buffer(ql_dbg_io
+ ql_dbg_buffer
, vha
, 0x302b,
1598 cp
->sense_buffer
, sense_len
);
1602 struct scsi_dif_tuple
{
1603 __be16 guard
; /* Checksum */
1604 __be16 app_tag
; /* APPL identifier */
1605 __be32 ref_tag
; /* Target LBA or indirect LBA */
1609 * Checks the guard or meta-data for the type of error
1610 * detected by the HBA. In case of errors, we set the
1611 * ASC/ASCQ fields in the sense buffer with ILLEGAL_REQUEST
1612 * to indicate to the kernel that the HBA detected error.
1615 qla2x00_handle_dif_error(srb_t
*sp
, struct sts_entry_24xx
*sts24
)
1617 struct scsi_qla_host
*vha
= sp
->fcport
->vha
;
1618 struct scsi_cmnd
*cmd
= GET_CMD_SP(sp
);
1619 uint8_t *ap
= &sts24
->data
[12];
1620 uint8_t *ep
= &sts24
->data
[20];
1621 uint32_t e_ref_tag
, a_ref_tag
;
1622 uint16_t e_app_tag
, a_app_tag
;
1623 uint16_t e_guard
, a_guard
;
1626 * swab32 of the "data" field in the beginning of qla2x00_status_entry()
1627 * would make guard field appear at offset 2
1629 a_guard
= le16_to_cpu(*(uint16_t *)(ap
+ 2));
1630 a_app_tag
= le16_to_cpu(*(uint16_t *)(ap
+ 0));
1631 a_ref_tag
= le32_to_cpu(*(uint32_t *)(ap
+ 4));
1632 e_guard
= le16_to_cpu(*(uint16_t *)(ep
+ 2));
1633 e_app_tag
= le16_to_cpu(*(uint16_t *)(ep
+ 0));
1634 e_ref_tag
= le32_to_cpu(*(uint32_t *)(ep
+ 4));
1636 ql_dbg(ql_dbg_io
, vha
, 0x3023,
1637 "iocb(s) %p Returned STATUS.\n", sts24
);
1639 ql_dbg(ql_dbg_io
, vha
, 0x3024,
1640 "DIF ERROR in cmd 0x%x lba 0x%llx act ref"
1641 " tag=0x%x, exp ref_tag=0x%x, act app tag=0x%x, exp app"
1642 " tag=0x%x, act guard=0x%x, exp guard=0x%x.\n",
1643 cmd
->cmnd
[0], (u64
)scsi_get_lba(cmd
), a_ref_tag
, e_ref_tag
,
1644 a_app_tag
, e_app_tag
, a_guard
, e_guard
);
1648 * For type 3: ref & app tag is all 'f's
1649 * For type 0,1,2: app tag is all 'f's
1651 if ((a_app_tag
== 0xffff) &&
1652 ((scsi_get_prot_type(cmd
) != SCSI_PROT_DIF_TYPE3
) ||
1653 (a_ref_tag
== 0xffffffff))) {
1654 uint32_t blocks_done
, resid
;
1655 sector_t lba_s
= scsi_get_lba(cmd
);
1657 /* 2TB boundary case covered automatically with this */
1658 blocks_done
= e_ref_tag
- (uint32_t)lba_s
+ 1;
1660 resid
= scsi_bufflen(cmd
) - (blocks_done
*
1661 cmd
->device
->sector_size
);
1663 scsi_set_resid(cmd
, resid
);
1664 cmd
->result
= DID_OK
<< 16;
1666 /* Update protection tag */
1667 if (scsi_prot_sg_count(cmd
)) {
1668 uint32_t i
, j
= 0, k
= 0, num_ent
;
1669 struct scatterlist
*sg
;
1670 struct sd_dif_tuple
*spt
;
1672 /* Patch the corresponding protection tags */
1673 scsi_for_each_prot_sg(cmd
, sg
,
1674 scsi_prot_sg_count(cmd
), i
) {
1675 num_ent
= sg_dma_len(sg
) / 8;
1676 if (k
+ num_ent
< blocks_done
) {
1680 j
= blocks_done
- k
- 1;
1685 if (k
!= blocks_done
) {
1686 ql_log(ql_log_warn
, vha
, 0x302f,
1687 "unexpected tag values tag:lba=%x:%llx)\n",
1688 e_ref_tag
, (unsigned long long)lba_s
);
1692 spt
= page_address(sg_page(sg
)) + sg
->offset
;
1695 spt
->app_tag
= 0xffff;
1696 if (scsi_get_prot_type(cmd
) == SCSI_PROT_DIF_TYPE3
)
1697 spt
->ref_tag
= 0xffffffff;
1704 if (e_guard
!= a_guard
) {
1705 scsi_build_sense_buffer(1, cmd
->sense_buffer
, ILLEGAL_REQUEST
,
1707 set_driver_byte(cmd
, DRIVER_SENSE
);
1708 set_host_byte(cmd
, DID_ABORT
);
1709 cmd
->result
|= SAM_STAT_CHECK_CONDITION
<< 1;
1714 if (e_ref_tag
!= a_ref_tag
) {
1715 scsi_build_sense_buffer(1, cmd
->sense_buffer
, ILLEGAL_REQUEST
,
1717 set_driver_byte(cmd
, DRIVER_SENSE
);
1718 set_host_byte(cmd
, DID_ABORT
);
1719 cmd
->result
|= SAM_STAT_CHECK_CONDITION
<< 1;
1723 /* check appl tag */
1724 if (e_app_tag
!= a_app_tag
) {
1725 scsi_build_sense_buffer(1, cmd
->sense_buffer
, ILLEGAL_REQUEST
,
1727 set_driver_byte(cmd
, DRIVER_SENSE
);
1728 set_host_byte(cmd
, DID_ABORT
);
1729 cmd
->result
|= SAM_STAT_CHECK_CONDITION
<< 1;
1737 qla25xx_process_bidir_status_iocb(scsi_qla_host_t
*vha
, void *pkt
,
1738 struct req_que
*req
, uint32_t index
)
1740 struct qla_hw_data
*ha
= vha
->hw
;
1742 uint16_t comp_status
;
1743 uint16_t scsi_status
;
1745 uint32_t rval
= EXT_STATUS_OK
;
1746 struct fc_bsg_job
*bsg_job
= NULL
;
1748 struct sts_entry_24xx
*sts24
;
1749 sts
= (sts_entry_t
*) pkt
;
1750 sts24
= (struct sts_entry_24xx
*) pkt
;
1752 /* Validate handle. */
1753 if (index
>= req
->num_outstanding_cmds
) {
1754 ql_log(ql_log_warn
, vha
, 0x70af,
1755 "Invalid SCSI completion handle 0x%x.\n", index
);
1756 set_bit(ISP_ABORT_NEEDED
, &vha
->dpc_flags
);
1760 sp
= req
->outstanding_cmds
[index
];
1762 /* Free outstanding command slot. */
1763 req
->outstanding_cmds
[index
] = NULL
;
1764 bsg_job
= sp
->u
.bsg_job
;
1766 ql_log(ql_log_warn
, vha
, 0x70b0,
1767 "Req:%d: Invalid ISP SCSI completion handle(0x%x)\n",
1770 set_bit(ISP_ABORT_NEEDED
, &vha
->dpc_flags
);
1774 if (IS_FWI2_CAPABLE(ha
)) {
1775 comp_status
= le16_to_cpu(sts24
->comp_status
);
1776 scsi_status
= le16_to_cpu(sts24
->scsi_status
) & SS_MASK
;
1778 comp_status
= le16_to_cpu(sts
->comp_status
);
1779 scsi_status
= le16_to_cpu(sts
->scsi_status
) & SS_MASK
;
1782 thread_id
= bsg_job
->request
->rqst_data
.h_vendor
.vendor_cmd
[1];
1783 switch (comp_status
) {
1785 if (scsi_status
== 0) {
1786 bsg_job
->reply
->reply_payload_rcv_len
=
1787 bsg_job
->reply_payload
.payload_len
;
1788 rval
= EXT_STATUS_OK
;
1792 case CS_DATA_OVERRUN
:
1793 ql_dbg(ql_dbg_user
, vha
, 0x70b1,
1794 "Command completed with date overrun thread_id=%d\n",
1796 rval
= EXT_STATUS_DATA_OVERRUN
;
1799 case CS_DATA_UNDERRUN
:
1800 ql_dbg(ql_dbg_user
, vha
, 0x70b2,
1801 "Command completed with date underrun thread_id=%d\n",
1803 rval
= EXT_STATUS_DATA_UNDERRUN
;
1805 case CS_BIDIR_RD_OVERRUN
:
1806 ql_dbg(ql_dbg_user
, vha
, 0x70b3,
1807 "Command completed with read data overrun thread_id=%d\n",
1809 rval
= EXT_STATUS_DATA_OVERRUN
;
1812 case CS_BIDIR_RD_WR_OVERRUN
:
1813 ql_dbg(ql_dbg_user
, vha
, 0x70b4,
1814 "Command completed with read and write data overrun "
1815 "thread_id=%d\n", thread_id
);
1816 rval
= EXT_STATUS_DATA_OVERRUN
;
1819 case CS_BIDIR_RD_OVERRUN_WR_UNDERRUN
:
1820 ql_dbg(ql_dbg_user
, vha
, 0x70b5,
1821 "Command completed with read data over and write data "
1822 "underrun thread_id=%d\n", thread_id
);
1823 rval
= EXT_STATUS_DATA_OVERRUN
;
1826 case CS_BIDIR_RD_UNDERRUN
:
1827 ql_dbg(ql_dbg_user
, vha
, 0x70b6,
1828 "Command completed with read data data underrun "
1829 "thread_id=%d\n", thread_id
);
1830 rval
= EXT_STATUS_DATA_UNDERRUN
;
1833 case CS_BIDIR_RD_UNDERRUN_WR_OVERRUN
:
1834 ql_dbg(ql_dbg_user
, vha
, 0x70b7,
1835 "Command completed with read data under and write data "
1836 "overrun thread_id=%d\n", thread_id
);
1837 rval
= EXT_STATUS_DATA_UNDERRUN
;
1840 case CS_BIDIR_RD_WR_UNDERRUN
:
1841 ql_dbg(ql_dbg_user
, vha
, 0x70b8,
1842 "Command completed with read and write data underrun "
1843 "thread_id=%d\n", thread_id
);
1844 rval
= EXT_STATUS_DATA_UNDERRUN
;
1848 ql_dbg(ql_dbg_user
, vha
, 0x70b9,
1849 "Command completed with data DMA error thread_id=%d\n",
1851 rval
= EXT_STATUS_DMA_ERR
;
1855 ql_dbg(ql_dbg_user
, vha
, 0x70ba,
1856 "Command completed with timeout thread_id=%d\n",
1858 rval
= EXT_STATUS_TIMEOUT
;
1861 ql_dbg(ql_dbg_user
, vha
, 0x70bb,
1862 "Command completed with completion status=0x%x "
1863 "thread_id=%d\n", comp_status
, thread_id
);
1864 rval
= EXT_STATUS_ERR
;
1867 bsg_job
->reply
->reply_payload_rcv_len
= 0;
1870 /* Return the vendor specific reply to API */
1871 bsg_job
->reply
->reply_data
.vendor_reply
.vendor_rsp
[0] = rval
;
1872 bsg_job
->reply_len
= sizeof(struct fc_bsg_reply
);
1873 /* Always return DID_OK, bsg will send the vendor specific response
1874 * in this case only */
1875 sp
->done(vha
, sp
, (DID_OK
<< 6));
1880 * qla2x00_status_entry() - Process a Status IOCB entry.
1881 * @ha: SCSI driver HA context
1882 * @pkt: Entry pointer
1885 qla2x00_status_entry(scsi_qla_host_t
*vha
, struct rsp_que
*rsp
, void *pkt
)
1889 struct scsi_cmnd
*cp
;
1891 struct sts_entry_24xx
*sts24
;
1892 uint16_t comp_status
;
1893 uint16_t scsi_status
;
1895 uint8_t lscsi_status
;
1897 uint32_t sense_len
, par_sense_len
, rsp_info_len
, resid_len
,
1899 uint8_t *rsp_info
, *sense_data
;
1900 struct qla_hw_data
*ha
= vha
->hw
;
1903 struct req_que
*req
;
1906 uint16_t state_flags
= 0;
1908 sts
= (sts_entry_t
*) pkt
;
1909 sts24
= (struct sts_entry_24xx
*) pkt
;
1910 if (IS_FWI2_CAPABLE(ha
)) {
1911 comp_status
= le16_to_cpu(sts24
->comp_status
);
1912 scsi_status
= le16_to_cpu(sts24
->scsi_status
) & SS_MASK
;
1913 state_flags
= le16_to_cpu(sts24
->state_flags
);
1915 comp_status
= le16_to_cpu(sts
->comp_status
);
1916 scsi_status
= le16_to_cpu(sts
->scsi_status
) & SS_MASK
;
1918 handle
= (uint32_t) LSW(sts
->handle
);
1919 que
= MSW(sts
->handle
);
1920 req
= ha
->req_q_map
[que
];
1922 /* Validate handle. */
1923 if (handle
< req
->num_outstanding_cmds
)
1924 sp
= req
->outstanding_cmds
[handle
];
1929 ql_dbg(ql_dbg_io
, vha
, 0x3017,
1930 "Invalid status handle (0x%x).\n", sts
->handle
);
1933 set_bit(FCOE_CTX_RESET_NEEDED
, &vha
->dpc_flags
);
1935 set_bit(ISP_ABORT_NEEDED
, &vha
->dpc_flags
);
1936 qla2xxx_wake_dpc(vha
);
1940 if (unlikely((state_flags
& BIT_1
) && (sp
->type
== SRB_BIDI_CMD
))) {
1941 qla25xx_process_bidir_status_iocb(vha
, pkt
, req
, handle
);
1945 /* Fast path completion. */
1946 if (comp_status
== CS_COMPLETE
&& scsi_status
== 0) {
1947 qla2x00_do_host_ramp_up(vha
);
1948 qla2x00_process_completed_request(vha
, req
, handle
);
1953 req
->outstanding_cmds
[handle
] = NULL
;
1954 cp
= GET_CMD_SP(sp
);
1956 ql_dbg(ql_dbg_io
, vha
, 0x3018,
1957 "Command already returned (0x%x/%p).\n",
1963 lscsi_status
= scsi_status
& STATUS_MASK
;
1965 fcport
= sp
->fcport
;
1968 sense_len
= par_sense_len
= rsp_info_len
= resid_len
=
1970 if (IS_FWI2_CAPABLE(ha
)) {
1971 if (scsi_status
& SS_SENSE_LEN_VALID
)
1972 sense_len
= le32_to_cpu(sts24
->sense_len
);
1973 if (scsi_status
& SS_RESPONSE_INFO_LEN_VALID
)
1974 rsp_info_len
= le32_to_cpu(sts24
->rsp_data_len
);
1975 if (scsi_status
& (SS_RESIDUAL_UNDER
| SS_RESIDUAL_OVER
))
1976 resid_len
= le32_to_cpu(sts24
->rsp_residual_count
);
1977 if (comp_status
== CS_DATA_UNDERRUN
)
1978 fw_resid_len
= le32_to_cpu(sts24
->residual_len
);
1979 rsp_info
= sts24
->data
;
1980 sense_data
= sts24
->data
;
1981 host_to_fcp_swap(sts24
->data
, sizeof(sts24
->data
));
1982 ox_id
= le16_to_cpu(sts24
->ox_id
);
1983 par_sense_len
= sizeof(sts24
->data
);
1985 if (scsi_status
& SS_SENSE_LEN_VALID
)
1986 sense_len
= le16_to_cpu(sts
->req_sense_length
);
1987 if (scsi_status
& SS_RESPONSE_INFO_LEN_VALID
)
1988 rsp_info_len
= le16_to_cpu(sts
->rsp_info_len
);
1989 resid_len
= le32_to_cpu(sts
->residual_length
);
1990 rsp_info
= sts
->rsp_info
;
1991 sense_data
= sts
->req_sense_data
;
1992 par_sense_len
= sizeof(sts
->req_sense_data
);
1995 /* Check for any FCP transport errors. */
1996 if (scsi_status
& SS_RESPONSE_INFO_LEN_VALID
) {
1997 /* Sense data lies beyond any FCP RESPONSE data. */
1998 if (IS_FWI2_CAPABLE(ha
)) {
1999 sense_data
+= rsp_info_len
;
2000 par_sense_len
-= rsp_info_len
;
2002 if (rsp_info_len
> 3 && rsp_info
[3]) {
2003 ql_dbg(ql_dbg_io
, fcport
->vha
, 0x3019,
2004 "FCP I/O protocol failure (0x%x/0x%x).\n",
2005 rsp_info_len
, rsp_info
[3]);
2007 res
= DID_BUS_BUSY
<< 16;
2012 /* Check for overrun. */
2013 if (IS_FWI2_CAPABLE(ha
) && comp_status
== CS_COMPLETE
&&
2014 scsi_status
& SS_RESIDUAL_OVER
)
2015 comp_status
= CS_DATA_OVERRUN
;
2018 * Based on Host and scsi status generate status code for Linux
2020 switch (comp_status
) {
2023 if (scsi_status
== 0) {
2027 if (scsi_status
& (SS_RESIDUAL_UNDER
| SS_RESIDUAL_OVER
)) {
2029 scsi_set_resid(cp
, resid
);
2031 if (!lscsi_status
&&
2032 ((unsigned)(scsi_bufflen(cp
) - resid
) <
2034 ql_dbg(ql_dbg_io
, fcport
->vha
, 0x301a,
2035 "Mid-layer underflow "
2036 "detected (0x%x of 0x%x bytes).\n",
2037 resid
, scsi_bufflen(cp
));
2039 res
= DID_ERROR
<< 16;
2043 res
= DID_OK
<< 16 | lscsi_status
;
2045 if (lscsi_status
== SAM_STAT_TASK_SET_FULL
) {
2046 ql_dbg(ql_dbg_io
, fcport
->vha
, 0x301b,
2047 "QUEUE FULL detected.\n");
2051 if (lscsi_status
!= SS_CHECK_CONDITION
)
2054 memset(cp
->sense_buffer
, 0, SCSI_SENSE_BUFFERSIZE
);
2055 if (!(scsi_status
& SS_SENSE_LEN_VALID
))
2058 qla2x00_handle_sense(sp
, sense_data
, par_sense_len
, sense_len
,
2062 case CS_DATA_UNDERRUN
:
2063 /* Use F/W calculated residual length. */
2064 resid
= IS_FWI2_CAPABLE(ha
) ? fw_resid_len
: resid_len
;
2065 scsi_set_resid(cp
, resid
);
2066 if (scsi_status
& SS_RESIDUAL_UNDER
) {
2067 if (IS_FWI2_CAPABLE(ha
) && fw_resid_len
!= resid_len
) {
2068 ql_dbg(ql_dbg_io
, fcport
->vha
, 0x301d,
2069 "Dropped frame(s) detected "
2070 "(0x%x of 0x%x bytes).\n",
2071 resid
, scsi_bufflen(cp
));
2073 res
= DID_ERROR
<< 16 | lscsi_status
;
2074 goto check_scsi_status
;
2077 if (!lscsi_status
&&
2078 ((unsigned)(scsi_bufflen(cp
) - resid
) <
2080 ql_dbg(ql_dbg_io
, fcport
->vha
, 0x301e,
2081 "Mid-layer underflow "
2082 "detected (0x%x of 0x%x bytes).\n",
2083 resid
, scsi_bufflen(cp
));
2085 res
= DID_ERROR
<< 16;
2088 } else if (lscsi_status
!= SAM_STAT_TASK_SET_FULL
&&
2089 lscsi_status
!= SAM_STAT_BUSY
) {
2091 * scsi status of task set and busy are considered to be
2092 * task not completed.
2095 ql_dbg(ql_dbg_io
, fcport
->vha
, 0x301f,
2096 "Dropped frame(s) detected (0x%x "
2097 "of 0x%x bytes).\n", resid
,
2100 res
= DID_ERROR
<< 16 | lscsi_status
;
2101 goto check_scsi_status
;
2103 ql_dbg(ql_dbg_io
, fcport
->vha
, 0x3030,
2104 "scsi_status: 0x%x, lscsi_status: 0x%x\n",
2105 scsi_status
, lscsi_status
);
2108 res
= DID_OK
<< 16 | lscsi_status
;
2113 * Check to see if SCSI Status is non zero. If so report SCSI
2116 if (lscsi_status
!= 0) {
2117 if (lscsi_status
== SAM_STAT_TASK_SET_FULL
) {
2118 ql_dbg(ql_dbg_io
, fcport
->vha
, 0x3020,
2119 "QUEUE FULL detected.\n");
2123 if (lscsi_status
!= SS_CHECK_CONDITION
)
2126 memset(cp
->sense_buffer
, 0, SCSI_SENSE_BUFFERSIZE
);
2127 if (!(scsi_status
& SS_SENSE_LEN_VALID
))
2130 qla2x00_handle_sense(sp
, sense_data
, par_sense_len
,
2131 sense_len
, rsp
, res
);
2135 case CS_PORT_LOGGED_OUT
:
2136 case CS_PORT_CONFIG_CHG
:
2139 case CS_PORT_UNAVAILABLE
:
2144 * We are going to have the fc class block the rport
2145 * while we try to recover so instruct the mid layer
2146 * to requeue until the class decides how to handle this.
2148 res
= DID_TRANSPORT_DISRUPTED
<< 16;
2150 if (comp_status
== CS_TIMEOUT
) {
2151 if (IS_FWI2_CAPABLE(ha
))
2153 else if ((le16_to_cpu(sts
->status_flags
) &
2154 SF_LOGOUT_SENT
) == 0)
2158 ql_dbg(ql_dbg_io
, fcport
->vha
, 0x3021,
2159 "Port down status: port-state=0x%x.\n",
2160 atomic_read(&fcport
->state
));
2162 if (atomic_read(&fcport
->state
) == FCS_ONLINE
)
2163 qla2x00_mark_device_lost(fcport
->vha
, fcport
, 1, 1);
2167 res
= DID_RESET
<< 16;
2171 logit
= qla2x00_handle_dif_error(sp
, sts24
);
2176 res
= DID_ERROR
<< 16;
2178 if (!IS_PI_SPLIT_DET_CAPABLE(ha
))
2181 if (state_flags
& BIT_4
)
2182 scmd_printk(KERN_WARNING
, cp
,
2183 "Unsupported device '%s' found.\n",
2184 cp
->device
->vendor
);
2188 res
= DID_ERROR
<< 16;
2194 ql_dbg(ql_dbg_io
, fcport
->vha
, 0x3022,
2195 "FCP command status: 0x%x-0x%x (0x%x) "
2196 "nexus=%ld:%d:%d portid=%02x%02x%02x oxid=0x%x "
2197 "cdb=%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x len=0x%x "
2198 "rsp_info=0x%x resid=0x%x fw_resid=0x%x.\n",
2199 comp_status
, scsi_status
, res
, vha
->host_no
,
2200 cp
->device
->id
, cp
->device
->lun
, fcport
->d_id
.b
.domain
,
2201 fcport
->d_id
.b
.area
, fcport
->d_id
.b
.al_pa
, ox_id
,
2202 cp
->cmnd
[0], cp
->cmnd
[1], cp
->cmnd
[2], cp
->cmnd
[3],
2203 cp
->cmnd
[4], cp
->cmnd
[5], cp
->cmnd
[6], cp
->cmnd
[7],
2204 cp
->cmnd
[8], cp
->cmnd
[9], scsi_bufflen(cp
), rsp_info_len
,
2205 resid_len
, fw_resid_len
);
2208 qla2x00_do_host_ramp_up(vha
);
2210 if (rsp
->status_srb
== NULL
)
2211 sp
->done(ha
, sp
, res
);
2215 * qla2x00_status_cont_entry() - Process a Status Continuations entry.
2216 * @ha: SCSI driver HA context
2217 * @pkt: Entry pointer
2219 * Extended sense data.
2222 qla2x00_status_cont_entry(struct rsp_que
*rsp
, sts_cont_entry_t
*pkt
)
2224 uint8_t sense_sz
= 0;
2225 struct qla_hw_data
*ha
= rsp
->hw
;
2226 struct scsi_qla_host
*vha
= pci_get_drvdata(ha
->pdev
);
2227 srb_t
*sp
= rsp
->status_srb
;
2228 struct scsi_cmnd
*cp
;
2232 if (!sp
|| !GET_CMD_SENSE_LEN(sp
))
2235 sense_len
= GET_CMD_SENSE_LEN(sp
);
2236 sense_ptr
= GET_CMD_SENSE_PTR(sp
);
2238 cp
= GET_CMD_SP(sp
);
2240 ql_log(ql_log_warn
, vha
, 0x3025,
2241 "cmd is NULL: already returned to OS (sp=%p).\n", sp
);
2243 rsp
->status_srb
= NULL
;
2247 if (sense_len
> sizeof(pkt
->data
))
2248 sense_sz
= sizeof(pkt
->data
);
2250 sense_sz
= sense_len
;
2252 /* Move sense data. */
2253 if (IS_FWI2_CAPABLE(ha
))
2254 host_to_fcp_swap(pkt
->data
, sizeof(pkt
->data
));
2255 memcpy(sense_ptr
, pkt
->data
, sense_sz
);
2256 ql_dump_buffer(ql_dbg_io
+ ql_dbg_buffer
, vha
, 0x302c,
2257 sense_ptr
, sense_sz
);
2259 sense_len
-= sense_sz
;
2260 sense_ptr
+= sense_sz
;
2262 SET_CMD_SENSE_PTR(sp
, sense_ptr
);
2263 SET_CMD_SENSE_LEN(sp
, sense_len
);
2265 /* Place command on done queue. */
2266 if (sense_len
== 0) {
2267 rsp
->status_srb
= NULL
;
2268 sp
->done(ha
, sp
, cp
->result
);
2273 * qla2x00_error_entry() - Process an error entry.
2274 * @ha: SCSI driver HA context
2275 * @pkt: Entry pointer
2278 qla2x00_error_entry(scsi_qla_host_t
*vha
, struct rsp_que
*rsp
, sts_entry_t
*pkt
)
2281 struct qla_hw_data
*ha
= vha
->hw
;
2282 const char func
[] = "ERROR-IOCB";
2283 uint16_t que
= MSW(pkt
->handle
);
2284 struct req_que
*req
= NULL
;
2285 int res
= DID_ERROR
<< 16;
2287 ql_dbg(ql_dbg_async
, vha
, 0x502a,
2288 "type of error status in response: 0x%x\n", pkt
->entry_status
);
2290 if (que
>= ha
->max_req_queues
|| !ha
->req_q_map
[que
])
2293 req
= ha
->req_q_map
[que
];
2295 if (pkt
->entry_status
& RF_BUSY
)
2296 res
= DID_BUS_BUSY
<< 16;
2298 sp
= qla2x00_get_sp_from_handle(vha
, func
, req
, pkt
);
2300 sp
->done(ha
, sp
, res
);
2304 ql_log(ql_log_warn
, vha
, 0x5030,
2305 "Error entry - invalid handle/queue.\n");
2308 set_bit(FCOE_CTX_RESET_NEEDED
, &vha
->dpc_flags
);
2310 set_bit(ISP_ABORT_NEEDED
, &vha
->dpc_flags
);
2311 qla2xxx_wake_dpc(vha
);
2315 * qla24xx_mbx_completion() - Process mailbox command completions.
2316 * @ha: SCSI driver HA context
2317 * @mb0: Mailbox0 register
2320 qla24xx_mbx_completion(scsi_qla_host_t
*vha
, uint16_t mb0
)
2324 uint16_t __iomem
*wptr
;
2325 struct qla_hw_data
*ha
= vha
->hw
;
2326 struct device_reg_24xx __iomem
*reg
= &ha
->iobase
->isp24
;
2328 /* Read all mbox registers? */
2329 mboxes
= (1 << ha
->mbx_count
) - 1;
2331 ql_dbg(ql_dbg_async
, vha
, 0x504e, "MBX pointer ERROR.\n");
2333 mboxes
= ha
->mcp
->in_mb
;
2335 /* Load return mailbox registers. */
2336 ha
->flags
.mbox_int
= 1;
2337 ha
->mailbox_out
[0] = mb0
;
2339 wptr
= (uint16_t __iomem
*)®
->mailbox1
;
2341 for (cnt
= 1; cnt
< ha
->mbx_count
; cnt
++) {
2343 ha
->mailbox_out
[cnt
] = RD_REG_WORD(wptr
);
2351 * qla24xx_process_response_queue() - Process response queue entries.
2352 * @ha: SCSI driver HA context
2354 void qla24xx_process_response_queue(struct scsi_qla_host
*vha
,
2355 struct rsp_que
*rsp
)
2357 struct sts_entry_24xx
*pkt
;
2358 struct qla_hw_data
*ha
= vha
->hw
;
2360 if (!vha
->flags
.online
)
2363 while (rsp
->ring_ptr
->signature
!= RESPONSE_PROCESSED
) {
2364 pkt
= (struct sts_entry_24xx
*)rsp
->ring_ptr
;
2367 if (rsp
->ring_index
== rsp
->length
) {
2368 rsp
->ring_index
= 0;
2369 rsp
->ring_ptr
= rsp
->ring
;
2374 if (pkt
->entry_status
!= 0) {
2375 qla2x00_error_entry(vha
, rsp
, (sts_entry_t
*) pkt
);
2377 (void)qlt_24xx_process_response_error(vha
, pkt
);
2379 ((response_t
*)pkt
)->signature
= RESPONSE_PROCESSED
;
2384 switch (pkt
->entry_type
) {
2386 qla2x00_status_entry(vha
, rsp
, pkt
);
2388 case STATUS_CONT_TYPE
:
2389 qla2x00_status_cont_entry(rsp
, (sts_cont_entry_t
*)pkt
);
2391 case VP_RPT_ID_IOCB_TYPE
:
2392 qla24xx_report_id_acquisition(vha
,
2393 (struct vp_rpt_id_entry_24xx
*)pkt
);
2395 case LOGINOUT_PORT_IOCB_TYPE
:
2396 qla24xx_logio_entry(vha
, rsp
->req
,
2397 (struct logio_entry_24xx
*)pkt
);
2399 case TSK_MGMT_IOCB_TYPE
:
2400 qla24xx_tm_iocb_entry(vha
, rsp
->req
,
2401 (struct tsk_mgmt_entry
*)pkt
);
2404 qla24xx_els_ct_entry(vha
, rsp
->req
, pkt
, CT_IOCB_TYPE
);
2407 qla24xx_els_ct_entry(vha
, rsp
->req
, pkt
, ELS_IOCB_TYPE
);
2409 case ABTS_RECV_24XX
:
2410 /* ensure that the ATIO queue is empty */
2411 qlt_24xx_process_atio_queue(vha
);
2412 case ABTS_RESP_24XX
:
2414 case NOTIFY_ACK_TYPE
:
2415 qlt_response_pkt_all_vps(vha
, (response_t
*)pkt
);
2418 /* Do nothing in this case, this check is to prevent it
2419 * from falling into default case
2423 /* Type Not Supported. */
2424 ql_dbg(ql_dbg_async
, vha
, 0x5042,
2425 "Received unknown response pkt type %x "
2426 "entry status=%x.\n",
2427 pkt
->entry_type
, pkt
->entry_status
);
2430 ((response_t
*)pkt
)->signature
= RESPONSE_PROCESSED
;
2434 /* Adjust ring index */
2435 if (IS_QLA82XX(ha
)) {
2436 struct device_reg_82xx __iomem
*reg
= &ha
->iobase
->isp82
;
2437 WRT_REG_DWORD(®
->rsp_q_out
[0], rsp
->ring_index
);
2439 WRT_REG_DWORD(rsp
->rsp_q_out
, rsp
->ring_index
);
2443 qla2xxx_check_risc_status(scsi_qla_host_t
*vha
)
2447 struct qla_hw_data
*ha
= vha
->hw
;
2448 struct device_reg_24xx __iomem
*reg
= &ha
->iobase
->isp24
;
2450 if (!IS_QLA25XX(ha
) && !IS_QLA81XX(ha
) && !IS_QLA83XX(ha
))
2454 WRT_REG_DWORD(®
->iobase_addr
, 0x7C00);
2455 RD_REG_DWORD(®
->iobase_addr
);
2456 WRT_REG_DWORD(®
->iobase_window
, 0x0001);
2457 for (cnt
= 10000; (RD_REG_DWORD(®
->iobase_window
) & BIT_0
) == 0 &&
2458 rval
== QLA_SUCCESS
; cnt
--) {
2460 WRT_REG_DWORD(®
->iobase_window
, 0x0001);
2463 rval
= QLA_FUNCTION_TIMEOUT
;
2465 if (rval
== QLA_SUCCESS
)
2468 WRT_REG_DWORD(®
->iobase_window
, 0x0003);
2469 for (cnt
= 100; (RD_REG_DWORD(®
->iobase_window
) & BIT_0
) == 0 &&
2470 rval
== QLA_SUCCESS
; cnt
--) {
2472 WRT_REG_DWORD(®
->iobase_window
, 0x0003);
2475 rval
= QLA_FUNCTION_TIMEOUT
;
2477 if (rval
!= QLA_SUCCESS
)
2481 if (RD_REG_DWORD(®
->iobase_c8
) & BIT_3
)
2482 ql_log(ql_log_info
, vha
, 0x504c,
2483 "Additional code -- 0x55AA.\n");
2486 WRT_REG_DWORD(®
->iobase_window
, 0x0000);
2487 RD_REG_DWORD(®
->iobase_window
);
2491 * qla24xx_intr_handler() - Process interrupts for the ISP23xx and ISP24xx.
2493 * @dev_id: SCSI driver HA context
2495 * Called by system whenever the host adapter generates an interrupt.
2497 * Returns handled flag.
2500 qla24xx_intr_handler(int irq
, void *dev_id
)
2502 scsi_qla_host_t
*vha
;
2503 struct qla_hw_data
*ha
;
2504 struct device_reg_24xx __iomem
*reg
;
2510 struct rsp_que
*rsp
;
2511 unsigned long flags
;
2513 rsp
= (struct rsp_que
*) dev_id
;
2515 ql_log(ql_log_info
, NULL
, 0x5059,
2516 "%s: NULL response queue pointer.\n", __func__
);
2521 reg
= &ha
->iobase
->isp24
;
2524 if (unlikely(pci_channel_offline(ha
->pdev
)))
2527 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
2528 vha
= pci_get_drvdata(ha
->pdev
);
2529 for (iter
= 50; iter
--; ) {
2530 stat
= RD_REG_DWORD(®
->host_status
);
2531 if (stat
& HSRX_RISC_PAUSED
) {
2532 if (unlikely(pci_channel_offline(ha
->pdev
)))
2535 hccr
= RD_REG_DWORD(®
->hccr
);
2537 ql_log(ql_log_warn
, vha
, 0x504b,
2538 "RISC paused -- HCCR=%x, Dumping firmware.\n",
2541 qla2xxx_check_risc_status(vha
);
2543 ha
->isp_ops
->fw_dump(vha
, 1);
2544 set_bit(ISP_ABORT_NEEDED
, &vha
->dpc_flags
);
2546 } else if ((stat
& HSRX_RISC_INT
) == 0)
2549 switch (stat
& 0xff) {
2550 case INTR_ROM_MB_SUCCESS
:
2551 case INTR_ROM_MB_FAILED
:
2552 case INTR_MB_SUCCESS
:
2553 case INTR_MB_FAILED
:
2554 qla24xx_mbx_completion(vha
, MSW(stat
));
2555 status
|= MBX_INTERRUPT
;
2558 case INTR_ASYNC_EVENT
:
2560 mb
[1] = RD_REG_WORD(®
->mailbox1
);
2561 mb
[2] = RD_REG_WORD(®
->mailbox2
);
2562 mb
[3] = RD_REG_WORD(®
->mailbox3
);
2563 qla2x00_async_event(vha
, rsp
, mb
);
2565 case INTR_RSP_QUE_UPDATE
:
2566 case INTR_RSP_QUE_UPDATE_83XX
:
2567 qla24xx_process_response_queue(vha
, rsp
);
2569 case INTR_ATIO_QUE_UPDATE
:
2570 qlt_24xx_process_atio_queue(vha
);
2572 case INTR_ATIO_RSP_QUE_UPDATE
:
2573 qlt_24xx_process_atio_queue(vha
);
2574 qla24xx_process_response_queue(vha
, rsp
);
2577 ql_dbg(ql_dbg_async
, vha
, 0x504f,
2578 "Unrecognized interrupt type (%d).\n", stat
* 0xff);
2581 WRT_REG_DWORD(®
->hccr
, HCCRX_CLR_RISC_INT
);
2582 RD_REG_DWORD_RELAXED(®
->hccr
);
2583 if (unlikely(IS_QLA83XX(ha
) && (ha
->pdev
->revision
== 1)))
2586 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
2588 if (test_bit(MBX_INTR_WAIT
, &ha
->mbx_cmd_flags
) &&
2589 (status
& MBX_INTERRUPT
) && ha
->flags
.mbox_int
) {
2590 set_bit(MBX_INTERRUPT
, &ha
->mbx_cmd_flags
);
2591 complete(&ha
->mbx_intr_comp
);
2598 qla24xx_msix_rsp_q(int irq
, void *dev_id
)
2600 struct qla_hw_data
*ha
;
2601 struct rsp_que
*rsp
;
2602 struct device_reg_24xx __iomem
*reg
;
2603 struct scsi_qla_host
*vha
;
2604 unsigned long flags
;
2606 rsp
= (struct rsp_que
*) dev_id
;
2608 ql_log(ql_log_info
, NULL
, 0x505a,
2609 "%s: NULL response queue pointer.\n", __func__
);
2613 reg
= &ha
->iobase
->isp24
;
2615 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
2617 vha
= pci_get_drvdata(ha
->pdev
);
2618 qla24xx_process_response_queue(vha
, rsp
);
2619 if (!ha
->flags
.disable_msix_handshake
) {
2620 WRT_REG_DWORD(®
->hccr
, HCCRX_CLR_RISC_INT
);
2621 RD_REG_DWORD_RELAXED(®
->hccr
);
2623 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
2629 qla25xx_msix_rsp_q(int irq
, void *dev_id
)
2631 struct qla_hw_data
*ha
;
2632 struct rsp_que
*rsp
;
2633 struct device_reg_24xx __iomem
*reg
;
2634 unsigned long flags
;
2636 rsp
= (struct rsp_que
*) dev_id
;
2638 ql_log(ql_log_info
, NULL
, 0x505b,
2639 "%s: NULL response queue pointer.\n", __func__
);
2644 /* Clear the interrupt, if enabled, for this response queue */
2645 if (!ha
->flags
.disable_msix_handshake
) {
2646 reg
= &ha
->iobase
->isp24
;
2647 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
2648 WRT_REG_DWORD(®
->hccr
, HCCRX_CLR_RISC_INT
);
2649 RD_REG_DWORD_RELAXED(®
->hccr
);
2650 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
2652 queue_work_on((int) (rsp
->id
- 1), ha
->wq
, &rsp
->q_work
);
2658 qla24xx_msix_default(int irq
, void *dev_id
)
2660 scsi_qla_host_t
*vha
;
2661 struct qla_hw_data
*ha
;
2662 struct rsp_que
*rsp
;
2663 struct device_reg_24xx __iomem
*reg
;
2668 unsigned long flags
;
2670 rsp
= (struct rsp_que
*) dev_id
;
2672 ql_log(ql_log_info
, NULL
, 0x505c,
2673 "%s: NULL response queue pointer.\n", __func__
);
2677 reg
= &ha
->iobase
->isp24
;
2680 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
2681 vha
= pci_get_drvdata(ha
->pdev
);
2683 stat
= RD_REG_DWORD(®
->host_status
);
2684 if (stat
& HSRX_RISC_PAUSED
) {
2685 if (unlikely(pci_channel_offline(ha
->pdev
)))
2688 hccr
= RD_REG_DWORD(®
->hccr
);
2690 ql_log(ql_log_info
, vha
, 0x5050,
2691 "RISC paused -- HCCR=%x, Dumping firmware.\n",
2694 qla2xxx_check_risc_status(vha
);
2696 ha
->isp_ops
->fw_dump(vha
, 1);
2697 set_bit(ISP_ABORT_NEEDED
, &vha
->dpc_flags
);
2699 } else if ((stat
& HSRX_RISC_INT
) == 0)
2702 switch (stat
& 0xff) {
2703 case INTR_ROM_MB_SUCCESS
:
2704 case INTR_ROM_MB_FAILED
:
2705 case INTR_MB_SUCCESS
:
2706 case INTR_MB_FAILED
:
2707 qla24xx_mbx_completion(vha
, MSW(stat
));
2708 status
|= MBX_INTERRUPT
;
2711 case INTR_ASYNC_EVENT
:
2713 mb
[1] = RD_REG_WORD(®
->mailbox1
);
2714 mb
[2] = RD_REG_WORD(®
->mailbox2
);
2715 mb
[3] = RD_REG_WORD(®
->mailbox3
);
2716 qla2x00_async_event(vha
, rsp
, mb
);
2718 case INTR_RSP_QUE_UPDATE
:
2719 case INTR_RSP_QUE_UPDATE_83XX
:
2720 qla24xx_process_response_queue(vha
, rsp
);
2722 case INTR_ATIO_QUE_UPDATE
:
2723 qlt_24xx_process_atio_queue(vha
);
2725 case INTR_ATIO_RSP_QUE_UPDATE
:
2726 qlt_24xx_process_atio_queue(vha
);
2727 qla24xx_process_response_queue(vha
, rsp
);
2730 ql_dbg(ql_dbg_async
, vha
, 0x5051,
2731 "Unrecognized interrupt type (%d).\n", stat
& 0xff);
2734 WRT_REG_DWORD(®
->hccr
, HCCRX_CLR_RISC_INT
);
2736 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
2738 if (test_bit(MBX_INTR_WAIT
, &ha
->mbx_cmd_flags
) &&
2739 (status
& MBX_INTERRUPT
) && ha
->flags
.mbox_int
) {
2740 set_bit(MBX_INTERRUPT
, &ha
->mbx_cmd_flags
);
2741 complete(&ha
->mbx_intr_comp
);
2746 /* Interrupt handling helpers. */
2748 struct qla_init_msix_entry
{
2750 irq_handler_t handler
;
2753 static struct qla_init_msix_entry msix_entries
[3] = {
2754 { "qla2xxx (default)", qla24xx_msix_default
},
2755 { "qla2xxx (rsp_q)", qla24xx_msix_rsp_q
},
2756 { "qla2xxx (multiq)", qla25xx_msix_rsp_q
},
2759 static struct qla_init_msix_entry qla82xx_msix_entries
[2] = {
2760 { "qla2xxx (default)", qla82xx_msix_default
},
2761 { "qla2xxx (rsp_q)", qla82xx_msix_rsp_q
},
2764 static struct qla_init_msix_entry qla83xx_msix_entries
[3] = {
2765 { "qla2xxx (default)", qla24xx_msix_default
},
2766 { "qla2xxx (rsp_q)", qla24xx_msix_rsp_q
},
2767 { "qla2xxx (atio_q)", qla83xx_msix_atio_q
},
2771 qla24xx_disable_msix(struct qla_hw_data
*ha
)
2774 struct qla_msix_entry
*qentry
;
2775 scsi_qla_host_t
*vha
= pci_get_drvdata(ha
->pdev
);
2777 for (i
= 0; i
< ha
->msix_count
; i
++) {
2778 qentry
= &ha
->msix_entries
[i
];
2779 if (qentry
->have_irq
)
2780 free_irq(qentry
->vector
, qentry
->rsp
);
2782 pci_disable_msix(ha
->pdev
);
2783 kfree(ha
->msix_entries
);
2784 ha
->msix_entries
= NULL
;
2785 ha
->flags
.msix_enabled
= 0;
2786 ql_dbg(ql_dbg_init
, vha
, 0x0042,
2787 "Disabled the MSI.\n");
2791 qla24xx_enable_msix(struct qla_hw_data
*ha
, struct rsp_que
*rsp
)
2793 #define MIN_MSIX_COUNT 2
2795 struct msix_entry
*entries
;
2796 struct qla_msix_entry
*qentry
;
2797 scsi_qla_host_t
*vha
= pci_get_drvdata(ha
->pdev
);
2799 entries
= kzalloc(sizeof(struct msix_entry
) * ha
->msix_count
,
2802 ql_log(ql_log_warn
, vha
, 0x00bc,
2803 "Failed to allocate memory for msix_entry.\n");
2807 for (i
= 0; i
< ha
->msix_count
; i
++)
2808 entries
[i
].entry
= i
;
2810 ret
= pci_enable_msix(ha
->pdev
, entries
, ha
->msix_count
);
2812 if (ret
< MIN_MSIX_COUNT
)
2815 ql_log(ql_log_warn
, vha
, 0x00c6,
2816 "MSI-X: Failed to enable support "
2817 "-- %d/%d\n Retry with %d vectors.\n",
2818 ha
->msix_count
, ret
, ret
);
2819 ha
->msix_count
= ret
;
2820 ret
= pci_enable_msix(ha
->pdev
, entries
, ha
->msix_count
);
2823 ql_log(ql_log_fatal
, vha
, 0x00c7,
2824 "MSI-X: Failed to enable support, "
2825 "giving up -- %d/%d.\n",
2826 ha
->msix_count
, ret
);
2829 ha
->max_rsp_queues
= ha
->msix_count
- 1;
2831 ha
->msix_entries
= kzalloc(sizeof(struct qla_msix_entry
) *
2832 ha
->msix_count
, GFP_KERNEL
);
2833 if (!ha
->msix_entries
) {
2834 ql_log(ql_log_fatal
, vha
, 0x00c8,
2835 "Failed to allocate memory for ha->msix_entries.\n");
2839 ha
->flags
.msix_enabled
= 1;
2841 for (i
= 0; i
< ha
->msix_count
; i
++) {
2842 qentry
= &ha
->msix_entries
[i
];
2843 qentry
->vector
= entries
[i
].vector
;
2844 qentry
->entry
= entries
[i
].entry
;
2845 qentry
->have_irq
= 0;
2849 /* Enable MSI-X vectors for the base queue */
2850 for (i
= 0; i
< ha
->msix_count
; i
++) {
2851 qentry
= &ha
->msix_entries
[i
];
2852 if (QLA_TGT_MODE_ENABLED() && IS_ATIO_MSIX_CAPABLE(ha
)) {
2853 ret
= request_irq(qentry
->vector
,
2854 qla83xx_msix_entries
[i
].handler
,
2855 0, qla83xx_msix_entries
[i
].name
, rsp
);
2856 } else if (IS_QLA82XX(ha
)) {
2857 ret
= request_irq(qentry
->vector
,
2858 qla82xx_msix_entries
[i
].handler
,
2859 0, qla82xx_msix_entries
[i
].name
, rsp
);
2861 ret
= request_irq(qentry
->vector
,
2862 msix_entries
[i
].handler
,
2863 0, msix_entries
[i
].name
, rsp
);
2866 ql_log(ql_log_fatal
, vha
, 0x00cb,
2867 "MSI-X: unable to register handler -- %x/%d.\n",
2868 qentry
->vector
, ret
);
2869 qla24xx_disable_msix(ha
);
2873 qentry
->have_irq
= 1;
2878 /* Enable MSI-X vector for response queue update for queue 0 */
2879 if (IS_QLA83XX(ha
)) {
2880 if (ha
->msixbase
&& ha
->mqiobase
&&
2881 (ha
->max_rsp_queues
> 1 || ha
->max_req_queues
> 1))
2885 && (ha
->max_rsp_queues
> 1 || ha
->max_req_queues
> 1))
2887 ql_dbg(ql_dbg_multiq
, vha
, 0xc005,
2888 "mqiobase=%p, max_rsp_queues=%d, max_req_queues=%d.\n",
2889 ha
->mqiobase
, ha
->max_rsp_queues
, ha
->max_req_queues
);
2890 ql_dbg(ql_dbg_init
, vha
, 0x0055,
2891 "mqiobase=%p, max_rsp_queues=%d, max_req_queues=%d.\n",
2892 ha
->mqiobase
, ha
->max_rsp_queues
, ha
->max_req_queues
);
2900 qla2x00_request_irqs(struct qla_hw_data
*ha
, struct rsp_que
*rsp
)
2903 device_reg_t __iomem
*reg
= ha
->iobase
;
2904 scsi_qla_host_t
*vha
= pci_get_drvdata(ha
->pdev
);
2906 /* If possible, enable MSI-X. */
2907 if (!IS_QLA2432(ha
) && !IS_QLA2532(ha
) && !IS_QLA8432(ha
) &&
2908 !IS_CNA_CAPABLE(ha
) && !IS_QLA2031(ha
))
2911 if (ha
->pdev
->subsystem_vendor
== PCI_VENDOR_ID_HP
&&
2912 (ha
->pdev
->subsystem_device
== 0x7040 ||
2913 ha
->pdev
->subsystem_device
== 0x7041 ||
2914 ha
->pdev
->subsystem_device
== 0x1705)) {
2915 ql_log(ql_log_warn
, vha
, 0x0034,
2916 "MSI-X: Unsupported ISP 2432 SSVID/SSDID (0x%X,0x%X).\n",
2917 ha
->pdev
->subsystem_vendor
,
2918 ha
->pdev
->subsystem_device
);
2922 if (IS_QLA2432(ha
) && (ha
->pdev
->revision
< QLA_MSIX_CHIP_REV_24XX
)) {
2923 ql_log(ql_log_warn
, vha
, 0x0035,
2924 "MSI-X; Unsupported ISP2432 (0x%X, 0x%X).\n",
2925 ha
->pdev
->revision
, QLA_MSIX_CHIP_REV_24XX
);
2929 ret
= qla24xx_enable_msix(ha
, rsp
);
2931 ql_dbg(ql_dbg_init
, vha
, 0x0036,
2932 "MSI-X: Enabled (0x%X, 0x%X).\n",
2933 ha
->chip_revision
, ha
->fw_attributes
);
2934 goto clear_risc_ints
;
2936 ql_log(ql_log_info
, vha
, 0x0037,
2937 "MSI-X Falling back-to MSI mode -%d.\n", ret
);
2940 if (!IS_QLA24XX(ha
) && !IS_QLA2532(ha
) && !IS_QLA8432(ha
) &&
2941 !IS_QLA8001(ha
) && !IS_QLA82XX(ha
))
2944 ret
= pci_enable_msi(ha
->pdev
);
2946 ql_dbg(ql_dbg_init
, vha
, 0x0038,
2948 ha
->flags
.msi_enabled
= 1;
2950 ql_log(ql_log_warn
, vha
, 0x0039,
2951 "MSI-X; Falling back-to INTa mode -- %d.\n", ret
);
2953 /* Skip INTx on ISP82xx. */
2954 if (!ha
->flags
.msi_enabled
&& IS_QLA82XX(ha
))
2955 return QLA_FUNCTION_FAILED
;
2959 ret
= request_irq(ha
->pdev
->irq
, ha
->isp_ops
->intr_handler
,
2960 ha
->flags
.msi_enabled
? 0 : IRQF_SHARED
,
2961 QLA2XXX_DRIVER_NAME
, rsp
);
2963 ql_log(ql_log_warn
, vha
, 0x003a,
2964 "Failed to reserve interrupt %d already in use.\n",
2967 } else if (!ha
->flags
.msi_enabled
)
2968 ql_dbg(ql_dbg_init
, vha
, 0x0125,
2969 "INTa mode: Enabled.\n");
2973 spin_lock_irq(&ha
->hardware_lock
);
2974 if (!IS_FWI2_CAPABLE(ha
))
2975 WRT_REG_WORD(®
->isp
.semaphore
, 0);
2976 spin_unlock_irq(&ha
->hardware_lock
);
2983 qla2x00_free_irqs(scsi_qla_host_t
*vha
)
2985 struct qla_hw_data
*ha
= vha
->hw
;
2986 struct rsp_que
*rsp
;
2989 * We need to check that ha->rsp_q_map is valid in case we are called
2990 * from a probe failure context.
2992 if (!ha
->rsp_q_map
|| !ha
->rsp_q_map
[0])
2994 rsp
= ha
->rsp_q_map
[0];
2996 if (ha
->flags
.msix_enabled
)
2997 qla24xx_disable_msix(ha
);
2998 else if (ha
->flags
.msi_enabled
) {
2999 free_irq(ha
->pdev
->irq
, rsp
);
3000 pci_disable_msi(ha
->pdev
);
3002 free_irq(ha
->pdev
->irq
, rsp
);
3006 int qla25xx_request_irq(struct rsp_que
*rsp
)
3008 struct qla_hw_data
*ha
= rsp
->hw
;
3009 struct qla_init_msix_entry
*intr
= &msix_entries
[2];
3010 struct qla_msix_entry
*msix
= rsp
->msix
;
3011 scsi_qla_host_t
*vha
= pci_get_drvdata(ha
->pdev
);
3014 ret
= request_irq(msix
->vector
, intr
->handler
, 0, intr
->name
, rsp
);
3016 ql_log(ql_log_fatal
, vha
, 0x00e6,
3017 "MSI-X: Unable to register handler -- %x/%d.\n",