projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[PATCH] qla2xxx: add remote port codes...
[linux-2.6-block.git] / drivers / scsi / qla2xxx / qla_isr.c
CommitLineData
1da177e4
LT		 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
21static void qla2x00_mbx_completion(scsi_qla_host_t *, uint16_t);
22static void qla2x00_async_event(scsi_qla_host_t *, uint32_t);
23static void qla2x00_process_completed_request(struct scsi_qla_host *, uint32_t);
24void qla2x00_process_response_queue(struct scsi_qla_host *);
25static void qla2x00_status_entry(scsi_qla_host_t *, sts_entry_t *);
26static void qla2x00_status_cont_entry(scsi_qla_host_t *, sts_cont_entry_t *);
27static void qla2x00_error_entry(scsi_qla_host_t *, sts_entry_t *);
28static void qla2x00_ms_entry(scsi_qla_host_t *, ms_iocb_entry_t *);
29
1da177e4
LT		 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 */
40irqreturn_t
41qla2100_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
1da177e4
LT		 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
1da177e4
LT		 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 */
120irqreturn_t
121qla2300_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
1da177e4
LT		 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
1da177e4
LT		 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 */
224static void
225qla2x00_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 */
261static void
262qla2x00_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 */
677static void
678qla2x00_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 sp->lun_queue->out_cnt--;
701 CMD_COMPL_STATUS(sp->cmd) = 0L;
702 CMD_SCSI_STATUS(sp->cmd) = 0L;
703
704 /* Save ISP completion status */
705 sp->cmd->result = DID_OK << 16;
706 sp->fo_retry_cnt = 0;
f4f051eb 707 qla2x00_sp_compl(ha, sp);
1da177e4
LT		 708 } else {
709 DEBUG2(printk("scsi(%ld): Invalid ISP SCSI completion handle\n",
710 ha->host_no));
711 qla_printk(KERN_WARNING, ha,
712 "Invalid ISP SCSI completion handle\n");
713
714 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
715 }
716}
717
718/**
719 * qla2x00_process_response_queue() - Process response queue entries.
720 * @ha: SCSI driver HA context
721 */
722void
723qla2x00_process_response_queue(struct scsi_qla_host *ha)
724{
725 device_reg_t __iomem *reg = ha->iobase;
726 sts_entry_t *pkt;
727 uint16_t handle_cnt;
728 uint16_t cnt;
729
730 if (!ha->flags.online)
731 return;
732
733 while (ha->response_ring_ptr->signature != RESPONSE_PROCESSED) {
734 pkt = (sts_entry_t *)ha->response_ring_ptr;
735
736 ha->rsp_ring_index++;
737 if (ha->rsp_ring_index == ha->response_q_length) {
738 ha->rsp_ring_index = 0;
739 ha->response_ring_ptr = ha->response_ring;
740 } else {
741 ha->response_ring_ptr++;
742 }
743
744 if (pkt->entry_status != 0) {
745 DEBUG3(printk(KERN_INFO
746 "scsi(%ld): Process error entry.\n", ha->host_no));
747
748 qla2x00_error_entry(ha, pkt);
749 ((response_t *)pkt)->signature = RESPONSE_PROCESSED;
750 wmb();
751 continue;
752 }
753
754 switch (pkt->entry_type) {
755 case STATUS_TYPE:
756 qla2x00_status_entry(ha, pkt);
757 break;
758 case STATUS_TYPE_21:
759 handle_cnt = ((sts21_entry_t *)pkt)->handle_count;
760 for (cnt = 0; cnt < handle_cnt; cnt++) {
761 qla2x00_process_completed_request(ha,
762 ((sts21_entry_t *)pkt)->handle[cnt]);
763 }
764 break;
765 case STATUS_TYPE_22:
766 handle_cnt = ((sts22_entry_t *)pkt)->handle_count;
767 for (cnt = 0; cnt < handle_cnt; cnt++) {
768 qla2x00_process_completed_request(ha,
769 ((sts22_entry_t *)pkt)->handle[cnt]);
770 }
771 break;
772 case STATUS_CONT_TYPE:
773 qla2x00_status_cont_entry(ha, (sts_cont_entry_t *)pkt);
774 break;
775 case MS_IOCB_TYPE:
776 qla2x00_ms_entry(ha, (ms_iocb_entry_t *)pkt);
777 break;
778 case MBX_IOCB_TYPE:
779 if (!IS_QLA2100(ha) && !IS_QLA2200(ha) &&
780 !IS_QLA6312(ha) && !IS_QLA6322(ha)) {
781 if (pkt->sys_define == SOURCE_ASYNC_IOCB) {
782 qla2x00_process_iodesc(ha,
783 (struct mbx_entry *)pkt);
784 } else {
785 /* MBX IOCB Type Not Supported. */
786 DEBUG4(printk(KERN_WARNING
787 "scsi(%ld): Received unknown MBX "
788 "IOCB response pkt type=%x "
789 "source=%x entry status=%x.\n",
790 ha->host_no, pkt->entry_type,
791 pkt->sys_define,
792 pkt->entry_status));
793 }
794 break;
795 }
796 /* Fallthrough. */
797 default:
798 /* Type Not Supported. */
799 DEBUG4(printk(KERN_WARNING
800 "scsi(%ld): Received unknown response pkt type %x "
801 "entry status=%x.\n",
802 ha->host_no, pkt->entry_type, pkt->entry_status));
803 break;
804 }
805 ((response_t *)pkt)->signature = RESPONSE_PROCESSED;
806 wmb();
807 }
808
809 /* Adjust ring index */
810 WRT_REG_WORD(ISP_RSP_Q_OUT(ha, reg), ha->rsp_ring_index);
811}
812
813/**
814 * qla2x00_status_entry() - Process a Status IOCB entry.
815 * @ha: SCSI driver HA context
816 * @pkt: Entry pointer
817 */
818static void
819qla2x00_status_entry(scsi_qla_host_t *ha, sts_entry_t *pkt)
820{
821 int ret;
822 unsigned b, t, l;
823 srb_t *sp;
824 os_lun_t *lq;
825 os_tgt_t *tq;
826 fc_port_t *fcport;
827 struct scsi_cmnd *cp;
828 uint16_t comp_status;
829 uint16_t scsi_status;
830 uint8_t lscsi_status;
831 int32_t resid;
832 uint8_t sense_sz = 0;
833 uint16_t rsp_info_len;
834
835 /* Fast path completion. */
836 if (le16_to_cpu(pkt->comp_status) == CS_COMPLETE &&
837 (le16_to_cpu(pkt->scsi_status) & SS_MASK) == 0) {
838 qla2x00_process_completed_request(ha, pkt->handle);
839
840 return;
841 }
842
843 /* Validate handle. */
844 if (pkt->handle < MAX_OUTSTANDING_COMMANDS) {
845 sp = ha->outstanding_cmds[pkt->handle];
846 ha->outstanding_cmds[pkt->handle] = NULL;
847 } else
848 sp = NULL;
849
850 if (sp == NULL) {
851 DEBUG2(printk("scsi(%ld): Status Entry invalid handle.\n",
852 ha->host_no));
853 qla_printk(KERN_WARNING, ha, "Status Entry invalid handle.\n");
854
855 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
856 if (ha->dpc_wait && !ha->dpc_active)
857 up(ha->dpc_wait);
858
859 return;
860 }
861 cp = sp->cmd;
862 if (cp == NULL) {
863 DEBUG2(printk("scsi(%ld): Command already returned back to OS "
864 "pkt->handle=%d sp=%p sp->state:%d\n",
865 ha->host_no, pkt->handle, sp, sp->state));
866 qla_printk(KERN_WARNING, ha,
867 "Command is NULL: already returned to OS (sp=%p)\n", sp);
868
869 return;
870 }
871
872 if (ha->actthreads)
873 ha->actthreads--;
874
875 if (sp->lun_queue == NULL) {
876 DEBUG2(printk("scsi(%ld): Status Entry invalid lun pointer.\n",
877 ha->host_no));
878 qla_printk(KERN_WARNING, ha,
879 "Status Entry invalid lun pointer.\n");
880
881 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
882 if (ha->dpc_wait && !ha->dpc_active)
883 up(ha->dpc_wait);
884
885 return;
886 }
887
888 sp->lun_queue->out_cnt--;
889
890 comp_status = le16_to_cpu(pkt->comp_status);
891 /* Mask of reserved bits 12-15, before we examine the scsi status */
892 scsi_status = le16_to_cpu(pkt->scsi_status) & SS_MASK;
893 lscsi_status = scsi_status & STATUS_MASK;
894
895 CMD_ENTRY_STATUS(cp) = pkt->entry_status;
896 CMD_COMPL_STATUS(cp) = comp_status;
897 CMD_SCSI_STATUS(cp) = scsi_status;
898
899 /* Generate LU queue on cntrl, target, LUN */
900 b = cp->device->channel;
901 t = cp->device->id;
902 l = cp->device->lun,
903
904 tq = sp->tgt_queue;
905 lq = sp->lun_queue;
906
1da177e4
LT		 907 /* Check for any FCP transport errors. */
908 if (scsi_status & SS_RESPONSE_INFO_LEN_VALID) {
909 rsp_info_len = le16_to_cpu(pkt->rsp_info_len);
910 if (rsp_info_len > 3 && pkt->rsp_info[3]) {
911 DEBUG2(printk("scsi(%ld:%d:%d:%d) FCP I/O protocol "
912 "failure (%x/%02x%02x%02x%02x%02x%02x%02x%02x)..."
913 "retrying command\n", ha->host_no, b, t, l,
914 rsp_info_len, pkt->rsp_info[0], pkt->rsp_info[1],
915 pkt->rsp_info[2], pkt->rsp_info[3],
916 pkt->rsp_info[4], pkt->rsp_info[5],
917 pkt->rsp_info[6], pkt->rsp_info[7]));
918
919 cp->result = DID_BUS_BUSY << 16;
f4f051eb 920 qla2x00_sp_compl(ha, sp);
1da177e4
LT		 921 return;
922 }
923 }
924
925 /*
926 * Based on Host and scsi status generate status code for Linux
927 */
928 switch (comp_status) {
929 case CS_COMPLETE:
930 if (scsi_status == 0) {
931 cp->result = DID_OK << 16;
932 break;
933 }
934 if (scsi_status & (SS_RESIDUAL_UNDER | SS_RESIDUAL_OVER)) {
935 resid = le32_to_cpu(pkt->residual_length);
936 cp->resid = resid;
937 CMD_RESID_LEN(cp) = resid;
938 }
1da177e4
LT		 939 cp->result = DID_OK << 16 | lscsi_status;
940
941 if (lscsi_status != SS_CHECK_CONDITION)
942 break;
943
944 /*
945 * Copy Sense Data into sense buffer
946 */
947 memset(cp->sense_buffer, 0, sizeof(cp->sense_buffer));
948
949 if (!(scsi_status & SS_SENSE_LEN_VALID))
950 break;
951
952 if (le16_to_cpu(pkt->req_sense_length) <
953 sizeof(cp->sense_buffer))
954 sense_sz = le16_to_cpu(pkt->req_sense_length);
955 else
956 sense_sz = sizeof(cp->sense_buffer);
957
958 CMD_ACTUAL_SNSLEN(cp) = sense_sz;
959 sp->request_sense_length = sense_sz;
960 sp->request_sense_ptr = cp->sense_buffer;
961
962 if (sp->request_sense_length > 32)
963 sense_sz = 32;
964
965 memcpy(cp->sense_buffer, pkt->req_sense_data, sense_sz);
966
967 sp->request_sense_ptr += sense_sz;
968 sp->request_sense_length -= sense_sz;
969 if (sp->request_sense_length != 0)
970 ha->status_srb = sp;
971
1da177e4
LT		 972 DEBUG5(printk("%s(): Check condition Sense data, "
973 "scsi(%ld:%d:%d:%d) cmd=%p pid=%ld\n",
974 __func__, ha->host_no, b, t, l, cp,
975 cp->serial_number));
976 if (sense_sz)
977 DEBUG5(qla2x00_dump_buffer(cp->sense_buffer,
978 CMD_ACTUAL_SNSLEN(cp)));
979 break;
980
981 case CS_DATA_UNDERRUN:
982 DEBUG2(printk(KERN_INFO
983 "scsi(%ld:%d:%d) UNDERRUN status detected 0x%x-0x%x.\n",
984 ha->host_no, t, l, comp_status, scsi_status));
985
986 resid = le32_to_cpu(pkt->residual_length);
987 if (scsi_status & SS_RESIDUAL_UNDER) {
988 cp->resid = resid;
989 CMD_RESID_LEN(cp) = resid;
990 }
991
992 /*
993 * Check to see if SCSI Status is non zero. If so report SCSI
994 * Status.
995 */
996 if (lscsi_status != 0) {
1da177e4
LT		 997 cp->result = DID_OK << 16 | lscsi_status;
998
999 if (lscsi_status != SS_CHECK_CONDITION)
1000 break;
1001
1002 /* Copy Sense Data into sense buffer */
1003 memset(cp->sense_buffer, 0, sizeof(cp->sense_buffer));
1004
1005 if (!(scsi_status & SS_SENSE_LEN_VALID))
1006 break;
1007
1008 if (le16_to_cpu(pkt->req_sense_length) <
1009 sizeof(cp->sense_buffer))
1010 sense_sz = le16_to_cpu(pkt->req_sense_length);
1011 else
1012 sense_sz = sizeof(cp->sense_buffer);
1013
1014 CMD_ACTUAL_SNSLEN(cp) = sense_sz;
1015 sp->request_sense_length = sense_sz;
1016 sp->request_sense_ptr = cp->sense_buffer;
1017
1018 if (sp->request_sense_length > 32)
1019 sense_sz = 32;
1020
1021 memcpy(cp->sense_buffer, pkt->req_sense_data, sense_sz);
1022
1023 sp->request_sense_ptr += sense_sz;
1024 sp->request_sense_length -= sense_sz;
1025 if (sp->request_sense_length != 0)
1026 ha->status_srb = sp;
1027
1da177e4
LT		 1028 DEBUG5(printk("%s(): Check condition Sense data, "
1029 "scsi(%ld:%d:%d:%d) cmd=%p pid=%ld\n",
1030 __func__, ha->host_no, b, t, l, cp,
1031 cp->serial_number));
1032 if (sense_sz)
1033 DEBUG5(qla2x00_dump_buffer(cp->sense_buffer,
1034 CMD_ACTUAL_SNSLEN(cp)));
1035 } else {
1036 /*
1037 * If RISC reports underrun and target does not report
1038 * it then we must have a lost frame, so tell upper
1039 * layer to retry it by reporting a bus busy.
1040 */
1041 if (!(scsi_status & SS_RESIDUAL_UNDER)) {
1042 DEBUG2(printk("scsi(%ld:%d:%d:%d) Dropped "
1043 "frame(s) detected (%x of %x bytes)..."
1044 "retrying command.\n",
1045 ha->host_no, b, t, l, resid,
1046 cp->request_bufflen));
1047
1048 cp->result = DID_BUS_BUSY << 16;
1049 ha->dropped_frame_error_cnt++;
1050 break;
1051 }
1052
1053 /* Handle mid-layer underflow */
1054 if ((unsigned)(cp->request_bufflen - resid) <
1055 cp->underflow) {
1056 qla_printk(KERN_INFO, ha,
1057 "scsi(%ld:%d:%d:%d): Mid-layer underflow "
1058 "detected (%x of %x bytes)...returning "
1059 "error status.\n",
1060 ha->host_no, b, t, l, resid,
1061 cp->request_bufflen);
1062
1063 cp->result = DID_ERROR << 16;
1064 break;
1065 }
1066
1067 /* Everybody online, looking good... */
1068 cp->result = DID_OK << 16;
1069 }
1070 break;
1071
1072 case CS_DATA_OVERRUN:
1073 DEBUG2(printk(KERN_INFO
1074 "scsi(%ld:%d:%d): OVERRUN status detected 0x%x-0x%x\n",
1075 ha->host_no, t, l, comp_status, scsi_status));
1076 DEBUG2(printk(KERN_INFO
1077 "CDB: 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x\n",
1078 cp->cmnd[0], cp->cmnd[1], cp->cmnd[2], cp->cmnd[3],
1079 cp->cmnd[4], cp->cmnd[5]));
1080 DEBUG2(printk(KERN_INFO
1081 "PID=0x%lx req=0x%x xtra=0x%x -- returning DID_ERROR "
1082 "status!\n",
1083 cp->serial_number, cp->request_bufflen,
1084 le32_to_cpu(pkt->residual_length)));
1085
1086 cp->result = DID_ERROR << 16;
1087 break;
1088
1089 case CS_PORT_LOGGED_OUT:
1090 case CS_PORT_CONFIG_CHG:
1091 case CS_PORT_BUSY:
1092 case CS_INCOMPLETE:
1093 case CS_PORT_UNAVAILABLE:
1094 /*
1095 * If the port is in Target Down state, return all IOs for this
1096 * Target with DID_NO_CONNECT ELSE Queue the IOs in the
1097 * retry_queue.
1098 */
1099 fcport = sp->fclun->fcport;
1100 DEBUG2(printk("scsi(%ld:%d:%d): status_entry: Port Down "
1101 "pid=%ld, compl status=0x%x, port state=0x%x\n",
1102 ha->host_no, t, l, cp->serial_number, comp_status,
1103 atomic_read(&fcport->state)));
1104
f4f051eb 1105 cp->result = DID_BUS_BUSY << 16;
1da177e4
LT		 1106 if (atomic_read(&fcport->state) == FCS_ONLINE) {
1107 qla2x00_mark_device_lost(ha, fcport, 1);
1108 }
1da177e4
LT		 1109 break;
1110
1111 case CS_RESET:
1112 DEBUG2(printk(KERN_INFO
1113 "scsi(%ld): RESET status detected 0x%x-0x%x.\n",
1114 ha->host_no, comp_status, scsi_status));
1115
f4f051eb 1116 cp->result = DID_RESET << 16;
1da177e4
LT		 1117 break;
1118
1119 case CS_ABORTED:
1120 /*
1121 * hv2.19.12 - DID_ABORT does not retry the request if we
1122 * aborted this request then abort otherwise it must be a
1123 * reset.
1124 */
1125 DEBUG2(printk(KERN_INFO
1126 "scsi(%ld): ABORT status detected 0x%x-0x%x.\n",
1127 ha->host_no, comp_status, scsi_status));
1128
1129 cp->result = DID_RESET << 16;
1130 break;
1131
1132 case CS_TIMEOUT:
1133 DEBUG2(printk(KERN_INFO
1134 "scsi(%ld:%d:%d:%d): TIMEOUT status detected 0x%x-0x%x "
1135 "sflags=%x.\n", ha->host_no, b, t, l, comp_status,
1136 scsi_status, le16_to_cpu(pkt->status_flags)));
1137
1138 cp->result = DID_BUS_BUSY << 16;
1139
1140 fcport = lq->fclun->fcport;
1141
1142 /* Check to see if logout occurred */
1143 if ((le16_to_cpu(pkt->status_flags) & SF_LOGOUT_SENT)) {
1144 qla2x00_mark_device_lost(ha, fcport, 1);
1145 }
1146 break;
1147
1148 case CS_QUEUE_FULL:
1149 DEBUG2(printk(KERN_INFO
1150 "scsi(%ld): QUEUE FULL status detected 0x%x-0x%x.\n",
1151 ha->host_no, comp_status, scsi_status));
1152
1153 /* SCSI Mid-Layer handles device queue full */
1154
1155 cp->result = DID_OK << 16 | lscsi_status;
1156
1157 /* TODO: ??? */
1158 /* Adjust queue depth */
1159 ret = scsi_track_queue_full(cp->device,
1160 sp->lun_queue->out_cnt - 1);
1161 if (ret) {
1162 qla_printk(KERN_INFO, ha,
1163 "scsi(%ld:%d:%d:%d): Queue depth adjusted to %d.\n",
1164 ha->host_no, cp->device->channel, cp->device->id,
1165 cp->device->lun, ret);
1166 }
1167 break;
1168
1169 default:
1170 DEBUG3(printk("scsi(%ld): Error detected (unknown status) "
1171 "0x%x-0x%x.\n",
1172 ha->host_no, comp_status, scsi_status));
1173 qla_printk(KERN_INFO, ha,
1174 "Unknown status detected 0x%x-0x%x.\n",
1175 comp_status, scsi_status);
1176
1177 cp->result = DID_ERROR << 16;
1178 break;
1179 }
1180
1181 /* Place command on done queue. */
1182 if (ha->status_srb == NULL)
f4f051eb 1183 qla2x00_sp_compl(ha, sp);
1da177e4
LT		 1184}
1185
1186/**
1187 * qla2x00_status_cont_entry() - Process a Status Continuations entry.
1188 * @ha: SCSI driver HA context
1189 * @pkt: Entry pointer
1190 *
1191 * Extended sense data.
1192 */
1193static void
1194qla2x00_status_cont_entry(scsi_qla_host_t *ha, sts_cont_entry_t *pkt)
1195{
1196 uint8_t sense_sz = 0;
1197 srb_t *sp = ha->status_srb;
1198 struct scsi_cmnd *cp;
1199
1200 if (sp != NULL && sp->request_sense_length != 0) {
1201 cp = sp->cmd;
1202 if (cp == NULL) {
1203 DEBUG2(printk("%s(): Cmd already returned back to OS "
1204 "sp=%p sp->state:%d\n", __func__, sp, sp->state));
1205 qla_printk(KERN_INFO, ha,
1206 "cmd is NULL: already returned to OS (sp=%p)\n",
1207 sp);
1208
1209 ha->status_srb = NULL;
1210 return;
1211 }
1212
1213 if (sp->request_sense_length > sizeof(pkt->data)) {
1214 sense_sz = sizeof(pkt->data);
1215 } else {
1216 sense_sz = sp->request_sense_length;
1217 }
1218
1219 /* Move sense data. */
1220 memcpy(sp->request_sense_ptr, pkt->data, sense_sz);
1221 DEBUG5(qla2x00_dump_buffer(sp->request_sense_ptr, sense_sz));
1222
1223 sp->request_sense_ptr += sense_sz;
1224 sp->request_sense_length -= sense_sz;
1225
1226 /* Place command on done queue. */
1227 if (sp->request_sense_length == 0) {
1da177e4 1228 ha->status_srb = NULL;
f4f051eb 1229 qla2x00_sp_compl(ha, sp);
1da177e4
LT		 1230 }
1231 }
1232}
1233
1234/**
1235 * qla2x00_error_entry() - Process an error entry.
1236 * @ha: SCSI driver HA context
1237 * @pkt: Entry pointer
1238 */
1239static void
1240qla2x00_error_entry(scsi_qla_host_t *ha, sts_entry_t *pkt)
1241{
1242 srb_t *sp;
1243
1244#if defined(QL_DEBUG_LEVEL_2)
1245 if (pkt->entry_status & RF_INV_E_ORDER)
1246 qla_printk(KERN_ERR, ha, "%s: Invalid Entry Order\n", __func__);
1247 else if (pkt->entry_status & RF_INV_E_COUNT)
1248 qla_printk(KERN_ERR, ha, "%s: Invalid Entry Count\n", __func__);
1249 else if (pkt->entry_status & RF_INV_E_PARAM)
1250 qla_printk(KERN_ERR, ha,
1251 "%s: Invalid Entry Parameter\n", __func__);
1252 else if (pkt->entry_status & RF_INV_E_TYPE)
1253 qla_printk(KERN_ERR, ha, "%s: Invalid Entry Type\n", __func__);
1254 else if (pkt->entry_status & RF_BUSY)
1255 qla_printk(KERN_ERR, ha, "%s: Busy\n", __func__);
1256 else
1257 qla_printk(KERN_ERR, ha, "%s: UNKNOWN flag error\n", __func__);
1258#endif
1259
1260 /* Validate handle. */
1261 if (pkt->handle < MAX_OUTSTANDING_COMMANDS)
1262 sp = ha->outstanding_cmds[pkt->handle];
1263 else
1264 sp = NULL;
1265
1266 if (sp) {
1267 /* Free outstanding command slot. */
1268 ha->outstanding_cmds[pkt->handle] = NULL;
1269 if (ha->actthreads)
1270 ha->actthreads--;
1271 sp->lun_queue->out_cnt--;
1272
1273 /* Bad payload or header */
1274 if (pkt->entry_status &
1275 (RF_INV_E_ORDER | RF_INV_E_COUNT |
1276 RF_INV_E_PARAM | RF_INV_E_TYPE)) {
1277 sp->cmd->result = DID_ERROR << 16;
1278 } else if (pkt->entry_status & RF_BUSY) {
1279 sp->cmd->result = DID_BUS_BUSY << 16;
1280 } else {
1281 sp->cmd->result = DID_ERROR << 16;
1282 }
f4f051eb 1283 qla2x00_sp_compl(ha, sp);
1da177e4
LT		 1284
1285 } else if (pkt->entry_type == COMMAND_A64_TYPE ||
1286 pkt->entry_type == COMMAND_TYPE) {
1287 DEBUG2(printk("scsi(%ld): Error entry - invalid handle\n",
1288 ha->host_no));
1289 qla_printk(KERN_WARNING, ha,
1290 "Error entry - invalid handle\n");
1291
1292 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
1293 if (ha->dpc_wait && !ha->dpc_active)
1294 up(ha->dpc_wait);
1295 }
1296}
1297
1298/**
1299 * qla2x00_ms_entry() - Process a Management Server entry.
1300 * @ha: SCSI driver HA context
1301 * @index: Response queue out pointer
1302 */
1303static void
1304qla2x00_ms_entry(scsi_qla_host_t *ha, ms_iocb_entry_t *pkt)
1305{
1306 srb_t *sp;
1307
1308 DEBUG3(printk("%s(%ld): pkt=%p pkthandle=%d.\n",
1309 __func__, ha->host_no, pkt, pkt->handle1));
1310
1311 /* Validate handle. */
1312 if (pkt->handle1 < MAX_OUTSTANDING_COMMANDS)
1313 sp = ha->outstanding_cmds[pkt->handle1];
1314 else
1315 sp = NULL;
1316
1317 if (sp == NULL) {
1318 DEBUG2(printk("scsi(%ld): MS entry - invalid handle\n",
1319 ha->host_no));
1320 qla_printk(KERN_WARNING, ha, "MS entry - invalid handle\n");
1321
1322 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
1323 return;
1324 }
1325
1326 CMD_COMPL_STATUS(sp->cmd) = le16_to_cpu(pkt->status);
1327 CMD_ENTRY_STATUS(sp->cmd) = pkt->entry_status;
1328
1329 /* Free outstanding command slot. */
1330 ha->outstanding_cmds[pkt->handle1] = NULL;
1331
f4f051eb 1332 qla2x00_sp_compl(ha, sp);
1da177e4 1333}
Linux 6.x block layer and io_uring tree(s)