?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
drm/tests: hdmi: Fix memory leaks in drm_display_mode_from_cea_vic()
[drm/drm-misc.git] / drivers / scsi / qla2xxx / qla_isr.c
blobfe98c76e9be32ff03a1960f366f0d700d1168383
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * QLogic Fibre Channel HBA Driver
4 * Copyright (c) 2003-2014 QLogic Corporation
5 */
6 #include "qla_def.h"
7 #include "qla_target.h"
8 #include "qla_gbl.h"
9
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>
19
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 *,
24 sts_entry_t *);
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,
28 uint16_t size);
29 static struct purex_item *qla24xx_copy_std_pkt(struct scsi_qla_host *vha,
30 void *pkt);
31 static struct purex_item *qla27xx_copy_fpin_pkt(struct scsi_qla_host *vha,
32 void **pkt, struct rsp_que **rsp);
33
34 static void
35 qla27xx_process_purex_fpin(struct scsi_qla_host *vha, struct purex_item *item)
36 {
37 void *pkt = &item->iocb;
38 uint16_t pkt_size = item->size;
39
40 ql_dbg(ql_dbg_init + ql_dbg_verbose, vha, 0x508d,
41 "%s: Enter\n", __func__);
42
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,
46 pkt, pkt_size);
47
48 fc_host_fpin_rcv(vha->host, pkt_size, (char *)pkt, 0);
49 }
50
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"
57 };
58
59 #define SFP_DISABLE_LASER_INITIATED 0x15 /* Sub code of 8070 AEN */
60 #define SFP_ENABLE_LASER_INITIATED 0x16 /* Sub code of 8070 AEN */
61
62 static inline void display_Laser_info(scsi_qla_host_t *vha,
63 u16 mb1, u16 mb2, u16 mb3) {
64
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",
68 mb3, mb2);
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",
72 mb3);
73 }
74
75 static void
76 qla24xx_process_abts(struct scsi_qla_host *vha, struct purex_item *pkt)
77 {
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;
83 dma_addr_t dma;
84 uint32_t fctl;
85 int rval;
86
87 ql_dbg(ql_dbg_init, vha, 0x0286, "%s: entered.\n", __func__);
88
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));
97
98 rsp_els = dma_alloc_coherent(&ha->pdev->dev, sizeof(*rsp_els), &dma,
99 GFP_KERNEL);
100 if (!rsp_els) {
101 ql_log(ql_log_warn, vha, 0x0287,
102 "Failed allocate dma buffer ABTS/ELS RSP.\n");
103 return;
104 }
105
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);
120 if (rval) {
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);
128 } else {
129 ql_dbg(ql_dbg_init, vha, 0x028a,
130 "%s: abort exchange done.\n", __func__);
131 }
132
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);
171 if (rval) {
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);
180 } else {
181 ql_dbg(ql_dbg_init, vha, 0x028ea,
182 "%s: done.\n", __func__);
183 }
184
185 dma_free_coherent(&ha->pdev->dev, sizeof(*rsp_els), rsp_els, dma);
186 }
187
188 /**
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.
196 *
197 * it is assumed pkt is the head iocb, not the continuation iocbk
198 */
199 void __qla_consume_iocb(struct scsi_qla_host *vha,
200 void **pkt, struct rsp_que **rsp)
201 {
202 struct rsp_que *rsp_q = *rsp;
203 response_t *new_pkt;
204 uint16_t entry_count_remaining;
205 struct purex_entry_24xx *purex = *pkt;
206
207 entry_count_remaining = purex->entry_count;
208 while (entry_count_remaining > 0) {
209 new_pkt = rsp_q->ring_ptr;
210 *pkt = new_pkt;
211
212 rsp_q->ring_index++;
213 if (rsp_q->ring_index == rsp_q->length) {
214 rsp_q->ring_index = 0;
215 rsp_q->ring_ptr = rsp_q->ring;
216 } else {
217 rsp_q->ring_ptr++;
218 }
219
220 new_pkt->signature = RESPONSE_PROCESSED;
221 /* flush signature */
222 wmb();
223 --entry_count_remaining;
224 }
225 }
226
227 /**
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
235 */
236 int __qla_copy_purex_to_buffer(struct scsi_qla_host *vha,
237 void **pkt, struct rsp_que **rsp, u8 *buf, u32 buf_len)
238 {
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;
245 u16 tpad;
246
247 entry_count_remaining = purex->entry_count;
248 total_bytes = (le16_to_cpu(purex->frame_size) & 0x0FFF)
249 - PURX_ELS_HEADER_SIZE;
250
251 /*
252 * end of payload may not end in 4bytes boundary. Need to
253 * round up / pad for room to swap, before saving data
254 */
255 tpad = roundup(total_bytes, 4);
256
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);
262 return -EIO;
263 }
264
265 pending_bytes = total_bytes = tpad;
266 no_bytes = (pending_bytes > sizeof(purex->els_frame_payload)) ?
267 sizeof(purex->els_frame_payload) : pending_bytes;
268
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;
273
274 ((response_t *)purex)->signature = RESPONSE_PROCESSED;
275 /* flush signature */
276 wmb();
277
278 do {
279 while ((total_bytes > 0) && (entry_count_remaining > 0)) {
280 new_pkt = (sts_cont_entry_t *)rsp_q->ring_ptr;
281 *pkt = new_pkt;
282
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",
286 buffer_copy_offset);
287 break;
288 }
289
290 rsp_q->ring_index++;
291 if (rsp_q->ring_index == rsp_q->length) {
292 rsp_q->ring_index = 0;
293 rsp_q->ring_ptr = rsp_q->ring;
294 } else {
295 rsp_q->ring_ptr++;
296 }
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,
301 no_bytes);
302 buffer_copy_offset += no_bytes;
303 pending_bytes -= no_bytes;
304 --entry_count_remaining;
305 } else {
306 ql_log(ql_log_warn, vha, 0x5044,
307 "Attempt to copy more that we got, optimizing..%x\n",
308 buffer_copy_offset);
309 memcpy((buf + buffer_copy_offset), new_pkt->data,
310 total_bytes - buffer_copy_offset);
311 }
312
313 ((response_t *)new_pkt)->signature = RESPONSE_PROCESSED;
314 /* flush signature */
315 wmb();
316 }
317
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);
322 return -EIO;
323 }
324 } while (entry_count_remaining > 0);
325
326 be32_to_cpu_array((u32 *)buf, (__be32 *)buf, total_bytes >> 2);
327
328 return 0;
329 }
330
331 /**
332 * qla2100_intr_handler() - Process interrupts for the ISP2100 and ISP2200.
333 * @irq: interrupt number
334 * @dev_id: SCSI driver HA context
335 *
336 * Called by system whenever the host adapter generates an interrupt.
337 *
338 * Returns handled flag.
339 */
340 irqreturn_t
341 qla2100_intr_handler(int irq, void *dev_id)
342 {
343 scsi_qla_host_t *vha;
344 struct qla_hw_data *ha;
345 struct device_reg_2xxx __iomem *reg;
346 int status;
347 unsigned long iter;
348 uint16_t hccr;
349 uint16_t mb[8];
350 struct rsp_que *rsp;
351 unsigned long flags;
352
353 rsp = (struct rsp_que *) dev_id;
354 if (!rsp) {
355 ql_log(ql_log_info, NULL, 0x505d,
356 "%s: NULL response queue pointer.\n", __func__);
357 return (IRQ_NONE);
358 }
359
360 ha = rsp->hw;
361 reg = &ha->iobase->isp;
362 status = 0;
363
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(&reg->hccr);
368 if (qla2x00_check_reg16_for_disconnect(vha, hccr))
369 break;
370 if (hccr & HCCR_RISC_PAUSE) {
371 if (pci_channel_offline(ha->pdev))
372 break;
373
374 /*
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.
378 */
379 wrt_reg_word(&reg->hccr, HCCR_RESET_RISC);
380 rd_reg_word(&reg->hccr);
381
382 ha->isp_ops->fw_dump(vha);
383 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
384 break;
385 } else if ((rd_reg_word(&reg->istatus) & ISR_RISC_INT) == 0)
386 break;
387
388 if (rd_reg_word(&reg->semaphore) & BIT_0) {
389 wrt_reg_word(&reg->hccr, HCCR_CLR_RISC_INT);
390 rd_reg_word(&reg->hccr);
391
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);
402 } else {
403 /*EMPTY*/
404 ql_dbg(ql_dbg_async, vha, 0x5025,
405 "Unrecognized interrupt type (%d).\n",
406 mb[0]);
407 }
408 /* Release mailbox registers. */
409 wrt_reg_word(&reg->semaphore, 0);
410 rd_reg_word(&reg->semaphore);
411 } else {
412 qla2x00_process_response_queue(rsp);
413
414 wrt_reg_word(&reg->hccr, HCCR_CLR_RISC_INT);
415 rd_reg_word(&reg->hccr);
416 }
417 }
418 qla2x00_handle_mbx_completion(ha, status);
419 spin_unlock_irqrestore(&ha->hardware_lock, flags);
420
421 return (IRQ_HANDLED);
422 }
423
424 bool
425 qla2x00_check_reg32_for_disconnect(scsi_qla_host_t *vha, uint32_t reg)
426 {
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);
433 }
434 return true;
435 } else
436 return false;
437 }
438
439 bool
440 qla2x00_check_reg16_for_disconnect(scsi_qla_host_t *vha, uint16_t reg)
441 {
442 return qla2x00_check_reg32_for_disconnect(vha, 0xffff0000 | reg);
443 }
444
445 /**
446 * qla2300_intr_handler() - Process interrupts for the ISP23xx and ISP63xx.
447 * @irq: interrupt number
448 * @dev_id: SCSI driver HA context
449 *
450 * Called by system whenever the host adapter generates an interrupt.
451 *
452 * Returns handled flag.
453 */
454 irqreturn_t
455 qla2300_intr_handler(int irq, void *dev_id)
456 {
457 scsi_qla_host_t *vha;
458 struct device_reg_2xxx __iomem *reg;
459 int status;
460 unsigned long iter;
461 uint32_t stat;
462 uint16_t hccr;
463 uint16_t mb[8];
464 struct rsp_que *rsp;
465 struct qla_hw_data *ha;
466 unsigned long flags;
467
468 rsp = (struct rsp_que *) dev_id;
469 if (!rsp) {
470 ql_log(ql_log_info, NULL, 0x5058,
471 "%s: NULL response queue pointer.\n", __func__);
472 return (IRQ_NONE);
473 }
474
475 ha = rsp->hw;
476 reg = &ha->iobase->isp;
477 status = 0;
478
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(&reg->u.isp2300.host_status);
483 if (qla2x00_check_reg32_for_disconnect(vha, stat))
484 break;
485 if (stat & HSR_RISC_PAUSED) {
486 if (unlikely(pci_channel_offline(ha->pdev)))
487 break;
488
489 hccr = rd_reg_word(&reg->hccr);
490
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);
495 else
496 ql_log(ql_log_warn, vha, 0x5027,
497 "RISC paused -- HCCR=%x, Dumping "
498 "firmware.\n", hccr);
499
500 /*
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.
504 */
505 wrt_reg_word(&reg->hccr, HCCR_RESET_RISC);
506 rd_reg_word(&reg->hccr);
507
508 ha->isp_ops->fw_dump(vha);
509 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
510 break;
511 } else if ((stat & HSR_RISC_INT) == 0)
512 break;
513
514 switch (stat & 0xff) {
515 case 0x1:
516 case 0x2:
517 case 0x10:
518 case 0x11:
519 qla2x00_mbx_completion(vha, MSW(stat));
520 status |= MBX_INTERRUPT;
521
522 /* Release mailbox registers. */
523 wrt_reg_word(&reg->semaphore, 0);
524 break;
525 case 0x12:
526 mb[0] = MSW(stat);
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);
531 break;
532 case 0x13:
533 qla2x00_process_response_queue(rsp);
534 break;
535 case 0x15:
536 mb[0] = MBA_CMPLT_1_16BIT;
537 mb[1] = MSW(stat);
538 qla2x00_async_event(vha, rsp, mb);
539 break;
540 case 0x16:
541 mb[0] = MBA_SCSI_COMPLETION;
542 mb[1] = MSW(stat);
543 mb[2] = RD_MAILBOX_REG(ha, reg, 2);
544 qla2x00_async_event(vha, rsp, mb);
545 break;
546 default:
547 ql_dbg(ql_dbg_async, vha, 0x5028,
548 "Unrecognized interrupt type (%d).\n", stat & 0xff);
549 break;
550 }
551 wrt_reg_word(&reg->hccr, HCCR_CLR_RISC_INT);
552 rd_reg_word_relaxed(&reg->hccr);
553 }
554 qla2x00_handle_mbx_completion(ha, status);
555 spin_unlock_irqrestore(&ha->hardware_lock, flags);
556
557 return (IRQ_HANDLED);
558 }
559
560 /**
561 * qla2x00_mbx_completion() - Process mailbox command completions.
562 * @vha: SCSI driver HA context
563 * @mb0: Mailbox0 register
564 */
565 static void
566 qla2x00_mbx_completion(scsi_qla_host_t *vha, uint16_t mb0)
567 {
568 uint16_t cnt;
569 uint32_t mboxes;
570 __le16 __iomem *wptr;
571 struct qla_hw_data *ha = vha->hw;
572 struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
573
574 /* Read all mbox registers? */
575 WARN_ON_ONCE(ha->mbx_count > 32);
576 mboxes = (1ULL << ha->mbx_count) - 1;
577 if (!ha->mcp)
578 ql_dbg(ql_dbg_async, vha, 0x5001, "MBX pointer ERROR.\n");
579 else
580 mboxes = ha->mcp->in_mb;
581
582 /* Load return mailbox registers. */
583 ha->flags.mbox_int = 1;
584 ha->mailbox_out[0] = mb0;
585 mboxes >>= 1;
586 wptr = MAILBOX_REG(ha, reg, 1);
587
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);
595
596 wptr++;
597 mboxes >>= 1;
598 }
599 }
600
601 static void
602 qla81xx_idc_event(scsi_qla_host_t *vha, uint16_t aen, uint16_t descr)
603 {
604 static char *event[] =
605 { "Complete", "Request Notification", "Time Extension" };
606 int rval;
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];
611
612 /* Seed data -- mailbox1 -> mailbox7. */
613 if (IS_QLA81XX(vha->hw) || IS_QLA83XX(vha->hw))
614 wptr = &reg24->mailbox1;
615 else if (IS_QLA8044(vha->hw))
616 wptr = &reg82->mailbox_out[1];
617 else
618 return;
619
620 for (cnt = 0; cnt < QLA_IDC_ACK_REGS; cnt++, wptr++)
621 mb[cnt] = rd_reg_word(wptr);
622
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]);
628 switch (aen) {
629 /* Handle IDC Error completion case. */
630 case MBA_IDC_COMPLETE:
631 if (mb[1] >> 15) {
632 vha->hw->flags.idc_compl_status = 1;
633 if (vha->hw->notify_dcbx_comp && !vha->vp_idx)
634 complete(&vha->hw->dcbx_comp);
635 }
636 break;
637
638 case MBA_IDC_NOTIFY:
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);
644
645 if (!timeout)
646 return;
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");
651 break;
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);
658 break;
659 }
660 }
661
662 #define LS_UNKNOWN 2
663 const char *
664 qla2x00_get_link_speed_str(struct qla_hw_data *ha, uint16_t speed)
665 {
666 static const char *const link_speeds[] = {
667 "1", "2", "?", "4", "8", "16", "32", "64", "10"
668 };
669 #define QLA_LAST_SPEED (ARRAY_SIZE(link_speeds) - 1)
670
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];
677 else
678 return link_speeds[LS_UNKNOWN];
679 }
680
681 static void
682 qla83xx_handle_8200_aen(scsi_qla_host_t *vha, uint16_t *mb)
683 {
684 struct qla_hw_data *ha = vha->hw;
685
686 /*
687 * 8200 AEN Interpretation:
688 * mb[0] = AEN code
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
696 */
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]);
703
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");
709
710 if (mb[1] & IDC_PEG_HALT_STATUS_CHANGE) {
711 uint32_t protocol_engine_id, fw_err_code, err_level;
712
713 /*
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])
725 */
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 "
742 "required.\n");
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);
751 }
752 }
753
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;
760
761 /*
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
773 * valid
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
778 * Ethernet
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
790 * Bit 31 = Reserved
791 */
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);
803
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,
810 sfp_status);
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,
819 dcbx_status);
820
821 qla83xx_schedule_work(vha, QLA83XX_NIC_CORE_RESET);
822 }
823
824 if (mb[1] & IDC_HEARTBEAT_FAILURE) {
825 ql_log(ql_log_warn, vha, 0x5069,
826 "Heartbeat Failure encountered, chip reset "
827 "required.\n");
828
829 qla83xx_schedule_work(vha, QLA83XX_NIC_CORE_RESET);
830 }
831 }
832
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)
837 return;
838 qla83xx_schedule_work(vha, MBA_IDC_AEN);
839 }
840 }
841
842 /**
843 * qla27xx_copy_multiple_pkt() - Copy over purex/purls packets that can
844 * span over multiple IOCBs.
845 * @vha: SCSI driver HA context
846 * @pkt: ELS packet
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
851 */
852 struct purex_item *
853 qla27xx_copy_multiple_pkt(struct scsi_qla_host *vha, void **pkt,
854 struct rsp_que **rsp, bool is_purls,
855 bool byte_order)
856 {
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;
866
867 if (is_purls) {
868 purls = *pkt;
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);
873 } else {
874 purex = *pkt;
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);
879 }
880
881 pending_bytes = total_bytes;
882 no_bytes = (pending_bytes > payload_size) ? payload_size :
883 pending_bytes;
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);
887
888 item = qla24xx_alloc_purex_item(vha, total_bytes);
889 if (!item)
890 return item;
891
892 iocb_pkt = &item->iocb;
893
894 if (is_purls)
895 memcpy(iocb_pkt, &purls->payload[0], no_bytes);
896 else
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;
901
902 if (is_purls)
903 ((response_t *)purls)->signature = RESPONSE_PROCESSED;
904 else
905 ((response_t *)purex)->signature = RESPONSE_PROCESSED;
906 wmb();
907
908 do {
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",
913 buffer_copy_offset);
914 cpu_relax();
915 continue;
916 }
917
918 new_pkt = (sts_cont_entry_t *)rsp_q->ring_ptr;
919 *pkt = new_pkt;
920
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",
924 buffer_copy_offset);
925 break;
926 }
927
928 rsp_q->ring_index++;
929 if (rsp_q->ring_index == rsp_q->length) {
930 rsp_q->ring_index = 0;
931 rsp_q->ring_ptr = rsp_q->ring;
932 } else {
933 rsp_q->ring_ptr++;
934 }
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;
943 } else {
944 ql_log(ql_log_warn, vha, 0x5044,
945 "Attempt to copy more that we got, optimizing..%x\n",
946 buffer_copy_offset);
947 memcpy(((uint8_t *)iocb_pkt + buffer_copy_offset),
948 new_pkt->data,
949 total_bytes - buffer_copy_offset);
950 }
951
952 ((response_t *)new_pkt)->signature = RESPONSE_PROCESSED;
953 wmb();
954 }
955
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);
961 return NULL;
962 }
963 } while (entry_count_remaining > 0);
964
965 if (byte_order)
966 host_to_fcp_swap((uint8_t *)&item->iocb, total_bytes);
967
968 return item;
969 }
970
971 int
972 qla2x00_is_a_vp_did(scsi_qla_host_t *vha, uint32_t rscn_entry)
973 {
974 struct qla_hw_data *ha = vha->hw;
975 scsi_qla_host_t *vp;
976 uint32_t vp_did;
977 unsigned long flags;
978 int ret = 0;
979
980 if (!ha->num_vhosts)
981 return ret;
982
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) {
987 ret = 1;
988 break;
989 }
990 }
991 spin_unlock_irqrestore(&ha->vport_slock, flags);
992
993 return ret;
994 }
995
996 fc_port_t *
997 qla2x00_find_fcport_by_loopid(scsi_qla_host_t *vha, uint16_t loop_id)
998 {
999 fc_port_t *f, *tf;
1000
1001 f = tf = NULL;
1002 list_for_each_entry_safe(f, tf, &vha->vp_fcports, list)
1003 if (f->loop_id == loop_id)
1004 return f;
1005 return NULL;
1006 }
1007
1008 fc_port_t *
1009 qla2x00_find_fcport_by_wwpn(scsi_qla_host_t *vha, u8 *wwpn, u8 incl_deleted)
1010 {
1011 fc_port_t *f, *tf;
1012
1013 f = tf = NULL;
1014 list_for_each_entry_safe(f, tf, &vha->vp_fcports, list) {
1015 if (memcmp(f->port_name, wwpn, WWN_SIZE) == 0) {
1016 if (incl_deleted)
1017 return f;
1018 else if (f->deleted == 0)
1019 return f;
1020 }
1021 }
1022 return NULL;
1023 }
1024
1025 fc_port_t *
1026 qla2x00_find_fcport_by_nportid(scsi_qla_host_t *vha, port_id_t *id,
1027 u8 incl_deleted)
1028 {
1029 fc_port_t *f, *tf;
1030
1031 f = tf = NULL;
1032 list_for_each_entry_safe(f, tf, &vha->vp_fcports, list) {
1033 if (f->d_id.b24 == id->b24) {
1034 if (incl_deleted)
1035 return f;
1036 else if (f->deleted == 0)
1037 return f;
1038 }
1039 }
1040 return NULL;
1041 }
1042
1043 /* Shall be called only on supported adapters. */
1044 static void
1045 qla27xx_handle_8200_aen(scsi_qla_host_t *vha, uint16_t *mb)
1046 {
1047 struct qla_hw_data *ha = vha->hw;
1048 bool reset_isp_needed = false;
1049
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]);
1055
1056 if ((mb[1] & BIT_8) == 0)
1057 return;
1058
1059 ql_log(ql_log_warn, vha, 0x02f1,
1060 "MPI Heartbeat stop. FW dump needed\n");
1061
1062 if (ql2xfulldump_on_mpifail) {
1063 ha->isp_ops->fw_dump(vha);
1064 reset_isp_needed = true;
1065 }
1066
1067 ha->isp_ops->mpi_fw_dump(vha, 1);
1068
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);
1073 }
1074 }
1075
1076 static struct purex_item *
1077 qla24xx_alloc_purex_item(scsi_qla_host_t *vha, uint16_t size)
1078 {
1079 struct purex_item *item = NULL;
1080 uint8_t item_hdr_size = sizeof(*item);
1081
1082 if (size > QLA_DEFAULT_PAYLOAD_SIZE) {
1083 item = kzalloc(item_hdr_size +
1084 (size - QLA_DEFAULT_PAYLOAD_SIZE), GFP_ATOMIC);
1085 } else {
1086 if (atomic_inc_return(&vha->default_item.in_use) == 1) {
1087 item = &vha->default_item;
1088 goto initialize_purex_header;
1089 } else {
1090 item = kzalloc(item_hdr_size, GFP_ATOMIC);
1091 }
1092 }
1093 if (!item) {
1094 ql_log(ql_log_warn, vha, 0x5092,
1095 ">> Failed allocate purex list item.\n");
1096
1097 return NULL;
1098 }
1099
1100 initialize_purex_header:
1101 item->vha = vha;
1102 item->size = size;
1103 return item;
1104 }
1105
1106 void
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))
1110 {
1111 struct purex_list *list = &vha->purex_list;
1112 ulong flags;
1113
1114 pkt->process_item = process_item;
1115
1116 spin_lock_irqsave(&list->lock, flags);
1117 list_add_tail(&pkt->list, &list->head);
1118 spin_unlock_irqrestore(&list->lock, flags);
1119
1120 set_bit(PROCESS_PUREX_IOCB, &vha->dpc_flags);
1121 }
1122
1123 /**
1124 * qla24xx_copy_std_pkt() - Copy over purex ELS which is
1125 * contained in a single IOCB.
1126 * purex packet.
1127 * @vha: SCSI driver HA context
1128 * @pkt: ELS packet
1129 */
1130 static struct purex_item
1131 *qla24xx_copy_std_pkt(struct scsi_qla_host *vha, void *pkt)
1132 {
1133 struct purex_item *item;
1134
1135 item = qla24xx_alloc_purex_item(vha,
1136 QLA_DEFAULT_PAYLOAD_SIZE);
1137 if (!item)
1138 return item;
1139
1140 memcpy(&item->iocb, pkt, sizeof(item->iocb));
1141 return item;
1142 }
1143
1144 /**
1145 * qla27xx_copy_fpin_pkt() - Copy over fpin packets that can
1146 * span over multiple IOCBs.
1147 * @vha: SCSI driver HA context
1148 * @pkt: ELS packet
1149 * @rsp: Response queue
1150 */
1151 static struct purex_item *
1152 qla27xx_copy_fpin_pkt(struct scsi_qla_host *vha, void **pkt,
1153 struct rsp_que **rsp)
1154 {
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;
1163
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);
1173
1174 item = qla24xx_alloc_purex_item(vha, total_bytes);
1175 if (!item)
1176 return item;
1177
1178 fpin_pkt = &item->iocb;
1179
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;
1184
1185 ((response_t *)purex)->signature = RESPONSE_PROCESSED;
1186 wmb();
1187
1188 do {
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);
1194 cpu_relax();
1195 continue;
1196 }
1197
1198 new_pkt = (sts_cont_entry_t *)rsp_q->ring_ptr;
1199 *pkt = new_pkt;
1200
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);
1205 break;
1206 }
1207
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;
1212 } else {
1213 rsp_q->ring_ptr++;
1214 }
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,
1220 no_bytes);
1221 buffer_copy_offset += no_bytes;
1222 pending_bytes -= no_bytes;
1223 --entry_count_remaining;
1224 } else {
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);
1231 }
1232
1233 ((response_t *)new_pkt)->signature = RESPONSE_PROCESSED;
1234 wmb();
1235 }
1236
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);
1242 return NULL;
1243 }
1244 } while (entry_count_remaining > 0);
1245 host_to_fcp_swap((uint8_t *)&item->iocb, total_bytes);
1246 return item;
1247 }
1248
1249 /**
1250 * qla2x00_async_event() - Process aynchronous events.
1251 * @vha: SCSI driver HA context
1252 * @rsp: response queue
1253 * @mb: Mailbox registers (0 - 3)
1254 */
1255 void
1256 qla2x00_async_event(scsi_qla_host_t *vha, struct rsp_que *rsp, uint16_t *mb)
1257 {
1258 uint16_t handle_cnt;
1259 uint16_t cnt, mbx;
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;
1268
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]);
1273 return;
1274 }
1275
1276 /* Setup to process RIO completion. */
1277 handle_cnt = 0;
1278 if (IS_CNA_CAPABLE(ha))
1279 goto skip_rio;
1280 switch (mb[0]) {
1281 case MBA_SCSI_COMPLETION:
1282 handles[0] = make_handle(mb[2], mb[1]);
1283 handle_cnt = 1;
1284 break;
1285 case MBA_CMPLT_1_16BIT:
1286 handles[0] = mb[1];
1287 handle_cnt = 1;
1288 mb[0] = MBA_SCSI_COMPLETION;
1289 break;
1290 case MBA_CMPLT_2_16BIT:
1291 handles[0] = mb[1];
1292 handles[1] = mb[2];
1293 handle_cnt = 2;
1294 mb[0] = MBA_SCSI_COMPLETION;
1295 break;
1296 case MBA_CMPLT_3_16BIT:
1297 handles[0] = mb[1];
1298 handles[1] = mb[2];
1299 handles[2] = mb[3];
1300 handle_cnt = 3;
1301 mb[0] = MBA_SCSI_COMPLETION;
1302 break;
1303 case MBA_CMPLT_4_16BIT:
1304 handles[0] = mb[1];
1305 handles[1] = mb[2];
1306 handles[2] = mb[3];
1307 handles[3] = (uint32_t)RD_MAILBOX_REG(ha, reg, 6);
1308 handle_cnt = 4;
1309 mb[0] = MBA_SCSI_COMPLETION;
1310 break;
1311 case MBA_CMPLT_5_16BIT:
1312 handles[0] = mb[1];
1313 handles[1] = mb[2];
1314 handles[2] = mb[3];
1315 handles[3] = (uint32_t)RD_MAILBOX_REG(ha, reg, 6);
1316 handles[4] = (uint32_t)RD_MAILBOX_REG(ha, reg, 7);
1317 handle_cnt = 5;
1318 mb[0] = MBA_SCSI_COMPLETION;
1319 break;
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));
1324 handle_cnt = 2;
1325 mb[0] = MBA_SCSI_COMPLETION;
1326 break;
1327 default:
1328 break;
1329 }
1330 skip_rio:
1331 switch (mb[0]) {
1332 case MBA_SCSI_COMPLETION: /* Fast Post */
1333 if (!vha->flags.online)
1334 break;
1335
1336 for (cnt = 0; cnt < handle_cnt; cnt++)
1337 qla2x00_process_completed_request(vha, rsp->req,
1338 handles[cnt]);
1339 break;
1340
1341 case MBA_RESET: /* Reset */
1342 ql_dbg(ql_dbg_async, vha, 0x5002,
1343 "Asynchronous RESET.\n");
1344
1345 set_bit(RESET_MARKER_NEEDED, &vha->dpc_flags);
1346 break;
1347
1348 case MBA_SYSTEM_ERR: /* System Error */
1349 mbx = 0;
1350
1351 vha->hw_err_cnt++;
1352
1353 if (IS_QLA81XX(ha) || IS_QLA83XX(ha) ||
1354 IS_QLA27XX(ha) || IS_QLA28XX(ha)) {
1355 u16 m[4];
1356
1357 m[0] = rd_reg_word(&reg24->mailbox4);
1358 m[1] = rd_reg_word(&reg24->mailbox5);
1359 m[2] = rd_reg_word(&reg24->mailbox6);
1360 mbx = m[3] = rd_reg_word(&reg24->mailbox7);
1361
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]);
1365 } else
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]);
1369
1370 if ((IS_QLA27XX(ha) || IS_QLA28XX(ha)) &&
1371 rd_reg_word(&reg24->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;
1375 QLA_FW_STOPPED(ha);
1376
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;
1384 } else {
1385 /* Check to see if MPI timeout occurred */
1386 if ((mbx & MBX_3) && (ha->port_no == 0))
1387 set_bit(MPI_RESET_NEEDED,
1388 &vha->dpc_flags);
1389
1390 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
1391 }
1392 } else if (mb[1] == 0) {
1393 ql_log(ql_log_fatal, vha, 0x5005,
1394 "Unrecoverable Hardware Error: adapter marked "
1395 "OFFLINE!\n");
1396 vha->flags.online = 0;
1397 vha->device_flags |= DFLG_DEV_FAILED;
1398 } else
1399 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
1400 break;
1401
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]);
1405
1406 vha->hw_err_cnt++;
1407
1408 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
1409 break;
1410
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]);
1414
1415 vha->hw_err_cnt++;
1416
1417 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
1418 break;
1419
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]);
1423 break;
1424
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);
1429 break;
1430
1431 case MBA_LIP_OCCURRED: /* Loop Initialization Procedure */
1432 ha->flags.lip_ae = 1;
1433
1434 ql_dbg(ql_dbg_async, vha, 0x5009,
1435 "LIP occurred (%x).\n", mb[1]);
1436
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);
1441 }
1442
1443 if (vha->vp_idx) {
1444 atomic_set(&vha->vp_state, VP_FAILED);
1445 fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
1446 }
1447
1448 set_bit(REGISTER_FC4_NEEDED, &vha->dpc_flags);
1449 set_bit(REGISTER_FDMI_NEEDED, &vha->dpc_flags);
1450
1451 vha->flags.management_server_logged_in = 0;
1452 qla2x00_post_aen_work(vha, FCH_EVT_LIP, mb[1]);
1453 break;
1454
1455 case MBA_LOOP_UP: /* Loop Up Event */
1456 if (IS_QLA2100(ha) || IS_QLA2200(ha))
1457 ha->link_data_rate = PORT_SPEED_1GB;
1458 else
1459 ha->link_data_rate = mb[1];
1460
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));
1464
1465 if (IS_QLA83XX(ha) || IS_QLA27XX(ha) || IS_QLA28XX(ha)) {
1466 if (mb[2] & BIT_0)
1467 ql_log(ql_log_info, vha, 0x11a0,
1468 "FEC=enabled (link up).\n");
1469 }
1470
1471 vha->flags.management_server_logged_in = 0;
1472 qla2x00_post_aen_work(vha, FCH_EVT_LINKUP, ha->link_data_rate);
1473
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;
1477 }
1478
1479 break;
1480
1481 case MBA_LOOP_DOWN: /* Loop Down Event */
1482 SAVE_TOPO(ha);
1483 ha->flags.lip_ae = 0;
1484 ha->current_topology = 0;
1485 vha->link_down_time = 0;
1486
1487 mbx = (IS_QLA81XX(ha) || IS_QLA8031(ha))
1488 ? rd_reg_word(&reg24->mailbox4) : 0;
1489 mbx = (IS_P3P_TYPE(ha)) ? rd_reg_word(&reg82->mailbox_out[4])
1490 : mbx;
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);
1494
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);
1498 /*
1499 * In case of loop down, restore WWPN from
1500 * NVRAM in case of FA-WWPN capable ISP
1501 * Restore for Physical Port only
1502 */
1503 if (!vha->vp_idx) {
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));
1513 }
1514
1515 clear_bit(VP_CONFIG_OK, &vha->vp_flags);
1516 }
1517
1518 vha->device_flags |= DFLG_NO_CABLE;
1519 qla2x00_mark_all_devices_lost(vha);
1520 }
1521
1522 if (vha->vp_idx) {
1523 atomic_set(&vha->vp_state, VP_FAILED);
1524 fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
1525 }
1526
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);
1530 break;
1531
1532 case MBA_LIP_RESET: /* LIP reset occurred */
1533 ql_dbg(ql_dbg_async, vha, 0x500c,
1534 "LIP reset occurred (%x).\n", mb[1]);
1535
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);
1540 }
1541
1542 if (vha->vp_idx) {
1543 atomic_set(&vha->vp_state, VP_FAILED);
1544 fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
1545 }
1546
1547 set_bit(RESET_MARKER_NEEDED, &vha->dpc_flags);
1548
1549 ha->operating_mode = LOOP;
1550 vha->flags.management_server_logged_in = 0;
1551 qla2x00_post_aen_work(vha, FCH_EVT_LIPRESET, mb[1]);
1552 break;
1553
1554 /* case MBA_DCBX_COMPLETE: */
1555 case MBA_POINT_TO_POINT: /* Point-to-Point */
1556 ha->flags.lip_ae = 0;
1557
1558 if (IS_QLA2100(ha))
1559 break;
1560
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);
1567
1568 } else
1569 ql_dbg(ql_dbg_async, vha, 0x500e,
1570 "Asynchronous P2P MODE received.\n");
1571
1572 /*
1573 * Until there's a transition from loop down to loop up, treat
1574 * this as loop down only.
1575 */
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,
1580 LOOP_DOWN_TIME);
1581 if (!N2N_TOPO(ha))
1582 qla2x00_mark_all_devices_lost(vha);
1583 }
1584
1585 if (vha->vp_idx) {
1586 atomic_set(&vha->vp_state, VP_FAILED);
1587 fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
1588 }
1589
1590 if (!(test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags)))
1591 set_bit(RESET_MARKER_NEEDED, &vha->dpc_flags);
1592
1593 set_bit(REGISTER_FC4_NEEDED, &vha->dpc_flags);
1594 set_bit(REGISTER_FDMI_NEEDED, &vha->dpc_flags);
1595
1596 vha->flags.management_server_logged_in = 0;
1597 break;
1598
1599 case MBA_CHG_IN_CONNECTION: /* Change in connection mode */
1600 if (IS_QLA2100(ha))
1601 break;
1602
1603 ql_dbg(ql_dbg_async, vha, 0x500f,
1604 "Configuration change detected: value=%x.\n", mb[1]);
1605
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,
1610 LOOP_DOWN_TIME);
1611 qla2x00_mark_all_devices_lost(vha);
1612 }
1613
1614 if (vha->vp_idx) {
1615 atomic_set(&vha->vp_state, VP_FAILED);
1616 fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
1617 }
1618
1619 set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
1620 set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
1621 break;
1622
1623 case MBA_PORT_UPDATE: /* Port database update */
1624 /*
1625 * Handle only global and vn-port update events
1626 *
1627 * Relevant inputs:
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
1633 *
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
1638 */
1639 if (IS_QLA2XXX_MIDTYPE(ha) &&
1640 ((mb[1] == 0xffff && (mb[3] & 0xff) != 0xff) ||
1641 (mb[1] != 0xffff)) && vha->vp_idx != (mb[3] & 0xff))
1642 break;
1643
1644 if (mb[2] == 0x7) {
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]);
1649
1650 if (mb[1] == 0xffff)
1651 goto global_port_update;
1652
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);
1656 break;
1657 }
1658
1659 /* use handle_cnt for loop id/nport handle */
1660 if (IS_FWI2_CAPABLE(ha))
1661 handle_cnt = NPH_SNS;
1662 else
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);
1667 break;
1668 }
1669
1670 /* Port logout */
1671 fcport = qla2x00_find_fcport_by_loopid(vha, mb[1]);
1672 if (!fcport)
1673 break;
1674 if (atomic_read(&fcport->state) != FCS_ONLINE)
1675 break;
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);
1682 }
1683 break;
1684
1685 global_port_update:
1686 if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
1687 atomic_set(&vha->loop_state, LOOP_DOWN);
1688 atomic_set(&vha->loop_down_timer,
1689 LOOP_DOWN_TIME);
1690 vha->device_flags |= DFLG_NO_CABLE;
1691 qla2x00_mark_all_devices_lost(vha);
1692 }
1693
1694 if (vha->vp_idx) {
1695 atomic_set(&vha->vp_state, VP_FAILED);
1696 fc_vport_set_state(vha->fc_vport,
1697 FC_VPORT_FAILED);
1698 qla2x00_mark_all_devices_lost(vha);
1699 }
1700
1701 vha->flags.management_server_logged_in = 0;
1702 ha->link_data_rate = PORT_SPEED_UNKNOWN;
1703 break;
1704 }
1705
1706 /*
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.
1710 */
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]);
1718 break;
1719 }
1720
1721 ql_dbg(ql_dbg_async, vha, 0x5012,
1722 "Port database changed %04x %04x %04x.\n",
1723 mb[1], mb[2], mb[3]);
1724
1725 /*
1726 * Mark all devices as missing so we will login again.
1727 */
1728 atomic_set(&vha->loop_state, LOOP_UP);
1729 vha->scan.scan_retry = 0;
1730
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);
1734 break;
1735
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))
1739 break;
1740 /* Only handle SCNs for our Vport index. */
1741 if (ha->flags.npiv_supported && vha->vp_idx != (mb[3] & 0xff))
1742 break;
1743
1744 ql_log(ql_log_warn, vha, 0x5013,
1745 "RSCN database changed -- %04x %04x %04x.\n",
1746 mb[1], mb[2], mb[3]);
1747
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);
1755 break;
1756 }
1757
1758 /* Ignore reserved bits from RSCN-payload. */
1759 rscn_entry = ((mb[1] & 0x3ff) << 16) | mb[2];
1760
1761 /* Skip RSCNs for virtual ports on the same physical port */
1762 if (qla2x00_is_a_vp_did(vha, rscn_entry))
1763 break;
1764
1765 atomic_set(&vha->loop_down_timer, 0);
1766 vha->flags.management_server_logged_in = 0;
1767 {
1768 struct event_arg ea;
1769
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);
1775 }
1776 break;
1777 case MBA_CONGN_NOTI_RECV:
1778 if (!ha->flags.scm_enabled ||
1779 mb[1] != QLA_CON_PRIMITIVE_RECEIVED)
1780 break;
1781
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]);
1788 }
1789 break;
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");
1794
1795 if (IS_FWI2_CAPABLE(ha))
1796 qla24xx_process_response_queue(vha, rsp);
1797 else
1798 qla2x00_process_response_queue(rsp);
1799 break;
1800
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++;
1806 break;
1807
1808 case MBA_TRACE_NOTIFICATION:
1809 ql_dbg(ql_dbg_async, vha, 0x5017,
1810 "Trace Notification -- %04x %04x.\n", mb[1], mb[2]);
1811 break;
1812
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]);
1817
1818 spin_lock_irqsave(&ha->cs84xx->access_lock, flags);
1819 switch (mb[1]) {
1820 case A84_PANIC_RECOVERY:
1821 ql_log(ql_log_info, vha, 0x5019,
1822 "Alert 84XX: panic recovery %04x %04x.\n",
1823 mb[2], mb[3]);
1824 break;
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);
1830 break;
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);
1836 break;
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);
1843 break;
1844 default:
1845 ql_log(ql_log_warn, vha, 0x501d,
1846 "Alert 84xx: Invalid Alert %04x %04x %04x.\n",
1847 mb[1], mb[2], mb[3]);
1848 }
1849 spin_unlock_irqrestore(&ha->cs84xx->access_lock, flags);
1850 break;
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]);
1855 break;
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]);
1860 break;
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]);
1865 break;
1866 case MBA_IDC_NOTIFY:
1867 if (IS_QLA8031(vha->hw) || IS_QLA8044(ha)) {
1868 mb[4] = rd_reg_word(&reg24->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);
1873 /*
1874 * Extend loop down timer since port is active.
1875 */
1876 if (atomic_read(&vha->loop_state) == LOOP_DOWN)
1877 atomic_set(&vha->loop_down_timer,
1878 LOOP_DOWN_TIME);
1879 qla2xxx_wake_dpc(vha);
1880 }
1881 }
1882 fallthrough;
1883 case MBA_IDC_COMPLETE:
1884 if (ha->notify_lb_portup_comp && !vha->vp_idx)
1885 complete(&ha->lb_portup_comp);
1886 fallthrough;
1887 case MBA_IDC_TIME_EXT:
1888 if (IS_QLA81XX(vha->hw) || IS_QLA8031(vha->hw) ||
1889 IS_QLA8044(ha))
1890 qla81xx_idc_event(vha, mb[0], mb[1]);
1891 break;
1892
1893 case MBA_IDC_AEN:
1894 if (IS_QLA27XX(ha) || IS_QLA28XX(ha)) {
1895 vha->hw_err_cnt++;
1896 qla27xx_handle_8200_aen(vha, mb);
1897 } else if (IS_QLA83XX(ha)) {
1898 mb[4] = rd_reg_word(&reg24->mailbox4);
1899 mb[5] = rd_reg_word(&reg24->mailbox5);
1900 mb[6] = rd_reg_word(&reg24->mailbox6);
1901 mb[7] = rd_reg_word(&reg24->mailbox7);
1902 qla83xx_handle_8200_aen(vha, mb);
1903 } else {
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]);
1907 }
1908 break;
1909
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);
1929 if (result == 2) {
1930 static char *reasons[] = {
1931 "reserved", "unexpected reject",
1932 "unexpected phase", "retry exceeded",
1933 "timed out", "not supported",
1934 "user stopped" };
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",
1940 phase >> 1);
1941 }
1942 }
1943 break;
1944
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]);
1950 break;
1951
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);
1956 break;
1957
1958 case MBA_TRANS_REMOVE:
1959 ql_dbg(ql_dbg_async, vha, 0x5091, "Transceiver Removal\n");
1960 break;
1961
1962 default:
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]);
1966 }
1967
1968 qlt_async_event(mb[0], vha, mb);
1969
1970 if (!vha->vp_idx && ha->num_vhosts)
1971 qla2x00_alert_all_vps(rsp, mb);
1972 }
1973
1974 /**
1975 * qla2x00_process_completed_request() - Process a Fast Post response.
1976 * @vha: SCSI driver HA context
1977 * @req: request queue
1978 * @index: SRB index
1979 */
1980 void
1981 qla2x00_process_completed_request(struct scsi_qla_host *vha,
1982 struct req_que *req, uint32_t index)
1983 {
1984 srb_t *sp;
1985 struct qla_hw_data *ha = vha->hw;
1986
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);
1991
1992 if (IS_P3P_TYPE(ha))
1993 set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
1994 else
1995 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
1996 return;
1997 }
1998
1999 sp = req->outstanding_cmds[index];
2000 if (sp) {
2001 /* Free outstanding command slot. */
2002 req->outstanding_cmds[index] = NULL;
2003
2004 /* Save ISP completion status */
2005 sp->done(sp, DID_OK << 16);
2006 } else {
2007 ql_log(ql_log_warn, vha, 0x3016, "Invalid SCSI SRB.\n");
2008
2009 if (IS_P3P_TYPE(ha))
2010 set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
2011 else
2012 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
2013 }
2014 }
2015
2016 static srb_t *
2017 qla_get_sp_from_handle(scsi_qla_host_t *vha, const char *func,
2018 struct req_que *req, void *iocb, u16 *ret_index)
2019 {
2020 struct qla_hw_data *ha = vha->hw;
2021 sts_entry_t *pkt = iocb;
2022 srb_t *sp;
2023 uint16_t index;
2024
2025 if (pkt->handle == QLA_SKIP_HANDLE)
2026 return NULL;
2027
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",
2032 func, index, iocb);
2033 if (IS_P3P_TYPE(ha))
2034 set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
2035 else
2036 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
2037 return NULL;
2038 }
2039 sp = req->outstanding_cmds[index];
2040 if (!sp) {
2041 ql_log(ql_log_warn, vha, 0x5032,
2042 "%s: Invalid completion handle (%x) -- timed-out.\n",
2043 func, index);
2044 return NULL;
2045 }
2046 if (sp->handle != index) {
2047 ql_log(ql_log_warn, vha, 0x5033,
2048 "%s: SRB handle (%x) mismatch %x.\n", func,
2049 sp->handle, index);
2050 return NULL;
2051 }
2052
2053 *ret_index = index;
2054 qla_put_fw_resources(sp->qpair, &sp->iores);
2055 return sp;
2056 }
2057
2058 srb_t *
2059 qla2x00_get_sp_from_handle(scsi_qla_host_t *vha, const char *func,
2060 struct req_que *req, void *iocb)
2061 {
2062 uint16_t index;
2063 srb_t *sp;
2064
2065 sp = qla_get_sp_from_handle(vha, func, req, iocb, &index);
2066 if (sp)
2067 req->outstanding_cmds[index] = NULL;
2068
2069 return sp;
2070 }
2071
2072 static void
2073 qla2x00_mbx_iocb_entry(scsi_qla_host_t *vha, struct req_que *req,
2074 struct mbx_entry *mbx)
2075 {
2076 const char func[] = "MBX-IOCB";
2077 const char *type;
2078 fc_port_t *fcport;
2079 srb_t *sp;
2080 struct srb_iocb *lio;
2081 uint16_t *data;
2082 uint16_t status;
2083
2084 sp = qla2x00_get_sp_from_handle(vha, func, req, mbx);
2085 if (!sp)
2086 return;
2087
2088 lio = &sp->u.iocb_cmd;
2089 type = sp->name;
2090 fcport = sp->fcport;
2091 data = lio->u.logio.data;
2092
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));
2105
2106 ql_dump_buffer(ql_dbg_async + ql_dbg_buffer, vha, 0x5029,
2107 mbx, sizeof(*mbx));
2108
2109 goto logio_done;
2110 }
2111
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)
2115 status = 0;
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));
2122
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;
2130 }
2131 goto logio_done;
2132 }
2133
2134 data[0] = le16_to_cpu(mbx->mb0);
2135 switch (data[0]) {
2136 case MBS_PORT_ID_USED:
2137 data[1] = le16_to_cpu(mbx->mb1);
2138 break;
2139 case MBS_LOOP_ID_USED:
2140 break;
2141 default:
2142 data[0] = MBS_COMMAND_ERROR;
2143 break;
2144 }
2145
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));
2153
2154 logio_done:
2155 sp->done(sp, 0);
2156 }
2157
2158 static void
2159 qla24xx_mbx_iocb_entry(scsi_qla_host_t *vha, struct req_que *req,
2160 struct mbx_24xx_entry *pkt)
2161 {
2162 const char func[] = "MBX-IOCB2";
2163 struct qla_hw_data *ha = vha->hw;
2164 srb_t *sp;
2165 struct srb_iocb *si;
2166 u16 sz, i;
2167 int res;
2168
2169 sp = qla2x00_get_sp_from_handle(vha, func, req, pkt);
2170 if (!sp)
2171 return;
2172
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);
2180 else
2181 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
2182 return;
2183 }
2184
2185 si = &sp->u.iocb_cmd;
2186 sz = min(ARRAY_SIZE(pkt->mb), ARRAY_SIZE(sp->u.iocb_cmd.u.mbx.in_mb));
2187
2188 for (i = 0; i < sz; i++)
2189 si->u.mbx.in_mb[i] = pkt->mb[i];
2190
2191 res = (si->u.mbx.in_mb[0] & MBS_MASK);
2192
2193 sp->done(sp, res);
2194 }
2195
2196 static void
2197 qla24xxx_nack_iocb_entry(scsi_qla_host_t *vha, struct req_que *req,
2198 struct nack_to_isp *pkt)
2199 {
2200 const char func[] = "nack";
2201 srb_t *sp;
2202 int res = 0;
2203
2204 sp = qla2x00_get_sp_from_handle(vha, func, req, pkt);
2205 if (!sp)
2206 return;
2207
2208 if (pkt->u.isp2x.status != cpu_to_le16(NOTIFY_ACK_SUCCESS))
2209 res = QLA_FUNCTION_FAILED;
2210
2211 sp->done(sp, res);
2212 }
2213
2214 static void
2215 qla2x00_ct_entry(scsi_qla_host_t *vha, struct req_que *req,
2216 sts_entry_t *pkt, int iocb_type)
2217 {
2218 const char func[] = "CT_IOCB";
2219 const char *type;
2220 srb_t *sp;
2221 struct bsg_job *bsg_job;
2222 struct fc_bsg_reply *bsg_reply;
2223 uint16_t comp_status;
2224 int res = 0;
2225
2226 sp = qla2x00_get_sp_from_handle(vha, func, req, pkt);
2227 if (!sp)
2228 return;
2229
2230 switch (sp->type) {
2231 case SRB_CT_CMD:
2232 bsg_job = sp->u.bsg_job;
2233 bsg_reply = bsg_job->reply;
2234
2235 type = "ct pass-through";
2236
2237 comp_status = le16_to_cpu(pkt->comp_status);
2238
2239 /*
2240 * return FC_CTELS_STATUS_OK and leave the decoding of the ELS/CT
2241 * fc payload to the caller
2242 */
2243 bsg_reply->reply_data.ctels_reply.status = FC_CTELS_STATUS_OK;
2244 bsg_job->reply_len = sizeof(struct fc_bsg_reply);
2245
2246 if (comp_status != CS_COMPLETE) {
2247 if (comp_status == CS_DATA_UNDERRUN) {
2248 res = DID_OK << 16;
2249 bsg_reply->reply_payload_rcv_len =
2250 le16_to_cpu(pkt->rsp_info_len);
2251
2252 ql_log(ql_log_warn, vha, 0x5048,
2253 "CT pass-through-%s error comp_status=0x%x total_byte=0x%x.\n",
2254 type, comp_status,
2255 bsg_reply->reply_payload_rcv_len);
2256 } else {
2257 ql_log(ql_log_warn, vha, 0x5049,
2258 "CT pass-through-%s error comp_status=0x%x.\n",
2259 type, comp_status);
2260 res = DID_ERROR << 16;
2261 bsg_reply->reply_payload_rcv_len = 0;
2262 }
2263 ql_dump_buffer(ql_dbg_async + ql_dbg_buffer, vha, 0x5035,
2264 pkt, sizeof(*pkt));
2265 } else {
2266 res = DID_OK << 16;
2267 bsg_reply->reply_payload_rcv_len =
2268 bsg_job->reply_payload.payload_len;
2269 bsg_job->reply_len = 0;
2270 }
2271 break;
2272 case SRB_CT_PTHRU_CMD:
2273 /*
2274 * borrowing sts_entry_24xx.comp_status.
2275 * same location as ct_entry_24xx.comp_status
2276 */
2277 res = qla2x00_chk_ms_status(vha, (ms_iocb_entry_t *)pkt,
2278 (struct ct_sns_rsp *)sp->u.iocb_cmd.u.ctarg.rsp,
2279 sp->name);
2280 break;
2281 }
2282
2283 sp->done(sp, res);
2284 }
2285
2286 static void
2287 qla24xx_els_ct_entry(scsi_qla_host_t *v, struct req_que *req,
2288 struct sts_entry_24xx *pkt, int iocb_type)
2289 {
2290 struct els_sts_entry_24xx *ese = (struct els_sts_entry_24xx *)pkt;
2291 const char func[] = "ELS_CT_IOCB";
2292 const char *type;
2293 srb_t *sp;
2294 struct bsg_job *bsg_job;
2295 struct fc_bsg_reply *bsg_reply;
2296 uint16_t comp_status;
2297 uint32_t fw_status[3];
2298 int res, logit = 1;
2299 struct srb_iocb *els;
2300 uint n;
2301 scsi_qla_host_t *vha;
2302 struct els_sts_entry_24xx *e = (struct els_sts_entry_24xx *)pkt;
2303
2304 sp = qla2x00_get_sp_from_handle(v, func, req, pkt);
2305 if (!sp)
2306 return;
2307 bsg_job = sp->u.bsg_job;
2308 vha = sp->vha;
2309
2310 type = NULL;
2311
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);
2315
2316 switch (sp->type) {
2317 case SRB_ELS_CMD_RPT:
2318 case SRB_ELS_CMD_HST:
2319 type = "rpt hst";
2320 break;
2321 case SRB_ELS_CMD_HST_NOLOGIN:
2322 type = "els";
2323 {
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;
2327
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);
2333
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,
2338 sp->remap.rsp.buf,
2339 sp->remap.rsp.len);
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);
2343 } else {
2344 ql_dbg(ql_dbg_user, vha, 0x700f,
2345 "%s: NOT REMAPPED (error)...!!!\n",
2346 __func__);
2347 }
2348 }
2349 }
2350 break;
2351 case SRB_CT_CMD:
2352 type = "ct pass-through";
2353 break;
2354 case SRB_ELS_DCMD:
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);
2360 sp->done(sp, 0);
2361 return;
2362 }
2363 break;
2364 case SRB_CT_PTHRU_CMD:
2365 /* borrowing sts_entry_24xx.comp_status.
2366 same location as ct_entry_24xx.comp_status
2367 */
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,
2370 sp->name);
2371 sp->done(sp, res);
2372 return;
2373 default:
2374 ql_dbg(ql_dbg_user, vha, 0x503e,
2375 "Unrecognized SRB: (%p) type=%d.\n", sp, sp->type);
2376 return;
2377 }
2378
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) {
2386 res = DID_OK << 16;
2387 } else {
2388 if (comp_status == CS_DATA_UNDERRUN) {
2389 res = DID_OK << 16;
2390 els->u.els_plogi.len = cpu_to_le16(le32_to_cpu(
2391 ese->total_byte_count));
2392
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]);
2399 logit = 0;
2400 }
2401
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__);
2406
2407 els->u.els_plogi.len = 0;
2408 res = DID_IMM_RETRY << 16;
2409 qlt_schedule_sess_for_deletion(sp->fcport);
2410 } else {
2411 els->u.els_plogi.len = 0;
2412 res = DID_ERROR << 16;
2413 }
2414
2415 if (sp->remap.remapped &&
2416 ((u8 *)sp->remap.rsp.buf)[0] == ELS_LS_RJT) {
2417 if (logit) {
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);
2421
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]);
2429 }
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);
2435 }
2436 } else if (logit) {
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]);
2447 }
2448 }
2449 goto els_ct_done;
2450 }
2451
2452 /* return FC_CTELS_STATUS_OK and leave the decoding of the ELS/CT
2453 * fc payload to the caller
2454 */
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);
2459
2460 if (comp_status != CS_COMPLETE) {
2461 if (comp_status == CS_DATA_UNDERRUN) {
2462 res = DID_OK << 16;
2463 bsg_reply->reply_payload_rcv_len =
2464 le32_to_cpu(ese->total_byte_count);
2465
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));
2471 } else {
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;
2480 }
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,
2484 pkt, sizeof(*pkt));
2485 }
2486 else {
2487 res = DID_OK << 16;
2488 bsg_reply->reply_payload_rcv_len = bsg_job->reply_payload.payload_len;
2489 bsg_job->reply_len = 0;
2490 }
2491 els_ct_done:
2492
2493 sp->done(sp, res);
2494 }
2495
2496 static void
2497 qla24xx_logio_entry(scsi_qla_host_t *vha, struct req_que *req,
2498 struct logio_entry_24xx *logio)
2499 {
2500 const char func[] = "LOGIO-IOCB";
2501 const char *type;
2502 fc_port_t *fcport;
2503 srb_t *sp;
2504 struct srb_iocb *lio;
2505 uint16_t *data;
2506 uint32_t iop[2];
2507 int logit = 1;
2508
2509 sp = qla2x00_get_sp_from_handle(vha, func, req, logio);
2510 if (!sp)
2511 return;
2512
2513 lio = &sp->u.iocb_cmd;
2514 type = sp->name;
2515 fcport = sp->fcport;
2516 data = lio->u.logio.data;
2517
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));
2530
2531 goto logio_done;
2532 }
2533
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]));
2539
2540 vha->hw->exch_starvation = 0;
2541 data[0] = MBS_COMMAND_COMPLETE;
2542
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]);
2548 goto logio_done;
2549 }
2550
2551 if (sp->type != SRB_LOGIN_CMD)
2552 goto logio_done;
2553
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;
2557
2558 iop[0] = le32_to_cpu(logio->io_parameter[0]);
2559 if (iop[0] & BIT_4) {
2560 fcport->port_type = FCT_TARGET;
2561 if (iop[0] & BIT_8)
2562 fcport->flags |= FCF_FCP2_DEVICE;
2563 } else if (iop[0] & BIT_5)
2564 fcport->port_type = FCT_INITIATOR;
2565
2566 if (iop[0] & BIT_7)
2567 fcport->flags |= FCF_CONF_COMP_SUPPORTED;
2568
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;
2573
2574 goto logio_done;
2575 }
2576
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];
2581 switch (iop[0]) {
2582 case LSC_SCODE_PORTID_USED:
2583 data[0] = MBS_PORT_ID_USED;
2584 data[1] = LSW(iop[1]);
2585 logit = 0;
2586 break;
2587 case LSC_SCODE_NPORT_USED:
2588 data[0] = MBS_LOOP_ID_USED;
2589 logit = 0;
2590 break;
2591 case LSC_SCODE_CMD_FAILED:
2592 if (iop[1] == 0x0606) {
2593 /*
2594 * PLOGI/PRLI Completed. We must have Recv PLOGI/PRLI,
2595 * Target side acked.
2596 */
2597 data[0] = MBS_COMMAND_COMPLETE;
2598 goto logio_done;
2599 }
2600 data[0] = MBS_COMMAND_ERROR;
2601 break;
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");
2607
2608 vha->hw->exch_starvation = 0;
2609
2610 if (IS_P3P_TYPE(vha->hw))
2611 set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
2612 else
2613 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
2614 qla2xxx_wake_dpc(vha);
2615 }
2616 fallthrough;
2617 default:
2618 data[0] = MBS_COMMAND_ERROR;
2619 break;
2620 }
2621
2622 if (logit)
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]));
2629 else
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]));
2636
2637 logio_done:
2638 sp->done(sp, 0);
2639 }
2640
2641 static void
2642 qla24xx_tm_iocb_entry(scsi_qla_host_t *vha, struct req_que *req, void *tsk)
2643 {
2644 const char func[] = "TMF-IOCB";
2645 const char *type;
2646 fc_port_t *fcport;
2647 srb_t *sp;
2648 struct srb_iocb *iocb;
2649 struct sts_entry_24xx *sts = (struct sts_entry_24xx *)tsk;
2650 u16 comp_status;
2651
2652 sp = qla2x00_get_sp_from_handle(vha, func, req, tsk);
2653 if (!sp)
2654 return;
2655
2656 comp_status = le16_to_cpu(sts->comp_status);
2657 iocb = &sp->u.iocb_cmd;
2658 type = sp->name;
2659 fcport = sp->fcport;
2660 iocb->u.tmf.data = QLA_SUCCESS;
2661
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;
2684 }
2685 }
2686
2687 switch (comp_status) {
2688 case CS_PORT_LOGGED_OUT:
2689 case CS_PORT_CONFIG_CHG:
2690 case CS_PORT_BUSY:
2691 case CS_INCOMPLETE:
2692 case CS_PORT_UNAVAILABLE:
2693 case CS_RESET:
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],
2700 comp_status);
2701
2702 qlt_schedule_sess_for_deletion(fcport);
2703 }
2704 break;
2705
2706 default:
2707 break;
2708 }
2709
2710 if (iocb->u.tmf.data != QLA_SUCCESS)
2711 ql_dump_buffer(ql_dbg_async + ql_dbg_buffer, sp->vha, 0x5055,
2712 sts, sizeof(*sts));
2713
2714 sp->done(sp, 0);
2715 }
2716
2717 static void qla24xx_nvme_iocb_entry(scsi_qla_host_t *vha, struct req_que *req,
2718 void *tsk, srb_t *sp)
2719 {
2720 fc_port_t *fcport;
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;
2727 int logit = 0;
2728
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;
2734
2735 if (unlikely(iocb->u.nvme.aen_op))
2736 atomic_dec(&sp->vha->hw->nvme_active_aen_cnt);
2737 else
2738 sp->qpair->cmd_completion_cnt++;
2739
2740 if (unlikely(comp_status != CS_COMPLETE))
2741 logit = 1;
2742
2743 fd->transferred_length = fd->payload_length -
2744 le32_to_cpu(sts->residual_len);
2745
2746 /*
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.
2753 */
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)) {
2761 /*
2762 * Non-zero value in first 12 bytes of NVMe_RSP IU, treat this
2763 * as an error.
2764 */
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");
2769 logit = 1;
2770 } else if (state_flags & SF_NVME_ERSP) {
2771 uint32_t *inbuf, *outbuf;
2772 uint16_t iter;
2773
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);
2785 }
2786 iocb->u.nvme.rsp_pyld_len =
2787 cpu_to_le16(sizeof(struct nvme_fc_ersp_iu));
2788 }
2789 iter = le16_to_cpu(iocb->u.nvme.rsp_pyld_len) >> 2;
2790 for (; iter; iter--)
2791 *outbuf++ = swab32(*inbuf++);
2792 }
2793
2794 if (state_flags & SF_NVME_ERSP) {
2795 struct nvme_fc_ersp_iu *rsp_iu = fd->rspaddr;
2796 u32 tgt_xfer_len;
2797
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);
2803 logit = 1;
2804 } else if (le16_to_cpu(comp_status) == CS_DATA_UNDERRUN) {
2805 /*
2806 * Do not log if this is just an underflow and there
2807 * is no data loss.
2808 */
2809 logit = 0;
2810 }
2811 }
2812
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),
2818 sts->ox_id);
2819
2820 /*
2821 * If transport error then Failure (HBA rejects request)
2822 * otherwise transport will handle.
2823 */
2824 switch (le16_to_cpu(comp_status)) {
2825 case CS_COMPLETE:
2826 break;
2827
2828 case CS_RESET:
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],
2837 comp_status);
2838
2839 qlt_schedule_sess_for_deletion(fcport);
2840 }
2841 fallthrough;
2842 case CS_ABORTED:
2843 case CS_PORT_BUSY:
2844 fd->transferred_length = 0;
2845 iocb->u.nvme.rsp_pyld_len = 0;
2846 ret = QLA_ABORTED;
2847 break;
2848 case CS_DATA_UNDERRUN:
2849 break;
2850 default:
2851 ret = QLA_FUNCTION_FAILED;
2852 break;
2853 }
2854 sp->done(sp, ret);
2855 }
2856
2857 static void qla_ctrlvp_completed(scsi_qla_host_t *vha, struct req_que *req,
2858 struct vp_ctrl_entry_24xx *vce)
2859 {
2860 const char func[] = "CTRLVP-IOCB";
2861 srb_t *sp;
2862 int rval = QLA_SUCCESS;
2863
2864 sp = qla2x00_get_sp_from_handle(vha, func, req, vce);
2865 if (!sp)
2866 return;
2867
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;
2879 } else {
2880 ql_dbg(ql_dbg_vport, vha, 0x10c6,
2881 "Done %s.\n", __func__);
2882 }
2883
2884 sp->rc = rval;
2885 sp->done(sp, rval);
2886 }
2887
2888 /* Process a single response queue entry. */
2889 static void qla2x00_process_response_entry(struct scsi_qla_host *vha,
2890 struct rsp_que *rsp,
2891 sts_entry_t *pkt)
2892 {
2893 sts21_entry_t *sts21_entry;
2894 sts22_entry_t *sts22_entry;
2895 uint16_t handle_cnt;
2896 uint16_t cnt;
2897
2898 switch (pkt->entry_type) {
2899 case STATUS_TYPE:
2900 qla2x00_status_entry(vha, rsp, pkt);
2901 break;
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]);
2908 break;
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]);
2915 break;
2916 case STATUS_CONT_TYPE:
2917 qla2x00_status_cont_entry(rsp, (sts_cont_entry_t *)pkt);
2918 break;
2919 case MBX_IOCB_TYPE:
2920 qla2x00_mbx_iocb_entry(vha, rsp->req, (struct mbx_entry *)pkt);
2921 break;
2922 case CT_IOCB_TYPE:
2923 qla2x00_ct_entry(vha, rsp->req, pkt, CT_IOCB_TYPE);
2924 break;
2925 default:
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);
2930 break;
2931 }
2932 }
2933
2934 /**
2935 * qla2x00_process_response_queue() - Process response queue entries.
2936 * @rsp: response queue
2937 */
2938 void
2939 qla2x00_process_response_queue(struct rsp_que *rsp)
2940 {
2941 struct scsi_qla_host *vha;
2942 struct qla_hw_data *ha = rsp->hw;
2943 struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
2944 sts_entry_t *pkt;
2945
2946 vha = pci_get_drvdata(ha->pdev);
2947
2948 if (!vha->flags.online)
2949 return;
2950
2951 while (rsp->ring_ptr->signature != RESPONSE_PROCESSED) {
2952 pkt = (sts_entry_t *)rsp->ring_ptr;
2953
2954 rsp->ring_index++;
2955 if (rsp->ring_index == rsp->length) {
2956 rsp->ring_index = 0;
2957 rsp->ring_ptr = rsp->ring;
2958 } else {
2959 rsp->ring_ptr++;
2960 }
2961
2962 if (pkt->entry_status != 0) {
2963 qla2x00_error_entry(vha, rsp, pkt);
2964 ((response_t *)pkt)->signature = RESPONSE_PROCESSED;
2965 wmb();
2966 continue;
2967 }
2968
2969 qla2x00_process_response_entry(vha, rsp, pkt);
2970 ((response_t *)pkt)->signature = RESPONSE_PROCESSED;
2971 wmb();
2972 }
2973
2974 /* Adjust ring index */
2975 wrt_reg_word(ISP_RSP_Q_OUT(ha, reg), rsp->ring_index);
2976 }
2977
2978 static inline void
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)
2981 {
2982 struct scsi_qla_host *vha = sp->vha;
2983 struct scsi_cmnd *cp = GET_CMD_SP(sp);
2984 uint32_t track_sense_len;
2985
2986 if (sense_len >= SCSI_SENSE_BUFFERSIZE)
2987 sense_len = SCSI_SENSE_BUFFERSIZE;
2988
2989 SET_CMD_SENSE_LEN(sp, sense_len);
2990 SET_CMD_SENSE_PTR(sp, cp->sense_buffer);
2991 track_sense_len = sense_len;
2992
2993 if (sense_len > par_sense_len)
2994 sense_len = par_sense_len;
2995
2996 memcpy(cp->sense_buffer, sense_data, sense_len);
2997
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);
3001
3002 if (track_sense_len != 0) {
3003 rsp->status_srb = sp;
3004 cp->result = res;
3005 }
3006
3007 if (sense_len) {
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,
3011 cp);
3012 ql_dump_buffer(ql_dbg_io + ql_dbg_buffer, vha, 0x302b,
3013 cp->sense_buffer, sense_len);
3014 }
3015 }
3016
3017 /*
3018 * Checks the guard or meta-data for the type of error
3019 * detected by the HBA. In case of errors, we set the
3020 * ASC/ASCQ fields in the sense buffer with ILLEGAL_REQUEST
3021 * to indicate to the kernel that the HBA detected error.
3022 */
3023 static inline int
3024 qla2x00_handle_dif_error(srb_t *sp, struct sts_entry_24xx *sts24)
3025 {
3026 struct scsi_qla_host *vha = sp->vha;
3027 struct scsi_cmnd *cmd = GET_CMD_SP(sp);
3028 uint8_t *ap = &sts24->data[12];
3029 uint8_t *ep = &sts24->data[20];
3030 uint32_t e_ref_tag, a_ref_tag;
3031 uint16_t e_app_tag, a_app_tag;
3032 uint16_t e_guard, a_guard;
3033
3034 /*
3035 * swab32 of the "data" field in the beginning of qla2x00_status_entry()
3036 * would make guard field appear at offset 2
3037 */
3038 a_guard = get_unaligned_le16(ap + 2);
3039 a_app_tag = get_unaligned_le16(ap + 0);
3040 a_ref_tag = get_unaligned_le32(ap + 4);
3041 e_guard = get_unaligned_le16(ep + 2);
3042 e_app_tag = get_unaligned_le16(ep + 0);
3043 e_ref_tag = get_unaligned_le32(ep + 4);
3044
3045 ql_dbg(ql_dbg_io, vha, 0x3023,
3046 "iocb(s) %p Returned STATUS.\n", sts24);
3047
3048 ql_dbg(ql_dbg_io, vha, 0x3024,
3049 "DIF ERROR in cmd 0x%x lba 0x%llx act ref"
3050 " tag=0x%x, exp ref_tag=0x%x, act app tag=0x%x, exp app"
3051 " tag=0x%x, act guard=0x%x, exp guard=0x%x.\n",
3052 cmd->cmnd[0], (u64)scsi_get_lba(cmd), a_ref_tag, e_ref_tag,
3053 a_app_tag, e_app_tag, a_guard, e_guard);
3054
3055 /*
3056 * Ignore sector if:
3057 * For type 3: ref & app tag is all 'f's
3058 * For type 0,1,2: app tag is all 'f's
3059 */
3060 if (a_app_tag == be16_to_cpu(T10_PI_APP_ESCAPE) &&
3061 (scsi_get_prot_type(cmd) != SCSI_PROT_DIF_TYPE3 ||
3062 a_ref_tag == be32_to_cpu(T10_PI_REF_ESCAPE))) {
3063 uint32_t blocks_done, resid;
3064 sector_t lba_s = scsi_get_lba(cmd);
3065
3066 /* 2TB boundary case covered automatically with this */
3067 blocks_done = e_ref_tag - (uint32_t)lba_s + 1;
3068
3069 resid = scsi_bufflen(cmd) - (blocks_done *
3070 cmd->device->sector_size);
3071
3072 scsi_set_resid(cmd, resid);
3073 cmd->result = DID_OK << 16;
3074
3075 /* Update protection tag */
3076 if (scsi_prot_sg_count(cmd)) {
3077 uint32_t i, j = 0, k = 0, num_ent;
3078 struct scatterlist *sg;
3079 struct t10_pi_tuple *spt;
3080
3081 /* Patch the corresponding protection tags */
3082 scsi_for_each_prot_sg(cmd, sg,
3083 scsi_prot_sg_count(cmd), i) {
3084 num_ent = sg_dma_len(sg) / 8;
3085 if (k + num_ent < blocks_done) {
3086 k += num_ent;
3087 continue;
3088 }
3089 j = blocks_done - k - 1;
3090 k = blocks_done;
3091 break;
3092 }
3093
3094 if (k != blocks_done) {
3095 ql_log(ql_log_warn, vha, 0x302f,
3096 "unexpected tag values tag:lba=%x:%llx)\n",
3097 e_ref_tag, (unsigned long long)lba_s);
3098 return 1;
3099 }
3100
3101 spt = page_address(sg_page(sg)) + sg->offset;
3102 spt += j;
3103
3104 spt->app_tag = T10_PI_APP_ESCAPE;
3105 if (scsi_get_prot_type(cmd) == SCSI_PROT_DIF_TYPE3)
3106 spt->ref_tag = T10_PI_REF_ESCAPE;
3107 }
3108
3109 return 0;
3110 }
3111
3112 /* check guard */
3113 if (e_guard != a_guard) {
3114 scsi_build_sense(cmd, 1, ILLEGAL_REQUEST, 0x10, 0x1);
3115 set_host_byte(cmd, DID_ABORT);
3116 return 1;
3117 }
3118
3119 /* check ref tag */
3120 if (e_ref_tag != a_ref_tag) {
3121 scsi_build_sense(cmd, 1, ILLEGAL_REQUEST, 0x10, 0x3);
3122 set_host_byte(cmd, DID_ABORT);
3123 return 1;
3124 }
3125
3126 /* check appl tag */
3127 if (e_app_tag != a_app_tag) {
3128 scsi_build_sense(cmd, 1, ILLEGAL_REQUEST, 0x10, 0x2);
3129 set_host_byte(cmd, DID_ABORT);
3130 return 1;
3131 }
3132
3133 return 1;
3134 }
3135
3136 static void
3137 qla25xx_process_bidir_status_iocb(scsi_qla_host_t *vha, void *pkt,
3138 struct req_que *req, uint32_t index)
3139 {
3140 struct qla_hw_data *ha = vha->hw;
3141 srb_t *sp;
3142 uint16_t comp_status;
3143 uint16_t scsi_status;
3144 uint16_t thread_id;
3145 uint32_t rval = EXT_STATUS_OK;
3146 struct bsg_job *bsg_job = NULL;
3147 struct fc_bsg_request *bsg_request;
3148 struct fc_bsg_reply *bsg_reply;
3149 sts_entry_t *sts = pkt;
3150 struct sts_entry_24xx *sts24 = pkt;
3151
3152 /* Validate handle. */
3153 if (index >= req->num_outstanding_cmds) {
3154 ql_log(ql_log_warn, vha, 0x70af,
3155 "Invalid SCSI completion handle 0x%x.\n", index);
3156 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
3157 return;
3158 }
3159
3160 sp = req->outstanding_cmds[index];
3161 if (!sp) {
3162 ql_log(ql_log_warn, vha, 0x70b0,
3163 "Req:%d: Invalid ISP SCSI completion handle(0x%x)\n",
3164 req->id, index);
3165
3166 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
3167 return;
3168 }
3169
3170 /* Free outstanding command slot. */
3171 req->outstanding_cmds[index] = NULL;
3172 bsg_job = sp->u.bsg_job;
3173 bsg_request = bsg_job->request;
3174 bsg_reply = bsg_job->reply;
3175
3176 if (IS_FWI2_CAPABLE(ha)) {
3177 comp_status = le16_to_cpu(sts24->comp_status);
3178 scsi_status = le16_to_cpu(sts24->scsi_status) & SS_MASK;
3179 } else {
3180 comp_status = le16_to_cpu(sts->comp_status);
3181 scsi_status = le16_to_cpu(sts->scsi_status) & SS_MASK;
3182 }
3183
3184 thread_id = bsg_request->rqst_data.h_vendor.vendor_cmd[1];
3185 switch (comp_status) {
3186 case CS_COMPLETE:
3187 if (scsi_status == 0) {
3188 bsg_reply->reply_payload_rcv_len =
3189 bsg_job->reply_payload.payload_len;
3190 vha->qla_stats.input_bytes +=
3191 bsg_reply->reply_payload_rcv_len;
3192 vha->qla_stats.input_requests++;
3193 rval = EXT_STATUS_OK;
3194 }
3195 goto done;
3196
3197 case CS_DATA_OVERRUN:
3198 ql_dbg(ql_dbg_user, vha, 0x70b1,
3199 "Command completed with data overrun thread_id=%d\n",
3200 thread_id);
3201 rval = EXT_STATUS_DATA_OVERRUN;
3202 break;
3203
3204 case CS_DATA_UNDERRUN:
3205 ql_dbg(ql_dbg_user, vha, 0x70b2,
3206 "Command completed with data underrun thread_id=%d\n",
3207 thread_id);
3208 rval = EXT_STATUS_DATA_UNDERRUN;
3209 break;
3210 case CS_BIDIR_RD_OVERRUN:
3211 ql_dbg(ql_dbg_user, vha, 0x70b3,
3212 "Command completed with read data overrun thread_id=%d\n",
3213 thread_id);
3214 rval = EXT_STATUS_DATA_OVERRUN;
3215 break;
3216
3217 case CS_BIDIR_RD_WR_OVERRUN:
3218 ql_dbg(ql_dbg_user, vha, 0x70b4,
3219 "Command completed with read and write data overrun "
3220 "thread_id=%d\n", thread_id);
3221 rval = EXT_STATUS_DATA_OVERRUN;
3222 break;
3223
3224 case CS_BIDIR_RD_OVERRUN_WR_UNDERRUN:
3225 ql_dbg(ql_dbg_user, vha, 0x70b5,
3226 "Command completed with read data over and write data "
3227 "underrun thread_id=%d\n", thread_id);
3228 rval = EXT_STATUS_DATA_OVERRUN;
3229 break;
3230
3231 case CS_BIDIR_RD_UNDERRUN:
3232 ql_dbg(ql_dbg_user, vha, 0x70b6,
3233 "Command completed with read data underrun "
3234 "thread_id=%d\n", thread_id);
3235 rval = EXT_STATUS_DATA_UNDERRUN;
3236 break;
3237
3238 case CS_BIDIR_RD_UNDERRUN_WR_OVERRUN:
3239 ql_dbg(ql_dbg_user, vha, 0x70b7,
3240 "Command completed with read data under and write data "
3241 "overrun thread_id=%d\n", thread_id);
3242 rval = EXT_STATUS_DATA_UNDERRUN;
3243 break;
3244
3245 case CS_BIDIR_RD_WR_UNDERRUN:
3246 ql_dbg(ql_dbg_user, vha, 0x70b8,
3247 "Command completed with read and write data underrun "
3248 "thread_id=%d\n", thread_id);
3249 rval = EXT_STATUS_DATA_UNDERRUN;
3250 break;
3251
3252 case CS_BIDIR_DMA:
3253 ql_dbg(ql_dbg_user, vha, 0x70b9,
3254 "Command completed with data DMA error thread_id=%d\n",
3255 thread_id);
3256 rval = EXT_STATUS_DMA_ERR;
3257 break;
3258
3259 case CS_TIMEOUT:
3260 ql_dbg(ql_dbg_user, vha, 0x70ba,
3261 "Command completed with timeout thread_id=%d\n",
3262 thread_id);
3263 rval = EXT_STATUS_TIMEOUT;
3264 break;
3265 default:
3266 ql_dbg(ql_dbg_user, vha, 0x70bb,
3267 "Command completed with completion status=0x%x "
3268 "thread_id=%d\n", comp_status, thread_id);
3269 rval = EXT_STATUS_ERR;
3270 break;
3271 }
3272 bsg_reply->reply_payload_rcv_len = 0;
3273
3274 done:
3275 /* Return the vendor specific reply to API */
3276 bsg_reply->reply_data.vendor_reply.vendor_rsp[0] = rval;
3277 bsg_job->reply_len = sizeof(struct fc_bsg_reply);
3278 /* Always return DID_OK, bsg will send the vendor specific response
3279 * in this case only */
3280 sp->done(sp, DID_OK << 16);
3281
3282 }
3283
3284 /**
3285 * qla2x00_status_entry() - Process a Status IOCB entry.
3286 * @vha: SCSI driver HA context
3287 * @rsp: response queue
3288 * @pkt: Entry pointer
3289 */
3290 static void
3291 qla2x00_status_entry(scsi_qla_host_t *vha, struct rsp_que *rsp, void *pkt)
3292 {
3293 srb_t *sp;
3294 fc_port_t *fcport;
3295 struct scsi_cmnd *cp;
3296 sts_entry_t *sts = pkt;
3297 struct sts_entry_24xx *sts24 = pkt;
3298 uint16_t comp_status;
3299 uint16_t scsi_status;
3300 uint16_t ox_id;
3301 uint8_t lscsi_status;
3302 int32_t resid;
3303 uint32_t sense_len, par_sense_len, rsp_info_len, resid_len,
3304 fw_resid_len;
3305 uint8_t *rsp_info, *sense_data;
3306 struct qla_hw_data *ha = vha->hw;
3307 uint32_t handle;
3308 uint16_t que;
3309 struct req_que *req;
3310 int logit = 1;
3311 int res = 0;
3312 uint16_t state_flags = 0;
3313 uint16_t sts_qual = 0;
3314
3315 if (IS_FWI2_CAPABLE(ha)) {
3316 comp_status = le16_to_cpu(sts24->comp_status);
3317 scsi_status = le16_to_cpu(sts24->scsi_status) & SS_MASK;
3318 state_flags = le16_to_cpu(sts24->state_flags);
3319 } else {
3320 comp_status = le16_to_cpu(sts->comp_status);
3321 scsi_status = le16_to_cpu(sts->scsi_status) & SS_MASK;
3322 }
3323 handle = (uint32_t) LSW(sts->handle);
3324 que = MSW(sts->handle);
3325 req = ha->req_q_map[que];
3326
3327 /* Check for invalid queue pointer */
3328 if (req == NULL ||
3329 que >= find_first_zero_bit(ha->req_qid_map, ha->max_req_queues)) {
3330 ql_dbg(ql_dbg_io, vha, 0x3059,
3331 "Invalid status handle (0x%x): Bad req pointer. req=%p, "
3332 "que=%u.\n", sts->handle, req, que);
3333 return;
3334 }
3335
3336 /* Validate handle. */
3337 if (handle < req->num_outstanding_cmds) {
3338 sp = req->outstanding_cmds[handle];
3339 if (!sp) {
3340 ql_dbg(ql_dbg_io, vha, 0x3075,
3341 "%s(%ld): Already returned command for status handle (0x%x).\n",
3342 __func__, vha->host_no, sts->handle);
3343 return;
3344 }
3345 } else {
3346 ql_dbg(ql_dbg_io, vha, 0x3017,
3347 "Invalid status handle, out of range (0x%x).\n",
3348 sts->handle);
3349
3350 if (!test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags)) {
3351 if (IS_P3P_TYPE(ha))
3352 set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
3353 else
3354 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
3355 qla2xxx_wake_dpc(vha);
3356 }
3357 return;
3358 }
3359 qla_put_fw_resources(sp->qpair, &sp->iores);
3360
3361 if (sp->cmd_type != TYPE_SRB) {
3362 req->outstanding_cmds[handle] = NULL;
3363 ql_dbg(ql_dbg_io, vha, 0x3015,
3364 "Unknown sp->cmd_type %x %p).\n",
3365 sp->cmd_type, sp);
3366 return;
3367 }
3368
3369 /* NVME completion. */
3370 if (sp->type == SRB_NVME_CMD) {
3371 req->outstanding_cmds[handle] = NULL;
3372 qla24xx_nvme_iocb_entry(vha, req, pkt, sp);
3373 return;
3374 }
3375
3376 if (unlikely((state_flags & BIT_1) && (sp->type == SRB_BIDI_CMD))) {
3377 qla25xx_process_bidir_status_iocb(vha, pkt, req, handle);
3378 return;
3379 }
3380
3381 /* Task Management completion. */
3382 if (sp->type == SRB_TM_CMD) {
3383 qla24xx_tm_iocb_entry(vha, req, pkt);
3384 return;
3385 }
3386
3387 /* Fast path completion. */
3388 qla_chk_edif_rx_sa_delete_pending(vha, sp, sts24);
3389 sp->qpair->cmd_completion_cnt++;
3390
3391 if (comp_status == CS_COMPLETE && scsi_status == 0) {
3392 qla2x00_process_completed_request(vha, req, handle);
3393
3394 return;
3395 }
3396
3397 cp = GET_CMD_SP(sp);
3398 if (cp == NULL) {
3399 ql_dbg(ql_dbg_io, vha, 0x3018,
3400 "Command already returned (0x%x/%p).\n",
3401 sts->handle, sp);
3402
3403 req->outstanding_cmds[handle] = NULL;
3404 return;
3405 }
3406
3407 lscsi_status = scsi_status & STATUS_MASK;
3408
3409 fcport = sp->fcport;
3410
3411 ox_id = 0;
3412 sense_len = par_sense_len = rsp_info_len = resid_len =
3413 fw_resid_len = 0;
3414 if (IS_FWI2_CAPABLE(ha)) {
3415 if (scsi_status & SS_SENSE_LEN_VALID)
3416 sense_len = le32_to_cpu(sts24->sense_len);
3417 if (scsi_status & SS_RESPONSE_INFO_LEN_VALID)
3418 rsp_info_len = le32_to_cpu(sts24->rsp_data_len);
3419 if (scsi_status & (SS_RESIDUAL_UNDER | SS_RESIDUAL_OVER))
3420 resid_len = le32_to_cpu(sts24->rsp_residual_count);
3421 if (comp_status == CS_DATA_UNDERRUN)
3422 fw_resid_len = le32_to_cpu(sts24->residual_len);
3423 rsp_info = sts24->data;
3424 sense_data = sts24->data;
3425 host_to_fcp_swap(sts24->data, sizeof(sts24->data));
3426 ox_id = le16_to_cpu(sts24->ox_id);
3427 par_sense_len = sizeof(sts24->data);
3428 sts_qual = le16_to_cpu(sts24->status_qualifier);
3429 } else {
3430 if (scsi_status & SS_SENSE_LEN_VALID)
3431 sense_len = le16_to_cpu(sts->req_sense_length);
3432 if (scsi_status & SS_RESPONSE_INFO_LEN_VALID)
3433 rsp_info_len = le16_to_cpu(sts->rsp_info_len);
3434 resid_len = le32_to_cpu(sts->residual_length);
3435 rsp_info = sts->rsp_info;
3436 sense_data = sts->req_sense_data;
3437 par_sense_len = sizeof(sts->req_sense_data);
3438 }
3439
3440 /* Check for any FCP transport errors. */
3441 if (scsi_status & SS_RESPONSE_INFO_LEN_VALID) {
3442 /* Sense data lies beyond any FCP RESPONSE data. */
3443 if (IS_FWI2_CAPABLE(ha)) {
3444 sense_data += rsp_info_len;
3445 par_sense_len -= rsp_info_len;
3446 }
3447 if (rsp_info_len > 3 && rsp_info[3]) {
3448 ql_dbg(ql_dbg_io, fcport->vha, 0x3019,
3449 "FCP I/O protocol failure (0x%x/0x%x).\n",
3450 rsp_info_len, rsp_info[3]);
3451
3452 res = DID_BUS_BUSY << 16;
3453 goto out;
3454 }
3455 }
3456
3457 /* Check for overrun. */
3458 if (IS_FWI2_CAPABLE(ha) && comp_status == CS_COMPLETE &&
3459 scsi_status & SS_RESIDUAL_OVER)
3460 comp_status = CS_DATA_OVERRUN;
3461
3462 /*
3463 * Check retry_delay_timer value if we receive a busy or
3464 * queue full.
3465 */
3466 if (unlikely(lscsi_status == SAM_STAT_TASK_SET_FULL ||
3467 lscsi_status == SAM_STAT_BUSY))
3468 qla2x00_set_retry_delay_timestamp(fcport, sts_qual);
3469
3470 /*
3471 * Based on Host and scsi status generate status code for Linux
3472 */
3473 switch (comp_status) {
3474 case CS_COMPLETE:
3475 case CS_QUEUE_FULL:
3476 if (scsi_status == 0) {
3477 res = DID_OK << 16;
3478 break;
3479 }
3480 if (scsi_status & (SS_RESIDUAL_UNDER | SS_RESIDUAL_OVER)) {
3481 resid = resid_len;
3482 scsi_set_resid(cp, resid);
3483
3484 if (!lscsi_status &&
3485 ((unsigned)(scsi_bufflen(cp) - resid) <
3486 cp->underflow)) {
3487 ql_dbg(ql_dbg_io, fcport->vha, 0x301a,
3488 "Mid-layer underflow detected (0x%x of 0x%x bytes).\n",
3489 resid, scsi_bufflen(cp));
3490
3491 res = DID_ERROR << 16;
3492 break;
3493 }
3494 }
3495 res = DID_OK << 16 | lscsi_status;
3496
3497 if (lscsi_status == SAM_STAT_TASK_SET_FULL) {
3498 ql_dbg(ql_dbg_io, fcport->vha, 0x301b,
3499 "QUEUE FULL detected.\n");
3500 break;
3501 }
3502 logit = 0;
3503 if (lscsi_status != SS_CHECK_CONDITION)
3504 break;
3505
3506 memset(cp->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
3507 if (!(scsi_status & SS_SENSE_LEN_VALID))
3508 break;
3509
3510 qla2x00_handle_sense(sp, sense_data, par_sense_len, sense_len,
3511 rsp, res);
3512 break;
3513
3514 case CS_DATA_UNDERRUN:
3515 /* Use F/W calculated residual length. */
3516 resid = IS_FWI2_CAPABLE(ha) ? fw_resid_len : resid_len;
3517 scsi_set_resid(cp, resid);
3518 if (scsi_status & SS_RESIDUAL_UNDER) {
3519 if (IS_FWI2_CAPABLE(ha) && fw_resid_len != resid_len) {
3520 ql_log(ql_log_warn, fcport->vha, 0x301d,
3521 "Dropped frame(s) detected (0x%x of 0x%x bytes).\n",
3522 resid, scsi_bufflen(cp));
3523
3524 res = DID_ERROR << 16 | lscsi_status;
3525 goto check_scsi_status;
3526 }
3527
3528 if (!lscsi_status &&
3529 ((unsigned)(scsi_bufflen(cp) - resid) <
3530 cp->underflow)) {
3531 ql_dbg(ql_dbg_io, fcport->vha, 0x301e,
3532 "Mid-layer underflow detected (0x%x of 0x%x bytes).\n",
3533 resid, scsi_bufflen(cp));
3534
3535 res = DID_ERROR << 16;
3536 break;
3537 }
3538 } else if (lscsi_status != SAM_STAT_TASK_SET_FULL &&
3539 lscsi_status != SAM_STAT_BUSY) {
3540 /*
3541 * scsi status of task set and busy are considered to be
3542 * task not completed.
3543 */
3544
3545 ql_log(ql_log_warn, fcport->vha, 0x301f,
3546 "Dropped frame(s) detected (0x%x of 0x%x bytes).\n",
3547 resid, scsi_bufflen(cp));
3548
3549 vha->interface_err_cnt++;
3550
3551 res = DID_ERROR << 16 | lscsi_status;
3552 goto check_scsi_status;
3553 } else {
3554 ql_dbg(ql_dbg_io, fcport->vha, 0x3030,
3555 "scsi_status: 0x%x, lscsi_status: 0x%x\n",
3556 scsi_status, lscsi_status);
3557 }
3558
3559 res = DID_OK << 16 | lscsi_status;
3560 logit = 0;
3561
3562 check_scsi_status:
3563 /*
3564 * Check to see if SCSI Status is non zero. If so report SCSI
3565 * Status.
3566 */
3567 if (lscsi_status != 0) {
3568 if (lscsi_status == SAM_STAT_TASK_SET_FULL) {
3569 ql_dbg(ql_dbg_io, fcport->vha, 0x3020,
3570 "QUEUE FULL detected.\n");
3571 logit = 1;
3572 break;
3573 }
3574 if (lscsi_status != SS_CHECK_CONDITION)
3575 break;
3576
3577 memset(cp->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
3578 if (!(scsi_status & SS_SENSE_LEN_VALID))
3579 break;
3580
3581 qla2x00_handle_sense(sp, sense_data, par_sense_len,
3582 sense_len, rsp, res);
3583 }
3584 break;
3585
3586 case CS_PORT_LOGGED_OUT:
3587 case CS_PORT_CONFIG_CHG:
3588 case CS_PORT_BUSY:
3589 case CS_INCOMPLETE:
3590 case CS_PORT_UNAVAILABLE:
3591 case CS_TIMEOUT:
3592 case CS_RESET:
3593 case CS_EDIF_INV_REQ:
3594
3595 /*
3596 * We are going to have the fc class block the rport
3597 * while we try to recover so instruct the mid layer
3598 * to requeue until the class decides how to handle this.
3599 */
3600 res = DID_TRANSPORT_DISRUPTED << 16;
3601
3602 if (comp_status == CS_TIMEOUT) {
3603 if (IS_FWI2_CAPABLE(ha))
3604 break;
3605 else if ((le16_to_cpu(sts->status_flags) &
3606 SF_LOGOUT_SENT) == 0)
3607 break;
3608 }
3609
3610 if (atomic_read(&fcport->state) == FCS_ONLINE) {
3611 ql_dbg(ql_dbg_disc, fcport->vha, 0x3021,
3612 "Port to be marked lost on fcport=%02x%02x%02x, current "
3613 "port state= %s comp_status %x.\n", fcport->d_id.b.domain,
3614 fcport->d_id.b.area, fcport->d_id.b.al_pa,
3615 port_state_str[FCS_ONLINE],
3616 comp_status);
3617
3618 qlt_schedule_sess_for_deletion(fcport);
3619 }
3620
3621 break;
3622
3623 case CS_ABORTED:
3624 res = DID_RESET << 16;
3625 break;
3626
3627 case CS_DIF_ERROR:
3628 logit = qla2x00_handle_dif_error(sp, sts24);
3629 res = cp->result;
3630 break;
3631
3632 case CS_TRANSPORT:
3633 res = DID_ERROR << 16;
3634 vha->hw_err_cnt++;
3635
3636 if (!IS_PI_SPLIT_DET_CAPABLE(ha))
3637 break;
3638
3639 if (state_flags & BIT_4)
3640 scmd_printk(KERN_WARNING, cp,
3641 "Unsupported device '%s' found.\n",
3642 cp->device->vendor);
3643 break;
3644
3645 case CS_DMA:
3646 ql_log(ql_log_info, fcport->vha, 0x3022,
3647 "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",
3648 comp_status, scsi_status, res, vha->host_no,
3649 cp->device->id, cp->device->lun, fcport->d_id.b24,
3650 ox_id, cp->cmnd, scsi_bufflen(cp), rsp_info_len,
3651 resid_len, fw_resid_len, sp, cp);
3652 ql_dump_buffer(ql_dbg_tgt + ql_dbg_verbose, vha, 0xe0ee,
3653 pkt, sizeof(*sts24));
3654 res = DID_ERROR << 16;
3655 vha->hw_err_cnt++;
3656 break;
3657 default:
3658 res = DID_ERROR << 16;
3659 break;
3660 }
3661
3662 out:
3663 if (logit)
3664 ql_dbg(ql_dbg_io, fcport->vha, 0x3022,
3665 "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",
3666 comp_status, scsi_status, res, vha->host_no,
3667 cp->device->id, cp->device->lun, fcport->d_id.b.domain,
3668 fcport->d_id.b.area, fcport->d_id.b.al_pa, ox_id,
3669 cp->cmnd, scsi_bufflen(cp), rsp_info_len,
3670 resid_len, fw_resid_len, sp, cp);
3671
3672 if (rsp->status_srb == NULL)
3673 sp->done(sp, res);
3674
3675 /* for io's, clearing of outstanding_cmds[handle] means scsi_done was called */
3676 req->outstanding_cmds[handle] = NULL;
3677 }
3678
3679 /**
3680 * qla2x00_status_cont_entry() - Process a Status Continuations entry.
3681 * @rsp: response queue
3682 * @pkt: Entry pointer
3683 *
3684 * Extended sense data.
3685 */
3686 static void
3687 qla2x00_status_cont_entry(struct rsp_que *rsp, sts_cont_entry_t *pkt)
3688 {
3689 uint8_t sense_sz = 0;
3690 struct qla_hw_data *ha = rsp->hw;
3691 struct scsi_qla_host *vha = pci_get_drvdata(ha->pdev);
3692 srb_t *sp = rsp->status_srb;
3693 struct scsi_cmnd *cp;
3694 uint32_t sense_len;
3695 uint8_t *sense_ptr;
3696
3697 if (!sp || !GET_CMD_SENSE_LEN(sp))
3698 return;
3699
3700 sense_len = GET_CMD_SENSE_LEN(sp);
3701 sense_ptr = GET_CMD_SENSE_PTR(sp);
3702
3703 cp = GET_CMD_SP(sp);
3704 if (cp == NULL) {
3705 ql_log(ql_log_warn, vha, 0x3025,
3706 "cmd is NULL: already returned to OS (sp=%p).\n", sp);
3707
3708 rsp->status_srb = NULL;
3709 return;
3710 }
3711
3712 if (sense_len > sizeof(pkt->data))
3713 sense_sz = sizeof(pkt->data);
3714 else
3715 sense_sz = sense_len;
3716
3717 /* Move sense data. */
3718 if (IS_FWI2_CAPABLE(ha))
3719 host_to_fcp_swap(pkt->data, sizeof(pkt->data));
3720 memcpy(sense_ptr, pkt->data, sense_sz);
3721 ql_dump_buffer(ql_dbg_io + ql_dbg_buffer, vha, 0x302c,
3722 sense_ptr, sense_sz);
3723
3724 sense_len -= sense_sz;
3725 sense_ptr += sense_sz;
3726
3727 SET_CMD_SENSE_PTR(sp, sense_ptr);
3728 SET_CMD_SENSE_LEN(sp, sense_len);
3729
3730 /* Place command on done queue. */
3731 if (sense_len == 0) {
3732 rsp->status_srb = NULL;
3733 sp->done(sp, cp->result);
3734 }
3735 }
3736
3737 /**
3738 * qla2x00_error_entry() - Process an error entry.
3739 * @vha: SCSI driver HA context
3740 * @rsp: response queue
3741 * @pkt: Entry pointer
3742 * return : 1=allow further error analysis. 0=no additional error analysis.
3743 */
3744 static int
3745 qla2x00_error_entry(scsi_qla_host_t *vha, struct rsp_que *rsp, sts_entry_t *pkt)
3746 {
3747 srb_t *sp;
3748 struct qla_hw_data *ha = vha->hw;
3749 const char func[] = "ERROR-IOCB";
3750 uint16_t que = MSW(pkt->handle);
3751 struct req_que *req = NULL;
3752 int res = DID_ERROR << 16;
3753 u16 index;
3754
3755 ql_dbg(ql_dbg_async, vha, 0x502a,
3756 "iocb type %xh with error status %xh, handle %xh, rspq id %d\n",
3757 pkt->entry_type, pkt->entry_status, pkt->handle, rsp->id);
3758
3759 if (que >= ha->max_req_queues || !ha->req_q_map[que])
3760 goto fatal;
3761
3762 req = ha->req_q_map[que];
3763
3764 if (pkt->entry_status & RF_BUSY)
3765 res = DID_BUS_BUSY << 16;
3766
3767 if ((pkt->handle & ~QLA_TGT_HANDLE_MASK) == QLA_TGT_SKIP_HANDLE)
3768 return 0;
3769
3770 switch (pkt->entry_type) {
3771 case NOTIFY_ACK_TYPE:
3772 case STATUS_CONT_TYPE:
3773 case LOGINOUT_PORT_IOCB_TYPE:
3774 case CT_IOCB_TYPE:
3775 case ELS_IOCB_TYPE:
3776 case ABORT_IOCB_TYPE:
3777 case MBX_IOCB_TYPE:
3778 default:
3779 sp = qla2x00_get_sp_from_handle(vha, func, req, pkt);
3780 if (sp) {
3781 sp->done(sp, res);
3782 return 0;
3783 }
3784 break;
3785
3786 case SA_UPDATE_IOCB_TYPE:
3787 case ABTS_RESP_24XX:
3788 case CTIO_TYPE7:
3789 case CTIO_CRC2:
3790 return 1;
3791 case STATUS_TYPE:
3792 sp = qla_get_sp_from_handle(vha, func, req, pkt, &index);
3793 if (sp) {
3794 sp->done(sp, res);
3795 req->outstanding_cmds[index] = NULL;
3796 return 0;
3797 }
3798 break;
3799 }
3800 fatal:
3801 ql_log(ql_log_warn, vha, 0x5030,
3802 "Error entry - invalid handle/queue (%04x).\n", que);
3803 return 0;
3804 }
3805
3806 /**
3807 * qla24xx_mbx_completion() - Process mailbox command completions.
3808 * @vha: SCSI driver HA context
3809 * @mb0: Mailbox0 register
3810 */
3811 static void
3812 qla24xx_mbx_completion(scsi_qla_host_t *vha, uint16_t mb0)
3813 {
3814 uint16_t cnt;
3815 uint32_t mboxes;
3816 __le16 __iomem *wptr;
3817 struct qla_hw_data *ha = vha->hw;
3818 struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
3819
3820 /* Read all mbox registers? */
3821 WARN_ON_ONCE(ha->mbx_count > 32);
3822 mboxes = (1ULL << ha->mbx_count) - 1;
3823 if (!ha->mcp)
3824 ql_dbg(ql_dbg_async, vha, 0x504e, "MBX pointer ERROR.\n");
3825 else
3826 mboxes = ha->mcp->in_mb;
3827
3828 /* Load return mailbox registers. */
3829 ha->flags.mbox_int = 1;
3830 ha->mailbox_out[0] = mb0;
3831 mboxes >>= 1;
3832 wptr = &reg->mailbox1;
3833
3834 for (cnt = 1; cnt < ha->mbx_count; cnt++) {
3835 if (mboxes & BIT_0)
3836 ha->mailbox_out[cnt] = rd_reg_word(wptr);
3837
3838 mboxes >>= 1;
3839 wptr++;
3840 }
3841 }
3842
3843 static void
3844 qla24xx_abort_iocb_entry(scsi_qla_host_t *vha, struct req_que *req,
3845 struct abort_entry_24xx *pkt)
3846 {
3847 const char func[] = "ABT_IOCB";
3848 srb_t *sp;
3849 srb_t *orig_sp = NULL;
3850 struct srb_iocb *abt;
3851
3852 sp = qla2x00_get_sp_from_handle(vha, func, req, pkt);
3853 if (!sp)
3854 return;
3855
3856 abt = &sp->u.iocb_cmd;
3857 abt->u.abt.comp_status = pkt->comp_status;
3858 orig_sp = sp->cmd_sp;
3859 /* Need to pass original sp */
3860 if (orig_sp)
3861 qla_nvme_abort_process_comp_status(pkt, orig_sp);
3862
3863 sp->done(sp, 0);
3864 }
3865
3866 void qla24xx_nvme_ls4_iocb(struct scsi_qla_host *vha,
3867 struct pt_ls4_request *pkt, struct req_que *req)
3868 {
3869 srb_t *sp;
3870 const char func[] = "LS4_IOCB";
3871 uint16_t comp_status;
3872
3873 sp = qla2x00_get_sp_from_handle(vha, func, req, pkt);
3874 if (!sp)
3875 return;
3876
3877 comp_status = le16_to_cpu(pkt->status);
3878 sp->done(sp, comp_status);
3879 }
3880
3881 /**
3882 * qla_chk_cont_iocb_avail - check for all continuation iocbs are available
3883 * before iocb processing can start.
3884 * @vha: host adapter pointer
3885 * @rsp: respond queue
3886 * @pkt: head iocb describing how many continuation iocb
3887 * Return: 0 all iocbs has arrived, xx- all iocbs have not arrived.
3888 */
3889 static int qla_chk_cont_iocb_avail(struct scsi_qla_host *vha,
3890 struct rsp_que *rsp, response_t *pkt, u32 rsp_q_in)
3891 {
3892 int start_pkt_ring_index;
3893 u32 iocb_cnt = 0;
3894 int rc = 0;
3895
3896 if (pkt->entry_count == 1)
3897 return rc;
3898
3899 /* ring_index was pre-increment. set it back to current pkt */
3900 if (rsp->ring_index == 0)
3901 start_pkt_ring_index = rsp->length - 1;
3902 else
3903 start_pkt_ring_index = rsp->ring_index - 1;
3904
3905 if (rsp_q_in < start_pkt_ring_index)
3906 /* q in ptr is wrapped */
3907 iocb_cnt = rsp->length - start_pkt_ring_index + rsp_q_in;
3908 else
3909 iocb_cnt = rsp_q_in - start_pkt_ring_index;
3910
3911 if (iocb_cnt < pkt->entry_count)
3912 rc = -EIO;
3913
3914 ql_dbg(ql_dbg_init, vha, 0x5091,
3915 "%s - ring %p pkt %p entry count %d iocb_cnt %d rsp_q_in %d rc %d\n",
3916 __func__, rsp->ring, pkt, pkt->entry_count, iocb_cnt, rsp_q_in, rc);
3917
3918 return rc;
3919 }
3920
3921 static void qla_marker_iocb_entry(scsi_qla_host_t *vha, struct req_que *req,
3922 struct mrk_entry_24xx *pkt)
3923 {
3924 const char func[] = "MRK-IOCB";
3925 srb_t *sp;
3926 int res = QLA_SUCCESS;
3927
3928 if (!IS_FWI2_CAPABLE(vha->hw))
3929 return;
3930
3931 sp = qla2x00_get_sp_from_handle(vha, func, req, pkt);
3932 if (!sp)
3933 return;
3934
3935 if (pkt->entry_status) {
3936 ql_dbg(ql_dbg_taskm, vha, 0x8025, "marker failure.\n");
3937 res = QLA_COMMAND_ERROR;
3938 }
3939 sp->u.iocb_cmd.u.tmf.data = res;
3940 sp->done(sp, res);
3941 }
3942
3943 /**
3944 * qla24xx_process_response_queue() - Process response queue entries.
3945 * @vha: SCSI driver HA context
3946 * @rsp: response queue
3947 */
3948 void qla24xx_process_response_queue(struct scsi_qla_host *vha,
3949 struct rsp_que *rsp)
3950 {
3951 struct sts_entry_24xx *pkt;
3952 struct qla_hw_data *ha = vha->hw;
3953 struct purex_entry_24xx *purex_entry;
3954 struct purex_item *pure_item;
3955 struct pt_ls4_rx_unsol *p;
3956 u16 rsp_in = 0, cur_ring_index;
3957 int is_shadow_hba;
3958
3959 if (!ha->flags.fw_started)
3960 return;
3961
3962 if (rsp->qpair->cpuid != raw_smp_processor_id() || !rsp->qpair->rcv_intr) {
3963 rsp->qpair->rcv_intr = 1;
3964
3965 if (!rsp->qpair->cpu_mapped)
3966 qla_cpu_update(rsp->qpair, raw_smp_processor_id());
3967 }
3968
3969 #define __update_rsp_in(_is_shadow_hba, _rsp, _rsp_in) \
3970 do { \
3971 _rsp_in = _is_shadow_hba ? *(_rsp)->in_ptr : \
3972 rd_reg_dword_relaxed((_rsp)->rsp_q_in); \
3973 } while (0)
3974
3975 is_shadow_hba = IS_SHADOW_REG_CAPABLE(ha);
3976
3977 __update_rsp_in(is_shadow_hba, rsp, rsp_in);
3978
3979 while (rsp->ring_index != rsp_in &&
3980 rsp->ring_ptr->signature != RESPONSE_PROCESSED) {
3981 pkt = (struct sts_entry_24xx *)rsp->ring_ptr;
3982 cur_ring_index = rsp->ring_index;
3983
3984 rsp->ring_index++;
3985 if (rsp->ring_index == rsp->length) {
3986 rsp->ring_index = 0;
3987 rsp->ring_ptr = rsp->ring;
3988 } else {
3989 rsp->ring_ptr++;
3990 }
3991
3992 if (pkt->entry_status != 0) {
3993 if (qla2x00_error_entry(vha, rsp, (sts_entry_t *) pkt))
3994 goto process_err;
3995
3996 ((response_t *)pkt)->signature = RESPONSE_PROCESSED;
3997 wmb();
3998 continue;
3999 }
4000 process_err:
4001
4002 switch (pkt->entry_type) {
4003 case STATUS_TYPE:
4004 qla2x00_status_entry(vha, rsp, pkt);
4005 break;
4006 case STATUS_CONT_TYPE:
4007 qla2x00_status_cont_entry(rsp, (sts_cont_entry_t *)pkt);
4008 break;
4009 case VP_RPT_ID_IOCB_TYPE:
4010 qla24xx_report_id_acquisition(vha,
4011 (struct vp_rpt_id_entry_24xx *)pkt);
4012 break;
4013 case LOGINOUT_PORT_IOCB_TYPE:
4014 qla24xx_logio_entry(vha, rsp->req,
4015 (struct logio_entry_24xx *)pkt);
4016 break;
4017 case CT_IOCB_TYPE:
4018 qla24xx_els_ct_entry(vha, rsp->req, pkt, CT_IOCB_TYPE);
4019 break;
4020 case ELS_IOCB_TYPE:
4021 qla24xx_els_ct_entry(vha, rsp->req, pkt, ELS_IOCB_TYPE);
4022 break;
4023 case ABTS_RECV_24XX:
4024 if (qla_ini_mode_enabled(vha)) {
4025 pure_item = qla24xx_copy_std_pkt(vha, pkt);
4026 if (!pure_item)
4027 break;
4028 qla24xx_queue_purex_item(vha, pure_item,
4029 qla24xx_process_abts);
4030 break;
4031 }
4032 if (IS_QLA83XX(ha) || IS_QLA27XX(ha) ||
4033 IS_QLA28XX(ha)) {
4034 /* ensure that the ATIO queue is empty */
4035 qlt_handle_abts_recv(vha, rsp,
4036 (response_t *)pkt);
4037 break;
4038 } else {
4039 qlt_24xx_process_atio_queue(vha, 1);
4040 }
4041 fallthrough;
4042 case ABTS_RESP_24XX:
4043 case CTIO_TYPE7:
4044 case CTIO_CRC2:
4045 qlt_response_pkt_all_vps(vha, rsp, (response_t *)pkt);
4046 break;
4047 case PT_LS4_REQUEST:
4048 qla24xx_nvme_ls4_iocb(vha, (struct pt_ls4_request *)pkt,
4049 rsp->req);
4050 break;
4051 case NOTIFY_ACK_TYPE:
4052 if (pkt->handle == QLA_TGT_SKIP_HANDLE)
4053 qlt_response_pkt_all_vps(vha, rsp,
4054 (response_t *)pkt);
4055 else
4056 qla24xxx_nack_iocb_entry(vha, rsp->req,
4057 (struct nack_to_isp *)pkt);
4058 break;
4059 case MARKER_TYPE:
4060 qla_marker_iocb_entry(vha, rsp->req, (struct mrk_entry_24xx *)pkt);
4061 break;
4062 case ABORT_IOCB_TYPE:
4063 qla24xx_abort_iocb_entry(vha, rsp->req,
4064 (struct abort_entry_24xx *)pkt);
4065 break;
4066 case MBX_IOCB_TYPE:
4067 qla24xx_mbx_iocb_entry(vha, rsp->req,
4068 (struct mbx_24xx_entry *)pkt);
4069 break;
4070 case VP_CTRL_IOCB_TYPE:
4071 qla_ctrlvp_completed(vha, rsp->req,
4072 (struct vp_ctrl_entry_24xx *)pkt);
4073 break;
4074 case PUREX_IOCB_TYPE:
4075 purex_entry = (void *)pkt;
4076 switch (purex_entry->els_frame_payload[3]) {
4077 case ELS_RDP:
4078 pure_item = qla24xx_copy_std_pkt(vha, pkt);
4079 if (!pure_item)
4080 break;
4081 qla24xx_queue_purex_item(vha, pure_item,
4082 qla24xx_process_purex_rdp);
4083 break;
4084 case ELS_FPIN:
4085 if (!vha->hw->flags.scm_enabled) {
4086 ql_log(ql_log_warn, vha, 0x5094,
4087 "SCM not active for this port\n");
4088 break;
4089 }
4090 pure_item = qla27xx_copy_fpin_pkt(vha,
4091 (void **)&pkt, &rsp);
4092 __update_rsp_in(is_shadow_hba, rsp, rsp_in);
4093 if (!pure_item)
4094 break;
4095 qla24xx_queue_purex_item(vha, pure_item,
4096 qla27xx_process_purex_fpin);
4097 break;
4098
4099 case ELS_AUTH_ELS:
4100 if (qla_chk_cont_iocb_avail(vha, rsp, (response_t *)pkt, rsp_in)) {
4101 /*
4102 * ring_ptr and ring_index were
4103 * pre-incremented above. Reset them
4104 * back to current. Wait for next
4105 * interrupt with all IOCBs to arrive
4106 * and re-process.
4107 */
4108 rsp->ring_ptr = (response_t *)pkt;
4109 rsp->ring_index = cur_ring_index;
4110
4111 ql_dbg(ql_dbg_init, vha, 0x5091,
4112 "Defer processing ELS opcode %#x...\n",
4113 purex_entry->els_frame_payload[3]);
4114 return;
4115 }
4116 qla24xx_auth_els(vha, (void **)&pkt, &rsp);
4117 break;
4118 default:
4119 ql_log(ql_log_warn, vha, 0x509c,
4120 "Discarding ELS Request opcode 0x%x\n",
4121 purex_entry->els_frame_payload[3]);
4122 }
4123 break;
4124 case SA_UPDATE_IOCB_TYPE:
4125 qla28xx_sa_update_iocb_entry(vha, rsp->req,
4126 (struct sa_update_28xx *)pkt);
4127 break;
4128 case PT_LS4_UNSOL:
4129 p = (void *)pkt;
4130 if (qla_chk_cont_iocb_avail(vha, rsp, (response_t *)pkt, rsp_in)) {
4131 rsp->ring_ptr = (response_t *)pkt;
4132 rsp->ring_index = cur_ring_index;
4133
4134 ql_dbg(ql_dbg_init, vha, 0x2124,
4135 "Defer processing UNSOL LS req opcode %#x...\n",
4136 p->payload[0]);
4137 return;
4138 }
4139 qla2xxx_process_purls_iocb((void **)&pkt, &rsp);
4140 break;
4141 default:
4142 /* Type Not Supported. */
4143 ql_dbg(ql_dbg_async, vha, 0x5042,
4144 "Received unknown response pkt type 0x%x entry status=%x.\n",
4145 pkt->entry_type, pkt->entry_status);
4146 break;
4147 }
4148 ((response_t *)pkt)->signature = RESPONSE_PROCESSED;
4149 wmb();
4150 }
4151
4152 /* Adjust ring index */
4153 if (IS_P3P_TYPE(ha)) {
4154 struct device_reg_82xx __iomem *reg = &ha->iobase->isp82;
4155
4156 wrt_reg_dword(&reg->rsp_q_out[0], rsp->ring_index);
4157 } else {
4158 wrt_reg_dword(rsp->rsp_q_out, rsp->ring_index);
4159 }
4160 }
4161
4162 static void
4163 qla2xxx_check_risc_status(scsi_qla_host_t *vha)
4164 {
4165 int rval;
4166 uint32_t cnt;
4167 struct qla_hw_data *ha = vha->hw;
4168 struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
4169
4170 if (!IS_QLA25XX(ha) && !IS_QLA81XX(ha) && !IS_QLA83XX(ha) &&
4171 !IS_QLA27XX(ha) && !IS_QLA28XX(ha))
4172 return;
4173
4174 rval = QLA_SUCCESS;
4175 wrt_reg_dword(&reg->iobase_addr, 0x7C00);
4176 rd_reg_dword(&reg->iobase_addr);
4177 wrt_reg_dword(&reg->iobase_window, 0x0001);
4178 for (cnt = 10000; (rd_reg_dword(&reg->iobase_window) & BIT_0) == 0 &&
4179 rval == QLA_SUCCESS; cnt--) {
4180 if (cnt) {
4181 wrt_reg_dword(&reg->iobase_window, 0x0001);
4182 udelay(10);
4183 } else
4184 rval = QLA_FUNCTION_TIMEOUT;
4185 }
4186 if (rval == QLA_SUCCESS)
4187 goto next_test;
4188
4189 rval = QLA_SUCCESS;
4190 wrt_reg_dword(&reg->iobase_window, 0x0003);
4191 for (cnt = 100; (rd_reg_dword(&reg->iobase_window) & BIT_0) == 0 &&
4192 rval == QLA_SUCCESS; cnt--) {
4193 if (cnt) {
4194 wrt_reg_dword(&reg->iobase_window, 0x0003);
4195 udelay(10);
4196 } else
4197 rval = QLA_FUNCTION_TIMEOUT;
4198 }
4199 if (rval != QLA_SUCCESS)
4200 goto done;
4201
4202 next_test:
4203 if (rd_reg_dword(&reg->iobase_c8) & BIT_3)
4204 ql_log(ql_log_info, vha, 0x504c,
4205 "Additional code -- 0x55AA.\n");
4206
4207 done:
4208 wrt_reg_dword(&reg->iobase_window, 0x0000);
4209 rd_reg_dword(&reg->iobase_window);
4210 }
4211
4212 /**
4213 * qla24xx_intr_handler() - Process interrupts for the ISP23xx and ISP24xx.
4214 * @irq: interrupt number
4215 * @dev_id: SCSI driver HA context
4216 *
4217 * Called by system whenever the host adapter generates an interrupt.
4218 *
4219 * Returns handled flag.
4220 */
4221 irqreturn_t
4222 qla24xx_intr_handler(int irq, void *dev_id)
4223 {
4224 scsi_qla_host_t *vha;
4225 struct qla_hw_data *ha;
4226 struct device_reg_24xx __iomem *reg;
4227 int status;
4228 unsigned long iter;
4229 uint32_t stat;
4230 uint32_t hccr;
4231 uint16_t mb[8];
4232 struct rsp_que *rsp;
4233 unsigned long flags;
4234 bool process_atio = false;
4235
4236 rsp = (struct rsp_que *) dev_id;
4237 if (!rsp) {
4238 ql_log(ql_log_info, NULL, 0x5059,
4239 "%s: NULL response queue pointer.\n", __func__);
4240 return IRQ_NONE;
4241 }
4242
4243 ha = rsp->hw;
4244 reg = &ha->iobase->isp24;
4245 status = 0;
4246
4247 if (unlikely(pci_channel_offline(ha->pdev)))
4248 return IRQ_HANDLED;
4249
4250 spin_lock_irqsave(&ha->hardware_lock, flags);
4251 vha = pci_get_drvdata(ha->pdev);
4252 for (iter = 50; iter--; ) {
4253 stat = rd_reg_dword(&reg->host_status);
4254 if (qla2x00_check_reg32_for_disconnect(vha, stat))
4255 break;
4256 if (stat & HSRX_RISC_PAUSED) {
4257 if (unlikely(pci_channel_offline(ha->pdev)))
4258 break;
4259
4260 hccr = rd_reg_dword(&reg->hccr);
4261
4262 ql_log(ql_log_warn, vha, 0x504b,
4263 "RISC paused -- HCCR=%x, Dumping firmware.\n",
4264 hccr);
4265
4266 qla2xxx_check_risc_status(vha);
4267
4268 ha->isp_ops->fw_dump(vha);
4269 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
4270 break;
4271 } else if ((stat & HSRX_RISC_INT) == 0)
4272 break;
4273
4274 switch (stat & 0xff) {
4275 case INTR_ROM_MB_SUCCESS:
4276 case INTR_ROM_MB_FAILED:
4277 case INTR_MB_SUCCESS:
4278 case INTR_MB_FAILED:
4279 qla24xx_mbx_completion(vha, MSW(stat));
4280 status |= MBX_INTERRUPT;
4281
4282 break;
4283 case INTR_ASYNC_EVENT:
4284 mb[0] = MSW(stat);
4285 mb[1] = rd_reg_word(&reg->mailbox1);
4286 mb[2] = rd_reg_word(&reg->mailbox2);
4287 mb[3] = rd_reg_word(&reg->mailbox3);
4288 qla2x00_async_event(vha, rsp, mb);
4289 break;
4290 case INTR_RSP_QUE_UPDATE:
4291 case INTR_RSP_QUE_UPDATE_83XX:
4292 qla24xx_process_response_queue(vha, rsp);
4293 break;
4294 case INTR_ATIO_QUE_UPDATE_27XX:
4295 case INTR_ATIO_QUE_UPDATE:
4296 process_atio = true;
4297 break;
4298 case INTR_ATIO_RSP_QUE_UPDATE:
4299 process_atio = true;
4300 qla24xx_process_response_queue(vha, rsp);
4301 break;
4302 default:
4303 ql_dbg(ql_dbg_async, vha, 0x504f,
4304 "Unrecognized interrupt type (%d).\n", stat * 0xff);
4305 break;
4306 }
4307 wrt_reg_dword(&reg->hccr, HCCRX_CLR_RISC_INT);
4308 rd_reg_dword_relaxed(&reg->hccr);
4309 if (unlikely(IS_QLA83XX(ha) && (ha->pdev->revision == 1)))
4310 ndelay(3500);
4311 }
4312 qla2x00_handle_mbx_completion(ha, status);
4313 spin_unlock_irqrestore(&ha->hardware_lock, flags);
4314
4315 if (process_atio) {
4316 spin_lock_irqsave(&ha->tgt.atio_lock, flags);
4317 qlt_24xx_process_atio_queue(vha, 0);
4318 spin_unlock_irqrestore(&ha->tgt.atio_lock, flags);
4319 }
4320
4321 return IRQ_HANDLED;
4322 }
4323
4324 static irqreturn_t
4325 qla24xx_msix_rsp_q(int irq, void *dev_id)
4326 {
4327 struct qla_hw_data *ha;
4328 struct rsp_que *rsp;
4329 struct device_reg_24xx __iomem *reg;
4330 struct scsi_qla_host *vha;
4331 unsigned long flags;
4332
4333 rsp = (struct rsp_que *) dev_id;
4334 if (!rsp) {
4335 ql_log(ql_log_info, NULL, 0x505a,
4336 "%s: NULL response queue pointer.\n", __func__);
4337 return IRQ_NONE;
4338 }
4339 ha = rsp->hw;
4340 reg = &ha->iobase->isp24;
4341
4342 spin_lock_irqsave(&ha->hardware_lock, flags);
4343
4344 vha = pci_get_drvdata(ha->pdev);
4345 qla24xx_process_response_queue(vha, rsp);
4346 if (!ha->flags.disable_msix_handshake) {
4347 wrt_reg_dword(&reg->hccr, HCCRX_CLR_RISC_INT);
4348 rd_reg_dword_relaxed(&reg->hccr);
4349 }
4350 spin_unlock_irqrestore(&ha->hardware_lock, flags);
4351
4352 return IRQ_HANDLED;
4353 }
4354
4355 static irqreturn_t
4356 qla24xx_msix_default(int irq, void *dev_id)
4357 {
4358 scsi_qla_host_t *vha;
4359 struct qla_hw_data *ha;
4360 struct rsp_que *rsp;
4361 struct device_reg_24xx __iomem *reg;
4362 int status;
4363 uint32_t stat;
4364 uint32_t hccr;
4365 uint16_t mb[8];
4366 unsigned long flags;
4367 bool process_atio = false;
4368
4369 rsp = (struct rsp_que *) dev_id;
4370 if (!rsp) {
4371 ql_log(ql_log_info, NULL, 0x505c,
4372 "%s: NULL response queue pointer.\n", __func__);
4373 return IRQ_NONE;
4374 }
4375 ha = rsp->hw;
4376 reg = &ha->iobase->isp24;
4377 status = 0;
4378
4379 spin_lock_irqsave(&ha->hardware_lock, flags);
4380 vha = pci_get_drvdata(ha->pdev);
4381 do {
4382 stat = rd_reg_dword(&reg->host_status);
4383 if (qla2x00_check_reg32_for_disconnect(vha, stat))
4384 break;
4385 if (stat & HSRX_RISC_PAUSED) {
4386 if (unlikely(pci_channel_offline(ha->pdev)))
4387 break;
4388
4389 hccr = rd_reg_dword(&reg->hccr);
4390
4391 ql_log(ql_log_info, vha, 0x5050,
4392 "RISC paused -- HCCR=%x, Dumping firmware.\n",
4393 hccr);
4394
4395 qla2xxx_check_risc_status(vha);
4396 vha->hw_err_cnt++;
4397
4398 ha->isp_ops->fw_dump(vha);
4399 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
4400 break;
4401 } else if ((stat & HSRX_RISC_INT) == 0)
4402 break;
4403
4404 switch (stat & 0xff) {
4405 case INTR_ROM_MB_SUCCESS:
4406 case INTR_ROM_MB_FAILED:
4407 case INTR_MB_SUCCESS:
4408 case INTR_MB_FAILED:
4409 qla24xx_mbx_completion(vha, MSW(stat));
4410 status |= MBX_INTERRUPT;
4411
4412 break;
4413 case INTR_ASYNC_EVENT:
4414 mb[0] = MSW(stat);
4415 mb[1] = rd_reg_word(&reg->mailbox1);
4416 mb[2] = rd_reg_word(&reg->mailbox2);
4417 mb[3] = rd_reg_word(&reg->mailbox3);
4418 qla2x00_async_event(vha, rsp, mb);
4419 break;
4420 case INTR_RSP_QUE_UPDATE:
4421 case INTR_RSP_QUE_UPDATE_83XX:
4422 qla24xx_process_response_queue(vha, rsp);
4423 break;
4424 case INTR_ATIO_QUE_UPDATE_27XX:
4425 case INTR_ATIO_QUE_UPDATE:
4426 process_atio = true;
4427 break;
4428 case INTR_ATIO_RSP_QUE_UPDATE:
4429 process_atio = true;
4430 qla24xx_process_response_queue(vha, rsp);
4431 break;
4432 default:
4433 ql_dbg(ql_dbg_async, vha, 0x5051,
4434 "Unrecognized interrupt type (%d).\n", stat & 0xff);
4435 break;
4436 }
4437 wrt_reg_dword(&reg->hccr, HCCRX_CLR_RISC_INT);
4438 } while (0);
4439 qla2x00_handle_mbx_completion(ha, status);
4440 spin_unlock_irqrestore(&ha->hardware_lock, flags);
4441
4442 if (process_atio) {
4443 spin_lock_irqsave(&ha->tgt.atio_lock, flags);
4444 qlt_24xx_process_atio_queue(vha, 0);
4445 spin_unlock_irqrestore(&ha->tgt.atio_lock, flags);
4446 }
4447
4448 return IRQ_HANDLED;
4449 }
4450
4451 irqreturn_t
4452 qla2xxx_msix_rsp_q(int irq, void *dev_id)
4453 {
4454 struct qla_hw_data *ha;
4455 struct qla_qpair *qpair;
4456
4457 qpair = dev_id;
4458 if (!qpair) {
4459 ql_log(ql_log_info, NULL, 0x505b,
4460 "%s: NULL response queue pointer.\n", __func__);
4461 return IRQ_NONE;
4462 }
4463 ha = qpair->hw;
4464
4465 queue_work(ha->wq, &qpair->q_work);
4466
4467 return IRQ_HANDLED;
4468 }
4469
4470 irqreturn_t
4471 qla2xxx_msix_rsp_q_hs(int irq, void *dev_id)
4472 {
4473 struct qla_hw_data *ha;
4474 struct qla_qpair *qpair;
4475 struct device_reg_24xx __iomem *reg;
4476 unsigned long flags;
4477
4478 qpair = dev_id;
4479 if (!qpair) {
4480 ql_log(ql_log_info, NULL, 0x505b,
4481 "%s: NULL response queue pointer.\n", __func__);
4482 return IRQ_NONE;
4483 }
4484 ha = qpair->hw;
4485
4486 reg = &ha->iobase->isp24;
4487 spin_lock_irqsave(&ha->hardware_lock, flags);
4488 wrt_reg_dword(&reg->hccr, HCCRX_CLR_RISC_INT);
4489 spin_unlock_irqrestore(&ha->hardware_lock, flags);
4490
4491 queue_work(ha->wq, &qpair->q_work);
4492
4493 return IRQ_HANDLED;
4494 }
4495
4496 /* Interrupt handling helpers. */
4497
4498 struct qla_init_msix_entry {
4499 const char *name;
4500 irq_handler_t handler;
4501 };
4502
4503 static const struct qla_init_msix_entry msix_entries[] = {
4504 { "default", qla24xx_msix_default },
4505 { "rsp_q", qla24xx_msix_rsp_q },
4506 { "atio_q", qla83xx_msix_atio_q },
4507 { "qpair_multiq", qla2xxx_msix_rsp_q },
4508 { "qpair_multiq_hs", qla2xxx_msix_rsp_q_hs },
4509 };
4510
4511 static const struct qla_init_msix_entry qla82xx_msix_entries[] = {
4512 { "qla2xxx (default)", qla82xx_msix_default },
4513 { "qla2xxx (rsp_q)", qla82xx_msix_rsp_q },
4514 };
4515
4516 static int
4517 qla24xx_enable_msix(struct qla_hw_data *ha, struct rsp_que *rsp)
4518 {
4519 int i, ret;
4520 struct qla_msix_entry *qentry;
4521 scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
4522 int min_vecs = QLA_BASE_VECTORS;
4523 struct irq_affinity desc = {
4524 .pre_vectors = QLA_BASE_VECTORS,
4525 };
4526
4527 if (QLA_TGT_MODE_ENABLED() && (ql2xenablemsix != 0) &&
4528 IS_ATIO_MSIX_CAPABLE(ha)) {
4529 desc.pre_vectors++;
4530 min_vecs++;
4531 }
4532
4533 if (USER_CTRL_IRQ(ha) || !ha->mqiobase) {
4534 /* user wants to control IRQ setting for target mode */
4535 ret = pci_alloc_irq_vectors(ha->pdev, min_vecs,
4536 min((u16)ha->msix_count, (u16)(num_online_cpus() + min_vecs)),
4537 PCI_IRQ_MSIX);
4538 } else
4539 ret = pci_alloc_irq_vectors_affinity(ha->pdev, min_vecs,
4540 min((u16)ha->msix_count, (u16)(num_online_cpus() + min_vecs)),
4541 PCI_IRQ_MSIX | PCI_IRQ_AFFINITY,
4542 &desc);
4543
4544 if (ret < 0) {
4545 ql_log(ql_log_fatal, vha, 0x00c7,
4546 "MSI-X: Failed to enable support, "
4547 "giving up -- %d/%d.\n",
4548 ha->msix_count, ret);
4549 goto msix_out;
4550 } else if (ret < ha->msix_count) {
4551 ql_log(ql_log_info, vha, 0x00c6,
4552 "MSI-X: Using %d vectors\n", ret);
4553 ha->msix_count = ret;
4554 /* Recalculate queue values */
4555 if (ha->mqiobase && (ql2xmqsupport || ql2xnvmeenable)) {
4556 ha->max_req_queues = ha->msix_count - 1;
4557
4558 /* ATIOQ needs 1 vector. That's 1 less QPair */
4559 if (QLA_TGT_MODE_ENABLED())
4560 ha->max_req_queues--;
4561
4562 ha->max_rsp_queues = ha->max_req_queues;
4563
4564 ha->max_qpairs = ha->max_req_queues - 1;
4565 ql_dbg_pci(ql_dbg_init, ha->pdev, 0x0190,
4566 "Adjusted Max no of queues pairs: %d.\n", ha->max_qpairs);
4567 }
4568 }
4569 vha->irq_offset = desc.pre_vectors;
4570 ha->msix_entries = kcalloc(ha->msix_count,
4571 sizeof(struct qla_msix_entry),
4572 GFP_KERNEL);
4573 if (!ha->msix_entries) {
4574 ql_log(ql_log_fatal, vha, 0x00c8,
4575 "Failed to allocate memory for ha->msix_entries.\n");
4576 ret = -ENOMEM;
4577 goto free_irqs;
4578 }
4579 ha->flags.msix_enabled = 1;
4580
4581 for (i = 0; i < ha->msix_count; i++) {
4582 qentry = &ha->msix_entries[i];
4583 qentry->vector = pci_irq_vector(ha->pdev, i);
4584 qentry->vector_base0 = i;
4585 qentry->entry = i;
4586 qentry->have_irq = 0;
4587 qentry->in_use = 0;
4588 qentry->handle = NULL;
4589 }
4590
4591 /* Enable MSI-X vectors for the base queue */
4592 for (i = 0; i < QLA_BASE_VECTORS; i++) {
4593 qentry = &ha->msix_entries[i];
4594 qentry->handle = rsp;
4595 rsp->msix = qentry;
4596 scnprintf(qentry->name, sizeof(qentry->name),
4597 "qla2xxx%lu_%s", vha->host_no, msix_entries[i].name);
4598 if (IS_P3P_TYPE(ha))
4599 ret = request_irq(qentry->vector,
4600 qla82xx_msix_entries[i].handler,
4601 0, qla82xx_msix_entries[i].name, rsp);
4602 else
4603 ret = request_irq(qentry->vector,
4604 msix_entries[i].handler,
4605 0, qentry->name, rsp);
4606 if (ret)
4607 goto msix_register_fail;
4608 qentry->have_irq = 1;
4609 qentry->in_use = 1;
4610 }
4611
4612 /*
4613 * If target mode is enable, also request the vector for the ATIO
4614 * queue.
4615 */
4616 if (QLA_TGT_MODE_ENABLED() && (ql2xenablemsix != 0) &&
4617 IS_ATIO_MSIX_CAPABLE(ha)) {
4618 qentry = &ha->msix_entries[QLA_ATIO_VECTOR];
4619 rsp->msix = qentry;
4620 qentry->handle = rsp;
4621 scnprintf(qentry->name, sizeof(qentry->name),
4622 "qla2xxx%lu_%s", vha->host_no,
4623 msix_entries[QLA_ATIO_VECTOR].name);
4624 qentry->in_use = 1;
4625 ret = request_irq(qentry->vector,
4626 msix_entries[QLA_ATIO_VECTOR].handler,
4627 0, qentry->name, rsp);
4628 qentry->have_irq = 1;
4629 }
4630
4631 msix_register_fail:
4632 if (ret) {
4633 ql_log(ql_log_fatal, vha, 0x00cb,
4634 "MSI-X: unable to register handler -- %x/%d.\n",
4635 qentry->vector, ret);
4636 qla2x00_free_irqs(vha);
4637 ha->mqenable = 0;
4638 goto msix_out;
4639 }
4640
4641 /* Enable MSI-X vector for response queue update for queue 0 */
4642 if (IS_MQUE_CAPABLE(ha) &&
4643 (ha->msixbase && ha->mqiobase && ha->max_qpairs))
4644 ha->mqenable = 1;
4645 else
4646 ha->mqenable = 0;
4647
4648 ql_dbg(ql_dbg_multiq, vha, 0xc005,
4649 "mqiobase=%p, max_rsp_queues=%d, max_req_queues=%d.\n",
4650 ha->mqiobase, ha->max_rsp_queues, ha->max_req_queues);
4651 ql_dbg(ql_dbg_init, vha, 0x0055,
4652 "mqiobase=%p, max_rsp_queues=%d, max_req_queues=%d.\n",
4653 ha->mqiobase, ha->max_rsp_queues, ha->max_req_queues);
4654
4655 msix_out:
4656 return ret;
4657
4658 free_irqs:
4659 pci_free_irq_vectors(ha->pdev);
4660 goto msix_out;
4661 }
4662
4663 int
4664 qla2x00_request_irqs(struct qla_hw_data *ha, struct rsp_que *rsp)
4665 {
4666 int ret = QLA_FUNCTION_FAILED;
4667 device_reg_t *reg = ha->iobase;
4668 scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
4669
4670 /* If possible, enable MSI-X. */
4671 if (ql2xenablemsix == 0 || (!IS_QLA2432(ha) && !IS_QLA2532(ha) &&
4672 !IS_QLA8432(ha) && !IS_CNA_CAPABLE(ha) && !IS_QLA2031(ha) &&
4673 !IS_QLAFX00(ha) && !IS_QLA27XX(ha) && !IS_QLA28XX(ha)))
4674 goto skip_msi;
4675
4676 if (ql2xenablemsix == 2)
4677 goto skip_msix;
4678
4679 if (ha->pdev->subsystem_vendor == PCI_VENDOR_ID_HP &&
4680 (ha->pdev->subsystem_device == 0x7040 ||
4681 ha->pdev->subsystem_device == 0x7041 ||
4682 ha->pdev->subsystem_device == 0x1705)) {
4683 ql_log(ql_log_warn, vha, 0x0034,
4684 "MSI-X: Unsupported ISP 2432 SSVID/SSDID (0x%X,0x%X).\n",
4685 ha->pdev->subsystem_vendor,
4686 ha->pdev->subsystem_device);
4687 goto skip_msi;
4688 }
4689
4690 if (IS_QLA2432(ha) && (ha->pdev->revision < QLA_MSIX_CHIP_REV_24XX)) {
4691 ql_log(ql_log_warn, vha, 0x0035,
4692 "MSI-X; Unsupported ISP2432 (0x%X, 0x%X).\n",
4693 ha->pdev->revision, QLA_MSIX_CHIP_REV_24XX);
4694 goto skip_msix;
4695 }
4696
4697 ret = qla24xx_enable_msix(ha, rsp);
4698 if (!ret) {
4699 ql_dbg(ql_dbg_init, vha, 0x0036,
4700 "MSI-X: Enabled (0x%X, 0x%X).\n",
4701 ha->chip_revision, ha->fw_attributes);
4702 goto clear_risc_ints;
4703 }
4704
4705 skip_msix:
4706
4707 ql_log(ql_log_info, vha, 0x0037,
4708 "Falling back-to MSI mode -- ret=%d.\n", ret);
4709
4710 if (!IS_QLA24XX(ha) && !IS_QLA2532(ha) && !IS_QLA8432(ha) &&
4711 !IS_QLA8001(ha) && !IS_P3P_TYPE(ha) && !IS_QLAFX00(ha) &&
4712 !IS_QLA27XX(ha) && !IS_QLA28XX(ha))
4713 goto skip_msi;
4714
4715 ret = pci_alloc_irq_vectors(ha->pdev, 1, 1, PCI_IRQ_MSI);
4716 if (ret > 0) {
4717 ql_dbg(ql_dbg_init, vha, 0x0038,
4718 "MSI: Enabled.\n");
4719 ha->flags.msi_enabled = 1;
4720 } else
4721 ql_log(ql_log_warn, vha, 0x0039,
4722 "Falling back-to INTa mode -- ret=%d.\n", ret);
4723 skip_msi:
4724
4725 /* Skip INTx on ISP82xx. */
4726 if (!ha->flags.msi_enabled && IS_QLA82XX(ha))
4727 return QLA_FUNCTION_FAILED;
4728
4729 ret = request_irq(ha->pdev->irq, ha->isp_ops->intr_handler,
4730 ha->flags.msi_enabled ? 0 : IRQF_SHARED,
4731 QLA2XXX_DRIVER_NAME, rsp);
4732 if (ret) {
4733 ql_log(ql_log_warn, vha, 0x003a,
4734 "Failed to reserve interrupt %d already in use.\n",
4735 ha->pdev->irq);
4736 goto fail;
4737 } else if (!ha->flags.msi_enabled) {
4738 ql_dbg(ql_dbg_init, vha, 0x0125,
4739 "INTa mode: Enabled.\n");
4740 ha->flags.mr_intr_valid = 1;
4741 /* Set max_qpair to 0, as MSI-X and MSI in not enabled */
4742 ha->max_qpairs = 0;
4743 }
4744
4745 clear_risc_ints:
4746 if (IS_FWI2_CAPABLE(ha) || IS_QLAFX00(ha))
4747 goto fail;
4748
4749 spin_lock_irq(&ha->hardware_lock);
4750 wrt_reg_word(&reg->isp.semaphore, 0);
4751 spin_unlock_irq(&ha->hardware_lock);
4752
4753 fail:
4754 return ret;
4755 }
4756
4757 void
4758 qla2x00_free_irqs(scsi_qla_host_t *vha)
4759 {
4760 struct qla_hw_data *ha = vha->hw;
4761 struct rsp_que *rsp;
4762 struct qla_msix_entry *qentry;
4763 int i;
4764
4765 /*
4766 * We need to check that ha->rsp_q_map is valid in case we are called
4767 * from a probe failure context.
4768 */
4769 if (!ha->rsp_q_map || !ha->rsp_q_map[0])
4770 goto free_irqs;
4771 rsp = ha->rsp_q_map[0];
4772
4773 if (ha->flags.msix_enabled) {
4774 for (i = 0; i < ha->msix_count; i++) {
4775 qentry = &ha->msix_entries[i];
4776 if (qentry->have_irq) {
4777 irq_set_affinity_notifier(qentry->vector, NULL);
4778 free_irq(pci_irq_vector(ha->pdev, i), qentry->handle);
4779 }
4780 }
4781 kfree(ha->msix_entries);
4782 ha->msix_entries = NULL;
4783 ha->flags.msix_enabled = 0;
4784 ql_dbg(ql_dbg_init, vha, 0x0042,
4785 "Disabled MSI-X.\n");
4786 } else {
4787 free_irq(pci_irq_vector(ha->pdev, 0), rsp);
4788 }
4789
4790 free_irqs:
4791 pci_free_irq_vectors(ha->pdev);
4792 }
4793
4794 int qla25xx_request_irq(struct qla_hw_data *ha, struct qla_qpair *qpair,
4795 struct qla_msix_entry *msix, int vector_type)
4796 {
4797 const struct qla_init_msix_entry *intr = &msix_entries[vector_type];
4798 scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
4799 int ret;
4800
4801 scnprintf(msix->name, sizeof(msix->name),
4802 "qla2xxx%lu_qpair%d", vha->host_no, qpair->id);
4803 ret = request_irq(msix->vector, intr->handler, 0, msix->name, qpair);
4804 if (ret) {
4805 ql_log(ql_log_fatal, vha, 0x00e6,
4806 "MSI-X: Unable to register handler -- %x/%d.\n",
4807 msix->vector, ret);
4808 return ret;
4809 }
4810 msix->have_irq = 1;
4811 msix->handle = qpair;
4812 qla_mapq_init_qp_cpu_map(ha, msix, qpair);
4813 return ret;
4814 }
Kernel DRM miscellaneous fixes and cross-tree changes