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/delay.h>
10 #include <scsi/scsi_tcq.h>
12 static void qla2x00_mbx_completion(scsi_qla_host_t
*, uint16_t);
13 static void qla2x00_process_completed_request(struct scsi_qla_host
*,
14 struct req_que
*, uint32_t);
15 static void qla2x00_status_entry(scsi_qla_host_t
*, struct rsp_que
*, void *);
16 static void qla2x00_status_cont_entry(scsi_qla_host_t
*, sts_cont_entry_t
*);
17 static void qla2x00_error_entry(scsi_qla_host_t
*, struct rsp_que
*,
19 static struct scsi_qla_host
*qla2x00_get_rsp_host(struct rsp_que
*);
22 * qla2100_intr_handler() - Process interrupts for the ISP2100 and ISP2200.
24 * @dev_id: SCSI driver HA context
26 * Called by system whenever the host adapter generates an interrupt.
28 * Returns handled flag.
31 qla2100_intr_handler(int irq
, void *dev_id
)
34 struct qla_hw_data
*ha
;
35 struct device_reg_2xxx __iomem
*reg
;
42 rsp
= (struct rsp_que
*) dev_id
;
45 "%s(): NULL response queue pointer\n", __func__
);
50 reg
= &ha
->iobase
->isp
;
53 spin_lock(&ha
->hardware_lock
);
54 vha
= qla2x00_get_rsp_host(rsp
);
55 for (iter
= 50; iter
--; ) {
56 hccr
= RD_REG_WORD(®
->hccr
);
57 if (hccr
& HCCR_RISC_PAUSE
) {
58 if (pci_channel_offline(ha
->pdev
))
62 * Issue a "HARD" reset in order for the RISC interrupt
63 * bit to be cleared. Schedule a big hammmer to get
64 * out of the RISC PAUSED state.
66 WRT_REG_WORD(®
->hccr
, HCCR_RESET_RISC
);
67 RD_REG_WORD(®
->hccr
);
69 ha
->isp_ops
->fw_dump(vha
, 1);
70 set_bit(ISP_ABORT_NEEDED
, &vha
->dpc_flags
);
72 } else if ((RD_REG_WORD(®
->istatus
) & ISR_RISC_INT
) == 0)
75 if (RD_REG_WORD(®
->semaphore
) & BIT_0
) {
76 WRT_REG_WORD(®
->hccr
, HCCR_CLR_RISC_INT
);
77 RD_REG_WORD(®
->hccr
);
79 /* Get mailbox data. */
80 mb
[0] = RD_MAILBOX_REG(ha
, reg
, 0);
81 if (mb
[0] > 0x3fff && mb
[0] < 0x8000) {
82 qla2x00_mbx_completion(vha
, mb
[0]);
83 status
|= MBX_INTERRUPT
;
84 } else if (mb
[0] > 0x7fff && mb
[0] < 0xc000) {
85 mb
[1] = RD_MAILBOX_REG(ha
, reg
, 1);
86 mb
[2] = RD_MAILBOX_REG(ha
, reg
, 2);
87 mb
[3] = RD_MAILBOX_REG(ha
, reg
, 3);
88 qla2x00_async_event(vha
, rsp
, mb
);
91 DEBUG2(printk("scsi(%ld): Unrecognized "
92 "interrupt type (%d).\n",
93 vha
->host_no
, mb
[0]));
95 /* Release mailbox registers. */
96 WRT_REG_WORD(®
->semaphore
, 0);
97 RD_REG_WORD(®
->semaphore
);
99 qla2x00_process_response_queue(rsp
);
101 WRT_REG_WORD(®
->hccr
, HCCR_CLR_RISC_INT
);
102 RD_REG_WORD(®
->hccr
);
105 spin_unlock(&ha
->hardware_lock
);
107 if (test_bit(MBX_INTR_WAIT
, &ha
->mbx_cmd_flags
) &&
108 (status
& MBX_INTERRUPT
) && ha
->flags
.mbox_int
) {
109 set_bit(MBX_INTERRUPT
, &ha
->mbx_cmd_flags
);
110 complete(&ha
->mbx_intr_comp
);
113 return (IRQ_HANDLED
);
117 * qla2300_intr_handler() - Process interrupts for the ISP23xx and ISP63xx.
119 * @dev_id: SCSI driver HA context
121 * Called by system whenever the host adapter generates an interrupt.
123 * Returns handled flag.
126 qla2300_intr_handler(int irq
, void *dev_id
)
128 scsi_qla_host_t
*vha
;
129 struct device_reg_2xxx __iomem
*reg
;
136 struct qla_hw_data
*ha
;
138 rsp
= (struct rsp_que
*) dev_id
;
141 "%s(): NULL response queue pointer\n", __func__
);
146 reg
= &ha
->iobase
->isp
;
149 spin_lock(&ha
->hardware_lock
);
150 vha
= qla2x00_get_rsp_host(rsp
);
151 for (iter
= 50; iter
--; ) {
152 stat
= RD_REG_DWORD(®
->u
.isp2300
.host_status
);
153 if (stat
& HSR_RISC_PAUSED
) {
154 if (pci_channel_offline(ha
->pdev
))
157 hccr
= RD_REG_WORD(®
->hccr
);
158 if (hccr
& (BIT_15
| BIT_13
| BIT_11
| BIT_8
))
159 qla_printk(KERN_INFO
, ha
, "Parity error -- "
160 "HCCR=%x, Dumping firmware!\n", hccr
);
162 qla_printk(KERN_INFO
, ha
, "RISC paused -- "
163 "HCCR=%x, Dumping firmware!\n", hccr
);
166 * Issue a "HARD" reset in order for the RISC
167 * interrupt bit to be cleared. Schedule a big
168 * hammmer to get out of the RISC PAUSED state.
170 WRT_REG_WORD(®
->hccr
, HCCR_RESET_RISC
);
171 RD_REG_WORD(®
->hccr
);
173 ha
->isp_ops
->fw_dump(vha
, 1);
174 set_bit(ISP_ABORT_NEEDED
, &vha
->dpc_flags
);
176 } else if ((stat
& HSR_RISC_INT
) == 0)
179 switch (stat
& 0xff) {
184 qla2x00_mbx_completion(vha
, MSW(stat
));
185 status
|= MBX_INTERRUPT
;
187 /* Release mailbox registers. */
188 WRT_REG_WORD(®
->semaphore
, 0);
192 mb
[1] = RD_MAILBOX_REG(ha
, reg
, 1);
193 mb
[2] = RD_MAILBOX_REG(ha
, reg
, 2);
194 mb
[3] = RD_MAILBOX_REG(ha
, reg
, 3);
195 qla2x00_async_event(vha
, rsp
, mb
);
198 qla2x00_process_response_queue(rsp
);
201 mb
[0] = MBA_CMPLT_1_16BIT
;
203 qla2x00_async_event(vha
, rsp
, mb
);
206 mb
[0] = MBA_SCSI_COMPLETION
;
208 mb
[2] = RD_MAILBOX_REG(ha
, reg
, 2);
209 qla2x00_async_event(vha
, rsp
, mb
);
212 DEBUG2(printk("scsi(%ld): Unrecognized interrupt type "
214 vha
->host_no
, stat
& 0xff));
217 WRT_REG_WORD(®
->hccr
, HCCR_CLR_RISC_INT
);
218 RD_REG_WORD_RELAXED(®
->hccr
);
220 spin_unlock(&ha
->hardware_lock
);
222 if (test_bit(MBX_INTR_WAIT
, &ha
->mbx_cmd_flags
) &&
223 (status
& MBX_INTERRUPT
) && ha
->flags
.mbox_int
) {
224 set_bit(MBX_INTERRUPT
, &ha
->mbx_cmd_flags
);
225 complete(&ha
->mbx_intr_comp
);
228 return (IRQ_HANDLED
);
232 * qla2x00_mbx_completion() - Process mailbox command completions.
233 * @ha: SCSI driver HA context
234 * @mb0: Mailbox0 register
237 qla2x00_mbx_completion(scsi_qla_host_t
*vha
, uint16_t mb0
)
240 uint16_t __iomem
*wptr
;
241 struct qla_hw_data
*ha
= vha
->hw
;
242 struct device_reg_2xxx __iomem
*reg
= &ha
->iobase
->isp
;
244 /* Load return mailbox registers. */
245 ha
->flags
.mbox_int
= 1;
246 ha
->mailbox_out
[0] = mb0
;
247 wptr
= (uint16_t __iomem
*)MAILBOX_REG(ha
, reg
, 1);
249 for (cnt
= 1; cnt
< ha
->mbx_count
; cnt
++) {
250 if (IS_QLA2200(ha
) && cnt
== 8)
251 wptr
= (uint16_t __iomem
*)MAILBOX_REG(ha
, reg
, 8);
252 if (cnt
== 4 || cnt
== 5)
253 ha
->mailbox_out
[cnt
] = qla2x00_debounce_register(wptr
);
255 ha
->mailbox_out
[cnt
] = RD_REG_WORD(wptr
);
261 DEBUG3(printk("%s(%ld): Got mailbox completion. cmd=%x.\n",
262 __func__
, vha
->host_no
, ha
->mcp
->mb
[0]));
264 DEBUG2_3(printk("%s(%ld): MBX pointer ERROR!\n",
265 __func__
, vha
->host_no
));
270 qla81xx_idc_event(scsi_qla_host_t
*vha
, uint16_t aen
, uint16_t descr
)
272 static char *event
[] =
273 { "Complete", "Request Notification", "Time Extension" };
275 struct device_reg_24xx __iomem
*reg24
= &vha
->hw
->iobase
->isp24
;
276 uint16_t __iomem
*wptr
;
277 uint16_t cnt
, timeout
, mb
[QLA_IDC_ACK_REGS
];
279 /* Seed data -- mailbox1 -> mailbox7. */
280 wptr
= (uint16_t __iomem
*)®24
->mailbox1
;
281 for (cnt
= 0; cnt
< QLA_IDC_ACK_REGS
; cnt
++, wptr
++)
282 mb
[cnt
] = RD_REG_WORD(wptr
);
284 DEBUG2(printk("scsi(%ld): Inter-Driver Commucation %s -- "
285 "%04x %04x %04x %04x %04x %04x %04x.\n", vha
->host_no
,
287 mb
[0], mb
[1], mb
[2], mb
[3], mb
[4], mb
[5], mb
[6]));
289 /* Acknowledgement needed? [Notify && non-zero timeout]. */
290 timeout
= (descr
>> 8) & 0xf;
291 if (aen
!= MBA_IDC_NOTIFY
|| !timeout
)
294 DEBUG2(printk("scsi(%ld): Inter-Driver Commucation %s -- "
295 "ACK timeout=%d.\n", vha
->host_no
, event
[aen
& 0xff], timeout
));
297 rval
= qla2x00_post_idc_ack_work(vha
, mb
);
298 if (rval
!= QLA_SUCCESS
)
299 qla_printk(KERN_WARNING
, vha
->hw
,
300 "IDC failed to post ACK.\n");
304 * qla2x00_async_event() - Process aynchronous events.
305 * @ha: SCSI driver HA context
306 * @mb: Mailbox registers (0 - 3)
309 qla2x00_async_event(scsi_qla_host_t
*vha
, struct rsp_que
*rsp
, uint16_t *mb
)
312 static char *link_speeds
[] = { "1", "2", "?", "4", "8", "10" };
317 struct qla_hw_data
*ha
= vha
->hw
;
318 struct device_reg_2xxx __iomem
*reg
= &ha
->iobase
->isp
;
319 uint32_t rscn_entry
, host_pid
;
320 uint8_t rscn_queue_index
;
323 /* Setup to process RIO completion. */
328 case MBA_SCSI_COMPLETION
:
329 handles
[0] = le32_to_cpu((uint32_t)((mb
[2] << 16) | mb
[1]));
332 case MBA_CMPLT_1_16BIT
:
335 mb
[0] = MBA_SCSI_COMPLETION
;
337 case MBA_CMPLT_2_16BIT
:
341 mb
[0] = MBA_SCSI_COMPLETION
;
343 case MBA_CMPLT_3_16BIT
:
348 mb
[0] = MBA_SCSI_COMPLETION
;
350 case MBA_CMPLT_4_16BIT
:
354 handles
[3] = (uint32_t)RD_MAILBOX_REG(ha
, reg
, 6);
356 mb
[0] = MBA_SCSI_COMPLETION
;
358 case MBA_CMPLT_5_16BIT
:
362 handles
[3] = (uint32_t)RD_MAILBOX_REG(ha
, reg
, 6);
363 handles
[4] = (uint32_t)RD_MAILBOX_REG(ha
, reg
, 7);
365 mb
[0] = MBA_SCSI_COMPLETION
;
367 case MBA_CMPLT_2_32BIT
:
368 handles
[0] = le32_to_cpu((uint32_t)((mb
[2] << 16) | mb
[1]));
369 handles
[1] = le32_to_cpu(
370 ((uint32_t)(RD_MAILBOX_REG(ha
, reg
, 7) << 16)) |
371 RD_MAILBOX_REG(ha
, reg
, 6));
373 mb
[0] = MBA_SCSI_COMPLETION
;
380 case MBA_SCSI_COMPLETION
: /* Fast Post */
381 if (!vha
->flags
.online
)
384 for (cnt
= 0; cnt
< handle_cnt
; cnt
++)
385 qla2x00_process_completed_request(vha
, rsp
->req
,
389 case MBA_RESET
: /* Reset */
390 DEBUG2(printk("scsi(%ld): Asynchronous RESET.\n",
393 set_bit(RESET_MARKER_NEEDED
, &vha
->dpc_flags
);
396 case MBA_SYSTEM_ERR
: /* System Error */
397 qla_printk(KERN_INFO
, ha
,
398 "ISP System Error - mbx1=%xh mbx2=%xh mbx3=%xh.\n",
399 mb
[1], mb
[2], mb
[3]);
401 ha
->isp_ops
->fw_dump(vha
, 1);
403 if (IS_FWI2_CAPABLE(ha
)) {
404 if (mb
[1] == 0 && mb
[2] == 0) {
405 qla_printk(KERN_ERR
, ha
,
406 "Unrecoverable Hardware Error: adapter "
407 "marked OFFLINE!\n");
408 vha
->flags
.online
= 0;
410 set_bit(ISP_ABORT_NEEDED
, &vha
->dpc_flags
);
411 } else if (mb
[1] == 0) {
412 qla_printk(KERN_INFO
, ha
,
413 "Unrecoverable Hardware Error: adapter marked "
415 vha
->flags
.online
= 0;
417 set_bit(ISP_ABORT_NEEDED
, &vha
->dpc_flags
);
420 case MBA_REQ_TRANSFER_ERR
: /* Request Transfer Error */
421 DEBUG2(printk("scsi(%ld): ISP Request Transfer Error.\n",
423 qla_printk(KERN_WARNING
, ha
, "ISP Request Transfer Error.\n");
425 set_bit(ISP_ABORT_NEEDED
, &vha
->dpc_flags
);
428 case MBA_RSP_TRANSFER_ERR
: /* Response Transfer Error */
429 DEBUG2(printk("scsi(%ld): ISP Response Transfer Error.\n",
431 qla_printk(KERN_WARNING
, ha
, "ISP Response Transfer Error.\n");
433 set_bit(ISP_ABORT_NEEDED
, &vha
->dpc_flags
);
436 case MBA_WAKEUP_THRES
: /* Request Queue Wake-up */
437 DEBUG2(printk("scsi(%ld): Asynchronous WAKEUP_THRES.\n",
441 case MBA_LIP_OCCURRED
: /* Loop Initialization Procedure */
442 DEBUG2(printk("scsi(%ld): LIP occurred (%x).\n", vha
->host_no
,
444 qla_printk(KERN_INFO
, ha
, "LIP occurred (%x).\n", mb
[1]);
446 if (atomic_read(&vha
->loop_state
) != LOOP_DOWN
) {
447 atomic_set(&vha
->loop_state
, LOOP_DOWN
);
448 atomic_set(&vha
->loop_down_timer
, LOOP_DOWN_TIME
);
449 qla2x00_mark_all_devices_lost(vha
, 1);
453 atomic_set(&vha
->vp_state
, VP_FAILED
);
454 fc_vport_set_state(vha
->fc_vport
, FC_VPORT_FAILED
);
457 set_bit(REGISTER_FC4_NEEDED
, &vha
->dpc_flags
);
458 set_bit(REGISTER_FDMI_NEEDED
, &vha
->dpc_flags
);
460 vha
->flags
.management_server_logged_in
= 0;
461 qla2x00_post_aen_work(vha
, FCH_EVT_LIP
, mb
[1]);
464 case MBA_LOOP_UP
: /* Loop Up Event */
465 if (IS_QLA2100(ha
) || IS_QLA2200(ha
)) {
466 link_speed
= link_speeds
[0];
467 ha
->link_data_rate
= PORT_SPEED_1GB
;
469 link_speed
= link_speeds
[LS_UNKNOWN
];
471 link_speed
= link_speeds
[mb
[1]];
472 else if (mb
[1] == 0x13)
473 link_speed
= link_speeds
[5];
474 ha
->link_data_rate
= mb
[1];
477 DEBUG2(printk("scsi(%ld): Asynchronous LOOP UP (%s Gbps).\n",
478 vha
->host_no
, link_speed
));
479 qla_printk(KERN_INFO
, ha
, "LOOP UP detected (%s Gbps).\n",
482 vha
->flags
.management_server_logged_in
= 0;
483 qla2x00_post_aen_work(vha
, FCH_EVT_LINKUP
, ha
->link_data_rate
);
486 case MBA_LOOP_DOWN
: /* Loop Down Event */
487 DEBUG2(printk("scsi(%ld): Asynchronous LOOP DOWN "
488 "(%x %x %x).\n", vha
->host_no
, mb
[1], mb
[2], mb
[3]));
489 qla_printk(KERN_INFO
, ha
, "LOOP DOWN detected (%x %x %x).\n",
490 mb
[1], mb
[2], mb
[3]);
492 if (atomic_read(&vha
->loop_state
) != LOOP_DOWN
) {
493 atomic_set(&vha
->loop_state
, LOOP_DOWN
);
494 atomic_set(&vha
->loop_down_timer
, LOOP_DOWN_TIME
);
495 vha
->device_flags
|= DFLG_NO_CABLE
;
496 qla2x00_mark_all_devices_lost(vha
, 1);
500 atomic_set(&vha
->vp_state
, VP_FAILED
);
501 fc_vport_set_state(vha
->fc_vport
, FC_VPORT_FAILED
);
504 vha
->flags
.management_server_logged_in
= 0;
505 ha
->link_data_rate
= PORT_SPEED_UNKNOWN
;
506 qla2x00_post_aen_work(vha
, FCH_EVT_LINKDOWN
, 0);
509 case MBA_LIP_RESET
: /* LIP reset occurred */
510 DEBUG2(printk("scsi(%ld): Asynchronous LIP RESET (%x).\n",
511 vha
->host_no
, mb
[1]));
512 qla_printk(KERN_INFO
, ha
,
513 "LIP reset occurred (%x).\n", mb
[1]);
515 if (atomic_read(&vha
->loop_state
) != LOOP_DOWN
) {
516 atomic_set(&vha
->loop_state
, LOOP_DOWN
);
517 atomic_set(&vha
->loop_down_timer
, LOOP_DOWN_TIME
);
518 qla2x00_mark_all_devices_lost(vha
, 1);
522 atomic_set(&vha
->vp_state
, VP_FAILED
);
523 fc_vport_set_state(vha
->fc_vport
, FC_VPORT_FAILED
);
526 set_bit(RESET_MARKER_NEEDED
, &vha
->dpc_flags
);
528 ha
->operating_mode
= LOOP
;
529 vha
->flags
.management_server_logged_in
= 0;
530 qla2x00_post_aen_work(vha
, FCH_EVT_LIPRESET
, mb
[1]);
533 /* case MBA_DCBX_COMPLETE: */
534 case MBA_POINT_TO_POINT
: /* Point-to-Point */
539 DEBUG2(printk("scsi(%ld): DCBX Completed -- %04x %04x "
540 "%04x\n", vha
->host_no
, mb
[1], mb
[2], mb
[3]));
542 DEBUG2(printk("scsi(%ld): Asynchronous P2P MODE "
543 "received.\n", vha
->host_no
));
546 * Until there's a transition from loop down to loop up, treat
547 * this as loop down only.
549 if (atomic_read(&vha
->loop_state
) != LOOP_DOWN
) {
550 atomic_set(&vha
->loop_state
, LOOP_DOWN
);
551 if (!atomic_read(&vha
->loop_down_timer
))
552 atomic_set(&vha
->loop_down_timer
,
554 qla2x00_mark_all_devices_lost(vha
, 1);
558 atomic_set(&vha
->vp_state
, VP_FAILED
);
559 fc_vport_set_state(vha
->fc_vport
, FC_VPORT_FAILED
);
562 if (!(test_bit(ABORT_ISP_ACTIVE
, &vha
->dpc_flags
)))
563 set_bit(RESET_MARKER_NEEDED
, &vha
->dpc_flags
);
565 set_bit(REGISTER_FC4_NEEDED
, &vha
->dpc_flags
);
566 set_bit(REGISTER_FDMI_NEEDED
, &vha
->dpc_flags
);
568 ha
->flags
.gpsc_supported
= 1;
569 vha
->flags
.management_server_logged_in
= 0;
572 case MBA_CHG_IN_CONNECTION
: /* Change in connection mode */
576 DEBUG2(printk("scsi(%ld): Asynchronous Change In Connection "
579 qla_printk(KERN_INFO
, ha
,
580 "Configuration change detected: value=%x.\n", mb
[1]);
582 if (atomic_read(&vha
->loop_state
) != LOOP_DOWN
) {
583 atomic_set(&vha
->loop_state
, LOOP_DOWN
);
584 if (!atomic_read(&vha
->loop_down_timer
))
585 atomic_set(&vha
->loop_down_timer
,
587 qla2x00_mark_all_devices_lost(vha
, 1);
591 atomic_set(&vha
->vp_state
, VP_FAILED
);
592 fc_vport_set_state(vha
->fc_vport
, FC_VPORT_FAILED
);
595 set_bit(LOOP_RESYNC_NEEDED
, &vha
->dpc_flags
);
596 set_bit(LOCAL_LOOP_UPDATE
, &vha
->dpc_flags
);
599 case MBA_PORT_UPDATE
: /* Port database update */
600 /* Only handle SCNs for our Vport index. */
601 if (vha
->vp_idx
&& vha
->vp_idx
!= (mb
[3] & 0xff))
605 * If PORT UPDATE is global (received LIP_OCCURRED/LIP_RESET
606 * event etc. earlier indicating loop is down) then process
607 * it. Otherwise ignore it and Wait for RSCN to come in.
609 atomic_set(&vha
->loop_down_timer
, 0);
610 if (atomic_read(&vha
->loop_state
) != LOOP_DOWN
&&
611 atomic_read(&vha
->loop_state
) != LOOP_DEAD
) {
612 DEBUG2(printk("scsi(%ld): Asynchronous PORT UPDATE "
613 "ignored %04x/%04x/%04x.\n", vha
->host_no
, mb
[1],
618 DEBUG2(printk("scsi(%ld): Asynchronous PORT UPDATE.\n",
620 DEBUG(printk(KERN_INFO
621 "scsi(%ld): Port database changed %04x %04x %04x.\n",
622 vha
->host_no
, mb
[1], mb
[2], mb
[3]));
625 * Mark all devices as missing so we will login again.
627 atomic_set(&vha
->loop_state
, LOOP_UP
);
629 qla2x00_mark_all_devices_lost(vha
, 1);
631 vha
->flags
.rscn_queue_overflow
= 1;
633 set_bit(LOOP_RESYNC_NEEDED
, &vha
->dpc_flags
);
634 set_bit(LOCAL_LOOP_UPDATE
, &vha
->dpc_flags
);
637 case MBA_RSCN_UPDATE
: /* State Change Registration */
638 /* Check if the Vport has issued a SCR */
639 if (vha
->vp_idx
&& test_bit(VP_SCR_NEEDED
, &vha
->vp_flags
))
641 /* Only handle SCNs for our Vport index. */
642 if (vha
->vp_idx
&& vha
->vp_idx
!= (mb
[3] & 0xff))
644 DEBUG2(printk("scsi(%ld): Asynchronous RSCR UPDATE.\n",
646 DEBUG(printk(KERN_INFO
647 "scsi(%ld): RSCN database changed -- %04x %04x %04x.\n",
648 vha
->host_no
, mb
[1], mb
[2], mb
[3]));
650 rscn_entry
= ((mb
[1] & 0xff) << 16) | mb
[2];
651 host_pid
= (vha
->d_id
.b
.domain
<< 16) | (vha
->d_id
.b
.area
<< 8)
653 if (rscn_entry
== host_pid
) {
654 DEBUG(printk(KERN_INFO
655 "scsi(%ld): Ignoring RSCN update to local host "
657 vha
->host_no
, host_pid
));
661 /* Ignore reserved bits from RSCN-payload. */
662 rscn_entry
= ((mb
[1] & 0x3ff) << 16) | mb
[2];
663 rscn_queue_index
= vha
->rscn_in_ptr
+ 1;
664 if (rscn_queue_index
== MAX_RSCN_COUNT
)
665 rscn_queue_index
= 0;
666 if (rscn_queue_index
!= vha
->rscn_out_ptr
) {
667 vha
->rscn_queue
[vha
->rscn_in_ptr
] = rscn_entry
;
668 vha
->rscn_in_ptr
= rscn_queue_index
;
670 vha
->flags
.rscn_queue_overflow
= 1;
673 atomic_set(&vha
->loop_state
, LOOP_UPDATE
);
674 atomic_set(&vha
->loop_down_timer
, 0);
675 vha
->flags
.management_server_logged_in
= 0;
677 set_bit(LOOP_RESYNC_NEEDED
, &vha
->dpc_flags
);
678 set_bit(RSCN_UPDATE
, &vha
->dpc_flags
);
679 qla2x00_post_aen_work(vha
, FCH_EVT_RSCN
, rscn_entry
);
682 /* case MBA_RIO_RESPONSE: */
683 case MBA_ZIO_RESPONSE
:
684 DEBUG3(printk("scsi(%ld): [R|Z]IO update completion.\n",
687 if (IS_FWI2_CAPABLE(ha
))
688 qla24xx_process_response_queue(rsp
);
690 qla2x00_process_response_queue(rsp
);
693 case MBA_DISCARD_RND_FRAME
:
694 DEBUG2(printk("scsi(%ld): Discard RND Frame -- %04x %04x "
695 "%04x.\n", vha
->host_no
, mb
[1], mb
[2], mb
[3]));
698 case MBA_TRACE_NOTIFICATION
:
699 DEBUG2(printk("scsi(%ld): Trace Notification -- %04x %04x.\n",
700 vha
->host_no
, mb
[1], mb
[2]));
703 case MBA_ISP84XX_ALERT
:
704 DEBUG2(printk("scsi(%ld): ISP84XX Alert Notification -- "
705 "%04x %04x %04x\n", vha
->host_no
, mb
[1], mb
[2], mb
[3]));
707 spin_lock_irqsave(&ha
->cs84xx
->access_lock
, flags
);
709 case A84_PANIC_RECOVERY
:
710 qla_printk(KERN_INFO
, ha
, "Alert 84XX: panic recovery "
711 "%04x %04x\n", mb
[2], mb
[3]);
713 case A84_OP_LOGIN_COMPLETE
:
714 ha
->cs84xx
->op_fw_version
= mb
[3] << 16 | mb
[2];
715 DEBUG2(qla_printk(KERN_INFO
, ha
, "Alert 84XX:"
716 "firmware version %x\n", ha
->cs84xx
->op_fw_version
));
718 case A84_DIAG_LOGIN_COMPLETE
:
719 ha
->cs84xx
->diag_fw_version
= mb
[3] << 16 | mb
[2];
720 DEBUG2(qla_printk(KERN_INFO
, ha
, "Alert 84XX:"
721 "diagnostic firmware version %x\n",
722 ha
->cs84xx
->diag_fw_version
));
724 case A84_GOLD_LOGIN_COMPLETE
:
725 ha
->cs84xx
->diag_fw_version
= mb
[3] << 16 | mb
[2];
726 ha
->cs84xx
->fw_update
= 1;
727 DEBUG2(qla_printk(KERN_INFO
, ha
, "Alert 84XX: gold "
728 "firmware version %x\n",
729 ha
->cs84xx
->gold_fw_version
));
732 qla_printk(KERN_ERR
, ha
,
733 "Alert 84xx: Invalid Alert %04x %04x %04x\n",
734 mb
[1], mb
[2], mb
[3]);
736 spin_unlock_irqrestore(&ha
->cs84xx
->access_lock
, flags
);
739 DEBUG2(printk("scsi(%ld): DCBX Started -- %04x %04x %04x\n",
740 vha
->host_no
, mb
[1], mb
[2], mb
[3]));
742 case MBA_DCBX_PARAM_UPDATE
:
743 DEBUG2(printk("scsi(%ld): DCBX Parameters Updated -- "
744 "%04x %04x %04x\n", vha
->host_no
, mb
[1], mb
[2], mb
[3]));
746 case MBA_FCF_CONF_ERR
:
747 DEBUG2(printk("scsi(%ld): FCF Configuration Error -- "
748 "%04x %04x %04x\n", vha
->host_no
, mb
[1], mb
[2], mb
[3]));
750 case MBA_IDC_COMPLETE
:
752 case MBA_IDC_TIME_EXT
:
753 qla81xx_idc_event(vha
, mb
[0], mb
[1]);
757 if (!vha
->vp_idx
&& ha
->num_vhosts
)
758 qla2x00_alert_all_vps(rsp
, mb
);
762 qla2x00_adjust_sdev_qdepth_up(struct scsi_device
*sdev
, void *data
)
764 fc_port_t
*fcport
= data
;
765 struct scsi_qla_host
*vha
= fcport
->vha
;
766 struct qla_hw_data
*ha
= vha
->hw
;
767 struct req_que
*req
= NULL
;
769 req
= ha
->req_q_map
[vha
->req_ques
[0]];
772 if (req
->max_q_depth
<= sdev
->queue_depth
)
775 if (sdev
->ordered_tags
)
776 scsi_adjust_queue_depth(sdev
, MSG_ORDERED_TAG
,
777 sdev
->queue_depth
+ 1);
779 scsi_adjust_queue_depth(sdev
, MSG_SIMPLE_TAG
,
780 sdev
->queue_depth
+ 1);
782 fcport
->last_ramp_up
= jiffies
;
784 DEBUG2(qla_printk(KERN_INFO
, ha
,
785 "scsi(%ld:%d:%d:%d): Queue depth adjusted-up to %d.\n",
786 fcport
->vha
->host_no
, sdev
->channel
, sdev
->id
, sdev
->lun
,
791 qla2x00_adjust_sdev_qdepth_down(struct scsi_device
*sdev
, void *data
)
793 fc_port_t
*fcport
= data
;
795 if (!scsi_track_queue_full(sdev
, sdev
->queue_depth
- 1))
798 DEBUG2(qla_printk(KERN_INFO
, fcport
->vha
->hw
,
799 "scsi(%ld:%d:%d:%d): Queue depth adjusted-down to %d.\n",
800 fcport
->vha
->host_no
, sdev
->channel
, sdev
->id
, sdev
->lun
,
805 qla2x00_ramp_up_queue_depth(scsi_qla_host_t
*vha
, struct req_que
*req
,
809 struct scsi_device
*sdev
;
811 sdev
= sp
->cmd
->device
;
812 if (sdev
->queue_depth
>= req
->max_q_depth
)
816 if (time_before(jiffies
,
817 fcport
->last_ramp_up
+ ql2xqfullrampup
* HZ
))
819 if (time_before(jiffies
,
820 fcport
->last_queue_full
+ ql2xqfullrampup
* HZ
))
823 starget_for_each_device(sdev
->sdev_target
, fcport
,
824 qla2x00_adjust_sdev_qdepth_up
);
828 * qla2x00_process_completed_request() - Process a Fast Post response.
829 * @ha: SCSI driver HA context
833 qla2x00_process_completed_request(struct scsi_qla_host
*vha
,
834 struct req_que
*req
, uint32_t index
)
837 struct qla_hw_data
*ha
= vha
->hw
;
839 /* Validate handle. */
840 if (index
>= MAX_OUTSTANDING_COMMANDS
) {
841 DEBUG2(printk("scsi(%ld): Invalid SCSI completion handle %d.\n",
842 vha
->host_no
, index
));
843 qla_printk(KERN_WARNING
, ha
,
844 "Invalid SCSI completion handle %d.\n", index
);
846 set_bit(ISP_ABORT_NEEDED
, &vha
->dpc_flags
);
850 sp
= req
->outstanding_cmds
[index
];
852 /* Free outstanding command slot. */
853 req
->outstanding_cmds
[index
] = NULL
;
855 CMD_COMPL_STATUS(sp
->cmd
) = 0L;
856 CMD_SCSI_STATUS(sp
->cmd
) = 0L;
858 /* Save ISP completion status */
859 sp
->cmd
->result
= DID_OK
<< 16;
861 qla2x00_ramp_up_queue_depth(vha
, req
, sp
);
862 qla2x00_sp_compl(ha
, sp
);
864 DEBUG2(printk("scsi(%ld): Invalid ISP SCSI completion handle\n",
866 qla_printk(KERN_WARNING
, ha
,
867 "Invalid ISP SCSI completion handle\n");
869 set_bit(ISP_ABORT_NEEDED
, &vha
->dpc_flags
);
874 * qla2x00_process_response_queue() - Process response queue entries.
875 * @ha: SCSI driver HA context
878 qla2x00_process_response_queue(struct rsp_que
*rsp
)
880 struct scsi_qla_host
*vha
;
881 struct qla_hw_data
*ha
= rsp
->hw
;
882 struct device_reg_2xxx __iomem
*reg
= &ha
->iobase
->isp
;
887 vha
= qla2x00_get_rsp_host(rsp
);
889 if (!vha
->flags
.online
)
892 while (rsp
->ring_ptr
->signature
!= RESPONSE_PROCESSED
) {
893 pkt
= (sts_entry_t
*)rsp
->ring_ptr
;
896 if (rsp
->ring_index
== rsp
->length
) {
898 rsp
->ring_ptr
= rsp
->ring
;
903 if (pkt
->entry_status
!= 0) {
904 DEBUG3(printk(KERN_INFO
905 "scsi(%ld): Process error entry.\n", vha
->host_no
));
907 qla2x00_error_entry(vha
, rsp
, pkt
);
908 ((response_t
*)pkt
)->signature
= RESPONSE_PROCESSED
;
913 switch (pkt
->entry_type
) {
915 qla2x00_status_entry(vha
, rsp
, pkt
);
918 handle_cnt
= ((sts21_entry_t
*)pkt
)->handle_count
;
919 for (cnt
= 0; cnt
< handle_cnt
; cnt
++) {
920 qla2x00_process_completed_request(vha
, rsp
->req
,
921 ((sts21_entry_t
*)pkt
)->handle
[cnt
]);
925 handle_cnt
= ((sts22_entry_t
*)pkt
)->handle_count
;
926 for (cnt
= 0; cnt
< handle_cnt
; cnt
++) {
927 qla2x00_process_completed_request(vha
, rsp
->req
,
928 ((sts22_entry_t
*)pkt
)->handle
[cnt
]);
931 case STATUS_CONT_TYPE
:
932 qla2x00_status_cont_entry(vha
, (sts_cont_entry_t
*)pkt
);
935 /* Type Not Supported. */
936 DEBUG4(printk(KERN_WARNING
937 "scsi(%ld): Received unknown response pkt type %x "
938 "entry status=%x.\n",
939 vha
->host_no
, pkt
->entry_type
, pkt
->entry_status
));
942 ((response_t
*)pkt
)->signature
= RESPONSE_PROCESSED
;
946 /* Adjust ring index */
947 WRT_REG_WORD(ISP_RSP_Q_OUT(ha
, reg
), rsp
->ring_index
);
951 qla2x00_handle_sense(srb_t
*sp
, uint8_t *sense_data
, uint32_t sense_len
)
953 struct scsi_cmnd
*cp
= sp
->cmd
;
955 if (sense_len
>= SCSI_SENSE_BUFFERSIZE
)
956 sense_len
= SCSI_SENSE_BUFFERSIZE
;
958 CMD_ACTUAL_SNSLEN(cp
) = sense_len
;
959 sp
->request_sense_length
= sense_len
;
960 sp
->request_sense_ptr
= cp
->sense_buffer
;
961 if (sp
->request_sense_length
> 32)
964 memcpy(cp
->sense_buffer
, sense_data
, sense_len
);
966 sp
->request_sense_ptr
+= sense_len
;
967 sp
->request_sense_length
-= sense_len
;
968 if (sp
->request_sense_length
!= 0)
969 sp
->fcport
->vha
->status_srb
= sp
;
971 DEBUG5(printk("%s(): Check condition Sense data, scsi(%ld:%d:%d:%d) "
972 "cmd=%p pid=%ld\n", __func__
, sp
->fcport
->vha
->host_no
,
973 cp
->device
->channel
, cp
->device
->id
, cp
->device
->lun
, cp
,
976 DEBUG5(qla2x00_dump_buffer(cp
->sense_buffer
,
977 CMD_ACTUAL_SNSLEN(cp
)));
981 * qla2x00_status_entry() - Process a Status IOCB entry.
982 * @ha: SCSI driver HA context
983 * @pkt: Entry pointer
986 qla2x00_status_entry(scsi_qla_host_t
*vha
, struct rsp_que
*rsp
, void *pkt
)
990 struct scsi_cmnd
*cp
;
992 struct sts_entry_24xx
*sts24
;
993 uint16_t comp_status
;
994 uint16_t scsi_status
;
995 uint8_t lscsi_status
;
997 uint32_t sense_len
, rsp_info_len
, resid_len
, fw_resid_len
;
998 uint8_t *rsp_info
, *sense_data
;
999 struct qla_hw_data
*ha
= vha
->hw
;
1000 struct req_que
*req
= rsp
->req
;
1002 sts
= (sts_entry_t
*) pkt
;
1003 sts24
= (struct sts_entry_24xx
*) pkt
;
1004 if (IS_FWI2_CAPABLE(ha
)) {
1005 comp_status
= le16_to_cpu(sts24
->comp_status
);
1006 scsi_status
= le16_to_cpu(sts24
->scsi_status
) & SS_MASK
;
1008 comp_status
= le16_to_cpu(sts
->comp_status
);
1009 scsi_status
= le16_to_cpu(sts
->scsi_status
) & SS_MASK
;
1012 /* Fast path completion. */
1013 if (comp_status
== CS_COMPLETE
&& scsi_status
== 0) {
1014 qla2x00_process_completed_request(vha
, req
, sts
->handle
);
1019 /* Validate handle. */
1020 if (sts
->handle
< MAX_OUTSTANDING_COMMANDS
) {
1021 sp
= req
->outstanding_cmds
[sts
->handle
];
1022 req
->outstanding_cmds
[sts
->handle
] = NULL
;
1027 DEBUG2(printk("scsi(%ld): Status Entry invalid handle.\n",
1029 qla_printk(KERN_WARNING
, ha
, "Status Entry invalid handle.\n");
1031 set_bit(ISP_ABORT_NEEDED
, &vha
->dpc_flags
);
1032 qla2xxx_wake_dpc(vha
);
1037 DEBUG2(printk("scsi(%ld): Command already returned back to OS "
1038 "pkt->handle=%d sp=%p.\n", vha
->host_no
, sts
->handle
, sp
));
1039 qla_printk(KERN_WARNING
, ha
,
1040 "Command is NULL: already returned to OS (sp=%p)\n", sp
);
1045 lscsi_status
= scsi_status
& STATUS_MASK
;
1046 CMD_ENTRY_STATUS(cp
) = sts
->entry_status
;
1047 CMD_COMPL_STATUS(cp
) = comp_status
;
1048 CMD_SCSI_STATUS(cp
) = scsi_status
;
1050 fcport
= sp
->fcport
;
1052 sense_len
= rsp_info_len
= resid_len
= fw_resid_len
= 0;
1053 if (IS_FWI2_CAPABLE(ha
)) {
1054 sense_len
= le32_to_cpu(sts24
->sense_len
);
1055 rsp_info_len
= le32_to_cpu(sts24
->rsp_data_len
);
1056 resid_len
= le32_to_cpu(sts24
->rsp_residual_count
);
1057 fw_resid_len
= le32_to_cpu(sts24
->residual_len
);
1058 rsp_info
= sts24
->data
;
1059 sense_data
= sts24
->data
;
1060 host_to_fcp_swap(sts24
->data
, sizeof(sts24
->data
));
1062 sense_len
= le16_to_cpu(sts
->req_sense_length
);
1063 rsp_info_len
= le16_to_cpu(sts
->rsp_info_len
);
1064 resid_len
= le32_to_cpu(sts
->residual_length
);
1065 rsp_info
= sts
->rsp_info
;
1066 sense_data
= sts
->req_sense_data
;
1069 /* Check for any FCP transport errors. */
1070 if (scsi_status
& SS_RESPONSE_INFO_LEN_VALID
) {
1071 /* Sense data lies beyond any FCP RESPONSE data. */
1072 if (IS_FWI2_CAPABLE(ha
))
1073 sense_data
+= rsp_info_len
;
1074 if (rsp_info_len
> 3 && rsp_info
[3]) {
1075 DEBUG2(printk("scsi(%ld:%d:%d:%d) FCP I/O protocol "
1076 "failure (%x/%02x%02x%02x%02x%02x%02x%02x%02x)..."
1077 "retrying command\n", vha
->host_no
,
1078 cp
->device
->channel
, cp
->device
->id
,
1079 cp
->device
->lun
, rsp_info_len
, rsp_info
[0],
1080 rsp_info
[1], rsp_info
[2], rsp_info
[3], rsp_info
[4],
1081 rsp_info
[5], rsp_info
[6], rsp_info
[7]));
1083 cp
->result
= DID_BUS_BUSY
<< 16;
1084 qla2x00_sp_compl(ha
, sp
);
1089 /* Check for overrun. */
1090 if (IS_FWI2_CAPABLE(ha
) && comp_status
== CS_COMPLETE
&&
1091 scsi_status
& SS_RESIDUAL_OVER
)
1092 comp_status
= CS_DATA_OVERRUN
;
1095 * Based on Host and scsi status generate status code for Linux
1097 switch (comp_status
) {
1100 if (scsi_status
== 0) {
1101 cp
->result
= DID_OK
<< 16;
1104 if (scsi_status
& (SS_RESIDUAL_UNDER
| SS_RESIDUAL_OVER
)) {
1106 scsi_set_resid(cp
, resid
);
1107 CMD_RESID_LEN(cp
) = resid
;
1109 if (!lscsi_status
&&
1110 ((unsigned)(scsi_bufflen(cp
) - resid
) <
1112 qla_printk(KERN_INFO
, ha
,
1113 "scsi(%ld:%d:%d:%d): Mid-layer underflow "
1114 "detected (%x of %x bytes)...returning "
1115 "error status.\n", vha
->host_no
,
1116 cp
->device
->channel
, cp
->device
->id
,
1117 cp
->device
->lun
, resid
,
1120 cp
->result
= DID_ERROR
<< 16;
1124 cp
->result
= DID_OK
<< 16 | lscsi_status
;
1126 if (lscsi_status
== SAM_STAT_TASK_SET_FULL
) {
1127 DEBUG2(printk(KERN_INFO
1128 "scsi(%ld): QUEUE FULL status detected "
1129 "0x%x-0x%x.\n", vha
->host_no
, comp_status
,
1132 /* Adjust queue depth for all luns on the port. */
1133 fcport
->last_queue_full
= jiffies
;
1134 starget_for_each_device(cp
->device
->sdev_target
,
1135 fcport
, qla2x00_adjust_sdev_qdepth_down
);
1138 if (lscsi_status
!= SS_CHECK_CONDITION
)
1141 memset(cp
->sense_buffer
, 0, SCSI_SENSE_BUFFERSIZE
);
1142 if (!(scsi_status
& SS_SENSE_LEN_VALID
))
1145 qla2x00_handle_sense(sp
, sense_data
, sense_len
);
1148 case CS_DATA_UNDERRUN
:
1150 /* Use F/W calculated residual length. */
1151 if (IS_FWI2_CAPABLE(ha
)) {
1152 if (!(scsi_status
& SS_RESIDUAL_UNDER
)) {
1154 } else if (resid
!= fw_resid_len
) {
1155 scsi_status
&= ~SS_RESIDUAL_UNDER
;
1158 resid
= fw_resid_len
;
1161 if (scsi_status
& SS_RESIDUAL_UNDER
) {
1162 scsi_set_resid(cp
, resid
);
1163 CMD_RESID_LEN(cp
) = resid
;
1165 DEBUG2(printk(KERN_INFO
1166 "scsi(%ld:%d:%d) UNDERRUN status detected "
1167 "0x%x-0x%x. resid=0x%x fw_resid=0x%x cdb=0x%x "
1168 "os_underflow=0x%x\n", vha
->host_no
,
1169 cp
->device
->id
, cp
->device
->lun
, comp_status
,
1170 scsi_status
, resid_len
, resid
, cp
->cmnd
[0],
1176 * Check to see if SCSI Status is non zero. If so report SCSI
1179 if (lscsi_status
!= 0) {
1180 cp
->result
= DID_OK
<< 16 | lscsi_status
;
1182 if (lscsi_status
== SAM_STAT_TASK_SET_FULL
) {
1183 DEBUG2(printk(KERN_INFO
1184 "scsi(%ld): QUEUE FULL status detected "
1185 "0x%x-0x%x.\n", vha
->host_no
, comp_status
,
1189 * Adjust queue depth for all luns on the
1192 fcport
->last_queue_full
= jiffies
;
1193 starget_for_each_device(
1194 cp
->device
->sdev_target
, fcport
,
1195 qla2x00_adjust_sdev_qdepth_down
);
1198 if (lscsi_status
!= SS_CHECK_CONDITION
)
1201 memset(cp
->sense_buffer
, 0, SCSI_SENSE_BUFFERSIZE
);
1202 if (!(scsi_status
& SS_SENSE_LEN_VALID
))
1205 qla2x00_handle_sense(sp
, sense_data
, sense_len
);
1208 * If RISC reports underrun and target does not report
1209 * it then we must have a lost frame, so tell upper
1210 * layer to retry it by reporting a bus busy.
1212 if (!(scsi_status
& SS_RESIDUAL_UNDER
)) {
1213 DEBUG2(printk("scsi(%ld:%d:%d:%d) Dropped "
1214 "frame(s) detected (%x of %x bytes)..."
1215 "retrying command.\n",
1216 vha
->host_no
, cp
->device
->channel
,
1217 cp
->device
->id
, cp
->device
->lun
, resid
,
1220 cp
->result
= DID_BUS_BUSY
<< 16;
1224 /* Handle mid-layer underflow */
1225 if ((unsigned)(scsi_bufflen(cp
) - resid
) <
1227 qla_printk(KERN_INFO
, ha
,
1228 "scsi(%ld:%d:%d:%d): Mid-layer underflow "
1229 "detected (%x of %x bytes)...returning "
1230 "error status.\n", vha
->host_no
,
1231 cp
->device
->channel
, cp
->device
->id
,
1232 cp
->device
->lun
, resid
,
1235 cp
->result
= DID_ERROR
<< 16;
1239 /* Everybody online, looking good... */
1240 cp
->result
= DID_OK
<< 16;
1244 case CS_DATA_OVERRUN
:
1245 DEBUG2(printk(KERN_INFO
1246 "scsi(%ld:%d:%d): OVERRUN status detected 0x%x-0x%x\n",
1247 vha
->host_no
, cp
->device
->id
, cp
->device
->lun
, comp_status
,
1249 DEBUG2(printk(KERN_INFO
1250 "CDB: 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x\n",
1251 cp
->cmnd
[0], cp
->cmnd
[1], cp
->cmnd
[2], cp
->cmnd
[3],
1252 cp
->cmnd
[4], cp
->cmnd
[5]));
1253 DEBUG2(printk(KERN_INFO
1254 "PID=0x%lx req=0x%x xtra=0x%x -- returning DID_ERROR "
1256 cp
->serial_number
, scsi_bufflen(cp
), resid_len
));
1258 cp
->result
= DID_ERROR
<< 16;
1261 case CS_PORT_LOGGED_OUT
:
1262 case CS_PORT_CONFIG_CHG
:
1265 case CS_PORT_UNAVAILABLE
:
1267 * If the port is in Target Down state, return all IOs for this
1268 * Target with DID_NO_CONNECT ELSE Queue the IOs in the
1271 DEBUG2(printk("scsi(%ld:%d:%d): status_entry: Port Down "
1272 "pid=%ld, compl status=0x%x, port state=0x%x\n",
1273 vha
->host_no
, cp
->device
->id
, cp
->device
->lun
,
1274 cp
->serial_number
, comp_status
,
1275 atomic_read(&fcport
->state
)));
1278 * We are going to have the fc class block the rport
1279 * while we try to recover so instruct the mid layer
1280 * to requeue until the class decides how to handle this.
1282 cp
->result
= DID_TRANSPORT_DISRUPTED
<< 16;
1283 if (atomic_read(&fcport
->state
) == FCS_ONLINE
)
1284 qla2x00_mark_device_lost(fcport
->vha
, fcport
, 1, 1);
1288 DEBUG2(printk(KERN_INFO
1289 "scsi(%ld): RESET status detected 0x%x-0x%x.\n",
1290 vha
->host_no
, comp_status
, scsi_status
));
1292 cp
->result
= DID_RESET
<< 16;
1297 * hv2.19.12 - DID_ABORT does not retry the request if we
1298 * aborted this request then abort otherwise it must be a
1301 DEBUG2(printk(KERN_INFO
1302 "scsi(%ld): ABORT status detected 0x%x-0x%x.\n",
1303 vha
->host_no
, comp_status
, scsi_status
));
1305 cp
->result
= DID_RESET
<< 16;
1310 * We are going to have the fc class block the rport
1311 * while we try to recover so instruct the mid layer
1312 * to requeue until the class decides how to handle this.
1314 cp
->result
= DID_TRANSPORT_DISRUPTED
<< 16;
1316 if (IS_FWI2_CAPABLE(ha
)) {
1317 DEBUG2(printk(KERN_INFO
1318 "scsi(%ld:%d:%d:%d): TIMEOUT status detected "
1319 "0x%x-0x%x\n", vha
->host_no
, cp
->device
->channel
,
1320 cp
->device
->id
, cp
->device
->lun
, comp_status
,
1324 DEBUG2(printk(KERN_INFO
1325 "scsi(%ld:%d:%d:%d): TIMEOUT status detected 0x%x-0x%x "
1326 "sflags=%x.\n", vha
->host_no
, cp
->device
->channel
,
1327 cp
->device
->id
, cp
->device
->lun
, comp_status
, scsi_status
,
1328 le16_to_cpu(sts
->status_flags
)));
1330 /* Check to see if logout occurred. */
1331 if ((le16_to_cpu(sts
->status_flags
) & SF_LOGOUT_SENT
))
1332 qla2x00_mark_device_lost(fcport
->vha
, fcport
, 1, 1);
1336 DEBUG3(printk("scsi(%ld): Error detected (unknown status) "
1337 "0x%x-0x%x.\n", vha
->host_no
, comp_status
, scsi_status
));
1338 qla_printk(KERN_INFO
, ha
,
1339 "Unknown status detected 0x%x-0x%x.\n",
1340 comp_status
, scsi_status
);
1342 cp
->result
= DID_ERROR
<< 16;
1346 /* Place command on done queue. */
1347 if (vha
->status_srb
== NULL
)
1348 qla2x00_sp_compl(ha
, sp
);
1352 * qla2x00_status_cont_entry() - Process a Status Continuations entry.
1353 * @ha: SCSI driver HA context
1354 * @pkt: Entry pointer
1356 * Extended sense data.
1359 qla2x00_status_cont_entry(scsi_qla_host_t
*vha
, sts_cont_entry_t
*pkt
)
1361 uint8_t sense_sz
= 0;
1362 struct qla_hw_data
*ha
= vha
->hw
;
1363 srb_t
*sp
= vha
->status_srb
;
1364 struct scsi_cmnd
*cp
;
1366 if (sp
!= NULL
&& sp
->request_sense_length
!= 0) {
1369 DEBUG2(printk("%s(): Cmd already returned back to OS "
1370 "sp=%p.\n", __func__
, sp
));
1371 qla_printk(KERN_INFO
, ha
,
1372 "cmd is NULL: already returned to OS (sp=%p)\n",
1375 vha
->status_srb
= NULL
;
1379 if (sp
->request_sense_length
> sizeof(pkt
->data
)) {
1380 sense_sz
= sizeof(pkt
->data
);
1382 sense_sz
= sp
->request_sense_length
;
1385 /* Move sense data. */
1386 if (IS_FWI2_CAPABLE(ha
))
1387 host_to_fcp_swap(pkt
->data
, sizeof(pkt
->data
));
1388 memcpy(sp
->request_sense_ptr
, pkt
->data
, sense_sz
);
1389 DEBUG5(qla2x00_dump_buffer(sp
->request_sense_ptr
, sense_sz
));
1391 sp
->request_sense_ptr
+= sense_sz
;
1392 sp
->request_sense_length
-= sense_sz
;
1394 /* Place command on done queue. */
1395 if (sp
->request_sense_length
== 0) {
1396 vha
->status_srb
= NULL
;
1397 qla2x00_sp_compl(ha
, sp
);
1403 * qla2x00_error_entry() - Process an error entry.
1404 * @ha: SCSI driver HA context
1405 * @pkt: Entry pointer
1408 qla2x00_error_entry(scsi_qla_host_t
*vha
, struct rsp_que
*rsp
, sts_entry_t
*pkt
)
1411 struct qla_hw_data
*ha
= vha
->hw
;
1412 struct req_que
*req
= rsp
->req
;
1413 #if defined(QL_DEBUG_LEVEL_2)
1414 if (pkt
->entry_status
& RF_INV_E_ORDER
)
1415 qla_printk(KERN_ERR
, ha
, "%s: Invalid Entry Order\n", __func__
);
1416 else if (pkt
->entry_status
& RF_INV_E_COUNT
)
1417 qla_printk(KERN_ERR
, ha
, "%s: Invalid Entry Count\n", __func__
);
1418 else if (pkt
->entry_status
& RF_INV_E_PARAM
)
1419 qla_printk(KERN_ERR
, ha
,
1420 "%s: Invalid Entry Parameter\n", __func__
);
1421 else if (pkt
->entry_status
& RF_INV_E_TYPE
)
1422 qla_printk(KERN_ERR
, ha
, "%s: Invalid Entry Type\n", __func__
);
1423 else if (pkt
->entry_status
& RF_BUSY
)
1424 qla_printk(KERN_ERR
, ha
, "%s: Busy\n", __func__
);
1426 qla_printk(KERN_ERR
, ha
, "%s: UNKNOWN flag error\n", __func__
);
1429 /* Validate handle. */
1430 if (pkt
->handle
< MAX_OUTSTANDING_COMMANDS
)
1431 sp
= req
->outstanding_cmds
[pkt
->handle
];
1436 /* Free outstanding command slot. */
1437 req
->outstanding_cmds
[pkt
->handle
] = NULL
;
1439 /* Bad payload or header */
1440 if (pkt
->entry_status
&
1441 (RF_INV_E_ORDER
| RF_INV_E_COUNT
|
1442 RF_INV_E_PARAM
| RF_INV_E_TYPE
)) {
1443 sp
->cmd
->result
= DID_ERROR
<< 16;
1444 } else if (pkt
->entry_status
& RF_BUSY
) {
1445 sp
->cmd
->result
= DID_BUS_BUSY
<< 16;
1447 sp
->cmd
->result
= DID_ERROR
<< 16;
1449 qla2x00_sp_compl(ha
, sp
);
1451 } else if (pkt
->entry_type
== COMMAND_A64_TYPE
|| pkt
->entry_type
==
1452 COMMAND_TYPE
|| pkt
->entry_type
== COMMAND_TYPE_7
) {
1453 DEBUG2(printk("scsi(%ld): Error entry - invalid handle\n",
1455 qla_printk(KERN_WARNING
, ha
,
1456 "Error entry - invalid handle\n");
1458 set_bit(ISP_ABORT_NEEDED
, &vha
->dpc_flags
);
1459 qla2xxx_wake_dpc(vha
);
1464 * qla24xx_mbx_completion() - Process mailbox command completions.
1465 * @ha: SCSI driver HA context
1466 * @mb0: Mailbox0 register
1469 qla24xx_mbx_completion(scsi_qla_host_t
*vha
, uint16_t mb0
)
1472 uint16_t __iomem
*wptr
;
1473 struct qla_hw_data
*ha
= vha
->hw
;
1474 struct device_reg_24xx __iomem
*reg
= &ha
->iobase
->isp24
;
1476 /* Load return mailbox registers. */
1477 ha
->flags
.mbox_int
= 1;
1478 ha
->mailbox_out
[0] = mb0
;
1479 wptr
= (uint16_t __iomem
*)®
->mailbox1
;
1481 for (cnt
= 1; cnt
< ha
->mbx_count
; cnt
++) {
1482 ha
->mailbox_out
[cnt
] = RD_REG_WORD(wptr
);
1487 DEBUG3(printk("%s(%ld): Got mailbox completion. cmd=%x.\n",
1488 __func__
, vha
->host_no
, ha
->mcp
->mb
[0]));
1490 DEBUG2_3(printk("%s(%ld): MBX pointer ERROR!\n",
1491 __func__
, vha
->host_no
));
1496 * qla24xx_process_response_queue() - Process response queue entries.
1497 * @ha: SCSI driver HA context
1500 qla24xx_process_response_queue(struct rsp_que
*rsp
)
1502 struct qla_hw_data
*ha
= rsp
->hw
;
1503 struct sts_entry_24xx
*pkt
;
1504 struct scsi_qla_host
*vha
;
1506 vha
= qla2x00_get_rsp_host(rsp
);
1508 if (!vha
->flags
.online
)
1511 while (rsp
->ring_ptr
->signature
!= RESPONSE_PROCESSED
) {
1512 pkt
= (struct sts_entry_24xx
*)rsp
->ring_ptr
;
1515 if (rsp
->ring_index
== rsp
->length
) {
1516 rsp
->ring_index
= 0;
1517 rsp
->ring_ptr
= rsp
->ring
;
1522 if (pkt
->entry_status
!= 0) {
1523 DEBUG3(printk(KERN_INFO
1524 "scsi(%ld): Process error entry.\n", vha
->host_no
));
1526 qla2x00_error_entry(vha
, rsp
, (sts_entry_t
*) pkt
);
1527 ((response_t
*)pkt
)->signature
= RESPONSE_PROCESSED
;
1532 switch (pkt
->entry_type
) {
1534 qla2x00_status_entry(vha
, rsp
, pkt
);
1536 case STATUS_CONT_TYPE
:
1537 qla2x00_status_cont_entry(vha
, (sts_cont_entry_t
*)pkt
);
1539 case VP_RPT_ID_IOCB_TYPE
:
1540 qla24xx_report_id_acquisition(vha
,
1541 (struct vp_rpt_id_entry_24xx
*)pkt
);
1544 /* Type Not Supported. */
1545 DEBUG4(printk(KERN_WARNING
1546 "scsi(%ld): Received unknown response pkt type %x "
1547 "entry status=%x.\n",
1548 vha
->host_no
, pkt
->entry_type
, pkt
->entry_status
));
1551 ((response_t
*)pkt
)->signature
= RESPONSE_PROCESSED
;
1555 /* Adjust ring index */
1556 ha
->isp_ops
->wrt_rsp_reg(ha
, rsp
->id
, rsp
->ring_index
);
1560 qla2xxx_check_risc_status(scsi_qla_host_t
*vha
)
1564 struct qla_hw_data
*ha
= vha
->hw
;
1565 struct device_reg_24xx __iomem
*reg
= &ha
->iobase
->isp24
;
1567 if (!IS_QLA25XX(ha
) && !IS_QLA81XX(ha
))
1571 WRT_REG_DWORD(®
->iobase_addr
, 0x7C00);
1572 RD_REG_DWORD(®
->iobase_addr
);
1573 WRT_REG_DWORD(®
->iobase_window
, 0x0001);
1574 for (cnt
= 10000; (RD_REG_DWORD(®
->iobase_window
) & BIT_0
) == 0 &&
1575 rval
== QLA_SUCCESS
; cnt
--) {
1577 WRT_REG_DWORD(®
->iobase_window
, 0x0001);
1580 rval
= QLA_FUNCTION_TIMEOUT
;
1582 if (rval
== QLA_SUCCESS
)
1585 WRT_REG_DWORD(®
->iobase_window
, 0x0003);
1586 for (cnt
= 100; (RD_REG_DWORD(®
->iobase_window
) & BIT_0
) == 0 &&
1587 rval
== QLA_SUCCESS
; cnt
--) {
1589 WRT_REG_DWORD(®
->iobase_window
, 0x0003);
1592 rval
= QLA_FUNCTION_TIMEOUT
;
1594 if (rval
!= QLA_SUCCESS
)
1598 if (RD_REG_DWORD(®
->iobase_c8
) & BIT_3
)
1599 qla_printk(KERN_INFO
, ha
, "Additional code -- 0x55AA.\n");
1602 WRT_REG_DWORD(®
->iobase_window
, 0x0000);
1603 RD_REG_DWORD(®
->iobase_window
);
1607 * qla24xx_intr_handler() - Process interrupts for the ISP23xx and ISP63xx.
1609 * @dev_id: SCSI driver HA context
1611 * Called by system whenever the host adapter generates an interrupt.
1613 * Returns handled flag.
1616 qla24xx_intr_handler(int irq
, void *dev_id
)
1618 scsi_qla_host_t
*vha
;
1619 struct qla_hw_data
*ha
;
1620 struct device_reg_24xx __iomem
*reg
;
1626 struct rsp_que
*rsp
;
1628 rsp
= (struct rsp_que
*) dev_id
;
1631 "%s(): NULL response queue pointer\n", __func__
);
1636 reg
= &ha
->iobase
->isp24
;
1639 spin_lock(&ha
->hardware_lock
);
1640 vha
= qla2x00_get_rsp_host(rsp
);
1641 for (iter
= 50; iter
--; ) {
1642 stat
= RD_REG_DWORD(®
->host_status
);
1643 if (stat
& HSRX_RISC_PAUSED
) {
1644 if (pci_channel_offline(ha
->pdev
))
1647 hccr
= RD_REG_DWORD(®
->hccr
);
1649 qla_printk(KERN_INFO
, ha
, "RISC paused -- HCCR=%x, "
1650 "Dumping firmware!\n", hccr
);
1652 qla2xxx_check_risc_status(vha
);
1654 ha
->isp_ops
->fw_dump(vha
, 1);
1655 set_bit(ISP_ABORT_NEEDED
, &vha
->dpc_flags
);
1657 } else if ((stat
& HSRX_RISC_INT
) == 0)
1660 switch (stat
& 0xff) {
1665 qla24xx_mbx_completion(vha
, MSW(stat
));
1666 status
|= MBX_INTERRUPT
;
1671 mb
[1] = RD_REG_WORD(®
->mailbox1
);
1672 mb
[2] = RD_REG_WORD(®
->mailbox2
);
1673 mb
[3] = RD_REG_WORD(®
->mailbox3
);
1674 qla2x00_async_event(vha
, rsp
, mb
);
1678 qla24xx_process_response_queue(rsp
);
1681 DEBUG2(printk("scsi(%ld): Unrecognized interrupt type "
1683 vha
->host_no
, stat
& 0xff));
1686 WRT_REG_DWORD(®
->hccr
, HCCRX_CLR_RISC_INT
);
1687 RD_REG_DWORD_RELAXED(®
->hccr
);
1689 spin_unlock(&ha
->hardware_lock
);
1691 if (test_bit(MBX_INTR_WAIT
, &ha
->mbx_cmd_flags
) &&
1692 (status
& MBX_INTERRUPT
) && ha
->flags
.mbox_int
) {
1693 set_bit(MBX_INTERRUPT
, &ha
->mbx_cmd_flags
);
1694 complete(&ha
->mbx_intr_comp
);
1701 qla24xx_msix_rsp_q(int irq
, void *dev_id
)
1703 struct qla_hw_data
*ha
;
1704 struct rsp_que
*rsp
;
1705 struct device_reg_24xx __iomem
*reg
;
1707 rsp
= (struct rsp_que
*) dev_id
;
1710 "%s(): NULL response queue pointer\n", __func__
);
1714 reg
= &ha
->iobase
->isp24
;
1716 spin_lock_irq(&ha
->hardware_lock
);
1718 qla24xx_process_response_queue(rsp
);
1719 WRT_REG_DWORD(®
->hccr
, HCCRX_CLR_RISC_INT
);
1721 spin_unlock_irq(&ha
->hardware_lock
);
1727 qla25xx_msix_rsp_q(int irq
, void *dev_id
)
1729 struct qla_hw_data
*ha
;
1730 struct rsp_que
*rsp
;
1731 struct device_reg_24xx __iomem
*reg
;
1733 rsp
= (struct rsp_que
*) dev_id
;
1736 "%s(): NULL response queue pointer\n", __func__
);
1740 reg
= &ha
->iobase
->isp24
;
1742 spin_lock_irq(&ha
->hardware_lock
);
1744 qla24xx_process_response_queue(rsp
);
1746 spin_unlock_irq(&ha
->hardware_lock
);
1752 qla24xx_msix_default(int irq
, void *dev_id
)
1754 scsi_qla_host_t
*vha
;
1755 struct qla_hw_data
*ha
;
1756 struct rsp_que
*rsp
;
1757 struct device_reg_24xx __iomem
*reg
;
1763 rsp
= (struct rsp_que
*) dev_id
;
1766 "%s(): NULL response queue pointer\n", __func__
));
1770 reg
= &ha
->iobase
->isp24
;
1773 spin_lock_irq(&ha
->hardware_lock
);
1774 vha
= qla2x00_get_rsp_host(rsp
);
1776 stat
= RD_REG_DWORD(®
->host_status
);
1777 if (stat
& HSRX_RISC_PAUSED
) {
1778 if (pci_channel_offline(ha
->pdev
))
1781 hccr
= RD_REG_DWORD(®
->hccr
);
1783 qla_printk(KERN_INFO
, ha
, "RISC paused -- HCCR=%x, "
1784 "Dumping firmware!\n", hccr
);
1786 qla2xxx_check_risc_status(vha
);
1788 ha
->isp_ops
->fw_dump(vha
, 1);
1789 set_bit(ISP_ABORT_NEEDED
, &vha
->dpc_flags
);
1791 } else if ((stat
& HSRX_RISC_INT
) == 0)
1794 switch (stat
& 0xff) {
1799 qla24xx_mbx_completion(vha
, MSW(stat
));
1800 status
|= MBX_INTERRUPT
;
1805 mb
[1] = RD_REG_WORD(®
->mailbox1
);
1806 mb
[2] = RD_REG_WORD(®
->mailbox2
);
1807 mb
[3] = RD_REG_WORD(®
->mailbox3
);
1808 qla2x00_async_event(vha
, rsp
, mb
);
1812 qla24xx_process_response_queue(rsp
);
1815 DEBUG2(printk("scsi(%ld): Unrecognized interrupt type "
1817 vha
->host_no
, stat
& 0xff));
1820 WRT_REG_DWORD(®
->hccr
, HCCRX_CLR_RISC_INT
);
1822 spin_unlock_irq(&ha
->hardware_lock
);
1824 if (test_bit(MBX_INTR_WAIT
, &ha
->mbx_cmd_flags
) &&
1825 (status
& MBX_INTERRUPT
) && ha
->flags
.mbox_int
) {
1826 set_bit(MBX_INTERRUPT
, &ha
->mbx_cmd_flags
);
1827 complete(&ha
->mbx_intr_comp
);
1833 /* Interrupt handling helpers. */
1835 struct qla_init_msix_entry
{
1839 irq_handler_t handler
;
1842 static struct qla_init_msix_entry base_queue
= {
1845 .name
= "qla2xxx (default)",
1846 .handler
= qla24xx_msix_default
,
1849 static struct qla_init_msix_entry base_rsp_queue
= {
1852 .name
= "qla2xxx (rsp_q)",
1853 .handler
= qla24xx_msix_rsp_q
,
1856 static struct qla_init_msix_entry multi_rsp_queue
= {
1859 .name
= "qla2xxx (multi_q)",
1860 .handler
= qla25xx_msix_rsp_q
,
1864 qla24xx_disable_msix(struct qla_hw_data
*ha
)
1867 struct qla_msix_entry
*qentry
;
1869 for (i
= 0; i
< ha
->msix_count
; i
++) {
1870 qentry
= &ha
->msix_entries
[i
];
1871 if (qentry
->have_irq
)
1872 free_irq(qentry
->vector
, qentry
->rsp
);
1874 pci_disable_msix(ha
->pdev
);
1875 kfree(ha
->msix_entries
);
1876 ha
->msix_entries
= NULL
;
1877 ha
->flags
.msix_enabled
= 0;
1881 qla24xx_enable_msix(struct qla_hw_data
*ha
, struct rsp_que
*rsp
)
1883 #define MIN_MSIX_COUNT 2
1885 struct msix_entry
*entries
;
1886 struct qla_msix_entry
*qentry
;
1887 struct qla_init_msix_entry
*msix_queue
;
1889 entries
= kzalloc(sizeof(struct msix_entry
) * ha
->msix_count
,
1894 for (i
= 0; i
< ha
->msix_count
; i
++)
1895 entries
[i
].entry
= i
;
1897 ret
= pci_enable_msix(ha
->pdev
, entries
, ha
->msix_count
);
1899 if (ret
< MIN_MSIX_COUNT
)
1902 qla_printk(KERN_WARNING
, ha
,
1903 "MSI-X: Failed to enable support -- %d/%d\n"
1904 " Retry with %d vectors\n", ha
->msix_count
, ret
, ret
);
1905 ha
->msix_count
= ret
;
1906 ret
= pci_enable_msix(ha
->pdev
, entries
, ha
->msix_count
);
1909 qla_printk(KERN_WARNING
, ha
, "MSI-X: Failed to enable"
1910 " support, giving up -- %d/%d\n",
1911 ha
->msix_count
, ret
);
1914 ha
->max_queues
= ha
->msix_count
- 1;
1916 ha
->msix_entries
= kzalloc(sizeof(struct qla_msix_entry
) *
1917 ha
->msix_count
, GFP_KERNEL
);
1918 if (!ha
->msix_entries
) {
1922 ha
->flags
.msix_enabled
= 1;
1924 for (i
= 0; i
< ha
->msix_count
; i
++) {
1925 qentry
= &ha
->msix_entries
[i
];
1926 qentry
->vector
= entries
[i
].vector
;
1927 qentry
->entry
= entries
[i
].entry
;
1928 qentry
->have_irq
= 0;
1932 /* Enable MSI-X for AENs for queue 0 */
1933 qentry
= &ha
->msix_entries
[0];
1934 ret
= request_irq(qentry
->vector
, base_queue
.handler
, 0,
1935 base_queue
.name
, rsp
);
1937 qla_printk(KERN_WARNING
, ha
,
1938 "MSI-X: Unable to register handler -- %x/%d.\n",
1939 qentry
->vector
, ret
);
1940 qla24xx_disable_msix(ha
);
1943 qentry
->have_irq
= 1;
1946 /* Enable MSI-X vector for response queue update for queue 0 */
1947 if (ha
->max_queues
> 1 && ha
->mqiobase
) {
1949 msix_queue
= &multi_rsp_queue
;
1950 qla_printk(KERN_INFO
, ha
,
1951 "MQ enabled, Number of Queue Resources: %d \n",
1955 msix_queue
= &base_rsp_queue
;
1958 qentry
= &ha
->msix_entries
[1];
1959 ret
= request_irq(qentry
->vector
, msix_queue
->handler
, 0,
1960 msix_queue
->name
, rsp
);
1962 qla_printk(KERN_WARNING
, ha
,
1963 "MSI-X: Unable to register handler -- %x/%d.\n",
1964 qentry
->vector
, ret
);
1965 qla24xx_disable_msix(ha
);
1969 qentry
->have_irq
= 1;
1978 qla2x00_request_irqs(struct qla_hw_data
*ha
, struct rsp_que
*rsp
)
1981 device_reg_t __iomem
*reg
= ha
->iobase
;
1983 /* If possible, enable MSI-X. */
1984 if (!IS_QLA2432(ha
) && !IS_QLA2532(ha
) &&
1985 !IS_QLA8432(ha
) && !IS_QLA8001(ha
))
1988 if (IS_QLA2432(ha
) && (ha
->pdev
->revision
< QLA_MSIX_CHIP_REV_24XX
||
1989 !QLA_MSIX_FW_MODE_1(ha
->fw_attributes
))) {
1990 DEBUG2(qla_printk(KERN_WARNING
, ha
,
1991 "MSI-X: Unsupported ISP2432 (0x%X, 0x%X).\n",
1992 ha
->pdev
->revision
, ha
->fw_attributes
));
1997 if (ha
->pdev
->subsystem_vendor
== PCI_VENDOR_ID_HP
&&
1998 (ha
->pdev
->subsystem_device
== 0x7040 ||
1999 ha
->pdev
->subsystem_device
== 0x7041 ||
2000 ha
->pdev
->subsystem_device
== 0x1705)) {
2001 DEBUG2(qla_printk(KERN_WARNING
, ha
,
2002 "MSI-X: Unsupported ISP2432 SSVID/SSDID (0x%X, 0x%X).\n",
2003 ha
->pdev
->subsystem_vendor
,
2004 ha
->pdev
->subsystem_device
));
2009 ret
= qla24xx_enable_msix(ha
, rsp
);
2011 DEBUG2(qla_printk(KERN_INFO
, ha
,
2012 "MSI-X: Enabled (0x%X, 0x%X).\n", ha
->chip_revision
,
2013 ha
->fw_attributes
));
2014 goto clear_risc_ints
;
2016 qla_printk(KERN_WARNING
, ha
,
2017 "MSI-X: Falling back-to INTa mode -- %d.\n", ret
);
2020 if (!IS_QLA24XX(ha
) && !IS_QLA2532(ha
) && !IS_QLA8432(ha
) &&
2024 ret
= pci_enable_msi(ha
->pdev
);
2026 DEBUG2(qla_printk(KERN_INFO
, ha
, "MSI: Enabled.\n"));
2027 ha
->flags
.msi_enabled
= 1;
2031 ret
= request_irq(ha
->pdev
->irq
, ha
->isp_ops
->intr_handler
,
2032 IRQF_DISABLED
|IRQF_SHARED
, QLA2XXX_DRIVER_NAME
, rsp
);
2034 qla_printk(KERN_WARNING
, ha
,
2035 "Failed to reserve interrupt %d already in use.\n",
2039 ha
->flags
.inta_enabled
= 1;
2043 * FIXME: Noted that 8014s were being dropped during NK testing.
2044 * Timing deltas during MSI-X/INTa transitions?
2048 spin_lock_irq(&ha
->hardware_lock
);
2049 if (IS_FWI2_CAPABLE(ha
)) {
2050 WRT_REG_DWORD(®
->isp24
.hccr
, HCCRX_CLR_HOST_INT
);
2051 WRT_REG_DWORD(®
->isp24
.hccr
, HCCRX_CLR_RISC_INT
);
2053 WRT_REG_WORD(®
->isp
.semaphore
, 0);
2054 WRT_REG_WORD(®
->isp
.hccr
, HCCR_CLR_RISC_INT
);
2055 WRT_REG_WORD(®
->isp
.hccr
, HCCR_CLR_HOST_INT
);
2057 spin_unlock_irq(&ha
->hardware_lock
);
2064 qla2x00_free_irqs(scsi_qla_host_t
*vha
)
2066 struct qla_hw_data
*ha
= vha
->hw
;
2067 struct rsp_que
*rsp
= ha
->rsp_q_map
[0];
2069 if (ha
->flags
.msix_enabled
)
2070 qla24xx_disable_msix(ha
);
2071 else if (ha
->flags
.inta_enabled
) {
2072 free_irq(ha
->pdev
->irq
, rsp
);
2073 pci_disable_msi(ha
->pdev
);
2077 static struct scsi_qla_host
*
2078 qla2x00_get_rsp_host(struct rsp_que
*rsp
)
2081 struct qla_hw_data
*ha
= rsp
->hw
;
2082 struct scsi_qla_host
*vha
= NULL
;
2083 struct sts_entry_24xx
*pkt
;
2084 struct req_que
*req
;
2087 pkt
= (struct sts_entry_24xx
*) rsp
->ring_ptr
;
2089 if (pkt
&& pkt
->handle
< MAX_OUTSTANDING_COMMANDS
) {
2090 sp
= req
->outstanding_cmds
[pkt
->handle
];
2092 vha
= sp
->fcport
->vha
;
2096 /* handle it in base queue */
2097 vha
= pci_get_drvdata(ha
->pdev
);
2102 int qla25xx_request_irq(struct rsp_que
*rsp
)
2104 struct qla_hw_data
*ha
= rsp
->hw
;
2105 struct qla_init_msix_entry
*intr
= &multi_rsp_queue
;
2106 struct qla_msix_entry
*msix
= rsp
->msix
;
2109 ret
= request_irq(msix
->vector
, intr
->handler
, 0, intr
->name
, rsp
);
2111 qla_printk(KERN_WARNING
, ha
,
2112 "MSI-X: Unable to register handler -- %x/%d.\n",
2122 qla25xx_wrt_rsp_reg(struct qla_hw_data
*ha
, uint16_t id
, uint16_t index
)
2124 device_reg_t __iomem
*reg
= (void *) ha
->mqiobase
+ QLA_QUE_PAGE
* id
;
2125 WRT_REG_DWORD(®
->isp25mq
.rsp_q_out
, index
);
2129 qla24xx_wrt_rsp_reg(struct qla_hw_data
*ha
, uint16_t id
, uint16_t index
)
2131 device_reg_t __iomem
*reg
= (void *) ha
->iobase
;
2132 WRT_REG_DWORD(®
->isp24
.rsp_q_out
, index
);