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