?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
close_port, kpacket_gen kmalloc oom, formard.c wake_sender/skb receive oom handling...
[cor_2_6_31.git] / drivers / scsi / qla2xxx / qla_isr.c
blob245e7afb4c4dcf897c54029f8a3940408a2a4fbe
1 /*
2 * QLogic Fibre Channel HBA Driver
3 * Copyright (c) 2003-2008 QLogic Corporation
4 *
5 * See LICENSE.qla2xxx for copyright and licensing details.
6 */
7 #include "qla_def.h"
8
9 #include <linux/delay.h>
10 #include <scsi/scsi_tcq.h>
11
12 static void qla2x00_mbx_completion(scsi_qla_host_t *, uint16_t);
13 static void qla2x00_process_completed_request(struct scsi_qla_host *,
14 struct req_que *, uint32_t);
15 static void qla2x00_status_entry(scsi_qla_host_t *, struct rsp_que *, void *);
16 static void qla2x00_status_cont_entry(struct rsp_que *, sts_cont_entry_t *);
17 static void qla2x00_error_entry(scsi_qla_host_t *, struct rsp_que *,
18 sts_entry_t *);
19
20 /**
21 * qla2100_intr_handler() - Process interrupts for the ISP2100 and ISP2200.
22 * @irq:
23 * @dev_id: SCSI driver HA context
24 *
25 * Called by system whenever the host adapter generates an interrupt.
26 *
27 * Returns handled flag.
28 */
29 irqreturn_t
30 qla2100_intr_handler(int irq, void *dev_id)
31 {
32 scsi_qla_host_t *vha;
33 struct qla_hw_data *ha;
34 struct device_reg_2xxx __iomem *reg;
35 int status;
36 unsigned long iter;
37 uint16_t hccr;
38 uint16_t mb[4];
39 struct rsp_que *rsp;
40 unsigned long flags;
41
42 rsp = (struct rsp_que *) dev_id;
43 if (!rsp) {
44 printk(KERN_INFO
45 "%s(): NULL response queue pointer\n", __func__);
46 return (IRQ_NONE);
47 }
48
49 ha = rsp->hw;
50 reg = &ha->iobase->isp;
51 status = 0;
52
53 spin_lock_irqsave(&ha->hardware_lock, flags);
54 vha = pci_get_drvdata(ha->pdev);
55 for (iter = 50; iter--; ) {
56 hccr = RD_REG_WORD(&reg->hccr);
57 if (hccr & HCCR_RISC_PAUSE) {
58 if (pci_channel_offline(ha->pdev))
59 break;
60
61 /*
62 * Issue a "HARD" reset in order for the RISC interrupt
63 * bit to be cleared. Schedule a big hammmer to get
64 * out of the RISC PAUSED state.
65 */
66 WRT_REG_WORD(&reg->hccr, HCCR_RESET_RISC);
67 RD_REG_WORD(&reg->hccr);
68
69 ha->isp_ops->fw_dump(vha, 1);
70 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
71 break;
72 } else if ((RD_REG_WORD(&reg->istatus) & ISR_RISC_INT) == 0)
73 break;
74
75 if (RD_REG_WORD(&reg->semaphore) & BIT_0) {
76 WRT_REG_WORD(&reg->hccr, HCCR_CLR_RISC_INT);
77 RD_REG_WORD(&reg->hccr);
78
79 /* Get mailbox data. */
80 mb[0] = RD_MAILBOX_REG(ha, reg, 0);
81 if (mb[0] > 0x3fff && mb[0] < 0x8000) {
82 qla2x00_mbx_completion(vha, mb[0]);
83 status |= MBX_INTERRUPT;
84 } else if (mb[0] > 0x7fff && mb[0] < 0xc000) {
85 mb[1] = RD_MAILBOX_REG(ha, reg, 1);
86 mb[2] = RD_MAILBOX_REG(ha, reg, 2);
87 mb[3] = RD_MAILBOX_REG(ha, reg, 3);
88 qla2x00_async_event(vha, rsp, mb);
89 } else {
90 /*EMPTY*/
91 DEBUG2(printk("scsi(%ld): Unrecognized "
92 "interrupt type (%d).\n",
93 vha->host_no, mb[0]));
94 }
95 /* Release mailbox registers. */
96 WRT_REG_WORD(&reg->semaphore, 0);
97 RD_REG_WORD(&reg->semaphore);
98 } else {
99 qla2x00_process_response_queue(rsp);
100
101 WRT_REG_WORD(&reg->hccr, HCCR_CLR_RISC_INT);
102 RD_REG_WORD(&reg->hccr);
103 }
104 }
105 spin_unlock_irqrestore(&ha->hardware_lock, flags);
106
107 if (test_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags) &&
108 (status & MBX_INTERRUPT) && ha->flags.mbox_int) {
109 set_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
110 complete(&ha->mbx_intr_comp);
111 }
112
113 return (IRQ_HANDLED);
114 }
115
116 /**
117 * qla2300_intr_handler() - Process interrupts for the ISP23xx and ISP63xx.
118 * @irq:
119 * @dev_id: SCSI driver HA context
120 *
121 * Called by system whenever the host adapter generates an interrupt.
122 *
123 * Returns handled flag.
124 */
125 irqreturn_t
126 qla2300_intr_handler(int irq, void *dev_id)
127 {
128 scsi_qla_host_t *vha;
129 struct device_reg_2xxx __iomem *reg;
130 int status;
131 unsigned long iter;
132 uint32_t stat;
133 uint16_t hccr;
134 uint16_t mb[4];
135 struct rsp_que *rsp;
136 struct qla_hw_data *ha;
137 unsigned long flags;
138
139 rsp = (struct rsp_que *) dev_id;
140 if (!rsp) {
141 printk(KERN_INFO
142 "%s(): NULL response queue pointer\n", __func__);
143 return (IRQ_NONE);
144 }
145
146 ha = rsp->hw;
147 reg = &ha->iobase->isp;
148 status = 0;
149
150 spin_lock_irqsave(&ha->hardware_lock, flags);
151 vha = pci_get_drvdata(ha->pdev);
152 for (iter = 50; iter--; ) {
153 stat = RD_REG_DWORD(&reg->u.isp2300.host_status);
154 if (stat & HSR_RISC_PAUSED) {
155 if (pci_channel_offline(ha->pdev))
156 break;
157
158 hccr = RD_REG_WORD(&reg->hccr);
159 if (hccr & (BIT_15 | BIT_13 | BIT_11 | BIT_8))
160 qla_printk(KERN_INFO, ha, "Parity error -- "
161 "HCCR=%x, Dumping firmware!\n", hccr);
162 else
163 qla_printk(KERN_INFO, ha, "RISC paused -- "
164 "HCCR=%x, Dumping firmware!\n", hccr);
165
166 /*
167 * Issue a "HARD" reset in order for the RISC
168 * interrupt bit to be cleared. Schedule a big
169 * hammmer to get out of the RISC PAUSED state.
170 */
171 WRT_REG_WORD(&reg->hccr, HCCR_RESET_RISC);
172 RD_REG_WORD(&reg->hccr);
173
174 ha->isp_ops->fw_dump(vha, 1);
175 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
176 break;
177 } else if ((stat & HSR_RISC_INT) == 0)
178 break;
179
180 switch (stat & 0xff) {
181 case 0x1:
182 case 0x2:
183 case 0x10:
184 case 0x11:
185 qla2x00_mbx_completion(vha, MSW(stat));
186 status |= MBX_INTERRUPT;
187
188 /* Release mailbox registers. */
189 WRT_REG_WORD(&reg->semaphore, 0);
190 break;
191 case 0x12:
192 mb[0] = MSW(stat);
193 mb[1] = RD_MAILBOX_REG(ha, reg, 1);
194 mb[2] = RD_MAILBOX_REG(ha, reg, 2);
195 mb[3] = RD_MAILBOX_REG(ha, reg, 3);
196 qla2x00_async_event(vha, rsp, mb);
197 break;
198 case 0x13:
199 qla2x00_process_response_queue(rsp);
200 break;
201 case 0x15:
202 mb[0] = MBA_CMPLT_1_16BIT;
203 mb[1] = MSW(stat);
204 qla2x00_async_event(vha, rsp, mb);
205 break;
206 case 0x16:
207 mb[0] = MBA_SCSI_COMPLETION;
208 mb[1] = MSW(stat);
209 mb[2] = RD_MAILBOX_REG(ha, reg, 2);
210 qla2x00_async_event(vha, rsp, mb);
211 break;
212 default:
213 DEBUG2(printk("scsi(%ld): Unrecognized interrupt type "
214 "(%d).\n",
215 vha->host_no, stat & 0xff));
216 break;
217 }
218 WRT_REG_WORD(&reg->hccr, HCCR_CLR_RISC_INT);
219 RD_REG_WORD_RELAXED(&reg->hccr);
220 }
221 spin_unlock_irqrestore(&ha->hardware_lock, flags);
222
223 if (test_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags) &&
224 (status & MBX_INTERRUPT) && ha->flags.mbox_int) {
225 set_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
226 complete(&ha->mbx_intr_comp);
227 }
228
229 return (IRQ_HANDLED);
230 }
231
232 /**
233 * qla2x00_mbx_completion() - Process mailbox command completions.
234 * @ha: SCSI driver HA context
235 * @mb0: Mailbox0 register
236 */
237 static void
238 qla2x00_mbx_completion(scsi_qla_host_t *vha, uint16_t mb0)
239 {
240 uint16_t cnt;
241 uint16_t __iomem *wptr;
242 struct qla_hw_data *ha = vha->hw;
243 struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
244
245 /* Load return mailbox registers. */
246 ha->flags.mbox_int = 1;
247 ha->mailbox_out[0] = mb0;
248 wptr = (uint16_t __iomem *)MAILBOX_REG(ha, reg, 1);
249
250 for (cnt = 1; cnt < ha->mbx_count; cnt++) {
251 if (IS_QLA2200(ha) && cnt == 8)
252 wptr = (uint16_t __iomem *)MAILBOX_REG(ha, reg, 8);
253 if (cnt == 4 || cnt == 5)
254 ha->mailbox_out[cnt] = qla2x00_debounce_register(wptr);
255 else
256 ha->mailbox_out[cnt] = RD_REG_WORD(wptr);
257
258 wptr++;
259 }
260
261 if (ha->mcp) {
262 DEBUG3(printk("%s(%ld): Got mailbox completion. cmd=%x.\n",
263 __func__, vha->host_no, ha->mcp->mb[0]));
264 } else {
265 DEBUG2_3(printk("%s(%ld): MBX pointer ERROR!\n",
266 __func__, vha->host_no));
267 }
268 }
269
270 static void
271 qla81xx_idc_event(scsi_qla_host_t *vha, uint16_t aen, uint16_t descr)
272 {
273 static char *event[] =
274 { "Complete", "Request Notification", "Time Extension" };
275 int rval;
276 struct device_reg_24xx __iomem *reg24 = &vha->hw->iobase->isp24;
277 uint16_t __iomem *wptr;
278 uint16_t cnt, timeout, mb[QLA_IDC_ACK_REGS];
279
280 /* Seed data -- mailbox1 -> mailbox7. */
281 wptr = (uint16_t __iomem *)&reg24->mailbox1;
282 for (cnt = 0; cnt < QLA_IDC_ACK_REGS; cnt++, wptr++)
283 mb[cnt] = RD_REG_WORD(wptr);
284
285 DEBUG2(printk("scsi(%ld): Inter-Driver Commucation %s -- "
286 "%04x %04x %04x %04x %04x %04x %04x.\n", vha->host_no,
287 event[aen & 0xff],
288 mb[0], mb[1], mb[2], mb[3], mb[4], mb[5], mb[6]));
289
290 /* Acknowledgement needed? [Notify && non-zero timeout]. */
291 timeout = (descr >> 8) & 0xf;
292 if (aen != MBA_IDC_NOTIFY || !timeout)
293 return;
294
295 DEBUG2(printk("scsi(%ld): Inter-Driver Commucation %s -- "
296 "ACK timeout=%d.\n", vha->host_no, event[aen & 0xff], timeout));
297
298 rval = qla2x00_post_idc_ack_work(vha, mb);
299 if (rval != QLA_SUCCESS)
300 qla_printk(KERN_WARNING, vha->hw,
301 "IDC failed to post ACK.\n");
302 }
303
304 /**
305 * qla2x00_async_event() - Process aynchronous events.
306 * @ha: SCSI driver HA context
307 * @mb: Mailbox registers (0 - 3)
308 */
309 void
310 qla2x00_async_event(scsi_qla_host_t *vha, struct rsp_que *rsp, uint16_t *mb)
311 {
312 #define LS_UNKNOWN 2
313 static char *link_speeds[] = { "1", "2", "?", "4", "8", "10" };
314 char *link_speed;
315 uint16_t handle_cnt;
316 uint16_t cnt;
317 uint32_t handles[5];
318 struct qla_hw_data *ha = vha->hw;
319 struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
320 uint32_t rscn_entry, host_pid;
321 uint8_t rscn_queue_index;
322 unsigned long flags;
323
324 /* Setup to process RIO completion. */
325 handle_cnt = 0;
326 if (IS_QLA81XX(ha))
327 goto skip_rio;
328 switch (mb[0]) {
329 case MBA_SCSI_COMPLETION:
330 handles[0] = le32_to_cpu((uint32_t)((mb[2] << 16) | mb[1]));
331 handle_cnt = 1;
332 break;
333 case MBA_CMPLT_1_16BIT:
334 handles[0] = mb[1];
335 handle_cnt = 1;
336 mb[0] = MBA_SCSI_COMPLETION;
337 break;
338 case MBA_CMPLT_2_16BIT:
339 handles[0] = mb[1];
340 handles[1] = mb[2];
341 handle_cnt = 2;
342 mb[0] = MBA_SCSI_COMPLETION;
343 break;
344 case MBA_CMPLT_3_16BIT:
345 handles[0] = mb[1];
346 handles[1] = mb[2];
347 handles[2] = mb[3];
348 handle_cnt = 3;
349 mb[0] = MBA_SCSI_COMPLETION;
350 break;
351 case MBA_CMPLT_4_16BIT:
352 handles[0] = mb[1];
353 handles[1] = mb[2];
354 handles[2] = mb[3];
355 handles[3] = (uint32_t)RD_MAILBOX_REG(ha, reg, 6);
356 handle_cnt = 4;
357 mb[0] = MBA_SCSI_COMPLETION;
358 break;
359 case MBA_CMPLT_5_16BIT:
360 handles[0] = mb[1];
361 handles[1] = mb[2];
362 handles[2] = mb[3];
363 handles[3] = (uint32_t)RD_MAILBOX_REG(ha, reg, 6);
364 handles[4] = (uint32_t)RD_MAILBOX_REG(ha, reg, 7);
365 handle_cnt = 5;
366 mb[0] = MBA_SCSI_COMPLETION;
367 break;
368 case MBA_CMPLT_2_32BIT:
369 handles[0] = le32_to_cpu((uint32_t)((mb[2] << 16) | mb[1]));
370 handles[1] = le32_to_cpu(
371 ((uint32_t)(RD_MAILBOX_REG(ha, reg, 7) << 16)) |
372 RD_MAILBOX_REG(ha, reg, 6));
373 handle_cnt = 2;
374 mb[0] = MBA_SCSI_COMPLETION;
375 break;
376 default:
377 break;
378 }
379 skip_rio:
380 switch (mb[0]) {
381 case MBA_SCSI_COMPLETION: /* Fast Post */
382 if (!vha->flags.online)
383 break;
384
385 for (cnt = 0; cnt < handle_cnt; cnt++)
386 qla2x00_process_completed_request(vha, rsp->req,
387 handles[cnt]);
388 break;
389
390 case MBA_RESET: /* Reset */
391 DEBUG2(printk("scsi(%ld): Asynchronous RESET.\n",
392 vha->host_no));
393
394 set_bit(RESET_MARKER_NEEDED, &vha->dpc_flags);
395 break;
396
397 case MBA_SYSTEM_ERR: /* System Error */
398 qla_printk(KERN_INFO, ha,
399 "ISP System Error - mbx1=%xh mbx2=%xh mbx3=%xh.\n",
400 mb[1], mb[2], mb[3]);
401
402 ha->isp_ops->fw_dump(vha, 1);
403
404 if (IS_FWI2_CAPABLE(ha)) {
405 if (mb[1] == 0 && mb[2] == 0) {
406 qla_printk(KERN_ERR, ha,
407 "Unrecoverable Hardware Error: adapter "
408 "marked OFFLINE!\n");
409 vha->flags.online = 0;
410 } else
411 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
412 } else if (mb[1] == 0) {
413 qla_printk(KERN_INFO, ha,
414 "Unrecoverable Hardware Error: adapter marked "
415 "OFFLINE!\n");
416 vha->flags.online = 0;
417 } else
418 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
419 break;
420
421 case MBA_REQ_TRANSFER_ERR: /* Request Transfer Error */
422 DEBUG2(printk("scsi(%ld): ISP Request Transfer Error.\n",
423 vha->host_no));
424 qla_printk(KERN_WARNING, ha, "ISP Request Transfer Error.\n");
425
426 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
427 break;
428
429 case MBA_RSP_TRANSFER_ERR: /* Response Transfer Error */
430 DEBUG2(printk("scsi(%ld): ISP Response Transfer Error.\n",
431 vha->host_no));
432 qla_printk(KERN_WARNING, ha, "ISP Response Transfer Error.\n");
433
434 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
435 break;
436
437 case MBA_WAKEUP_THRES: /* Request Queue Wake-up */
438 DEBUG2(printk("scsi(%ld): Asynchronous WAKEUP_THRES.\n",
439 vha->host_no));
440 break;
441
442 case MBA_LIP_OCCURRED: /* Loop Initialization Procedure */
443 DEBUG2(printk("scsi(%ld): LIP occurred (%x).\n", vha->host_no,
444 mb[1]));
445 qla_printk(KERN_INFO, ha, "LIP occurred (%x).\n", mb[1]);
446
447 if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
448 atomic_set(&vha->loop_state, LOOP_DOWN);
449 atomic_set(&vha->loop_down_timer, LOOP_DOWN_TIME);
450 qla2x00_mark_all_devices_lost(vha, 1);
451 }
452
453 if (vha->vp_idx) {
454 atomic_set(&vha->vp_state, VP_FAILED);
455 fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
456 }
457
458 set_bit(REGISTER_FC4_NEEDED, &vha->dpc_flags);
459 set_bit(REGISTER_FDMI_NEEDED, &vha->dpc_flags);
460
461 vha->flags.management_server_logged_in = 0;
462 qla2x00_post_aen_work(vha, FCH_EVT_LIP, mb[1]);
463 break;
464
465 case MBA_LOOP_UP: /* Loop Up Event */
466 if (IS_QLA2100(ha) || IS_QLA2200(ha)) {
467 link_speed = link_speeds[0];
468 ha->link_data_rate = PORT_SPEED_1GB;
469 } else {
470 link_speed = link_speeds[LS_UNKNOWN];
471 if (mb[1] < 5)
472 link_speed = link_speeds[mb[1]];
473 else if (mb[1] == 0x13)
474 link_speed = link_speeds[5];
475 ha->link_data_rate = mb[1];
476 }
477
478 DEBUG2(printk("scsi(%ld): Asynchronous LOOP UP (%s Gbps).\n",
479 vha->host_no, link_speed));
480 qla_printk(KERN_INFO, ha, "LOOP UP detected (%s Gbps).\n",
481 link_speed);
482
483 vha->flags.management_server_logged_in = 0;
484 qla2x00_post_aen_work(vha, FCH_EVT_LINKUP, ha->link_data_rate);
485 break;
486
487 case MBA_LOOP_DOWN: /* Loop Down Event */
488 DEBUG2(printk("scsi(%ld): Asynchronous LOOP DOWN "
489 "(%x %x %x).\n", vha->host_no, mb[1], mb[2], mb[3]));
490 qla_printk(KERN_INFO, ha, "LOOP DOWN detected (%x %x %x).\n",
491 mb[1], mb[2], mb[3]);
492
493 if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
494 atomic_set(&vha->loop_state, LOOP_DOWN);
495 atomic_set(&vha->loop_down_timer, LOOP_DOWN_TIME);
496 vha->device_flags |= DFLG_NO_CABLE;
497 qla2x00_mark_all_devices_lost(vha, 1);
498 }
499
500 if (vha->vp_idx) {
501 atomic_set(&vha->vp_state, VP_FAILED);
502 fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
503 }
504
505 vha->flags.management_server_logged_in = 0;
506 ha->link_data_rate = PORT_SPEED_UNKNOWN;
507 qla2x00_post_aen_work(vha, FCH_EVT_LINKDOWN, 0);
508 break;
509
510 case MBA_LIP_RESET: /* LIP reset occurred */
511 DEBUG2(printk("scsi(%ld): Asynchronous LIP RESET (%x).\n",
512 vha->host_no, mb[1]));
513 qla_printk(KERN_INFO, ha,
514 "LIP reset occurred (%x).\n", mb[1]);
515
516 if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
517 atomic_set(&vha->loop_state, LOOP_DOWN);
518 atomic_set(&vha->loop_down_timer, LOOP_DOWN_TIME);
519 qla2x00_mark_all_devices_lost(vha, 1);
520 }
521
522 if (vha->vp_idx) {
523 atomic_set(&vha->vp_state, VP_FAILED);
524 fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
525 }
526
527 set_bit(RESET_MARKER_NEEDED, &vha->dpc_flags);
528
529 ha->operating_mode = LOOP;
530 vha->flags.management_server_logged_in = 0;
531 qla2x00_post_aen_work(vha, FCH_EVT_LIPRESET, mb[1]);
532 break;
533
534 /* case MBA_DCBX_COMPLETE: */
535 case MBA_POINT_TO_POINT: /* Point-to-Point */
536 if (IS_QLA2100(ha))
537 break;
538
539 if (IS_QLA81XX(ha))
540 DEBUG2(printk("scsi(%ld): DCBX Completed -- %04x %04x "
541 "%04x\n", vha->host_no, mb[1], mb[2], mb[3]));
542 else
543 DEBUG2(printk("scsi(%ld): Asynchronous P2P MODE "
544 "received.\n", vha->host_no));
545
546 /*
547 * Until there's a transition from loop down to loop up, treat
548 * this as loop down only.
549 */
550 if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
551 atomic_set(&vha->loop_state, LOOP_DOWN);
552 if (!atomic_read(&vha->loop_down_timer))
553 atomic_set(&vha->loop_down_timer,
554 LOOP_DOWN_TIME);
555 qla2x00_mark_all_devices_lost(vha, 1);
556 }
557
558 if (vha->vp_idx) {
559 atomic_set(&vha->vp_state, VP_FAILED);
560 fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
561 }
562
563 if (!(test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags)))
564 set_bit(RESET_MARKER_NEEDED, &vha->dpc_flags);
565
566 set_bit(REGISTER_FC4_NEEDED, &vha->dpc_flags);
567 set_bit(REGISTER_FDMI_NEEDED, &vha->dpc_flags);
568
569 ha->flags.gpsc_supported = 1;
570 vha->flags.management_server_logged_in = 0;
571 break;
572
573 case MBA_CHG_IN_CONNECTION: /* Change in connection mode */
574 if (IS_QLA2100(ha))
575 break;
576
577 DEBUG2(printk("scsi(%ld): Asynchronous Change In Connection "
578 "received.\n",
579 vha->host_no));
580 qla_printk(KERN_INFO, ha,
581 "Configuration change detected: value=%x.\n", mb[1]);
582
583 if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
584 atomic_set(&vha->loop_state, LOOP_DOWN);
585 if (!atomic_read(&vha->loop_down_timer))
586 atomic_set(&vha->loop_down_timer,
587 LOOP_DOWN_TIME);
588 qla2x00_mark_all_devices_lost(vha, 1);
589 }
590
591 if (vha->vp_idx) {
592 atomic_set(&vha->vp_state, VP_FAILED);
593 fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
594 }
595
596 set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
597 set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
598 break;
599
600 case MBA_PORT_UPDATE: /* Port database update */
601 /* Only handle SCNs for our Vport index. */
602 if (vha->vp_idx && vha->vp_idx != (mb[3] & 0xff))
603 break;
604
605 /*
606 * If PORT UPDATE is global (received LIP_OCCURRED/LIP_RESET
607 * event etc. earlier indicating loop is down) then process
608 * it. Otherwise ignore it and Wait for RSCN to come in.
609 */
610 atomic_set(&vha->loop_down_timer, 0);
611 if (atomic_read(&vha->loop_state) != LOOP_DOWN &&
612 atomic_read(&vha->loop_state) != LOOP_DEAD) {
613 DEBUG2(printk("scsi(%ld): Asynchronous PORT UPDATE "
614 "ignored %04x/%04x/%04x.\n", vha->host_no, mb[1],
615 mb[2], mb[3]));
616 break;
617 }
618
619 DEBUG2(printk("scsi(%ld): Asynchronous PORT UPDATE.\n",
620 vha->host_no));
621 DEBUG(printk(KERN_INFO
622 "scsi(%ld): Port database changed %04x %04x %04x.\n",
623 vha->host_no, mb[1], mb[2], mb[3]));
624
625 /*
626 * Mark all devices as missing so we will login again.
627 */
628 atomic_set(&vha->loop_state, LOOP_UP);
629
630 qla2x00_mark_all_devices_lost(vha, 1);
631
632 vha->flags.rscn_queue_overflow = 1;
633
634 set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
635 set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
636 break;
637
638 case MBA_RSCN_UPDATE: /* State Change Registration */
639 /* Check if the Vport has issued a SCR */
640 if (vha->vp_idx && test_bit(VP_SCR_NEEDED, &vha->vp_flags))
641 break;
642 /* Only handle SCNs for our Vport index. */
643 if (vha->vp_idx && vha->vp_idx != (mb[3] & 0xff))
644 break;
645 DEBUG2(printk("scsi(%ld): Asynchronous RSCR UPDATE.\n",
646 vha->host_no));
647 DEBUG(printk(KERN_INFO
648 "scsi(%ld): RSCN database changed -- %04x %04x %04x.\n",
649 vha->host_no, mb[1], mb[2], mb[3]));
650
651 rscn_entry = ((mb[1] & 0xff) << 16) | mb[2];
652 host_pid = (vha->d_id.b.domain << 16) | (vha->d_id.b.area << 8)
653 | vha->d_id.b.al_pa;
654 if (rscn_entry == host_pid) {
655 DEBUG(printk(KERN_INFO
656 "scsi(%ld): Ignoring RSCN update to local host "
657 "port ID (%06x)\n",
658 vha->host_no, host_pid));
659 break;
660 }
661
662 /* Ignore reserved bits from RSCN-payload. */
663 rscn_entry = ((mb[1] & 0x3ff) << 16) | mb[2];
664 rscn_queue_index = vha->rscn_in_ptr + 1;
665 if (rscn_queue_index == MAX_RSCN_COUNT)
666 rscn_queue_index = 0;
667 if (rscn_queue_index != vha->rscn_out_ptr) {
668 vha->rscn_queue[vha->rscn_in_ptr] = rscn_entry;
669 vha->rscn_in_ptr = rscn_queue_index;
670 } else {
671 vha->flags.rscn_queue_overflow = 1;
672 }
673
674 atomic_set(&vha->loop_state, LOOP_UPDATE);
675 atomic_set(&vha->loop_down_timer, 0);
676 vha->flags.management_server_logged_in = 0;
677
678 set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
679 set_bit(RSCN_UPDATE, &vha->dpc_flags);
680 qla2x00_post_aen_work(vha, FCH_EVT_RSCN, rscn_entry);
681 break;
682
683 /* case MBA_RIO_RESPONSE: */
684 case MBA_ZIO_RESPONSE:
685 DEBUG3(printk("scsi(%ld): [R|Z]IO update completion.\n",
686 vha->host_no));
687
688 if (IS_FWI2_CAPABLE(ha))
689 qla24xx_process_response_queue(vha, rsp);
690 else
691 qla2x00_process_response_queue(rsp);
692 break;
693
694 case MBA_DISCARD_RND_FRAME:
695 DEBUG2(printk("scsi(%ld): Discard RND Frame -- %04x %04x "
696 "%04x.\n", vha->host_no, mb[1], mb[2], mb[3]));
697 break;
698
699 case MBA_TRACE_NOTIFICATION:
700 DEBUG2(printk("scsi(%ld): Trace Notification -- %04x %04x.\n",
701 vha->host_no, mb[1], mb[2]));
702 break;
703
704 case MBA_ISP84XX_ALERT:
705 DEBUG2(printk("scsi(%ld): ISP84XX Alert Notification -- "
706 "%04x %04x %04x\n", vha->host_no, mb[1], mb[2], mb[3]));
707
708 spin_lock_irqsave(&ha->cs84xx->access_lock, flags);
709 switch (mb[1]) {
710 case A84_PANIC_RECOVERY:
711 qla_printk(KERN_INFO, ha, "Alert 84XX: panic recovery "
712 "%04x %04x\n", mb[2], mb[3]);
713 break;
714 case A84_OP_LOGIN_COMPLETE:
715 ha->cs84xx->op_fw_version = mb[3] << 16 | mb[2];
716 DEBUG2(qla_printk(KERN_INFO, ha, "Alert 84XX:"
717 "firmware version %x\n", ha->cs84xx->op_fw_version));
718 break;
719 case A84_DIAG_LOGIN_COMPLETE:
720 ha->cs84xx->diag_fw_version = mb[3] << 16 | mb[2];
721 DEBUG2(qla_printk(KERN_INFO, ha, "Alert 84XX:"
722 "diagnostic firmware version %x\n",
723 ha->cs84xx->diag_fw_version));
724 break;
725 case A84_GOLD_LOGIN_COMPLETE:
726 ha->cs84xx->diag_fw_version = mb[3] << 16 | mb[2];
727 ha->cs84xx->fw_update = 1;
728 DEBUG2(qla_printk(KERN_INFO, ha, "Alert 84XX: gold "
729 "firmware version %x\n",
730 ha->cs84xx->gold_fw_version));
731 break;
732 default:
733 qla_printk(KERN_ERR, ha,
734 "Alert 84xx: Invalid Alert %04x %04x %04x\n",
735 mb[1], mb[2], mb[3]);
736 }
737 spin_unlock_irqrestore(&ha->cs84xx->access_lock, flags);
738 break;
739 case MBA_DCBX_START:
740 DEBUG2(printk("scsi(%ld): DCBX Started -- %04x %04x %04x\n",
741 vha->host_no, mb[1], mb[2], mb[3]));
742 break;
743 case MBA_DCBX_PARAM_UPDATE:
744 DEBUG2(printk("scsi(%ld): DCBX Parameters Updated -- "
745 "%04x %04x %04x\n", vha->host_no, mb[1], mb[2], mb[3]));
746 break;
747 case MBA_FCF_CONF_ERR:
748 DEBUG2(printk("scsi(%ld): FCF Configuration Error -- "
749 "%04x %04x %04x\n", vha->host_no, mb[1], mb[2], mb[3]));
750 break;
751 case MBA_IDC_COMPLETE:
752 case MBA_IDC_NOTIFY:
753 case MBA_IDC_TIME_EXT:
754 qla81xx_idc_event(vha, mb[0], mb[1]);
755 break;
756 }
757
758 if (!vha->vp_idx && ha->num_vhosts)
759 qla2x00_alert_all_vps(rsp, mb);
760 }
761
762 static void
763 qla2x00_adjust_sdev_qdepth_up(struct scsi_device *sdev, void *data)
764 {
765 fc_port_t *fcport = data;
766 struct scsi_qla_host *vha = fcport->vha;
767 struct qla_hw_data *ha = vha->hw;
768 struct req_que *req = NULL;
769
770 if (!ql2xqfulltracking)
771 return;
772
773 req = vha->req;
774 if (!req)
775 return;
776 if (req->max_q_depth <= sdev->queue_depth)
777 return;
778
779 if (sdev->ordered_tags)
780 scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG,
781 sdev->queue_depth + 1);
782 else
783 scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG,
784 sdev->queue_depth + 1);
785
786 fcport->last_ramp_up = jiffies;
787
788 DEBUG2(qla_printk(KERN_INFO, ha,
789 "scsi(%ld:%d:%d:%d): Queue depth adjusted-up to %d.\n",
790 fcport->vha->host_no, sdev->channel, sdev->id, sdev->lun,
791 sdev->queue_depth));
792 }
793
794 static void
795 qla2x00_adjust_sdev_qdepth_down(struct scsi_device *sdev, void *data)
796 {
797 fc_port_t *fcport = data;
798
799 if (!scsi_track_queue_full(sdev, sdev->queue_depth - 1))
800 return;
801
802 DEBUG2(qla_printk(KERN_INFO, fcport->vha->hw,
803 "scsi(%ld:%d:%d:%d): Queue depth adjusted-down to %d.\n",
804 fcport->vha->host_no, sdev->channel, sdev->id, sdev->lun,
805 sdev->queue_depth));
806 }
807
808 static inline void
809 qla2x00_ramp_up_queue_depth(scsi_qla_host_t *vha, struct req_que *req,
810 srb_t *sp)
811 {
812 fc_port_t *fcport;
813 struct scsi_device *sdev;
814
815 if (!ql2xqfulltracking)
816 return;
817
818 sdev = sp->cmd->device;
819 if (sdev->queue_depth >= req->max_q_depth)
820 return;
821
822 fcport = sp->fcport;
823 if (time_before(jiffies,
824 fcport->last_ramp_up + ql2xqfullrampup * HZ))
825 return;
826 if (time_before(jiffies,
827 fcport->last_queue_full + ql2xqfullrampup * HZ))
828 return;
829
830 starget_for_each_device(sdev->sdev_target, fcport,
831 qla2x00_adjust_sdev_qdepth_up);
832 }
833
834 /**
835 * qla2x00_process_completed_request() - Process a Fast Post response.
836 * @ha: SCSI driver HA context
837 * @index: SRB index
838 */
839 static void
840 qla2x00_process_completed_request(struct scsi_qla_host *vha,
841 struct req_que *req, uint32_t index)
842 {
843 srb_t *sp;
844 struct qla_hw_data *ha = vha->hw;
845
846 /* Validate handle. */
847 if (index >= MAX_OUTSTANDING_COMMANDS) {
848 DEBUG2(printk("scsi(%ld): Invalid SCSI completion handle %d.\n",
849 vha->host_no, index));
850 qla_printk(KERN_WARNING, ha,
851 "Invalid SCSI completion handle %d.\n", index);
852
853 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
854 return;
855 }
856
857 sp = req->outstanding_cmds[index];
858 if (sp) {
859 /* Free outstanding command slot. */
860 req->outstanding_cmds[index] = NULL;
861
862 /* Save ISP completion status */
863 sp->cmd->result = DID_OK << 16;
864
865 qla2x00_ramp_up_queue_depth(vha, req, sp);
866 qla2x00_sp_compl(ha, sp);
867 } else {
868 DEBUG2(printk("scsi(%ld) Req:%d: Invalid ISP SCSI completion"
869 " handle(%d)\n", vha->host_no, req->id, index));
870 qla_printk(KERN_WARNING, ha,
871 "Invalid ISP SCSI completion handle\n");
872
873 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
874 }
875 }
876
877 /**
878 * qla2x00_process_response_queue() - Process response queue entries.
879 * @ha: SCSI driver HA context
880 */
881 void
882 qla2x00_process_response_queue(struct rsp_que *rsp)
883 {
884 struct scsi_qla_host *vha;
885 struct qla_hw_data *ha = rsp->hw;
886 struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
887 sts_entry_t *pkt;
888 uint16_t handle_cnt;
889 uint16_t cnt;
890
891 vha = pci_get_drvdata(ha->pdev);
892
893 if (!vha->flags.online)
894 return;
895
896 while (rsp->ring_ptr->signature != RESPONSE_PROCESSED) {
897 pkt = (sts_entry_t *)rsp->ring_ptr;
898
899 rsp->ring_index++;
900 if (rsp->ring_index == rsp->length) {
901 rsp->ring_index = 0;
902 rsp->ring_ptr = rsp->ring;
903 } else {
904 rsp->ring_ptr++;
905 }
906
907 if (pkt->entry_status != 0) {
908 DEBUG3(printk(KERN_INFO
909 "scsi(%ld): Process error entry.\n", vha->host_no));
910
911 qla2x00_error_entry(vha, rsp, pkt);
912 ((response_t *)pkt)->signature = RESPONSE_PROCESSED;
913 wmb();
914 continue;
915 }
916
917 switch (pkt->entry_type) {
918 case STATUS_TYPE:
919 qla2x00_status_entry(vha, rsp, pkt);
920 break;
921 case STATUS_TYPE_21:
922 handle_cnt = ((sts21_entry_t *)pkt)->handle_count;
923 for (cnt = 0; cnt < handle_cnt; cnt++) {
924 qla2x00_process_completed_request(vha, rsp->req,
925 ((sts21_entry_t *)pkt)->handle[cnt]);
926 }
927 break;
928 case STATUS_TYPE_22:
929 handle_cnt = ((sts22_entry_t *)pkt)->handle_count;
930 for (cnt = 0; cnt < handle_cnt; cnt++) {
931 qla2x00_process_completed_request(vha, rsp->req,
932 ((sts22_entry_t *)pkt)->handle[cnt]);
933 }
934 break;
935 case STATUS_CONT_TYPE:
936 qla2x00_status_cont_entry(rsp, (sts_cont_entry_t *)pkt);
937 break;
938 default:
939 /* Type Not Supported. */
940 DEBUG4(printk(KERN_WARNING
941 "scsi(%ld): Received unknown response pkt type %x "
942 "entry status=%x.\n",
943 vha->host_no, pkt->entry_type, pkt->entry_status));
944 break;
945 }
946 ((response_t *)pkt)->signature = RESPONSE_PROCESSED;
947 wmb();
948 }
949
950 /* Adjust ring index */
951 WRT_REG_WORD(ISP_RSP_Q_OUT(ha, reg), rsp->ring_index);
952 }
953
954 static inline void
955 qla2x00_handle_sense(srb_t *sp, uint8_t *sense_data, uint32_t sense_len,
956 struct rsp_que *rsp)
957 {
958 struct scsi_cmnd *cp = sp->cmd;
959
960 if (sense_len >= SCSI_SENSE_BUFFERSIZE)
961 sense_len = SCSI_SENSE_BUFFERSIZE;
962
963 sp->request_sense_length = sense_len;
964 sp->request_sense_ptr = cp->sense_buffer;
965 if (sp->request_sense_length > 32)
966 sense_len = 32;
967
968 memcpy(cp->sense_buffer, sense_data, sense_len);
969
970 sp->request_sense_ptr += sense_len;
971 sp->request_sense_length -= sense_len;
972 if (sp->request_sense_length != 0)
973 rsp->status_srb = sp;
974
975 DEBUG5(printk("%s(): Check condition Sense data, scsi(%ld:%d:%d:%d) "
976 "cmd=%p pid=%ld\n", __func__, sp->fcport->vha->host_no,
977 cp->device->channel, cp->device->id, cp->device->lun, cp,
978 cp->serial_number));
979 if (sense_len)
980 DEBUG5(qla2x00_dump_buffer(cp->sense_buffer, sense_len));
981 }
982
983 /**
984 * qla2x00_status_entry() - Process a Status IOCB entry.
985 * @ha: SCSI driver HA context
986 * @pkt: Entry pointer
987 */
988 static void
989 qla2x00_status_entry(scsi_qla_host_t *vha, struct rsp_que *rsp, void *pkt)
990 {
991 srb_t *sp;
992 fc_port_t *fcport;
993 struct scsi_cmnd *cp;
994 sts_entry_t *sts;
995 struct sts_entry_24xx *sts24;
996 uint16_t comp_status;
997 uint16_t scsi_status;
998 uint8_t lscsi_status;
999 int32_t resid;
1000 uint32_t sense_len, rsp_info_len, resid_len, fw_resid_len;
1001 uint8_t *rsp_info, *sense_data;
1002 struct qla_hw_data *ha = vha->hw;
1003 uint32_t handle;
1004 uint16_t que;
1005 struct req_que *req;
1006
1007 sts = (sts_entry_t *) pkt;
1008 sts24 = (struct sts_entry_24xx *) pkt;
1009 if (IS_FWI2_CAPABLE(ha)) {
1010 comp_status = le16_to_cpu(sts24->comp_status);
1011 scsi_status = le16_to_cpu(sts24->scsi_status) & SS_MASK;
1012 } else {
1013 comp_status = le16_to_cpu(sts->comp_status);
1014 scsi_status = le16_to_cpu(sts->scsi_status) & SS_MASK;
1015 }
1016 handle = (uint32_t) LSW(sts->handle);
1017 que = MSW(sts->handle);
1018 req = ha->req_q_map[que];
1019 /* Fast path completion. */
1020 if (comp_status == CS_COMPLETE && scsi_status == 0) {
1021 qla2x00_process_completed_request(vha, req, handle);
1022
1023 return;
1024 }
1025
1026 /* Validate handle. */
1027 if (handle < MAX_OUTSTANDING_COMMANDS) {
1028 sp = req->outstanding_cmds[handle];
1029 req->outstanding_cmds[handle] = NULL;
1030 } else
1031 sp = NULL;
1032
1033 if (sp == NULL) {
1034 DEBUG2(printk("scsi(%ld): Status Entry invalid handle.\n",
1035 vha->host_no));
1036 qla_printk(KERN_WARNING, ha, "Status Entry invalid handle.\n");
1037
1038 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
1039 qla2xxx_wake_dpc(vha);
1040 return;
1041 }
1042 cp = sp->cmd;
1043 if (cp == NULL) {
1044 DEBUG2(printk("scsi(%ld): Command already returned back to OS "
1045 "pkt->handle=%d sp=%p.\n", vha->host_no, handle, sp));
1046 qla_printk(KERN_WARNING, ha,
1047 "Command is NULL: already returned to OS (sp=%p)\n", sp);
1048
1049 return;
1050 }
1051
1052 lscsi_status = scsi_status & STATUS_MASK;
1053
1054 fcport = sp->fcport;
1055
1056 sense_len = rsp_info_len = resid_len = fw_resid_len = 0;
1057 if (IS_FWI2_CAPABLE(ha)) {
1058 sense_len = le32_to_cpu(sts24->sense_len);
1059 rsp_info_len = le32_to_cpu(sts24->rsp_data_len);
1060 resid_len = le32_to_cpu(sts24->rsp_residual_count);
1061 fw_resid_len = le32_to_cpu(sts24->residual_len);
1062 rsp_info = sts24->data;
1063 sense_data = sts24->data;
1064 host_to_fcp_swap(sts24->data, sizeof(sts24->data));
1065 } else {
1066 sense_len = le16_to_cpu(sts->req_sense_length);
1067 rsp_info_len = le16_to_cpu(sts->rsp_info_len);
1068 resid_len = le32_to_cpu(sts->residual_length);
1069 rsp_info = sts->rsp_info;
1070 sense_data = sts->req_sense_data;
1071 }
1072
1073 /* Check for any FCP transport errors. */
1074 if (scsi_status & SS_RESPONSE_INFO_LEN_VALID) {
1075 /* Sense data lies beyond any FCP RESPONSE data. */
1076 if (IS_FWI2_CAPABLE(ha))
1077 sense_data += rsp_info_len;
1078 if (rsp_info_len > 3 && rsp_info[3]) {
1079 DEBUG2(printk("scsi(%ld:%d:%d:%d) FCP I/O protocol "
1080 "failure (%x/%02x%02x%02x%02x%02x%02x%02x%02x)..."
1081 "retrying command\n", vha->host_no,
1082 cp->device->channel, cp->device->id,
1083 cp->device->lun, rsp_info_len, rsp_info[0],
1084 rsp_info[1], rsp_info[2], rsp_info[3], rsp_info[4],
1085 rsp_info[5], rsp_info[6], rsp_info[7]));
1086
1087 cp->result = DID_BUS_BUSY << 16;
1088 qla2x00_sp_compl(ha, sp);
1089 return;
1090 }
1091 }
1092
1093 /* Check for overrun. */
1094 if (IS_FWI2_CAPABLE(ha) && comp_status == CS_COMPLETE &&
1095 scsi_status & SS_RESIDUAL_OVER)
1096 comp_status = CS_DATA_OVERRUN;
1097
1098 /*
1099 * Based on Host and scsi status generate status code for Linux
1100 */
1101 switch (comp_status) {
1102 case CS_COMPLETE:
1103 case CS_QUEUE_FULL:
1104 if (scsi_status == 0) {
1105 cp->result = DID_OK << 16;
1106 break;
1107 }
1108 if (scsi_status & (SS_RESIDUAL_UNDER | SS_RESIDUAL_OVER)) {
1109 resid = resid_len;
1110 scsi_set_resid(cp, resid);
1111
1112 if (!lscsi_status &&
1113 ((unsigned)(scsi_bufflen(cp) - resid) <
1114 cp->underflow)) {
1115 qla_printk(KERN_INFO, ha,
1116 "scsi(%ld:%d:%d:%d): Mid-layer underflow "
1117 "detected (%x of %x bytes)...returning "
1118 "error status.\n", vha->host_no,
1119 cp->device->channel, cp->device->id,
1120 cp->device->lun, resid,
1121 scsi_bufflen(cp));
1122
1123 cp->result = DID_ERROR << 16;
1124 break;
1125 }
1126 }
1127 cp->result = DID_OK << 16 | lscsi_status;
1128
1129 if (lscsi_status == SAM_STAT_TASK_SET_FULL) {
1130 DEBUG2(printk(KERN_INFO
1131 "scsi(%ld): QUEUE FULL status detected "
1132 "0x%x-0x%x.\n", vha->host_no, comp_status,
1133 scsi_status));
1134
1135 /* Adjust queue depth for all luns on the port. */
1136 if (!ql2xqfulltracking)
1137 break;
1138 fcport->last_queue_full = jiffies;
1139 starget_for_each_device(cp->device->sdev_target,
1140 fcport, qla2x00_adjust_sdev_qdepth_down);
1141 break;
1142 }
1143 if (lscsi_status != SS_CHECK_CONDITION)
1144 break;
1145
1146 memset(cp->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
1147 if (!(scsi_status & SS_SENSE_LEN_VALID))
1148 break;
1149
1150 qla2x00_handle_sense(sp, sense_data, sense_len, rsp);
1151 break;
1152
1153 case CS_DATA_UNDERRUN:
1154 resid = resid_len;
1155 /* Use F/W calculated residual length. */
1156 if (IS_FWI2_CAPABLE(ha)) {
1157 if (!(scsi_status & SS_RESIDUAL_UNDER)) {
1158 lscsi_status = 0;
1159 } else if (resid != fw_resid_len) {
1160 scsi_status &= ~SS_RESIDUAL_UNDER;
1161 lscsi_status = 0;
1162 }
1163 resid = fw_resid_len;
1164 }
1165
1166 if (scsi_status & SS_RESIDUAL_UNDER) {
1167 scsi_set_resid(cp, resid);
1168 } else {
1169 DEBUG2(printk(KERN_INFO
1170 "scsi(%ld:%d:%d) UNDERRUN status detected "
1171 "0x%x-0x%x. resid=0x%x fw_resid=0x%x cdb=0x%x "
1172 "os_underflow=0x%x\n", vha->host_no,
1173 cp->device->id, cp->device->lun, comp_status,
1174 scsi_status, resid_len, resid, cp->cmnd[0],
1175 cp->underflow));
1176
1177 }
1178
1179 /*
1180 * Check to see if SCSI Status is non zero. If so report SCSI
1181 * Status.
1182 */
1183 if (lscsi_status != 0) {
1184 cp->result = DID_OK << 16 | lscsi_status;
1185
1186 if (lscsi_status == SAM_STAT_TASK_SET_FULL) {
1187 DEBUG2(printk(KERN_INFO
1188 "scsi(%ld): QUEUE FULL status detected "
1189 "0x%x-0x%x.\n", vha->host_no, comp_status,
1190 scsi_status));
1191
1192 /*
1193 * Adjust queue depth for all luns on the
1194 * port.
1195 */
1196 if (!ql2xqfulltracking)
1197 break;
1198 fcport->last_queue_full = jiffies;
1199 starget_for_each_device(
1200 cp->device->sdev_target, fcport,
1201 qla2x00_adjust_sdev_qdepth_down);
1202 break;
1203 }
1204 if (lscsi_status != SS_CHECK_CONDITION)
1205 break;
1206
1207 memset(cp->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
1208 if (!(scsi_status & SS_SENSE_LEN_VALID))
1209 break;
1210
1211 qla2x00_handle_sense(sp, sense_data, sense_len, rsp);
1212 } else {
1213 /*
1214 * If RISC reports underrun and target does not report
1215 * it then we must have a lost frame, so tell upper
1216 * layer to retry it by reporting an error.
1217 */
1218 if (!(scsi_status & SS_RESIDUAL_UNDER)) {
1219 DEBUG2(printk("scsi(%ld:%d:%d:%d) Dropped "
1220 "frame(s) detected (%x of %x bytes)..."
1221 "retrying command.\n",
1222 vha->host_no, cp->device->channel,
1223 cp->device->id, cp->device->lun, resid,
1224 scsi_bufflen(cp)));
1225
1226 cp->result = DID_ERROR << 16;
1227 break;
1228 }
1229
1230 /* Handle mid-layer underflow */
1231 if ((unsigned)(scsi_bufflen(cp) - resid) <
1232 cp->underflow) {
1233 qla_printk(KERN_INFO, ha,
1234 "scsi(%ld:%d:%d:%d): Mid-layer underflow "
1235 "detected (%x of %x bytes)...returning "
1236 "error status.\n", vha->host_no,
1237 cp->device->channel, cp->device->id,
1238 cp->device->lun, resid,
1239 scsi_bufflen(cp));
1240
1241 cp->result = DID_ERROR << 16;
1242 break;
1243 }
1244
1245 /* Everybody online, looking good... */
1246 cp->result = DID_OK << 16;
1247 }
1248 break;
1249
1250 case CS_DATA_OVERRUN:
1251 DEBUG2(printk(KERN_INFO
1252 "scsi(%ld:%d:%d): OVERRUN status detected 0x%x-0x%x\n",
1253 vha->host_no, cp->device->id, cp->device->lun, comp_status,
1254 scsi_status));
1255 DEBUG2(printk(KERN_INFO
1256 "CDB: 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x\n",
1257 cp->cmnd[0], cp->cmnd[1], cp->cmnd[2], cp->cmnd[3],
1258 cp->cmnd[4], cp->cmnd[5]));
1259 DEBUG2(printk(KERN_INFO
1260 "PID=0x%lx req=0x%x xtra=0x%x -- returning DID_ERROR "
1261 "status!\n",
1262 cp->serial_number, scsi_bufflen(cp), resid_len));
1263
1264 cp->result = DID_ERROR << 16;
1265 break;
1266
1267 case CS_PORT_LOGGED_OUT:
1268 case CS_PORT_CONFIG_CHG:
1269 case CS_PORT_BUSY:
1270 case CS_INCOMPLETE:
1271 case CS_PORT_UNAVAILABLE:
1272 /*
1273 * If the port is in Target Down state, return all IOs for this
1274 * Target with DID_NO_CONNECT ELSE Queue the IOs in the
1275 * retry_queue.
1276 */
1277 DEBUG2(printk("scsi(%ld:%d:%d): status_entry: Port Down "
1278 "pid=%ld, compl status=0x%x, port state=0x%x\n",
1279 vha->host_no, cp->device->id, cp->device->lun,
1280 cp->serial_number, comp_status,
1281 atomic_read(&fcport->state)));
1282
1283 /*
1284 * We are going to have the fc class block the rport
1285 * while we try to recover so instruct the mid layer
1286 * to requeue until the class decides how to handle this.
1287 */
1288 cp->result = DID_TRANSPORT_DISRUPTED << 16;
1289 if (atomic_read(&fcport->state) == FCS_ONLINE)
1290 qla2x00_mark_device_lost(fcport->vha, fcport, 1, 1);
1291 break;
1292
1293 case CS_RESET:
1294 DEBUG2(printk(KERN_INFO
1295 "scsi(%ld): RESET status detected 0x%x-0x%x.\n",
1296 vha->host_no, comp_status, scsi_status));
1297
1298 cp->result = DID_RESET << 16;
1299 break;
1300
1301 case CS_ABORTED:
1302 /*
1303 * hv2.19.12 - DID_ABORT does not retry the request if we
1304 * aborted this request then abort otherwise it must be a
1305 * reset.
1306 */
1307 DEBUG2(printk(KERN_INFO
1308 "scsi(%ld): ABORT status detected 0x%x-0x%x.\n",
1309 vha->host_no, comp_status, scsi_status));
1310
1311 cp->result = DID_RESET << 16;
1312 break;
1313
1314 case CS_TIMEOUT:
1315 /*
1316 * We are going to have the fc class block the rport
1317 * while we try to recover so instruct the mid layer
1318 * to requeue until the class decides how to handle this.
1319 */
1320 cp->result = DID_TRANSPORT_DISRUPTED << 16;
1321
1322 if (IS_FWI2_CAPABLE(ha)) {
1323 DEBUG2(printk(KERN_INFO
1324 "scsi(%ld:%d:%d:%d): TIMEOUT status detected "
1325 "0x%x-0x%x\n", vha->host_no, cp->device->channel,
1326 cp->device->id, cp->device->lun, comp_status,
1327 scsi_status));
1328 break;
1329 }
1330 DEBUG2(printk(KERN_INFO
1331 "scsi(%ld:%d:%d:%d): TIMEOUT status detected 0x%x-0x%x "
1332 "sflags=%x.\n", vha->host_no, cp->device->channel,
1333 cp->device->id, cp->device->lun, comp_status, scsi_status,
1334 le16_to_cpu(sts->status_flags)));
1335
1336 /* Check to see if logout occurred. */
1337 if ((le16_to_cpu(sts->status_flags) & SF_LOGOUT_SENT))
1338 qla2x00_mark_device_lost(fcport->vha, fcport, 1, 1);
1339 break;
1340
1341 default:
1342 DEBUG3(printk("scsi(%ld): Error detected (unknown status) "
1343 "0x%x-0x%x.\n", vha->host_no, comp_status, scsi_status));
1344 qla_printk(KERN_INFO, ha,
1345 "Unknown status detected 0x%x-0x%x.\n",
1346 comp_status, scsi_status);
1347
1348 cp->result = DID_ERROR << 16;
1349 break;
1350 }
1351
1352 /* Place command on done queue. */
1353 if (rsp->status_srb == NULL)
1354 qla2x00_sp_compl(ha, sp);
1355 }
1356
1357 /**
1358 * qla2x00_status_cont_entry() - Process a Status Continuations entry.
1359 * @ha: SCSI driver HA context
1360 * @pkt: Entry pointer
1361 *
1362 * Extended sense data.
1363 */
1364 static void
1365 qla2x00_status_cont_entry(struct rsp_que *rsp, sts_cont_entry_t *pkt)
1366 {
1367 uint8_t sense_sz = 0;
1368 struct qla_hw_data *ha = rsp->hw;
1369 srb_t *sp = rsp->status_srb;
1370 struct scsi_cmnd *cp;
1371
1372 if (sp != NULL && sp->request_sense_length != 0) {
1373 cp = sp->cmd;
1374 if (cp == NULL) {
1375 DEBUG2(printk("%s(): Cmd already returned back to OS "
1376 "sp=%p.\n", __func__, sp));
1377 qla_printk(KERN_INFO, ha,
1378 "cmd is NULL: already returned to OS (sp=%p)\n",
1379 sp);
1380
1381 rsp->status_srb = NULL;
1382 return;
1383 }
1384
1385 if (sp->request_sense_length > sizeof(pkt->data)) {
1386 sense_sz = sizeof(pkt->data);
1387 } else {
1388 sense_sz = sp->request_sense_length;
1389 }
1390
1391 /* Move sense data. */
1392 if (IS_FWI2_CAPABLE(ha))
1393 host_to_fcp_swap(pkt->data, sizeof(pkt->data));
1394 memcpy(sp->request_sense_ptr, pkt->data, sense_sz);
1395 DEBUG5(qla2x00_dump_buffer(sp->request_sense_ptr, sense_sz));
1396
1397 sp->request_sense_ptr += sense_sz;
1398 sp->request_sense_length -= sense_sz;
1399
1400 /* Place command on done queue. */
1401 if (sp->request_sense_length == 0) {
1402 rsp->status_srb = NULL;
1403 qla2x00_sp_compl(ha, sp);
1404 }
1405 }
1406 }
1407
1408 /**
1409 * qla2x00_error_entry() - Process an error entry.
1410 * @ha: SCSI driver HA context
1411 * @pkt: Entry pointer
1412 */
1413 static void
1414 qla2x00_error_entry(scsi_qla_host_t *vha, struct rsp_que *rsp, sts_entry_t *pkt)
1415 {
1416 srb_t *sp;
1417 struct qla_hw_data *ha = vha->hw;
1418 uint32_t handle = LSW(pkt->handle);
1419 uint16_t que = MSW(pkt->handle);
1420 struct req_que *req = ha->req_q_map[que];
1421 #if defined(QL_DEBUG_LEVEL_2)
1422 if (pkt->entry_status & RF_INV_E_ORDER)
1423 qla_printk(KERN_ERR, ha, "%s: Invalid Entry Order\n", __func__);
1424 else if (pkt->entry_status & RF_INV_E_COUNT)
1425 qla_printk(KERN_ERR, ha, "%s: Invalid Entry Count\n", __func__);
1426 else if (pkt->entry_status & RF_INV_E_PARAM)
1427 qla_printk(KERN_ERR, ha,
1428 "%s: Invalid Entry Parameter\n", __func__);
1429 else if (pkt->entry_status & RF_INV_E_TYPE)
1430 qla_printk(KERN_ERR, ha, "%s: Invalid Entry Type\n", __func__);
1431 else if (pkt->entry_status & RF_BUSY)
1432 qla_printk(KERN_ERR, ha, "%s: Busy\n", __func__);
1433 else
1434 qla_printk(KERN_ERR, ha, "%s: UNKNOWN flag error\n", __func__);
1435 #endif
1436
1437 /* Validate handle. */
1438 if (handle < MAX_OUTSTANDING_COMMANDS)
1439 sp = req->outstanding_cmds[handle];
1440 else
1441 sp = NULL;
1442
1443 if (sp) {
1444 /* Free outstanding command slot. */
1445 req->outstanding_cmds[handle] = NULL;
1446
1447 /* Bad payload or header */
1448 if (pkt->entry_status &
1449 (RF_INV_E_ORDER | RF_INV_E_COUNT |
1450 RF_INV_E_PARAM | RF_INV_E_TYPE)) {
1451 sp->cmd->result = DID_ERROR << 16;
1452 } else if (pkt->entry_status & RF_BUSY) {
1453 sp->cmd->result = DID_BUS_BUSY << 16;
1454 } else {
1455 sp->cmd->result = DID_ERROR << 16;
1456 }
1457 qla2x00_sp_compl(ha, sp);
1458
1459 } else if (pkt->entry_type == COMMAND_A64_TYPE || pkt->entry_type ==
1460 COMMAND_TYPE || pkt->entry_type == COMMAND_TYPE_7) {
1461 DEBUG2(printk("scsi(%ld): Error entry - invalid handle\n",
1462 vha->host_no));
1463 qla_printk(KERN_WARNING, ha,
1464 "Error entry - invalid handle\n");
1465
1466 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
1467 qla2xxx_wake_dpc(vha);
1468 }
1469 }
1470
1471 /**
1472 * qla24xx_mbx_completion() - Process mailbox command completions.
1473 * @ha: SCSI driver HA context
1474 * @mb0: Mailbox0 register
1475 */
1476 static void
1477 qla24xx_mbx_completion(scsi_qla_host_t *vha, uint16_t mb0)
1478 {
1479 uint16_t cnt;
1480 uint16_t __iomem *wptr;
1481 struct qla_hw_data *ha = vha->hw;
1482 struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
1483
1484 /* Load return mailbox registers. */
1485 ha->flags.mbox_int = 1;
1486 ha->mailbox_out[0] = mb0;
1487 wptr = (uint16_t __iomem *)&reg->mailbox1;
1488
1489 for (cnt = 1; cnt < ha->mbx_count; cnt++) {
1490 ha->mailbox_out[cnt] = RD_REG_WORD(wptr);
1491 wptr++;
1492 }
1493
1494 if (ha->mcp) {
1495 DEBUG3(printk("%s(%ld): Got mailbox completion. cmd=%x.\n",
1496 __func__, vha->host_no, ha->mcp->mb[0]));
1497 } else {
1498 DEBUG2_3(printk("%s(%ld): MBX pointer ERROR!\n",
1499 __func__, vha->host_no));
1500 }
1501 }
1502
1503 /**
1504 * qla24xx_process_response_queue() - Process response queue entries.
1505 * @ha: SCSI driver HA context
1506 */
1507 void qla24xx_process_response_queue(struct scsi_qla_host *vha,
1508 struct rsp_que *rsp)
1509 {
1510 struct sts_entry_24xx *pkt;
1511
1512 if (!vha->flags.online)
1513 return;
1514
1515 while (rsp->ring_ptr->signature != RESPONSE_PROCESSED) {
1516 pkt = (struct sts_entry_24xx *)rsp->ring_ptr;
1517
1518 rsp->ring_index++;
1519 if (rsp->ring_index == rsp->length) {
1520 rsp->ring_index = 0;
1521 rsp->ring_ptr = rsp->ring;
1522 } else {
1523 rsp->ring_ptr++;
1524 }
1525
1526 if (pkt->entry_status != 0) {
1527 DEBUG3(printk(KERN_INFO
1528 "scsi(%ld): Process error entry.\n", vha->host_no));
1529
1530 qla2x00_error_entry(vha, rsp, (sts_entry_t *) pkt);
1531 ((response_t *)pkt)->signature = RESPONSE_PROCESSED;
1532 wmb();
1533 continue;
1534 }
1535
1536 switch (pkt->entry_type) {
1537 case STATUS_TYPE:
1538 qla2x00_status_entry(vha, rsp, pkt);
1539 break;
1540 case STATUS_CONT_TYPE:
1541 qla2x00_status_cont_entry(rsp, (sts_cont_entry_t *)pkt);
1542 break;
1543 case VP_RPT_ID_IOCB_TYPE:
1544 qla24xx_report_id_acquisition(vha,
1545 (struct vp_rpt_id_entry_24xx *)pkt);
1546 break;
1547 default:
1548 /* Type Not Supported. */
1549 DEBUG4(printk(KERN_WARNING
1550 "scsi(%ld): Received unknown response pkt type %x "
1551 "entry status=%x.\n",
1552 vha->host_no, pkt->entry_type, pkt->entry_status));
1553 break;
1554 }
1555 ((response_t *)pkt)->signature = RESPONSE_PROCESSED;
1556 wmb();
1557 }
1558
1559 /* Adjust ring index */
1560 WRT_REG_DWORD(rsp->rsp_q_out, rsp->ring_index);
1561 }
1562
1563 static void
1564 qla2xxx_check_risc_status(scsi_qla_host_t *vha)
1565 {
1566 int rval;
1567 uint32_t cnt;
1568 struct qla_hw_data *ha = vha->hw;
1569 struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
1570
1571 if (!IS_QLA25XX(ha) && !IS_QLA81XX(ha))
1572 return;
1573
1574 rval = QLA_SUCCESS;
1575 WRT_REG_DWORD(&reg->iobase_addr, 0x7C00);
1576 RD_REG_DWORD(&reg->iobase_addr);
1577 WRT_REG_DWORD(&reg->iobase_window, 0x0001);
1578 for (cnt = 10000; (RD_REG_DWORD(&reg->iobase_window) & BIT_0) == 0 &&
1579 rval == QLA_SUCCESS; cnt--) {
1580 if (cnt) {
1581 WRT_REG_DWORD(&reg->iobase_window, 0x0001);
1582 udelay(10);
1583 } else
1584 rval = QLA_FUNCTION_TIMEOUT;
1585 }
1586 if (rval == QLA_SUCCESS)
1587 goto next_test;
1588
1589 WRT_REG_DWORD(&reg->iobase_window, 0x0003);
1590 for (cnt = 100; (RD_REG_DWORD(&reg->iobase_window) & BIT_0) == 0 &&
1591 rval == QLA_SUCCESS; cnt--) {
1592 if (cnt) {
1593 WRT_REG_DWORD(&reg->iobase_window, 0x0003);
1594 udelay(10);
1595 } else
1596 rval = QLA_FUNCTION_TIMEOUT;
1597 }
1598 if (rval != QLA_SUCCESS)
1599 goto done;
1600
1601 next_test:
1602 if (RD_REG_DWORD(&reg->iobase_c8) & BIT_3)
1603 qla_printk(KERN_INFO, ha, "Additional code -- 0x55AA.\n");
1604
1605 done:
1606 WRT_REG_DWORD(&reg->iobase_window, 0x0000);
1607 RD_REG_DWORD(&reg->iobase_window);
1608 }
1609
1610 /**
1611 * qla24xx_intr_handler() - Process interrupts for the ISP23xx and ISP63xx.
1612 * @irq:
1613 * @dev_id: SCSI driver HA context
1614 *
1615 * Called by system whenever the host adapter generates an interrupt.
1616 *
1617 * Returns handled flag.
1618 */
1619 irqreturn_t
1620 qla24xx_intr_handler(int irq, void *dev_id)
1621 {
1622 scsi_qla_host_t *vha;
1623 struct qla_hw_data *ha;
1624 struct device_reg_24xx __iomem *reg;
1625 int status;
1626 unsigned long iter;
1627 uint32_t stat;
1628 uint32_t hccr;
1629 uint16_t mb[4];
1630 struct rsp_que *rsp;
1631 unsigned long flags;
1632
1633 rsp = (struct rsp_que *) dev_id;
1634 if (!rsp) {
1635 printk(KERN_INFO
1636 "%s(): NULL response queue pointer\n", __func__);
1637 return IRQ_NONE;
1638 }
1639
1640 ha = rsp->hw;
1641 reg = &ha->iobase->isp24;
1642 status = 0;
1643
1644 spin_lock_irqsave(&ha->hardware_lock, flags);
1645 vha = pci_get_drvdata(ha->pdev);
1646 for (iter = 50; iter--; ) {
1647 stat = RD_REG_DWORD(&reg->host_status);
1648 if (stat & HSRX_RISC_PAUSED) {
1649 if (pci_channel_offline(ha->pdev))
1650 break;
1651
1652 hccr = RD_REG_DWORD(&reg->hccr);
1653
1654 qla_printk(KERN_INFO, ha, "RISC paused -- HCCR=%x, "
1655 "Dumping firmware!\n", hccr);
1656
1657 qla2xxx_check_risc_status(vha);
1658
1659 ha->isp_ops->fw_dump(vha, 1);
1660 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
1661 break;
1662 } else if ((stat & HSRX_RISC_INT) == 0)
1663 break;
1664
1665 switch (stat & 0xff) {
1666 case 0x1:
1667 case 0x2:
1668 case 0x10:
1669 case 0x11:
1670 qla24xx_mbx_completion(vha, MSW(stat));
1671 status |= MBX_INTERRUPT;
1672
1673 break;
1674 case 0x12:
1675 mb[0] = MSW(stat);
1676 mb[1] = RD_REG_WORD(&reg->mailbox1);
1677 mb[2] = RD_REG_WORD(&reg->mailbox2);
1678 mb[3] = RD_REG_WORD(&reg->mailbox3);
1679 qla2x00_async_event(vha, rsp, mb);
1680 break;
1681 case 0x13:
1682 case 0x14:
1683 qla24xx_process_response_queue(vha, rsp);
1684 break;
1685 default:
1686 DEBUG2(printk("scsi(%ld): Unrecognized interrupt type "
1687 "(%d).\n",
1688 vha->host_no, stat & 0xff));
1689 break;
1690 }
1691 WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
1692 RD_REG_DWORD_RELAXED(&reg->hccr);
1693 }
1694 spin_unlock_irqrestore(&ha->hardware_lock, flags);
1695
1696 if (test_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags) &&
1697 (status & MBX_INTERRUPT) && ha->flags.mbox_int) {
1698 set_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
1699 complete(&ha->mbx_intr_comp);
1700 }
1701
1702 return IRQ_HANDLED;
1703 }
1704
1705 static irqreturn_t
1706 qla24xx_msix_rsp_q(int irq, void *dev_id)
1707 {
1708 struct qla_hw_data *ha;
1709 struct rsp_que *rsp;
1710 struct device_reg_24xx __iomem *reg;
1711 struct scsi_qla_host *vha;
1712
1713 rsp = (struct rsp_que *) dev_id;
1714 if (!rsp) {
1715 printk(KERN_INFO
1716 "%s(): NULL response queue pointer\n", __func__);
1717 return IRQ_NONE;
1718 }
1719 ha = rsp->hw;
1720 reg = &ha->iobase->isp24;
1721
1722 spin_lock_irq(&ha->hardware_lock);
1723
1724 vha = qla25xx_get_host(rsp);
1725 qla24xx_process_response_queue(vha, rsp);
1726 WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
1727
1728 spin_unlock_irq(&ha->hardware_lock);
1729
1730 return IRQ_HANDLED;
1731 }
1732
1733 static irqreturn_t
1734 qla25xx_msix_rsp_q(int irq, void *dev_id)
1735 {
1736 struct qla_hw_data *ha;
1737 struct rsp_que *rsp;
1738
1739 rsp = (struct rsp_que *) dev_id;
1740 if (!rsp) {
1741 printk(KERN_INFO
1742 "%s(): NULL response queue pointer\n", __func__);
1743 return IRQ_NONE;
1744 }
1745 ha = rsp->hw;
1746
1747 queue_work_on((int) (rsp->id - 1), ha->wq, &rsp->q_work);
1748
1749 return IRQ_HANDLED;
1750 }
1751
1752 static irqreturn_t
1753 qla24xx_msix_default(int irq, void *dev_id)
1754 {
1755 scsi_qla_host_t *vha;
1756 struct qla_hw_data *ha;
1757 struct rsp_que *rsp;
1758 struct device_reg_24xx __iomem *reg;
1759 int status;
1760 uint32_t stat;
1761 uint32_t hccr;
1762 uint16_t mb[4];
1763
1764 rsp = (struct rsp_que *) dev_id;
1765 if (!rsp) {
1766 DEBUG(printk(
1767 "%s(): NULL response queue pointer\n", __func__));
1768 return IRQ_NONE;
1769 }
1770 ha = rsp->hw;
1771 reg = &ha->iobase->isp24;
1772 status = 0;
1773
1774 spin_lock_irq(&ha->hardware_lock);
1775 vha = pci_get_drvdata(ha->pdev);
1776 do {
1777 stat = RD_REG_DWORD(&reg->host_status);
1778 if (stat & HSRX_RISC_PAUSED) {
1779 if (pci_channel_offline(ha->pdev))
1780 break;
1781
1782 hccr = RD_REG_DWORD(&reg->hccr);
1783
1784 qla_printk(KERN_INFO, ha, "RISC paused -- HCCR=%x, "
1785 "Dumping firmware!\n", hccr);
1786
1787 qla2xxx_check_risc_status(vha);
1788
1789 ha->isp_ops->fw_dump(vha, 1);
1790 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
1791 break;
1792 } else if ((stat & HSRX_RISC_INT) == 0)
1793 break;
1794
1795 switch (stat & 0xff) {
1796 case 0x1:
1797 case 0x2:
1798 case 0x10:
1799 case 0x11:
1800 qla24xx_mbx_completion(vha, MSW(stat));
1801 status |= MBX_INTERRUPT;
1802
1803 break;
1804 case 0x12:
1805 mb[0] = MSW(stat);
1806 mb[1] = RD_REG_WORD(&reg->mailbox1);
1807 mb[2] = RD_REG_WORD(&reg->mailbox2);
1808 mb[3] = RD_REG_WORD(&reg->mailbox3);
1809 qla2x00_async_event(vha, rsp, mb);
1810 break;
1811 case 0x13:
1812 case 0x14:
1813 qla24xx_process_response_queue(vha, rsp);
1814 break;
1815 default:
1816 DEBUG2(printk("scsi(%ld): Unrecognized interrupt type "
1817 "(%d).\n",
1818 vha->host_no, stat & 0xff));
1819 break;
1820 }
1821 WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
1822 } while (0);
1823 spin_unlock_irq(&ha->hardware_lock);
1824
1825 if (test_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags) &&
1826 (status & MBX_INTERRUPT) && ha->flags.mbox_int) {
1827 set_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
1828 complete(&ha->mbx_intr_comp);
1829 }
1830
1831 return IRQ_HANDLED;
1832 }
1833
1834 /* Interrupt handling helpers. */
1835
1836 struct qla_init_msix_entry {
1837 const char *name;
1838 irq_handler_t handler;
1839 };
1840
1841 static struct qla_init_msix_entry msix_entries[3] = {
1842 { "qla2xxx (default)", qla24xx_msix_default },
1843 { "qla2xxx (rsp_q)", qla24xx_msix_rsp_q },
1844 { "qla2xxx (multiq)", qla25xx_msix_rsp_q },
1845 };
1846
1847 static void
1848 qla24xx_disable_msix(struct qla_hw_data *ha)
1849 {
1850 int i;
1851 struct qla_msix_entry *qentry;
1852
1853 for (i = 0; i < ha->msix_count; i++) {
1854 qentry = &ha->msix_entries[i];
1855 if (qentry->have_irq)
1856 free_irq(qentry->vector, qentry->rsp);
1857 }
1858 pci_disable_msix(ha->pdev);
1859 kfree(ha->msix_entries);
1860 ha->msix_entries = NULL;
1861 ha->flags.msix_enabled = 0;
1862 }
1863
1864 static int
1865 qla24xx_enable_msix(struct qla_hw_data *ha, struct rsp_que *rsp)
1866 {
1867 #define MIN_MSIX_COUNT 2
1868 int i, ret;
1869 struct msix_entry *entries;
1870 struct qla_msix_entry *qentry;
1871
1872 entries = kzalloc(sizeof(struct msix_entry) * ha->msix_count,
1873 GFP_KERNEL);
1874 if (!entries)
1875 return -ENOMEM;
1876
1877 for (i = 0; i < ha->msix_count; i++)
1878 entries[i].entry = i;
1879
1880 ret = pci_enable_msix(ha->pdev, entries, ha->msix_count);
1881 if (ret) {
1882 if (ret < MIN_MSIX_COUNT)
1883 goto msix_failed;
1884
1885 qla_printk(KERN_WARNING, ha,
1886 "MSI-X: Failed to enable support -- %d/%d\n"
1887 " Retry with %d vectors\n", ha->msix_count, ret, ret);
1888 ha->msix_count = ret;
1889 ret = pci_enable_msix(ha->pdev, entries, ha->msix_count);
1890 if (ret) {
1891 msix_failed:
1892 qla_printk(KERN_WARNING, ha, "MSI-X: Failed to enable"
1893 " support, giving up -- %d/%d\n",
1894 ha->msix_count, ret);
1895 goto msix_out;
1896 }
1897 ha->max_rsp_queues = ha->msix_count - 1;
1898 }
1899 ha->msix_entries = kzalloc(sizeof(struct qla_msix_entry) *
1900 ha->msix_count, GFP_KERNEL);
1901 if (!ha->msix_entries) {
1902 ret = -ENOMEM;
1903 goto msix_out;
1904 }
1905 ha->flags.msix_enabled = 1;
1906
1907 for (i = 0; i < ha->msix_count; i++) {
1908 qentry = &ha->msix_entries[i];
1909 qentry->vector = entries[i].vector;
1910 qentry->entry = entries[i].entry;
1911 qentry->have_irq = 0;
1912 qentry->rsp = NULL;
1913 }
1914
1915 /* Enable MSI-X vectors for the base queue */
1916 for (i = 0; i < 2; i++) {
1917 qentry = &ha->msix_entries[i];
1918 ret = request_irq(qentry->vector, msix_entries[i].handler,
1919 0, msix_entries[i].name, rsp);
1920 if (ret) {
1921 qla_printk(KERN_WARNING, ha,
1922 "MSI-X: Unable to register handler -- %x/%d.\n",
1923 qentry->vector, ret);
1924 qla24xx_disable_msix(ha);
1925 ha->mqenable = 0;
1926 goto msix_out;
1927 }
1928 qentry->have_irq = 1;
1929 qentry->rsp = rsp;
1930 rsp->msix = qentry;
1931 }
1932
1933 /* Enable MSI-X vector for response queue update for queue 0 */
1934 if (ha->mqiobase && (ha->max_rsp_queues > 1 || ha->max_req_queues > 1))
1935 ha->mqenable = 1;
1936
1937 msix_out:
1938 kfree(entries);
1939 return ret;
1940 }
1941
1942 int
1943 qla2x00_request_irqs(struct qla_hw_data *ha, struct rsp_que *rsp)
1944 {
1945 int ret;
1946 device_reg_t __iomem *reg = ha->iobase;
1947
1948 /* If possible, enable MSI-X. */
1949 if (!IS_QLA2432(ha) && !IS_QLA2532(ha) &&
1950 !IS_QLA8432(ha) && !IS_QLA8001(ha))
1951 goto skip_msix;
1952
1953 if (IS_QLA2432(ha) && (ha->pdev->revision < QLA_MSIX_CHIP_REV_24XX ||
1954 !QLA_MSIX_FW_MODE_1(ha->fw_attributes))) {
1955 DEBUG2(qla_printk(KERN_WARNING, ha,
1956 "MSI-X: Unsupported ISP2432 (0x%X, 0x%X).\n",
1957 ha->pdev->revision, ha->fw_attributes));
1958
1959 goto skip_msix;
1960 }
1961
1962 if (ha->pdev->subsystem_vendor == PCI_VENDOR_ID_HP &&
1963 (ha->pdev->subsystem_device == 0x7040 ||
1964 ha->pdev->subsystem_device == 0x7041 ||
1965 ha->pdev->subsystem_device == 0x1705)) {
1966 DEBUG2(qla_printk(KERN_WARNING, ha,
1967 "MSI-X: Unsupported ISP2432 SSVID/SSDID (0x%X, 0x%X).\n",
1968 ha->pdev->subsystem_vendor,
1969 ha->pdev->subsystem_device));
1970
1971 goto skip_msi;
1972 }
1973
1974 ret = qla24xx_enable_msix(ha, rsp);
1975 if (!ret) {
1976 DEBUG2(qla_printk(KERN_INFO, ha,
1977 "MSI-X: Enabled (0x%X, 0x%X).\n", ha->chip_revision,
1978 ha->fw_attributes));
1979 goto clear_risc_ints;
1980 }
1981 qla_printk(KERN_WARNING, ha,
1982 "MSI-X: Falling back-to INTa mode -- %d.\n", ret);
1983 skip_msix:
1984
1985 if (!IS_QLA24XX(ha) && !IS_QLA2532(ha) && !IS_QLA8432(ha) &&
1986 !IS_QLA8001(ha))
1987 goto skip_msi;
1988
1989 ret = pci_enable_msi(ha->pdev);
1990 if (!ret) {
1991 DEBUG2(qla_printk(KERN_INFO, ha, "MSI: Enabled.\n"));
1992 ha->flags.msi_enabled = 1;
1993 }
1994 skip_msi:
1995
1996 ret = request_irq(ha->pdev->irq, ha->isp_ops->intr_handler,
1997 IRQF_SHARED, QLA2XXX_DRIVER_NAME, rsp);
1998 if (ret) {
1999 qla_printk(KERN_WARNING, ha,
2000 "Failed to reserve interrupt %d already in use.\n",
2001 ha->pdev->irq);
2002 goto fail;
2003 }
2004 ha->flags.inta_enabled = 1;
2005 clear_risc_ints:
2006
2007 /*
2008 * FIXME: Noted that 8014s were being dropped during NK testing.
2009 * Timing deltas during MSI-X/INTa transitions?
2010 */
2011 if (IS_QLA81XX(ha))
2012 goto fail;
2013 spin_lock_irq(&ha->hardware_lock);
2014 if (IS_FWI2_CAPABLE(ha)) {
2015 WRT_REG_DWORD(&reg->isp24.hccr, HCCRX_CLR_HOST_INT);
2016 WRT_REG_DWORD(&reg->isp24.hccr, HCCRX_CLR_RISC_INT);
2017 } else {
2018 WRT_REG_WORD(&reg->isp.semaphore, 0);
2019 WRT_REG_WORD(&reg->isp.hccr, HCCR_CLR_RISC_INT);
2020 WRT_REG_WORD(&reg->isp.hccr, HCCR_CLR_HOST_INT);
2021 }
2022 spin_unlock_irq(&ha->hardware_lock);
2023
2024 fail:
2025 return ret;
2026 }
2027
2028 void
2029 qla2x00_free_irqs(scsi_qla_host_t *vha)
2030 {
2031 struct qla_hw_data *ha = vha->hw;
2032 struct rsp_que *rsp = ha->rsp_q_map[0];
2033
2034 if (ha->flags.msix_enabled)
2035 qla24xx_disable_msix(ha);
2036 else if (ha->flags.inta_enabled) {
2037 free_irq(ha->pdev->irq, rsp);
2038 pci_disable_msi(ha->pdev);
2039 }
2040 }
2041
2042
2043 int qla25xx_request_irq(struct rsp_que *rsp)
2044 {
2045 struct qla_hw_data *ha = rsp->hw;
2046 struct qla_init_msix_entry *intr = &msix_entries[2];
2047 struct qla_msix_entry *msix = rsp->msix;
2048 int ret;
2049
2050 ret = request_irq(msix->vector, intr->handler, 0, intr->name, rsp);
2051 if (ret) {
2052 qla_printk(KERN_WARNING, ha,
2053 "MSI-X: Unable to register handler -- %x/%d.\n",
2054 msix->vector, ret);
2055 return ret;
2056 }
2057 msix->have_irq = 1;
2058 msix->rsp = rsp;
2059 return ret;
2060 }
2061
2062 struct scsi_qla_host *
2063 qla25xx_get_host(struct rsp_que *rsp)
2064 {
2065 srb_t *sp;
2066 struct qla_hw_data *ha = rsp->hw;
2067 struct scsi_qla_host *vha = NULL;
2068 struct sts_entry_24xx *pkt;
2069 struct req_que *req;
2070 uint16_t que;
2071 uint32_t handle;
2072
2073 pkt = (struct sts_entry_24xx *) rsp->ring_ptr;
2074 que = MSW(pkt->handle);
2075 handle = (uint32_t) LSW(pkt->handle);
2076 req = ha->req_q_map[que];
2077 if (handle < MAX_OUTSTANDING_COMMANDS) {
2078 sp = req->outstanding_cmds[handle];
2079 if (sp)
2080 return sp->fcport->vha;
2081 else
2082 goto base_que;
2083 }
2084 base_que:
2085 vha = pci_get_drvdata(ha->pdev);
2086 return vha;
2087 }
connection oriented routing - ARCHIVE NO UPDATES HERE