1 // SPDX-License-Identifier: GPL-2.0-only
3 * QLogic Fibre Channel HBA Driver
4 * Copyright (c) 2003-2014 QLogic Corporation
7 #include "qla_target.h"
10 #include <linux/delay.h>
11 #include <linux/slab.h>
12 #include <linux/cpu.h>
13 #include <linux/t10-pi.h>
14 #include <scsi/scsi_tcq.h>
15 #include <scsi/scsi_bsg_fc.h>
16 #include <scsi/scsi_eh.h>
17 #include <scsi/fc/fc_fs.h>
18 #include <linux/nvme-fc-driver.h>
20 static void qla2x00_mbx_completion(scsi_qla_host_t *, uint16_t);
21 static void qla2x00_status_entry(scsi_qla_host_t *, struct rsp_que *, void *);
22 static void qla2x00_status_cont_entry(struct rsp_que *, sts_cont_entry_t *);
23 static int qla2x00_error_entry(scsi_qla_host_t *, struct rsp_que *,
25 static void qla27xx_process_purex_fpin(struct scsi_qla_host *vha,
26 struct purex_item *item);
27 static struct purex_item *qla24xx_alloc_purex_item(scsi_qla_host_t *vha,
29 static struct purex_item *qla24xx_copy_std_pkt(struct scsi_qla_host *vha,
31 static struct purex_item *qla27xx_copy_fpin_pkt(struct scsi_qla_host *vha,
32 void **pkt, struct rsp_que **rsp);
35 qla27xx_process_purex_fpin(struct scsi_qla_host *vha, struct purex_item *item)
37 void *pkt = &item->iocb;
38 uint16_t pkt_size = item->size;
40 ql_dbg(ql_dbg_init + ql_dbg_verbose, vha, 0x508d,
41 "%s: Enter\n", __func__);
43 ql_dbg(ql_dbg_init + ql_dbg_verbose, vha, 0x508e,
44 "-------- ELS REQ -------\n");
45 ql_dump_buffer(ql_dbg_init + ql_dbg_verbose, vha, 0x508f,
48 fc_host_fpin_rcv(vha->host, pkt_size, (char *)pkt, 0);
51 const char *const port_state_str[] = {
52 [FCS_UNKNOWN] = "Unknown",
53 [FCS_UNCONFIGURED] = "UNCONFIGURED",
54 [FCS_DEVICE_DEAD] = "DEAD",
55 [FCS_DEVICE_LOST] = "LOST",
56 [FCS_ONLINE] = "ONLINE"
59 #define SFP_DISABLE_LASER_INITIATED 0x15 /* Sub code of 8070 AEN */
60 #define SFP_ENABLE_LASER_INITIATED 0x16 /* Sub code of 8070 AEN */
62 static inline void display_Laser_info(scsi_qla_host_t *vha,
63 u16 mb1, u16 mb2, u16 mb3) {
65 if (mb1 == SFP_DISABLE_LASER_INITIATED)
66 ql_log(ql_log_warn, vha, 0xf0a2,
67 "SFP temperature (%d C) reached/exceeded the threshold (%d C). Laser is disabled.\n",
69 if (mb1 == SFP_ENABLE_LASER_INITIATED)
70 ql_log(ql_log_warn, vha, 0xf0a3,
71 "SFP temperature (%d C) reached normal operating level. Laser is enabled.\n",
76 qla24xx_process_abts(struct scsi_qla_host *vha, struct purex_item *pkt)
78 struct abts_entry_24xx *abts =
79 (struct abts_entry_24xx *)&pkt->iocb;
80 struct qla_hw_data *ha = vha->hw;
81 struct els_entry_24xx *rsp_els;
82 struct abts_entry_24xx *abts_rsp;
87 ql_dbg(ql_dbg_init, vha, 0x0286, "%s: entered.\n", __func__);
89 ql_log(ql_log_warn, vha, 0x0287,
90 "Processing ABTS xchg=%#x oxid=%#x rxid=%#x seqid=%#x seqcnt=%#x\n",
91 abts->rx_xch_addr_to_abort, abts->ox_id, abts->rx_id,
92 abts->seq_id, abts->seq_cnt);
93 ql_dbg(ql_dbg_init + ql_dbg_verbose, vha, 0x0287,
94 "-------- ABTS RCV -------\n");
95 ql_dump_buffer(ql_dbg_init + ql_dbg_verbose, vha, 0x0287,
96 (uint8_t *)abts, sizeof(*abts));
98 rsp_els = dma_alloc_coherent(&ha->pdev->dev, sizeof(*rsp_els), &dma,
101 ql_log(ql_log_warn, vha, 0x0287,
102 "Failed allocate dma buffer ABTS/ELS RSP.\n");
106 /* terminate exchange */
107 rsp_els->entry_type = ELS_IOCB_TYPE;
108 rsp_els->entry_count = 1;
109 rsp_els->nport_handle = cpu_to_le16(~0);
110 rsp_els->rx_xchg_address = abts->rx_xch_addr_to_abort;
111 rsp_els->control_flags = cpu_to_le16(EPD_RX_XCHG);
112 ql_dbg(ql_dbg_init, vha, 0x0283,
113 "Sending ELS Response to terminate exchange %#x...\n",
114 abts->rx_xch_addr_to_abort);
115 ql_dbg(ql_dbg_init + ql_dbg_verbose, vha, 0x0283,
116 "-------- ELS RSP -------\n");
117 ql_dump_buffer(ql_dbg_init + ql_dbg_verbose, vha, 0x0283,
118 (uint8_t *)rsp_els, sizeof(*rsp_els));
119 rval = qla2x00_issue_iocb(vha, rsp_els, dma, 0);
121 ql_log(ql_log_warn, vha, 0x0288,
122 "%s: iocb failed to execute -> %x\n", __func__, rval);
123 } else if (rsp_els->comp_status) {
124 ql_log(ql_log_warn, vha, 0x0289,
125 "%s: iocb failed to complete -> completion=%#x subcode=(%#x,%#x)\n",
126 __func__, rsp_els->comp_status,
127 rsp_els->error_subcode_1, rsp_els->error_subcode_2);
129 ql_dbg(ql_dbg_init, vha, 0x028a,
130 "%s: abort exchange done.\n", __func__);
133 /* send ABTS response */
134 abts_rsp = (void *)rsp_els;
135 memset(abts_rsp, 0, sizeof(*abts_rsp));
136 abts_rsp->entry_type = ABTS_RSP_TYPE;
137 abts_rsp->entry_count = 1;
138 abts_rsp->nport_handle = abts->nport_handle;
139 abts_rsp->vp_idx = abts->vp_idx;
140 abts_rsp->sof_type = abts->sof_type & 0xf0;
141 abts_rsp->rx_xch_addr = abts->rx_xch_addr;
142 abts_rsp->d_id[0] = abts->s_id[0];
143 abts_rsp->d_id[1] = abts->s_id[1];
144 abts_rsp->d_id[2] = abts->s_id[2];
145 abts_rsp->r_ctl = FC_ROUTING_BLD | FC_R_CTL_BLD_BA_ACC;
146 abts_rsp->s_id[0] = abts->d_id[0];
147 abts_rsp->s_id[1] = abts->d_id[1];
148 abts_rsp->s_id[2] = abts->d_id[2];
149 abts_rsp->cs_ctl = abts->cs_ctl;
150 /* include flipping bit23 in fctl */
151 fctl = ~(abts->f_ctl[2] | 0x7F) << 16 |
152 FC_F_CTL_LAST_SEQ | FC_F_CTL_END_SEQ | FC_F_CTL_SEQ_INIT;
153 abts_rsp->f_ctl[0] = fctl >> 0 & 0xff;
154 abts_rsp->f_ctl[1] = fctl >> 8 & 0xff;
155 abts_rsp->f_ctl[2] = fctl >> 16 & 0xff;
156 abts_rsp->type = FC_TYPE_BLD;
157 abts_rsp->rx_id = abts->rx_id;
158 abts_rsp->ox_id = abts->ox_id;
159 abts_rsp->payload.ba_acc.aborted_rx_id = abts->rx_id;
160 abts_rsp->payload.ba_acc.aborted_ox_id = abts->ox_id;
161 abts_rsp->payload.ba_acc.high_seq_cnt = cpu_to_le16(~0);
162 abts_rsp->rx_xch_addr_to_abort = abts->rx_xch_addr_to_abort;
163 ql_dbg(ql_dbg_init, vha, 0x028b,
164 "Sending BA ACC response to ABTS %#x...\n",
165 abts->rx_xch_addr_to_abort);
166 ql_dbg(ql_dbg_init + ql_dbg_verbose, vha, 0x028b,
167 "-------- ELS RSP -------\n");
168 ql_dump_buffer(ql_dbg_init + ql_dbg_verbose, vha, 0x028b,
169 (uint8_t *)abts_rsp, sizeof(*abts_rsp));
170 rval = qla2x00_issue_iocb(vha, abts_rsp, dma, 0);
172 ql_log(ql_log_warn, vha, 0x028c,
173 "%s: iocb failed to execute -> %x\n", __func__, rval);
174 } else if (abts_rsp->comp_status) {
175 ql_log(ql_log_warn, vha, 0x028d,
176 "%s: iocb failed to complete -> completion=%#x subcode=(%#x,%#x)\n",
177 __func__, abts_rsp->comp_status,
178 abts_rsp->payload.error.subcode1,
179 abts_rsp->payload.error.subcode2);
181 ql_dbg(ql_dbg_init, vha, 0x028ea,
182 "%s: done.\n", __func__);
185 dma_free_coherent(&ha->pdev->dev, sizeof(*rsp_els), rsp_els, dma);
189 * __qla_consume_iocb - this routine is used to tell fw driver has processed
190 * or consumed the head IOCB along with the continuation IOCB's from the
191 * provided respond queue.
192 * @vha: host adapter pointer
193 * @pkt: pointer to current packet. On return, this pointer shall move
194 * to the next packet.
195 * @rsp: respond queue pointer.
197 * it is assumed pkt is the head iocb, not the continuation iocbk
199 void __qla_consume_iocb(struct scsi_qla_host *vha,
200 void **pkt, struct rsp_que **rsp)
202 struct rsp_que *rsp_q = *rsp;
204 uint16_t entry_count_remaining;
205 struct purex_entry_24xx *purex = *pkt;
207 entry_count_remaining = purex->entry_count;
208 while (entry_count_remaining > 0) {
209 new_pkt = rsp_q->ring_ptr;
213 if (rsp_q->ring_index == rsp_q->length) {
214 rsp_q->ring_index = 0;
215 rsp_q->ring_ptr = rsp_q->ring;
220 new_pkt->signature = RESPONSE_PROCESSED;
221 /* flush signature */
223 --entry_count_remaining;
228 * __qla_copy_purex_to_buffer - extract ELS payload from Purex IOCB
229 * and save to provided buffer
230 * @vha: host adapter pointer
231 * @pkt: pointer Purex IOCB
232 * @rsp: respond queue
233 * @buf: extracted ELS payload copy here
234 * @buf_len: buffer length
236 int __qla_copy_purex_to_buffer(struct scsi_qla_host *vha,
237 void **pkt, struct rsp_que **rsp, u8 *buf, u32 buf_len)
239 struct purex_entry_24xx *purex = *pkt;
240 struct rsp_que *rsp_q = *rsp;
241 sts_cont_entry_t *new_pkt;
242 uint16_t no_bytes = 0, total_bytes = 0, pending_bytes = 0;
243 uint16_t buffer_copy_offset = 0;
244 uint16_t entry_count_remaining;
247 entry_count_remaining = purex->entry_count;
248 total_bytes = (le16_to_cpu(purex->frame_size) & 0x0FFF)
249 - PURX_ELS_HEADER_SIZE;
252 * end of payload may not end in 4bytes boundary. Need to
253 * round up / pad for room to swap, before saving data
255 tpad = roundup(total_bytes, 4);
257 if (buf_len < tpad) {
258 ql_dbg(ql_dbg_async, vha, 0x5084,
259 "%s buffer is too small %d < %d\n",
260 __func__, buf_len, tpad);
261 __qla_consume_iocb(vha, pkt, rsp);
265 pending_bytes = total_bytes = tpad;
266 no_bytes = (pending_bytes > sizeof(purex->els_frame_payload)) ?
267 sizeof(purex->els_frame_payload) : pending_bytes;
269 memcpy(buf, &purex->els_frame_payload[0], no_bytes);
270 buffer_copy_offset += no_bytes;
271 pending_bytes -= no_bytes;
272 --entry_count_remaining;
274 ((response_t *)purex)->signature = RESPONSE_PROCESSED;
275 /* flush signature */
279 while ((total_bytes > 0) && (entry_count_remaining > 0)) {
280 new_pkt = (sts_cont_entry_t *)rsp_q->ring_ptr;
283 if (new_pkt->entry_type != STATUS_CONT_TYPE) {
284 ql_log(ql_log_warn, vha, 0x507a,
285 "Unexpected IOCB type, partial data 0x%x\n",
291 if (rsp_q->ring_index == rsp_q->length) {
292 rsp_q->ring_index = 0;
293 rsp_q->ring_ptr = rsp_q->ring;
297 no_bytes = (pending_bytes > sizeof(new_pkt->data)) ?
298 sizeof(new_pkt->data) : pending_bytes;
299 if ((buffer_copy_offset + no_bytes) <= total_bytes) {
300 memcpy((buf + buffer_copy_offset), new_pkt->data,
302 buffer_copy_offset += no_bytes;
303 pending_bytes -= no_bytes;
304 --entry_count_remaining;
306 ql_log(ql_log_warn, vha, 0x5044,
307 "Attempt to copy more that we got, optimizing..%x\n",
309 memcpy((buf + buffer_copy_offset), new_pkt->data,
310 total_bytes - buffer_copy_offset);
313 ((response_t *)new_pkt)->signature = RESPONSE_PROCESSED;
314 /* flush signature */
318 if (pending_bytes != 0 || entry_count_remaining != 0) {
319 ql_log(ql_log_fatal, vha, 0x508b,
320 "Dropping partial Data, underrun bytes = 0x%x, entry cnts 0x%x\n",
321 total_bytes, entry_count_remaining);
324 } while (entry_count_remaining > 0);
326 be32_to_cpu_array((u32 *)buf, (__be32 *)buf, total_bytes >> 2);
332 * qla2100_intr_handler() - Process interrupts for the ISP2100 and ISP2200.
333 * @irq: interrupt number
334 * @dev_id: SCSI driver HA context
336 * Called by system whenever the host adapter generates an interrupt.
338 * Returns handled flag.
341 qla2100_intr_handler(int irq, void *dev_id)
343 scsi_qla_host_t *vha;
344 struct qla_hw_data *ha;
345 struct device_reg_2xxx __iomem *reg;
353 rsp = (struct rsp_que *) dev_id;
355 ql_log(ql_log_info, NULL, 0x505d,
356 "%s: NULL response queue pointer.\n", __func__);
361 reg = &ha->iobase->isp;
364 spin_lock_irqsave(&ha->hardware_lock, flags);
365 vha = pci_get_drvdata(ha->pdev);
366 for (iter = 50; iter--; ) {
367 hccr = rd_reg_word(®->hccr);
368 if (qla2x00_check_reg16_for_disconnect(vha, hccr))
370 if (hccr & HCCR_RISC_PAUSE) {
371 if (pci_channel_offline(ha->pdev))
375 * Issue a "HARD" reset in order for the RISC interrupt
376 * bit to be cleared. Schedule a big hammer to get
377 * out of the RISC PAUSED state.
379 wrt_reg_word(®->hccr, HCCR_RESET_RISC);
380 rd_reg_word(®->hccr);
382 ha->isp_ops->fw_dump(vha);
383 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
385 } else if ((rd_reg_word(®->istatus) & ISR_RISC_INT) == 0)
388 if (rd_reg_word(®->semaphore) & BIT_0) {
389 wrt_reg_word(®->hccr, HCCR_CLR_RISC_INT);
390 rd_reg_word(®->hccr);
392 /* Get mailbox data. */
393 mb[0] = RD_MAILBOX_REG(ha, reg, 0);
394 if (mb[0] > 0x3fff && mb[0] < 0x8000) {
395 qla2x00_mbx_completion(vha, mb[0]);
396 status |= MBX_INTERRUPT;
397 } else if (mb[0] > 0x7fff && mb[0] < 0xc000) {
398 mb[1] = RD_MAILBOX_REG(ha, reg, 1);
399 mb[2] = RD_MAILBOX_REG(ha, reg, 2);
400 mb[3] = RD_MAILBOX_REG(ha, reg, 3);
401 qla2x00_async_event(vha, rsp, mb);
404 ql_dbg(ql_dbg_async, vha, 0x5025,
405 "Unrecognized interrupt type (%d).\n",
408 /* Release mailbox registers. */
409 wrt_reg_word(®->semaphore, 0);
410 rd_reg_word(®->semaphore);
412 qla2x00_process_response_queue(rsp);
414 wrt_reg_word(®->hccr, HCCR_CLR_RISC_INT);
415 rd_reg_word(®->hccr);
418 qla2x00_handle_mbx_completion(ha, status);
419 spin_unlock_irqrestore(&ha->hardware_lock, flags);
421 return (IRQ_HANDLED);
425 qla2x00_check_reg32_for_disconnect(scsi_qla_host_t *vha, uint32_t reg)
427 /* Check for PCI disconnection */
428 if (reg == 0xffffffff && !pci_channel_offline(vha->hw->pdev)) {
429 if (!test_and_set_bit(PFLG_DISCONNECTED, &vha->pci_flags) &&
430 !test_bit(PFLG_DRIVER_REMOVING, &vha->pci_flags) &&
431 !test_bit(PFLG_DRIVER_PROBING, &vha->pci_flags)) {
432 qla_schedule_eeh_work(vha);
440 qla2x00_check_reg16_for_disconnect(scsi_qla_host_t *vha, uint16_t reg)
442 return qla2x00_check_reg32_for_disconnect(vha, 0xffff0000 | reg);
446 * qla2300_intr_handler() - Process interrupts for the ISP23xx and ISP63xx.
447 * @irq: interrupt number
448 * @dev_id: SCSI driver HA context
450 * Called by system whenever the host adapter generates an interrupt.
452 * Returns handled flag.
455 qla2300_intr_handler(int irq, void *dev_id)
457 scsi_qla_host_t *vha;
458 struct device_reg_2xxx __iomem *reg;
465 struct qla_hw_data *ha;
468 rsp = (struct rsp_que *) dev_id;
470 ql_log(ql_log_info, NULL, 0x5058,
471 "%s: NULL response queue pointer.\n", __func__);
476 reg = &ha->iobase->isp;
479 spin_lock_irqsave(&ha->hardware_lock, flags);
480 vha = pci_get_drvdata(ha->pdev);
481 for (iter = 50; iter--; ) {
482 stat = rd_reg_dword(®->u.isp2300.host_status);
483 if (qla2x00_check_reg32_for_disconnect(vha, stat))
485 if (stat & HSR_RISC_PAUSED) {
486 if (unlikely(pci_channel_offline(ha->pdev)))
489 hccr = rd_reg_word(®->hccr);
491 if (hccr & (BIT_15 | BIT_13 | BIT_11 | BIT_8))
492 ql_log(ql_log_warn, vha, 0x5026,
493 "Parity error -- HCCR=%x, Dumping "
494 "firmware.\n", hccr);
496 ql_log(ql_log_warn, vha, 0x5027,
497 "RISC paused -- HCCR=%x, Dumping "
498 "firmware.\n", hccr);
501 * Issue a "HARD" reset in order for the RISC
502 * interrupt bit to be cleared. Schedule a big
503 * hammer to get out of the RISC PAUSED state.
505 wrt_reg_word(®->hccr, HCCR_RESET_RISC);
506 rd_reg_word(®->hccr);
508 ha->isp_ops->fw_dump(vha);
509 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
511 } else if ((stat & HSR_RISC_INT) == 0)
514 switch (stat & 0xff) {
519 qla2x00_mbx_completion(vha, MSW(stat));
520 status |= MBX_INTERRUPT;
522 /* Release mailbox registers. */
523 wrt_reg_word(®->semaphore, 0);
527 mb[1] = RD_MAILBOX_REG(ha, reg, 1);
528 mb[2] = RD_MAILBOX_REG(ha, reg, 2);
529 mb[3] = RD_MAILBOX_REG(ha, reg, 3);
530 qla2x00_async_event(vha, rsp, mb);
533 qla2x00_process_response_queue(rsp);
536 mb[0] = MBA_CMPLT_1_16BIT;
538 qla2x00_async_event(vha, rsp, mb);
541 mb[0] = MBA_SCSI_COMPLETION;
543 mb[2] = RD_MAILBOX_REG(ha, reg, 2);
544 qla2x00_async_event(vha, rsp, mb);
547 ql_dbg(ql_dbg_async, vha, 0x5028,
548 "Unrecognized interrupt type (%d).\n", stat & 0xff);
551 wrt_reg_word(®->hccr, HCCR_CLR_RISC_INT);
552 rd_reg_word_relaxed(®->hccr);
554 qla2x00_handle_mbx_completion(ha, status);
555 spin_unlock_irqrestore(&ha->hardware_lock, flags);
557 return (IRQ_HANDLED);
561 * qla2x00_mbx_completion() - Process mailbox command completions.
562 * @vha: SCSI driver HA context
563 * @mb0: Mailbox0 register
566 qla2x00_mbx_completion(scsi_qla_host_t *vha, uint16_t mb0)
570 __le16 __iomem *wptr;
571 struct qla_hw_data *ha = vha->hw;
572 struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
574 /* Read all mbox registers? */
575 WARN_ON_ONCE(ha->mbx_count > 32);
576 mboxes = (1ULL << ha->mbx_count) - 1;
578 ql_dbg(ql_dbg_async, vha, 0x5001, "MBX pointer ERROR.\n");
580 mboxes = ha->mcp->in_mb;
582 /* Load return mailbox registers. */
583 ha->flags.mbox_int = 1;
584 ha->mailbox_out[0] = mb0;
586 wptr = MAILBOX_REG(ha, reg, 1);
588 for (cnt = 1; cnt < ha->mbx_count; cnt++) {
589 if (IS_QLA2200(ha) && cnt == 8)
590 wptr = MAILBOX_REG(ha, reg, 8);
591 if ((cnt == 4 || cnt == 5) && (mboxes & BIT_0))
592 ha->mailbox_out[cnt] = qla2x00_debounce_register(wptr);
593 else if (mboxes & BIT_0)
594 ha->mailbox_out[cnt] = rd_reg_word(wptr);
602 qla81xx_idc_event(scsi_qla_host_t *vha, uint16_t aen, uint16_t descr)
604 static char *event[] =
605 { "Complete", "Request Notification", "Time Extension" };
607 struct device_reg_24xx __iomem *reg24 = &vha->hw->iobase->isp24;
608 struct device_reg_82xx __iomem *reg82 = &vha->hw->iobase->isp82;
609 __le16 __iomem *wptr;
610 uint16_t cnt, timeout, mb[QLA_IDC_ACK_REGS];
612 /* Seed data -- mailbox1 -> mailbox7. */
613 if (IS_QLA81XX(vha->hw) || IS_QLA83XX(vha->hw))
614 wptr = ®24->mailbox1;
615 else if (IS_QLA8044(vha->hw))
616 wptr = ®82->mailbox_out[1];
620 for (cnt = 0; cnt < QLA_IDC_ACK_REGS; cnt++, wptr++)
621 mb[cnt] = rd_reg_word(wptr);
623 ql_dbg(ql_dbg_async, vha, 0x5021,
624 "Inter-Driver Communication %s -- "
625 "%04x %04x %04x %04x %04x %04x %04x.\n",
626 event[aen & 0xff], mb[0], mb[1], mb[2], mb[3],
627 mb[4], mb[5], mb[6]);
629 /* Handle IDC Error completion case. */
630 case MBA_IDC_COMPLETE:
632 vha->hw->flags.idc_compl_status = 1;
633 if (vha->hw->notify_dcbx_comp && !vha->vp_idx)
634 complete(&vha->hw->dcbx_comp);
639 /* Acknowledgement needed? [Notify && non-zero timeout]. */
640 timeout = (descr >> 8) & 0xf;
641 ql_dbg(ql_dbg_async, vha, 0x5022,
642 "%lu Inter-Driver Communication %s -- ACK timeout=%d.\n",
643 vha->host_no, event[aen & 0xff], timeout);
647 rval = qla2x00_post_idc_ack_work(vha, mb);
648 if (rval != QLA_SUCCESS)
649 ql_log(ql_log_warn, vha, 0x5023,
650 "IDC failed to post ACK.\n");
652 case MBA_IDC_TIME_EXT:
653 vha->hw->idc_extend_tmo = descr;
654 ql_dbg(ql_dbg_async, vha, 0x5087,
655 "%lu Inter-Driver Communication %s -- "
656 "Extend timeout by=%d.\n",
657 vha->host_no, event[aen & 0xff], vha->hw->idc_extend_tmo);
664 qla2x00_get_link_speed_str(struct qla_hw_data *ha, uint16_t speed)
666 static const char *const link_speeds[] = {
667 "1", "2", "?", "4", "8", "16", "32", "64", "10"
669 #define QLA_LAST_SPEED (ARRAY_SIZE(link_speeds) - 1)
671 if (IS_QLA2100(ha) || IS_QLA2200(ha))
672 return link_speeds[0];
673 else if (speed == 0x13)
674 return link_speeds[QLA_LAST_SPEED];
675 else if (speed < QLA_LAST_SPEED)
676 return link_speeds[speed];
678 return link_speeds[LS_UNKNOWN];
682 qla83xx_handle_8200_aen(scsi_qla_host_t *vha, uint16_t *mb)
684 struct qla_hw_data *ha = vha->hw;
687 * 8200 AEN Interpretation:
689 * mb[1] = AEN Reason code
690 * mb[2] = LSW of Peg-Halt Status-1 Register
691 * mb[6] = MSW of Peg-Halt Status-1 Register
692 * mb[3] = LSW of Peg-Halt Status-2 register
693 * mb[7] = MSW of Peg-Halt Status-2 register
694 * mb[4] = IDC Device-State Register value
695 * mb[5] = IDC Driver-Presence Register value
697 ql_dbg(ql_dbg_async, vha, 0x506b, "AEN Code: mb[0] = 0x%x AEN reason: "
698 "mb[1] = 0x%x PH-status1: mb[2] = 0x%x PH-status1: mb[6] = 0x%x.\n",
699 mb[0], mb[1], mb[2], mb[6]);
700 ql_dbg(ql_dbg_async, vha, 0x506c, "PH-status2: mb[3] = 0x%x "
701 "PH-status2: mb[7] = 0x%x Device-State: mb[4] = 0x%x "
702 "Drv-Presence: mb[5] = 0x%x.\n", mb[3], mb[7], mb[4], mb[5]);
704 if (mb[1] & (IDC_PEG_HALT_STATUS_CHANGE | IDC_NIC_FW_REPORTED_FAILURE |
705 IDC_HEARTBEAT_FAILURE)) {
706 ha->flags.nic_core_hung = 1;
707 ql_log(ql_log_warn, vha, 0x5060,
708 "83XX: F/W Error Reported: Check if reset required.\n");
710 if (mb[1] & IDC_PEG_HALT_STATUS_CHANGE) {
711 uint32_t protocol_engine_id, fw_err_code, err_level;
714 * IDC_PEG_HALT_STATUS_CHANGE interpretation:
715 * - PEG-Halt Status-1 Register:
716 * (LSW = mb[2], MSW = mb[6])
717 * Bits 0-7 = protocol-engine ID
718 * Bits 8-28 = f/w error code
719 * Bits 29-31 = Error-level
720 * Error-level 0x1 = Non-Fatal error
721 * Error-level 0x2 = Recoverable Fatal error
722 * Error-level 0x4 = UnRecoverable Fatal error
723 * - PEG-Halt Status-2 Register:
724 * (LSW = mb[3], MSW = mb[7])
726 protocol_engine_id = (mb[2] & 0xff);
727 fw_err_code = (((mb[2] & 0xff00) >> 8) |
728 ((mb[6] & 0x1fff) << 8));
729 err_level = ((mb[6] & 0xe000) >> 13);
730 ql_log(ql_log_warn, vha, 0x5061, "PegHalt Status-1 "
731 "Register: protocol_engine_id=0x%x "
732 "fw_err_code=0x%x err_level=0x%x.\n",
733 protocol_engine_id, fw_err_code, err_level);
734 ql_log(ql_log_warn, vha, 0x5062, "PegHalt Status-2 "
735 "Register: 0x%x%x.\n", mb[7], mb[3]);
736 if (err_level == ERR_LEVEL_NON_FATAL) {
737 ql_log(ql_log_warn, vha, 0x5063,
738 "Not a fatal error, f/w has recovered itself.\n");
739 } else if (err_level == ERR_LEVEL_RECOVERABLE_FATAL) {
740 ql_log(ql_log_fatal, vha, 0x5064,
741 "Recoverable Fatal error: Chip reset "
743 qla83xx_schedule_work(vha,
744 QLA83XX_NIC_CORE_RESET);
745 } else if (err_level == ERR_LEVEL_UNRECOVERABLE_FATAL) {
746 ql_log(ql_log_fatal, vha, 0x5065,
747 "Unrecoverable Fatal error: Set FAILED "
748 "state, reboot required.\n");
749 qla83xx_schedule_work(vha,
750 QLA83XX_NIC_CORE_UNRECOVERABLE);
754 if (mb[1] & IDC_NIC_FW_REPORTED_FAILURE) {
755 uint16_t peg_fw_state, nw_interface_link_up;
756 uint16_t nw_interface_signal_detect, sfp_status;
757 uint16_t htbt_counter, htbt_monitor_enable;
758 uint16_t sfp_additional_info, sfp_multirate;
759 uint16_t sfp_tx_fault, link_speed, dcbx_status;
762 * IDC_NIC_FW_REPORTED_FAILURE interpretation:
763 * - PEG-to-FC Status Register:
764 * (LSW = mb[2], MSW = mb[6])
765 * Bits 0-7 = Peg-Firmware state
766 * Bit 8 = N/W Interface Link-up
767 * Bit 9 = N/W Interface signal detected
768 * Bits 10-11 = SFP Status
769 * SFP Status 0x0 = SFP+ transceiver not expected
770 * SFP Status 0x1 = SFP+ transceiver not present
771 * SFP Status 0x2 = SFP+ transceiver invalid
772 * SFP Status 0x3 = SFP+ transceiver present and
774 * Bits 12-14 = Heartbeat Counter
775 * Bit 15 = Heartbeat Monitor Enable
776 * Bits 16-17 = SFP Additional Info
777 * SFP info 0x0 = Unregocnized transceiver for
779 * SFP info 0x1 = SFP+ brand validation failed
780 * SFP info 0x2 = SFP+ speed validation failed
781 * SFP info 0x3 = SFP+ access error
782 * Bit 18 = SFP Multirate
783 * Bit 19 = SFP Tx Fault
784 * Bits 20-22 = Link Speed
785 * Bits 23-27 = Reserved
786 * Bits 28-30 = DCBX Status
787 * DCBX Status 0x0 = DCBX Disabled
788 * DCBX Status 0x1 = DCBX Enabled
789 * DCBX Status 0x2 = DCBX Exchange error
792 peg_fw_state = (mb[2] & 0x00ff);
793 nw_interface_link_up = ((mb[2] & 0x0100) >> 8);
794 nw_interface_signal_detect = ((mb[2] & 0x0200) >> 9);
795 sfp_status = ((mb[2] & 0x0c00) >> 10);
796 htbt_counter = ((mb[2] & 0x7000) >> 12);
797 htbt_monitor_enable = ((mb[2] & 0x8000) >> 15);
798 sfp_additional_info = (mb[6] & 0x0003);
799 sfp_multirate = ((mb[6] & 0x0004) >> 2);
800 sfp_tx_fault = ((mb[6] & 0x0008) >> 3);
801 link_speed = ((mb[6] & 0x0070) >> 4);
802 dcbx_status = ((mb[6] & 0x7000) >> 12);
804 ql_log(ql_log_warn, vha, 0x5066,
805 "Peg-to-Fc Status Register:\n"
806 "peg_fw_state=0x%x, nw_interface_link_up=0x%x, "
807 "nw_interface_signal_detect=0x%x"
808 "\nsfp_statis=0x%x.\n ", peg_fw_state,
809 nw_interface_link_up, nw_interface_signal_detect,
811 ql_log(ql_log_warn, vha, 0x5067,
812 "htbt_counter=0x%x, htbt_monitor_enable=0x%x, "
813 "sfp_additional_info=0x%x, sfp_multirate=0x%x.\n ",
814 htbt_counter, htbt_monitor_enable,
815 sfp_additional_info, sfp_multirate);
816 ql_log(ql_log_warn, vha, 0x5068,
817 "sfp_tx_fault=0x%x, link_state=0x%x, "
818 "dcbx_status=0x%x.\n", sfp_tx_fault, link_speed,
821 qla83xx_schedule_work(vha, QLA83XX_NIC_CORE_RESET);
824 if (mb[1] & IDC_HEARTBEAT_FAILURE) {
825 ql_log(ql_log_warn, vha, 0x5069,
826 "Heartbeat Failure encountered, chip reset "
829 qla83xx_schedule_work(vha, QLA83XX_NIC_CORE_RESET);
833 if (mb[1] & IDC_DEVICE_STATE_CHANGE) {
834 ql_log(ql_log_info, vha, 0x506a,
835 "IDC Device-State changed = 0x%x.\n", mb[4]);
836 if (ha->flags.nic_core_reset_owner)
838 qla83xx_schedule_work(vha, MBA_IDC_AEN);
843 * qla27xx_copy_multiple_pkt() - Copy over purex/purls packets that can
844 * span over multiple IOCBs.
845 * @vha: SCSI driver HA context
847 * @rsp: Response queue
848 * @is_purls: True, for Unsolicited Received FC-NVMe LS rsp IOCB
849 * false, for Unsolicited Received ELS IOCB
850 * @byte_order: True, to change the byte ordering of iocb payload
853 qla27xx_copy_multiple_pkt(struct scsi_qla_host *vha, void **pkt,
854 struct rsp_que **rsp, bool is_purls,
857 struct purex_entry_24xx *purex = NULL;
858 struct pt_ls4_rx_unsol *purls = NULL;
859 struct rsp_que *rsp_q = *rsp;
860 sts_cont_entry_t *new_pkt;
861 uint16_t no_bytes = 0, total_bytes = 0, pending_bytes = 0;
862 uint16_t buffer_copy_offset = 0, payload_size = 0;
863 uint16_t entry_count, entry_count_remaining;
864 struct purex_item *item;
865 void *iocb_pkt = NULL;
869 total_bytes = (le16_to_cpu(purls->frame_size) & 0x0FFF) -
870 PURX_ELS_HEADER_SIZE;
871 entry_count = entry_count_remaining = purls->entry_count;
872 payload_size = sizeof(purls->payload);
875 total_bytes = (le16_to_cpu(purex->frame_size) & 0x0FFF) -
876 PURX_ELS_HEADER_SIZE;
877 entry_count = entry_count_remaining = purex->entry_count;
878 payload_size = sizeof(purex->els_frame_payload);
881 pending_bytes = total_bytes;
882 no_bytes = (pending_bytes > payload_size) ? payload_size :
884 ql_dbg(ql_dbg_async, vha, 0x509a,
885 "%s LS, frame_size 0x%x, entry count %d\n",
886 (is_purls ? "PURLS" : "FPIN"), total_bytes, entry_count);
888 item = qla24xx_alloc_purex_item(vha, total_bytes);
892 iocb_pkt = &item->iocb;
895 memcpy(iocb_pkt, &purls->payload[0], no_bytes);
897 memcpy(iocb_pkt, &purex->els_frame_payload[0], no_bytes);
898 buffer_copy_offset += no_bytes;
899 pending_bytes -= no_bytes;
900 --entry_count_remaining;
903 ((response_t *)purls)->signature = RESPONSE_PROCESSED;
905 ((response_t *)purex)->signature = RESPONSE_PROCESSED;
909 while ((total_bytes > 0) && (entry_count_remaining > 0)) {
910 if (rsp_q->ring_ptr->signature == RESPONSE_PROCESSED) {
911 ql_dbg(ql_dbg_async, vha, 0x5084,
912 "Ran out of IOCBs, partial data 0x%x\n",
918 new_pkt = (sts_cont_entry_t *)rsp_q->ring_ptr;
921 if (new_pkt->entry_type != STATUS_CONT_TYPE) {
922 ql_log(ql_log_warn, vha, 0x507a,
923 "Unexpected IOCB type, partial data 0x%x\n",
929 if (rsp_q->ring_index == rsp_q->length) {
930 rsp_q->ring_index = 0;
931 rsp_q->ring_ptr = rsp_q->ring;
935 no_bytes = (pending_bytes > sizeof(new_pkt->data)) ?
936 sizeof(new_pkt->data) : pending_bytes;
937 if ((buffer_copy_offset + no_bytes) <= total_bytes) {
938 memcpy(((uint8_t *)iocb_pkt + buffer_copy_offset),
939 new_pkt->data, no_bytes);
940 buffer_copy_offset += no_bytes;
941 pending_bytes -= no_bytes;
942 --entry_count_remaining;
944 ql_log(ql_log_warn, vha, 0x5044,
945 "Attempt to copy more that we got, optimizing..%x\n",
947 memcpy(((uint8_t *)iocb_pkt + buffer_copy_offset),
949 total_bytes - buffer_copy_offset);
952 ((response_t *)new_pkt)->signature = RESPONSE_PROCESSED;
956 if (pending_bytes != 0 || entry_count_remaining != 0) {
957 ql_log(ql_log_fatal, vha, 0x508b,
958 "Dropping partial FPIN, underrun bytes = 0x%x, entry cnts 0x%x\n",
959 total_bytes, entry_count_remaining);
960 qla24xx_free_purex_item(item);
963 } while (entry_count_remaining > 0);
966 host_to_fcp_swap((uint8_t *)&item->iocb, total_bytes);
972 qla2x00_is_a_vp_did(scsi_qla_host_t *vha, uint32_t rscn_entry)
974 struct qla_hw_data *ha = vha->hw;
983 spin_lock_irqsave(&ha->vport_slock, flags);
984 list_for_each_entry(vp, &ha->vp_list, list) {
985 vp_did = vp->d_id.b24;
986 if (vp_did == rscn_entry) {
991 spin_unlock_irqrestore(&ha->vport_slock, flags);
997 qla2x00_find_fcport_by_loopid(scsi_qla_host_t *vha, uint16_t loop_id)
1002 list_for_each_entry_safe(f, tf, &vha->vp_fcports, list)
1003 if (f->loop_id == loop_id)
1009 qla2x00_find_fcport_by_wwpn(scsi_qla_host_t *vha, u8 *wwpn, u8 incl_deleted)
1014 list_for_each_entry_safe(f, tf, &vha->vp_fcports, list) {
1015 if (memcmp(f->port_name, wwpn, WWN_SIZE) == 0) {
1018 else if (f->deleted == 0)
1026 qla2x00_find_fcport_by_nportid(scsi_qla_host_t *vha, port_id_t *id,
1032 list_for_each_entry_safe(f, tf, &vha->vp_fcports, list) {
1033 if (f->d_id.b24 == id->b24) {
1036 else if (f->deleted == 0)
1043 /* Shall be called only on supported adapters. */
1045 qla27xx_handle_8200_aen(scsi_qla_host_t *vha, uint16_t *mb)
1047 struct qla_hw_data *ha = vha->hw;
1048 bool reset_isp_needed = false;
1050 ql_log(ql_log_warn, vha, 0x02f0,
1051 "MPI Heartbeat stop. MPI reset is%s needed. "
1052 "MB0[%xh] MB1[%xh] MB2[%xh] MB3[%xh]\n",
1053 mb[1] & BIT_8 ? "" : " not",
1054 mb[0], mb[1], mb[2], mb[3]);
1056 if ((mb[1] & BIT_8) == 0)
1059 ql_log(ql_log_warn, vha, 0x02f1,
1060 "MPI Heartbeat stop. FW dump needed\n");
1062 if (ql2xfulldump_on_mpifail) {
1063 ha->isp_ops->fw_dump(vha);
1064 reset_isp_needed = true;
1067 ha->isp_ops->mpi_fw_dump(vha, 1);
1069 if (reset_isp_needed) {
1070 vha->hw->flags.fw_init_done = 0;
1071 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
1072 qla2xxx_wake_dpc(vha);
1076 static struct purex_item *
1077 qla24xx_alloc_purex_item(scsi_qla_host_t *vha, uint16_t size)
1079 struct purex_item *item = NULL;
1080 uint8_t item_hdr_size = sizeof(*item);
1082 if (size > QLA_DEFAULT_PAYLOAD_SIZE) {
1083 item = kzalloc(item_hdr_size +
1084 (size - QLA_DEFAULT_PAYLOAD_SIZE), GFP_ATOMIC);
1086 if (atomic_inc_return(&vha->default_item.in_use) == 1) {
1087 item = &vha->default_item;
1088 goto initialize_purex_header;
1090 item = kzalloc(item_hdr_size, GFP_ATOMIC);
1094 ql_log(ql_log_warn, vha, 0x5092,
1095 ">> Failed allocate purex list item.\n");
1100 initialize_purex_header:
1107 qla24xx_queue_purex_item(scsi_qla_host_t *vha, struct purex_item *pkt,
1108 void (*process_item)(struct scsi_qla_host *vha,
1109 struct purex_item *pkt))
1111 struct purex_list *list = &vha->purex_list;
1114 pkt->process_item = process_item;
1116 spin_lock_irqsave(&list->lock, flags);
1117 list_add_tail(&pkt->list, &list->head);
1118 spin_unlock_irqrestore(&list->lock, flags);
1120 set_bit(PROCESS_PUREX_IOCB, &vha->dpc_flags);
1124 * qla24xx_copy_std_pkt() - Copy over purex ELS which is
1125 * contained in a single IOCB.
1127 * @vha: SCSI driver HA context
1130 static struct purex_item
1131 *qla24xx_copy_std_pkt(struct scsi_qla_host *vha, void *pkt)
1133 struct purex_item *item;
1135 item = qla24xx_alloc_purex_item(vha,
1136 QLA_DEFAULT_PAYLOAD_SIZE);
1140 memcpy(&item->iocb, pkt, sizeof(item->iocb));
1145 * qla27xx_copy_fpin_pkt() - Copy over fpin packets that can
1146 * span over multiple IOCBs.
1147 * @vha: SCSI driver HA context
1149 * @rsp: Response queue
1151 static struct purex_item *
1152 qla27xx_copy_fpin_pkt(struct scsi_qla_host *vha, void **pkt,
1153 struct rsp_que **rsp)
1155 struct purex_entry_24xx *purex = *pkt;
1156 struct rsp_que *rsp_q = *rsp;
1157 sts_cont_entry_t *new_pkt;
1158 uint16_t no_bytes = 0, total_bytes = 0, pending_bytes = 0;
1159 uint16_t buffer_copy_offset = 0;
1160 uint16_t entry_count, entry_count_remaining;
1161 struct purex_item *item;
1162 void *fpin_pkt = NULL;
1164 total_bytes = (le16_to_cpu(purex->frame_size) & 0x0FFF)
1165 - PURX_ELS_HEADER_SIZE;
1166 pending_bytes = total_bytes;
1167 entry_count = entry_count_remaining = purex->entry_count;
1168 no_bytes = (pending_bytes > sizeof(purex->els_frame_payload)) ?
1169 sizeof(purex->els_frame_payload) : pending_bytes;
1170 ql_log(ql_log_info, vha, 0x509a,
1171 "FPIN ELS, frame_size 0x%x, entry count %d\n",
1172 total_bytes, entry_count);
1174 item = qla24xx_alloc_purex_item(vha, total_bytes);
1178 fpin_pkt = &item->iocb;
1180 memcpy(fpin_pkt, &purex->els_frame_payload[0], no_bytes);
1181 buffer_copy_offset += no_bytes;
1182 pending_bytes -= no_bytes;
1183 --entry_count_remaining;
1185 ((response_t *)purex)->signature = RESPONSE_PROCESSED;
1189 while ((total_bytes > 0) && (entry_count_remaining > 0)) {
1190 if (rsp_q->ring_ptr->signature == RESPONSE_PROCESSED) {
1191 ql_dbg(ql_dbg_async, vha, 0x5084,
1192 "Ran out of IOCBs, partial data 0x%x\n",
1193 buffer_copy_offset);
1198 new_pkt = (sts_cont_entry_t *)rsp_q->ring_ptr;
1201 if (new_pkt->entry_type != STATUS_CONT_TYPE) {
1202 ql_log(ql_log_warn, vha, 0x507a,
1203 "Unexpected IOCB type, partial data 0x%x\n",
1204 buffer_copy_offset);
1208 rsp_q->ring_index++;
1209 if (rsp_q->ring_index == rsp_q->length) {
1210 rsp_q->ring_index = 0;
1211 rsp_q->ring_ptr = rsp_q->ring;
1215 no_bytes = (pending_bytes > sizeof(new_pkt->data)) ?
1216 sizeof(new_pkt->data) : pending_bytes;
1217 if ((buffer_copy_offset + no_bytes) <= total_bytes) {
1218 memcpy(((uint8_t *)fpin_pkt +
1219 buffer_copy_offset), new_pkt->data,
1221 buffer_copy_offset += no_bytes;
1222 pending_bytes -= no_bytes;
1223 --entry_count_remaining;
1225 ql_log(ql_log_warn, vha, 0x5044,
1226 "Attempt to copy more that we got, optimizing..%x\n",
1227 buffer_copy_offset);
1228 memcpy(((uint8_t *)fpin_pkt +
1229 buffer_copy_offset), new_pkt->data,
1230 total_bytes - buffer_copy_offset);
1233 ((response_t *)new_pkt)->signature = RESPONSE_PROCESSED;
1237 if (pending_bytes != 0 || entry_count_remaining != 0) {
1238 ql_log(ql_log_fatal, vha, 0x508b,
1239 "Dropping partial FPIN, underrun bytes = 0x%x, entry cnts 0x%x\n",
1240 total_bytes, entry_count_remaining);
1241 qla24xx_free_purex_item(item);
1244 } while (entry_count_remaining > 0);
1245 host_to_fcp_swap((uint8_t *)&item->iocb, total_bytes);
1250 * qla2x00_async_event() - Process aynchronous events.
1251 * @vha: SCSI driver HA context
1252 * @rsp: response queue
1253 * @mb: Mailbox registers (0 - 3)
1256 qla2x00_async_event(scsi_qla_host_t *vha, struct rsp_que *rsp, uint16_t *mb)
1258 uint16_t handle_cnt;
1260 uint32_t handles[5];
1261 struct qla_hw_data *ha = vha->hw;
1262 struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
1263 struct device_reg_24xx __iomem *reg24 = &ha->iobase->isp24;
1264 struct device_reg_82xx __iomem *reg82 = &ha->iobase->isp82;
1265 uint32_t rscn_entry, host_pid;
1266 unsigned long flags;
1267 fc_port_t *fcport = NULL;
1269 if (!vha->hw->flags.fw_started) {
1270 ql_log(ql_log_warn, vha, 0x50ff,
1271 "Dropping AEN - %04x %04x %04x %04x.\n",
1272 mb[0], mb[1], mb[2], mb[3]);
1276 /* Setup to process RIO completion. */
1278 if (IS_CNA_CAPABLE(ha))
1281 case MBA_SCSI_COMPLETION:
1282 handles[0] = make_handle(mb[2], mb[1]);
1285 case MBA_CMPLT_1_16BIT:
1288 mb[0] = MBA_SCSI_COMPLETION;
1290 case MBA_CMPLT_2_16BIT:
1294 mb[0] = MBA_SCSI_COMPLETION;
1296 case MBA_CMPLT_3_16BIT:
1301 mb[0] = MBA_SCSI_COMPLETION;
1303 case MBA_CMPLT_4_16BIT:
1307 handles[3] = (uint32_t)RD_MAILBOX_REG(ha, reg, 6);
1309 mb[0] = MBA_SCSI_COMPLETION;
1311 case MBA_CMPLT_5_16BIT:
1315 handles[3] = (uint32_t)RD_MAILBOX_REG(ha, reg, 6);
1316 handles[4] = (uint32_t)RD_MAILBOX_REG(ha, reg, 7);
1318 mb[0] = MBA_SCSI_COMPLETION;
1320 case MBA_CMPLT_2_32BIT:
1321 handles[0] = make_handle(mb[2], mb[1]);
1322 handles[1] = make_handle(RD_MAILBOX_REG(ha, reg, 7),
1323 RD_MAILBOX_REG(ha, reg, 6));
1325 mb[0] = MBA_SCSI_COMPLETION;
1332 case MBA_SCSI_COMPLETION: /* Fast Post */
1333 if (!vha->flags.online)
1336 for (cnt = 0; cnt < handle_cnt; cnt++)
1337 qla2x00_process_completed_request(vha, rsp->req,
1341 case MBA_RESET: /* Reset */
1342 ql_dbg(ql_dbg_async, vha, 0x5002,
1343 "Asynchronous RESET.\n");
1345 set_bit(RESET_MARKER_NEEDED, &vha->dpc_flags);
1348 case MBA_SYSTEM_ERR: /* System Error */
1353 if (IS_QLA81XX(ha) || IS_QLA83XX(ha) ||
1354 IS_QLA27XX(ha) || IS_QLA28XX(ha)) {
1357 m[0] = rd_reg_word(®24->mailbox4);
1358 m[1] = rd_reg_word(®24->mailbox5);
1359 m[2] = rd_reg_word(®24->mailbox6);
1360 mbx = m[3] = rd_reg_word(®24->mailbox7);
1362 ql_log(ql_log_warn, vha, 0x5003,
1363 "ISP System Error - mbx1=%xh mbx2=%xh mbx3=%xh mbx4=%xh mbx5=%xh mbx6=%xh mbx7=%xh.\n",
1364 mb[1], mb[2], mb[3], m[0], m[1], m[2], m[3]);
1366 ql_log(ql_log_warn, vha, 0x5003,
1367 "ISP System Error - mbx1=%xh mbx2=%xh mbx3=%xh.\n ",
1368 mb[1], mb[2], mb[3]);
1370 if ((IS_QLA27XX(ha) || IS_QLA28XX(ha)) &&
1371 rd_reg_word(®24->mailbox7) & BIT_8)
1372 ha->isp_ops->mpi_fw_dump(vha, 1);
1373 ha->isp_ops->fw_dump(vha);
1374 ha->flags.fw_init_done = 0;
1377 if (IS_FWI2_CAPABLE(ha)) {
1378 if (mb[1] == 0 && mb[2] == 0) {
1379 ql_log(ql_log_fatal, vha, 0x5004,
1380 "Unrecoverable Hardware Error: adapter "
1381 "marked OFFLINE!\n");
1382 vha->flags.online = 0;
1383 vha->device_flags |= DFLG_DEV_FAILED;
1385 /* Check to see if MPI timeout occurred */
1386 if ((mbx & MBX_3) && (ha->port_no == 0))
1387 set_bit(MPI_RESET_NEEDED,
1390 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
1392 } else if (mb[1] == 0) {
1393 ql_log(ql_log_fatal, vha, 0x5005,
1394 "Unrecoverable Hardware Error: adapter marked "
1396 vha->flags.online = 0;
1397 vha->device_flags |= DFLG_DEV_FAILED;
1399 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
1402 case MBA_REQ_TRANSFER_ERR: /* Request Transfer Error */
1403 ql_log(ql_log_warn, vha, 0x5006,
1404 "ISP Request Transfer Error (%x).\n", mb[1]);
1408 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
1411 case MBA_RSP_TRANSFER_ERR: /* Response Transfer Error */
1412 ql_log(ql_log_warn, vha, 0x5007,
1413 "ISP Response Transfer Error (%x).\n", mb[1]);
1417 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
1420 case MBA_WAKEUP_THRES: /* Request Queue Wake-up */
1421 ql_dbg(ql_dbg_async, vha, 0x5008,
1422 "Asynchronous WAKEUP_THRES (%x).\n", mb[1]);
1425 case MBA_LOOP_INIT_ERR:
1426 ql_log(ql_log_warn, vha, 0x5090,
1427 "LOOP INIT ERROR (%x).\n", mb[1]);
1428 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
1431 case MBA_LIP_OCCURRED: /* Loop Initialization Procedure */
1432 ha->flags.lip_ae = 1;
1434 ql_dbg(ql_dbg_async, vha, 0x5009,
1435 "LIP occurred (%x).\n", mb[1]);
1437 if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
1438 atomic_set(&vha->loop_state, LOOP_DOWN);
1439 atomic_set(&vha->loop_down_timer, LOOP_DOWN_TIME);
1440 qla2x00_mark_all_devices_lost(vha);
1444 atomic_set(&vha->vp_state, VP_FAILED);
1445 fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
1448 set_bit(REGISTER_FC4_NEEDED, &vha->dpc_flags);
1449 set_bit(REGISTER_FDMI_NEEDED, &vha->dpc_flags);
1451 vha->flags.management_server_logged_in = 0;
1452 qla2x00_post_aen_work(vha, FCH_EVT_LIP, mb[1]);
1455 case MBA_LOOP_UP: /* Loop Up Event */
1456 if (IS_QLA2100(ha) || IS_QLA2200(ha))
1457 ha->link_data_rate = PORT_SPEED_1GB;
1459 ha->link_data_rate = mb[1];
1461 ql_log(ql_log_info, vha, 0x500a,
1462 "LOOP UP detected (%s Gbps).\n",
1463 qla2x00_get_link_speed_str(ha, ha->link_data_rate));
1465 if (IS_QLA83XX(ha) || IS_QLA27XX(ha) || IS_QLA28XX(ha)) {
1467 ql_log(ql_log_info, vha, 0x11a0,
1468 "FEC=enabled (link up).\n");
1471 vha->flags.management_server_logged_in = 0;
1472 qla2x00_post_aen_work(vha, FCH_EVT_LINKUP, ha->link_data_rate);
1474 if (vha->link_down_time < vha->hw->port_down_retry_count) {
1475 vha->short_link_down_cnt++;
1476 vha->link_down_time = QLA2XX_MAX_LINK_DOWN_TIME;
1481 case MBA_LOOP_DOWN: /* Loop Down Event */
1483 ha->flags.lip_ae = 0;
1484 ha->current_topology = 0;
1485 vha->link_down_time = 0;
1487 mbx = (IS_QLA81XX(ha) || IS_QLA8031(ha))
1488 ? rd_reg_word(®24->mailbox4) : 0;
1489 mbx = (IS_P3P_TYPE(ha)) ? rd_reg_word(®82->mailbox_out[4])
1491 ql_log(ql_log_info, vha, 0x500b,
1492 "LOOP DOWN detected (%x %x %x %x).\n",
1493 mb[1], mb[2], mb[3], mbx);
1495 if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
1496 atomic_set(&vha->loop_state, LOOP_DOWN);
1497 atomic_set(&vha->loop_down_timer, LOOP_DOWN_TIME);
1499 * In case of loop down, restore WWPN from
1500 * NVRAM in case of FA-WWPN capable ISP
1501 * Restore for Physical Port only
1504 if (ha->flags.fawwpn_enabled &&
1505 (ha->current_topology == ISP_CFG_F)) {
1506 memcpy(vha->port_name, ha->port_name, WWN_SIZE);
1507 fc_host_port_name(vha->host) =
1508 wwn_to_u64(vha->port_name);
1509 ql_dbg(ql_dbg_init + ql_dbg_verbose,
1510 vha, 0x00d8, "LOOP DOWN detected,"
1511 "restore WWPN %016llx\n",
1512 wwn_to_u64(vha->port_name));
1515 clear_bit(VP_CONFIG_OK, &vha->vp_flags);
1518 vha->device_flags |= DFLG_NO_CABLE;
1519 qla2x00_mark_all_devices_lost(vha);
1523 atomic_set(&vha->vp_state, VP_FAILED);
1524 fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
1527 vha->flags.management_server_logged_in = 0;
1528 ha->link_data_rate = PORT_SPEED_UNKNOWN;
1529 qla2x00_post_aen_work(vha, FCH_EVT_LINKDOWN, 0);
1532 case MBA_LIP_RESET: /* LIP reset occurred */
1533 ql_dbg(ql_dbg_async, vha, 0x500c,
1534 "LIP reset occurred (%x).\n", mb[1]);
1536 if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
1537 atomic_set(&vha->loop_state, LOOP_DOWN);
1538 atomic_set(&vha->loop_down_timer, LOOP_DOWN_TIME);
1539 qla2x00_mark_all_devices_lost(vha);
1543 atomic_set(&vha->vp_state, VP_FAILED);
1544 fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
1547 set_bit(RESET_MARKER_NEEDED, &vha->dpc_flags);
1549 ha->operating_mode = LOOP;
1550 vha->flags.management_server_logged_in = 0;
1551 qla2x00_post_aen_work(vha, FCH_EVT_LIPRESET, mb[1]);
1554 /* case MBA_DCBX_COMPLETE: */
1555 case MBA_POINT_TO_POINT: /* Point-to-Point */
1556 ha->flags.lip_ae = 0;
1561 if (IS_CNA_CAPABLE(ha)) {
1562 ql_dbg(ql_dbg_async, vha, 0x500d,
1563 "DCBX Completed -- %04x %04x %04x.\n",
1564 mb[1], mb[2], mb[3]);
1565 if (ha->notify_dcbx_comp && !vha->vp_idx)
1566 complete(&ha->dcbx_comp);
1569 ql_dbg(ql_dbg_async, vha, 0x500e,
1570 "Asynchronous P2P MODE received.\n");
1573 * Until there's a transition from loop down to loop up, treat
1574 * this as loop down only.
1576 if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
1577 atomic_set(&vha->loop_state, LOOP_DOWN);
1578 if (!atomic_read(&vha->loop_down_timer))
1579 atomic_set(&vha->loop_down_timer,
1582 qla2x00_mark_all_devices_lost(vha);
1586 atomic_set(&vha->vp_state, VP_FAILED);
1587 fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
1590 if (!(test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags)))
1591 set_bit(RESET_MARKER_NEEDED, &vha->dpc_flags);
1593 set_bit(REGISTER_FC4_NEEDED, &vha->dpc_flags);
1594 set_bit(REGISTER_FDMI_NEEDED, &vha->dpc_flags);
1596 vha->flags.management_server_logged_in = 0;
1599 case MBA_CHG_IN_CONNECTION: /* Change in connection mode */
1603 ql_dbg(ql_dbg_async, vha, 0x500f,
1604 "Configuration change detected: value=%x.\n", mb[1]);
1606 if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
1607 atomic_set(&vha->loop_state, LOOP_DOWN);
1608 if (!atomic_read(&vha->loop_down_timer))
1609 atomic_set(&vha->loop_down_timer,
1611 qla2x00_mark_all_devices_lost(vha);
1615 atomic_set(&vha->vp_state, VP_FAILED);
1616 fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
1619 set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
1620 set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
1623 case MBA_PORT_UPDATE: /* Port database update */
1625 * Handle only global and vn-port update events
1628 * mb[1] = N_Port handle of changed port
1629 * OR 0xffff for global event
1630 * mb[2] = New login state
1631 * 7 = Port logged out
1632 * mb[3] = LSB is vp_idx, 0xff = all vps
1634 * Skip processing if:
1635 * Event is global, vp_idx is NOT all vps,
1636 * vp_idx does not match
1637 * Event is not global, vp_idx does not match
1639 if (IS_QLA2XXX_MIDTYPE(ha) &&
1640 ((mb[1] == 0xffff && (mb[3] & 0xff) != 0xff) ||
1641 (mb[1] != 0xffff)) && vha->vp_idx != (mb[3] & 0xff))
1645 ql_dbg(ql_dbg_async, vha, 0x5010,
1646 "Port %s %04x %04x %04x.\n",
1647 mb[1] == 0xffff ? "unavailable" : "logout",
1648 mb[1], mb[2], mb[3]);
1650 if (mb[1] == 0xffff)
1651 goto global_port_update;
1653 if (mb[1] == NPH_SNS_LID(ha)) {
1654 set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
1655 set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
1659 /* use handle_cnt for loop id/nport handle */
1660 if (IS_FWI2_CAPABLE(ha))
1661 handle_cnt = NPH_SNS;
1663 handle_cnt = SIMPLE_NAME_SERVER;
1664 if (mb[1] == handle_cnt) {
1665 set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
1666 set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
1671 fcport = qla2x00_find_fcport_by_loopid(vha, mb[1]);
1674 if (atomic_read(&fcport->state) != FCS_ONLINE)
1676 ql_dbg(ql_dbg_async, vha, 0x508a,
1677 "Marking port lost loopid=%04x portid=%06x.\n",
1678 fcport->loop_id, fcport->d_id.b24);
1679 if (qla_ini_mode_enabled(vha)) {
1680 fcport->logout_on_delete = 0;
1681 qlt_schedule_sess_for_deletion(fcport);
1686 if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
1687 atomic_set(&vha->loop_state, LOOP_DOWN);
1688 atomic_set(&vha->loop_down_timer,
1690 vha->device_flags |= DFLG_NO_CABLE;
1691 qla2x00_mark_all_devices_lost(vha);
1695 atomic_set(&vha->vp_state, VP_FAILED);
1696 fc_vport_set_state(vha->fc_vport,
1698 qla2x00_mark_all_devices_lost(vha);
1701 vha->flags.management_server_logged_in = 0;
1702 ha->link_data_rate = PORT_SPEED_UNKNOWN;
1707 * If PORT UPDATE is global (received LIP_OCCURRED/LIP_RESET
1708 * event etc. earlier indicating loop is down) then process
1709 * it. Otherwise ignore it and Wait for RSCN to come in.
1711 atomic_set(&vha->loop_down_timer, 0);
1712 if (atomic_read(&vha->loop_state) != LOOP_DOWN &&
1713 !ha->flags.n2n_ae &&
1714 atomic_read(&vha->loop_state) != LOOP_DEAD) {
1715 ql_dbg(ql_dbg_async, vha, 0x5011,
1716 "Asynchronous PORT UPDATE ignored %04x/%04x/%04x.\n",
1717 mb[1], mb[2], mb[3]);
1721 ql_dbg(ql_dbg_async, vha, 0x5012,
1722 "Port database changed %04x %04x %04x.\n",
1723 mb[1], mb[2], mb[3]);
1726 * Mark all devices as missing so we will login again.
1728 atomic_set(&vha->loop_state, LOOP_UP);
1729 vha->scan.scan_retry = 0;
1731 set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
1732 set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
1733 set_bit(VP_CONFIG_OK, &vha->vp_flags);
1736 case MBA_RSCN_UPDATE: /* State Change Registration */
1737 /* Check if the Vport has issued a SCR */
1738 if (vha->vp_idx && test_bit(VP_SCR_NEEDED, &vha->vp_flags))
1740 /* Only handle SCNs for our Vport index. */
1741 if (ha->flags.npiv_supported && vha->vp_idx != (mb[3] & 0xff))
1744 ql_log(ql_log_warn, vha, 0x5013,
1745 "RSCN database changed -- %04x %04x %04x.\n",
1746 mb[1], mb[2], mb[3]);
1748 rscn_entry = ((mb[1] & 0xff) << 16) | mb[2];
1749 host_pid = (vha->d_id.b.domain << 16) | (vha->d_id.b.area << 8)
1750 | vha->d_id.b.al_pa;
1751 if (rscn_entry == host_pid) {
1752 ql_dbg(ql_dbg_async, vha, 0x5014,
1753 "Ignoring RSCN update to local host "
1754 "port ID (%06x).\n", host_pid);
1758 /* Ignore reserved bits from RSCN-payload. */
1759 rscn_entry = ((mb[1] & 0x3ff) << 16) | mb[2];
1761 /* Skip RSCNs for virtual ports on the same physical port */
1762 if (qla2x00_is_a_vp_did(vha, rscn_entry))
1765 atomic_set(&vha->loop_down_timer, 0);
1766 vha->flags.management_server_logged_in = 0;
1768 struct event_arg ea;
1770 memset(&ea, 0, sizeof(ea));
1771 ea.id.b24 = rscn_entry;
1772 ea.id.b.rsvd_1 = rscn_entry >> 24;
1773 qla2x00_handle_rscn(vha, &ea);
1774 qla2x00_post_aen_work(vha, FCH_EVT_RSCN, rscn_entry);
1777 case MBA_CONGN_NOTI_RECV:
1778 if (!ha->flags.scm_enabled ||
1779 mb[1] != QLA_CON_PRIMITIVE_RECEIVED)
1782 if (mb[2] == QLA_CONGESTION_ARB_WARNING) {
1783 ql_dbg(ql_dbg_async, vha, 0x509b,
1784 "Congestion Warning %04x %04x.\n", mb[1], mb[2]);
1785 } else if (mb[2] == QLA_CONGESTION_ARB_ALARM) {
1786 ql_log(ql_log_warn, vha, 0x509b,
1787 "Congestion Alarm %04x %04x.\n", mb[1], mb[2]);
1790 /* case MBA_RIO_RESPONSE: */
1791 case MBA_ZIO_RESPONSE:
1792 ql_dbg(ql_dbg_async, vha, 0x5015,
1793 "[R|Z]IO update completion.\n");
1795 if (IS_FWI2_CAPABLE(ha))
1796 qla24xx_process_response_queue(vha, rsp);
1798 qla2x00_process_response_queue(rsp);
1801 case MBA_DISCARD_RND_FRAME:
1802 ql_dbg(ql_dbg_async, vha, 0x5016,
1803 "Discard RND Frame -- %04x %04x %04x.\n",
1804 mb[1], mb[2], mb[3]);
1805 vha->interface_err_cnt++;
1808 case MBA_TRACE_NOTIFICATION:
1809 ql_dbg(ql_dbg_async, vha, 0x5017,
1810 "Trace Notification -- %04x %04x.\n", mb[1], mb[2]);
1813 case MBA_ISP84XX_ALERT:
1814 ql_dbg(ql_dbg_async, vha, 0x5018,
1815 "ISP84XX Alert Notification -- %04x %04x %04x.\n",
1816 mb[1], mb[2], mb[3]);
1818 spin_lock_irqsave(&ha->cs84xx->access_lock, flags);
1820 case A84_PANIC_RECOVERY:
1821 ql_log(ql_log_info, vha, 0x5019,
1822 "Alert 84XX: panic recovery %04x %04x.\n",
1825 case A84_OP_LOGIN_COMPLETE:
1826 ha->cs84xx->op_fw_version = mb[3] << 16 | mb[2];
1827 ql_log(ql_log_info, vha, 0x501a,
1828 "Alert 84XX: firmware version %x.\n",
1829 ha->cs84xx->op_fw_version);
1831 case A84_DIAG_LOGIN_COMPLETE:
1832 ha->cs84xx->diag_fw_version = mb[3] << 16 | mb[2];
1833 ql_log(ql_log_info, vha, 0x501b,
1834 "Alert 84XX: diagnostic firmware version %x.\n",
1835 ha->cs84xx->diag_fw_version);
1837 case A84_GOLD_LOGIN_COMPLETE:
1838 ha->cs84xx->diag_fw_version = mb[3] << 16 | mb[2];
1839 ha->cs84xx->fw_update = 1;
1840 ql_log(ql_log_info, vha, 0x501c,
1841 "Alert 84XX: gold firmware version %x.\n",
1842 ha->cs84xx->gold_fw_version);
1845 ql_log(ql_log_warn, vha, 0x501d,
1846 "Alert 84xx: Invalid Alert %04x %04x %04x.\n",
1847 mb[1], mb[2], mb[3]);
1849 spin_unlock_irqrestore(&ha->cs84xx->access_lock, flags);
1851 case MBA_DCBX_START:
1852 ql_dbg(ql_dbg_async, vha, 0x501e,
1853 "DCBX Started -- %04x %04x %04x.\n",
1854 mb[1], mb[2], mb[3]);
1856 case MBA_DCBX_PARAM_UPDATE:
1857 ql_dbg(ql_dbg_async, vha, 0x501f,
1858 "DCBX Parameters Updated -- %04x %04x %04x.\n",
1859 mb[1], mb[2], mb[3]);
1861 case MBA_FCF_CONF_ERR:
1862 ql_dbg(ql_dbg_async, vha, 0x5020,
1863 "FCF Configuration Error -- %04x %04x %04x.\n",
1864 mb[1], mb[2], mb[3]);
1866 case MBA_IDC_NOTIFY:
1867 if (IS_QLA8031(vha->hw) || IS_QLA8044(ha)) {
1868 mb[4] = rd_reg_word(®24->mailbox4);
1869 if (((mb[2] & 0x7fff) == MBC_PORT_RESET ||
1870 (mb[2] & 0x7fff) == MBC_SET_PORT_CONFIG) &&
1871 (mb[4] & INTERNAL_LOOPBACK_MASK) != 0) {
1872 set_bit(ISP_QUIESCE_NEEDED, &vha->dpc_flags);
1874 * Extend loop down timer since port is active.
1876 if (atomic_read(&vha->loop_state) == LOOP_DOWN)
1877 atomic_set(&vha->loop_down_timer,
1879 qla2xxx_wake_dpc(vha);
1883 case MBA_IDC_COMPLETE:
1884 if (ha->notify_lb_portup_comp && !vha->vp_idx)
1885 complete(&ha->lb_portup_comp);
1887 case MBA_IDC_TIME_EXT:
1888 if (IS_QLA81XX(vha->hw) || IS_QLA8031(vha->hw) ||
1890 qla81xx_idc_event(vha, mb[0], mb[1]);
1894 if (IS_QLA27XX(ha) || IS_QLA28XX(ha)) {
1896 qla27xx_handle_8200_aen(vha, mb);
1897 } else if (IS_QLA83XX(ha)) {
1898 mb[4] = rd_reg_word(®24->mailbox4);
1899 mb[5] = rd_reg_word(®24->mailbox5);
1900 mb[6] = rd_reg_word(®24->mailbox6);
1901 mb[7] = rd_reg_word(®24->mailbox7);
1902 qla83xx_handle_8200_aen(vha, mb);
1904 ql_dbg(ql_dbg_async, vha, 0x5052,
1905 "skip Heartbeat processing mb0-3=[0x%04x] [0x%04x] [0x%04x] [0x%04x]\n",
1906 mb[0], mb[1], mb[2], mb[3]);
1910 case MBA_DPORT_DIAGNOSTICS:
1911 if ((mb[1] & 0xF) == AEN_DONE_DIAG_TEST_WITH_NOERR ||
1912 (mb[1] & 0xF) == AEN_DONE_DIAG_TEST_WITH_ERR)
1913 vha->dport_status &= ~DPORT_DIAG_IN_PROGRESS;
1914 ql_dbg(ql_dbg_async, vha, 0x5052,
1915 "D-Port Diagnostics: %04x %04x %04x %04x\n",
1916 mb[0], mb[1], mb[2], mb[3]);
1917 memcpy(vha->dport_data, mb, sizeof(vha->dport_data));
1918 if (IS_QLA83XX(ha) || IS_QLA27XX(ha) || IS_QLA28XX(ha)) {
1919 static char *results[] = {
1920 "start", "done(pass)", "done(error)", "undefined" };
1921 static char *types[] = {
1922 "none", "dynamic", "static", "other" };
1923 uint result = mb[1] >> 0 & 0x3;
1924 uint type = mb[1] >> 6 & 0x3;
1925 uint sw = mb[1] >> 15 & 0x1;
1926 ql_dbg(ql_dbg_async, vha, 0x5052,
1927 "D-Port Diagnostics: result=%s type=%s [sw=%u]\n",
1928 results[result], types[type], sw);
1930 static char *reasons[] = {
1931 "reserved", "unexpected reject",
1932 "unexpected phase", "retry exceeded",
1933 "timed out", "not supported",
1935 uint reason = mb[2] >> 0 & 0xf;
1936 uint phase = mb[2] >> 12 & 0xf;
1937 ql_dbg(ql_dbg_async, vha, 0x5052,
1938 "D-Port Diagnostics: reason=%s phase=%u \n",
1939 reason < 7 ? reasons[reason] : "other",
1945 case MBA_TEMPERATURE_ALERT:
1946 if (IS_QLA27XX(ha) || IS_QLA28XX(ha))
1947 display_Laser_info(vha, mb[1], mb[2], mb[3]);
1948 ql_dbg(ql_dbg_async, vha, 0x505e,
1949 "TEMPERATURE ALERT: %04x %04x %04x\n", mb[1], mb[2], mb[3]);
1952 case MBA_TRANS_INSERT:
1953 ql_dbg(ql_dbg_async, vha, 0x5091,
1954 "Transceiver Insertion: %04x\n", mb[1]);
1955 set_bit(DETECT_SFP_CHANGE, &vha->dpc_flags);
1958 case MBA_TRANS_REMOVE:
1959 ql_dbg(ql_dbg_async, vha, 0x5091, "Transceiver Removal\n");
1963 ql_dbg(ql_dbg_async, vha, 0x5057,
1964 "Unknown AEN:%04x %04x %04x %04x\n",
1965 mb[0], mb[1], mb[2], mb[3]);
1968 qlt_async_event(mb[0], vha, mb);
1970 if (!vha->vp_idx && ha->num_vhosts)
1971 qla2x00_alert_all_vps(rsp, mb);
1975 * qla2x00_process_completed_request() - Process a Fast Post response.
1976 * @vha: SCSI driver HA context
1977 * @req: request queue
1981 qla2x00_process_completed_request(struct scsi_qla_host *vha,
1982 struct req_que *req, uint32_t index)
1985 struct qla_hw_data *ha = vha->hw;
1987 /* Validate handle. */
1988 if (index >= req->num_outstanding_cmds) {
1989 ql_log(ql_log_warn, vha, 0x3014,
1990 "Invalid SCSI command index (%x).\n", index);
1992 if (IS_P3P_TYPE(ha))
1993 set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
1995 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
1999 sp = req->outstanding_cmds[index];
2001 /* Free outstanding command slot. */
2002 req->outstanding_cmds[index] = NULL;
2004 /* Save ISP completion status */
2005 sp->done(sp, DID_OK << 16);
2007 ql_log(ql_log_warn, vha, 0x3016, "Invalid SCSI SRB.\n");
2009 if (IS_P3P_TYPE(ha))
2010 set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
2012 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
2017 qla_get_sp_from_handle(scsi_qla_host_t *vha, const char *func,
2018 struct req_que *req, void *iocb, u16 *ret_index)
2020 struct qla_hw_data *ha = vha->hw;
2021 sts_entry_t *pkt = iocb;
2025 if (pkt->handle == QLA_SKIP_HANDLE)
2028 index = LSW(pkt->handle);
2029 if (index >= req->num_outstanding_cmds) {
2030 ql_log(ql_log_warn, vha, 0x5031,
2031 "%s: Invalid command index (%x) type %8ph.\n",
2033 if (IS_P3P_TYPE(ha))
2034 set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
2036 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
2039 sp = req->outstanding_cmds[index];
2041 ql_log(ql_log_warn, vha, 0x5032,
2042 "%s: Invalid completion handle (%x) -- timed-out.\n",
2046 if (sp->handle != index) {
2047 ql_log(ql_log_warn, vha, 0x5033,
2048 "%s: SRB handle (%x) mismatch %x.\n", func,
2054 qla_put_fw_resources(sp->qpair, &sp->iores);
2059 qla2x00_get_sp_from_handle(scsi_qla_host_t *vha, const char *func,
2060 struct req_que *req, void *iocb)
2065 sp = qla_get_sp_from_handle(vha, func, req, iocb, &index);
2067 req->outstanding_cmds[index] = NULL;
2073 qla2x00_mbx_iocb_entry(scsi_qla_host_t *vha, struct req_que *req,
2074 struct mbx_entry *mbx)
2076 const char func[] = "MBX-IOCB";
2080 struct srb_iocb *lio;
2084 sp = qla2x00_get_sp_from_handle(vha, func, req, mbx);
2088 lio = &sp->u.iocb_cmd;
2090 fcport = sp->fcport;
2091 data = lio->u.logio.data;
2093 data[0] = MBS_COMMAND_ERROR;
2094 data[1] = lio->u.logio.flags & SRB_LOGIN_RETRIED ?
2095 QLA_LOGIO_LOGIN_RETRIED : 0;
2096 if (mbx->entry_status) {
2097 ql_dbg(ql_dbg_async, vha, 0x5043,
2098 "Async-%s error entry - hdl=%x portid=%02x%02x%02x "
2099 "entry-status=%x status=%x state-flag=%x "
2100 "status-flags=%x.\n", type, sp->handle,
2101 fcport->d_id.b.domain, fcport->d_id.b.area,
2102 fcport->d_id.b.al_pa, mbx->entry_status,
2103 le16_to_cpu(mbx->status), le16_to_cpu(mbx->state_flags),
2104 le16_to_cpu(mbx->status_flags));
2106 ql_dump_buffer(ql_dbg_async + ql_dbg_buffer, vha, 0x5029,
2112 status = le16_to_cpu(mbx->status);
2113 if (status == 0x30 && sp->type == SRB_LOGIN_CMD &&
2114 le16_to_cpu(mbx->mb0) == MBS_COMMAND_COMPLETE)
2116 if (!status && le16_to_cpu(mbx->mb0) == MBS_COMMAND_COMPLETE) {
2117 ql_dbg(ql_dbg_async, vha, 0x5045,
2118 "Async-%s complete - hdl=%x portid=%02x%02x%02x mbx1=%x.\n",
2119 type, sp->handle, fcport->d_id.b.domain,
2120 fcport->d_id.b.area, fcport->d_id.b.al_pa,
2121 le16_to_cpu(mbx->mb1));
2123 data[0] = MBS_COMMAND_COMPLETE;
2124 if (sp->type == SRB_LOGIN_CMD) {
2125 fcport->port_type = FCT_TARGET;
2126 if (le16_to_cpu(mbx->mb1) & BIT_0)
2127 fcport->port_type = FCT_INITIATOR;
2128 else if (le16_to_cpu(mbx->mb1) & BIT_1)
2129 fcport->flags |= FCF_FCP2_DEVICE;
2134 data[0] = le16_to_cpu(mbx->mb0);
2136 case MBS_PORT_ID_USED:
2137 data[1] = le16_to_cpu(mbx->mb1);
2139 case MBS_LOOP_ID_USED:
2142 data[0] = MBS_COMMAND_ERROR;
2146 ql_log(ql_log_warn, vha, 0x5046,
2147 "Async-%s failed - hdl=%x portid=%02x%02x%02x status=%x "
2148 "mb0=%x mb1=%x mb2=%x mb6=%x mb7=%x.\n", type, sp->handle,
2149 fcport->d_id.b.domain, fcport->d_id.b.area, fcport->d_id.b.al_pa,
2150 status, le16_to_cpu(mbx->mb0), le16_to_cpu(mbx->mb1),
2151 le16_to_cpu(mbx->mb2), le16_to_cpu(mbx->mb6),
2152 le16_to_cpu(mbx->mb7));
2159 qla24xx_mbx_iocb_entry(scsi_qla_host_t *vha, struct req_que *req,
2160 struct mbx_24xx_entry *pkt)
2162 const char func[] = "MBX-IOCB2";
2163 struct qla_hw_data *ha = vha->hw;
2165 struct srb_iocb *si;
2169 sp = qla2x00_get_sp_from_handle(vha, func, req, pkt);
2173 if (sp->type == SRB_SCSI_CMD ||
2174 sp->type == SRB_NVME_CMD ||
2175 sp->type == SRB_TM_CMD) {
2176 ql_log(ql_log_warn, vha, 0x509d,
2177 "Inconsistent event entry type %d\n", sp->type);
2178 if (IS_P3P_TYPE(ha))
2179 set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
2181 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
2185 si = &sp->u.iocb_cmd;
2186 sz = min(ARRAY_SIZE(pkt->mb), ARRAY_SIZE(sp->u.iocb_cmd.u.mbx.in_mb));
2188 for (i = 0; i < sz; i++)
2189 si->u.mbx.in_mb[i] = pkt->mb[i];
2191 res = (si->u.mbx.in_mb[0] & MBS_MASK);
2197 qla24xxx_nack_iocb_entry(scsi_qla_host_t *vha, struct req_que *req,
2198 struct nack_to_isp *pkt)
2200 const char func[] = "nack";
2204 sp = qla2x00_get_sp_from_handle(vha, func, req, pkt);
2208 if (pkt->u.isp2x.status != cpu_to_le16(NOTIFY_ACK_SUCCESS))
2209 res = QLA_FUNCTION_FAILED;
2215 qla2x00_ct_entry(scsi_qla_host_t *vha, struct req_que *req,
2216 sts_entry_t *pkt, int iocb_type)
2218 const char func[] = "CT_IOCB";
2221 struct bsg_job *bsg_job;
2222 struct fc_bsg_reply *bsg_reply;
2223 uint16_t comp_status;
2226 sp = qla2x00_get_sp_from_handle(vha, func, req, pkt);
2232 bsg_job = sp->u.bsg_job;
2233 bsg_reply = bsg_job->reply;
2235 type = "ct pass-through";
2237 comp_status = le16_to_cpu(pkt->comp_status);
2240 * return FC_CTELS_STATUS_OK and leave the decoding of the ELS/CT
2241 * fc payload to the caller
2243 bsg_reply->reply_data.ctels_reply.status = FC_CTELS_STATUS_OK;
2244 bsg_job->reply_len = sizeof(struct fc_bsg_reply);
2246 if (comp_status != CS_COMPLETE) {
2247 if (comp_status == CS_DATA_UNDERRUN) {
2249 bsg_reply->reply_payload_rcv_len =
2250 le16_to_cpu(pkt->rsp_info_len);
2252 ql_log(ql_log_warn, vha, 0x5048,
2253 "CT pass-through-%s error comp_status=0x%x total_byte=0x%x.\n",
2255 bsg_reply->reply_payload_rcv_len);
2257 ql_log(ql_log_warn, vha, 0x5049,
2258 "CT pass-through-%s error comp_status=0x%x.\n",
2260 res = DID_ERROR << 16;
2261 bsg_reply->reply_payload_rcv_len = 0;
2263 ql_dump_buffer(ql_dbg_async + ql_dbg_buffer, vha, 0x5035,
2267 bsg_reply->reply_payload_rcv_len =
2268 bsg_job->reply_payload.payload_len;
2269 bsg_job->reply_len = 0;
2272 case SRB_CT_PTHRU_CMD:
2274 * borrowing sts_entry_24xx.comp_status.
2275 * same location as ct_entry_24xx.comp_status
2277 res = qla2x00_chk_ms_status(vha, (ms_iocb_entry_t *)pkt,
2278 (struct ct_sns_rsp *)sp->u.iocb_cmd.u.ctarg.rsp,
2287 qla24xx_els_ct_entry(scsi_qla_host_t *v, struct req_que *req,
2288 struct sts_entry_24xx *pkt, int iocb_type)
2290 struct els_sts_entry_24xx *ese = (struct els_sts_entry_24xx *)pkt;
2291 const char func[] = "ELS_CT_IOCB";
2294 struct bsg_job *bsg_job;
2295 struct fc_bsg_reply *bsg_reply;
2296 uint16_t comp_status;
2297 uint32_t fw_status[3];
2299 struct srb_iocb *els;
2301 scsi_qla_host_t *vha;
2302 struct els_sts_entry_24xx *e = (struct els_sts_entry_24xx *)pkt;
2304 sp = qla2x00_get_sp_from_handle(v, func, req, pkt);
2307 bsg_job = sp->u.bsg_job;
2312 comp_status = fw_status[0] = le16_to_cpu(pkt->comp_status);
2313 fw_status[1] = le32_to_cpu(((struct els_sts_entry_24xx *)pkt)->error_subcode_1);
2314 fw_status[2] = le32_to_cpu(((struct els_sts_entry_24xx *)pkt)->error_subcode_2);
2317 case SRB_ELS_CMD_RPT:
2318 case SRB_ELS_CMD_HST:
2321 case SRB_ELS_CMD_HST_NOLOGIN:
2324 struct els_entry_24xx *els = (void *)pkt;
2325 struct qla_bsg_auth_els_request *p =
2326 (struct qla_bsg_auth_els_request *)bsg_job->request;
2328 ql_dbg(ql_dbg_user, vha, 0x700f,
2329 "%s %s. portid=%02x%02x%02x status %x xchg %x bsg ptr %p\n",
2330 __func__, sc_to_str(p->e.sub_cmd),
2331 e->d_id[2], e->d_id[1], e->d_id[0],
2332 comp_status, p->e.extra_rx_xchg_address, bsg_job);
2334 if (!(le16_to_cpu(els->control_flags) & ECF_PAYLOAD_DESCR_MASK)) {
2335 if (sp->remap.remapped) {
2336 n = sg_copy_from_buffer(bsg_job->reply_payload.sg_list,
2337 bsg_job->reply_payload.sg_cnt,
2340 ql_dbg(ql_dbg_user + ql_dbg_verbose, vha, 0x700e,
2341 "%s: SG copied %x of %x\n",
2342 __func__, n, sp->remap.rsp.len);
2344 ql_dbg(ql_dbg_user, vha, 0x700f,
2345 "%s: NOT REMAPPED (error)...!!!\n",
2352 type = "ct pass-through";
2355 type = "Driver ELS logo";
2356 if (iocb_type != ELS_IOCB_TYPE) {
2357 ql_dbg(ql_dbg_user, vha, 0x5047,
2358 "Completing %s: (%p) type=%d.\n",
2359 type, sp, sp->type);
2364 case SRB_CT_PTHRU_CMD:
2365 /* borrowing sts_entry_24xx.comp_status.
2366 same location as ct_entry_24xx.comp_status
2368 res = qla2x00_chk_ms_status(sp->vha, (ms_iocb_entry_t *)pkt,
2369 (struct ct_sns_rsp *)sp->u.iocb_cmd.u.ctarg.rsp,
2374 ql_dbg(ql_dbg_user, vha, 0x503e,
2375 "Unrecognized SRB: (%p) type=%d.\n", sp, sp->type);
2379 if (iocb_type == ELS_IOCB_TYPE) {
2380 els = &sp->u.iocb_cmd;
2381 els->u.els_plogi.fw_status[0] = cpu_to_le32(fw_status[0]);
2382 els->u.els_plogi.fw_status[1] = cpu_to_le32(fw_status[1]);
2383 els->u.els_plogi.fw_status[2] = cpu_to_le32(fw_status[2]);
2384 els->u.els_plogi.comp_status = cpu_to_le16(fw_status[0]);
2385 if (comp_status == CS_COMPLETE) {
2388 if (comp_status == CS_DATA_UNDERRUN) {
2390 els->u.els_plogi.len = cpu_to_le16(le32_to_cpu(
2391 ese->total_byte_count));
2393 if (sp->remap.remapped &&
2394 ((u8 *)sp->remap.rsp.buf)[0] == ELS_LS_ACC) {
2395 ql_dbg(ql_dbg_user, vha, 0x503f,
2396 "%s IOCB Done LS_ACC %02x%02x%02x -> %02x%02x%02x",
2397 __func__, e->s_id[0], e->s_id[2], e->s_id[1],
2398 e->d_id[2], e->d_id[1], e->d_id[0]);
2402 } else if (comp_status == CS_PORT_LOGGED_OUT) {
2403 ql_dbg(ql_dbg_disc, vha, 0x911e,
2404 "%s %d schedule session deletion\n",
2405 __func__, __LINE__);
2407 els->u.els_plogi.len = 0;
2408 res = DID_IMM_RETRY << 16;
2409 qlt_schedule_sess_for_deletion(sp->fcport);
2411 els->u.els_plogi.len = 0;
2412 res = DID_ERROR << 16;
2415 if (sp->remap.remapped &&
2416 ((u8 *)sp->remap.rsp.buf)[0] == ELS_LS_RJT) {
2418 ql_dbg(ql_dbg_user, vha, 0x503f,
2419 "%s IOCB Done LS_RJT hdl=%x comp_status=0x%x\n",
2420 type, sp->handle, comp_status);
2422 ql_dbg(ql_dbg_user, vha, 0x503f,
2423 "subcode 1=0x%x subcode 2=0x%x bytes=0x%x %02x%02x%02x -> %02x%02x%02x\n",
2424 fw_status[1], fw_status[2],
2425 le32_to_cpu(((struct els_sts_entry_24xx *)
2426 pkt)->total_byte_count),
2427 e->s_id[0], e->s_id[2], e->s_id[1],
2428 e->d_id[2], e->d_id[1], e->d_id[0]);
2430 if (sp->fcport && sp->fcport->flags & FCF_FCSP_DEVICE &&
2431 sp->type == SRB_ELS_CMD_HST_NOLOGIN) {
2432 ql_dbg(ql_dbg_edif, vha, 0x911e,
2433 "%s rcv reject. Sched delete\n", __func__);
2434 qlt_schedule_sess_for_deletion(sp->fcport);
2437 ql_log(ql_log_info, vha, 0x503f,
2438 "%s IOCB Done hdl=%x comp_status=0x%x\n",
2439 type, sp->handle, comp_status);
2440 ql_log(ql_log_info, vha, 0x503f,
2441 "subcode 1=0x%x subcode 2=0x%x bytes=0x%x %02x%02x%02x -> %02x%02x%02x\n",
2442 fw_status[1], fw_status[2],
2443 le32_to_cpu(((struct els_sts_entry_24xx *)
2444 pkt)->total_byte_count),
2445 e->s_id[0], e->s_id[2], e->s_id[1],
2446 e->d_id[2], e->d_id[1], e->d_id[0]);
2452 /* return FC_CTELS_STATUS_OK and leave the decoding of the ELS/CT
2453 * fc payload to the caller
2455 bsg_job = sp->u.bsg_job;
2456 bsg_reply = bsg_job->reply;
2457 bsg_reply->reply_data.ctels_reply.status = FC_CTELS_STATUS_OK;
2458 bsg_job->reply_len = sizeof(struct fc_bsg_reply) + sizeof(fw_status);
2460 if (comp_status != CS_COMPLETE) {
2461 if (comp_status == CS_DATA_UNDERRUN) {
2463 bsg_reply->reply_payload_rcv_len =
2464 le32_to_cpu(ese->total_byte_count);
2466 ql_dbg(ql_dbg_user, vha, 0x503f,
2467 "ELS-CT pass-through-%s error hdl=%x comp_status-status=0x%x "
2468 "error subcode 1=0x%x error subcode 2=0x%x total_byte = 0x%x.\n",
2469 type, sp->handle, comp_status, fw_status[1], fw_status[2],
2470 le32_to_cpu(ese->total_byte_count));
2472 ql_dbg(ql_dbg_user, vha, 0x5040,
2473 "ELS-CT pass-through-%s error hdl=%x comp_status-status=0x%x "
2474 "error subcode 1=0x%x error subcode 2=0x%x.\n",
2475 type, sp->handle, comp_status,
2476 le32_to_cpu(ese->error_subcode_1),
2477 le32_to_cpu(ese->error_subcode_2));
2478 res = DID_ERROR << 16;
2479 bsg_reply->reply_payload_rcv_len = 0;
2481 memcpy(bsg_job->reply + sizeof(struct fc_bsg_reply),
2482 fw_status, sizeof(fw_status));
2483 ql_dump_buffer(ql_dbg_user + ql_dbg_buffer, vha, 0x5056,
2488 bsg_reply->reply_payload_rcv_len = bsg_job->reply_payload.payload_len;
2489 bsg_job->reply_len = 0;
2497 qla24xx_logio_entry(scsi_qla_host_t *vha, struct req_que *req,
2498 struct logio_entry_24xx *logio)
2500 const char func[] = "LOGIO-IOCB";
2504 struct srb_iocb *lio;
2509 sp = qla2x00_get_sp_from_handle(vha, func, req, logio);
2513 lio = &sp->u.iocb_cmd;
2515 fcport = sp->fcport;
2516 data = lio->u.logio.data;
2518 data[0] = MBS_COMMAND_ERROR;
2519 data[1] = lio->u.logio.flags & SRB_LOGIN_RETRIED ?
2520 QLA_LOGIO_LOGIN_RETRIED : 0;
2521 if (logio->entry_status) {
2522 ql_log(ql_log_warn, fcport->vha, 0x5034,
2523 "Async-%s error entry - %8phC hdl=%x"
2524 "portid=%02x%02x%02x entry-status=%x.\n",
2525 type, fcport->port_name, sp->handle, fcport->d_id.b.domain,
2526 fcport->d_id.b.area, fcport->d_id.b.al_pa,
2527 logio->entry_status);
2528 ql_dump_buffer(ql_dbg_async + ql_dbg_buffer, vha, 0x504d,
2529 logio, sizeof(*logio));
2534 if (le16_to_cpu(logio->comp_status) == CS_COMPLETE) {
2535 ql_dbg(ql_dbg_async, sp->vha, 0x5036,
2536 "Async-%s complete: handle=%x pid=%06x wwpn=%8phC iop0=%x\n",
2537 type, sp->handle, fcport->d_id.b24, fcport->port_name,
2538 le32_to_cpu(logio->io_parameter[0]));
2540 vha->hw->exch_starvation = 0;
2541 data[0] = MBS_COMMAND_COMPLETE;
2543 if (sp->type == SRB_PRLI_CMD) {
2544 lio->u.logio.iop[0] =
2545 le32_to_cpu(logio->io_parameter[0]);
2546 lio->u.logio.iop[1] =
2547 le32_to_cpu(logio->io_parameter[1]);
2551 if (sp->type != SRB_LOGIN_CMD)
2554 lio->u.logio.iop[1] = le32_to_cpu(logio->io_parameter[5]);
2555 if (le32_to_cpu(logio->io_parameter[5]) & LIO_COMM_FEAT_FCSP)
2556 fcport->flags |= FCF_FCSP_DEVICE;
2558 iop[0] = le32_to_cpu(logio->io_parameter[0]);
2559 if (iop[0] & BIT_4) {
2560 fcport->port_type = FCT_TARGET;
2562 fcport->flags |= FCF_FCP2_DEVICE;
2563 } else if (iop[0] & BIT_5)
2564 fcport->port_type = FCT_INITIATOR;
2567 fcport->flags |= FCF_CONF_COMP_SUPPORTED;
2569 if (logio->io_parameter[7] || logio->io_parameter[8])
2570 fcport->supported_classes |= FC_COS_CLASS2;
2571 if (logio->io_parameter[9] || logio->io_parameter[10])
2572 fcport->supported_classes |= FC_COS_CLASS3;
2577 iop[0] = le32_to_cpu(logio->io_parameter[0]);
2578 iop[1] = le32_to_cpu(logio->io_parameter[1]);
2579 lio->u.logio.iop[0] = iop[0];
2580 lio->u.logio.iop[1] = iop[1];
2582 case LSC_SCODE_PORTID_USED:
2583 data[0] = MBS_PORT_ID_USED;
2584 data[1] = LSW(iop[1]);
2587 case LSC_SCODE_NPORT_USED:
2588 data[0] = MBS_LOOP_ID_USED;
2591 case LSC_SCODE_CMD_FAILED:
2592 if (iop[1] == 0x0606) {
2594 * PLOGI/PRLI Completed. We must have Recv PLOGI/PRLI,
2595 * Target side acked.
2597 data[0] = MBS_COMMAND_COMPLETE;
2600 data[0] = MBS_COMMAND_ERROR;
2602 case LSC_SCODE_NOXCB:
2603 vha->hw->exch_starvation++;
2604 if (vha->hw->exch_starvation > 5) {
2605 ql_log(ql_log_warn, vha, 0xd046,
2606 "Exchange starvation. Resetting RISC\n");
2608 vha->hw->exch_starvation = 0;
2610 if (IS_P3P_TYPE(vha->hw))
2611 set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
2613 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
2614 qla2xxx_wake_dpc(vha);
2618 data[0] = MBS_COMMAND_ERROR;
2623 ql_log(ql_log_warn, sp->vha, 0x5037, "Async-%s failed: "
2624 "handle=%x pid=%06x wwpn=%8phC comp_status=%x iop0=%x iop1=%x\n",
2625 type, sp->handle, fcport->d_id.b24, fcport->port_name,
2626 le16_to_cpu(logio->comp_status),
2627 le32_to_cpu(logio->io_parameter[0]),
2628 le32_to_cpu(logio->io_parameter[1]));
2630 ql_dbg(ql_dbg_disc, sp->vha, 0x5037, "Async-%s failed: "
2631 "handle=%x pid=%06x wwpn=%8phC comp_status=%x iop0=%x iop1=%x\n",
2632 type, sp->handle, fcport->d_id.b24, fcport->port_name,
2633 le16_to_cpu(logio->comp_status),
2634 le32_to_cpu(logio->io_parameter[0]),
2635 le32_to_cpu(logio->io_parameter[1]));
2642 qla24xx_tm_iocb_entry(scsi_qla_host_t *vha, struct req_que *req, void *tsk)
2644 const char func[] = "TMF-IOCB";
2648 struct srb_iocb *iocb;
2649 struct sts_entry_24xx *sts = (struct sts_entry_24xx *)tsk;
2652 sp = qla2x00_get_sp_from_handle(vha, func, req, tsk);
2656 comp_status = le16_to_cpu(sts->comp_status);
2657 iocb = &sp->u.iocb_cmd;
2659 fcport = sp->fcport;
2660 iocb->u.tmf.data = QLA_SUCCESS;
2662 if (sts->entry_status) {
2663 ql_log(ql_log_warn, fcport->vha, 0x5038,
2664 "Async-%s error - hdl=%x entry-status(%x).\n",
2665 type, sp->handle, sts->entry_status);
2666 iocb->u.tmf.data = QLA_FUNCTION_FAILED;
2667 } else if (sts->comp_status != cpu_to_le16(CS_COMPLETE)) {
2668 ql_log(ql_log_warn, fcport->vha, 0x5039,
2669 "Async-%s error - hdl=%x completion status(%x).\n",
2670 type, sp->handle, comp_status);
2671 iocb->u.tmf.data = QLA_FUNCTION_FAILED;
2672 } else if ((le16_to_cpu(sts->scsi_status) &
2673 SS_RESPONSE_INFO_LEN_VALID)) {
2674 host_to_fcp_swap(sts->data, sizeof(sts->data));
2675 if (le32_to_cpu(sts->rsp_data_len) < 4) {
2676 ql_log(ql_log_warn, fcport->vha, 0x503b,
2677 "Async-%s error - hdl=%x not enough response(%d).\n",
2678 type, sp->handle, sts->rsp_data_len);
2679 } else if (sts->data[3]) {
2680 ql_log(ql_log_warn, fcport->vha, 0x503c,
2681 "Async-%s error - hdl=%x response(%x).\n",
2682 type, sp->handle, sts->data[3]);
2683 iocb->u.tmf.data = QLA_FUNCTION_FAILED;
2687 switch (comp_status) {
2688 case CS_PORT_LOGGED_OUT:
2689 case CS_PORT_CONFIG_CHG:
2692 case CS_PORT_UNAVAILABLE:
2694 if (atomic_read(&fcport->state) == FCS_ONLINE) {
2695 ql_dbg(ql_dbg_disc, fcport->vha, 0x3021,
2696 "-Port to be marked lost on fcport=%02x%02x%02x, current port state= %s comp_status %x.\n",
2697 fcport->d_id.b.domain, fcport->d_id.b.area,
2698 fcport->d_id.b.al_pa,
2699 port_state_str[FCS_ONLINE],
2702 qlt_schedule_sess_for_deletion(fcport);
2710 if (iocb->u.tmf.data != QLA_SUCCESS)
2711 ql_dump_buffer(ql_dbg_async + ql_dbg_buffer, sp->vha, 0x5055,
2717 static void qla24xx_nvme_iocb_entry(scsi_qla_host_t *vha, struct req_que *req,
2718 void *tsk, srb_t *sp)
2721 struct srb_iocb *iocb;
2722 struct sts_entry_24xx *sts = (struct sts_entry_24xx *)tsk;
2723 uint16_t state_flags;
2724 struct nvmefc_fcp_req *fd;
2725 uint16_t ret = QLA_SUCCESS;
2726 __le16 comp_status = sts->comp_status;
2729 iocb = &sp->u.iocb_cmd;
2730 fcport = sp->fcport;
2731 iocb->u.nvme.comp_status = comp_status;
2732 state_flags = le16_to_cpu(sts->state_flags);
2733 fd = iocb->u.nvme.desc;
2735 if (unlikely(iocb->u.nvme.aen_op))
2736 atomic_dec(&sp->vha->hw->nvme_active_aen_cnt);
2738 sp->qpair->cmd_completion_cnt++;
2740 if (unlikely(comp_status != CS_COMPLETE))
2743 fd->transferred_length = fd->payload_length -
2744 le32_to_cpu(sts->residual_len);
2747 * State flags: Bit 6 and 0.
2748 * If 0 is set, we don't care about 6.
2749 * both cases resp was dma'd to host buffer
2750 * if both are 0, that is good path case.
2751 * if six is set and 0 is clear, we need to
2752 * copy resp data from status iocb to resp buffer.
2754 if (!(state_flags & (SF_FCP_RSP_DMA | SF_NVME_ERSP))) {
2755 iocb->u.nvme.rsp_pyld_len = 0;
2756 } else if ((state_flags & (SF_FCP_RSP_DMA | SF_NVME_ERSP)) ==
2757 (SF_FCP_RSP_DMA | SF_NVME_ERSP)) {
2758 /* Response already DMA'd to fd->rspaddr. */
2759 iocb->u.nvme.rsp_pyld_len = sts->nvme_rsp_pyld_len;
2760 } else if ((state_flags & SF_FCP_RSP_DMA)) {
2762 * Non-zero value in first 12 bytes of NVMe_RSP IU, treat this
2765 iocb->u.nvme.rsp_pyld_len = 0;
2766 fd->transferred_length = 0;
2767 ql_dbg(ql_dbg_io, fcport->vha, 0x307a,
2768 "Unexpected values in NVMe_RSP IU.\n");
2770 } else if (state_flags & SF_NVME_ERSP) {
2771 uint32_t *inbuf, *outbuf;
2774 inbuf = (uint32_t *)&sts->nvme_ersp_data;
2775 outbuf = (uint32_t *)fd->rspaddr;
2776 iocb->u.nvme.rsp_pyld_len = sts->nvme_rsp_pyld_len;
2777 if (unlikely(le16_to_cpu(iocb->u.nvme.rsp_pyld_len) >
2778 sizeof(struct nvme_fc_ersp_iu))) {
2779 if (ql_mask_match(ql_dbg_io)) {
2780 WARN_ONCE(1, "Unexpected response payload length %u.\n",
2781 iocb->u.nvme.rsp_pyld_len);
2782 ql_log(ql_log_warn, fcport->vha, 0x5100,
2783 "Unexpected response payload length %u.\n",
2784 iocb->u.nvme.rsp_pyld_len);
2786 iocb->u.nvme.rsp_pyld_len =
2787 cpu_to_le16(sizeof(struct nvme_fc_ersp_iu));
2789 iter = le16_to_cpu(iocb->u.nvme.rsp_pyld_len) >> 2;
2790 for (; iter; iter--)
2791 *outbuf++ = swab32(*inbuf++);
2794 if (state_flags & SF_NVME_ERSP) {
2795 struct nvme_fc_ersp_iu *rsp_iu = fd->rspaddr;
2798 tgt_xfer_len = be32_to_cpu(rsp_iu->xfrd_len);
2799 if (fd->transferred_length != tgt_xfer_len) {
2800 ql_log(ql_log_warn, fcport->vha, 0x3079,
2801 "Dropped frame(s) detected (sent/rcvd=%u/%u).\n",
2802 tgt_xfer_len, fd->transferred_length);
2804 } else if (le16_to_cpu(comp_status) == CS_DATA_UNDERRUN) {
2806 * Do not log if this is just an underflow and there
2813 if (unlikely(logit))
2814 ql_dbg(ql_dbg_io, fcport->vha, 0x5060,
2815 "NVME-%s ERR Handling - hdl=%x status(%x) tr_len:%x resid=%x ox_id=%x\n",
2816 sp->name, sp->handle, comp_status,
2817 fd->transferred_length, le32_to_cpu(sts->residual_len),
2821 * If transport error then Failure (HBA rejects request)
2822 * otherwise transport will handle.
2824 switch (le16_to_cpu(comp_status)) {
2829 case CS_PORT_UNAVAILABLE:
2830 case CS_PORT_LOGGED_OUT:
2831 fcport->nvme_flag |= NVME_FLAG_RESETTING;
2832 if (atomic_read(&fcport->state) == FCS_ONLINE) {
2833 ql_dbg(ql_dbg_disc, fcport->vha, 0x3021,
2834 "Port to be marked lost on fcport=%06x, current "
2835 "port state= %s comp_status %x.\n",
2836 fcport->d_id.b24, port_state_str[FCS_ONLINE],
2839 qlt_schedule_sess_for_deletion(fcport);
2844 fd->transferred_length = 0;
2845 iocb->u.nvme.rsp_pyld_len = 0;
2848 case CS_DATA_UNDERRUN:
2851 ret = QLA_FUNCTION_FAILED;
2857 static void qla_ctrlvp_completed(scsi_qla_host_t *vha, struct req_que *req,
2858 struct vp_ctrl_entry_24xx *vce)
2860 const char func[] = "CTRLVP-IOCB";
2862 int rval = QLA_SUCCESS;
2864 sp = qla2x00_get_sp_from_handle(vha, func, req, vce);
2868 if (vce->entry_status != 0) {
2869 ql_dbg(ql_dbg_vport, vha, 0x10c4,
2870 "%s: Failed to complete IOCB -- error status (%x)\n",
2871 sp->name, vce->entry_status);
2872 rval = QLA_FUNCTION_FAILED;
2873 } else if (vce->comp_status != cpu_to_le16(CS_COMPLETE)) {
2874 ql_dbg(ql_dbg_vport, vha, 0x10c5,
2875 "%s: Failed to complete IOCB -- completion status (%x) vpidx %x\n",
2876 sp->name, le16_to_cpu(vce->comp_status),
2877 le16_to_cpu(vce->vp_idx_failed));
2878 rval = QLA_FUNCTION_FAILED;
2880 ql_dbg(ql_dbg_vport, vha, 0x10c6,
2881 "Done %s.\n", __func__);
2888 /* Process a single response queue entry. */
2889 static void qla2x00_process_response_entry(struct scsi_qla_host *vha,
2890 struct rsp_que *rsp,
2893 sts21_entry_t *sts21_entry;
2894 sts22_entry_t *sts22_entry;
2895 uint16_t handle_cnt;
2898 switch (pkt->entry_type) {
2900 qla2x00_status_entry(vha, rsp, pkt);
2902 case STATUS_TYPE_21:
2903 sts21_entry = (sts21_entry_t *)pkt;
2904 handle_cnt = sts21_entry->handle_count;
2905 for (cnt = 0; cnt < handle_cnt; cnt++)
2906 qla2x00_process_completed_request(vha, rsp->req,
2907 sts21_entry->handle[cnt]);
2909 case STATUS_TYPE_22:
2910 sts22_entry = (sts22_entry_t *)pkt;
2911 handle_cnt = sts22_entry->handle_count;
2912 for (cnt = 0; cnt < handle_cnt; cnt++)
2913 qla2x00_process_completed_request(vha, rsp->req,
2914 sts22_entry->handle[cnt]);
2916 case STATUS_CONT_TYPE:
2917 qla2x00_status_cont_entry(rsp, (sts_cont_entry_t *)pkt);
2920 qla2x00_mbx_iocb_entry(vha, rsp->req, (struct mbx_entry *)pkt);
2923 qla2x00_ct_entry(vha, rsp->req, pkt, CT_IOCB_TYPE);
2926 /* Type Not Supported. */
2927 ql_log(ql_log_warn, vha, 0x504a,
2928 "Received unknown response pkt type %x entry status=%x.\n",
2929 pkt->entry_type, pkt->entry_status);
2935 * qla2x00_process_response_queue() - Process response queue entries.
2936 * @rsp: response queue
2939 qla2x00_process_response_queue(struct rsp_que *rsp)
2941 struct scsi_qla_host *vha;
2942 struct qla_hw_data *ha = rsp->hw;
2943 struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
2946 vha = pci_get_drvdata(ha->pdev);
2948 if (!vha->flags.online)
2951 while (rsp->ring_ptr->signature != RESPONSE_PROCESSED) {
2952 pkt = (sts_entry_t *)rsp->ring_ptr;
2955 if (rsp->ring_index == rsp->length) {
2956 rsp->ring_index = 0;
2957 rsp->ring_ptr = rsp->ring;
2962 if (pkt->entry_status != 0) {
2963 qla2x00_error_entry(vha, rsp, pkt);
2964 ((response_t *)pkt)->signature = RESPONSE_PROCESSED;
2969 qla2x00_process_response_entry(vha, rsp, pkt);
2970 ((response_t *)pkt)->signature = RESPONSE_PROCESSED;
2974 /* Adjust ring index */
2975 wrt_reg_word(ISP_RSP_Q_OUT(ha, reg), rsp->ring_index);
2979 qla2x00_handle_sense(srb_t *sp, uint8_t *sense_data, uint32_t par_sense_len,
2980 uint32_t sense_len, struct rsp_que *rsp, int res)
2982 struct scsi_qla_host *vha = sp->vha;
2983 struct scsi_cmnd *cp = GET_CMD_SP(sp);
2984 uint32_t track_sense_len;
2986 if (sense_len >= SCSI_SENSE_BUFFERSIZE)
2987 sense_len = SCSI_SENSE_BUFFERSIZE;
2989 SET_CMD_SENSE_LEN(sp, sense_len);
2990 SET_CMD_SENSE_PTR(sp, cp->sense_buffer);
2991 track_sense_len = sense_len;
2993 if (sense_len > par_sense_len)
2994 sense_len = par_sense_len;
2996 memcpy(cp->sense_buffer, sense_data, sense_len);
2998 SET_CMD_SENSE_PTR(sp, cp->sense_buffer + sense_len);
2999 track_sense_len -= sense_len;
3000 SET_CMD_SENSE_LEN(sp, track_sense_len);
3002 if (track_sense_len != 0) {
3003 rsp->status_srb = sp;
3008 ql_dbg(ql_dbg_io + ql_dbg_buffer, vha, 0x301c,
3009 "Check condition Sense data, nexus%ld:%d:%llu cmd=%p.\n",
3010 sp->vha->host_no, cp->device->id, cp->device->lun,
3012 ql_dump_buffer(ql_dbg_io + ql_dbg_buffer, vha, 0x302b,
3013 cp->sense_buffer, sense_len);
3017 struct scsi_dif_tuple {
3018 __be16 guard; /* Checksum */
3019 __be16 app_tag; /* APPL identifier */
3020 __be32 ref_tag; /* Target LBA or indirect LBA */
3024 * Checks the guard or meta-data for the type of error
3025 * detected by the HBA. In case of errors, we set the
3026 * ASC/ASCQ fields in the sense buffer with ILLEGAL_REQUEST
3027 * to indicate to the kernel that the HBA detected error.
3030 qla2x00_handle_dif_error(srb_t *sp, struct sts_entry_24xx *sts24)
3032 struct scsi_qla_host *vha = sp->vha;
3033 struct scsi_cmnd *cmd = GET_CMD_SP(sp);
3034 uint8_t *ap = &sts24->data[12];
3035 uint8_t *ep = &sts24->data[20];
3036 uint32_t e_ref_tag, a_ref_tag;
3037 uint16_t e_app_tag, a_app_tag;
3038 uint16_t e_guard, a_guard;
3041 * swab32 of the "data" field in the beginning of qla2x00_status_entry()
3042 * would make guard field appear at offset 2
3044 a_guard = get_unaligned_le16(ap + 2);
3045 a_app_tag = get_unaligned_le16(ap + 0);
3046 a_ref_tag = get_unaligned_le32(ap + 4);
3047 e_guard = get_unaligned_le16(ep + 2);
3048 e_app_tag = get_unaligned_le16(ep + 0);
3049 e_ref_tag = get_unaligned_le32(ep + 4);
3051 ql_dbg(ql_dbg_io, vha, 0x3023,
3052 "iocb(s) %p Returned STATUS.\n", sts24);
3054 ql_dbg(ql_dbg_io, vha, 0x3024,
3055 "DIF ERROR in cmd 0x%x lba 0x%llx act ref"
3056 " tag=0x%x, exp ref_tag=0x%x, act app tag=0x%x, exp app"
3057 " tag=0x%x, act guard=0x%x, exp guard=0x%x.\n",
3058 cmd->cmnd[0], (u64)scsi_get_lba(cmd), a_ref_tag, e_ref_tag,
3059 a_app_tag, e_app_tag, a_guard, e_guard);
3063 * For type 3: ref & app tag is all 'f's
3064 * For type 0,1,2: app tag is all 'f's
3066 if (a_app_tag == be16_to_cpu(T10_PI_APP_ESCAPE) &&
3067 (scsi_get_prot_type(cmd) != SCSI_PROT_DIF_TYPE3 ||
3068 a_ref_tag == be32_to_cpu(T10_PI_REF_ESCAPE))) {
3069 uint32_t blocks_done, resid;
3070 sector_t lba_s = scsi_get_lba(cmd);
3072 /* 2TB boundary case covered automatically with this */
3073 blocks_done = e_ref_tag - (uint32_t)lba_s + 1;
3075 resid = scsi_bufflen(cmd) - (blocks_done *
3076 cmd->device->sector_size);
3078 scsi_set_resid(cmd, resid);
3079 cmd->result = DID_OK << 16;
3081 /* Update protection tag */
3082 if (scsi_prot_sg_count(cmd)) {
3083 uint32_t i, j = 0, k = 0, num_ent;
3084 struct scatterlist *sg;
3085 struct t10_pi_tuple *spt;
3087 /* Patch the corresponding protection tags */
3088 scsi_for_each_prot_sg(cmd, sg,
3089 scsi_prot_sg_count(cmd), i) {
3090 num_ent = sg_dma_len(sg) / 8;
3091 if (k + num_ent < blocks_done) {
3095 j = blocks_done - k - 1;
3100 if (k != blocks_done) {
3101 ql_log(ql_log_warn, vha, 0x302f,
3102 "unexpected tag values tag:lba=%x:%llx)\n",
3103 e_ref_tag, (unsigned long long)lba_s);
3107 spt = page_address(sg_page(sg)) + sg->offset;
3110 spt->app_tag = T10_PI_APP_ESCAPE;
3111 if (scsi_get_prot_type(cmd) == SCSI_PROT_DIF_TYPE3)
3112 spt->ref_tag = T10_PI_REF_ESCAPE;
3119 if (e_guard != a_guard) {
3120 scsi_build_sense(cmd, 1, ILLEGAL_REQUEST, 0x10, 0x1);
3121 set_host_byte(cmd, DID_ABORT);
3126 if (e_ref_tag != a_ref_tag) {
3127 scsi_build_sense(cmd, 1, ILLEGAL_REQUEST, 0x10, 0x3);
3128 set_host_byte(cmd, DID_ABORT);
3132 /* check appl tag */
3133 if (e_app_tag != a_app_tag) {
3134 scsi_build_sense(cmd, 1, ILLEGAL_REQUEST, 0x10, 0x2);
3135 set_host_byte(cmd, DID_ABORT);
3143 qla25xx_process_bidir_status_iocb(scsi_qla_host_t *vha, void *pkt,
3144 struct req_que *req, uint32_t index)
3146 struct qla_hw_data *ha = vha->hw;
3148 uint16_t comp_status;
3149 uint16_t scsi_status;
3151 uint32_t rval = EXT_STATUS_OK;
3152 struct bsg_job *bsg_job = NULL;
3153 struct fc_bsg_request *bsg_request;
3154 struct fc_bsg_reply *bsg_reply;
3155 sts_entry_t *sts = pkt;
3156 struct sts_entry_24xx *sts24 = pkt;
3158 /* Validate handle. */
3159 if (index >= req->num_outstanding_cmds) {
3160 ql_log(ql_log_warn, vha, 0x70af,
3161 "Invalid SCSI completion handle 0x%x.\n", index);
3162 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
3166 sp = req->outstanding_cmds[index];
3168 ql_log(ql_log_warn, vha, 0x70b0,
3169 "Req:%d: Invalid ISP SCSI completion handle(0x%x)\n",
3172 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
3176 /* Free outstanding command slot. */
3177 req->outstanding_cmds[index] = NULL;
3178 bsg_job = sp->u.bsg_job;
3179 bsg_request = bsg_job->request;
3180 bsg_reply = bsg_job->reply;
3182 if (IS_FWI2_CAPABLE(ha)) {
3183 comp_status = le16_to_cpu(sts24->comp_status);
3184 scsi_status = le16_to_cpu(sts24->scsi_status) & SS_MASK;
3186 comp_status = le16_to_cpu(sts->comp_status);
3187 scsi_status = le16_to_cpu(sts->scsi_status) & SS_MASK;
3190 thread_id = bsg_request->rqst_data.h_vendor.vendor_cmd[1];
3191 switch (comp_status) {
3193 if (scsi_status == 0) {
3194 bsg_reply->reply_payload_rcv_len =
3195 bsg_job->reply_payload.payload_len;
3196 vha->qla_stats.input_bytes +=
3197 bsg_reply->reply_payload_rcv_len;
3198 vha->qla_stats.input_requests++;
3199 rval = EXT_STATUS_OK;
3203 case CS_DATA_OVERRUN:
3204 ql_dbg(ql_dbg_user, vha, 0x70b1,
3205 "Command completed with data overrun thread_id=%d\n",
3207 rval = EXT_STATUS_DATA_OVERRUN;
3210 case CS_DATA_UNDERRUN:
3211 ql_dbg(ql_dbg_user, vha, 0x70b2,
3212 "Command completed with data underrun thread_id=%d\n",
3214 rval = EXT_STATUS_DATA_UNDERRUN;
3216 case CS_BIDIR_RD_OVERRUN:
3217 ql_dbg(ql_dbg_user, vha, 0x70b3,
3218 "Command completed with read data overrun thread_id=%d\n",
3220 rval = EXT_STATUS_DATA_OVERRUN;
3223 case CS_BIDIR_RD_WR_OVERRUN:
3224 ql_dbg(ql_dbg_user, vha, 0x70b4,
3225 "Command completed with read and write data overrun "
3226 "thread_id=%d\n", thread_id);
3227 rval = EXT_STATUS_DATA_OVERRUN;
3230 case CS_BIDIR_RD_OVERRUN_WR_UNDERRUN:
3231 ql_dbg(ql_dbg_user, vha, 0x70b5,
3232 "Command completed with read data over and write data "
3233 "underrun thread_id=%d\n", thread_id);
3234 rval = EXT_STATUS_DATA_OVERRUN;
3237 case CS_BIDIR_RD_UNDERRUN:
3238 ql_dbg(ql_dbg_user, vha, 0x70b6,
3239 "Command completed with read data underrun "
3240 "thread_id=%d\n", thread_id);
3241 rval = EXT_STATUS_DATA_UNDERRUN;
3244 case CS_BIDIR_RD_UNDERRUN_WR_OVERRUN:
3245 ql_dbg(ql_dbg_user, vha, 0x70b7,
3246 "Command completed with read data under and write data "
3247 "overrun thread_id=%d\n", thread_id);
3248 rval = EXT_STATUS_DATA_UNDERRUN;
3251 case CS_BIDIR_RD_WR_UNDERRUN:
3252 ql_dbg(ql_dbg_user, vha, 0x70b8,
3253 "Command completed with read and write data underrun "
3254 "thread_id=%d\n", thread_id);
3255 rval = EXT_STATUS_DATA_UNDERRUN;
3259 ql_dbg(ql_dbg_user, vha, 0x70b9,
3260 "Command completed with data DMA error thread_id=%d\n",
3262 rval = EXT_STATUS_DMA_ERR;
3266 ql_dbg(ql_dbg_user, vha, 0x70ba,
3267 "Command completed with timeout thread_id=%d\n",
3269 rval = EXT_STATUS_TIMEOUT;
3272 ql_dbg(ql_dbg_user, vha, 0x70bb,
3273 "Command completed with completion status=0x%x "
3274 "thread_id=%d\n", comp_status, thread_id);
3275 rval = EXT_STATUS_ERR;
3278 bsg_reply->reply_payload_rcv_len = 0;
3281 /* Return the vendor specific reply to API */
3282 bsg_reply->reply_data.vendor_reply.vendor_rsp[0] = rval;
3283 bsg_job->reply_len = sizeof(struct fc_bsg_reply);
3284 /* Always return DID_OK, bsg will send the vendor specific response
3285 * in this case only */
3286 sp->done(sp, DID_OK << 16);
3291 * qla2x00_status_entry() - Process a Status IOCB entry.
3292 * @vha: SCSI driver HA context
3293 * @rsp: response queue
3294 * @pkt: Entry pointer
3297 qla2x00_status_entry(scsi_qla_host_t *vha, struct rsp_que *rsp, void *pkt)
3301 struct scsi_cmnd *cp;
3302 sts_entry_t *sts = pkt;
3303 struct sts_entry_24xx *sts24 = pkt;
3304 uint16_t comp_status;
3305 uint16_t scsi_status;
3307 uint8_t lscsi_status;
3309 uint32_t sense_len, par_sense_len, rsp_info_len, resid_len,
3311 uint8_t *rsp_info, *sense_data;
3312 struct qla_hw_data *ha = vha->hw;
3315 struct req_que *req;
3318 uint16_t state_flags = 0;
3319 uint16_t sts_qual = 0;
3321 if (IS_FWI2_CAPABLE(ha)) {
3322 comp_status = le16_to_cpu(sts24->comp_status);
3323 scsi_status = le16_to_cpu(sts24->scsi_status) & SS_MASK;
3324 state_flags = le16_to_cpu(sts24->state_flags);
3326 comp_status = le16_to_cpu(sts->comp_status);
3327 scsi_status = le16_to_cpu(sts->scsi_status) & SS_MASK;
3329 handle = (uint32_t) LSW(sts->handle);
3330 que = MSW(sts->handle);
3331 req = ha->req_q_map[que];
3333 /* Check for invalid queue pointer */
3335 que >= find_first_zero_bit(ha->req_qid_map, ha->max_req_queues)) {
3336 ql_dbg(ql_dbg_io, vha, 0x3059,
3337 "Invalid status handle (0x%x): Bad req pointer. req=%p, "
3338 "que=%u.\n", sts->handle, req, que);
3342 /* Validate handle. */
3343 if (handle < req->num_outstanding_cmds) {
3344 sp = req->outstanding_cmds[handle];
3346 ql_dbg(ql_dbg_io, vha, 0x3075,
3347 "%s(%ld): Already returned command for status handle (0x%x).\n",
3348 __func__, vha->host_no, sts->handle);
3352 ql_dbg(ql_dbg_io, vha, 0x3017,
3353 "Invalid status handle, out of range (0x%x).\n",
3356 if (!test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags)) {
3357 if (IS_P3P_TYPE(ha))
3358 set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
3360 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
3361 qla2xxx_wake_dpc(vha);
3365 qla_put_fw_resources(sp->qpair, &sp->iores);
3367 if (sp->cmd_type != TYPE_SRB) {
3368 req->outstanding_cmds[handle] = NULL;
3369 ql_dbg(ql_dbg_io, vha, 0x3015,
3370 "Unknown sp->cmd_type %x %p).\n",
3375 /* NVME completion. */
3376 if (sp->type == SRB_NVME_CMD) {
3377 req->outstanding_cmds[handle] = NULL;
3378 qla24xx_nvme_iocb_entry(vha, req, pkt, sp);
3382 if (unlikely((state_flags & BIT_1) && (sp->type == SRB_BIDI_CMD))) {
3383 qla25xx_process_bidir_status_iocb(vha, pkt, req, handle);
3387 /* Task Management completion. */
3388 if (sp->type == SRB_TM_CMD) {
3389 qla24xx_tm_iocb_entry(vha, req, pkt);
3393 /* Fast path completion. */
3394 qla_chk_edif_rx_sa_delete_pending(vha, sp, sts24);
3395 sp->qpair->cmd_completion_cnt++;
3397 if (comp_status == CS_COMPLETE && scsi_status == 0) {
3398 qla2x00_process_completed_request(vha, req, handle);
3403 cp = GET_CMD_SP(sp);
3405 ql_dbg(ql_dbg_io, vha, 0x3018,
3406 "Command already returned (0x%x/%p).\n",
3409 req->outstanding_cmds[handle] = NULL;
3413 lscsi_status = scsi_status & STATUS_MASK;
3415 fcport = sp->fcport;
3418 sense_len = par_sense_len = rsp_info_len = resid_len =
3420 if (IS_FWI2_CAPABLE(ha)) {
3421 if (scsi_status & SS_SENSE_LEN_VALID)
3422 sense_len = le32_to_cpu(sts24->sense_len);
3423 if (scsi_status & SS_RESPONSE_INFO_LEN_VALID)
3424 rsp_info_len = le32_to_cpu(sts24->rsp_data_len);
3425 if (scsi_status & (SS_RESIDUAL_UNDER | SS_RESIDUAL_OVER))
3426 resid_len = le32_to_cpu(sts24->rsp_residual_count);
3427 if (comp_status == CS_DATA_UNDERRUN)
3428 fw_resid_len = le32_to_cpu(sts24->residual_len);
3429 rsp_info = sts24->data;
3430 sense_data = sts24->data;
3431 host_to_fcp_swap(sts24->data, sizeof(sts24->data));
3432 ox_id = le16_to_cpu(sts24->ox_id);
3433 par_sense_len = sizeof(sts24->data);
3434 sts_qual = le16_to_cpu(sts24->status_qualifier);
3436 if (scsi_status & SS_SENSE_LEN_VALID)
3437 sense_len = le16_to_cpu(sts->req_sense_length);
3438 if (scsi_status & SS_RESPONSE_INFO_LEN_VALID)
3439 rsp_info_len = le16_to_cpu(sts->rsp_info_len);
3440 resid_len = le32_to_cpu(sts->residual_length);
3441 rsp_info = sts->rsp_info;
3442 sense_data = sts->req_sense_data;
3443 par_sense_len = sizeof(sts->req_sense_data);
3446 /* Check for any FCP transport errors. */
3447 if (scsi_status & SS_RESPONSE_INFO_LEN_VALID) {
3448 /* Sense data lies beyond any FCP RESPONSE data. */
3449 if (IS_FWI2_CAPABLE(ha)) {
3450 sense_data += rsp_info_len;
3451 par_sense_len -= rsp_info_len;
3453 if (rsp_info_len > 3 && rsp_info[3]) {
3454 ql_dbg(ql_dbg_io, fcport->vha, 0x3019,
3455 "FCP I/O protocol failure (0x%x/0x%x).\n",
3456 rsp_info_len, rsp_info[3]);
3458 res = DID_BUS_BUSY << 16;
3463 /* Check for overrun. */
3464 if (IS_FWI2_CAPABLE(ha) && comp_status == CS_COMPLETE &&
3465 scsi_status & SS_RESIDUAL_OVER)
3466 comp_status = CS_DATA_OVERRUN;
3469 * Check retry_delay_timer value if we receive a busy or
3472 if (unlikely(lscsi_status == SAM_STAT_TASK_SET_FULL ||
3473 lscsi_status == SAM_STAT_BUSY))
3474 qla2x00_set_retry_delay_timestamp(fcport, sts_qual);
3477 * Based on Host and scsi status generate status code for Linux
3479 switch (comp_status) {
3482 if (scsi_status == 0) {
3486 if (scsi_status & (SS_RESIDUAL_UNDER | SS_RESIDUAL_OVER)) {
3488 scsi_set_resid(cp, resid);
3490 if (!lscsi_status &&
3491 ((unsigned)(scsi_bufflen(cp) - resid) <
3493 ql_dbg(ql_dbg_io, fcport->vha, 0x301a,
3494 "Mid-layer underflow detected (0x%x of 0x%x bytes).\n",
3495 resid, scsi_bufflen(cp));
3497 res = DID_ERROR << 16;
3501 res = DID_OK << 16 | lscsi_status;
3503 if (lscsi_status == SAM_STAT_TASK_SET_FULL) {
3504 ql_dbg(ql_dbg_io, fcport->vha, 0x301b,
3505 "QUEUE FULL detected.\n");
3509 if (lscsi_status != SS_CHECK_CONDITION)
3512 memset(cp->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
3513 if (!(scsi_status & SS_SENSE_LEN_VALID))
3516 qla2x00_handle_sense(sp, sense_data, par_sense_len, sense_len,
3520 case CS_DATA_UNDERRUN:
3521 /* Use F/W calculated residual length. */
3522 resid = IS_FWI2_CAPABLE(ha) ? fw_resid_len : resid_len;
3523 scsi_set_resid(cp, resid);
3524 if (scsi_status & SS_RESIDUAL_UNDER) {
3525 if (IS_FWI2_CAPABLE(ha) && fw_resid_len != resid_len) {
3526 ql_log(ql_log_warn, fcport->vha, 0x301d,
3527 "Dropped frame(s) detected (0x%x of 0x%x bytes).\n",
3528 resid, scsi_bufflen(cp));
3530 res = DID_ERROR << 16 | lscsi_status;
3531 goto check_scsi_status;
3534 if (!lscsi_status &&
3535 ((unsigned)(scsi_bufflen(cp) - resid) <
3537 ql_dbg(ql_dbg_io, fcport->vha, 0x301e,
3538 "Mid-layer underflow detected (0x%x of 0x%x bytes).\n",
3539 resid, scsi_bufflen(cp));
3541 res = DID_ERROR << 16;
3544 } else if (lscsi_status != SAM_STAT_TASK_SET_FULL &&
3545 lscsi_status != SAM_STAT_BUSY) {
3547 * scsi status of task set and busy are considered to be
3548 * task not completed.
3551 ql_log(ql_log_warn, fcport->vha, 0x301f,
3552 "Dropped frame(s) detected (0x%x of 0x%x bytes).\n",
3553 resid, scsi_bufflen(cp));
3555 vha->interface_err_cnt++;
3557 res = DID_ERROR << 16 | lscsi_status;
3558 goto check_scsi_status;
3560 ql_dbg(ql_dbg_io, fcport->vha, 0x3030,
3561 "scsi_status: 0x%x, lscsi_status: 0x%x\n",
3562 scsi_status, lscsi_status);
3565 res = DID_OK << 16 | lscsi_status;
3570 * Check to see if SCSI Status is non zero. If so report SCSI
3573 if (lscsi_status != 0) {
3574 if (lscsi_status == SAM_STAT_TASK_SET_FULL) {
3575 ql_dbg(ql_dbg_io, fcport->vha, 0x3020,
3576 "QUEUE FULL detected.\n");
3580 if (lscsi_status != SS_CHECK_CONDITION)
3583 memset(cp->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
3584 if (!(scsi_status & SS_SENSE_LEN_VALID))
3587 qla2x00_handle_sense(sp, sense_data, par_sense_len,
3588 sense_len, rsp, res);
3592 case CS_PORT_LOGGED_OUT:
3593 case CS_PORT_CONFIG_CHG:
3596 case CS_PORT_UNAVAILABLE:
3599 case CS_EDIF_INV_REQ:
3602 * We are going to have the fc class block the rport
3603 * while we try to recover so instruct the mid layer
3604 * to requeue until the class decides how to handle this.
3606 res = DID_TRANSPORT_DISRUPTED << 16;
3608 if (comp_status == CS_TIMEOUT) {
3609 if (IS_FWI2_CAPABLE(ha))
3611 else if ((le16_to_cpu(sts->status_flags) &
3612 SF_LOGOUT_SENT) == 0)
3616 if (atomic_read(&fcport->state) == FCS_ONLINE) {
3617 ql_dbg(ql_dbg_disc, fcport->vha, 0x3021,
3618 "Port to be marked lost on fcport=%02x%02x%02x, current "
3619 "port state= %s comp_status %x.\n", fcport->d_id.b.domain,
3620 fcport->d_id.b.area, fcport->d_id.b.al_pa,
3621 port_state_str[FCS_ONLINE],
3624 qlt_schedule_sess_for_deletion(fcport);
3630 res = DID_RESET << 16;
3634 logit = qla2x00_handle_dif_error(sp, sts24);
3639 res = DID_ERROR << 16;
3642 if (!IS_PI_SPLIT_DET_CAPABLE(ha))
3645 if (state_flags & BIT_4)
3646 scmd_printk(KERN_WARNING, cp,
3647 "Unsupported device '%s' found.\n",
3648 cp->device->vendor);
3652 ql_log(ql_log_info, fcport->vha, 0x3022,
3653 "CS_DMA error: 0x%x-0x%x (0x%x) nexus=%ld:%d:%llu portid=%06x oxid=0x%x cdb=%10phN len=0x%x rsp_info=0x%x resid=0x%x fw_resid=0x%x sp=%p cp=%p.\n",
3654 comp_status, scsi_status, res, vha->host_no,
3655 cp->device->id, cp->device->lun, fcport->d_id.b24,
3656 ox_id, cp->cmnd, scsi_bufflen(cp), rsp_info_len,
3657 resid_len, fw_resid_len, sp, cp);
3658 ql_dump_buffer(ql_dbg_tgt + ql_dbg_verbose, vha, 0xe0ee,
3659 pkt, sizeof(*sts24));
3660 res = DID_ERROR << 16;
3664 res = DID_ERROR << 16;
3670 ql_dbg(ql_dbg_io, fcport->vha, 0x3022,
3671 "FCP command status: 0x%x-0x%x (0x%x) nexus=%ld:%d:%llu portid=%02x%02x%02x oxid=0x%x cdb=%10phN len=0x%x rsp_info=0x%x resid=0x%x fw_resid=0x%x sp=%p cp=%p.\n",
3672 comp_status, scsi_status, res, vha->host_no,
3673 cp->device->id, cp->device->lun, fcport->d_id.b.domain,
3674 fcport->d_id.b.area, fcport->d_id.b.al_pa, ox_id,
3675 cp->cmnd, scsi_bufflen(cp), rsp_info_len,
3676 resid_len, fw_resid_len, sp, cp);
3678 if (rsp->status_srb == NULL)
3681 /* for io's, clearing of outstanding_cmds[handle] means scsi_done was called */
3682 req->outstanding_cmds[handle] = NULL;
3686 * qla2x00_status_cont_entry() - Process a Status Continuations entry.
3687 * @rsp: response queue
3688 * @pkt: Entry pointer
3690 * Extended sense data.
3693 qla2x00_status_cont_entry(struct rsp_que *rsp, sts_cont_entry_t *pkt)
3695 uint8_t sense_sz = 0;
3696 struct qla_hw_data *ha = rsp->hw;
3697 struct scsi_qla_host *vha = pci_get_drvdata(ha->pdev);
3698 srb_t *sp = rsp->status_srb;
3699 struct scsi_cmnd *cp;
3703 if (!sp || !GET_CMD_SENSE_LEN(sp))
3706 sense_len = GET_CMD_SENSE_LEN(sp);
3707 sense_ptr = GET_CMD_SENSE_PTR(sp);
3709 cp = GET_CMD_SP(sp);
3711 ql_log(ql_log_warn, vha, 0x3025,
3712 "cmd is NULL: already returned to OS (sp=%p).\n", sp);
3714 rsp->status_srb = NULL;
3718 if (sense_len > sizeof(pkt->data))
3719 sense_sz = sizeof(pkt->data);
3721 sense_sz = sense_len;
3723 /* Move sense data. */
3724 if (IS_FWI2_CAPABLE(ha))
3725 host_to_fcp_swap(pkt->data, sizeof(pkt->data));
3726 memcpy(sense_ptr, pkt->data, sense_sz);
3727 ql_dump_buffer(ql_dbg_io + ql_dbg_buffer, vha, 0x302c,
3728 sense_ptr, sense_sz);
3730 sense_len -= sense_sz;
3731 sense_ptr += sense_sz;
3733 SET_CMD_SENSE_PTR(sp, sense_ptr);
3734 SET_CMD_SENSE_LEN(sp, sense_len);
3736 /* Place command on done queue. */
3737 if (sense_len == 0) {
3738 rsp->status_srb = NULL;
3739 sp->done(sp, cp->result);
3744 * qla2x00_error_entry() - Process an error entry.
3745 * @vha: SCSI driver HA context
3746 * @rsp: response queue
3747 * @pkt: Entry pointer
3748 * return : 1=allow further error analysis. 0=no additional error analysis.
3751 qla2x00_error_entry(scsi_qla_host_t *vha, struct rsp_que *rsp, sts_entry_t *pkt)
3754 struct qla_hw_data *ha = vha->hw;
3755 const char func[] = "ERROR-IOCB";
3756 uint16_t que = MSW(pkt->handle);
3757 struct req_que *req = NULL;
3758 int res = DID_ERROR << 16;
3761 ql_dbg(ql_dbg_async, vha, 0x502a,
3762 "iocb type %xh with error status %xh, handle %xh, rspq id %d\n",
3763 pkt->entry_type, pkt->entry_status, pkt->handle, rsp->id);
3765 if (que >= ha->max_req_queues || !ha->req_q_map[que])
3768 req = ha->req_q_map[que];
3770 if (pkt->entry_status & RF_BUSY)
3771 res = DID_BUS_BUSY << 16;
3773 if ((pkt->handle & ~QLA_TGT_HANDLE_MASK) == QLA_TGT_SKIP_HANDLE)
3776 switch (pkt->entry_type) {
3777 case NOTIFY_ACK_TYPE:
3778 case STATUS_CONT_TYPE:
3779 case LOGINOUT_PORT_IOCB_TYPE:
3782 case ABORT_IOCB_TYPE:
3785 sp = qla2x00_get_sp_from_handle(vha, func, req, pkt);
3792 case SA_UPDATE_IOCB_TYPE:
3793 case ABTS_RESP_24XX:
3798 sp = qla_get_sp_from_handle(vha, func, req, pkt, &index);
3801 req->outstanding_cmds[index] = NULL;
3807 ql_log(ql_log_warn, vha, 0x5030,
3808 "Error entry - invalid handle/queue (%04x).\n", que);
3813 * qla24xx_mbx_completion() - Process mailbox command completions.
3814 * @vha: SCSI driver HA context
3815 * @mb0: Mailbox0 register
3818 qla24xx_mbx_completion(scsi_qla_host_t *vha, uint16_t mb0)
3822 __le16 __iomem *wptr;
3823 struct qla_hw_data *ha = vha->hw;
3824 struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
3826 /* Read all mbox registers? */
3827 WARN_ON_ONCE(ha->mbx_count > 32);
3828 mboxes = (1ULL << ha->mbx_count) - 1;
3830 ql_dbg(ql_dbg_async, vha, 0x504e, "MBX pointer ERROR.\n");
3832 mboxes = ha->mcp->in_mb;
3834 /* Load return mailbox registers. */
3835 ha->flags.mbox_int = 1;
3836 ha->mailbox_out[0] = mb0;
3838 wptr = ®->mailbox1;
3840 for (cnt = 1; cnt < ha->mbx_count; cnt++) {
3842 ha->mailbox_out[cnt] = rd_reg_word(wptr);
3850 qla24xx_abort_iocb_entry(scsi_qla_host_t *vha, struct req_que *req,
3851 struct abort_entry_24xx *pkt)
3853 const char func[] = "ABT_IOCB";
3855 srb_t *orig_sp = NULL;
3856 struct srb_iocb *abt;
3858 sp = qla2x00_get_sp_from_handle(vha, func, req, pkt);
3862 abt = &sp->u.iocb_cmd;
3863 abt->u.abt.comp_status = pkt->comp_status;
3864 orig_sp = sp->cmd_sp;
3865 /* Need to pass original sp */
3867 qla_nvme_abort_process_comp_status(pkt, orig_sp);
3872 void qla24xx_nvme_ls4_iocb(struct scsi_qla_host *vha,
3873 struct pt_ls4_request *pkt, struct req_que *req)
3876 const char func[] = "LS4_IOCB";
3877 uint16_t comp_status;
3879 sp = qla2x00_get_sp_from_handle(vha, func, req, pkt);
3883 comp_status = le16_to_cpu(pkt->status);
3884 sp->done(sp, comp_status);
3888 * qla_chk_cont_iocb_avail - check for all continuation iocbs are available
3889 * before iocb processing can start.
3890 * @vha: host adapter pointer
3891 * @rsp: respond queue
3892 * @pkt: head iocb describing how many continuation iocb
3893 * Return: 0 all iocbs has arrived, xx- all iocbs have not arrived.
3895 static int qla_chk_cont_iocb_avail(struct scsi_qla_host *vha,
3896 struct rsp_que *rsp, response_t *pkt, u32 rsp_q_in)
3898 int start_pkt_ring_index;
3902 if (pkt->entry_count == 1)
3905 /* ring_index was pre-increment. set it back to current pkt */
3906 if (rsp->ring_index == 0)
3907 start_pkt_ring_index = rsp->length - 1;
3909 start_pkt_ring_index = rsp->ring_index - 1;
3911 if (rsp_q_in < start_pkt_ring_index)
3912 /* q in ptr is wrapped */
3913 iocb_cnt = rsp->length - start_pkt_ring_index + rsp_q_in;
3915 iocb_cnt = rsp_q_in - start_pkt_ring_index;
3917 if (iocb_cnt < pkt->entry_count)
3920 ql_dbg(ql_dbg_init, vha, 0x5091,
3921 "%s - ring %p pkt %p entry count %d iocb_cnt %d rsp_q_in %d rc %d\n",
3922 __func__, rsp->ring, pkt, pkt->entry_count, iocb_cnt, rsp_q_in, rc);
3927 static void qla_marker_iocb_entry(scsi_qla_host_t *vha, struct req_que *req,
3928 struct mrk_entry_24xx *pkt)
3930 const char func[] = "MRK-IOCB";
3932 int res = QLA_SUCCESS;
3934 if (!IS_FWI2_CAPABLE(vha->hw))
3937 sp = qla2x00_get_sp_from_handle(vha, func, req, pkt);
3941 if (pkt->entry_status) {
3942 ql_dbg(ql_dbg_taskm, vha, 0x8025, "marker failure.\n");
3943 res = QLA_COMMAND_ERROR;
3945 sp->u.iocb_cmd.u.tmf.data = res;
3950 * qla24xx_process_response_queue() - Process response queue entries.
3951 * @vha: SCSI driver HA context
3952 * @rsp: response queue
3954 void qla24xx_process_response_queue(struct scsi_qla_host *vha,
3955 struct rsp_que *rsp)
3957 struct sts_entry_24xx *pkt;
3958 struct qla_hw_data *ha = vha->hw;
3959 struct purex_entry_24xx *purex_entry;
3960 struct purex_item *pure_item;
3961 struct pt_ls4_rx_unsol *p;
3962 u16 rsp_in = 0, cur_ring_index;
3965 if (!ha->flags.fw_started)
3968 if (rsp->qpair->cpuid != smp_processor_id() || !rsp->qpair->rcv_intr) {
3969 rsp->qpair->rcv_intr = 1;
3971 if (!rsp->qpair->cpu_mapped)
3972 qla_cpu_update(rsp->qpair, raw_smp_processor_id());
3975 #define __update_rsp_in(_is_shadow_hba, _rsp, _rsp_in) \
3977 _rsp_in = _is_shadow_hba ? *(_rsp)->in_ptr : \
3978 rd_reg_dword_relaxed((_rsp)->rsp_q_in); \
3981 is_shadow_hba = IS_SHADOW_REG_CAPABLE(ha);
3983 __update_rsp_in(is_shadow_hba, rsp, rsp_in);
3985 while (rsp->ring_index != rsp_in &&
3986 rsp->ring_ptr->signature != RESPONSE_PROCESSED) {
3987 pkt = (struct sts_entry_24xx *)rsp->ring_ptr;
3988 cur_ring_index = rsp->ring_index;
3991 if (rsp->ring_index == rsp->length) {
3992 rsp->ring_index = 0;
3993 rsp->ring_ptr = rsp->ring;
3998 if (pkt->entry_status != 0) {
3999 if (qla2x00_error_entry(vha, rsp, (sts_entry_t *) pkt))
4002 ((response_t *)pkt)->signature = RESPONSE_PROCESSED;
4008 switch (pkt->entry_type) {
4010 qla2x00_status_entry(vha, rsp, pkt);
4012 case STATUS_CONT_TYPE:
4013 qla2x00_status_cont_entry(rsp, (sts_cont_entry_t *)pkt);
4015 case VP_RPT_ID_IOCB_TYPE:
4016 qla24xx_report_id_acquisition(vha,
4017 (struct vp_rpt_id_entry_24xx *)pkt);
4019 case LOGINOUT_PORT_IOCB_TYPE:
4020 qla24xx_logio_entry(vha, rsp->req,
4021 (struct logio_entry_24xx *)pkt);
4024 qla24xx_els_ct_entry(vha, rsp->req, pkt, CT_IOCB_TYPE);
4027 qla24xx_els_ct_entry(vha, rsp->req, pkt, ELS_IOCB_TYPE);
4029 case ABTS_RECV_24XX:
4030 if (qla_ini_mode_enabled(vha)) {
4031 pure_item = qla24xx_copy_std_pkt(vha, pkt);
4034 qla24xx_queue_purex_item(vha, pure_item,
4035 qla24xx_process_abts);
4038 if (IS_QLA83XX(ha) || IS_QLA27XX(ha) ||
4040 /* ensure that the ATIO queue is empty */
4041 qlt_handle_abts_recv(vha, rsp,
4045 qlt_24xx_process_atio_queue(vha, 1);
4048 case ABTS_RESP_24XX:
4051 qlt_response_pkt_all_vps(vha, rsp, (response_t *)pkt);
4053 case PT_LS4_REQUEST:
4054 qla24xx_nvme_ls4_iocb(vha, (struct pt_ls4_request *)pkt,
4057 case NOTIFY_ACK_TYPE:
4058 if (pkt->handle == QLA_TGT_SKIP_HANDLE)
4059 qlt_response_pkt_all_vps(vha, rsp,
4062 qla24xxx_nack_iocb_entry(vha, rsp->req,
4063 (struct nack_to_isp *)pkt);
4066 qla_marker_iocb_entry(vha, rsp->req, (struct mrk_entry_24xx *)pkt);
4068 case ABORT_IOCB_TYPE:
4069 qla24xx_abort_iocb_entry(vha, rsp->req,
4070 (struct abort_entry_24xx *)pkt);
4073 qla24xx_mbx_iocb_entry(vha, rsp->req,
4074 (struct mbx_24xx_entry *)pkt);
4076 case VP_CTRL_IOCB_TYPE:
4077 qla_ctrlvp_completed(vha, rsp->req,
4078 (struct vp_ctrl_entry_24xx *)pkt);
4080 case PUREX_IOCB_TYPE:
4081 purex_entry = (void *)pkt;
4082 switch (purex_entry->els_frame_payload[3]) {
4084 pure_item = qla24xx_copy_std_pkt(vha, pkt);
4087 qla24xx_queue_purex_item(vha, pure_item,
4088 qla24xx_process_purex_rdp);
4091 if (!vha->hw->flags.scm_enabled) {
4092 ql_log(ql_log_warn, vha, 0x5094,
4093 "SCM not active for this port\n");
4096 pure_item = qla27xx_copy_fpin_pkt(vha,
4097 (void **)&pkt, &rsp);
4098 __update_rsp_in(is_shadow_hba, rsp, rsp_in);
4101 qla24xx_queue_purex_item(vha, pure_item,
4102 qla27xx_process_purex_fpin);
4106 if (qla_chk_cont_iocb_avail(vha, rsp, (response_t *)pkt, rsp_in)) {
4108 * ring_ptr and ring_index were
4109 * pre-incremented above. Reset them
4110 * back to current. Wait for next
4111 * interrupt with all IOCBs to arrive
4114 rsp->ring_ptr = (response_t *)pkt;
4115 rsp->ring_index = cur_ring_index;
4117 ql_dbg(ql_dbg_init, vha, 0x5091,
4118 "Defer processing ELS opcode %#x...\n",
4119 purex_entry->els_frame_payload[3]);
4122 qla24xx_auth_els(vha, (void **)&pkt, &rsp);
4125 ql_log(ql_log_warn, vha, 0x509c,
4126 "Discarding ELS Request opcode 0x%x\n",
4127 purex_entry->els_frame_payload[3]);
4130 case SA_UPDATE_IOCB_TYPE:
4131 qla28xx_sa_update_iocb_entry(vha, rsp->req,
4132 (struct sa_update_28xx *)pkt);
4136 if (qla_chk_cont_iocb_avail(vha, rsp, (response_t *)pkt, rsp_in)) {
4137 rsp->ring_ptr = (response_t *)pkt;
4138 rsp->ring_index = cur_ring_index;
4140 ql_dbg(ql_dbg_init, vha, 0x2124,
4141 "Defer processing UNSOL LS req opcode %#x...\n",
4145 qla2xxx_process_purls_iocb((void **)&pkt, &rsp);
4148 /* Type Not Supported. */
4149 ql_dbg(ql_dbg_async, vha, 0x5042,
4150 "Received unknown response pkt type 0x%x entry status=%x.\n",
4151 pkt->entry_type, pkt->entry_status);
4154 ((response_t *)pkt)->signature = RESPONSE_PROCESSED;
4158 /* Adjust ring index */
4159 if (IS_P3P_TYPE(ha)) {
4160 struct device_reg_82xx __iomem *reg = &ha->iobase->isp82;
4162 wrt_reg_dword(®->rsp_q_out[0], rsp->ring_index);
4164 wrt_reg_dword(rsp->rsp_q_out, rsp->ring_index);
4169 qla2xxx_check_risc_status(scsi_qla_host_t *vha)
4173 struct qla_hw_data *ha = vha->hw;
4174 struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
4176 if (!IS_QLA25XX(ha) && !IS_QLA81XX(ha) && !IS_QLA83XX(ha) &&
4177 !IS_QLA27XX(ha) && !IS_QLA28XX(ha))
4181 wrt_reg_dword(®->iobase_addr, 0x7C00);
4182 rd_reg_dword(®->iobase_addr);
4183 wrt_reg_dword(®->iobase_window, 0x0001);
4184 for (cnt = 10000; (rd_reg_dword(®->iobase_window) & BIT_0) == 0 &&
4185 rval == QLA_SUCCESS; cnt--) {
4187 wrt_reg_dword(®->iobase_window, 0x0001);
4190 rval = QLA_FUNCTION_TIMEOUT;
4192 if (rval == QLA_SUCCESS)
4196 wrt_reg_dword(®->iobase_window, 0x0003);
4197 for (cnt = 100; (rd_reg_dword(®->iobase_window) & BIT_0) == 0 &&
4198 rval == QLA_SUCCESS; cnt--) {
4200 wrt_reg_dword(®->iobase_window, 0x0003);
4203 rval = QLA_FUNCTION_TIMEOUT;
4205 if (rval != QLA_SUCCESS)
4209 if (rd_reg_dword(®->iobase_c8) & BIT_3)
4210 ql_log(ql_log_info, vha, 0x504c,
4211 "Additional code -- 0x55AA.\n");
4214 wrt_reg_dword(®->iobase_window, 0x0000);
4215 rd_reg_dword(®->iobase_window);
4219 * qla24xx_intr_handler() - Process interrupts for the ISP23xx and ISP24xx.
4220 * @irq: interrupt number
4221 * @dev_id: SCSI driver HA context
4223 * Called by system whenever the host adapter generates an interrupt.
4225 * Returns handled flag.
4228 qla24xx_intr_handler(int irq, void *dev_id)
4230 scsi_qla_host_t *vha;
4231 struct qla_hw_data *ha;
4232 struct device_reg_24xx __iomem *reg;
4238 struct rsp_que *rsp;
4239 unsigned long flags;
4240 bool process_atio = false;
4242 rsp = (struct rsp_que *) dev_id;
4244 ql_log(ql_log_info, NULL, 0x5059,
4245 "%s: NULL response queue pointer.\n", __func__);
4250 reg = &ha->iobase->isp24;
4253 if (unlikely(pci_channel_offline(ha->pdev)))
4256 spin_lock_irqsave(&ha->hardware_lock, flags);
4257 vha = pci_get_drvdata(ha->pdev);
4258 for (iter = 50; iter--; ) {
4259 stat = rd_reg_dword(®->host_status);
4260 if (qla2x00_check_reg32_for_disconnect(vha, stat))
4262 if (stat & HSRX_RISC_PAUSED) {
4263 if (unlikely(pci_channel_offline(ha->pdev)))
4266 hccr = rd_reg_dword(®->hccr);
4268 ql_log(ql_log_warn, vha, 0x504b,
4269 "RISC paused -- HCCR=%x, Dumping firmware.\n",
4272 qla2xxx_check_risc_status(vha);
4274 ha->isp_ops->fw_dump(vha);
4275 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
4277 } else if ((stat & HSRX_RISC_INT) == 0)
4280 switch (stat & 0xff) {
4281 case INTR_ROM_MB_SUCCESS:
4282 case INTR_ROM_MB_FAILED:
4283 case INTR_MB_SUCCESS:
4284 case INTR_MB_FAILED:
4285 qla24xx_mbx_completion(vha, MSW(stat));
4286 status |= MBX_INTERRUPT;
4289 case INTR_ASYNC_EVENT:
4291 mb[1] = rd_reg_word(®->mailbox1);
4292 mb[2] = rd_reg_word(®->mailbox2);
4293 mb[3] = rd_reg_word(®->mailbox3);
4294 qla2x00_async_event(vha, rsp, mb);
4296 case INTR_RSP_QUE_UPDATE:
4297 case INTR_RSP_QUE_UPDATE_83XX:
4298 qla24xx_process_response_queue(vha, rsp);
4300 case INTR_ATIO_QUE_UPDATE_27XX:
4301 case INTR_ATIO_QUE_UPDATE:
4302 process_atio = true;
4304 case INTR_ATIO_RSP_QUE_UPDATE:
4305 process_atio = true;
4306 qla24xx_process_response_queue(vha, rsp);
4309 ql_dbg(ql_dbg_async, vha, 0x504f,
4310 "Unrecognized interrupt type (%d).\n", stat * 0xff);
4313 wrt_reg_dword(®->hccr, HCCRX_CLR_RISC_INT);
4314 rd_reg_dword_relaxed(®->hccr);
4315 if (unlikely(IS_QLA83XX(ha) && (ha->pdev->revision == 1)))
4318 qla2x00_handle_mbx_completion(ha, status);
4319 spin_unlock_irqrestore(&ha->hardware_lock, flags);
4322 spin_lock_irqsave(&ha->tgt.atio_lock, flags);
4323 qlt_24xx_process_atio_queue(vha, 0);
4324 spin_unlock_irqrestore(&ha->tgt.atio_lock, flags);
4331 qla24xx_msix_rsp_q(int irq, void *dev_id)
4333 struct qla_hw_data *ha;
4334 struct rsp_que *rsp;
4335 struct device_reg_24xx __iomem *reg;
4336 struct scsi_qla_host *vha;
4337 unsigned long flags;
4339 rsp = (struct rsp_que *) dev_id;
4341 ql_log(ql_log_info, NULL, 0x505a,
4342 "%s: NULL response queue pointer.\n", __func__);
4346 reg = &ha->iobase->isp24;
4348 spin_lock_irqsave(&ha->hardware_lock, flags);
4350 vha = pci_get_drvdata(ha->pdev);
4351 qla24xx_process_response_queue(vha, rsp);
4352 if (!ha->flags.disable_msix_handshake) {
4353 wrt_reg_dword(®->hccr, HCCRX_CLR_RISC_INT);
4354 rd_reg_dword_relaxed(®->hccr);
4356 spin_unlock_irqrestore(&ha->hardware_lock, flags);
4362 qla24xx_msix_default(int irq, void *dev_id)
4364 scsi_qla_host_t *vha;
4365 struct qla_hw_data *ha;
4366 struct rsp_que *rsp;
4367 struct device_reg_24xx __iomem *reg;
4372 unsigned long flags;
4373 bool process_atio = false;
4375 rsp = (struct rsp_que *) dev_id;
4377 ql_log(ql_log_info, NULL, 0x505c,
4378 "%s: NULL response queue pointer.\n", __func__);
4382 reg = &ha->iobase->isp24;
4385 spin_lock_irqsave(&ha->hardware_lock, flags);
4386 vha = pci_get_drvdata(ha->pdev);
4388 stat = rd_reg_dword(®->host_status);
4389 if (qla2x00_check_reg32_for_disconnect(vha, stat))
4391 if (stat & HSRX_RISC_PAUSED) {
4392 if (unlikely(pci_channel_offline(ha->pdev)))
4395 hccr = rd_reg_dword(®->hccr);
4397 ql_log(ql_log_info, vha, 0x5050,
4398 "RISC paused -- HCCR=%x, Dumping firmware.\n",
4401 qla2xxx_check_risc_status(vha);
4404 ha->isp_ops->fw_dump(vha);
4405 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
4407 } else if ((stat & HSRX_RISC_INT) == 0)
4410 switch (stat & 0xff) {
4411 case INTR_ROM_MB_SUCCESS:
4412 case INTR_ROM_MB_FAILED:
4413 case INTR_MB_SUCCESS:
4414 case INTR_MB_FAILED:
4415 qla24xx_mbx_completion(vha, MSW(stat));
4416 status |= MBX_INTERRUPT;
4419 case INTR_ASYNC_EVENT:
4421 mb[1] = rd_reg_word(®->mailbox1);
4422 mb[2] = rd_reg_word(®->mailbox2);
4423 mb[3] = rd_reg_word(®->mailbox3);
4424 qla2x00_async_event(vha, rsp, mb);
4426 case INTR_RSP_QUE_UPDATE:
4427 case INTR_RSP_QUE_UPDATE_83XX:
4428 qla24xx_process_response_queue(vha, rsp);
4430 case INTR_ATIO_QUE_UPDATE_27XX:
4431 case INTR_ATIO_QUE_UPDATE:
4432 process_atio = true;
4434 case INTR_ATIO_RSP_QUE_UPDATE:
4435 process_atio = true;
4436 qla24xx_process_response_queue(vha, rsp);
4439 ql_dbg(ql_dbg_async, vha, 0x5051,
4440 "Unrecognized interrupt type (%d).\n", stat & 0xff);
4443 wrt_reg_dword(®->hccr, HCCRX_CLR_RISC_INT);
4445 qla2x00_handle_mbx_completion(ha, status);
4446 spin_unlock_irqrestore(&ha->hardware_lock, flags);
4449 spin_lock_irqsave(&ha->tgt.atio_lock, flags);
4450 qlt_24xx_process_atio_queue(vha, 0);
4451 spin_unlock_irqrestore(&ha->tgt.atio_lock, flags);
4458 qla2xxx_msix_rsp_q(int irq, void *dev_id)
4460 struct qla_hw_data *ha;
4461 struct qla_qpair *qpair;
4465 ql_log(ql_log_info, NULL, 0x505b,
4466 "%s: NULL response queue pointer.\n", __func__);
4471 queue_work_on(smp_processor_id(), ha->wq, &qpair->q_work);
4477 qla2xxx_msix_rsp_q_hs(int irq, void *dev_id)
4479 struct qla_hw_data *ha;
4480 struct qla_qpair *qpair;
4481 struct device_reg_24xx __iomem *reg;
4482 unsigned long flags;
4486 ql_log(ql_log_info, NULL, 0x505b,
4487 "%s: NULL response queue pointer.\n", __func__);
4492 reg = &ha->iobase->isp24;
4493 spin_lock_irqsave(&ha->hardware_lock, flags);
4494 wrt_reg_dword(®->hccr, HCCRX_CLR_RISC_INT);
4495 spin_unlock_irqrestore(&ha->hardware_lock, flags);
4497 queue_work_on(smp_processor_id(), ha->wq, &qpair->q_work);
4502 /* Interrupt handling helpers. */
4504 struct qla_init_msix_entry {
4506 irq_handler_t handler;
4509 static const struct qla_init_msix_entry msix_entries[] = {
4510 { "default", qla24xx_msix_default },
4511 { "rsp_q", qla24xx_msix_rsp_q },
4512 { "atio_q", qla83xx_msix_atio_q },
4513 { "qpair_multiq", qla2xxx_msix_rsp_q },
4514 { "qpair_multiq_hs", qla2xxx_msix_rsp_q_hs },
4517 static const struct qla_init_msix_entry qla82xx_msix_entries[] = {
4518 { "qla2xxx (default)", qla82xx_msix_default },
4519 { "qla2xxx (rsp_q)", qla82xx_msix_rsp_q },
4523 qla24xx_enable_msix(struct qla_hw_data *ha, struct rsp_que *rsp)
4526 struct qla_msix_entry *qentry;
4527 scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
4528 int min_vecs = QLA_BASE_VECTORS;
4529 struct irq_affinity desc = {
4530 .pre_vectors = QLA_BASE_VECTORS,
4533 if (QLA_TGT_MODE_ENABLED() && (ql2xenablemsix != 0) &&
4534 IS_ATIO_MSIX_CAPABLE(ha)) {
4539 if (USER_CTRL_IRQ(ha) || !ha->mqiobase) {
4540 /* user wants to control IRQ setting for target mode */
4541 ret = pci_alloc_irq_vectors(ha->pdev, min_vecs,
4542 min((u16)ha->msix_count, (u16)(num_online_cpus() + min_vecs)),
4545 ret = pci_alloc_irq_vectors_affinity(ha->pdev, min_vecs,
4546 min((u16)ha->msix_count, (u16)(num_online_cpus() + min_vecs)),
4547 PCI_IRQ_MSIX | PCI_IRQ_AFFINITY,
4551 ql_log(ql_log_fatal, vha, 0x00c7,
4552 "MSI-X: Failed to enable support, "
4553 "giving up -- %d/%d.\n",
4554 ha->msix_count, ret);
4556 } else if (ret < ha->msix_count) {
4557 ql_log(ql_log_info, vha, 0x00c6,
4558 "MSI-X: Using %d vectors\n", ret);
4559 ha->msix_count = ret;
4560 /* Recalculate queue values */
4561 if (ha->mqiobase && (ql2xmqsupport || ql2xnvmeenable)) {
4562 ha->max_req_queues = ha->msix_count - 1;
4564 /* ATIOQ needs 1 vector. That's 1 less QPair */
4565 if (QLA_TGT_MODE_ENABLED())
4566 ha->max_req_queues--;
4568 ha->max_rsp_queues = ha->max_req_queues;
4570 ha->max_qpairs = ha->max_req_queues - 1;
4571 ql_dbg_pci(ql_dbg_init, ha->pdev, 0x0190,
4572 "Adjusted Max no of queues pairs: %d.\n", ha->max_qpairs);
4575 vha->irq_offset = desc.pre_vectors;
4576 ha->msix_entries = kcalloc(ha->msix_count,
4577 sizeof(struct qla_msix_entry),
4579 if (!ha->msix_entries) {
4580 ql_log(ql_log_fatal, vha, 0x00c8,
4581 "Failed to allocate memory for ha->msix_entries.\n");
4585 ha->flags.msix_enabled = 1;
4587 for (i = 0; i < ha->msix_count; i++) {
4588 qentry = &ha->msix_entries[i];
4589 qentry->vector = pci_irq_vector(ha->pdev, i);
4590 qentry->vector_base0 = i;
4592 qentry->have_irq = 0;
4594 qentry->handle = NULL;
4597 /* Enable MSI-X vectors for the base queue */
4598 for (i = 0; i < QLA_BASE_VECTORS; i++) {
4599 qentry = &ha->msix_entries[i];
4600 qentry->handle = rsp;
4602 scnprintf(qentry->name, sizeof(qentry->name),
4603 "qla2xxx%lu_%s", vha->host_no, msix_entries[i].name);
4604 if (IS_P3P_TYPE(ha))
4605 ret = request_irq(qentry->vector,
4606 qla82xx_msix_entries[i].handler,
4607 0, qla82xx_msix_entries[i].name, rsp);
4609 ret = request_irq(qentry->vector,
4610 msix_entries[i].handler,
4611 0, qentry->name, rsp);
4613 goto msix_register_fail;
4614 qentry->have_irq = 1;
4619 * If target mode is enable, also request the vector for the ATIO
4622 if (QLA_TGT_MODE_ENABLED() && (ql2xenablemsix != 0) &&
4623 IS_ATIO_MSIX_CAPABLE(ha)) {
4624 qentry = &ha->msix_entries[QLA_ATIO_VECTOR];
4626 qentry->handle = rsp;
4627 scnprintf(qentry->name, sizeof(qentry->name),
4628 "qla2xxx%lu_%s", vha->host_no,
4629 msix_entries[QLA_ATIO_VECTOR].name);
4631 ret = request_irq(qentry->vector,
4632 msix_entries[QLA_ATIO_VECTOR].handler,
4633 0, qentry->name, rsp);
4634 qentry->have_irq = 1;
4639 ql_log(ql_log_fatal, vha, 0x00cb,
4640 "MSI-X: unable to register handler -- %x/%d.\n",
4641 qentry->vector, ret);
4642 qla2x00_free_irqs(vha);
4647 /* Enable MSI-X vector for response queue update for queue 0 */
4648 if (IS_MQUE_CAPABLE(ha) &&
4649 (ha->msixbase && ha->mqiobase && ha->max_qpairs))
4654 ql_dbg(ql_dbg_multiq, vha, 0xc005,
4655 "mqiobase=%p, max_rsp_queues=%d, max_req_queues=%d.\n",
4656 ha->mqiobase, ha->max_rsp_queues, ha->max_req_queues);
4657 ql_dbg(ql_dbg_init, vha, 0x0055,
4658 "mqiobase=%p, max_rsp_queues=%d, max_req_queues=%d.\n",
4659 ha->mqiobase, ha->max_rsp_queues, ha->max_req_queues);
4665 pci_free_irq_vectors(ha->pdev);
4670 qla2x00_request_irqs(struct qla_hw_data *ha, struct rsp_que *rsp)
4672 int ret = QLA_FUNCTION_FAILED;
4673 device_reg_t *reg = ha->iobase;
4674 scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
4676 /* If possible, enable MSI-X. */
4677 if (ql2xenablemsix == 0 || (!IS_QLA2432(ha) && !IS_QLA2532(ha) &&
4678 !IS_QLA8432(ha) && !IS_CNA_CAPABLE(ha) && !IS_QLA2031(ha) &&
4679 !IS_QLAFX00(ha) && !IS_QLA27XX(ha) && !IS_QLA28XX(ha)))
4682 if (ql2xenablemsix == 2)
4685 if (ha->pdev->subsystem_vendor == PCI_VENDOR_ID_HP &&
4686 (ha->pdev->subsystem_device == 0x7040 ||
4687 ha->pdev->subsystem_device == 0x7041 ||
4688 ha->pdev->subsystem_device == 0x1705)) {
4689 ql_log(ql_log_warn, vha, 0x0034,
4690 "MSI-X: Unsupported ISP 2432 SSVID/SSDID (0x%X,0x%X).\n",
4691 ha->pdev->subsystem_vendor,
4692 ha->pdev->subsystem_device);
4696 if (IS_QLA2432(ha) && (ha->pdev->revision < QLA_MSIX_CHIP_REV_24XX)) {
4697 ql_log(ql_log_warn, vha, 0x0035,
4698 "MSI-X; Unsupported ISP2432 (0x%X, 0x%X).\n",
4699 ha->pdev->revision, QLA_MSIX_CHIP_REV_24XX);
4703 ret = qla24xx_enable_msix(ha, rsp);
4705 ql_dbg(ql_dbg_init, vha, 0x0036,
4706 "MSI-X: Enabled (0x%X, 0x%X).\n",
4707 ha->chip_revision, ha->fw_attributes);
4708 goto clear_risc_ints;
4713 ql_log(ql_log_info, vha, 0x0037,
4714 "Falling back-to MSI mode -- ret=%d.\n", ret);
4716 if (!IS_QLA24XX(ha) && !IS_QLA2532(ha) && !IS_QLA8432(ha) &&
4717 !IS_QLA8001(ha) && !IS_P3P_TYPE(ha) && !IS_QLAFX00(ha) &&
4718 !IS_QLA27XX(ha) && !IS_QLA28XX(ha))
4721 ret = pci_alloc_irq_vectors(ha->pdev, 1, 1, PCI_IRQ_MSI);
4723 ql_dbg(ql_dbg_init, vha, 0x0038,
4725 ha->flags.msi_enabled = 1;
4727 ql_log(ql_log_warn, vha, 0x0039,
4728 "Falling back-to INTa mode -- ret=%d.\n", ret);
4731 /* Skip INTx on ISP82xx. */
4732 if (!ha->flags.msi_enabled && IS_QLA82XX(ha))
4733 return QLA_FUNCTION_FAILED;
4735 ret = request_irq(ha->pdev->irq, ha->isp_ops->intr_handler,
4736 ha->flags.msi_enabled ? 0 : IRQF_SHARED,
4737 QLA2XXX_DRIVER_NAME, rsp);
4739 ql_log(ql_log_warn, vha, 0x003a,
4740 "Failed to reserve interrupt %d already in use.\n",
4743 } else if (!ha->flags.msi_enabled) {
4744 ql_dbg(ql_dbg_init, vha, 0x0125,
4745 "INTa mode: Enabled.\n");
4746 ha->flags.mr_intr_valid = 1;
4747 /* Set max_qpair to 0, as MSI-X and MSI in not enabled */
4752 if (IS_FWI2_CAPABLE(ha) || IS_QLAFX00(ha))
4755 spin_lock_irq(&ha->hardware_lock);
4756 wrt_reg_word(®->isp.semaphore, 0);
4757 spin_unlock_irq(&ha->hardware_lock);
4764 qla2x00_free_irqs(scsi_qla_host_t *vha)
4766 struct qla_hw_data *ha = vha->hw;
4767 struct rsp_que *rsp;
4768 struct qla_msix_entry *qentry;
4772 * We need to check that ha->rsp_q_map is valid in case we are called
4773 * from a probe failure context.
4775 if (!ha->rsp_q_map || !ha->rsp_q_map[0])
4777 rsp = ha->rsp_q_map[0];
4779 if (ha->flags.msix_enabled) {
4780 for (i = 0; i < ha->msix_count; i++) {
4781 qentry = &ha->msix_entries[i];
4782 if (qentry->have_irq) {
4783 irq_set_affinity_notifier(qentry->vector, NULL);
4784 free_irq(pci_irq_vector(ha->pdev, i), qentry->handle);
4787 kfree(ha->msix_entries);
4788 ha->msix_entries = NULL;
4789 ha->flags.msix_enabled = 0;
4790 ql_dbg(ql_dbg_init, vha, 0x0042,
4791 "Disabled MSI-X.\n");
4793 free_irq(pci_irq_vector(ha->pdev, 0), rsp);
4797 pci_free_irq_vectors(ha->pdev);
4800 int qla25xx_request_irq(struct qla_hw_data *ha, struct qla_qpair *qpair,
4801 struct qla_msix_entry *msix, int vector_type)
4803 const struct qla_init_msix_entry *intr = &msix_entries[vector_type];
4804 scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
4807 scnprintf(msix->name, sizeof(msix->name),
4808 "qla2xxx%lu_qpair%d", vha->host_no, qpair->id);
4809 ret = request_irq(msix->vector, intr->handler, 0, msix->name, qpair);
4811 ql_log(ql_log_fatal, vha, 0x00e6,
4812 "MSI-X: Unable to register handler -- %x/%d.\n",
4817 msix->handle = qpair;
4818 qla_mapq_init_qp_cpu_map(ha, msix, qpair);