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 *, 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(&ha->hardware_lock);
51 for (iter = 50; iter--; ) {
52 hccr = RD_REG_WORD(®->hccr);
53 if (hccr & HCCR_RISC_PAUSE) {
54 if (pci_channel_offline(ha->pdev))
58 * Issue a "HARD" reset in order for the RISC interrupt
59 * bit to be cleared. Schedule a big hammmer to get
60 * out of the RISC PAUSED state.
62 WRT_REG_WORD(®->hccr, HCCR_RESET_RISC);
63 RD_REG_WORD(®->hccr);
65 ha->isp_ops->fw_dump(ha, 1);
66 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
68 } else if ((RD_REG_WORD(®->istatus) & ISR_RISC_INT) == 0)
71 if (RD_REG_WORD(®->semaphore) & BIT_0) {
72 WRT_REG_WORD(®->hccr, HCCR_CLR_RISC_INT);
73 RD_REG_WORD(®->hccr);
75 /* Get mailbox data. */
76 mb[0] = RD_MAILBOX_REG(ha, reg, 0);
77 if (mb[0] > 0x3fff && mb[0] < 0x8000) {
78 qla2x00_mbx_completion(ha, mb[0]);
79 status |= MBX_INTERRUPT;
80 } else if (mb[0] > 0x7fff && mb[0] < 0xc000) {
81 mb[1] = RD_MAILBOX_REG(ha, reg, 1);
82 mb[2] = RD_MAILBOX_REG(ha, reg, 2);
83 mb[3] = RD_MAILBOX_REG(ha, reg, 3);
84 qla2x00_async_event(ha, mb);
87 DEBUG2(printk("scsi(%ld): Unrecognized "
88 "interrupt type (%d).\n",
91 /* Release mailbox registers. */
92 WRT_REG_WORD(®->semaphore, 0);
93 RD_REG_WORD(®->semaphore);
95 qla2x00_process_response_queue(ha);
97 WRT_REG_WORD(®->hccr, HCCR_CLR_RISC_INT);
98 RD_REG_WORD(®->hccr);
101 spin_unlock(&ha->hardware_lock);
103 if (test_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags) &&
104 (status & MBX_INTERRUPT) && ha->flags.mbox_int) {
105 set_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
106 complete(&ha->mbx_intr_comp);
109 return (IRQ_HANDLED);
113 * qla2300_intr_handler() - Process interrupts for the ISP23xx and ISP63xx.
115 * @dev_id: SCSI driver HA context
117 * Called by system whenever the host adapter generates an interrupt.
119 * Returns handled flag.
122 qla2300_intr_handler(int irq, void *dev_id)
125 struct device_reg_2xxx __iomem *reg;
132 ha = (scsi_qla_host_t *) dev_id;
135 "%s(): NULL host pointer\n", __func__);
139 reg = &ha->iobase->isp;
142 spin_lock(&ha->hardware_lock);
143 for (iter = 50; iter--; ) {
144 stat = RD_REG_DWORD(®->u.isp2300.host_status);
145 if (stat & HSR_RISC_PAUSED) {
146 if (pci_channel_offline(ha->pdev))
149 hccr = RD_REG_WORD(®->hccr);
150 if (hccr & (BIT_15 | BIT_13 | BIT_11 | BIT_8))
151 qla_printk(KERN_INFO, ha, "Parity error -- "
152 "HCCR=%x, Dumping firmware!\n", hccr);
154 qla_printk(KERN_INFO, ha, "RISC paused -- "
155 "HCCR=%x, Dumping firmware!\n", hccr);
158 * Issue a "HARD" reset in order for the RISC
159 * interrupt bit to be cleared. Schedule a big
160 * hammmer to get out of the RISC PAUSED state.
162 WRT_REG_WORD(®->hccr, HCCR_RESET_RISC);
163 RD_REG_WORD(®->hccr);
165 ha->isp_ops->fw_dump(ha, 1);
166 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
168 } else if ((stat & HSR_RISC_INT) == 0)
171 switch (stat & 0xff) {
176 qla2x00_mbx_completion(ha, MSW(stat));
177 status |= MBX_INTERRUPT;
179 /* Release mailbox registers. */
180 WRT_REG_WORD(®->semaphore, 0);
184 mb[1] = RD_MAILBOX_REG(ha, reg, 1);
185 mb[2] = RD_MAILBOX_REG(ha, reg, 2);
186 mb[3] = RD_MAILBOX_REG(ha, reg, 3);
187 qla2x00_async_event(ha, mb);
190 qla2x00_process_response_queue(ha);
193 mb[0] = MBA_CMPLT_1_16BIT;
195 qla2x00_async_event(ha, mb);
198 mb[0] = MBA_SCSI_COMPLETION;
200 mb[2] = RD_MAILBOX_REG(ha, reg, 2);
201 qla2x00_async_event(ha, mb);
204 DEBUG2(printk("scsi(%ld): Unrecognized interrupt type "
206 ha->host_no, stat & 0xff));
209 WRT_REG_WORD(®->hccr, HCCR_CLR_RISC_INT);
210 RD_REG_WORD_RELAXED(®->hccr);
212 spin_unlock(&ha->hardware_lock);
214 if (test_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags) &&
215 (status & MBX_INTERRUPT) && ha->flags.mbox_int) {
216 set_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
217 complete(&ha->mbx_intr_comp);
220 return (IRQ_HANDLED);
224 * qla2x00_mbx_completion() - Process mailbox command completions.
225 * @ha: SCSI driver HA context
226 * @mb0: Mailbox0 register
229 qla2x00_mbx_completion(scsi_qla_host_t *ha, uint16_t mb0)
232 uint16_t __iomem *wptr;
233 struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
235 /* Load return mailbox registers. */
236 ha->flags.mbox_int = 1;
237 ha->mailbox_out[0] = mb0;
238 wptr = (uint16_t __iomem *)MAILBOX_REG(ha, reg, 1);
240 for (cnt = 1; cnt < ha->mbx_count; cnt++) {
241 if (IS_QLA2200(ha) && cnt == 8)
242 wptr = (uint16_t __iomem *)MAILBOX_REG(ha, reg, 8);
243 if (cnt == 4 || cnt == 5)
244 ha->mailbox_out[cnt] = qla2x00_debounce_register(wptr);
246 ha->mailbox_out[cnt] = RD_REG_WORD(wptr);
252 DEBUG3(printk("%s(%ld): Got mailbox completion. cmd=%x.\n",
253 __func__, ha->host_no, ha->mcp->mb[0]));
255 DEBUG2_3(printk("%s(%ld): MBX pointer ERROR!\n",
256 __func__, ha->host_no));
261 * qla2x00_async_event() - Process aynchronous events.
262 * @ha: SCSI driver HA context
263 * @mb: Mailbox registers (0 - 3)
266 qla2x00_async_event(scsi_qla_host_t *ha, uint16_t *mb)
269 static char *link_speeds[5] = { "1", "2", "?", "4", "8" };
274 struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
275 uint32_t rscn_entry, host_pid;
276 uint8_t rscn_queue_index;
278 /* Setup to process RIO completion. */
281 case MBA_SCSI_COMPLETION:
282 handles[0] = le32_to_cpu((uint32_t)((mb[2] << 16) | mb[1]));
285 case MBA_CMPLT_1_16BIT:
288 mb[0] = MBA_SCSI_COMPLETION;
290 case MBA_CMPLT_2_16BIT:
294 mb[0] = MBA_SCSI_COMPLETION;
296 case MBA_CMPLT_3_16BIT:
301 mb[0] = MBA_SCSI_COMPLETION;
303 case MBA_CMPLT_4_16BIT:
307 handles[3] = (uint32_t)RD_MAILBOX_REG(ha, reg, 6);
309 mb[0] = MBA_SCSI_COMPLETION;
311 case MBA_CMPLT_5_16BIT:
315 handles[3] = (uint32_t)RD_MAILBOX_REG(ha, reg, 6);
316 handles[4] = (uint32_t)RD_MAILBOX_REG(ha, reg, 7);
318 mb[0] = MBA_SCSI_COMPLETION;
320 case MBA_CMPLT_2_32BIT:
321 handles[0] = le32_to_cpu((uint32_t)((mb[2] << 16) | mb[1]));
322 handles[1] = le32_to_cpu(
323 ((uint32_t)(RD_MAILBOX_REG(ha, reg, 7) << 16)) |
324 RD_MAILBOX_REG(ha, reg, 6));
326 mb[0] = MBA_SCSI_COMPLETION;
333 case MBA_SCSI_COMPLETION: /* Fast Post */
334 if (!ha->flags.online)
337 for (cnt = 0; cnt < handle_cnt; cnt++)
338 qla2x00_process_completed_request(ha, handles[cnt]);
341 case MBA_RESET: /* Reset */
342 DEBUG2(printk("scsi(%ld): Asynchronous RESET.\n", ha->host_no));
344 set_bit(RESET_MARKER_NEEDED, &ha->dpc_flags);
347 case MBA_SYSTEM_ERR: /* System Error */
348 qla_printk(KERN_INFO, ha,
349 "ISP System Error - mbx1=%xh mbx2=%xh mbx3=%xh.\n",
350 mb[1], mb[2], mb[3]);
352 ha->isp_ops->fw_dump(ha, 1);
354 if (IS_FWI2_CAPABLE(ha)) {
355 if (mb[1] == 0 && mb[2] == 0) {
356 qla_printk(KERN_ERR, ha,
357 "Unrecoverable Hardware Error: adapter "
358 "marked OFFLINE!\n");
359 ha->flags.online = 0;
361 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
362 } else if (mb[1] == 0) {
363 qla_printk(KERN_INFO, ha,
364 "Unrecoverable Hardware Error: adapter marked "
366 ha->flags.online = 0;
368 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
371 case MBA_REQ_TRANSFER_ERR: /* Request Transfer Error */
372 DEBUG2(printk("scsi(%ld): ISP Request Transfer Error.\n",
374 qla_printk(KERN_WARNING, ha, "ISP Request Transfer Error.\n");
376 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
379 case MBA_RSP_TRANSFER_ERR: /* Response Transfer Error */
380 DEBUG2(printk("scsi(%ld): ISP Response Transfer Error.\n",
382 qla_printk(KERN_WARNING, ha, "ISP Response Transfer Error.\n");
384 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
387 case MBA_WAKEUP_THRES: /* Request Queue Wake-up */
388 DEBUG2(printk("scsi(%ld): Asynchronous WAKEUP_THRES.\n",
392 case MBA_LIP_OCCURRED: /* Loop Initialization Procedure */
393 DEBUG2(printk("scsi(%ld): LIP occured (%x).\n", ha->host_no,
395 qla_printk(KERN_INFO, ha, "LIP occured (%x).\n", mb[1]);
397 if (atomic_read(&ha->loop_state) != LOOP_DOWN) {
398 atomic_set(&ha->loop_state, LOOP_DOWN);
399 atomic_set(&ha->loop_down_timer, LOOP_DOWN_TIME);
400 qla2x00_mark_all_devices_lost(ha, 1);
404 atomic_set(&ha->vp_state, VP_FAILED);
405 fc_vport_set_state(ha->fc_vport, FC_VPORT_FAILED);
408 set_bit(REGISTER_FC4_NEEDED, &ha->dpc_flags);
410 ha->flags.management_server_logged_in = 0;
411 qla2x00_post_aen_work(ha, FCH_EVT_LIP, mb[1]);
414 case MBA_LOOP_UP: /* Loop Up Event */
415 if (IS_QLA2100(ha) || IS_QLA2200(ha)) {
416 link_speed = link_speeds[0];
417 ha->link_data_rate = PORT_SPEED_1GB;
419 link_speed = link_speeds[LS_UNKNOWN];
421 link_speed = link_speeds[mb[1]];
422 ha->link_data_rate = mb[1];
425 DEBUG2(printk("scsi(%ld): Asynchronous LOOP UP (%s Gbps).\n",
426 ha->host_no, link_speed));
427 qla_printk(KERN_INFO, ha, "LOOP UP detected (%s Gbps).\n",
430 ha->flags.management_server_logged_in = 0;
431 qla2x00_post_aen_work(ha, FCH_EVT_LINKUP, ha->link_data_rate);
434 case MBA_LOOP_DOWN: /* Loop Down Event */
435 DEBUG2(printk("scsi(%ld): Asynchronous LOOP DOWN (%x).\n",
436 ha->host_no, mb[1]));
437 qla_printk(KERN_INFO, ha, "LOOP DOWN detected (%x).\n", mb[1]);
439 if (atomic_read(&ha->loop_state) != LOOP_DOWN) {
440 atomic_set(&ha->loop_state, LOOP_DOWN);
441 atomic_set(&ha->loop_down_timer, LOOP_DOWN_TIME);
442 ha->device_flags |= DFLG_NO_CABLE;
443 qla2x00_mark_all_devices_lost(ha, 1);
447 atomic_set(&ha->vp_state, VP_FAILED);
448 fc_vport_set_state(ha->fc_vport, FC_VPORT_FAILED);
451 ha->flags.management_server_logged_in = 0;
452 ha->link_data_rate = PORT_SPEED_UNKNOWN;
454 set_bit(REGISTER_FDMI_NEEDED, &ha->dpc_flags);
455 qla2x00_post_aen_work(ha, FCH_EVT_LINKDOWN, 0);
458 case MBA_LIP_RESET: /* LIP reset occurred */
459 DEBUG2(printk("scsi(%ld): Asynchronous LIP RESET (%x).\n",
460 ha->host_no, mb[1]));
461 qla_printk(KERN_INFO, ha,
462 "LIP reset occured (%x).\n", mb[1]);
464 if (atomic_read(&ha->loop_state) != LOOP_DOWN) {
465 atomic_set(&ha->loop_state, LOOP_DOWN);
466 atomic_set(&ha->loop_down_timer, LOOP_DOWN_TIME);
467 qla2x00_mark_all_devices_lost(ha, 1);
471 atomic_set(&ha->vp_state, VP_FAILED);
472 fc_vport_set_state(ha->fc_vport, FC_VPORT_FAILED);
475 set_bit(RESET_MARKER_NEEDED, &ha->dpc_flags);
477 ha->operating_mode = LOOP;
478 ha->flags.management_server_logged_in = 0;
479 qla2x00_post_aen_work(ha, FCH_EVT_LIPRESET, mb[1]);
482 case MBA_POINT_TO_POINT: /* Point-to-Point */
486 DEBUG2(printk("scsi(%ld): Asynchronous P2P MODE received.\n",
490 * Until there's a transition from loop down to loop up, treat
491 * this as loop down only.
493 if (atomic_read(&ha->loop_state) != LOOP_DOWN) {
494 atomic_set(&ha->loop_state, LOOP_DOWN);
495 if (!atomic_read(&ha->loop_down_timer))
496 atomic_set(&ha->loop_down_timer,
498 qla2x00_mark_all_devices_lost(ha, 1);
502 atomic_set(&ha->vp_state, VP_FAILED);
503 fc_vport_set_state(ha->fc_vport, FC_VPORT_FAILED);
506 if (!(test_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags))) {
507 set_bit(RESET_MARKER_NEEDED, &ha->dpc_flags);
509 set_bit(REGISTER_FC4_NEEDED, &ha->dpc_flags);
511 ha->flags.gpsc_supported = 1;
512 ha->flags.management_server_logged_in = 0;
515 case MBA_CHG_IN_CONNECTION: /* Change in connection mode */
519 DEBUG2(printk("scsi(%ld): Asynchronous Change In Connection "
522 qla_printk(KERN_INFO, ha,
523 "Configuration change detected: value=%x.\n", mb[1]);
525 if (atomic_read(&ha->loop_state) != LOOP_DOWN) {
526 atomic_set(&ha->loop_state, LOOP_DOWN);
527 if (!atomic_read(&ha->loop_down_timer))
528 atomic_set(&ha->loop_down_timer,
530 qla2x00_mark_all_devices_lost(ha, 1);
534 atomic_set(&ha->vp_state, VP_FAILED);
535 fc_vport_set_state(ha->fc_vport, FC_VPORT_FAILED);
538 set_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags);
539 set_bit(LOCAL_LOOP_UPDATE, &ha->dpc_flags);
542 case MBA_PORT_UPDATE: /* Port database update */
544 * If PORT UPDATE is global (recieved LIP_OCCURED/LIP_RESET
545 * event etc. earlier indicating loop is down) then process
546 * it. Otherwise ignore it and Wait for RSCN to come in.
548 atomic_set(&ha->loop_down_timer, 0);
549 if (atomic_read(&ha->loop_state) != LOOP_DOWN &&
550 atomic_read(&ha->loop_state) != LOOP_DEAD) {
551 DEBUG2(printk("scsi(%ld): Asynchronous PORT UPDATE "
552 "ignored %04x/%04x/%04x.\n", ha->host_no, mb[1],
557 DEBUG2(printk("scsi(%ld): Asynchronous PORT UPDATE.\n",
559 DEBUG(printk(KERN_INFO
560 "scsi(%ld): Port database changed %04x %04x %04x.\n",
561 ha->host_no, mb[1], mb[2], mb[3]));
564 * Mark all devices as missing so we will login again.
566 atomic_set(&ha->loop_state, LOOP_UP);
568 qla2x00_mark_all_devices_lost(ha, 1);
570 ha->flags.rscn_queue_overflow = 1;
572 set_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags);
573 set_bit(LOCAL_LOOP_UPDATE, &ha->dpc_flags);
576 case MBA_RSCN_UPDATE: /* State Change Registration */
577 /* Check if the Vport has issued a SCR */
578 if (ha->parent && test_bit(VP_SCR_NEEDED, &ha->vp_flags))
580 /* Only handle SCNs for our Vport index. */
581 if (ha->flags.npiv_supported && ha->vp_idx != mb[3])
584 DEBUG2(printk("scsi(%ld): Asynchronous RSCR UPDATE.\n",
586 DEBUG(printk(KERN_INFO
587 "scsi(%ld): RSCN database changed -- %04x %04x %04x.\n",
588 ha->host_no, mb[1], mb[2], mb[3]));
590 rscn_entry = (mb[1] << 16) | mb[2];
591 host_pid = (ha->d_id.b.domain << 16) | (ha->d_id.b.area << 8) |
593 if (rscn_entry == host_pid) {
594 DEBUG(printk(KERN_INFO
595 "scsi(%ld): Ignoring RSCN update to local host "
597 ha->host_no, host_pid));
601 rscn_queue_index = ha->rscn_in_ptr + 1;
602 if (rscn_queue_index == MAX_RSCN_COUNT)
603 rscn_queue_index = 0;
604 if (rscn_queue_index != ha->rscn_out_ptr) {
605 ha->rscn_queue[ha->rscn_in_ptr] = rscn_entry;
606 ha->rscn_in_ptr = rscn_queue_index;
608 ha->flags.rscn_queue_overflow = 1;
611 atomic_set(&ha->loop_state, LOOP_UPDATE);
612 atomic_set(&ha->loop_down_timer, 0);
613 ha->flags.management_server_logged_in = 0;
615 set_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags);
616 set_bit(RSCN_UPDATE, &ha->dpc_flags);
617 qla2x00_post_aen_work(ha, FCH_EVT_RSCN, rscn_entry);
620 /* case MBA_RIO_RESPONSE: */
621 case MBA_ZIO_RESPONSE:
622 DEBUG2(printk("scsi(%ld): [R|Z]IO update completion.\n",
624 DEBUG(printk(KERN_INFO
625 "scsi(%ld): [R|Z]IO update completion.\n",
628 if (IS_FWI2_CAPABLE(ha))
629 qla24xx_process_response_queue(ha);
631 qla2x00_process_response_queue(ha);
634 case MBA_DISCARD_RND_FRAME:
635 DEBUG2(printk("scsi(%ld): Discard RND Frame -- %04x %04x "
636 "%04x.\n", ha->host_no, mb[1], mb[2], mb[3]));
639 case MBA_TRACE_NOTIFICATION:
640 DEBUG2(printk("scsi(%ld): Trace Notification -- %04x %04x.\n",
641 ha->host_no, mb[1], mb[2]));
645 if (!ha->parent && ha->num_vhosts)
646 qla2x00_alert_all_vps(ha, mb);
650 qla2x00_adjust_sdev_qdepth_up(struct scsi_device *sdev, void *data)
652 fc_port_t *fcport = data;
654 if (fcport->ha->max_q_depth <= sdev->queue_depth)
657 if (sdev->ordered_tags)
658 scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG,
659 sdev->queue_depth + 1);
661 scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG,
662 sdev->queue_depth + 1);
664 fcport->last_ramp_up = jiffies;
666 DEBUG2(qla_printk(KERN_INFO, fcport->ha,
667 "scsi(%ld:%d:%d:%d): Queue depth adjusted-up to %d.\n",
668 fcport->ha->host_no, sdev->channel, sdev->id, sdev->lun,
673 qla2x00_adjust_sdev_qdepth_down(struct scsi_device *sdev, void *data)
675 fc_port_t *fcport = data;
677 if (!scsi_track_queue_full(sdev, sdev->queue_depth - 1))
680 DEBUG2(qla_printk(KERN_INFO, fcport->ha,
681 "scsi(%ld:%d:%d:%d): Queue depth adjusted-down to %d.\n",
682 fcport->ha->host_no, sdev->channel, sdev->id, sdev->lun,
687 qla2x00_ramp_up_queue_depth(scsi_qla_host_t *ha, srb_t *sp)
690 struct scsi_device *sdev;
692 sdev = sp->cmd->device;
693 if (sdev->queue_depth >= ha->max_q_depth)
697 if (time_before(jiffies,
698 fcport->last_ramp_up + ql2xqfullrampup * HZ))
700 if (time_before(jiffies,
701 fcport->last_queue_full + ql2xqfullrampup * HZ))
704 starget_for_each_device(sdev->sdev_target, fcport,
705 qla2x00_adjust_sdev_qdepth_up);
709 * qla2x00_process_completed_request() - Process a Fast Post response.
710 * @ha: SCSI driver HA context
714 qla2x00_process_completed_request(struct scsi_qla_host *ha, uint32_t index)
718 /* Validate handle. */
719 if (index >= MAX_OUTSTANDING_COMMANDS) {
720 DEBUG2(printk("scsi(%ld): Invalid SCSI completion handle %d.\n",
721 ha->host_no, index));
722 qla_printk(KERN_WARNING, ha,
723 "Invalid SCSI completion handle %d.\n", index);
725 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
729 sp = ha->outstanding_cmds[index];
731 /* Free outstanding command slot. */
732 ha->outstanding_cmds[index] = NULL;
734 CMD_COMPL_STATUS(sp->cmd) = 0L;
735 CMD_SCSI_STATUS(sp->cmd) = 0L;
737 /* Save ISP completion status */
738 sp->cmd->result = DID_OK << 16;
740 qla2x00_ramp_up_queue_depth(ha, sp);
741 qla2x00_sp_compl(ha, sp);
743 DEBUG2(printk("scsi(%ld): Invalid ISP SCSI completion handle\n",
745 qla_printk(KERN_WARNING, ha,
746 "Invalid ISP SCSI completion handle\n");
748 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
753 * qla2x00_process_response_queue() - Process response queue entries.
754 * @ha: SCSI driver HA context
757 qla2x00_process_response_queue(struct scsi_qla_host *ha)
759 struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
764 if (!ha->flags.online)
767 while (ha->response_ring_ptr->signature != RESPONSE_PROCESSED) {
768 pkt = (sts_entry_t *)ha->response_ring_ptr;
770 ha->rsp_ring_index++;
771 if (ha->rsp_ring_index == ha->response_q_length) {
772 ha->rsp_ring_index = 0;
773 ha->response_ring_ptr = ha->response_ring;
775 ha->response_ring_ptr++;
778 if (pkt->entry_status != 0) {
779 DEBUG3(printk(KERN_INFO
780 "scsi(%ld): Process error entry.\n", ha->host_no));
782 qla2x00_error_entry(ha, pkt);
783 ((response_t *)pkt)->signature = RESPONSE_PROCESSED;
788 switch (pkt->entry_type) {
790 qla2x00_status_entry(ha, pkt);
793 handle_cnt = ((sts21_entry_t *)pkt)->handle_count;
794 for (cnt = 0; cnt < handle_cnt; cnt++) {
795 qla2x00_process_completed_request(ha,
796 ((sts21_entry_t *)pkt)->handle[cnt]);
800 handle_cnt = ((sts22_entry_t *)pkt)->handle_count;
801 for (cnt = 0; cnt < handle_cnt; cnt++) {
802 qla2x00_process_completed_request(ha,
803 ((sts22_entry_t *)pkt)->handle[cnt]);
806 case STATUS_CONT_TYPE:
807 qla2x00_status_cont_entry(ha, (sts_cont_entry_t *)pkt);
810 qla2x00_ms_entry(ha, (ms_iocb_entry_t *)pkt);
813 /* Type Not Supported. */
814 DEBUG4(printk(KERN_WARNING
815 "scsi(%ld): Received unknown response pkt type %x "
816 "entry status=%x.\n",
817 ha->host_no, pkt->entry_type, pkt->entry_status));
820 ((response_t *)pkt)->signature = RESPONSE_PROCESSED;
824 /* Adjust ring index */
825 WRT_REG_WORD(ISP_RSP_Q_OUT(ha, reg), ha->rsp_ring_index);
829 qla2x00_handle_sense(srb_t *sp, uint8_t *sense_data, uint32_t sense_len)
831 struct scsi_cmnd *cp = sp->cmd;
833 if (sense_len >= SCSI_SENSE_BUFFERSIZE)
834 sense_len = SCSI_SENSE_BUFFERSIZE;
836 CMD_ACTUAL_SNSLEN(cp) = sense_len;
837 sp->request_sense_length = sense_len;
838 sp->request_sense_ptr = cp->sense_buffer;
839 if (sp->request_sense_length > 32)
842 memcpy(cp->sense_buffer, sense_data, sense_len);
844 sp->request_sense_ptr += sense_len;
845 sp->request_sense_length -= sense_len;
846 if (sp->request_sense_length != 0)
847 sp->ha->status_srb = sp;
849 DEBUG5(printk("%s(): Check condition Sense data, scsi(%ld:%d:%d:%d) "
850 "cmd=%p pid=%ld\n", __func__, sp->ha->host_no, cp->device->channel,
851 cp->device->id, cp->device->lun, cp, cp->serial_number));
853 DEBUG5(qla2x00_dump_buffer(cp->sense_buffer,
854 CMD_ACTUAL_SNSLEN(cp)));
858 * qla2x00_status_entry() - Process a Status IOCB entry.
859 * @ha: SCSI driver HA context
860 * @pkt: Entry pointer
863 qla2x00_status_entry(scsi_qla_host_t *ha, void *pkt)
867 struct scsi_cmnd *cp;
869 struct sts_entry_24xx *sts24;
870 uint16_t comp_status;
871 uint16_t scsi_status;
872 uint8_t lscsi_status;
874 uint32_t sense_len, rsp_info_len, resid_len, fw_resid_len;
875 uint8_t *rsp_info, *sense_data;
877 sts = (sts_entry_t *) pkt;
878 sts24 = (struct sts_entry_24xx *) pkt;
879 if (IS_FWI2_CAPABLE(ha)) {
880 comp_status = le16_to_cpu(sts24->comp_status);
881 scsi_status = le16_to_cpu(sts24->scsi_status) & SS_MASK;
883 comp_status = le16_to_cpu(sts->comp_status);
884 scsi_status = le16_to_cpu(sts->scsi_status) & SS_MASK;
887 /* Fast path completion. */
888 if (comp_status == CS_COMPLETE && scsi_status == 0) {
889 qla2x00_process_completed_request(ha, sts->handle);
894 /* Validate handle. */
895 if (sts->handle < MAX_OUTSTANDING_COMMANDS) {
896 sp = ha->outstanding_cmds[sts->handle];
897 ha->outstanding_cmds[sts->handle] = NULL;
902 DEBUG2(printk("scsi(%ld): Status Entry invalid handle.\n",
904 qla_printk(KERN_WARNING, ha, "Status Entry invalid handle.\n");
906 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
907 qla2xxx_wake_dpc(ha);
912 DEBUG2(printk("scsi(%ld): Command already returned back to OS "
913 "pkt->handle=%d sp=%p.\n", ha->host_no, sts->handle, sp));
914 qla_printk(KERN_WARNING, ha,
915 "Command is NULL: already returned to OS (sp=%p)\n", sp);
920 lscsi_status = scsi_status & STATUS_MASK;
921 CMD_ENTRY_STATUS(cp) = sts->entry_status;
922 CMD_COMPL_STATUS(cp) = comp_status;
923 CMD_SCSI_STATUS(cp) = scsi_status;
927 sense_len = rsp_info_len = resid_len = fw_resid_len = 0;
928 if (IS_FWI2_CAPABLE(ha)) {
929 sense_len = le32_to_cpu(sts24->sense_len);
930 rsp_info_len = le32_to_cpu(sts24->rsp_data_len);
931 resid_len = le32_to_cpu(sts24->rsp_residual_count);
932 fw_resid_len = le32_to_cpu(sts24->residual_len);
933 rsp_info = sts24->data;
934 sense_data = sts24->data;
935 host_to_fcp_swap(sts24->data, sizeof(sts24->data));
937 sense_len = le16_to_cpu(sts->req_sense_length);
938 rsp_info_len = le16_to_cpu(sts->rsp_info_len);
939 resid_len = le32_to_cpu(sts->residual_length);
940 rsp_info = sts->rsp_info;
941 sense_data = sts->req_sense_data;
944 /* Check for any FCP transport errors. */
945 if (scsi_status & SS_RESPONSE_INFO_LEN_VALID) {
946 /* Sense data lies beyond any FCP RESPONSE data. */
947 if (IS_FWI2_CAPABLE(ha))
948 sense_data += rsp_info_len;
949 if (rsp_info_len > 3 && rsp_info[3]) {
950 DEBUG2(printk("scsi(%ld:%d:%d:%d) FCP I/O protocol "
951 "failure (%x/%02x%02x%02x%02x%02x%02x%02x%02x)..."
952 "retrying command\n", ha->host_no,
953 cp->device->channel, cp->device->id,
954 cp->device->lun, rsp_info_len, rsp_info[0],
955 rsp_info[1], rsp_info[2], rsp_info[3], rsp_info[4],
956 rsp_info[5], rsp_info[6], rsp_info[7]));
958 cp->result = DID_BUS_BUSY << 16;
959 qla2x00_sp_compl(ha, sp);
964 /* Check for overrun. */
965 if (IS_FWI2_CAPABLE(ha) && comp_status == CS_COMPLETE &&
966 scsi_status & SS_RESIDUAL_OVER)
967 comp_status = CS_DATA_OVERRUN;
970 * Based on Host and scsi status generate status code for Linux
972 switch (comp_status) {
975 if (scsi_status == 0) {
976 cp->result = DID_OK << 16;
979 if (scsi_status & (SS_RESIDUAL_UNDER | SS_RESIDUAL_OVER)) {
981 scsi_set_resid(cp, resid);
982 CMD_RESID_LEN(cp) = resid;
985 ((unsigned)(scsi_bufflen(cp) - resid) <
987 qla_printk(KERN_INFO, ha,
988 "scsi(%ld:%d:%d:%d): Mid-layer underflow "
989 "detected (%x of %x bytes)...returning "
990 "error status.\n", ha->host_no,
991 cp->device->channel, cp->device->id,
992 cp->device->lun, resid,
995 cp->result = DID_ERROR << 16;
999 cp->result = DID_OK << 16 | lscsi_status;
1001 if (lscsi_status == SAM_STAT_TASK_SET_FULL) {
1002 DEBUG2(printk(KERN_INFO
1003 "scsi(%ld): QUEUE FULL status detected "
1004 "0x%x-0x%x.\n", ha->host_no, comp_status,
1007 /* Adjust queue depth for all luns on the port. */
1008 fcport->last_queue_full = jiffies;
1009 starget_for_each_device(cp->device->sdev_target,
1010 fcport, qla2x00_adjust_sdev_qdepth_down);
1013 if (lscsi_status != SS_CHECK_CONDITION)
1016 memset(cp->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
1017 if (!(scsi_status & SS_SENSE_LEN_VALID))
1020 qla2x00_handle_sense(sp, sense_data, sense_len);
1023 case CS_DATA_UNDERRUN:
1025 /* Use F/W calculated residual length. */
1026 if (IS_FWI2_CAPABLE(ha)) {
1027 if (scsi_status & SS_RESIDUAL_UNDER &&
1028 resid != fw_resid_len) {
1029 scsi_status &= ~SS_RESIDUAL_UNDER;
1032 resid = fw_resid_len;
1035 if (scsi_status & SS_RESIDUAL_UNDER) {
1036 scsi_set_resid(cp, resid);
1037 CMD_RESID_LEN(cp) = resid;
1039 DEBUG2(printk(KERN_INFO
1040 "scsi(%ld:%d:%d) UNDERRUN status detected "
1041 "0x%x-0x%x. resid=0x%x fw_resid=0x%x cdb=0x%x "
1042 "os_underflow=0x%x\n", ha->host_no,
1043 cp->device->id, cp->device->lun, comp_status,
1044 scsi_status, resid_len, resid, cp->cmnd[0],
1050 * Check to see if SCSI Status is non zero. If so report SCSI
1053 if (lscsi_status != 0) {
1054 cp->result = DID_OK << 16 | lscsi_status;
1056 if (lscsi_status == SAM_STAT_TASK_SET_FULL) {
1057 DEBUG2(printk(KERN_INFO
1058 "scsi(%ld): QUEUE FULL status detected "
1059 "0x%x-0x%x.\n", ha->host_no, comp_status,
1063 * Adjust queue depth for all luns on the
1066 fcport->last_queue_full = jiffies;
1067 starget_for_each_device(
1068 cp->device->sdev_target, fcport,
1069 qla2x00_adjust_sdev_qdepth_down);
1072 if (lscsi_status != SS_CHECK_CONDITION)
1075 memset(cp->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
1076 if (!(scsi_status & SS_SENSE_LEN_VALID))
1079 qla2x00_handle_sense(sp, sense_data, sense_len);
1082 * In case of a Underrun condition, set both the lscsi
1083 * status and the completion status to appropriate
1087 ((unsigned)(scsi_bufflen(cp) - resid) <
1089 DEBUG2(qla_printk(KERN_INFO, ha,
1090 "scsi(%ld:%d:%d:%d): Mid-layer underflow "
1091 "detected (%x of %x bytes)...returning "
1092 "error status.\n", ha->host_no,
1093 cp->device->channel, cp->device->id,
1094 cp->device->lun, resid,
1097 cp->result = DID_ERROR << 16 | lscsi_status;
1101 * If RISC reports underrun and target does not report
1102 * it then we must have a lost frame, so tell upper
1103 * layer to retry it by reporting a bus busy.
1105 if (!(scsi_status & SS_RESIDUAL_UNDER)) {
1106 DEBUG2(printk("scsi(%ld:%d:%d:%d) Dropped "
1107 "frame(s) detected (%x of %x bytes)..."
1108 "retrying command.\n", ha->host_no,
1109 cp->device->channel, cp->device->id,
1110 cp->device->lun, resid,
1113 cp->result = DID_BUS_BUSY << 16;
1117 /* Handle mid-layer underflow */
1118 if ((unsigned)(scsi_bufflen(cp) - resid) <
1120 qla_printk(KERN_INFO, ha,
1121 "scsi(%ld:%d:%d:%d): Mid-layer underflow "
1122 "detected (%x of %x bytes)...returning "
1123 "error status.\n", ha->host_no,
1124 cp->device->channel, cp->device->id,
1125 cp->device->lun, resid,
1128 cp->result = DID_ERROR << 16;
1132 /* Everybody online, looking good... */
1133 cp->result = DID_OK << 16;
1137 case CS_DATA_OVERRUN:
1138 DEBUG2(printk(KERN_INFO
1139 "scsi(%ld:%d:%d): OVERRUN status detected 0x%x-0x%x\n",
1140 ha->host_no, cp->device->id, cp->device->lun, comp_status,
1142 DEBUG2(printk(KERN_INFO
1143 "CDB: 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x\n",
1144 cp->cmnd[0], cp->cmnd[1], cp->cmnd[2], cp->cmnd[3],
1145 cp->cmnd[4], cp->cmnd[5]));
1146 DEBUG2(printk(KERN_INFO
1147 "PID=0x%lx req=0x%x xtra=0x%x -- returning DID_ERROR "
1149 cp->serial_number, scsi_bufflen(cp), resid_len));
1151 cp->result = DID_ERROR << 16;
1154 case CS_PORT_LOGGED_OUT:
1155 case CS_PORT_CONFIG_CHG:
1158 case CS_PORT_UNAVAILABLE:
1160 * If the port is in Target Down state, return all IOs for this
1161 * Target with DID_NO_CONNECT ELSE Queue the IOs in the
1164 DEBUG2(printk("scsi(%ld:%d:%d): status_entry: Port Down "
1165 "pid=%ld, compl status=0x%x, port state=0x%x\n",
1166 ha->host_no, cp->device->id, cp->device->lun,
1167 cp->serial_number, comp_status,
1168 atomic_read(&fcport->state)));
1170 cp->result = DID_BUS_BUSY << 16;
1171 if (atomic_read(&fcport->state) == FCS_ONLINE) {
1172 qla2x00_mark_device_lost(ha, fcport, 1, 1);
1177 DEBUG2(printk(KERN_INFO
1178 "scsi(%ld): RESET status detected 0x%x-0x%x.\n",
1179 ha->host_no, comp_status, scsi_status));
1181 cp->result = DID_RESET << 16;
1186 * hv2.19.12 - DID_ABORT does not retry the request if we
1187 * aborted this request then abort otherwise it must be a
1190 DEBUG2(printk(KERN_INFO
1191 "scsi(%ld): ABORT status detected 0x%x-0x%x.\n",
1192 ha->host_no, comp_status, scsi_status));
1194 cp->result = DID_RESET << 16;
1198 cp->result = DID_BUS_BUSY << 16;
1200 if (IS_FWI2_CAPABLE(ha)) {
1201 DEBUG2(printk(KERN_INFO
1202 "scsi(%ld:%d:%d:%d): TIMEOUT status detected "
1203 "0x%x-0x%x\n", ha->host_no, cp->device->channel,
1204 cp->device->id, cp->device->lun, comp_status,
1208 DEBUG2(printk(KERN_INFO
1209 "scsi(%ld:%d:%d:%d): TIMEOUT status detected 0x%x-0x%x "
1210 "sflags=%x.\n", ha->host_no, cp->device->channel,
1211 cp->device->id, cp->device->lun, comp_status, scsi_status,
1212 le16_to_cpu(sts->status_flags)));
1214 /* Check to see if logout occurred. */
1215 if ((le16_to_cpu(sts->status_flags) & SF_LOGOUT_SENT))
1216 qla2x00_mark_device_lost(ha, fcport, 1, 1);
1220 DEBUG3(printk("scsi(%ld): Error detected (unknown status) "
1221 "0x%x-0x%x.\n", ha->host_no, comp_status, scsi_status));
1222 qla_printk(KERN_INFO, ha,
1223 "Unknown status detected 0x%x-0x%x.\n",
1224 comp_status, scsi_status);
1226 cp->result = DID_ERROR << 16;
1230 /* Place command on done queue. */
1231 if (ha->status_srb == NULL)
1232 qla2x00_sp_compl(ha, sp);
1236 * qla2x00_status_cont_entry() - Process a Status Continuations entry.
1237 * @ha: SCSI driver HA context
1238 * @pkt: Entry pointer
1240 * Extended sense data.
1243 qla2x00_status_cont_entry(scsi_qla_host_t *ha, sts_cont_entry_t *pkt)
1245 uint8_t sense_sz = 0;
1246 srb_t *sp = ha->status_srb;
1247 struct scsi_cmnd *cp;
1249 if (sp != NULL && sp->request_sense_length != 0) {
1252 DEBUG2(printk("%s(): Cmd already returned back to OS "
1253 "sp=%p.\n", __func__, sp));
1254 qla_printk(KERN_INFO, ha,
1255 "cmd is NULL: already returned to OS (sp=%p)\n",
1258 ha->status_srb = NULL;
1262 if (sp->request_sense_length > sizeof(pkt->data)) {
1263 sense_sz = sizeof(pkt->data);
1265 sense_sz = sp->request_sense_length;
1268 /* Move sense data. */
1269 if (IS_FWI2_CAPABLE(ha))
1270 host_to_fcp_swap(pkt->data, sizeof(pkt->data));
1271 memcpy(sp->request_sense_ptr, pkt->data, sense_sz);
1272 DEBUG5(qla2x00_dump_buffer(sp->request_sense_ptr, sense_sz));
1274 sp->request_sense_ptr += sense_sz;
1275 sp->request_sense_length -= sense_sz;
1277 /* Place command on done queue. */
1278 if (sp->request_sense_length == 0) {
1279 ha->status_srb = NULL;
1280 qla2x00_sp_compl(ha, sp);
1286 * qla2x00_error_entry() - Process an error entry.
1287 * @ha: SCSI driver HA context
1288 * @pkt: Entry pointer
1291 qla2x00_error_entry(scsi_qla_host_t *ha, sts_entry_t *pkt)
1295 #if defined(QL_DEBUG_LEVEL_2)
1296 if (pkt->entry_status & RF_INV_E_ORDER)
1297 qla_printk(KERN_ERR, ha, "%s: Invalid Entry Order\n", __func__);
1298 else if (pkt->entry_status & RF_INV_E_COUNT)
1299 qla_printk(KERN_ERR, ha, "%s: Invalid Entry Count\n", __func__);
1300 else if (pkt->entry_status & RF_INV_E_PARAM)
1301 qla_printk(KERN_ERR, ha,
1302 "%s: Invalid Entry Parameter\n", __func__);
1303 else if (pkt->entry_status & RF_INV_E_TYPE)
1304 qla_printk(KERN_ERR, ha, "%s: Invalid Entry Type\n", __func__);
1305 else if (pkt->entry_status & RF_BUSY)
1306 qla_printk(KERN_ERR, ha, "%s: Busy\n", __func__);
1308 qla_printk(KERN_ERR, ha, "%s: UNKNOWN flag error\n", __func__);
1311 /* Validate handle. */
1312 if (pkt->handle < MAX_OUTSTANDING_COMMANDS)
1313 sp = ha->outstanding_cmds[pkt->handle];
1318 /* Free outstanding command slot. */
1319 ha->outstanding_cmds[pkt->handle] = NULL;
1321 /* Bad payload or header */
1322 if (pkt->entry_status &
1323 (RF_INV_E_ORDER | RF_INV_E_COUNT |
1324 RF_INV_E_PARAM | RF_INV_E_TYPE)) {
1325 sp->cmd->result = DID_ERROR << 16;
1326 } else if (pkt->entry_status & RF_BUSY) {
1327 sp->cmd->result = DID_BUS_BUSY << 16;
1329 sp->cmd->result = DID_ERROR << 16;
1331 qla2x00_sp_compl(ha, sp);
1333 } else if (pkt->entry_type == COMMAND_A64_TYPE || pkt->entry_type ==
1334 COMMAND_TYPE || pkt->entry_type == COMMAND_TYPE_7) {
1335 DEBUG2(printk("scsi(%ld): Error entry - invalid handle\n",
1337 qla_printk(KERN_WARNING, ha,
1338 "Error entry - invalid handle\n");
1340 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
1341 qla2xxx_wake_dpc(ha);
1346 * qla2x00_ms_entry() - Process a Management Server entry.
1347 * @ha: SCSI driver HA context
1348 * @index: Response queue out pointer
1351 qla2x00_ms_entry(scsi_qla_host_t *ha, ms_iocb_entry_t *pkt)
1355 DEBUG3(printk("%s(%ld): pkt=%p pkthandle=%d.\n",
1356 __func__, ha->host_no, pkt, pkt->handle1));
1358 /* Validate handle. */
1359 if (pkt->handle1 < MAX_OUTSTANDING_COMMANDS)
1360 sp = ha->outstanding_cmds[pkt->handle1];
1365 DEBUG2(printk("scsi(%ld): MS entry - invalid handle\n",
1367 qla_printk(KERN_WARNING, ha, "MS entry - invalid handle\n");
1369 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
1373 CMD_COMPL_STATUS(sp->cmd) = le16_to_cpu(pkt->status);
1374 CMD_ENTRY_STATUS(sp->cmd) = pkt->entry_status;
1376 /* Free outstanding command slot. */
1377 ha->outstanding_cmds[pkt->handle1] = NULL;
1379 qla2x00_sp_compl(ha, sp);
1384 * qla24xx_mbx_completion() - Process mailbox command completions.
1385 * @ha: SCSI driver HA context
1386 * @mb0: Mailbox0 register
1389 qla24xx_mbx_completion(scsi_qla_host_t *ha, uint16_t mb0)
1392 uint16_t __iomem *wptr;
1393 struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
1395 /* Load return mailbox registers. */
1396 ha->flags.mbox_int = 1;
1397 ha->mailbox_out[0] = mb0;
1398 wptr = (uint16_t __iomem *)®->mailbox1;
1400 for (cnt = 1; cnt < ha->mbx_count; cnt++) {
1401 ha->mailbox_out[cnt] = RD_REG_WORD(wptr);
1406 DEBUG3(printk("%s(%ld): Got mailbox completion. cmd=%x.\n",
1407 __func__, ha->host_no, ha->mcp->mb[0]));
1409 DEBUG2_3(printk("%s(%ld): MBX pointer ERROR!\n",
1410 __func__, ha->host_no));
1415 * qla24xx_process_response_queue() - Process response queue entries.
1416 * @ha: SCSI driver HA context
1419 qla24xx_process_response_queue(struct scsi_qla_host *ha)
1421 struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
1422 struct sts_entry_24xx *pkt;
1424 if (!ha->flags.online)
1427 while (ha->response_ring_ptr->signature != RESPONSE_PROCESSED) {
1428 pkt = (struct sts_entry_24xx *)ha->response_ring_ptr;
1430 ha->rsp_ring_index++;
1431 if (ha->rsp_ring_index == ha->response_q_length) {
1432 ha->rsp_ring_index = 0;
1433 ha->response_ring_ptr = ha->response_ring;
1435 ha->response_ring_ptr++;
1438 if (pkt->entry_status != 0) {
1439 DEBUG3(printk(KERN_INFO
1440 "scsi(%ld): Process error entry.\n", ha->host_no));
1442 qla2x00_error_entry(ha, (sts_entry_t *) pkt);
1443 ((response_t *)pkt)->signature = RESPONSE_PROCESSED;
1448 switch (pkt->entry_type) {
1450 qla2x00_status_entry(ha, pkt);
1452 case STATUS_CONT_TYPE:
1453 qla2x00_status_cont_entry(ha, (sts_cont_entry_t *)pkt);
1456 qla24xx_ms_entry(ha, (struct ct_entry_24xx *)pkt);
1458 case VP_RPT_ID_IOCB_TYPE:
1459 qla24xx_report_id_acquisition(ha,
1460 (struct vp_rpt_id_entry_24xx *)pkt);
1463 /* Type Not Supported. */
1464 DEBUG4(printk(KERN_WARNING
1465 "scsi(%ld): Received unknown response pkt type %x "
1466 "entry status=%x.\n",
1467 ha->host_no, pkt->entry_type, pkt->entry_status));
1470 ((response_t *)pkt)->signature = RESPONSE_PROCESSED;
1474 /* Adjust ring index */
1475 WRT_REG_DWORD(®->rsp_q_out, ha->rsp_ring_index);
1479 qla2xxx_check_risc_status(scsi_qla_host_t *ha)
1483 struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
1485 if (!IS_QLA25XX(ha))
1489 WRT_REG_DWORD(®->iobase_addr, 0x7C00);
1490 RD_REG_DWORD(®->iobase_addr);
1491 WRT_REG_DWORD(®->iobase_window, 0x0001);
1492 for (cnt = 10000; (RD_REG_DWORD(®->iobase_window) & BIT_0) == 0 &&
1493 rval == QLA_SUCCESS; cnt--) {
1495 WRT_REG_DWORD(®->iobase_window, 0x0001);
1498 rval = QLA_FUNCTION_TIMEOUT;
1500 if (rval == QLA_SUCCESS)
1503 WRT_REG_DWORD(®->iobase_window, 0x0003);
1504 for (cnt = 100; (RD_REG_DWORD(®->iobase_window) & BIT_0) == 0 &&
1505 rval == QLA_SUCCESS; cnt--) {
1507 WRT_REG_DWORD(®->iobase_window, 0x0003);
1510 rval = QLA_FUNCTION_TIMEOUT;
1512 if (rval != QLA_SUCCESS)
1516 if (RD_REG_DWORD(®->iobase_c8) & BIT_3)
1517 qla_printk(KERN_INFO, ha, "Additional code -- 0x55AA.\n");
1520 WRT_REG_DWORD(®->iobase_window, 0x0000);
1521 RD_REG_DWORD(®->iobase_window);
1525 * qla24xx_intr_handler() - Process interrupts for the ISP23xx and ISP63xx.
1527 * @dev_id: SCSI driver HA context
1529 * Called by system whenever the host adapter generates an interrupt.
1531 * Returns handled flag.
1534 qla24xx_intr_handler(int irq, void *dev_id)
1536 scsi_qla_host_t *ha;
1537 struct device_reg_24xx __iomem *reg;
1544 ha = (scsi_qla_host_t *) dev_id;
1547 "%s(): NULL host pointer\n", __func__);
1551 reg = &ha->iobase->isp24;
1554 spin_lock(&ha->hardware_lock);
1555 for (iter = 50; iter--; ) {
1556 stat = RD_REG_DWORD(®->host_status);
1557 if (stat & HSRX_RISC_PAUSED) {
1558 if (pci_channel_offline(ha->pdev))
1561 hccr = RD_REG_DWORD(®->hccr);
1563 qla_printk(KERN_INFO, ha, "RISC paused -- HCCR=%x, "
1564 "Dumping firmware!\n", hccr);
1566 qla2xxx_check_risc_status(ha);
1568 ha->isp_ops->fw_dump(ha, 1);
1569 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
1571 } else if ((stat & HSRX_RISC_INT) == 0)
1574 switch (stat & 0xff) {
1579 qla24xx_mbx_completion(ha, MSW(stat));
1580 status |= MBX_INTERRUPT;
1585 mb[1] = RD_REG_WORD(®->mailbox1);
1586 mb[2] = RD_REG_WORD(®->mailbox2);
1587 mb[3] = RD_REG_WORD(®->mailbox3);
1588 qla2x00_async_event(ha, mb);
1591 qla24xx_process_response_queue(ha);
1594 DEBUG2(printk("scsi(%ld): Unrecognized interrupt type "
1596 ha->host_no, stat & 0xff));
1599 WRT_REG_DWORD(®->hccr, HCCRX_CLR_RISC_INT);
1600 RD_REG_DWORD_RELAXED(®->hccr);
1602 spin_unlock(&ha->hardware_lock);
1604 if (test_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags) &&
1605 (status & MBX_INTERRUPT) && ha->flags.mbox_int) {
1606 set_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
1607 complete(&ha->mbx_intr_comp);
1614 * qla24xx_ms_entry() - Process a Management Server entry.
1615 * @ha: SCSI driver HA context
1616 * @index: Response queue out pointer
1619 qla24xx_ms_entry(scsi_qla_host_t *ha, struct ct_entry_24xx *pkt)
1623 DEBUG3(printk("%s(%ld): pkt=%p pkthandle=%d.\n",
1624 __func__, ha->host_no, pkt, pkt->handle));
1626 DEBUG9(printk("%s: ct pkt dump:\n", __func__));
1627 DEBUG9(qla2x00_dump_buffer((void *)pkt, sizeof(struct ct_entry_24xx)));
1629 /* Validate handle. */
1630 if (pkt->handle < MAX_OUTSTANDING_COMMANDS)
1631 sp = ha->outstanding_cmds[pkt->handle];
1636 DEBUG2(printk("scsi(%ld): MS entry - invalid handle\n",
1638 DEBUG10(printk("scsi(%ld): MS entry - invalid handle\n",
1640 qla_printk(KERN_WARNING, ha, "MS entry - invalid handle %d\n",
1643 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
1647 CMD_COMPL_STATUS(sp->cmd) = le16_to_cpu(pkt->comp_status);
1648 CMD_ENTRY_STATUS(sp->cmd) = pkt->entry_status;
1650 /* Free outstanding command slot. */
1651 ha->outstanding_cmds[pkt->handle] = NULL;
1653 qla2x00_sp_compl(ha, sp);
1657 qla24xx_msix_rsp_q(int irq, void *dev_id)
1659 scsi_qla_host_t *ha;
1660 struct device_reg_24xx __iomem *reg;
1663 reg = &ha->iobase->isp24;
1665 spin_lock(&ha->hardware_lock);
1667 qla24xx_process_response_queue(ha);
1668 WRT_REG_DWORD(®->hccr, HCCRX_CLR_RISC_INT);
1670 spin_unlock(&ha->hardware_lock);
1676 qla24xx_msix_default(int irq, void *dev_id)
1678 scsi_qla_host_t *ha;
1679 struct device_reg_24xx __iomem *reg;
1686 reg = &ha->iobase->isp24;
1689 spin_lock(&ha->hardware_lock);
1691 stat = RD_REG_DWORD(®->host_status);
1692 if (stat & HSRX_RISC_PAUSED) {
1693 if (pci_channel_offline(ha->pdev))
1696 hccr = RD_REG_DWORD(®->hccr);
1698 qla_printk(KERN_INFO, ha, "RISC paused -- HCCR=%x, "
1699 "Dumping firmware!\n", hccr);
1701 qla2xxx_check_risc_status(ha);
1703 ha->isp_ops->fw_dump(ha, 1);
1704 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
1706 } else if ((stat & HSRX_RISC_INT) == 0)
1709 switch (stat & 0xff) {
1714 qla24xx_mbx_completion(ha, MSW(stat));
1715 status |= MBX_INTERRUPT;
1720 mb[1] = RD_REG_WORD(®->mailbox1);
1721 mb[2] = RD_REG_WORD(®->mailbox2);
1722 mb[3] = RD_REG_WORD(®->mailbox3);
1723 qla2x00_async_event(ha, mb);
1726 qla24xx_process_response_queue(ha);
1729 DEBUG2(printk("scsi(%ld): Unrecognized interrupt type "
1731 ha->host_no, stat & 0xff));
1734 WRT_REG_DWORD(®->hccr, HCCRX_CLR_RISC_INT);
1736 spin_unlock(&ha->hardware_lock);
1738 if (test_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags) &&
1739 (status & MBX_INTERRUPT) && ha->flags.mbox_int) {
1740 set_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
1741 complete(&ha->mbx_intr_comp);
1747 /* Interrupt handling helpers. */
1749 struct qla_init_msix_entry {
1753 irq_handler_t handler;
1756 static struct qla_init_msix_entry imsix_entries[QLA_MSIX_ENTRIES] = {
1757 { QLA_MSIX_DEFAULT, QLA_MIDX_DEFAULT,
1758 "qla2xxx (default)", qla24xx_msix_default },
1760 { QLA_MSIX_RSP_Q, QLA_MIDX_RSP_Q,
1761 "qla2xxx (rsp_q)", qla24xx_msix_rsp_q },
1765 qla24xx_disable_msix(scsi_qla_host_t *ha)
1768 struct qla_msix_entry *qentry;
1770 for (i = 0; i < QLA_MSIX_ENTRIES; i++) {
1771 qentry = &ha->msix_entries[imsix_entries[i].index];
1772 if (qentry->have_irq)
1773 free_irq(qentry->msix_vector, ha);
1775 pci_disable_msix(ha->pdev);
1779 qla24xx_enable_msix(scsi_qla_host_t *ha)
1782 struct msix_entry entries[QLA_MSIX_ENTRIES];
1783 struct qla_msix_entry *qentry;
1785 for (i = 0; i < QLA_MSIX_ENTRIES; i++)
1786 entries[i].entry = imsix_entries[i].entry;
1788 ret = pci_enable_msix(ha->pdev, entries, ARRAY_SIZE(entries));
1790 qla_printk(KERN_WARNING, ha,
1791 "MSI-X: Failed to enable support -- %d/%d\n",
1792 QLA_MSIX_ENTRIES, ret);
1795 ha->flags.msix_enabled = 1;
1797 for (i = 0; i < QLA_MSIX_ENTRIES; i++) {
1798 qentry = &ha->msix_entries[imsix_entries[i].index];
1799 qentry->msix_vector = entries[i].vector;
1800 qentry->msix_entry = entries[i].entry;
1801 qentry->have_irq = 0;
1802 ret = request_irq(qentry->msix_vector,
1803 imsix_entries[i].handler, 0, imsix_entries[i].name, ha);
1805 qla_printk(KERN_WARNING, ha,
1806 "MSI-X: Unable to register handler -- %x/%d.\n",
1807 imsix_entries[i].index, ret);
1808 qla24xx_disable_msix(ha);
1811 qentry->have_irq = 1;
1819 qla2x00_request_irqs(scsi_qla_host_t *ha)
1822 device_reg_t __iomem *reg = ha->iobase;
1824 /* If possible, enable MSI-X. */
1825 if (!IS_QLA2432(ha) && !IS_QLA2532(ha))
1828 if (IS_QLA2432(ha) && (ha->chip_revision < QLA_MSIX_CHIP_REV_24XX ||
1829 !QLA_MSIX_FW_MODE_1(ha->fw_attributes))) {
1830 DEBUG2(qla_printk(KERN_WARNING, ha,
1831 "MSI-X: Unsupported ISP2432 (0x%X, 0x%X).\n",
1832 ha->chip_revision, ha->fw_attributes));
1837 if (ha->pdev->subsystem_vendor == PCI_VENDOR_ID_HP &&
1838 (ha->pdev->subsystem_device == 0x7040 ||
1839 ha->pdev->subsystem_device == 0x7041 ||
1840 ha->pdev->subsystem_device == 0x1705)) {
1841 DEBUG2(qla_printk(KERN_WARNING, ha,
1842 "MSI-X: Unsupported ISP2432 SSVID/SSDID (0x%X, 0x%X).\n",
1843 ha->pdev->subsystem_vendor,
1844 ha->pdev->subsystem_device));
1849 ret = qla24xx_enable_msix(ha);
1851 DEBUG2(qla_printk(KERN_INFO, ha,
1852 "MSI-X: Enabled (0x%X, 0x%X).\n", ha->chip_revision,
1853 ha->fw_attributes));
1854 goto clear_risc_ints;
1856 qla_printk(KERN_WARNING, ha,
1857 "MSI-X: Falling back-to INTa mode -- %d.\n", ret);
1860 if (!IS_QLA24XX(ha) && !IS_QLA2532(ha))
1863 ret = pci_enable_msi(ha->pdev);
1865 DEBUG2(qla_printk(KERN_INFO, ha, "MSI: Enabled.\n"));
1866 ha->flags.msi_enabled = 1;
1870 ret = request_irq(ha->pdev->irq, ha->isp_ops->intr_handler,
1871 IRQF_DISABLED|IRQF_SHARED, QLA2XXX_DRIVER_NAME, ha);
1873 qla_printk(KERN_WARNING, ha,
1874 "Failed to reserve interrupt %d already in use.\n",
1878 ha->flags.inta_enabled = 1;
1879 ha->host->irq = ha->pdev->irq;
1882 ha->isp_ops->disable_intrs(ha);
1883 spin_lock_irq(&ha->hardware_lock);
1884 if (IS_FWI2_CAPABLE(ha)) {
1885 WRT_REG_DWORD(®->isp24.hccr, HCCRX_CLR_HOST_INT);
1886 WRT_REG_DWORD(®->isp24.hccr, HCCRX_CLR_RISC_INT);
1888 WRT_REG_WORD(®->isp.semaphore, 0);
1889 WRT_REG_WORD(®->isp.hccr, HCCR_CLR_RISC_INT);
1890 WRT_REG_WORD(®->isp.hccr, HCCR_CLR_HOST_INT);
1892 spin_unlock_irq(&ha->hardware_lock);
1893 ha->isp_ops->enable_intrs(ha);
1900 qla2x00_free_irqs(scsi_qla_host_t *ha)
1903 if (ha->flags.msix_enabled)
1904 qla24xx_disable_msix(ha);
1905 else if (ha->flags.inta_enabled) {
1906 free_irq(ha->host->irq, ha);
1907 pci_disable_msi(ha->pdev);