2 * QLOGIC LINUX SOFTWARE
4 * QLogic ISP2x00 device driver for Linux 2.6.x
5 * Copyright (C) 2003-2004 QLogic Corporation
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the
10 * Free Software Foundation; either version 2, or (at your option) any
13 * This program is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * General Public License for more details.
21 static void qla2x00_mbx_completion(scsi_qla_host_t
*, uint16_t);
22 static void qla2x00_async_event(scsi_qla_host_t
*, uint32_t);
23 static void qla2x00_process_completed_request(struct scsi_qla_host
*, uint32_t);
24 void qla2x00_process_response_queue(struct scsi_qla_host
*);
25 static void qla2x00_status_entry(scsi_qla_host_t
*, sts_entry_t
*);
26 static void qla2x00_status_cont_entry(scsi_qla_host_t
*, sts_cont_entry_t
*);
27 static void qla2x00_error_entry(scsi_qla_host_t
*, sts_entry_t
*);
28 static void qla2x00_ms_entry(scsi_qla_host_t
*, ms_iocb_entry_t
*);
31 * qla2100_intr_handler() - Process interrupts for the ISP2100 and ISP2200.
33 * @dev_id: SCSI driver HA context
36 * Called by system whenever the host adapter generates an interrupt.
38 * Returns handled flag.
41 qla2100_intr_handler(int irq
, void *dev_id
, struct pt_regs
*regs
)
44 device_reg_t __iomem
*reg
;
50 ha
= (scsi_qla_host_t
*) dev_id
;
53 "%s(): NULL host pointer\n", __func__
);
60 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
61 for (iter
= 50; iter
--; ) {
62 if ((RD_REG_WORD(®
->istatus
) & ISR_RISC_INT
) == 0)
65 if (RD_REG_WORD(®
->semaphore
) & BIT_0
) {
66 WRT_REG_WORD(®
->hccr
, HCCR_CLR_RISC_INT
);
67 RD_REG_WORD(®
->hccr
);
69 /* Get mailbox data. */
70 mbx
= RD_MAILBOX_REG(ha
, reg
, 0);
71 if (mbx
> 0x3fff && mbx
< 0x8000) {
72 qla2x00_mbx_completion(ha
, (uint16_t)mbx
);
73 status
|= MBX_INTERRUPT
;
74 } else if (mbx
> 0x7fff && mbx
< 0xc000) {
75 qla2x00_async_event(ha
, mbx
);
78 DEBUG2(printk("scsi(%ld): Unrecognized "
79 "interrupt type (%d)\n",
82 /* Release mailbox registers. */
83 WRT_REG_WORD(®
->semaphore
, 0);
84 RD_REG_WORD(®
->semaphore
);
86 qla2x00_process_response_queue(ha
);
88 WRT_REG_WORD(®
->hccr
, HCCR_CLR_RISC_INT
);
89 RD_REG_WORD(®
->hccr
);
92 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
94 if (test_bit(MBX_INTR_WAIT
, &ha
->mbx_cmd_flags
) &&
95 (status
& MBX_INTERRUPT
) && ha
->flags
.mbox_int
) {
96 spin_lock_irqsave(&ha
->mbx_reg_lock
, flags
);
98 set_bit(MBX_INTERRUPT
, &ha
->mbx_cmd_flags
);
99 up(&ha
->mbx_intr_sem
);
101 spin_unlock_irqrestore(&ha
->mbx_reg_lock
, flags
);
104 return (IRQ_HANDLED
);
108 * qla2300_intr_handler() - Process interrupts for the ISP23xx and ISP63xx.
110 * @dev_id: SCSI driver HA context
113 * Called by system whenever the host adapter generates an interrupt.
115 * Returns handled flag.
118 qla2300_intr_handler(int irq
, void *dev_id
, struct pt_regs
*regs
)
121 device_reg_t __iomem
*reg
;
129 ha
= (scsi_qla_host_t
*) dev_id
;
132 "%s(): NULL host pointer\n", __func__
);
139 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
140 for (iter
= 50; iter
--; ) {
141 stat
= RD_REG_DWORD(®
->u
.isp2300
.host_status
);
142 if (stat
& HSR_RISC_PAUSED
) {
143 hccr
= RD_REG_WORD(®
->hccr
);
144 if (hccr
& (BIT_15
| BIT_13
| BIT_11
| BIT_8
))
145 qla_printk(KERN_INFO
, ha
,
146 "Parity error -- HCCR=%x.\n", hccr
);
148 qla_printk(KERN_INFO
, ha
,
149 "RISC paused -- HCCR=%x\n", hccr
);
152 * Issue a "HARD" reset in order for the RISC
153 * interrupt bit to be cleared. Schedule a big
154 * hammmer to get out of the RISC PAUSED state.
156 WRT_REG_WORD(®
->hccr
, HCCR_RESET_RISC
);
157 RD_REG_WORD(®
->hccr
);
158 set_bit(ISP_ABORT_NEEDED
, &ha
->dpc_flags
);
160 } else if ((stat
& HSR_RISC_INT
) == 0)
164 switch (stat
& 0xff) {
166 qla2x00_process_response_queue(ha
);
172 qla2x00_mbx_completion(ha
, (uint16_t)mbx
);
173 status
|= MBX_INTERRUPT
;
175 /* Release mailbox registers. */
176 WRT_REG_WORD(®
->semaphore
, 0);
179 qla2x00_async_event(ha
, mbx
);
182 mbx
= mbx
<< 16 | MBA_CMPLT_1_16BIT
;
183 qla2x00_async_event(ha
, mbx
);
186 mbx
= mbx
<< 16 | MBA_SCSI_COMPLETION
;
187 qla2x00_async_event(ha
, mbx
);
190 DEBUG2(printk("scsi(%ld): Unrecognized interrupt type "
192 ha
->host_no
, stat
& 0xff));
195 WRT_REG_WORD(®
->hccr
, HCCR_CLR_RISC_INT
);
196 RD_REG_WORD_RELAXED(®
->hccr
);
198 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
200 if (test_bit(MBX_INTR_WAIT
, &ha
->mbx_cmd_flags
) &&
201 (status
& MBX_INTERRUPT
) && ha
->flags
.mbox_int
) {
202 spin_lock_irqsave(&ha
->mbx_reg_lock
, flags
);
204 set_bit(MBX_INTERRUPT
, &ha
->mbx_cmd_flags
);
205 up(&ha
->mbx_intr_sem
);
207 spin_unlock_irqrestore(&ha
->mbx_reg_lock
, flags
);
210 return (IRQ_HANDLED
);
214 * qla2x00_mbx_completion() - Process mailbox command completions.
215 * @ha: SCSI driver HA context
216 * @mb0: Mailbox0 register
219 qla2x00_mbx_completion(scsi_qla_host_t
*ha
, uint16_t mb0
)
222 uint16_t __iomem
*wptr
;
223 device_reg_t __iomem
*reg
= ha
->iobase
;
225 /* Load return mailbox registers. */
226 ha
->flags
.mbox_int
= 1;
227 ha
->mailbox_out
[0] = mb0
;
228 wptr
= (uint16_t __iomem
*)MAILBOX_REG(ha
, reg
, 1);
230 for (cnt
= 1; cnt
< ha
->mbx_count
; cnt
++) {
231 if (IS_QLA2200(ha
) && cnt
== 8)
232 wptr
= (uint16_t __iomem
*)MAILBOX_REG(ha
, reg
, 8);
233 if (cnt
== 4 || cnt
== 5)
234 ha
->mailbox_out
[cnt
] = qla2x00_debounce_register(wptr
);
236 ha
->mailbox_out
[cnt
] = RD_REG_WORD(wptr
);
242 DEBUG3(printk("%s(%ld): Got mailbox completion. cmd=%x.\n",
243 __func__
, ha
->host_no
, ha
->mcp
->mb
[0]));
245 DEBUG2_3(printk("%s(%ld): MBX pointer ERROR!\n",
246 __func__
, ha
->host_no
));
251 * qla2x00_async_event() - Process aynchronous events.
252 * @ha: SCSI driver HA context
253 * @mb0: Mailbox0 register
256 qla2x00_async_event(scsi_qla_host_t
*ha
, uint32_t mbx
)
258 static char *link_speeds
[5] = { "1", "2", "4", "?", "10" };
264 device_reg_t __iomem
*reg
= ha
->iobase
;
265 uint32_t rscn_entry
, host_pid
;
266 uint8_t rscn_queue_index
;
268 /* Setup to process RIO completion. */
272 case MBA_SCSI_COMPLETION
:
273 if (IS_QLA2100(ha
) || IS_QLA2200(ha
))
274 handles
[0] = le32_to_cpu(
275 ((uint32_t)(RD_MAILBOX_REG(ha
, reg
, 2) << 16)) |
276 RD_MAILBOX_REG(ha
, reg
, 1));
278 handles
[0] = le32_to_cpu(
279 ((uint32_t)(RD_MAILBOX_REG(ha
, reg
, 2) << 16)) |
283 case MBA_CMPLT_1_16BIT
:
284 if (IS_QLA2100(ha
) || IS_QLA2200(ha
))
285 handles
[0] = (uint32_t)RD_MAILBOX_REG(ha
, reg
, 1);
287 handles
[0] = MSW(mbx
);
289 mb
[0] = MBA_SCSI_COMPLETION
;
291 case MBA_CMPLT_2_16BIT
:
292 handles
[0] = (uint32_t)RD_MAILBOX_REG(ha
, reg
, 1);
293 handles
[1] = (uint32_t)RD_MAILBOX_REG(ha
, reg
, 2);
295 mb
[0] = MBA_SCSI_COMPLETION
;
297 case MBA_CMPLT_3_16BIT
:
298 handles
[0] = (uint32_t)RD_MAILBOX_REG(ha
, reg
, 1);
299 handles
[1] = (uint32_t)RD_MAILBOX_REG(ha
, reg
, 2);
300 handles
[2] = (uint32_t)RD_MAILBOX_REG(ha
, reg
, 3);
302 mb
[0] = MBA_SCSI_COMPLETION
;
304 case MBA_CMPLT_4_16BIT
:
305 handles
[0] = (uint32_t)RD_MAILBOX_REG(ha
, reg
, 1);
306 handles
[1] = (uint32_t)RD_MAILBOX_REG(ha
, reg
, 2);
307 handles
[2] = (uint32_t)RD_MAILBOX_REG(ha
, reg
, 3);
308 handles
[3] = (uint32_t)RD_MAILBOX_REG(ha
, reg
, 6);
310 mb
[0] = MBA_SCSI_COMPLETION
;
312 case MBA_CMPLT_5_16BIT
:
313 handles
[0] = (uint32_t)RD_MAILBOX_REG(ha
, reg
, 1);
314 handles
[1] = (uint32_t)RD_MAILBOX_REG(ha
, reg
, 2);
315 handles
[2] = (uint32_t)RD_MAILBOX_REG(ha
, reg
, 3);
316 handles
[3] = (uint32_t)RD_MAILBOX_REG(ha
, reg
, 6);
317 handles
[4] = (uint32_t)RD_MAILBOX_REG(ha
, reg
, 7);
319 mb
[0] = MBA_SCSI_COMPLETION
;
321 case MBA_CMPLT_2_32BIT
:
322 handles
[0] = le32_to_cpu(
323 ((uint32_t)(RD_MAILBOX_REG(ha
, reg
, 2) << 16)) |
324 RD_MAILBOX_REG(ha
, reg
, 1));
325 handles
[1] = le32_to_cpu(
326 ((uint32_t)(RD_MAILBOX_REG(ha
, reg
, 7) << 16)) |
327 RD_MAILBOX_REG(ha
, reg
, 6));
329 mb
[0] = MBA_SCSI_COMPLETION
;
336 case MBA_SCSI_COMPLETION
: /* Fast Post */
337 if (!ha
->flags
.online
)
340 for (cnt
= 0; cnt
< handle_cnt
; cnt
++)
341 qla2x00_process_completed_request(ha
, handles
[cnt
]);
344 case MBA_RESET
: /* Reset */
345 DEBUG2(printk("scsi(%ld): Asynchronous RESET.\n", ha
->host_no
));
347 set_bit(RESET_MARKER_NEEDED
, &ha
->dpc_flags
);
350 case MBA_SYSTEM_ERR
: /* System Error */
351 mb
[1] = RD_MAILBOX_REG(ha
, reg
, 1);
352 mb
[2] = RD_MAILBOX_REG(ha
, reg
, 2);
353 mb
[3] = RD_MAILBOX_REG(ha
, reg
, 3);
355 qla_printk(KERN_INFO
, ha
,
356 "ISP System Error - mbx1=%xh mbx2=%xh mbx3=%xh.\n",
357 mb
[1], mb
[2], mb
[3]);
359 if (IS_QLA2100(ha
) || IS_QLA2200(ha
))
360 qla2100_fw_dump(ha
, 1);
362 qla2300_fw_dump(ha
, 1);
365 qla_printk(KERN_INFO
, ha
,
366 "Unrecoverable Hardware Error: adapter marked "
368 ha
->flags
.online
= 0;
370 set_bit(ISP_ABORT_NEEDED
, &ha
->dpc_flags
);
373 case MBA_REQ_TRANSFER_ERR
: /* Request Transfer Error */
374 DEBUG2(printk("scsi(%ld): ISP Request Transfer Error.\n",
376 qla_printk(KERN_WARNING
, ha
, "ISP Request Transfer Error.\n");
378 set_bit(ISP_ABORT_NEEDED
, &ha
->dpc_flags
);
381 case MBA_RSP_TRANSFER_ERR
: /* Response Transfer Error */
382 DEBUG2(printk("scsi(%ld): ISP Response Transfer Error.\n",
384 qla_printk(KERN_WARNING
, ha
, "ISP Response Transfer Error.\n");
386 set_bit(ISP_ABORT_NEEDED
, &ha
->dpc_flags
);
389 case MBA_WAKEUP_THRES
: /* Request Queue Wake-up */
390 DEBUG2(printk("scsi(%ld): Asynchronous WAKEUP_THRES.\n",
394 case MBA_LIP_OCCURRED
: /* Loop Initialization Procedure */
395 mb
[1] = RD_MAILBOX_REG(ha
, reg
, 1);
397 DEBUG2(printk("scsi(%ld): LIP occured (%x).\n", ha
->host_no
,
399 qla_printk(KERN_INFO
, ha
, "LIP occured (%x).\n", mb
[1]);
401 if (atomic_read(&ha
->loop_state
) != LOOP_DOWN
) {
402 atomic_set(&ha
->loop_state
, LOOP_DOWN
);
403 atomic_set(&ha
->loop_down_timer
, LOOP_DOWN_TIME
);
404 qla2x00_mark_all_devices_lost(ha
);
407 set_bit(REGISTER_FC4_NEEDED
, &ha
->dpc_flags
);
409 ha
->flags
.management_server_logged_in
= 0;
411 /* Update AEN queue. */
412 qla2x00_enqueue_aen(ha
, MBA_LIP_OCCURRED
, NULL
);
416 case MBA_LOOP_UP
: /* Loop Up Event */
417 mb
[1] = RD_MAILBOX_REG(ha
, reg
, 1);
419 ha
->link_data_rate
= 0;
420 if (IS_QLA2100(ha
) || IS_QLA2200(ha
)) {
421 link_speed
= link_speeds
[0];
423 link_speed
= link_speeds
[3];
425 link_speed
= link_speeds
[mb
[1]];
426 ha
->link_data_rate
= mb
[1];
429 DEBUG2(printk("scsi(%ld): Asynchronous LOOP UP (%s Gbps).\n",
430 ha
->host_no
, link_speed
));
431 qla_printk(KERN_INFO
, ha
, "LOOP UP detected (%s Gbps).\n",
434 ha
->flags
.management_server_logged_in
= 0;
436 /* Update AEN queue. */
437 qla2x00_enqueue_aen(ha
, MBA_LOOP_UP
, NULL
);
440 case MBA_LOOP_DOWN
: /* Loop Down Event */
441 DEBUG2(printk("scsi(%ld): Asynchronous LOOP DOWN.\n",
443 qla_printk(KERN_INFO
, ha
, "LOOP DOWN detected.\n");
445 if (atomic_read(&ha
->loop_state
) != LOOP_DOWN
) {
446 atomic_set(&ha
->loop_state
, LOOP_DOWN
);
447 atomic_set(&ha
->loop_down_timer
, LOOP_DOWN_TIME
);
448 ha
->device_flags
|= DFLG_NO_CABLE
;
449 qla2x00_mark_all_devices_lost(ha
);
452 ha
->flags
.management_server_logged_in
= 0;
453 ha
->link_data_rate
= 0;
455 /* Update AEN queue. */
456 qla2x00_enqueue_aen(ha
, MBA_LOOP_DOWN
, NULL
);
459 case MBA_LIP_RESET
: /* LIP reset occurred */
460 mb
[1] = RD_MAILBOX_REG(ha
, reg
, 1);
462 DEBUG2(printk("scsi(%ld): Asynchronous LIP RESET (%x).\n",
463 ha
->host_no
, mb
[1]));
464 qla_printk(KERN_INFO
, ha
,
465 "LIP reset occured (%x).\n", mb
[1]);
467 if (atomic_read(&ha
->loop_state
) != LOOP_DOWN
) {
468 atomic_set(&ha
->loop_state
, LOOP_DOWN
);
469 atomic_set(&ha
->loop_down_timer
, LOOP_DOWN_TIME
);
470 qla2x00_mark_all_devices_lost(ha
);
473 set_bit(RESET_MARKER_NEEDED
, &ha
->dpc_flags
);
475 ha
->operating_mode
= LOOP
;
476 ha
->flags
.management_server_logged_in
= 0;
478 /* Update AEN queue. */
479 qla2x00_enqueue_aen(ha
, MBA_LIP_RESET
, NULL
);
483 case MBA_POINT_TO_POINT
: /* Point-to-Point */
487 DEBUG2(printk("scsi(%ld): Asynchronous P2P MODE received.\n",
491 * Until there's a transition from loop down to loop up, treat
492 * this as loop down only.
494 if (atomic_read(&ha
->loop_state
) != LOOP_DOWN
) {
495 atomic_set(&ha
->loop_state
, LOOP_DOWN
);
496 if (!atomic_read(&ha
->loop_down_timer
))
497 atomic_set(&ha
->loop_down_timer
,
499 qla2x00_mark_all_devices_lost(ha
);
502 if (!(test_bit(ABORT_ISP_ACTIVE
, &ha
->dpc_flags
))) {
503 set_bit(RESET_MARKER_NEEDED
, &ha
->dpc_flags
);
505 set_bit(REGISTER_FC4_NEEDED
, &ha
->dpc_flags
);
508 case MBA_CHG_IN_CONNECTION
: /* Change in connection mode */
512 mb
[1] = RD_MAILBOX_REG(ha
, reg
, 1);
514 DEBUG2(printk("scsi(%ld): Asynchronous Change In Connection "
517 qla_printk(KERN_INFO
, ha
,
518 "Configuration change detected: value=%x.\n", mb
[1]);
520 if (atomic_read(&ha
->loop_state
) != LOOP_DOWN
) {
521 atomic_set(&ha
->loop_state
, LOOP_DOWN
);
522 if (!atomic_read(&ha
->loop_down_timer
))
523 atomic_set(&ha
->loop_down_timer
,
525 qla2x00_mark_all_devices_lost(ha
);
528 set_bit(LOOP_RESYNC_NEEDED
, &ha
->dpc_flags
);
529 set_bit(LOCAL_LOOP_UPDATE
, &ha
->dpc_flags
);
532 case MBA_PORT_UPDATE
: /* Port database update */
533 mb
[1] = RD_MAILBOX_REG(ha
, reg
, 1);
534 mb
[2] = RD_MAILBOX_REG(ha
, reg
, 2);
537 * If a single remote port just logged into (or logged out of)
538 * us, create a new entry in our rscn fcports list and handle
539 * the event like an RSCN.
541 if (!IS_QLA2100(ha
) && !IS_QLA2200(ha
) && !IS_QLA6312(ha
) &&
542 !IS_QLA6322(ha
) && ha
->flags
.init_done
&& mb
[1] != 0xffff &&
543 ((ha
->operating_mode
== P2P
&& mb
[1] != 0) ||
544 (ha
->operating_mode
!= P2P
&& mb
[1] !=
545 SNS_FIRST_LOOP_ID
)) && (mb
[2] == 6 || mb
[2] == 7)) {
547 fc_port_t
*rscn_fcport
;
549 /* Create new fcport for login. */
550 rscn_fcport
= qla2x00_alloc_rscn_fcport(ha
, GFP_ATOMIC
);
552 DEBUG14(printk("scsi(%ld): Port Update -- "
553 "creating RSCN fcport %p for %x/%x.\n",
554 ha
->host_no
, rscn_fcport
, mb
[1], mb
[2]));
556 rscn_fcport
->loop_id
= mb
[1];
557 rscn_fcport
->d_id
.b24
= INVALID_PORT_ID
;
558 atomic_set(&rscn_fcport
->state
,
560 list_add_tail(&rscn_fcport
->list
,
563 rval
= qla2x00_handle_port_rscn(ha
, 0,
565 if (rval
== QLA_SUCCESS
)
568 DEBUG14(printk("scsi(%ld): Port Update -- "
569 "-- unable to allocate RSCN fcport "
570 "login.\n", ha
->host_no
));
575 * If PORT UPDATE is global (recieved LIP_OCCURED/LIP_RESET
576 * event etc. earlier indicating loop is down) then process
577 * it. Otherwise ignore it and Wait for RSCN to come in.
579 atomic_set(&ha
->loop_down_timer
, 0);
580 if (atomic_read(&ha
->loop_state
) != LOOP_DOWN
&&
581 atomic_read(&ha
->loop_state
) != LOOP_DEAD
) {
582 DEBUG2(printk("scsi(%ld): Asynchronous PORT UPDATE "
583 "ignored.\n", ha
->host_no
));
587 DEBUG2(printk("scsi(%ld): Asynchronous PORT UPDATE.\n",
589 DEBUG(printk(KERN_INFO
590 "scsi(%ld): Port database changed %04x %04x.\n",
591 ha
->host_no
, mb
[1], mb
[2]));
594 * Mark all devices as missing so we will login again.
596 atomic_set(&ha
->loop_state
, LOOP_UP
);
598 qla2x00_mark_all_devices_lost(ha
);
600 ha
->flags
.rscn_queue_overflow
= 1;
602 set_bit(LOOP_RESYNC_NEEDED
, &ha
->dpc_flags
);
603 set_bit(LOCAL_LOOP_UPDATE
, &ha
->dpc_flags
);
605 /* Update AEN queue. */
606 qla2x00_enqueue_aen(ha
, MBA_PORT_UPDATE
, NULL
);
609 case MBA_RSCN_UPDATE
: /* State Change Registration */
610 mb
[1] = RD_MAILBOX_REG(ha
, reg
, 1);
611 mb
[2] = RD_MAILBOX_REG(ha
, reg
, 2);
613 DEBUG2(printk("scsi(%ld): Asynchronous RSCR UPDATE.\n",
615 DEBUG(printk(KERN_INFO
616 "scsi(%ld): RSCN database changed -- %04x %04x.\n",
617 ha
->host_no
, mb
[1], mb
[2]));
619 rscn_entry
= (mb
[1] << 16) | mb
[2];
620 host_pid
= (ha
->d_id
.b
.domain
<< 16) | (ha
->d_id
.b
.area
<< 8) |
622 if (rscn_entry
== host_pid
) {
623 DEBUG(printk(KERN_INFO
624 "scsi(%ld): Ignoring RSCN update to local host "
626 ha
->host_no
, host_pid
));
630 rscn_queue_index
= ha
->rscn_in_ptr
+ 1;
631 if (rscn_queue_index
== MAX_RSCN_COUNT
)
632 rscn_queue_index
= 0;
633 if (rscn_queue_index
!= ha
->rscn_out_ptr
) {
634 ha
->rscn_queue
[ha
->rscn_in_ptr
] = rscn_entry
;
635 ha
->rscn_in_ptr
= rscn_queue_index
;
637 ha
->flags
.rscn_queue_overflow
= 1;
640 atomic_set(&ha
->loop_state
, LOOP_UPDATE
);
641 atomic_set(&ha
->loop_down_timer
, 0);
642 ha
->flags
.management_server_logged_in
= 0;
644 set_bit(LOOP_RESYNC_NEEDED
, &ha
->dpc_flags
);
645 set_bit(RSCN_UPDATE
, &ha
->dpc_flags
);
647 /* Update AEN queue. */
648 qla2x00_enqueue_aen(ha
, MBA_RSCN_UPDATE
, &mb
[0]);
651 /* case MBA_RIO_RESPONSE: */
652 case MBA_ZIO_RESPONSE
:
653 DEBUG2(printk("scsi(%ld): [R|Z]IO update completion.\n",
655 DEBUG(printk(KERN_INFO
656 "scsi(%ld): [R|Z]IO update completion.\n",
659 qla2x00_process_response_queue(ha
);
665 * qla2x00_process_completed_request() - Process a Fast Post response.
666 * @ha: SCSI driver HA context
670 qla2x00_process_completed_request(struct scsi_qla_host
*ha
, uint32_t index
)
674 /* Validate handle. */
675 if (index
>= MAX_OUTSTANDING_COMMANDS
) {
676 DEBUG2(printk("scsi(%ld): Invalid SCSI completion handle %d.\n",
677 ha
->host_no
, index
));
678 qla_printk(KERN_WARNING
, ha
,
679 "Invalid SCSI completion handle %d.\n", index
);
681 set_bit(ISP_ABORT_NEEDED
, &ha
->dpc_flags
);
685 sp
= ha
->outstanding_cmds
[index
];
687 /* Free outstanding command slot. */
688 ha
->outstanding_cmds
[index
] = NULL
;
690 CMD_COMPL_STATUS(sp
->cmd
) = 0L;
691 CMD_SCSI_STATUS(sp
->cmd
) = 0L;
693 /* Save ISP completion status */
694 sp
->cmd
->result
= DID_OK
<< 16;
695 qla2x00_sp_compl(ha
, sp
);
697 DEBUG2(printk("scsi(%ld): Invalid ISP SCSI completion handle\n",
699 qla_printk(KERN_WARNING
, ha
,
700 "Invalid ISP SCSI completion handle\n");
702 set_bit(ISP_ABORT_NEEDED
, &ha
->dpc_flags
);
707 * qla2x00_process_response_queue() - Process response queue entries.
708 * @ha: SCSI driver HA context
711 qla2x00_process_response_queue(struct scsi_qla_host
*ha
)
713 device_reg_t __iomem
*reg
= ha
->iobase
;
718 if (!ha
->flags
.online
)
721 while (ha
->response_ring_ptr
->signature
!= RESPONSE_PROCESSED
) {
722 pkt
= (sts_entry_t
*)ha
->response_ring_ptr
;
724 ha
->rsp_ring_index
++;
725 if (ha
->rsp_ring_index
== ha
->response_q_length
) {
726 ha
->rsp_ring_index
= 0;
727 ha
->response_ring_ptr
= ha
->response_ring
;
729 ha
->response_ring_ptr
++;
732 if (pkt
->entry_status
!= 0) {
733 DEBUG3(printk(KERN_INFO
734 "scsi(%ld): Process error entry.\n", ha
->host_no
));
736 qla2x00_error_entry(ha
, pkt
);
737 ((response_t
*)pkt
)->signature
= RESPONSE_PROCESSED
;
742 switch (pkt
->entry_type
) {
744 qla2x00_status_entry(ha
, pkt
);
747 handle_cnt
= ((sts21_entry_t
*)pkt
)->handle_count
;
748 for (cnt
= 0; cnt
< handle_cnt
; cnt
++) {
749 qla2x00_process_completed_request(ha
,
750 ((sts21_entry_t
*)pkt
)->handle
[cnt
]);
754 handle_cnt
= ((sts22_entry_t
*)pkt
)->handle_count
;
755 for (cnt
= 0; cnt
< handle_cnt
; cnt
++) {
756 qla2x00_process_completed_request(ha
,
757 ((sts22_entry_t
*)pkt
)->handle
[cnt
]);
760 case STATUS_CONT_TYPE
:
761 qla2x00_status_cont_entry(ha
, (sts_cont_entry_t
*)pkt
);
764 qla2x00_ms_entry(ha
, (ms_iocb_entry_t
*)pkt
);
767 if (!IS_QLA2100(ha
) && !IS_QLA2200(ha
) &&
768 !IS_QLA6312(ha
) && !IS_QLA6322(ha
)) {
769 if (pkt
->sys_define
== SOURCE_ASYNC_IOCB
) {
770 qla2x00_process_iodesc(ha
,
771 (struct mbx_entry
*)pkt
);
773 /* MBX IOCB Type Not Supported. */
774 DEBUG4(printk(KERN_WARNING
775 "scsi(%ld): Received unknown MBX "
776 "IOCB response pkt type=%x "
777 "source=%x entry status=%x.\n",
778 ha
->host_no
, pkt
->entry_type
,
786 /* Type Not Supported. */
787 DEBUG4(printk(KERN_WARNING
788 "scsi(%ld): Received unknown response pkt type %x "
789 "entry status=%x.\n",
790 ha
->host_no
, pkt
->entry_type
, pkt
->entry_status
));
793 ((response_t
*)pkt
)->signature
= RESPONSE_PROCESSED
;
797 /* Adjust ring index */
798 WRT_REG_WORD(ISP_RSP_Q_OUT(ha
, reg
), ha
->rsp_ring_index
);
802 * qla2x00_status_entry() - Process a Status IOCB entry.
803 * @ha: SCSI driver HA context
804 * @pkt: Entry pointer
807 qla2x00_status_entry(scsi_qla_host_t
*ha
, sts_entry_t
*pkt
)
812 struct scsi_cmnd
*cp
;
813 uint16_t comp_status
;
814 uint16_t scsi_status
;
815 uint8_t lscsi_status
;
817 uint8_t sense_sz
= 0;
818 uint16_t rsp_info_len
;
820 /* Fast path completion. */
821 if (le16_to_cpu(pkt
->comp_status
) == CS_COMPLETE
&&
822 (le16_to_cpu(pkt
->scsi_status
) & SS_MASK
) == 0) {
823 qla2x00_process_completed_request(ha
, pkt
->handle
);
828 /* Validate handle. */
829 if (pkt
->handle
< MAX_OUTSTANDING_COMMANDS
) {
830 sp
= ha
->outstanding_cmds
[pkt
->handle
];
831 ha
->outstanding_cmds
[pkt
->handle
] = NULL
;
836 DEBUG2(printk("scsi(%ld): Status Entry invalid handle.\n",
838 qla_printk(KERN_WARNING
, ha
, "Status Entry invalid handle.\n");
840 set_bit(ISP_ABORT_NEEDED
, &ha
->dpc_flags
);
841 if (ha
->dpc_wait
&& !ha
->dpc_active
)
848 DEBUG2(printk("scsi(%ld): Command already returned back to OS "
849 "pkt->handle=%d sp=%p sp->state:%d\n",
850 ha
->host_no
, pkt
->handle
, sp
, sp
->state
));
851 qla_printk(KERN_WARNING
, ha
,
852 "Command is NULL: already returned to OS (sp=%p)\n", sp
);
857 comp_status
= le16_to_cpu(pkt
->comp_status
);
858 /* Mask of reserved bits 12-15, before we examine the scsi status */
859 scsi_status
= le16_to_cpu(pkt
->scsi_status
) & SS_MASK
;
860 lscsi_status
= scsi_status
& STATUS_MASK
;
862 CMD_ENTRY_STATUS(cp
) = pkt
->entry_status
;
863 CMD_COMPL_STATUS(cp
) = comp_status
;
864 CMD_SCSI_STATUS(cp
) = scsi_status
;
866 /* Generate LU queue on cntrl, target, LUN */
867 b
= cp
->device
->channel
;
873 /* Check for any FCP transport errors. */
874 if (scsi_status
& SS_RESPONSE_INFO_LEN_VALID
) {
875 rsp_info_len
= le16_to_cpu(pkt
->rsp_info_len
);
876 if (rsp_info_len
> 3 && pkt
->rsp_info
[3]) {
877 DEBUG2(printk("scsi(%ld:%d:%d:%d) FCP I/O protocol "
878 "failure (%x/%02x%02x%02x%02x%02x%02x%02x%02x)..."
879 "retrying command\n", ha
->host_no
, b
, t
, l
,
880 rsp_info_len
, pkt
->rsp_info
[0], pkt
->rsp_info
[1],
881 pkt
->rsp_info
[2], pkt
->rsp_info
[3],
882 pkt
->rsp_info
[4], pkt
->rsp_info
[5],
883 pkt
->rsp_info
[6], pkt
->rsp_info
[7]));
885 cp
->result
= DID_BUS_BUSY
<< 16;
886 qla2x00_sp_compl(ha
, sp
);
892 * Based on Host and scsi status generate status code for Linux
894 switch (comp_status
) {
896 if (scsi_status
== 0) {
897 cp
->result
= DID_OK
<< 16;
900 if (scsi_status
& (SS_RESIDUAL_UNDER
| SS_RESIDUAL_OVER
)) {
901 resid
= le32_to_cpu(pkt
->residual_length
);
903 CMD_RESID_LEN(cp
) = resid
;
905 cp
->result
= DID_OK
<< 16 | lscsi_status
;
907 if (lscsi_status
!= SS_CHECK_CONDITION
)
911 * Copy Sense Data into sense buffer
913 memset(cp
->sense_buffer
, 0, sizeof(cp
->sense_buffer
));
915 if (!(scsi_status
& SS_SENSE_LEN_VALID
))
918 if (le16_to_cpu(pkt
->req_sense_length
) <
919 sizeof(cp
->sense_buffer
))
920 sense_sz
= le16_to_cpu(pkt
->req_sense_length
);
922 sense_sz
= sizeof(cp
->sense_buffer
);
924 CMD_ACTUAL_SNSLEN(cp
) = sense_sz
;
925 sp
->request_sense_length
= sense_sz
;
926 sp
->request_sense_ptr
= cp
->sense_buffer
;
928 if (sp
->request_sense_length
> 32)
931 memcpy(cp
->sense_buffer
, pkt
->req_sense_data
, sense_sz
);
933 sp
->request_sense_ptr
+= sense_sz
;
934 sp
->request_sense_length
-= sense_sz
;
935 if (sp
->request_sense_length
!= 0)
938 DEBUG5(printk("%s(): Check condition Sense data, "
939 "scsi(%ld:%d:%d:%d) cmd=%p pid=%ld\n",
940 __func__
, ha
->host_no
, b
, t
, l
, cp
,
943 DEBUG5(qla2x00_dump_buffer(cp
->sense_buffer
,
944 CMD_ACTUAL_SNSLEN(cp
)));
947 case CS_DATA_UNDERRUN
:
948 DEBUG2(printk(KERN_INFO
949 "scsi(%ld:%d:%d) UNDERRUN status detected 0x%x-0x%x.\n",
950 ha
->host_no
, t
, l
, comp_status
, scsi_status
));
952 resid
= le32_to_cpu(pkt
->residual_length
);
953 if (scsi_status
& SS_RESIDUAL_UNDER
) {
955 CMD_RESID_LEN(cp
) = resid
;
959 * Check to see if SCSI Status is non zero. If so report SCSI
962 if (lscsi_status
!= 0) {
963 cp
->result
= DID_OK
<< 16 | lscsi_status
;
965 if (lscsi_status
!= SS_CHECK_CONDITION
)
968 /* Copy Sense Data into sense buffer */
969 memset(cp
->sense_buffer
, 0, sizeof(cp
->sense_buffer
));
971 if (!(scsi_status
& SS_SENSE_LEN_VALID
))
974 if (le16_to_cpu(pkt
->req_sense_length
) <
975 sizeof(cp
->sense_buffer
))
976 sense_sz
= le16_to_cpu(pkt
->req_sense_length
);
978 sense_sz
= sizeof(cp
->sense_buffer
);
980 CMD_ACTUAL_SNSLEN(cp
) = sense_sz
;
981 sp
->request_sense_length
= sense_sz
;
982 sp
->request_sense_ptr
= cp
->sense_buffer
;
984 if (sp
->request_sense_length
> 32)
987 memcpy(cp
->sense_buffer
, pkt
->req_sense_data
, sense_sz
);
989 sp
->request_sense_ptr
+= sense_sz
;
990 sp
->request_sense_length
-= sense_sz
;
991 if (sp
->request_sense_length
!= 0)
994 DEBUG5(printk("%s(): Check condition Sense data, "
995 "scsi(%ld:%d:%d:%d) cmd=%p pid=%ld\n",
996 __func__
, ha
->host_no
, b
, t
, l
, cp
,
999 DEBUG5(qla2x00_dump_buffer(cp
->sense_buffer
,
1000 CMD_ACTUAL_SNSLEN(cp
)));
1003 * If RISC reports underrun and target does not report
1004 * it then we must have a lost frame, so tell upper
1005 * layer to retry it by reporting a bus busy.
1007 if (!(scsi_status
& SS_RESIDUAL_UNDER
)) {
1008 DEBUG2(printk("scsi(%ld:%d:%d:%d) Dropped "
1009 "frame(s) detected (%x of %x bytes)..."
1010 "retrying command.\n",
1011 ha
->host_no
, b
, t
, l
, resid
,
1012 cp
->request_bufflen
));
1014 cp
->result
= DID_BUS_BUSY
<< 16;
1018 /* Handle mid-layer underflow */
1019 if ((unsigned)(cp
->request_bufflen
- resid
) <
1021 qla_printk(KERN_INFO
, ha
,
1022 "scsi(%ld:%d:%d:%d): Mid-layer underflow "
1023 "detected (%x of %x bytes)...returning "
1025 ha
->host_no
, b
, t
, l
, resid
,
1026 cp
->request_bufflen
);
1028 cp
->result
= DID_ERROR
<< 16;
1032 /* Everybody online, looking good... */
1033 cp
->result
= DID_OK
<< 16;
1037 case CS_DATA_OVERRUN
:
1038 DEBUG2(printk(KERN_INFO
1039 "scsi(%ld:%d:%d): OVERRUN status detected 0x%x-0x%x\n",
1040 ha
->host_no
, t
, l
, comp_status
, scsi_status
));
1041 DEBUG2(printk(KERN_INFO
1042 "CDB: 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x\n",
1043 cp
->cmnd
[0], cp
->cmnd
[1], cp
->cmnd
[2], cp
->cmnd
[3],
1044 cp
->cmnd
[4], cp
->cmnd
[5]));
1045 DEBUG2(printk(KERN_INFO
1046 "PID=0x%lx req=0x%x xtra=0x%x -- returning DID_ERROR "
1048 cp
->serial_number
, cp
->request_bufflen
,
1049 le32_to_cpu(pkt
->residual_length
)));
1051 cp
->result
= DID_ERROR
<< 16;
1054 case CS_PORT_LOGGED_OUT
:
1055 case CS_PORT_CONFIG_CHG
:
1058 case CS_PORT_UNAVAILABLE
:
1060 * If the port is in Target Down state, return all IOs for this
1061 * Target with DID_NO_CONNECT ELSE Queue the IOs in the
1064 DEBUG2(printk("scsi(%ld:%d:%d): status_entry: Port Down "
1065 "pid=%ld, compl status=0x%x, port state=0x%x\n",
1066 ha
->host_no
, t
, l
, cp
->serial_number
, comp_status
,
1067 atomic_read(&fcport
->state
)));
1069 cp
->result
= DID_BUS_BUSY
<< 16;
1070 if (atomic_read(&fcport
->state
) == FCS_ONLINE
) {
1071 qla2x00_mark_device_lost(ha
, fcport
, 1);
1076 DEBUG2(printk(KERN_INFO
1077 "scsi(%ld): RESET status detected 0x%x-0x%x.\n",
1078 ha
->host_no
, comp_status
, scsi_status
));
1080 cp
->result
= DID_RESET
<< 16;
1085 * hv2.19.12 - DID_ABORT does not retry the request if we
1086 * aborted this request then abort otherwise it must be a
1089 DEBUG2(printk(KERN_INFO
1090 "scsi(%ld): ABORT status detected 0x%x-0x%x.\n",
1091 ha
->host_no
, comp_status
, scsi_status
));
1093 cp
->result
= DID_RESET
<< 16;
1097 DEBUG2(printk(KERN_INFO
1098 "scsi(%ld:%d:%d:%d): TIMEOUT status detected 0x%x-0x%x "
1099 "sflags=%x.\n", ha
->host_no
, b
, t
, l
, comp_status
,
1100 scsi_status
, le16_to_cpu(pkt
->status_flags
)));
1102 cp
->result
= DID_BUS_BUSY
<< 16;
1104 /* Check to see if logout occurred */
1105 if ((le16_to_cpu(pkt
->status_flags
) & SF_LOGOUT_SENT
)) {
1106 qla2x00_mark_device_lost(ha
, fcport
, 1);
1111 DEBUG2(printk(KERN_INFO
1112 "scsi(%ld): QUEUE FULL status detected 0x%x-0x%x.\n",
1113 ha
->host_no
, comp_status
, scsi_status
));
1115 /* SCSI Mid-Layer handles device queue full */
1117 cp
->result
= DID_OK
<< 16 | lscsi_status
;
1122 DEBUG3(printk("scsi(%ld): Error detected (unknown status) "
1124 ha
->host_no
, comp_status
, scsi_status
));
1125 qla_printk(KERN_INFO
, ha
,
1126 "Unknown status detected 0x%x-0x%x.\n",
1127 comp_status
, scsi_status
);
1129 cp
->result
= DID_ERROR
<< 16;
1133 /* Place command on done queue. */
1134 if (ha
->status_srb
== NULL
)
1135 qla2x00_sp_compl(ha
, sp
);
1139 * qla2x00_status_cont_entry() - Process a Status Continuations entry.
1140 * @ha: SCSI driver HA context
1141 * @pkt: Entry pointer
1143 * Extended sense data.
1146 qla2x00_status_cont_entry(scsi_qla_host_t
*ha
, sts_cont_entry_t
*pkt
)
1148 uint8_t sense_sz
= 0;
1149 srb_t
*sp
= ha
->status_srb
;
1150 struct scsi_cmnd
*cp
;
1152 if (sp
!= NULL
&& sp
->request_sense_length
!= 0) {
1155 DEBUG2(printk("%s(): Cmd already returned back to OS "
1156 "sp=%p sp->state:%d\n", __func__
, sp
, sp
->state
));
1157 qla_printk(KERN_INFO
, ha
,
1158 "cmd is NULL: already returned to OS (sp=%p)\n",
1161 ha
->status_srb
= NULL
;
1165 if (sp
->request_sense_length
> sizeof(pkt
->data
)) {
1166 sense_sz
= sizeof(pkt
->data
);
1168 sense_sz
= sp
->request_sense_length
;
1171 /* Move sense data. */
1172 memcpy(sp
->request_sense_ptr
, pkt
->data
, sense_sz
);
1173 DEBUG5(qla2x00_dump_buffer(sp
->request_sense_ptr
, sense_sz
));
1175 sp
->request_sense_ptr
+= sense_sz
;
1176 sp
->request_sense_length
-= sense_sz
;
1178 /* Place command on done queue. */
1179 if (sp
->request_sense_length
== 0) {
1180 ha
->status_srb
= NULL
;
1181 qla2x00_sp_compl(ha
, sp
);
1187 * qla2x00_error_entry() - Process an error entry.
1188 * @ha: SCSI driver HA context
1189 * @pkt: Entry pointer
1192 qla2x00_error_entry(scsi_qla_host_t
*ha
, sts_entry_t
*pkt
)
1196 #if defined(QL_DEBUG_LEVEL_2)
1197 if (pkt
->entry_status
& RF_INV_E_ORDER
)
1198 qla_printk(KERN_ERR
, ha
, "%s: Invalid Entry Order\n", __func__
);
1199 else if (pkt
->entry_status
& RF_INV_E_COUNT
)
1200 qla_printk(KERN_ERR
, ha
, "%s: Invalid Entry Count\n", __func__
);
1201 else if (pkt
->entry_status
& RF_INV_E_PARAM
)
1202 qla_printk(KERN_ERR
, ha
,
1203 "%s: Invalid Entry Parameter\n", __func__
);
1204 else if (pkt
->entry_status
& RF_INV_E_TYPE
)
1205 qla_printk(KERN_ERR
, ha
, "%s: Invalid Entry Type\n", __func__
);
1206 else if (pkt
->entry_status
& RF_BUSY
)
1207 qla_printk(KERN_ERR
, ha
, "%s: Busy\n", __func__
);
1209 qla_printk(KERN_ERR
, ha
, "%s: UNKNOWN flag error\n", __func__
);
1212 /* Validate handle. */
1213 if (pkt
->handle
< MAX_OUTSTANDING_COMMANDS
)
1214 sp
= ha
->outstanding_cmds
[pkt
->handle
];
1219 /* Free outstanding command slot. */
1220 ha
->outstanding_cmds
[pkt
->handle
] = NULL
;
1222 /* Bad payload or header */
1223 if (pkt
->entry_status
&
1224 (RF_INV_E_ORDER
| RF_INV_E_COUNT
|
1225 RF_INV_E_PARAM
| RF_INV_E_TYPE
)) {
1226 sp
->cmd
->result
= DID_ERROR
<< 16;
1227 } else if (pkt
->entry_status
& RF_BUSY
) {
1228 sp
->cmd
->result
= DID_BUS_BUSY
<< 16;
1230 sp
->cmd
->result
= DID_ERROR
<< 16;
1232 qla2x00_sp_compl(ha
, sp
);
1234 } else if (pkt
->entry_type
== COMMAND_A64_TYPE
||
1235 pkt
->entry_type
== COMMAND_TYPE
) {
1236 DEBUG2(printk("scsi(%ld): Error entry - invalid handle\n",
1238 qla_printk(KERN_WARNING
, ha
,
1239 "Error entry - invalid handle\n");
1241 set_bit(ISP_ABORT_NEEDED
, &ha
->dpc_flags
);
1242 if (ha
->dpc_wait
&& !ha
->dpc_active
)
1248 * qla2x00_ms_entry() - Process a Management Server entry.
1249 * @ha: SCSI driver HA context
1250 * @index: Response queue out pointer
1253 qla2x00_ms_entry(scsi_qla_host_t
*ha
, ms_iocb_entry_t
*pkt
)
1257 DEBUG3(printk("%s(%ld): pkt=%p pkthandle=%d.\n",
1258 __func__
, ha
->host_no
, pkt
, pkt
->handle1
));
1260 /* Validate handle. */
1261 if (pkt
->handle1
< MAX_OUTSTANDING_COMMANDS
)
1262 sp
= ha
->outstanding_cmds
[pkt
->handle1
];
1267 DEBUG2(printk("scsi(%ld): MS entry - invalid handle\n",
1269 qla_printk(KERN_WARNING
, ha
, "MS entry - invalid handle\n");
1271 set_bit(ISP_ABORT_NEEDED
, &ha
->dpc_flags
);
1275 CMD_COMPL_STATUS(sp
->cmd
) = le16_to_cpu(pkt
->status
);
1276 CMD_ENTRY_STATUS(sp
->cmd
) = pkt
->entry_status
;
1278 /* Free outstanding command slot. */
1279 ha
->outstanding_cmds
[pkt
->handle1
] = NULL
;
1281 qla2x00_sp_compl(ha
, sp
);