?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Automatic merge of rsync://rsync.kernel.org/pub/scm/linux/kernel/git/gregkh/driver...
[linux-2.6/verdex.git] / drivers / scsi / qla2xxx / qla_isr.c
blob6792cfae56e29cb48a28fcffd4f7a98c03b4fc26
1 /*
2 * QLOGIC LINUX SOFTWARE
3 *
4 * QLogic ISP2x00 device driver for Linux 2.6.x
5 * Copyright (C) 2003-2004 QLogic Corporation
6 * (www.qlogic.com)
7 *
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the
10 * Free Software Foundation; either version 2, or (at your option) any
11 * later version.
12 *
13 * This program is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * General Public License for more details.
17 *
18 */
19 #include "qla_def.h"
20
21 static void qla2x00_mbx_completion(scsi_qla_host_t *, uint16_t);
22 static void qla2x00_async_event(scsi_qla_host_t *, uint32_t);
23 static void qla2x00_process_completed_request(struct scsi_qla_host *, uint32_t);
24 void qla2x00_process_response_queue(struct scsi_qla_host *);
25 static void qla2x00_status_entry(scsi_qla_host_t *, sts_entry_t *);
26 static void qla2x00_status_cont_entry(scsi_qla_host_t *, sts_cont_entry_t *);
27 static void qla2x00_error_entry(scsi_qla_host_t *, sts_entry_t *);
28 static void qla2x00_ms_entry(scsi_qla_host_t *, ms_iocb_entry_t *);
29
30 /**
31 * qla2100_intr_handler() - Process interrupts for the ISP2100 and ISP2200.
32 * @irq:
33 * @dev_id: SCSI driver HA context
34 * @regs:
35 *
36 * Called by system whenever the host adapter generates an interrupt.
37 *
38 * Returns handled flag.
39 */
40 irqreturn_t
41 qla2100_intr_handler(int irq, void *dev_id, struct pt_regs *regs)
42 {
43 scsi_qla_host_t *ha;
44 device_reg_t __iomem *reg;
45 int status;
46 unsigned long flags;
47 unsigned long iter;
48 uint32_t mbx;
49
50 ha = (scsi_qla_host_t *) dev_id;
51 if (!ha) {
52 printk(KERN_INFO
53 "%s(): NULL host pointer\n", __func__);
54 return (IRQ_NONE);
55 }
56
57 reg = ha->iobase;
58 status = 0;
59
60 spin_lock_irqsave(&ha->hardware_lock, flags);
61 for (iter = 50; iter--; ) {
62 if ((RD_REG_WORD(&reg->istatus) & ISR_RISC_INT) == 0)
63 break;
64
65 if (RD_REG_WORD(&reg->semaphore) & BIT_0) {
66 WRT_REG_WORD(&reg->hccr, HCCR_CLR_RISC_INT);
67 RD_REG_WORD(&reg->hccr);
68
69 /* Get mailbox data. */
70 mbx = RD_MAILBOX_REG(ha, reg, 0);
71 if (mbx > 0x3fff && mbx < 0x8000) {
72 qla2x00_mbx_completion(ha, (uint16_t)mbx);
73 status |= MBX_INTERRUPT;
74 } else if (mbx > 0x7fff && mbx < 0xc000) {
75 qla2x00_async_event(ha, mbx);
76 } else {
77 /*EMPTY*/
78 DEBUG2(printk("scsi(%ld): Unrecognized "
79 "interrupt type (%d)\n",
80 ha->host_no, mbx));
81 }
82 /* Release mailbox registers. */
83 WRT_REG_WORD(&reg->semaphore, 0);
84 RD_REG_WORD(&reg->semaphore);
85 } else {
86 qla2x00_process_response_queue(ha);
87
88 WRT_REG_WORD(&reg->hccr, HCCR_CLR_RISC_INT);
89 RD_REG_WORD(&reg->hccr);
90 }
91 }
92 spin_unlock_irqrestore(&ha->hardware_lock, flags);
93
94 ha->last_irq_cpu = _smp_processor_id();
95 ha->total_isr_cnt++;
96
97 if (test_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags) &&
98 (status & MBX_INTERRUPT) && ha->flags.mbox_int) {
99 spin_lock_irqsave(&ha->mbx_reg_lock, flags);
100
101 set_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
102 up(&ha->mbx_intr_sem);
103
104 spin_unlock_irqrestore(&ha->mbx_reg_lock, flags);
105 }
106
107 return (IRQ_HANDLED);
108 }
109
110 /**
111 * qla2300_intr_handler() - Process interrupts for the ISP23xx and ISP63xx.
112 * @irq:
113 * @dev_id: SCSI driver HA context
114 * @regs:
115 *
116 * Called by system whenever the host adapter generates an interrupt.
117 *
118 * Returns handled flag.
119 */
120 irqreturn_t
121 qla2300_intr_handler(int irq, void *dev_id, struct pt_regs *regs)
122 {
123 scsi_qla_host_t *ha;
124 device_reg_t __iomem *reg;
125 int status;
126 unsigned long flags;
127 unsigned long iter;
128 uint32_t stat;
129 uint32_t mbx;
130 uint16_t hccr;
131
132 ha = (scsi_qla_host_t *) dev_id;
133 if (!ha) {
134 printk(KERN_INFO
135 "%s(): NULL host pointer\n", __func__);
136 return (IRQ_NONE);
137 }
138
139 reg = ha->iobase;
140 status = 0;
141
142 spin_lock_irqsave(&ha->hardware_lock, flags);
143 for (iter = 50; iter--; ) {
144 stat = RD_REG_DWORD(&reg->u.isp2300.host_status);
145 if (stat & HSR_RISC_PAUSED) {
146 hccr = RD_REG_WORD(&reg->hccr);
147 if (hccr & (BIT_15 | BIT_13 | BIT_11 | BIT_8))
148 qla_printk(KERN_INFO, ha,
149 "Parity error -- HCCR=%x.\n", hccr);
150 else
151 qla_printk(KERN_INFO, ha,
152 "RISC paused -- HCCR=%x\n", hccr);
153
154 /*
155 * Issue a "HARD" reset in order for the RISC
156 * interrupt bit to be cleared. Schedule a big
157 * hammmer to get out of the RISC PAUSED state.
158 */
159 WRT_REG_WORD(&reg->hccr, HCCR_RESET_RISC);
160 RD_REG_WORD(&reg->hccr);
161 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
162 break;
163 } else if ((stat & HSR_RISC_INT) == 0)
164 break;
165
166 mbx = MSW(stat);
167 switch (stat & 0xff) {
168 case 0x13:
169 qla2x00_process_response_queue(ha);
170 break;
171 case 0x1:
172 case 0x2:
173 case 0x10:
174 case 0x11:
175 qla2x00_mbx_completion(ha, (uint16_t)mbx);
176 status |= MBX_INTERRUPT;
177
178 /* Release mailbox registers. */
179 WRT_REG_WORD(&reg->semaphore, 0);
180 break;
181 case 0x12:
182 qla2x00_async_event(ha, mbx);
183 break;
184 case 0x15:
185 mbx = mbx << 16 | MBA_CMPLT_1_16BIT;
186 qla2x00_async_event(ha, mbx);
187 break;
188 case 0x16:
189 mbx = mbx << 16 | MBA_SCSI_COMPLETION;
190 qla2x00_async_event(ha, mbx);
191 break;
192 default:
193 DEBUG2(printk("scsi(%ld): Unrecognized interrupt type "
194 "(%d)\n",
195 ha->host_no, stat & 0xff));
196 break;
197 }
198 WRT_REG_WORD(&reg->hccr, HCCR_CLR_RISC_INT);
199 RD_REG_WORD_RELAXED(&reg->hccr);
200 }
201 spin_unlock_irqrestore(&ha->hardware_lock, flags);
202
203 ha->last_irq_cpu = _smp_processor_id();
204 ha->total_isr_cnt++;
205
206 if (test_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags) &&
207 (status & MBX_INTERRUPT) && ha->flags.mbox_int) {
208 spin_lock_irqsave(&ha->mbx_reg_lock, flags);
209
210 set_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
211 up(&ha->mbx_intr_sem);
212
213 spin_unlock_irqrestore(&ha->mbx_reg_lock, flags);
214 }
215
216 return (IRQ_HANDLED);
217 }
218
219 /**
220 * qla2x00_mbx_completion() - Process mailbox command completions.
221 * @ha: SCSI driver HA context
222 * @mb0: Mailbox0 register
223 */
224 static void
225 qla2x00_mbx_completion(scsi_qla_host_t *ha, uint16_t mb0)
226 {
227 uint16_t cnt;
228 uint16_t __iomem *wptr;
229 device_reg_t __iomem *reg = ha->iobase;
230
231 /* Load return mailbox registers. */
232 ha->flags.mbox_int = 1;
233 ha->mailbox_out[0] = mb0;
234 wptr = (uint16_t __iomem *)MAILBOX_REG(ha, reg, 1);
235
236 for (cnt = 1; cnt < ha->mbx_count; cnt++) {
237 if (IS_QLA2200(ha) && cnt == 8)
238 wptr = (uint16_t __iomem *)MAILBOX_REG(ha, reg, 8);
239 if (cnt == 4 || cnt == 5)
240 ha->mailbox_out[cnt] = qla2x00_debounce_register(wptr);
241 else
242 ha->mailbox_out[cnt] = RD_REG_WORD(wptr);
243
244 wptr++;
245 }
246
247 if (ha->mcp) {
248 DEBUG3(printk("%s(%ld): Got mailbox completion. cmd=%x.\n",
249 __func__, ha->host_no, ha->mcp->mb[0]));
250 } else {
251 DEBUG2_3(printk("%s(%ld): MBX pointer ERROR!\n",
252 __func__, ha->host_no));
253 }
254 }
255
256 /**
257 * qla2x00_async_event() - Process aynchronous events.
258 * @ha: SCSI driver HA context
259 * @mb0: Mailbox0 register
260 */
261 static void
262 qla2x00_async_event(scsi_qla_host_t *ha, uint32_t mbx)
263 {
264 static char *link_speeds[5] = { "1", "2", "4", "?", "10" };
265 char *link_speed;
266 uint16_t mb[4];
267 uint16_t handle_cnt;
268 uint16_t cnt;
269 uint32_t handles[5];
270 device_reg_t __iomem *reg = ha->iobase;
271 uint32_t rscn_entry, host_pid;
272 uint8_t rscn_queue_index;
273
274 /* Setup to process RIO completion. */
275 handle_cnt = 0;
276 mb[0] = LSW(mbx);
277 switch (mb[0]) {
278 case MBA_SCSI_COMPLETION:
279 if (IS_QLA2100(ha) || IS_QLA2200(ha))
280 handles[0] = le32_to_cpu(
281 ((uint32_t)(RD_MAILBOX_REG(ha, reg, 2) << 16)) |
282 RD_MAILBOX_REG(ha, reg, 1));
283 else
284 handles[0] = le32_to_cpu(
285 ((uint32_t)(RD_MAILBOX_REG(ha, reg, 2) << 16)) |
286 MSW(mbx));
287 handle_cnt = 1;
288 break;
289 case MBA_CMPLT_1_16BIT:
290 if (IS_QLA2100(ha) || IS_QLA2200(ha))
291 handles[0] = (uint32_t)RD_MAILBOX_REG(ha, reg, 1);
292 else
293 handles[0] = MSW(mbx);
294 handle_cnt = 1;
295 mb[0] = MBA_SCSI_COMPLETION;
296 break;
297 case MBA_CMPLT_2_16BIT:
298 handles[0] = (uint32_t)RD_MAILBOX_REG(ha, reg, 1);
299 handles[1] = (uint32_t)RD_MAILBOX_REG(ha, reg, 2);
300 handle_cnt = 2;
301 mb[0] = MBA_SCSI_COMPLETION;
302 break;
303 case MBA_CMPLT_3_16BIT:
304 handles[0] = (uint32_t)RD_MAILBOX_REG(ha, reg, 1);
305 handles[1] = (uint32_t)RD_MAILBOX_REG(ha, reg, 2);
306 handles[2] = (uint32_t)RD_MAILBOX_REG(ha, reg, 3);
307 handle_cnt = 3;
308 mb[0] = MBA_SCSI_COMPLETION;
309 break;
310 case MBA_CMPLT_4_16BIT:
311 handles[0] = (uint32_t)RD_MAILBOX_REG(ha, reg, 1);
312 handles[1] = (uint32_t)RD_MAILBOX_REG(ha, reg, 2);
313 handles[2] = (uint32_t)RD_MAILBOX_REG(ha, reg, 3);
314 handles[3] = (uint32_t)RD_MAILBOX_REG(ha, reg, 6);
315 handle_cnt = 4;
316 mb[0] = MBA_SCSI_COMPLETION;
317 break;
318 case MBA_CMPLT_5_16BIT:
319 handles[0] = (uint32_t)RD_MAILBOX_REG(ha, reg, 1);
320 handles[1] = (uint32_t)RD_MAILBOX_REG(ha, reg, 2);
321 handles[2] = (uint32_t)RD_MAILBOX_REG(ha, reg, 3);
322 handles[3] = (uint32_t)RD_MAILBOX_REG(ha, reg, 6);
323 handles[4] = (uint32_t)RD_MAILBOX_REG(ha, reg, 7);
324 handle_cnt = 5;
325 mb[0] = MBA_SCSI_COMPLETION;
326 break;
327 case MBA_CMPLT_2_32BIT:
328 handles[0] = le32_to_cpu(
329 ((uint32_t)(RD_MAILBOX_REG(ha, reg, 2) << 16)) |
330 RD_MAILBOX_REG(ha, reg, 1));
331 handles[1] = le32_to_cpu(
332 ((uint32_t)(RD_MAILBOX_REG(ha, reg, 7) << 16)) |
333 RD_MAILBOX_REG(ha, reg, 6));
334 handle_cnt = 2;
335 mb[0] = MBA_SCSI_COMPLETION;
336 break;
337 default:
338 break;
339 }
340
341 switch (mb[0]) {
342 case MBA_SCSI_COMPLETION: /* Fast Post */
343 if (!ha->flags.online)
344 break;
345
346 for (cnt = 0; cnt < handle_cnt; cnt++)
347 qla2x00_process_completed_request(ha, handles[cnt]);
348 break;
349
350 case MBA_RESET: /* Reset */
351 DEBUG2(printk("scsi(%ld): Asynchronous RESET.\n", ha->host_no));
352
353 set_bit(RESET_MARKER_NEEDED, &ha->dpc_flags);
354 break;
355
356 case MBA_SYSTEM_ERR: /* System Error */
357 mb[1] = RD_MAILBOX_REG(ha, reg, 1);
358 mb[2] = RD_MAILBOX_REG(ha, reg, 2);
359 mb[3] = RD_MAILBOX_REG(ha, reg, 3);
360
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
365 if (IS_QLA2100(ha) || IS_QLA2200(ha))
366 qla2100_fw_dump(ha, 1);
367 else
368 qla2300_fw_dump(ha, 1);
369
370 if (mb[1] == 0) {
371 qla_printk(KERN_INFO, ha,
372 "Unrecoverable Hardware Error: adapter marked "
373 "OFFLINE!\n");
374 ha->flags.online = 0;
375 } else
376 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
377 break;
378
379 case MBA_REQ_TRANSFER_ERR: /* Request Transfer Error */
380 DEBUG2(printk("scsi(%ld): ISP Request Transfer Error.\n",
381 ha->host_no));
382 qla_printk(KERN_WARNING, ha, "ISP Request Transfer Error.\n");
383
384 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
385 break;
386
387 case MBA_RSP_TRANSFER_ERR: /* Response Transfer Error */
388 DEBUG2(printk("scsi(%ld): ISP Response Transfer Error.\n",
389 ha->host_no));
390 qla_printk(KERN_WARNING, ha, "ISP Response Transfer Error.\n");
391
392 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
393 break;
394
395 case MBA_WAKEUP_THRES: /* Request Queue Wake-up */
396 DEBUG2(printk("scsi(%ld): Asynchronous WAKEUP_THRES.\n",
397 ha->host_no));
398 break;
399
400 case MBA_LIP_OCCURRED: /* Loop Initialization Procedure */
401 mb[1] = RD_MAILBOX_REG(ha, reg, 1);
402
403 DEBUG2(printk("scsi(%ld): LIP occured (%x).\n", ha->host_no,
404 mb[1]));
405 qla_printk(KERN_INFO, ha, "LIP occured (%x).\n", mb[1]);
406
407 if (atomic_read(&ha->loop_state) != LOOP_DOWN) {
408 atomic_set(&ha->loop_state, LOOP_DOWN);
409 atomic_set(&ha->loop_down_timer, LOOP_DOWN_TIME);
410 qla2x00_mark_all_devices_lost(ha);
411 }
412
413 set_bit(REGISTER_FC4_NEEDED, &ha->dpc_flags);
414
415 ha->flags.management_server_logged_in = 0;
416
417 /* Update AEN queue. */
418 qla2x00_enqueue_aen(ha, MBA_LIP_OCCURRED, NULL);
419
420 ha->total_lip_cnt++;
421 break;
422
423 case MBA_LOOP_UP: /* Loop Up Event */
424 mb[1] = RD_MAILBOX_REG(ha, reg, 1);
425
426 ha->link_data_rate = 0;
427 if (IS_QLA2100(ha) || IS_QLA2200(ha)) {
428 link_speed = link_speeds[0];
429 } else {
430 link_speed = link_speeds[3];
431 if (mb[1] < 5)
432 link_speed = link_speeds[mb[1]];
433 ha->link_data_rate = mb[1];
434 }
435
436 DEBUG2(printk("scsi(%ld): Asynchronous LOOP UP (%s Gbps).\n",
437 ha->host_no, link_speed));
438 qla_printk(KERN_INFO, ha, "LOOP UP detected (%s Gbps).\n",
439 link_speed);
440
441 ha->flags.management_server_logged_in = 0;
442
443 /* Update AEN queue. */
444 qla2x00_enqueue_aen(ha, MBA_LOOP_UP, NULL);
445 break;
446
447 case MBA_LOOP_DOWN: /* Loop Down Event */
448 DEBUG2(printk("scsi(%ld): Asynchronous LOOP DOWN.\n",
449 ha->host_no));
450 qla_printk(KERN_INFO, ha, "LOOP DOWN detected.\n");
451
452 if (atomic_read(&ha->loop_state) != LOOP_DOWN) {
453 atomic_set(&ha->loop_state, LOOP_DOWN);
454 atomic_set(&ha->loop_down_timer, LOOP_DOWN_TIME);
455 ha->device_flags |= DFLG_NO_CABLE;
456 qla2x00_mark_all_devices_lost(ha);
457 }
458
459 ha->flags.management_server_logged_in = 0;
460 ha->link_data_rate = 0;
461
462 /* Update AEN queue. */
463 qla2x00_enqueue_aen(ha, MBA_LOOP_DOWN, NULL);
464 break;
465
466 case MBA_LIP_RESET: /* LIP reset occurred */
467 mb[1] = RD_MAILBOX_REG(ha, reg, 1);
468
469 DEBUG2(printk("scsi(%ld): Asynchronous LIP RESET (%x).\n",
470 ha->host_no, mb[1]));
471 qla_printk(KERN_INFO, ha,
472 "LIP reset occured (%x).\n", mb[1]);
473
474 if (atomic_read(&ha->loop_state) != LOOP_DOWN) {
475 atomic_set(&ha->loop_state, LOOP_DOWN);
476 atomic_set(&ha->loop_down_timer, LOOP_DOWN_TIME);
477 qla2x00_mark_all_devices_lost(ha);
478 }
479
480 set_bit(RESET_MARKER_NEEDED, &ha->dpc_flags);
481
482 ha->operating_mode = LOOP;
483 ha->flags.management_server_logged_in = 0;
484
485 /* Update AEN queue. */
486 qla2x00_enqueue_aen(ha, MBA_LIP_RESET, NULL);
487
488 ha->total_lip_cnt++;
489 break;
490
491 case MBA_POINT_TO_POINT: /* Point-to-Point */
492 if (IS_QLA2100(ha))
493 break;
494
495 DEBUG2(printk("scsi(%ld): Asynchronous P2P MODE received.\n",
496 ha->host_no));
497
498 /*
499 * Until there's a transition from loop down to loop up, treat
500 * this as loop down only.
501 */
502 if (atomic_read(&ha->loop_state) != LOOP_DOWN) {
503 atomic_set(&ha->loop_state, LOOP_DOWN);
504 if (!atomic_read(&ha->loop_down_timer))
505 atomic_set(&ha->loop_down_timer,
506 LOOP_DOWN_TIME);
507 qla2x00_mark_all_devices_lost(ha);
508 }
509
510 if (!(test_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags))) {
511 set_bit(RESET_MARKER_NEEDED, &ha->dpc_flags);
512 }
513 set_bit(REGISTER_FC4_NEEDED, &ha->dpc_flags);
514 break;
515
516 case MBA_CHG_IN_CONNECTION: /* Change in connection mode */
517 if (IS_QLA2100(ha))
518 break;
519
520 mb[1] = RD_MAILBOX_REG(ha, reg, 1);
521
522 DEBUG2(printk("scsi(%ld): Asynchronous Change In Connection "
523 "received.\n",
524 ha->host_no));
525 qla_printk(KERN_INFO, ha,
526 "Configuration change detected: value=%x.\n", mb[1]);
527
528 if (atomic_read(&ha->loop_state) != LOOP_DOWN) {
529 atomic_set(&ha->loop_state, LOOP_DOWN);
530 if (!atomic_read(&ha->loop_down_timer))
531 atomic_set(&ha->loop_down_timer,
532 LOOP_DOWN_TIME);
533 qla2x00_mark_all_devices_lost(ha);
534 }
535
536 set_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags);
537 set_bit(LOCAL_LOOP_UPDATE, &ha->dpc_flags);
538 break;
539
540 case MBA_PORT_UPDATE: /* Port database update */
541 mb[1] = RD_MAILBOX_REG(ha, reg, 1);
542 mb[2] = RD_MAILBOX_REG(ha, reg, 2);
543
544 /*
545 * If a single remote port just logged into (or logged out of)
546 * us, create a new entry in our rscn fcports list and handle
547 * the event like an RSCN.
548 */
549 if (!IS_QLA2100(ha) && !IS_QLA2200(ha) && !IS_QLA6312(ha) &&
550 !IS_QLA6322(ha) && ha->flags.init_done && mb[1] != 0xffff &&
551 ((ha->operating_mode == P2P && mb[1] != 0) ||
552 (ha->operating_mode != P2P && mb[1] !=
553 SNS_FIRST_LOOP_ID)) && (mb[2] == 6 || mb[2] == 7)) {
554 int rval;
555 fc_port_t *rscn_fcport;
556
557 /* Create new fcport for login. */
558 rscn_fcport = qla2x00_alloc_rscn_fcport(ha, GFP_ATOMIC);
559 if (rscn_fcport) {
560 DEBUG14(printk("scsi(%ld): Port Update -- "
561 "creating RSCN fcport %p for %x/%x.\n",
562 ha->host_no, rscn_fcport, mb[1], mb[2]));
563
564 rscn_fcport->loop_id = mb[1];
565 rscn_fcport->d_id.b24 = INVALID_PORT_ID;
566 atomic_set(&rscn_fcport->state,
567 FCS_DEVICE_LOST);
568 list_add_tail(&rscn_fcport->list,
569 &ha->rscn_fcports);
570
571 rval = qla2x00_handle_port_rscn(ha, 0,
572 rscn_fcport, 1);
573 if (rval == QLA_SUCCESS)
574 break;
575 } else {
576 DEBUG14(printk("scsi(%ld): Port Update -- "
577 "-- unable to allocate RSCN fcport "
578 "login.\n", ha->host_no));
579 }
580 }
581
582 /*
583 * If PORT UPDATE is global (recieved LIP_OCCURED/LIP_RESET
584 * event etc. earlier indicating loop is down) then process
585 * it. Otherwise ignore it and Wait for RSCN to come in.
586 */
587 atomic_set(&ha->loop_down_timer, 0);
588 if (atomic_read(&ha->loop_state) != LOOP_DOWN &&
589 atomic_read(&ha->loop_state) != LOOP_DEAD) {
590 DEBUG2(printk("scsi(%ld): Asynchronous PORT UPDATE "
591 "ignored.\n", ha->host_no));
592 break;
593 }
594
595 DEBUG2(printk("scsi(%ld): Asynchronous PORT UPDATE.\n",
596 ha->host_no));
597 DEBUG(printk(KERN_INFO
598 "scsi(%ld): Port database changed %04x %04x.\n",
599 ha->host_no, mb[1], mb[2]));
600
601 /*
602 * Mark all devices as missing so we will login again.
603 */
604 atomic_set(&ha->loop_state, LOOP_UP);
605
606 qla2x00_mark_all_devices_lost(ha);
607
608 ha->flags.rscn_queue_overflow = 1;
609
610 set_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags);
611 set_bit(LOCAL_LOOP_UPDATE, &ha->dpc_flags);
612
613 /* Update AEN queue. */
614 qla2x00_enqueue_aen(ha, MBA_PORT_UPDATE, NULL);
615 break;
616
617 case MBA_RSCN_UPDATE: /* State Change Registration */
618 mb[1] = RD_MAILBOX_REG(ha, reg, 1);
619 mb[2] = RD_MAILBOX_REG(ha, reg, 2);
620
621 DEBUG2(printk("scsi(%ld): Asynchronous RSCR UPDATE.\n",
622 ha->host_no));
623 DEBUG(printk(KERN_INFO
624 "scsi(%ld): RSCN database changed -- %04x %04x.\n",
625 ha->host_no, mb[1], mb[2]));
626
627 rscn_entry = (mb[1] << 16) | mb[2];
628 host_pid = (ha->d_id.b.domain << 16) | (ha->d_id.b.area << 8) |
629 ha->d_id.b.al_pa;
630 if (rscn_entry == host_pid) {
631 DEBUG(printk(KERN_INFO
632 "scsi(%ld): Ignoring RSCN update to local host "
633 "port ID (%06x)\n",
634 ha->host_no, host_pid));
635 break;
636 }
637
638 rscn_queue_index = ha->rscn_in_ptr + 1;
639 if (rscn_queue_index == MAX_RSCN_COUNT)
640 rscn_queue_index = 0;
641 if (rscn_queue_index != ha->rscn_out_ptr) {
642 ha->rscn_queue[ha->rscn_in_ptr] = rscn_entry;
643 ha->rscn_in_ptr = rscn_queue_index;
644 } else {
645 ha->flags.rscn_queue_overflow = 1;
646 }
647
648 atomic_set(&ha->loop_state, LOOP_UPDATE);
649 atomic_set(&ha->loop_down_timer, 0);
650 ha->flags.management_server_logged_in = 0;
651
652 set_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags);
653 set_bit(RSCN_UPDATE, &ha->dpc_flags);
654
655 /* Update AEN queue. */
656 qla2x00_enqueue_aen(ha, MBA_RSCN_UPDATE, &mb[0]);
657 break;
658
659 /* case MBA_RIO_RESPONSE: */
660 case MBA_ZIO_RESPONSE:
661 DEBUG2(printk("scsi(%ld): [R|Z]IO update completion.\n",
662 ha->host_no));
663 DEBUG(printk(KERN_INFO
664 "scsi(%ld): [R|Z]IO update completion.\n",
665 ha->host_no));
666
667 qla2x00_process_response_queue(ha);
668 break;
669 }
670 }
671
672 /**
673 * qla2x00_process_completed_request() - Process a Fast Post response.
674 * @ha: SCSI driver HA context
675 * @index: SRB index
676 */
677 static void
678 qla2x00_process_completed_request(struct scsi_qla_host *ha, uint32_t index)
679 {
680 srb_t *sp;
681
682 /* Validate handle. */
683 if (index >= MAX_OUTSTANDING_COMMANDS) {
684 DEBUG2(printk("scsi(%ld): Invalid SCSI completion handle %d.\n",
685 ha->host_no, index));
686 qla_printk(KERN_WARNING, ha,
687 "Invalid SCSI completion handle %d.\n", index);
688
689 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
690 return;
691 }
692
693 sp = ha->outstanding_cmds[index];
694 if (sp) {
695 /* Free outstanding command slot. */
696 ha->outstanding_cmds[index] = NULL;
697
698 if (ha->actthreads)
699 ha->actthreads--;
700 CMD_COMPL_STATUS(sp->cmd) = 0L;
701 CMD_SCSI_STATUS(sp->cmd) = 0L;
702
703 /* Save ISP completion status */
704 sp->cmd->result = DID_OK << 16;
705 sp->fo_retry_cnt = 0;
706 qla2x00_sp_compl(ha, sp);
707 } else {
708 DEBUG2(printk("scsi(%ld): Invalid ISP SCSI completion handle\n",
709 ha->host_no));
710 qla_printk(KERN_WARNING, ha,
711 "Invalid ISP SCSI completion handle\n");
712
713 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
714 }
715 }
716
717 /**
718 * qla2x00_process_response_queue() - Process response queue entries.
719 * @ha: SCSI driver HA context
720 */
721 void
722 qla2x00_process_response_queue(struct scsi_qla_host *ha)
723 {
724 device_reg_t __iomem *reg = ha->iobase;
725 sts_entry_t *pkt;
726 uint16_t handle_cnt;
727 uint16_t cnt;
728
729 if (!ha->flags.online)
730 return;
731
732 while (ha->response_ring_ptr->signature != RESPONSE_PROCESSED) {
733 pkt = (sts_entry_t *)ha->response_ring_ptr;
734
735 ha->rsp_ring_index++;
736 if (ha->rsp_ring_index == ha->response_q_length) {
737 ha->rsp_ring_index = 0;
738 ha->response_ring_ptr = ha->response_ring;
739 } else {
740 ha->response_ring_ptr++;
741 }
742
743 if (pkt->entry_status != 0) {
744 DEBUG3(printk(KERN_INFO
745 "scsi(%ld): Process error entry.\n", ha->host_no));
746
747 qla2x00_error_entry(ha, pkt);
748 ((response_t *)pkt)->signature = RESPONSE_PROCESSED;
749 wmb();
750 continue;
751 }
752
753 switch (pkt->entry_type) {
754 case STATUS_TYPE:
755 qla2x00_status_entry(ha, pkt);
756 break;
757 case STATUS_TYPE_21:
758 handle_cnt = ((sts21_entry_t *)pkt)->handle_count;
759 for (cnt = 0; cnt < handle_cnt; cnt++) {
760 qla2x00_process_completed_request(ha,
761 ((sts21_entry_t *)pkt)->handle[cnt]);
762 }
763 break;
764 case STATUS_TYPE_22:
765 handle_cnt = ((sts22_entry_t *)pkt)->handle_count;
766 for (cnt = 0; cnt < handle_cnt; cnt++) {
767 qla2x00_process_completed_request(ha,
768 ((sts22_entry_t *)pkt)->handle[cnt]);
769 }
770 break;
771 case STATUS_CONT_TYPE:
772 qla2x00_status_cont_entry(ha, (sts_cont_entry_t *)pkt);
773 break;
774 case MS_IOCB_TYPE:
775 qla2x00_ms_entry(ha, (ms_iocb_entry_t *)pkt);
776 break;
777 case MBX_IOCB_TYPE:
778 if (!IS_QLA2100(ha) && !IS_QLA2200(ha) &&
779 !IS_QLA6312(ha) && !IS_QLA6322(ha)) {
780 if (pkt->sys_define == SOURCE_ASYNC_IOCB) {
781 qla2x00_process_iodesc(ha,
782 (struct mbx_entry *)pkt);
783 } else {
784 /* MBX IOCB Type Not Supported. */
785 DEBUG4(printk(KERN_WARNING
786 "scsi(%ld): Received unknown MBX "
787 "IOCB response pkt type=%x "
788 "source=%x entry status=%x.\n",
789 ha->host_no, pkt->entry_type,
790 pkt->sys_define,
791 pkt->entry_status));
792 }
793 break;
794 }
795 /* Fallthrough. */
796 default:
797 /* Type Not Supported. */
798 DEBUG4(printk(KERN_WARNING
799 "scsi(%ld): Received unknown response pkt type %x "
800 "entry status=%x.\n",
801 ha->host_no, pkt->entry_type, pkt->entry_status));
802 break;
803 }
804 ((response_t *)pkt)->signature = RESPONSE_PROCESSED;
805 wmb();
806 }
807
808 /* Adjust ring index */
809 WRT_REG_WORD(ISP_RSP_Q_OUT(ha, reg), ha->rsp_ring_index);
810 }
811
812 /**
813 * qla2x00_status_entry() - Process a Status IOCB entry.
814 * @ha: SCSI driver HA context
815 * @pkt: Entry pointer
816 */
817 static void
818 qla2x00_status_entry(scsi_qla_host_t *ha, sts_entry_t *pkt)
819 {
820 unsigned b, t, l;
821 srb_t *sp;
822 fc_port_t *fcport;
823 struct scsi_cmnd *cp;
824 uint16_t comp_status;
825 uint16_t scsi_status;
826 uint8_t lscsi_status;
827 int32_t resid;
828 uint8_t sense_sz = 0;
829 uint16_t rsp_info_len;
830
831 /* Fast path completion. */
832 if (le16_to_cpu(pkt->comp_status) == CS_COMPLETE &&
833 (le16_to_cpu(pkt->scsi_status) & SS_MASK) == 0) {
834 qla2x00_process_completed_request(ha, pkt->handle);
835
836 return;
837 }
838
839 /* Validate handle. */
840 if (pkt->handle < MAX_OUTSTANDING_COMMANDS) {
841 sp = ha->outstanding_cmds[pkt->handle];
842 ha->outstanding_cmds[pkt->handle] = NULL;
843 } else
844 sp = NULL;
845
846 if (sp == NULL) {
847 DEBUG2(printk("scsi(%ld): Status Entry invalid handle.\n",
848 ha->host_no));
849 qla_printk(KERN_WARNING, ha, "Status Entry invalid handle.\n");
850
851 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
852 if (ha->dpc_wait && !ha->dpc_active)
853 up(ha->dpc_wait);
854
855 return;
856 }
857 cp = sp->cmd;
858 if (cp == NULL) {
859 DEBUG2(printk("scsi(%ld): Command already returned back to OS "
860 "pkt->handle=%d sp=%p sp->state:%d\n",
861 ha->host_no, pkt->handle, sp, sp->state));
862 qla_printk(KERN_WARNING, ha,
863 "Command is NULL: already returned to OS (sp=%p)\n", sp);
864
865 return;
866 }
867
868 if (ha->actthreads)
869 ha->actthreads--;
870
871 comp_status = le16_to_cpu(pkt->comp_status);
872 /* Mask of reserved bits 12-15, before we examine the scsi status */
873 scsi_status = le16_to_cpu(pkt->scsi_status) & SS_MASK;
874 lscsi_status = scsi_status & STATUS_MASK;
875
876 CMD_ENTRY_STATUS(cp) = pkt->entry_status;
877 CMD_COMPL_STATUS(cp) = comp_status;
878 CMD_SCSI_STATUS(cp) = scsi_status;
879
880 /* Generate LU queue on cntrl, target, LUN */
881 b = cp->device->channel;
882 t = cp->device->id;
883 l = cp->device->lun,
884
885 fcport = sp->fcport;
886
887 /* Check for any FCP transport errors. */
888 if (scsi_status & SS_RESPONSE_INFO_LEN_VALID) {
889 rsp_info_len = le16_to_cpu(pkt->rsp_info_len);
890 if (rsp_info_len > 3 && pkt->rsp_info[3]) {
891 DEBUG2(printk("scsi(%ld:%d:%d:%d) FCP I/O protocol "
892 "failure (%x/%02x%02x%02x%02x%02x%02x%02x%02x)..."
893 "retrying command\n", ha->host_no, b, t, l,
894 rsp_info_len, pkt->rsp_info[0], pkt->rsp_info[1],
895 pkt->rsp_info[2], pkt->rsp_info[3],
896 pkt->rsp_info[4], pkt->rsp_info[5],
897 pkt->rsp_info[6], pkt->rsp_info[7]));
898
899 cp->result = DID_BUS_BUSY << 16;
900 qla2x00_sp_compl(ha, sp);
901 return;
902 }
903 }
904
905 /*
906 * Based on Host and scsi status generate status code for Linux
907 */
908 switch (comp_status) {
909 case CS_COMPLETE:
910 if (scsi_status == 0) {
911 cp->result = DID_OK << 16;
912 break;
913 }
914 if (scsi_status & (SS_RESIDUAL_UNDER | SS_RESIDUAL_OVER)) {
915 resid = le32_to_cpu(pkt->residual_length);
916 cp->resid = resid;
917 CMD_RESID_LEN(cp) = resid;
918 }
919 cp->result = DID_OK << 16 | lscsi_status;
920
921 if (lscsi_status != SS_CHECK_CONDITION)
922 break;
923
924 /*
925 * Copy Sense Data into sense buffer
926 */
927 memset(cp->sense_buffer, 0, sizeof(cp->sense_buffer));
928
929 if (!(scsi_status & SS_SENSE_LEN_VALID))
930 break;
931
932 if (le16_to_cpu(pkt->req_sense_length) <
933 sizeof(cp->sense_buffer))
934 sense_sz = le16_to_cpu(pkt->req_sense_length);
935 else
936 sense_sz = sizeof(cp->sense_buffer);
937
938 CMD_ACTUAL_SNSLEN(cp) = sense_sz;
939 sp->request_sense_length = sense_sz;
940 sp->request_sense_ptr = cp->sense_buffer;
941
942 if (sp->request_sense_length > 32)
943 sense_sz = 32;
944
945 memcpy(cp->sense_buffer, pkt->req_sense_data, sense_sz);
946
947 sp->request_sense_ptr += sense_sz;
948 sp->request_sense_length -= sense_sz;
949 if (sp->request_sense_length != 0)
950 ha->status_srb = sp;
951
952 DEBUG5(printk("%s(): Check condition Sense data, "
953 "scsi(%ld:%d:%d:%d) cmd=%p pid=%ld\n",
954 __func__, ha->host_no, b, t, l, cp,
955 cp->serial_number));
956 if (sense_sz)
957 DEBUG5(qla2x00_dump_buffer(cp->sense_buffer,
958 CMD_ACTUAL_SNSLEN(cp)));
959 break;
960
961 case CS_DATA_UNDERRUN:
962 DEBUG2(printk(KERN_INFO
963 "scsi(%ld:%d:%d) UNDERRUN status detected 0x%x-0x%x.\n",
964 ha->host_no, t, l, comp_status, scsi_status));
965
966 resid = le32_to_cpu(pkt->residual_length);
967 if (scsi_status & SS_RESIDUAL_UNDER) {
968 cp->resid = resid;
969 CMD_RESID_LEN(cp) = resid;
970 }
971
972 /*
973 * Check to see if SCSI Status is non zero. If so report SCSI
974 * Status.
975 */
976 if (lscsi_status != 0) {
977 cp->result = DID_OK << 16 | lscsi_status;
978
979 if (lscsi_status != SS_CHECK_CONDITION)
980 break;
981
982 /* Copy Sense Data into sense buffer */
983 memset(cp->sense_buffer, 0, sizeof(cp->sense_buffer));
984
985 if (!(scsi_status & SS_SENSE_LEN_VALID))
986 break;
987
988 if (le16_to_cpu(pkt->req_sense_length) <
989 sizeof(cp->sense_buffer))
990 sense_sz = le16_to_cpu(pkt->req_sense_length);
991 else
992 sense_sz = sizeof(cp->sense_buffer);
993
994 CMD_ACTUAL_SNSLEN(cp) = sense_sz;
995 sp->request_sense_length = sense_sz;
996 sp->request_sense_ptr = cp->sense_buffer;
997
998 if (sp->request_sense_length > 32)
999 sense_sz = 32;
1000
1001 memcpy(cp->sense_buffer, pkt->req_sense_data, sense_sz);
1002
1003 sp->request_sense_ptr += sense_sz;
1004 sp->request_sense_length -= sense_sz;
1005 if (sp->request_sense_length != 0)
1006 ha->status_srb = sp;
1007
1008 DEBUG5(printk("%s(): Check condition Sense data, "
1009 "scsi(%ld:%d:%d:%d) cmd=%p pid=%ld\n",
1010 __func__, ha->host_no, b, t, l, cp,
1011 cp->serial_number));
1012 if (sense_sz)
1013 DEBUG5(qla2x00_dump_buffer(cp->sense_buffer,
1014 CMD_ACTUAL_SNSLEN(cp)));
1015 } else {
1016 /*
1017 * If RISC reports underrun and target does not report
1018 * it then we must have a lost frame, so tell upper
1019 * layer to retry it by reporting a bus busy.
1020 */
1021 if (!(scsi_status & SS_RESIDUAL_UNDER)) {
1022 DEBUG2(printk("scsi(%ld:%d:%d:%d) Dropped "
1023 "frame(s) detected (%x of %x bytes)..."
1024 "retrying command.\n",
1025 ha->host_no, b, t, l, resid,
1026 cp->request_bufflen));
1027
1028 cp->result = DID_BUS_BUSY << 16;
1029 ha->dropped_frame_error_cnt++;
1030 break;
1031 }
1032
1033 /* Handle mid-layer underflow */
1034 if ((unsigned)(cp->request_bufflen - resid) <
1035 cp->underflow) {
1036 qla_printk(KERN_INFO, ha,
1037 "scsi(%ld:%d:%d:%d): Mid-layer underflow "
1038 "detected (%x of %x bytes)...returning "
1039 "error status.\n",
1040 ha->host_no, b, t, l, resid,
1041 cp->request_bufflen);
1042
1043 cp->result = DID_ERROR << 16;
1044 break;
1045 }
1046
1047 /* Everybody online, looking good... */
1048 cp->result = DID_OK << 16;
1049 }
1050 break;
1051
1052 case CS_DATA_OVERRUN:
1053 DEBUG2(printk(KERN_INFO
1054 "scsi(%ld:%d:%d): OVERRUN status detected 0x%x-0x%x\n",
1055 ha->host_no, t, l, comp_status, scsi_status));
1056 DEBUG2(printk(KERN_INFO
1057 "CDB: 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x\n",
1058 cp->cmnd[0], cp->cmnd[1], cp->cmnd[2], cp->cmnd[3],
1059 cp->cmnd[4], cp->cmnd[5]));
1060 DEBUG2(printk(KERN_INFO
1061 "PID=0x%lx req=0x%x xtra=0x%x -- returning DID_ERROR "
1062 "status!\n",
1063 cp->serial_number, cp->request_bufflen,
1064 le32_to_cpu(pkt->residual_length)));
1065
1066 cp->result = DID_ERROR << 16;
1067 break;
1068
1069 case CS_PORT_LOGGED_OUT:
1070 case CS_PORT_CONFIG_CHG:
1071 case CS_PORT_BUSY:
1072 case CS_INCOMPLETE:
1073 case CS_PORT_UNAVAILABLE:
1074 /*
1075 * If the port is in Target Down state, return all IOs for this
1076 * Target with DID_NO_CONNECT ELSE Queue the IOs in the
1077 * retry_queue.
1078 */
1079 DEBUG2(printk("scsi(%ld:%d:%d): status_entry: Port Down "
1080 "pid=%ld, compl status=0x%x, port state=0x%x\n",
1081 ha->host_no, t, l, cp->serial_number, comp_status,
1082 atomic_read(&fcport->state)));
1083
1084 cp->result = DID_BUS_BUSY << 16;
1085 if (atomic_read(&fcport->state) == FCS_ONLINE) {
1086 qla2x00_mark_device_lost(ha, fcport, 1);
1087 }
1088 break;
1089
1090 case CS_RESET:
1091 DEBUG2(printk(KERN_INFO
1092 "scsi(%ld): RESET status detected 0x%x-0x%x.\n",
1093 ha->host_no, comp_status, scsi_status));
1094
1095 cp->result = DID_RESET << 16;
1096 break;
1097
1098 case CS_ABORTED:
1099 /*
1100 * hv2.19.12 - DID_ABORT does not retry the request if we
1101 * aborted this request then abort otherwise it must be a
1102 * reset.
1103 */
1104 DEBUG2(printk(KERN_INFO
1105 "scsi(%ld): ABORT status detected 0x%x-0x%x.\n",
1106 ha->host_no, comp_status, scsi_status));
1107
1108 cp->result = DID_RESET << 16;
1109 break;
1110
1111 case CS_TIMEOUT:
1112 DEBUG2(printk(KERN_INFO
1113 "scsi(%ld:%d:%d:%d): TIMEOUT status detected 0x%x-0x%x "
1114 "sflags=%x.\n", ha->host_no, b, t, l, comp_status,
1115 scsi_status, le16_to_cpu(pkt->status_flags)));
1116
1117 cp->result = DID_BUS_BUSY << 16;
1118
1119 /* Check to see if logout occurred */
1120 if ((le16_to_cpu(pkt->status_flags) & SF_LOGOUT_SENT)) {
1121 qla2x00_mark_device_lost(ha, fcport, 1);
1122 }
1123 break;
1124
1125 case CS_QUEUE_FULL:
1126 DEBUG2(printk(KERN_INFO
1127 "scsi(%ld): QUEUE FULL status detected 0x%x-0x%x.\n",
1128 ha->host_no, comp_status, scsi_status));
1129
1130 /* SCSI Mid-Layer handles device queue full */
1131
1132 cp->result = DID_OK << 16 | lscsi_status;
1133
1134 break;
1135
1136 default:
1137 DEBUG3(printk("scsi(%ld): Error detected (unknown status) "
1138 "0x%x-0x%x.\n",
1139 ha->host_no, comp_status, scsi_status));
1140 qla_printk(KERN_INFO, ha,
1141 "Unknown status detected 0x%x-0x%x.\n",
1142 comp_status, scsi_status);
1143
1144 cp->result = DID_ERROR << 16;
1145 break;
1146 }
1147
1148 /* Place command on done queue. */
1149 if (ha->status_srb == NULL)
1150 qla2x00_sp_compl(ha, sp);
1151 }
1152
1153 /**
1154 * qla2x00_status_cont_entry() - Process a Status Continuations entry.
1155 * @ha: SCSI driver HA context
1156 * @pkt: Entry pointer
1157 *
1158 * Extended sense data.
1159 */
1160 static void
1161 qla2x00_status_cont_entry(scsi_qla_host_t *ha, sts_cont_entry_t *pkt)
1162 {
1163 uint8_t sense_sz = 0;
1164 srb_t *sp = ha->status_srb;
1165 struct scsi_cmnd *cp;
1166
1167 if (sp != NULL && sp->request_sense_length != 0) {
1168 cp = sp->cmd;
1169 if (cp == NULL) {
1170 DEBUG2(printk("%s(): Cmd already returned back to OS "
1171 "sp=%p sp->state:%d\n", __func__, sp, sp->state));
1172 qla_printk(KERN_INFO, ha,
1173 "cmd is NULL: already returned to OS (sp=%p)\n",
1174 sp);
1175
1176 ha->status_srb = NULL;
1177 return;
1178 }
1179
1180 if (sp->request_sense_length > sizeof(pkt->data)) {
1181 sense_sz = sizeof(pkt->data);
1182 } else {
1183 sense_sz = sp->request_sense_length;
1184 }
1185
1186 /* Move sense data. */
1187 memcpy(sp->request_sense_ptr, pkt->data, sense_sz);
1188 DEBUG5(qla2x00_dump_buffer(sp->request_sense_ptr, sense_sz));
1189
1190 sp->request_sense_ptr += sense_sz;
1191 sp->request_sense_length -= sense_sz;
1192
1193 /* Place command on done queue. */
1194 if (sp->request_sense_length == 0) {
1195 ha->status_srb = NULL;
1196 qla2x00_sp_compl(ha, sp);
1197 }
1198 }
1199 }
1200
1201 /**
1202 * qla2x00_error_entry() - Process an error entry.
1203 * @ha: SCSI driver HA context
1204 * @pkt: Entry pointer
1205 */
1206 static void
1207 qla2x00_error_entry(scsi_qla_host_t *ha, sts_entry_t *pkt)
1208 {
1209 srb_t *sp;
1210
1211 #if defined(QL_DEBUG_LEVEL_2)
1212 if (pkt->entry_status & RF_INV_E_ORDER)
1213 qla_printk(KERN_ERR, ha, "%s: Invalid Entry Order\n", __func__);
1214 else if (pkt->entry_status & RF_INV_E_COUNT)
1215 qla_printk(KERN_ERR, ha, "%s: Invalid Entry Count\n", __func__);
1216 else if (pkt->entry_status & RF_INV_E_PARAM)
1217 qla_printk(KERN_ERR, ha,
1218 "%s: Invalid Entry Parameter\n", __func__);
1219 else if (pkt->entry_status & RF_INV_E_TYPE)
1220 qla_printk(KERN_ERR, ha, "%s: Invalid Entry Type\n", __func__);
1221 else if (pkt->entry_status & RF_BUSY)
1222 qla_printk(KERN_ERR, ha, "%s: Busy\n", __func__);
1223 else
1224 qla_printk(KERN_ERR, ha, "%s: UNKNOWN flag error\n", __func__);
1225 #endif
1226
1227 /* Validate handle. */
1228 if (pkt->handle < MAX_OUTSTANDING_COMMANDS)
1229 sp = ha->outstanding_cmds[pkt->handle];
1230 else
1231 sp = NULL;
1232
1233 if (sp) {
1234 /* Free outstanding command slot. */
1235 ha->outstanding_cmds[pkt->handle] = NULL;
1236 if (ha->actthreads)
1237 ha->actthreads--;
1238 /* Bad payload or header */
1239 if (pkt->entry_status &
1240 (RF_INV_E_ORDER | RF_INV_E_COUNT |
1241 RF_INV_E_PARAM | RF_INV_E_TYPE)) {
1242 sp->cmd->result = DID_ERROR << 16;
1243 } else if (pkt->entry_status & RF_BUSY) {
1244 sp->cmd->result = DID_BUS_BUSY << 16;
1245 } else {
1246 sp->cmd->result = DID_ERROR << 16;
1247 }
1248 qla2x00_sp_compl(ha, sp);
1249
1250 } else if (pkt->entry_type == COMMAND_A64_TYPE ||
1251 pkt->entry_type == COMMAND_TYPE) {
1252 DEBUG2(printk("scsi(%ld): Error entry - invalid handle\n",
1253 ha->host_no));
1254 qla_printk(KERN_WARNING, ha,
1255 "Error entry - invalid handle\n");
1256
1257 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
1258 if (ha->dpc_wait && !ha->dpc_active)
1259 up(ha->dpc_wait);
1260 }
1261 }
1262
1263 /**
1264 * qla2x00_ms_entry() - Process a Management Server entry.
1265 * @ha: SCSI driver HA context
1266 * @index: Response queue out pointer
1267 */
1268 static void
1269 qla2x00_ms_entry(scsi_qla_host_t *ha, ms_iocb_entry_t *pkt)
1270 {
1271 srb_t *sp;
1272
1273 DEBUG3(printk("%s(%ld): pkt=%p pkthandle=%d.\n",
1274 __func__, ha->host_no, pkt, pkt->handle1));
1275
1276 /* Validate handle. */
1277 if (pkt->handle1 < MAX_OUTSTANDING_COMMANDS)
1278 sp = ha->outstanding_cmds[pkt->handle1];
1279 else
1280 sp = NULL;
1281
1282 if (sp == NULL) {
1283 DEBUG2(printk("scsi(%ld): MS entry - invalid handle\n",
1284 ha->host_no));
1285 qla_printk(KERN_WARNING, ha, "MS entry - invalid handle\n");
1286
1287 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
1288 return;
1289 }
1290
1291 CMD_COMPL_STATUS(sp->cmd) = le16_to_cpu(pkt->status);
1292 CMD_ENTRY_STATUS(sp->cmd) = pkt->entry_status;
1293
1294 /* Free outstanding command slot. */
1295 ha->outstanding_cmds[pkt->handle1] = NULL;
1296
1297 qla2x00_sp_compl(ha, sp);
1298 }
Verdex Pro support