2 * QLogic Fibre Channel HBA Driver
3 * Copyright (c) 2003-2005 QLogic Corporation
5 * See LICENSE.qla2xxx for copyright and licensing details.
9 #include <scsi/scsi_tcq.h>
11 static void qla2x00_mbx_completion(scsi_qla_host_t
*, uint16_t);
12 static void qla2x00_async_event(scsi_qla_host_t
*, uint16_t *);
13 static void qla2x00_process_completed_request(struct scsi_qla_host
*, uint32_t);
14 static void qla2x00_status_entry(scsi_qla_host_t
*, void *);
15 static void qla2x00_status_cont_entry(scsi_qla_host_t
*, sts_cont_entry_t
*);
16 static void qla2x00_error_entry(scsi_qla_host_t
*, sts_entry_t
*);
17 static void qla2x00_ms_entry(scsi_qla_host_t
*, ms_iocb_entry_t
*);
19 static void qla24xx_ms_entry(scsi_qla_host_t
*, struct ct_entry_24xx
*);
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 device_reg_2xxx __iomem
*reg
;
40 ha
= (scsi_qla_host_t
*) dev_id
;
43 "%s(): NULL host pointer\n", __func__
);
47 reg
= &ha
->iobase
->isp
;
50 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
51 for (iter
= 50; iter
--; ) {
52 if ((RD_REG_WORD(®
->istatus
) & ISR_RISC_INT
) == 0)
55 if (RD_REG_WORD(®
->semaphore
) & BIT_0
) {
56 WRT_REG_WORD(®
->hccr
, HCCR_CLR_RISC_INT
);
57 RD_REG_WORD(®
->hccr
);
59 /* Get mailbox data. */
60 mb
[0] = RD_MAILBOX_REG(ha
, reg
, 0);
61 if (mb
[0] > 0x3fff && mb
[0] < 0x8000) {
62 qla2x00_mbx_completion(ha
, mb
[0]);
63 status
|= MBX_INTERRUPT
;
64 } else if (mb
[0] > 0x7fff && mb
[0] < 0xc000) {
65 mb
[1] = RD_MAILBOX_REG(ha
, reg
, 1);
66 mb
[2] = RD_MAILBOX_REG(ha
, reg
, 2);
67 mb
[3] = RD_MAILBOX_REG(ha
, reg
, 3);
68 qla2x00_async_event(ha
, mb
);
71 DEBUG2(printk("scsi(%ld): Unrecognized "
72 "interrupt type (%d).\n",
75 /* Release mailbox registers. */
76 WRT_REG_WORD(®
->semaphore
, 0);
77 RD_REG_WORD(®
->semaphore
);
79 qla2x00_process_response_queue(ha
);
81 WRT_REG_WORD(®
->hccr
, HCCR_CLR_RISC_INT
);
82 RD_REG_WORD(®
->hccr
);
85 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
87 if (test_bit(MBX_INTR_WAIT
, &ha
->mbx_cmd_flags
) &&
88 (status
& MBX_INTERRUPT
) && ha
->flags
.mbox_int
) {
89 spin_lock_irqsave(&ha
->mbx_reg_lock
, flags
);
91 set_bit(MBX_INTERRUPT
, &ha
->mbx_cmd_flags
);
92 up(&ha
->mbx_intr_sem
);
94 spin_unlock_irqrestore(&ha
->mbx_reg_lock
, flags
);
101 * qla2300_intr_handler() - Process interrupts for the ISP23xx and ISP63xx.
103 * @dev_id: SCSI driver HA context
105 * Called by system whenever the host adapter generates an interrupt.
107 * Returns handled flag.
110 qla2300_intr_handler(int irq
, void *dev_id
)
113 struct device_reg_2xxx __iomem
*reg
;
121 ha
= (scsi_qla_host_t
*) dev_id
;
124 "%s(): NULL host pointer\n", __func__
);
128 reg
= &ha
->iobase
->isp
;
131 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
132 for (iter
= 50; iter
--; ) {
133 stat
= RD_REG_DWORD(®
->u
.isp2300
.host_status
);
134 if (stat
& HSR_RISC_PAUSED
) {
135 hccr
= RD_REG_WORD(®
->hccr
);
136 if (hccr
& (BIT_15
| BIT_13
| BIT_11
| BIT_8
))
137 qla_printk(KERN_INFO
, ha
,
138 "Parity error -- HCCR=%x.\n", hccr
);
140 qla_printk(KERN_INFO
, ha
,
141 "RISC paused -- HCCR=%x.\n", hccr
);
144 * Issue a "HARD" reset in order for the RISC
145 * interrupt bit to be cleared. Schedule a big
146 * hammmer to get out of the RISC PAUSED state.
148 WRT_REG_WORD(®
->hccr
, HCCR_RESET_RISC
);
149 RD_REG_WORD(®
->hccr
);
150 set_bit(ISP_ABORT_NEEDED
, &ha
->dpc_flags
);
152 } else if ((stat
& HSR_RISC_INT
) == 0)
155 switch (stat
& 0xff) {
160 qla2x00_mbx_completion(ha
, MSW(stat
));
161 status
|= MBX_INTERRUPT
;
163 /* Release mailbox registers. */
164 WRT_REG_WORD(®
->semaphore
, 0);
168 mb
[1] = RD_MAILBOX_REG(ha
, reg
, 1);
169 mb
[2] = RD_MAILBOX_REG(ha
, reg
, 2);
170 mb
[3] = RD_MAILBOX_REG(ha
, reg
, 3);
171 qla2x00_async_event(ha
, mb
);
174 qla2x00_process_response_queue(ha
);
177 mb
[0] = MBA_CMPLT_1_16BIT
;
179 qla2x00_async_event(ha
, mb
);
182 mb
[0] = MBA_SCSI_COMPLETION
;
184 mb
[2] = RD_MAILBOX_REG(ha
, reg
, 2);
185 qla2x00_async_event(ha
, mb
);
188 DEBUG2(printk("scsi(%ld): Unrecognized interrupt type "
190 ha
->host_no
, stat
& 0xff));
193 WRT_REG_WORD(®
->hccr
, HCCR_CLR_RISC_INT
);
194 RD_REG_WORD_RELAXED(®
->hccr
);
196 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
198 if (test_bit(MBX_INTR_WAIT
, &ha
->mbx_cmd_flags
) &&
199 (status
& MBX_INTERRUPT
) && ha
->flags
.mbox_int
) {
200 spin_lock_irqsave(&ha
->mbx_reg_lock
, flags
);
202 set_bit(MBX_INTERRUPT
, &ha
->mbx_cmd_flags
);
203 up(&ha
->mbx_intr_sem
);
205 spin_unlock_irqrestore(&ha
->mbx_reg_lock
, flags
);
208 return (IRQ_HANDLED
);
212 * qla2x00_mbx_completion() - Process mailbox command completions.
213 * @ha: SCSI driver HA context
214 * @mb0: Mailbox0 register
217 qla2x00_mbx_completion(scsi_qla_host_t
*ha
, uint16_t mb0
)
220 uint16_t __iomem
*wptr
;
221 struct device_reg_2xxx __iomem
*reg
= &ha
->iobase
->isp
;
223 /* Load return mailbox registers. */
224 ha
->flags
.mbox_int
= 1;
225 ha
->mailbox_out
[0] = mb0
;
226 wptr
= (uint16_t __iomem
*)MAILBOX_REG(ha
, reg
, 1);
228 for (cnt
= 1; cnt
< ha
->mbx_count
; cnt
++) {
229 if (IS_QLA2200(ha
) && cnt
== 8)
230 wptr
= (uint16_t __iomem
*)MAILBOX_REG(ha
, reg
, 8);
231 if (cnt
== 4 || cnt
== 5)
232 ha
->mailbox_out
[cnt
] = qla2x00_debounce_register(wptr
);
234 ha
->mailbox_out
[cnt
] = RD_REG_WORD(wptr
);
240 DEBUG3(printk("%s(%ld): Got mailbox completion. cmd=%x.\n",
241 __func__
, ha
->host_no
, ha
->mcp
->mb
[0]));
243 DEBUG2_3(printk("%s(%ld): MBX pointer ERROR!\n",
244 __func__
, ha
->host_no
));
249 * qla2x00_async_event() - Process aynchronous events.
250 * @ha: SCSI driver HA context
251 * @mb: Mailbox registers (0 - 3)
254 qla2x00_async_event(scsi_qla_host_t
*ha
, uint16_t *mb
)
257 static char *link_speeds
[5] = { "1", "2", "?", "4", "10" };
262 struct device_reg_2xxx __iomem
*reg
= &ha
->iobase
->isp
;
263 uint32_t rscn_entry
, host_pid
;
264 uint8_t rscn_queue_index
;
266 /* Setup to process RIO completion. */
269 case MBA_SCSI_COMPLETION
:
270 handles
[0] = le32_to_cpu((uint32_t)((mb
[2] << 16) | mb
[1]));
273 case MBA_CMPLT_1_16BIT
:
276 mb
[0] = MBA_SCSI_COMPLETION
;
278 case MBA_CMPLT_2_16BIT
:
282 mb
[0] = MBA_SCSI_COMPLETION
;
284 case MBA_CMPLT_3_16BIT
:
289 mb
[0] = MBA_SCSI_COMPLETION
;
291 case MBA_CMPLT_4_16BIT
:
295 handles
[3] = (uint32_t)RD_MAILBOX_REG(ha
, reg
, 6);
297 mb
[0] = MBA_SCSI_COMPLETION
;
299 case MBA_CMPLT_5_16BIT
:
303 handles
[3] = (uint32_t)RD_MAILBOX_REG(ha
, reg
, 6);
304 handles
[4] = (uint32_t)RD_MAILBOX_REG(ha
, reg
, 7);
306 mb
[0] = MBA_SCSI_COMPLETION
;
308 case MBA_CMPLT_2_32BIT
:
309 handles
[0] = le32_to_cpu((uint32_t)((mb
[2] << 16) | mb
[1]));
310 handles
[1] = le32_to_cpu(
311 ((uint32_t)(RD_MAILBOX_REG(ha
, reg
, 7) << 16)) |
312 RD_MAILBOX_REG(ha
, reg
, 6));
314 mb
[0] = MBA_SCSI_COMPLETION
;
321 case MBA_SCSI_COMPLETION
: /* Fast Post */
322 if (!ha
->flags
.online
)
325 for (cnt
= 0; cnt
< handle_cnt
; cnt
++)
326 qla2x00_process_completed_request(ha
, handles
[cnt
]);
329 case MBA_RESET
: /* Reset */
330 DEBUG2(printk("scsi(%ld): Asynchronous RESET.\n", ha
->host_no
));
332 set_bit(RESET_MARKER_NEEDED
, &ha
->dpc_flags
);
335 case MBA_SYSTEM_ERR
: /* System Error */
336 mb
[1] = RD_MAILBOX_REG(ha
, reg
, 1);
337 mb
[2] = RD_MAILBOX_REG(ha
, reg
, 2);
338 mb
[3] = RD_MAILBOX_REG(ha
, reg
, 3);
340 qla_printk(KERN_INFO
, ha
,
341 "ISP System Error - mbx1=%xh mbx2=%xh mbx3=%xh.\n",
342 mb
[1], mb
[2], mb
[3]);
344 ha
->isp_ops
.fw_dump(ha
, 1);
346 if (IS_QLA24XX(ha
) || IS_QLA54XX(ha
)) {
347 if (mb
[1] == 0 && mb
[2] == 0) {
348 qla_printk(KERN_ERR
, ha
,
349 "Unrecoverable Hardware Error: adapter "
350 "marked OFFLINE!\n");
351 ha
->flags
.online
= 0;
353 set_bit(ISP_ABORT_NEEDED
, &ha
->dpc_flags
);
354 } else if (mb
[1] == 0) {
355 qla_printk(KERN_INFO
, ha
,
356 "Unrecoverable Hardware Error: adapter marked "
358 ha
->flags
.online
= 0;
360 set_bit(ISP_ABORT_NEEDED
, &ha
->dpc_flags
);
363 case MBA_REQ_TRANSFER_ERR
: /* Request Transfer Error */
364 DEBUG2(printk("scsi(%ld): ISP Request Transfer Error.\n",
366 qla_printk(KERN_WARNING
, ha
, "ISP Request Transfer Error.\n");
368 set_bit(ISP_ABORT_NEEDED
, &ha
->dpc_flags
);
371 case MBA_RSP_TRANSFER_ERR
: /* Response Transfer Error */
372 DEBUG2(printk("scsi(%ld): ISP Response Transfer Error.\n",
374 qla_printk(KERN_WARNING
, ha
, "ISP Response Transfer Error.\n");
376 set_bit(ISP_ABORT_NEEDED
, &ha
->dpc_flags
);
379 case MBA_WAKEUP_THRES
: /* Request Queue Wake-up */
380 DEBUG2(printk("scsi(%ld): Asynchronous WAKEUP_THRES.\n",
384 case MBA_LIP_OCCURRED
: /* Loop Initialization Procedure */
385 DEBUG2(printk("scsi(%ld): LIP occured (%x).\n", ha
->host_no
,
387 qla_printk(KERN_INFO
, ha
, "LIP occured (%x).\n", mb
[1]);
389 if (atomic_read(&ha
->loop_state
) != LOOP_DOWN
) {
390 atomic_set(&ha
->loop_state
, LOOP_DOWN
);
391 atomic_set(&ha
->loop_down_timer
, LOOP_DOWN_TIME
);
392 qla2x00_mark_all_devices_lost(ha
, 1);
395 set_bit(REGISTER_FC4_NEEDED
, &ha
->dpc_flags
);
397 ha
->flags
.management_server_logged_in
= 0;
400 case MBA_LOOP_UP
: /* Loop Up Event */
401 if (IS_QLA2100(ha
) || IS_QLA2200(ha
)) {
402 link_speed
= link_speeds
[0];
403 ha
->link_data_rate
= PORT_SPEED_1GB
;
405 link_speed
= link_speeds
[LS_UNKNOWN
];
407 link_speed
= link_speeds
[mb
[1]];
408 ha
->link_data_rate
= mb
[1];
411 DEBUG2(printk("scsi(%ld): Asynchronous LOOP UP (%s Gbps).\n",
412 ha
->host_no
, link_speed
));
413 qla_printk(KERN_INFO
, ha
, "LOOP UP detected (%s Gbps).\n",
416 ha
->flags
.management_server_logged_in
= 0;
419 case MBA_LOOP_DOWN
: /* Loop Down Event */
420 DEBUG2(printk("scsi(%ld): Asynchronous LOOP DOWN (%x).\n",
421 ha
->host_no
, mb
[1]));
422 qla_printk(KERN_INFO
, ha
, "LOOP DOWN detected (%x).\n", mb
[1]);
424 if (atomic_read(&ha
->loop_state
) != LOOP_DOWN
) {
425 atomic_set(&ha
->loop_state
, LOOP_DOWN
);
426 atomic_set(&ha
->loop_down_timer
, LOOP_DOWN_TIME
);
427 ha
->device_flags
|= DFLG_NO_CABLE
;
428 qla2x00_mark_all_devices_lost(ha
, 1);
431 ha
->flags
.management_server_logged_in
= 0;
432 ha
->link_data_rate
= PORT_SPEED_UNKNOWN
;
434 set_bit(REGISTER_FDMI_NEEDED
, &ha
->dpc_flags
);
437 case MBA_LIP_RESET
: /* LIP reset occurred */
438 DEBUG2(printk("scsi(%ld): Asynchronous LIP RESET (%x).\n",
439 ha
->host_no
, mb
[1]));
440 qla_printk(KERN_INFO
, ha
,
441 "LIP reset occured (%x).\n", mb
[1]);
443 if (atomic_read(&ha
->loop_state
) != LOOP_DOWN
) {
444 atomic_set(&ha
->loop_state
, LOOP_DOWN
);
445 atomic_set(&ha
->loop_down_timer
, LOOP_DOWN_TIME
);
446 qla2x00_mark_all_devices_lost(ha
, 1);
449 set_bit(RESET_MARKER_NEEDED
, &ha
->dpc_flags
);
451 ha
->operating_mode
= LOOP
;
452 ha
->flags
.management_server_logged_in
= 0;
455 case MBA_POINT_TO_POINT
: /* Point-to-Point */
459 DEBUG2(printk("scsi(%ld): Asynchronous P2P MODE received.\n",
463 * Until there's a transition from loop down to loop up, treat
464 * this as loop down only.
466 if (atomic_read(&ha
->loop_state
) != LOOP_DOWN
) {
467 atomic_set(&ha
->loop_state
, LOOP_DOWN
);
468 if (!atomic_read(&ha
->loop_down_timer
))
469 atomic_set(&ha
->loop_down_timer
,
471 qla2x00_mark_all_devices_lost(ha
, 1);
474 if (!(test_bit(ABORT_ISP_ACTIVE
, &ha
->dpc_flags
))) {
475 set_bit(RESET_MARKER_NEEDED
, &ha
->dpc_flags
);
477 set_bit(REGISTER_FC4_NEEDED
, &ha
->dpc_flags
);
480 case MBA_CHG_IN_CONNECTION
: /* Change in connection mode */
484 DEBUG2(printk("scsi(%ld): Asynchronous Change In Connection "
487 qla_printk(KERN_INFO
, ha
,
488 "Configuration change detected: value=%x.\n", mb
[1]);
490 if (atomic_read(&ha
->loop_state
) != LOOP_DOWN
) {
491 atomic_set(&ha
->loop_state
, LOOP_DOWN
);
492 if (!atomic_read(&ha
->loop_down_timer
))
493 atomic_set(&ha
->loop_down_timer
,
495 qla2x00_mark_all_devices_lost(ha
, 1);
498 set_bit(LOOP_RESYNC_NEEDED
, &ha
->dpc_flags
);
499 set_bit(LOCAL_LOOP_UPDATE
, &ha
->dpc_flags
);
502 case MBA_PORT_UPDATE
: /* Port database update */
504 * If PORT UPDATE is global (recieved LIP_OCCURED/LIP_RESET
505 * event etc. earlier indicating loop is down) then process
506 * it. Otherwise ignore it and Wait for RSCN to come in.
508 atomic_set(&ha
->loop_down_timer
, 0);
509 if (atomic_read(&ha
->loop_state
) != LOOP_DOWN
&&
510 atomic_read(&ha
->loop_state
) != LOOP_DEAD
) {
511 DEBUG2(printk("scsi(%ld): Asynchronous PORT UPDATE "
512 "ignored %04x/%04x/%04x.\n", ha
->host_no
, mb
[1],
517 DEBUG2(printk("scsi(%ld): Asynchronous PORT UPDATE.\n",
519 DEBUG(printk(KERN_INFO
520 "scsi(%ld): Port database changed %04x %04x %04x.\n",
521 ha
->host_no
, mb
[1], mb
[2], mb
[3]));
524 * Mark all devices as missing so we will login again.
526 atomic_set(&ha
->loop_state
, LOOP_UP
);
528 qla2x00_mark_all_devices_lost(ha
, 1);
530 ha
->flags
.rscn_queue_overflow
= 1;
532 set_bit(LOOP_RESYNC_NEEDED
, &ha
->dpc_flags
);
533 set_bit(LOCAL_LOOP_UPDATE
, &ha
->dpc_flags
);
536 case MBA_RSCN_UPDATE
: /* State Change Registration */
537 DEBUG2(printk("scsi(%ld): Asynchronous RSCR UPDATE.\n",
539 DEBUG(printk(KERN_INFO
540 "scsi(%ld): RSCN database changed -- %04x %04x.\n",
541 ha
->host_no
, mb
[1], mb
[2]));
543 rscn_entry
= (mb
[1] << 16) | mb
[2];
544 host_pid
= (ha
->d_id
.b
.domain
<< 16) | (ha
->d_id
.b
.area
<< 8) |
546 if (rscn_entry
== host_pid
) {
547 DEBUG(printk(KERN_INFO
548 "scsi(%ld): Ignoring RSCN update to local host "
550 ha
->host_no
, host_pid
));
554 rscn_queue_index
= ha
->rscn_in_ptr
+ 1;
555 if (rscn_queue_index
== MAX_RSCN_COUNT
)
556 rscn_queue_index
= 0;
557 if (rscn_queue_index
!= ha
->rscn_out_ptr
) {
558 ha
->rscn_queue
[ha
->rscn_in_ptr
] = rscn_entry
;
559 ha
->rscn_in_ptr
= rscn_queue_index
;
561 ha
->flags
.rscn_queue_overflow
= 1;
564 atomic_set(&ha
->loop_state
, LOOP_UPDATE
);
565 atomic_set(&ha
->loop_down_timer
, 0);
566 ha
->flags
.management_server_logged_in
= 0;
568 set_bit(LOOP_RESYNC_NEEDED
, &ha
->dpc_flags
);
569 set_bit(RSCN_UPDATE
, &ha
->dpc_flags
);
572 /* case MBA_RIO_RESPONSE: */
573 case MBA_ZIO_RESPONSE
:
574 DEBUG2(printk("scsi(%ld): [R|Z]IO update completion.\n",
576 DEBUG(printk(KERN_INFO
577 "scsi(%ld): [R|Z]IO update completion.\n",
580 if (IS_QLA24XX(ha
) || IS_QLA54XX(ha
))
581 qla24xx_process_response_queue(ha
);
583 qla2x00_process_response_queue(ha
);
586 case MBA_DISCARD_RND_FRAME
:
587 DEBUG2(printk("scsi(%ld): Discard RND Frame -- %04x %04x "
588 "%04x.\n", ha
->host_no
, mb
[1], mb
[2], mb
[3]));
591 case MBA_TRACE_NOTIFICATION
:
592 DEBUG2(printk("scsi(%ld): Trace Notification -- %04x %04x.\n",
593 ha
->host_no
, mb
[1], mb
[2]));
599 qla2x00_adjust_sdev_qdepth_up(struct scsi_device
*sdev
, void *data
)
601 fc_port_t
*fcport
= data
;
603 if (fcport
->ha
->max_q_depth
<= sdev
->queue_depth
)
606 if (sdev
->ordered_tags
)
607 scsi_adjust_queue_depth(sdev
, MSG_ORDERED_TAG
,
608 sdev
->queue_depth
+ 1);
610 scsi_adjust_queue_depth(sdev
, MSG_SIMPLE_TAG
,
611 sdev
->queue_depth
+ 1);
613 fcport
->last_ramp_up
= jiffies
;
615 DEBUG2(qla_printk(KERN_INFO
, fcport
->ha
,
616 "scsi(%ld:%d:%d:%d): Queue depth adjusted-up to %d.\n",
617 fcport
->ha
->host_no
, sdev
->channel
, sdev
->id
, sdev
->lun
,
622 qla2x00_adjust_sdev_qdepth_down(struct scsi_device
*sdev
, void *data
)
624 fc_port_t
*fcport
= data
;
626 if (!scsi_track_queue_full(sdev
, sdev
->queue_depth
- 1))
629 DEBUG2(qla_printk(KERN_INFO
, fcport
->ha
,
630 "scsi(%ld:%d:%d:%d): Queue depth adjusted-down to %d.\n",
631 fcport
->ha
->host_no
, sdev
->channel
, sdev
->id
, sdev
->lun
,
636 qla2x00_ramp_up_queue_depth(scsi_qla_host_t
*ha
, srb_t
*sp
)
639 struct scsi_device
*sdev
;
641 sdev
= sp
->cmd
->device
;
642 if (sdev
->queue_depth
>= ha
->max_q_depth
)
646 if (time_before(jiffies
,
647 fcport
->last_ramp_up
+ ql2xqfullrampup
* HZ
))
649 if (time_before(jiffies
,
650 fcport
->last_queue_full
+ ql2xqfullrampup
* HZ
))
653 starget_for_each_device(sdev
->sdev_target
, fcport
,
654 qla2x00_adjust_sdev_qdepth_up
);
658 * qla2x00_process_completed_request() - Process a Fast Post response.
659 * @ha: SCSI driver HA context
663 qla2x00_process_completed_request(struct scsi_qla_host
*ha
, uint32_t index
)
667 /* Validate handle. */
668 if (index
>= MAX_OUTSTANDING_COMMANDS
) {
669 DEBUG2(printk("scsi(%ld): Invalid SCSI completion handle %d.\n",
670 ha
->host_no
, index
));
671 qla_printk(KERN_WARNING
, ha
,
672 "Invalid SCSI completion handle %d.\n", index
);
674 set_bit(ISP_ABORT_NEEDED
, &ha
->dpc_flags
);
678 sp
= ha
->outstanding_cmds
[index
];
680 /* Free outstanding command slot. */
681 ha
->outstanding_cmds
[index
] = NULL
;
683 CMD_COMPL_STATUS(sp
->cmd
) = 0L;
684 CMD_SCSI_STATUS(sp
->cmd
) = 0L;
686 /* Save ISP completion status */
687 sp
->cmd
->result
= DID_OK
<< 16;
689 qla2x00_ramp_up_queue_depth(ha
, sp
);
690 qla2x00_sp_compl(ha
, sp
);
692 DEBUG2(printk("scsi(%ld): Invalid ISP SCSI completion handle\n",
694 qla_printk(KERN_WARNING
, ha
,
695 "Invalid ISP SCSI completion handle\n");
697 set_bit(ISP_ABORT_NEEDED
, &ha
->dpc_flags
);
702 * qla2x00_process_response_queue() - Process response queue entries.
703 * @ha: SCSI driver HA context
706 qla2x00_process_response_queue(struct scsi_qla_host
*ha
)
708 struct device_reg_2xxx __iomem
*reg
= &ha
->iobase
->isp
;
713 if (!ha
->flags
.online
)
716 while (ha
->response_ring_ptr
->signature
!= RESPONSE_PROCESSED
) {
717 pkt
= (sts_entry_t
*)ha
->response_ring_ptr
;
719 ha
->rsp_ring_index
++;
720 if (ha
->rsp_ring_index
== ha
->response_q_length
) {
721 ha
->rsp_ring_index
= 0;
722 ha
->response_ring_ptr
= ha
->response_ring
;
724 ha
->response_ring_ptr
++;
727 if (pkt
->entry_status
!= 0) {
728 DEBUG3(printk(KERN_INFO
729 "scsi(%ld): Process error entry.\n", ha
->host_no
));
731 qla2x00_error_entry(ha
, pkt
);
732 ((response_t
*)pkt
)->signature
= RESPONSE_PROCESSED
;
737 switch (pkt
->entry_type
) {
739 qla2x00_status_entry(ha
, pkt
);
742 handle_cnt
= ((sts21_entry_t
*)pkt
)->handle_count
;
743 for (cnt
= 0; cnt
< handle_cnt
; cnt
++) {
744 qla2x00_process_completed_request(ha
,
745 ((sts21_entry_t
*)pkt
)->handle
[cnt
]);
749 handle_cnt
= ((sts22_entry_t
*)pkt
)->handle_count
;
750 for (cnt
= 0; cnt
< handle_cnt
; cnt
++) {
751 qla2x00_process_completed_request(ha
,
752 ((sts22_entry_t
*)pkt
)->handle
[cnt
]);
755 case STATUS_CONT_TYPE
:
756 qla2x00_status_cont_entry(ha
, (sts_cont_entry_t
*)pkt
);
759 qla2x00_ms_entry(ha
, (ms_iocb_entry_t
*)pkt
);
762 /* Type Not Supported. */
763 DEBUG4(printk(KERN_WARNING
764 "scsi(%ld): Received unknown response pkt type %x "
765 "entry status=%x.\n",
766 ha
->host_no
, pkt
->entry_type
, pkt
->entry_status
));
769 ((response_t
*)pkt
)->signature
= RESPONSE_PROCESSED
;
773 /* Adjust ring index */
774 WRT_REG_WORD(ISP_RSP_Q_OUT(ha
, reg
), ha
->rsp_ring_index
);
778 * qla2x00_status_entry() - Process a Status IOCB entry.
779 * @ha: SCSI driver HA context
780 * @pkt: Entry pointer
783 qla2x00_status_entry(scsi_qla_host_t
*ha
, void *pkt
)
787 struct scsi_cmnd
*cp
;
789 struct sts_entry_24xx
*sts24
;
790 uint16_t comp_status
;
791 uint16_t scsi_status
;
792 uint8_t lscsi_status
;
794 uint32_t sense_len
, rsp_info_len
, resid_len
, fw_resid_len
;
795 uint8_t *rsp_info
, *sense_data
;
797 sts
= (sts_entry_t
*) pkt
;
798 sts24
= (struct sts_entry_24xx
*) pkt
;
799 if (IS_QLA24XX(ha
) || IS_QLA54XX(ha
)) {
800 comp_status
= le16_to_cpu(sts24
->comp_status
);
801 scsi_status
= le16_to_cpu(sts24
->scsi_status
) & SS_MASK
;
803 comp_status
= le16_to_cpu(sts
->comp_status
);
804 scsi_status
= le16_to_cpu(sts
->scsi_status
) & SS_MASK
;
807 /* Fast path completion. */
808 if (comp_status
== CS_COMPLETE
&& scsi_status
== 0) {
809 qla2x00_process_completed_request(ha
, sts
->handle
);
814 /* Validate handle. */
815 if (sts
->handle
< MAX_OUTSTANDING_COMMANDS
) {
816 sp
= ha
->outstanding_cmds
[sts
->handle
];
817 ha
->outstanding_cmds
[sts
->handle
] = NULL
;
822 DEBUG2(printk("scsi(%ld): Status Entry invalid handle.\n",
824 qla_printk(KERN_WARNING
, ha
, "Status Entry invalid handle.\n");
826 set_bit(ISP_ABORT_NEEDED
, &ha
->dpc_flags
);
827 qla2xxx_wake_dpc(ha
);
832 DEBUG2(printk("scsi(%ld): Command already returned back to OS "
833 "pkt->handle=%d sp=%p.\n", ha
->host_no
, sts
->handle
, sp
));
834 qla_printk(KERN_WARNING
, ha
,
835 "Command is NULL: already returned to OS (sp=%p)\n", sp
);
840 lscsi_status
= scsi_status
& STATUS_MASK
;
841 CMD_ENTRY_STATUS(cp
) = sts
->entry_status
;
842 CMD_COMPL_STATUS(cp
) = comp_status
;
843 CMD_SCSI_STATUS(cp
) = scsi_status
;
847 sense_len
= rsp_info_len
= resid_len
= fw_resid_len
= 0;
848 if (IS_QLA24XX(ha
) || IS_QLA54XX(ha
)) {
849 sense_len
= le32_to_cpu(sts24
->sense_len
);
850 rsp_info_len
= le32_to_cpu(sts24
->rsp_data_len
);
851 resid_len
= le32_to_cpu(sts24
->rsp_residual_count
);
852 fw_resid_len
= le32_to_cpu(sts24
->residual_len
);
853 rsp_info
= sts24
->data
;
854 sense_data
= sts24
->data
;
855 host_to_fcp_swap(sts24
->data
, sizeof(sts24
->data
));
857 sense_len
= le16_to_cpu(sts
->req_sense_length
);
858 rsp_info_len
= le16_to_cpu(sts
->rsp_info_len
);
859 resid_len
= le32_to_cpu(sts
->residual_length
);
860 rsp_info
= sts
->rsp_info
;
861 sense_data
= sts
->req_sense_data
;
864 /* Check for any FCP transport errors. */
865 if (scsi_status
& SS_RESPONSE_INFO_LEN_VALID
) {
866 /* Sense data lies beyond any FCP RESPONSE data. */
867 if (IS_QLA24XX(ha
) || IS_QLA54XX(ha
))
868 sense_data
+= rsp_info_len
;
869 if (rsp_info_len
> 3 && rsp_info
[3]) {
870 DEBUG2(printk("scsi(%ld:%d:%d:%d) FCP I/O protocol "
871 "failure (%x/%02x%02x%02x%02x%02x%02x%02x%02x)..."
872 "retrying command\n", ha
->host_no
,
873 cp
->device
->channel
, cp
->device
->id
,
874 cp
->device
->lun
, rsp_info_len
, rsp_info
[0],
875 rsp_info
[1], rsp_info
[2], rsp_info
[3], rsp_info
[4],
876 rsp_info
[5], rsp_info
[6], rsp_info
[7]));
878 cp
->result
= DID_BUS_BUSY
<< 16;
879 qla2x00_sp_compl(ha
, sp
);
885 * Based on Host and scsi status generate status code for Linux
887 switch (comp_status
) {
890 if (scsi_status
== 0) {
891 cp
->result
= DID_OK
<< 16;
894 if (scsi_status
& (SS_RESIDUAL_UNDER
| SS_RESIDUAL_OVER
)) {
897 CMD_RESID_LEN(cp
) = resid
;
900 ((unsigned)(cp
->request_bufflen
- resid
) <
902 qla_printk(KERN_INFO
, ha
,
903 "scsi(%ld:%d:%d:%d): Mid-layer underflow "
904 "detected (%x of %x bytes)...returning "
905 "error status.\n", ha
->host_no
,
906 cp
->device
->channel
, cp
->device
->id
,
907 cp
->device
->lun
, resid
,
908 cp
->request_bufflen
);
910 cp
->result
= DID_ERROR
<< 16;
914 cp
->result
= DID_OK
<< 16 | lscsi_status
;
916 if (lscsi_status
== SAM_STAT_TASK_SET_FULL
) {
917 DEBUG2(printk(KERN_INFO
918 "scsi(%ld): QUEUE FULL status detected "
919 "0x%x-0x%x.\n", ha
->host_no
, comp_status
,
922 /* Adjust queue depth for all luns on the port. */
923 fcport
->last_queue_full
= jiffies
;
924 starget_for_each_device(cp
->device
->sdev_target
,
925 fcport
, qla2x00_adjust_sdev_qdepth_down
);
928 if (lscsi_status
!= SS_CHECK_CONDITION
)
931 /* Copy Sense Data into sense buffer. */
932 memset(cp
->sense_buffer
, 0, sizeof(cp
->sense_buffer
));
934 if (!(scsi_status
& SS_SENSE_LEN_VALID
))
937 if (sense_len
>= sizeof(cp
->sense_buffer
))
938 sense_len
= sizeof(cp
->sense_buffer
);
940 CMD_ACTUAL_SNSLEN(cp
) = sense_len
;
941 sp
->request_sense_length
= sense_len
;
942 sp
->request_sense_ptr
= cp
->sense_buffer
;
944 if (sp
->request_sense_length
> 32)
947 memcpy(cp
->sense_buffer
, sense_data
, sense_len
);
949 sp
->request_sense_ptr
+= sense_len
;
950 sp
->request_sense_length
-= sense_len
;
951 if (sp
->request_sense_length
!= 0)
954 DEBUG5(printk("%s(): Check condition Sense data, "
955 "scsi(%ld:%d:%d:%d) cmd=%p pid=%ld\n", __func__
,
956 ha
->host_no
, cp
->device
->channel
, cp
->device
->id
,
957 cp
->device
->lun
, cp
, cp
->serial_number
));
959 DEBUG5(qla2x00_dump_buffer(cp
->sense_buffer
,
960 CMD_ACTUAL_SNSLEN(cp
)));
963 case CS_DATA_UNDERRUN
:
965 /* Use F/W calculated residual length. */
966 if (IS_QLA24XX(ha
) || IS_QLA54XX(ha
))
967 resid
= fw_resid_len
;
969 if (scsi_status
& SS_RESIDUAL_UNDER
) {
971 CMD_RESID_LEN(cp
) = resid
;
973 DEBUG2(printk(KERN_INFO
974 "scsi(%ld:%d:%d) UNDERRUN status detected "
975 "0x%x-0x%x. resid=0x%x fw_resid=0x%x cdb=0x%x "
976 "os_underflow=0x%x\n", ha
->host_no
,
977 cp
->device
->id
, cp
->device
->lun
, comp_status
,
978 scsi_status
, resid_len
, resid
, cp
->cmnd
[0],
984 * Check to see if SCSI Status is non zero. If so report SCSI
987 if (lscsi_status
!= 0) {
988 cp
->result
= DID_OK
<< 16 | lscsi_status
;
990 if (lscsi_status
!= SS_CHECK_CONDITION
)
993 /* Copy Sense Data into sense buffer */
994 memset(cp
->sense_buffer
, 0, sizeof(cp
->sense_buffer
));
996 if (!(scsi_status
& SS_SENSE_LEN_VALID
))
999 if (sense_len
>= sizeof(cp
->sense_buffer
))
1000 sense_len
= sizeof(cp
->sense_buffer
);
1002 CMD_ACTUAL_SNSLEN(cp
) = sense_len
;
1003 sp
->request_sense_length
= sense_len
;
1004 sp
->request_sense_ptr
= cp
->sense_buffer
;
1006 if (sp
->request_sense_length
> 32)
1009 memcpy(cp
->sense_buffer
, sense_data
, sense_len
);
1011 sp
->request_sense_ptr
+= sense_len
;
1012 sp
->request_sense_length
-= sense_len
;
1013 if (sp
->request_sense_length
!= 0)
1014 ha
->status_srb
= sp
;
1016 DEBUG5(printk("%s(): Check condition Sense data, "
1017 "scsi(%ld:%d:%d:%d) cmd=%p pid=%ld\n",
1018 __func__
, ha
->host_no
, cp
->device
->channel
,
1019 cp
->device
->id
, cp
->device
->lun
, cp
,
1020 cp
->serial_number
));
1023 DEBUG5(qla2x00_dump_buffer(cp
->sense_buffer
,
1024 CMD_ACTUAL_SNSLEN(cp
)));
1027 * If RISC reports underrun and target does not report
1028 * it then we must have a lost frame, so tell upper
1029 * layer to retry it by reporting a bus busy.
1031 if (!(scsi_status
& SS_RESIDUAL_UNDER
)) {
1032 DEBUG2(printk("scsi(%ld:%d:%d:%d) Dropped "
1033 "frame(s) detected (%x of %x bytes)..."
1034 "retrying command.\n", ha
->host_no
,
1035 cp
->device
->channel
, cp
->device
->id
,
1036 cp
->device
->lun
, resid
,
1037 cp
->request_bufflen
));
1039 cp
->result
= DID_BUS_BUSY
<< 16;
1043 /* Handle mid-layer underflow */
1044 if ((unsigned)(cp
->request_bufflen
- resid
) <
1046 qla_printk(KERN_INFO
, ha
,
1047 "scsi(%ld:%d:%d:%d): Mid-layer underflow "
1048 "detected (%x of %x bytes)...returning "
1049 "error status.\n", ha
->host_no
,
1050 cp
->device
->channel
, cp
->device
->id
,
1051 cp
->device
->lun
, resid
,
1052 cp
->request_bufflen
);
1054 cp
->result
= DID_ERROR
<< 16;
1058 /* Everybody online, looking good... */
1059 cp
->result
= DID_OK
<< 16;
1063 case CS_DATA_OVERRUN
:
1064 DEBUG2(printk(KERN_INFO
1065 "scsi(%ld:%d:%d): OVERRUN status detected 0x%x-0x%x\n",
1066 ha
->host_no
, cp
->device
->id
, cp
->device
->lun
, comp_status
,
1068 DEBUG2(printk(KERN_INFO
1069 "CDB: 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x\n",
1070 cp
->cmnd
[0], cp
->cmnd
[1], cp
->cmnd
[2], cp
->cmnd
[3],
1071 cp
->cmnd
[4], cp
->cmnd
[5]));
1072 DEBUG2(printk(KERN_INFO
1073 "PID=0x%lx req=0x%x xtra=0x%x -- returning DID_ERROR "
1075 cp
->serial_number
, cp
->request_bufflen
, resid_len
));
1077 cp
->result
= DID_ERROR
<< 16;
1080 case CS_PORT_LOGGED_OUT
:
1081 case CS_PORT_CONFIG_CHG
:
1084 case CS_PORT_UNAVAILABLE
:
1086 * If the port is in Target Down state, return all IOs for this
1087 * Target with DID_NO_CONNECT ELSE Queue the IOs in the
1090 DEBUG2(printk("scsi(%ld:%d:%d): status_entry: Port Down "
1091 "pid=%ld, compl status=0x%x, port state=0x%x\n",
1092 ha
->host_no
, cp
->device
->id
, cp
->device
->lun
,
1093 cp
->serial_number
, comp_status
,
1094 atomic_read(&fcport
->state
)));
1096 cp
->result
= DID_BUS_BUSY
<< 16;
1097 if (atomic_read(&fcport
->state
) == FCS_ONLINE
) {
1098 qla2x00_mark_device_lost(ha
, fcport
, 1, 1);
1103 DEBUG2(printk(KERN_INFO
1104 "scsi(%ld): RESET status detected 0x%x-0x%x.\n",
1105 ha
->host_no
, comp_status
, scsi_status
));
1107 cp
->result
= DID_RESET
<< 16;
1112 * hv2.19.12 - DID_ABORT does not retry the request if we
1113 * aborted this request then abort otherwise it must be a
1116 DEBUG2(printk(KERN_INFO
1117 "scsi(%ld): ABORT status detected 0x%x-0x%x.\n",
1118 ha
->host_no
, comp_status
, scsi_status
));
1120 cp
->result
= DID_RESET
<< 16;
1124 cp
->result
= DID_BUS_BUSY
<< 16;
1126 if (IS_QLA24XX(ha
) || IS_QLA54XX(ha
)) {
1127 DEBUG2(printk(KERN_INFO
1128 "scsi(%ld:%d:%d:%d): TIMEOUT status detected "
1129 "0x%x-0x%x\n", ha
->host_no
, cp
->device
->channel
,
1130 cp
->device
->id
, cp
->device
->lun
, comp_status
,
1134 DEBUG2(printk(KERN_INFO
1135 "scsi(%ld:%d:%d:%d): TIMEOUT status detected 0x%x-0x%x "
1136 "sflags=%x.\n", ha
->host_no
, cp
->device
->channel
,
1137 cp
->device
->id
, cp
->device
->lun
, comp_status
, scsi_status
,
1138 le16_to_cpu(sts
->status_flags
)));
1140 /* Check to see if logout occurred. */
1141 if ((le16_to_cpu(sts
->status_flags
) & SF_LOGOUT_SENT
))
1142 qla2x00_mark_device_lost(ha
, fcport
, 1, 1);
1146 DEBUG3(printk("scsi(%ld): Error detected (unknown status) "
1147 "0x%x-0x%x.\n", ha
->host_no
, comp_status
, scsi_status
));
1148 qla_printk(KERN_INFO
, ha
,
1149 "Unknown status detected 0x%x-0x%x.\n",
1150 comp_status
, scsi_status
);
1152 cp
->result
= DID_ERROR
<< 16;
1156 /* Place command on done queue. */
1157 if (ha
->status_srb
== NULL
)
1158 qla2x00_sp_compl(ha
, sp
);
1162 * qla2x00_status_cont_entry() - Process a Status Continuations entry.
1163 * @ha: SCSI driver HA context
1164 * @pkt: Entry pointer
1166 * Extended sense data.
1169 qla2x00_status_cont_entry(scsi_qla_host_t
*ha
, sts_cont_entry_t
*pkt
)
1171 uint8_t sense_sz
= 0;
1172 srb_t
*sp
= ha
->status_srb
;
1173 struct scsi_cmnd
*cp
;
1175 if (sp
!= NULL
&& sp
->request_sense_length
!= 0) {
1178 DEBUG2(printk("%s(): Cmd already returned back to OS "
1179 "sp=%p.\n", __func__
, sp
));
1180 qla_printk(KERN_INFO
, ha
,
1181 "cmd is NULL: already returned to OS (sp=%p)\n",
1184 ha
->status_srb
= NULL
;
1188 if (sp
->request_sense_length
> sizeof(pkt
->data
)) {
1189 sense_sz
= sizeof(pkt
->data
);
1191 sense_sz
= sp
->request_sense_length
;
1194 /* Move sense data. */
1195 if (IS_QLA24XX(ha
) || IS_QLA54XX(ha
))
1196 host_to_fcp_swap(pkt
->data
, sizeof(pkt
->data
));
1197 memcpy(sp
->request_sense_ptr
, pkt
->data
, sense_sz
);
1198 DEBUG5(qla2x00_dump_buffer(sp
->request_sense_ptr
, sense_sz
));
1200 sp
->request_sense_ptr
+= sense_sz
;
1201 sp
->request_sense_length
-= sense_sz
;
1203 /* Place command on done queue. */
1204 if (sp
->request_sense_length
== 0) {
1205 ha
->status_srb
= NULL
;
1206 qla2x00_sp_compl(ha
, sp
);
1212 * qla2x00_error_entry() - Process an error entry.
1213 * @ha: SCSI driver HA context
1214 * @pkt: Entry pointer
1217 qla2x00_error_entry(scsi_qla_host_t
*ha
, sts_entry_t
*pkt
)
1221 #if defined(QL_DEBUG_LEVEL_2)
1222 if (pkt
->entry_status
& RF_INV_E_ORDER
)
1223 qla_printk(KERN_ERR
, ha
, "%s: Invalid Entry Order\n", __func__
);
1224 else if (pkt
->entry_status
& RF_INV_E_COUNT
)
1225 qla_printk(KERN_ERR
, ha
, "%s: Invalid Entry Count\n", __func__
);
1226 else if (pkt
->entry_status
& RF_INV_E_PARAM
)
1227 qla_printk(KERN_ERR
, ha
,
1228 "%s: Invalid Entry Parameter\n", __func__
);
1229 else if (pkt
->entry_status
& RF_INV_E_TYPE
)
1230 qla_printk(KERN_ERR
, ha
, "%s: Invalid Entry Type\n", __func__
);
1231 else if (pkt
->entry_status
& RF_BUSY
)
1232 qla_printk(KERN_ERR
, ha
, "%s: Busy\n", __func__
);
1234 qla_printk(KERN_ERR
, ha
, "%s: UNKNOWN flag error\n", __func__
);
1237 /* Validate handle. */
1238 if (pkt
->handle
< MAX_OUTSTANDING_COMMANDS
)
1239 sp
= ha
->outstanding_cmds
[pkt
->handle
];
1244 /* Free outstanding command slot. */
1245 ha
->outstanding_cmds
[pkt
->handle
] = NULL
;
1247 /* Bad payload or header */
1248 if (pkt
->entry_status
&
1249 (RF_INV_E_ORDER
| RF_INV_E_COUNT
|
1250 RF_INV_E_PARAM
| RF_INV_E_TYPE
)) {
1251 sp
->cmd
->result
= DID_ERROR
<< 16;
1252 } else if (pkt
->entry_status
& RF_BUSY
) {
1253 sp
->cmd
->result
= DID_BUS_BUSY
<< 16;
1255 sp
->cmd
->result
= DID_ERROR
<< 16;
1257 qla2x00_sp_compl(ha
, sp
);
1259 } else if (pkt
->entry_type
== COMMAND_A64_TYPE
|| pkt
->entry_type
==
1260 COMMAND_TYPE
|| pkt
->entry_type
== COMMAND_TYPE_7
) {
1261 DEBUG2(printk("scsi(%ld): Error entry - invalid handle\n",
1263 qla_printk(KERN_WARNING
, ha
,
1264 "Error entry - invalid handle\n");
1266 set_bit(ISP_ABORT_NEEDED
, &ha
->dpc_flags
);
1267 qla2xxx_wake_dpc(ha
);
1272 * qla2x00_ms_entry() - Process a Management Server entry.
1273 * @ha: SCSI driver HA context
1274 * @index: Response queue out pointer
1277 qla2x00_ms_entry(scsi_qla_host_t
*ha
, ms_iocb_entry_t
*pkt
)
1281 DEBUG3(printk("%s(%ld): pkt=%p pkthandle=%d.\n",
1282 __func__
, ha
->host_no
, pkt
, pkt
->handle1
));
1284 /* Validate handle. */
1285 if (pkt
->handle1
< MAX_OUTSTANDING_COMMANDS
)
1286 sp
= ha
->outstanding_cmds
[pkt
->handle1
];
1291 DEBUG2(printk("scsi(%ld): MS entry - invalid handle\n",
1293 qla_printk(KERN_WARNING
, ha
, "MS entry - invalid handle\n");
1295 set_bit(ISP_ABORT_NEEDED
, &ha
->dpc_flags
);
1299 CMD_COMPL_STATUS(sp
->cmd
) = le16_to_cpu(pkt
->status
);
1300 CMD_ENTRY_STATUS(sp
->cmd
) = pkt
->entry_status
;
1302 /* Free outstanding command slot. */
1303 ha
->outstanding_cmds
[pkt
->handle1
] = NULL
;
1305 qla2x00_sp_compl(ha
, sp
);
1310 * qla24xx_mbx_completion() - Process mailbox command completions.
1311 * @ha: SCSI driver HA context
1312 * @mb0: Mailbox0 register
1315 qla24xx_mbx_completion(scsi_qla_host_t
*ha
, uint16_t mb0
)
1318 uint16_t __iomem
*wptr
;
1319 struct device_reg_24xx __iomem
*reg
= &ha
->iobase
->isp24
;
1321 /* Load return mailbox registers. */
1322 ha
->flags
.mbox_int
= 1;
1323 ha
->mailbox_out
[0] = mb0
;
1324 wptr
= (uint16_t __iomem
*)®
->mailbox1
;
1326 for (cnt
= 1; cnt
< ha
->mbx_count
; cnt
++) {
1327 ha
->mailbox_out
[cnt
] = RD_REG_WORD(wptr
);
1332 DEBUG3(printk("%s(%ld): Got mailbox completion. cmd=%x.\n",
1333 __func__
, ha
->host_no
, ha
->mcp
->mb
[0]));
1335 DEBUG2_3(printk("%s(%ld): MBX pointer ERROR!\n",
1336 __func__
, ha
->host_no
));
1341 * qla24xx_process_response_queue() - Process response queue entries.
1342 * @ha: SCSI driver HA context
1345 qla24xx_process_response_queue(struct scsi_qla_host
*ha
)
1347 struct device_reg_24xx __iomem
*reg
= &ha
->iobase
->isp24
;
1348 struct sts_entry_24xx
*pkt
;
1350 if (!ha
->flags
.online
)
1353 while (ha
->response_ring_ptr
->signature
!= RESPONSE_PROCESSED
) {
1354 pkt
= (struct sts_entry_24xx
*)ha
->response_ring_ptr
;
1356 ha
->rsp_ring_index
++;
1357 if (ha
->rsp_ring_index
== ha
->response_q_length
) {
1358 ha
->rsp_ring_index
= 0;
1359 ha
->response_ring_ptr
= ha
->response_ring
;
1361 ha
->response_ring_ptr
++;
1364 if (pkt
->entry_status
!= 0) {
1365 DEBUG3(printk(KERN_INFO
1366 "scsi(%ld): Process error entry.\n", ha
->host_no
));
1368 qla2x00_error_entry(ha
, (sts_entry_t
*) pkt
);
1369 ((response_t
*)pkt
)->signature
= RESPONSE_PROCESSED
;
1374 switch (pkt
->entry_type
) {
1376 qla2x00_status_entry(ha
, pkt
);
1378 case STATUS_CONT_TYPE
:
1379 qla2x00_status_cont_entry(ha
, (sts_cont_entry_t
*)pkt
);
1382 qla24xx_ms_entry(ha
, (struct ct_entry_24xx
*)pkt
);
1385 /* Type Not Supported. */
1386 DEBUG4(printk(KERN_WARNING
1387 "scsi(%ld): Received unknown response pkt type %x "
1388 "entry status=%x.\n",
1389 ha
->host_no
, pkt
->entry_type
, pkt
->entry_status
));
1392 ((response_t
*)pkt
)->signature
= RESPONSE_PROCESSED
;
1396 /* Adjust ring index */
1397 WRT_REG_DWORD(®
->rsp_q_out
, ha
->rsp_ring_index
);
1401 * qla24xx_intr_handler() - Process interrupts for the ISP23xx and ISP63xx.
1403 * @dev_id: SCSI driver HA context
1405 * Called by system whenever the host adapter generates an interrupt.
1407 * Returns handled flag.
1410 qla24xx_intr_handler(int irq
, void *dev_id
)
1412 scsi_qla_host_t
*ha
;
1413 struct device_reg_24xx __iomem
*reg
;
1415 unsigned long flags
;
1421 ha
= (scsi_qla_host_t
*) dev_id
;
1424 "%s(): NULL host pointer\n", __func__
);
1428 reg
= &ha
->iobase
->isp24
;
1431 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
1432 for (iter
= 50; iter
--; ) {
1433 stat
= RD_REG_DWORD(®
->host_status
);
1434 if (stat
& HSRX_RISC_PAUSED
) {
1435 hccr
= RD_REG_DWORD(®
->hccr
);
1437 qla_printk(KERN_INFO
, ha
, "RISC paused -- HCCR=%x, "
1438 "Dumping firmware!\n", hccr
);
1439 qla24xx_fw_dump(ha
, 1);
1441 set_bit(ISP_ABORT_NEEDED
, &ha
->dpc_flags
);
1443 } else if ((stat
& HSRX_RISC_INT
) == 0)
1446 switch (stat
& 0xff) {
1451 qla24xx_mbx_completion(ha
, MSW(stat
));
1452 status
|= MBX_INTERRUPT
;
1457 mb
[1] = RD_REG_WORD(®
->mailbox1
);
1458 mb
[2] = RD_REG_WORD(®
->mailbox2
);
1459 mb
[3] = RD_REG_WORD(®
->mailbox3
);
1460 qla2x00_async_event(ha
, mb
);
1463 qla24xx_process_response_queue(ha
);
1466 DEBUG2(printk("scsi(%ld): Unrecognized interrupt type "
1468 ha
->host_no
, stat
& 0xff));
1471 WRT_REG_DWORD(®
->hccr
, HCCRX_CLR_RISC_INT
);
1472 RD_REG_DWORD_RELAXED(®
->hccr
);
1474 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
1476 if (test_bit(MBX_INTR_WAIT
, &ha
->mbx_cmd_flags
) &&
1477 (status
& MBX_INTERRUPT
) && ha
->flags
.mbox_int
) {
1478 spin_lock_irqsave(&ha
->mbx_reg_lock
, flags
);
1480 set_bit(MBX_INTERRUPT
, &ha
->mbx_cmd_flags
);
1481 up(&ha
->mbx_intr_sem
);
1483 spin_unlock_irqrestore(&ha
->mbx_reg_lock
, flags
);
1490 * qla24xx_ms_entry() - Process a Management Server entry.
1491 * @ha: SCSI driver HA context
1492 * @index: Response queue out pointer
1495 qla24xx_ms_entry(scsi_qla_host_t
*ha
, struct ct_entry_24xx
*pkt
)
1499 DEBUG3(printk("%s(%ld): pkt=%p pkthandle=%d.\n",
1500 __func__
, ha
->host_no
, pkt
, pkt
->handle
));
1502 DEBUG9(printk("%s: ct pkt dump:\n", __func__
));
1503 DEBUG9(qla2x00_dump_buffer((void *)pkt
, sizeof(struct ct_entry_24xx
)));
1505 /* Validate handle. */
1506 if (pkt
->handle
< MAX_OUTSTANDING_COMMANDS
)
1507 sp
= ha
->outstanding_cmds
[pkt
->handle
];
1512 DEBUG2(printk("scsi(%ld): MS entry - invalid handle\n",
1514 DEBUG10(printk("scsi(%ld): MS entry - invalid handle\n",
1516 qla_printk(KERN_WARNING
, ha
, "MS entry - invalid handle %d\n",
1519 set_bit(ISP_ABORT_NEEDED
, &ha
->dpc_flags
);
1523 CMD_COMPL_STATUS(sp
->cmd
) = le16_to_cpu(pkt
->comp_status
);
1524 CMD_ENTRY_STATUS(sp
->cmd
) = pkt
->entry_status
;
1526 /* Free outstanding command slot. */
1527 ha
->outstanding_cmds
[pkt
->handle
] = NULL
;
1529 qla2x00_sp_compl(ha
, sp
);
1533 qla24xx_msix_rsp_q(int irq
, void *dev_id
)
1535 scsi_qla_host_t
*ha
;
1536 struct device_reg_24xx __iomem
*reg
;
1537 unsigned long flags
;
1540 reg
= &ha
->iobase
->isp24
;
1542 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
1544 qla24xx_process_response_queue(ha
);
1546 WRT_REG_DWORD(®
->hccr
, HCCRX_CLR_RISC_INT
);
1547 RD_REG_DWORD_RELAXED(®
->hccr
);
1549 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
1555 qla24xx_msix_default(int irq
, void *dev_id
)
1557 scsi_qla_host_t
*ha
;
1558 struct device_reg_24xx __iomem
*reg
;
1560 unsigned long flags
;
1567 reg
= &ha
->iobase
->isp24
;
1570 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
1571 for (iter
= 50; iter
--; ) {
1572 stat
= RD_REG_DWORD(®
->host_status
);
1573 if (stat
& HSRX_RISC_PAUSED
) {
1574 hccr
= RD_REG_DWORD(®
->hccr
);
1576 qla_printk(KERN_INFO
, ha
, "RISC paused -- HCCR=%x, "
1577 "Dumping firmware!\n", hccr
);
1578 ha
->isp_ops
.fw_dump(ha
, 1);
1579 set_bit(ISP_ABORT_NEEDED
, &ha
->dpc_flags
);
1581 } else if ((stat
& HSRX_RISC_INT
) == 0)
1584 switch (stat
& 0xff) {
1589 qla24xx_mbx_completion(ha
, MSW(stat
));
1590 status
|= MBX_INTERRUPT
;
1595 mb
[1] = RD_REG_WORD(®
->mailbox1
);
1596 mb
[2] = RD_REG_WORD(®
->mailbox2
);
1597 mb
[3] = RD_REG_WORD(®
->mailbox3
);
1598 qla2x00_async_event(ha
, mb
);
1601 qla24xx_process_response_queue(ha
);
1604 DEBUG2(printk("scsi(%ld): Unrecognized interrupt type "
1606 ha
->host_no
, stat
& 0xff));
1609 WRT_REG_DWORD(®
->hccr
, HCCRX_CLR_RISC_INT
);
1610 RD_REG_DWORD_RELAXED(®
->hccr
);
1612 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
1614 if (test_bit(MBX_INTR_WAIT
, &ha
->mbx_cmd_flags
) &&
1615 (status
& MBX_INTERRUPT
) && ha
->flags
.mbox_int
) {
1616 spin_lock_irqsave(&ha
->mbx_reg_lock
, flags
);
1618 set_bit(MBX_INTERRUPT
, &ha
->mbx_cmd_flags
);
1619 up(&ha
->mbx_intr_sem
);
1621 spin_unlock_irqrestore(&ha
->mbx_reg_lock
, flags
);
1627 /* Interrupt handling helpers. */
1629 struct qla_init_msix_entry
{
1633 irqreturn_t (*handler
)(int, void *);
1636 static struct qla_init_msix_entry imsix_entries
[QLA_MSIX_ENTRIES
] = {
1637 { QLA_MSIX_DEFAULT
, QLA_MIDX_DEFAULT
,
1638 "qla2xxx (default)", qla24xx_msix_default
},
1640 { QLA_MSIX_RSP_Q
, QLA_MIDX_RSP_Q
,
1641 "qla2xxx (rsp_q)", qla24xx_msix_rsp_q
},
1645 qla24xx_disable_msix(scsi_qla_host_t
*ha
)
1648 struct qla_msix_entry
*qentry
;
1650 for (i
= 0; i
< QLA_MSIX_ENTRIES
; i
++) {
1651 qentry
= &ha
->msix_entries
[imsix_entries
[i
].index
];
1652 if (qentry
->have_irq
)
1653 free_irq(qentry
->msix_vector
, ha
);
1655 pci_disable_msix(ha
->pdev
);
1659 qla24xx_enable_msix(scsi_qla_host_t
*ha
)
1662 struct msix_entry entries
[QLA_MSIX_ENTRIES
];
1663 struct qla_msix_entry
*qentry
;
1665 for (i
= 0; i
< QLA_MSIX_ENTRIES
; i
++)
1666 entries
[i
].entry
= imsix_entries
[i
].entry
;
1668 ret
= pci_enable_msix(ha
->pdev
, entries
, ARRAY_SIZE(entries
));
1670 qla_printk(KERN_WARNING
, ha
,
1671 "MSI-X: Failed to enable support -- %d/%d\n",
1672 QLA_MSIX_ENTRIES
, ret
);
1675 ha
->flags
.msix_enabled
= 1;
1677 for (i
= 0; i
< QLA_MSIX_ENTRIES
; i
++) {
1678 qentry
= &ha
->msix_entries
[imsix_entries
[i
].index
];
1679 qentry
->msix_vector
= entries
[i
].vector
;
1680 qentry
->msix_entry
= entries
[i
].entry
;
1681 qentry
->have_irq
= 0;
1682 ret
= request_irq(qentry
->msix_vector
,
1683 imsix_entries
[i
].handler
, 0, imsix_entries
[i
].name
, ha
);
1685 qla_printk(KERN_WARNING
, ha
,
1686 "MSI-X: Unable to register handler -- %x/%d.\n",
1687 imsix_entries
[i
].index
, ret
);
1688 qla24xx_disable_msix(ha
);
1691 qentry
->have_irq
= 1;
1699 qla2x00_request_irqs(scsi_qla_host_t
*ha
)
1703 /* If possible, enable MSI-X. */
1704 if (!IS_QLA2432(ha
))
1707 if (ha
->chip_revision
< QLA_MSIX_CHIP_REV_24XX
||
1708 !QLA_MSIX_FW_MODE_1(ha
->fw_attributes
)) {
1709 DEBUG2(qla_printk(KERN_WARNING
, ha
,
1710 "MSI-X: Unsupported ISP2432 (0x%X, 0x%X).\n",
1711 ha
->chip_revision
, ha
->fw_attributes
));
1716 ret
= qla24xx_enable_msix(ha
);
1718 DEBUG2(qla_printk(KERN_INFO
, ha
,
1719 "MSI-X: Enabled (0x%X, 0x%X).\n", ha
->chip_revision
,
1720 ha
->fw_attributes
));
1723 qla_printk(KERN_WARNING
, ha
,
1724 "MSI-X: Falling back-to INTa mode -- %d.\n", ret
);
1726 ret
= request_irq(ha
->pdev
->irq
, ha
->isp_ops
.intr_handler
,
1727 IRQF_DISABLED
|IRQF_SHARED
, QLA2XXX_DRIVER_NAME
, ha
);
1729 ha
->flags
.inta_enabled
= 1;
1730 ha
->host
->irq
= ha
->pdev
->irq
;
1732 qla_printk(KERN_WARNING
, ha
,
1733 "Failed to reserve interrupt %d already in use.\n",
1741 qla2x00_free_irqs(scsi_qla_host_t
*ha
)
1744 if (ha
->flags
.msix_enabled
)
1745 qla24xx_disable_msix(ha
);
1746 else if (ha
->flags
.inta_enabled
)
1747 free_irq(ha
->host
->irq
, ha
);