blob: 9eb6ef33304486df9af4d1594391ab7b62196748 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Andrew Vasquezfa90c542005-10-27 11:10:08 -07002 * QLogic Fibre Channel HBA Driver
Andrew Vasquez01e58d82008-04-03 13:13:13 -07003 * Copyright (c) 2003-2008 QLogic Corporation
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 *
Andrew Vasquezfa90c542005-10-27 11:10:08 -07005 * See LICENSE.qla2xxx for copyright and licensing details.
Linus Torvalds1da177e2005-04-16 15:20:36 -07006 */
7#include "qla_def.h"
8
Andrew Vasquez05236a02007-09-20 14:07:37 -07009#include <linux/delay.h>
Andrew Vasquezdf7baa52006-10-13 09:33:39 -070010#include <scsi/scsi_tcq.h>
11
Linus Torvalds1da177e2005-04-16 15:20:36 -070012static void qla2x00_mbx_completion(scsi_qla_host_t *, uint16_t);
Linus Torvalds1da177e2005-04-16 15:20:36 -070013static void qla2x00_process_completed_request(struct scsi_qla_host *, uint32_t);
Andrew Vasquez9a853f72005-07-06 10:31:27 -070014static void qla2x00_status_entry(scsi_qla_host_t *, void *);
Linus Torvalds1da177e2005-04-16 15:20:36 -070015static void qla2x00_status_cont_entry(scsi_qla_host_t *, sts_cont_entry_t *);
16static void qla2x00_error_entry(scsi_qla_host_t *, sts_entry_t *);
Andrew Vasquez9a853f72005-07-06 10:31:27 -070017
Linus Torvalds1da177e2005-04-16 15:20:36 -070018/**
19 * qla2100_intr_handler() - Process interrupts for the ISP2100 and ISP2200.
20 * @irq:
21 * @dev_id: SCSI driver HA context
Linus Torvalds1da177e2005-04-16 15:20:36 -070022 *
23 * Called by system whenever the host adapter generates an interrupt.
24 *
25 * Returns handled flag.
26 */
27irqreturn_t
David Howells7d12e782006-10-05 14:55:46 +010028qla2100_intr_handler(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -070029{
30 scsi_qla_host_t *ha;
Andrew Vasquez3d716442005-07-06 10:30:26 -070031 struct device_reg_2xxx __iomem *reg;
Linus Torvalds1da177e2005-04-16 15:20:36 -070032 int status;
Linus Torvalds1da177e2005-04-16 15:20:36 -070033 unsigned long iter;
Seokmann Ju14e660e2007-09-20 14:07:36 -070034 uint16_t hccr;
Andrew Vasquez9a853f72005-07-06 10:31:27 -070035 uint16_t mb[4];
Linus Torvalds1da177e2005-04-16 15:20:36 -070036
37 ha = (scsi_qla_host_t *) dev_id;
38 if (!ha) {
39 printk(KERN_INFO
40 "%s(): NULL host pointer\n", __func__);
41 return (IRQ_NONE);
42 }
43
Andrew Vasquez3d716442005-07-06 10:30:26 -070044 reg = &ha->iobase->isp;
Linus Torvalds1da177e2005-04-16 15:20:36 -070045 status = 0;
46
Andrew Vasquezc6952482008-04-03 13:13:17 -070047 spin_lock(&ha->hardware_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070048 for (iter = 50; iter--; ) {
Seokmann Ju14e660e2007-09-20 14:07:36 -070049 hccr = RD_REG_WORD(&reg->hccr);
50 if (hccr & HCCR_RISC_PAUSE) {
51 if (pci_channel_offline(ha->pdev))
52 break;
53
54 /*
55 * Issue a "HARD" reset in order for the RISC interrupt
56 * bit to be cleared. Schedule a big hammmer to get
57 * out of the RISC PAUSED state.
58 */
59 WRT_REG_WORD(&reg->hccr, HCCR_RESET_RISC);
60 RD_REG_WORD(&reg->hccr);
61
62 ha->isp_ops->fw_dump(ha, 1);
63 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
64 break;
65 } else if ((RD_REG_WORD(&reg->istatus) & ISR_RISC_INT) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -070066 break;
67
68 if (RD_REG_WORD(&reg->semaphore) & BIT_0) {
69 WRT_REG_WORD(&reg->hccr, HCCR_CLR_RISC_INT);
70 RD_REG_WORD(&reg->hccr);
71
72 /* Get mailbox data. */
Andrew Vasquez9a853f72005-07-06 10:31:27 -070073 mb[0] = RD_MAILBOX_REG(ha, reg, 0);
74 if (mb[0] > 0x3fff && mb[0] < 0x8000) {
75 qla2x00_mbx_completion(ha, mb[0]);
Linus Torvalds1da177e2005-04-16 15:20:36 -070076 status |= MBX_INTERRUPT;
Andrew Vasquez9a853f72005-07-06 10:31:27 -070077 } else if (mb[0] > 0x7fff && mb[0] < 0xc000) {
78 mb[1] = RD_MAILBOX_REG(ha, reg, 1);
79 mb[2] = RD_MAILBOX_REG(ha, reg, 2);
80 mb[3] = RD_MAILBOX_REG(ha, reg, 3);
81 qla2x00_async_event(ha, mb);
Linus Torvalds1da177e2005-04-16 15:20:36 -070082 } else {
83 /*EMPTY*/
84 DEBUG2(printk("scsi(%ld): Unrecognized "
Andrew Vasquez9a853f72005-07-06 10:31:27 -070085 "interrupt type (%d).\n",
86 ha->host_no, mb[0]));
Linus Torvalds1da177e2005-04-16 15:20:36 -070087 }
88 /* Release mailbox registers. */
89 WRT_REG_WORD(&reg->semaphore, 0);
90 RD_REG_WORD(&reg->semaphore);
91 } else {
92 qla2x00_process_response_queue(ha);
93
94 WRT_REG_WORD(&reg->hccr, HCCR_CLR_RISC_INT);
95 RD_REG_WORD(&reg->hccr);
96 }
97 }
Andrew Vasquezc6952482008-04-03 13:13:17 -070098 spin_unlock(&ha->hardware_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070099
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100 if (test_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags) &&
101 (status & MBX_INTERRUPT) && ha->flags.mbox_int) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102 set_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
Marcus Barrow0b05a1f2008-01-17 09:02:13 -0800103 complete(&ha->mbx_intr_comp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104 }
105
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106 return (IRQ_HANDLED);
107}
108
109/**
110 * qla2300_intr_handler() - Process interrupts for the ISP23xx and ISP63xx.
111 * @irq:
112 * @dev_id: SCSI driver HA context
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113 *
114 * Called by system whenever the host adapter generates an interrupt.
115 *
116 * Returns handled flag.
117 */
118irqreturn_t
David Howells7d12e782006-10-05 14:55:46 +0100119qla2300_intr_handler(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120{
121 scsi_qla_host_t *ha;
Andrew Vasquez3d716442005-07-06 10:30:26 -0700122 struct device_reg_2xxx __iomem *reg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123 int status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124 unsigned long iter;
125 uint32_t stat;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126 uint16_t hccr;
Andrew Vasquez9a853f72005-07-06 10:31:27 -0700127 uint16_t mb[4];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128
129 ha = (scsi_qla_host_t *) dev_id;
130 if (!ha) {
131 printk(KERN_INFO
132 "%s(): NULL host pointer\n", __func__);
133 return (IRQ_NONE);
134 }
135
Andrew Vasquez3d716442005-07-06 10:30:26 -0700136 reg = &ha->iobase->isp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137 status = 0;
138
Andrew Vasquezc6952482008-04-03 13:13:17 -0700139 spin_lock(&ha->hardware_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140 for (iter = 50; iter--; ) {
141 stat = RD_REG_DWORD(&reg->u.isp2300.host_status);
142 if (stat & HSR_RISC_PAUSED) {
Seokmann Ju14e660e2007-09-20 14:07:36 -0700143 if (pci_channel_offline(ha->pdev))
144 break;
145
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146 hccr = RD_REG_WORD(&reg->hccr);
147 if (hccr & (BIT_15 | BIT_13 | BIT_11 | BIT_8))
Andrew Vasquez07f31802006-12-13 19:20:31 -0800148 qla_printk(KERN_INFO, ha, "Parity error -- "
149 "HCCR=%x, Dumping firmware!\n", hccr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150 else
Andrew Vasquez07f31802006-12-13 19:20:31 -0800151 qla_printk(KERN_INFO, ha, "RISC paused -- "
152 "HCCR=%x, Dumping firmware!\n", hccr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153
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);
Andrew Vasquez07f31802006-12-13 19:20:31 -0800161
Andrew Vasquezfd34f552007-07-19 15:06:00 -0700162 ha->isp_ops->fw_dump(ha, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
164 break;
165 } else if ((stat & HSR_RISC_INT) == 0)
166 break;
167
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168 switch (stat & 0xff) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169 case 0x1:
170 case 0x2:
171 case 0x10:
172 case 0x11:
Andrew Vasquez9a853f72005-07-06 10:31:27 -0700173 qla2x00_mbx_completion(ha, MSW(stat));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174 status |= MBX_INTERRUPT;
175
176 /* Release mailbox registers. */
177 WRT_REG_WORD(&reg->semaphore, 0);
178 break;
179 case 0x12:
Andrew Vasquez9a853f72005-07-06 10:31:27 -0700180 mb[0] = MSW(stat);
181 mb[1] = RD_MAILBOX_REG(ha, reg, 1);
182 mb[2] = RD_MAILBOX_REG(ha, reg, 2);
183 mb[3] = RD_MAILBOX_REG(ha, reg, 3);
184 qla2x00_async_event(ha, mb);
185 break;
186 case 0x13:
187 qla2x00_process_response_queue(ha);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188 break;
189 case 0x15:
Andrew Vasquez9a853f72005-07-06 10:31:27 -0700190 mb[0] = MBA_CMPLT_1_16BIT;
191 mb[1] = MSW(stat);
192 qla2x00_async_event(ha, mb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193 break;
194 case 0x16:
Andrew Vasquez9a853f72005-07-06 10:31:27 -0700195 mb[0] = MBA_SCSI_COMPLETION;
196 mb[1] = MSW(stat);
197 mb[2] = RD_MAILBOX_REG(ha, reg, 2);
198 qla2x00_async_event(ha, mb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199 break;
200 default:
201 DEBUG2(printk("scsi(%ld): Unrecognized interrupt type "
Andrew Vasquez9a853f72005-07-06 10:31:27 -0700202 "(%d).\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 ha->host_no, stat & 0xff));
204 break;
205 }
206 WRT_REG_WORD(&reg->hccr, HCCR_CLR_RISC_INT);
207 RD_REG_WORD_RELAXED(&reg->hccr);
208 }
Andrew Vasquezc6952482008-04-03 13:13:17 -0700209 spin_unlock(&ha->hardware_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 if (test_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags) &&
212 (status & MBX_INTERRUPT) && ha->flags.mbox_int) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 set_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
Marcus Barrow0b05a1f2008-01-17 09:02:13 -0800214 complete(&ha->mbx_intr_comp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215 }
216
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217 return (IRQ_HANDLED);
218}
219
220/**
221 * qla2x00_mbx_completion() - Process mailbox command completions.
222 * @ha: SCSI driver HA context
223 * @mb0: Mailbox0 register
224 */
225static void
226qla2x00_mbx_completion(scsi_qla_host_t *ha, uint16_t mb0)
227{
228 uint16_t cnt;
229 uint16_t __iomem *wptr;
Andrew Vasquez3d716442005-07-06 10:30:26 -0700230 struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231
232 /* Load return mailbox registers. */
233 ha->flags.mbox_int = 1;
234 ha->mailbox_out[0] = mb0;
235 wptr = (uint16_t __iomem *)MAILBOX_REG(ha, reg, 1);
236
237 for (cnt = 1; cnt < ha->mbx_count; cnt++) {
Andrew Vasquezfa2a1ce2005-07-06 10:32:07 -0700238 if (IS_QLA2200(ha) && cnt == 8)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239 wptr = (uint16_t __iomem *)MAILBOX_REG(ha, reg, 8);
240 if (cnt == 4 || cnt == 5)
241 ha->mailbox_out[cnt] = qla2x00_debounce_register(wptr);
242 else
243 ha->mailbox_out[cnt] = RD_REG_WORD(wptr);
Andrew Vasquezfa2a1ce2005-07-06 10:32:07 -0700244
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 wptr++;
246 }
247
248 if (ha->mcp) {
249 DEBUG3(printk("%s(%ld): Got mailbox completion. cmd=%x.\n",
250 __func__, ha->host_no, ha->mcp->mb[0]));
251 } else {
252 DEBUG2_3(printk("%s(%ld): MBX pointer ERROR!\n",
253 __func__, ha->host_no));
254 }
255}
256
257/**
258 * qla2x00_async_event() - Process aynchronous events.
259 * @ha: SCSI driver HA context
Andrew Vasquez9a853f72005-07-06 10:31:27 -0700260 * @mb: Mailbox registers (0 - 3)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 */
Seokmann Ju2c3dfe32007-07-05 13:16:51 -0700262void
Andrew Vasquez9a853f72005-07-06 10:31:27 -0700263qla2x00_async_event(scsi_qla_host_t *ha, uint16_t *mb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264{
Andrew Vasquez9a853f72005-07-06 10:31:27 -0700265#define LS_UNKNOWN 2
Andrew Vasquezc3a2f0d2007-07-19 20:37:34 -0700266 static char *link_speeds[5] = { "1", "2", "?", "4", "8" };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267 char *link_speed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268 uint16_t handle_cnt;
269 uint16_t cnt;
270 uint32_t handles[5];
Andrew Vasquez3d716442005-07-06 10:30:26 -0700271 struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272 uint32_t rscn_entry, host_pid;
273 uint8_t rscn_queue_index;
Harihara Kadayam4d4df192008-04-03 13:13:26 -0700274 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275
276 /* Setup to process RIO completion. */
277 handle_cnt = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278 switch (mb[0]) {
279 case MBA_SCSI_COMPLETION:
Andrew Vasquez9a853f72005-07-06 10:31:27 -0700280 handles[0] = le32_to_cpu((uint32_t)((mb[2] << 16) | mb[1]));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 handle_cnt = 1;
282 break;
283 case MBA_CMPLT_1_16BIT:
Andrew Vasquez9a853f72005-07-06 10:31:27 -0700284 handles[0] = mb[1];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 handle_cnt = 1;
286 mb[0] = MBA_SCSI_COMPLETION;
287 break;
288 case MBA_CMPLT_2_16BIT:
Andrew Vasquez9a853f72005-07-06 10:31:27 -0700289 handles[0] = mb[1];
290 handles[1] = mb[2];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 handle_cnt = 2;
292 mb[0] = MBA_SCSI_COMPLETION;
293 break;
294 case MBA_CMPLT_3_16BIT:
Andrew Vasquez9a853f72005-07-06 10:31:27 -0700295 handles[0] = mb[1];
296 handles[1] = mb[2];
297 handles[2] = mb[3];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298 handle_cnt = 3;
299 mb[0] = MBA_SCSI_COMPLETION;
300 break;
301 case MBA_CMPLT_4_16BIT:
Andrew Vasquez9a853f72005-07-06 10:31:27 -0700302 handles[0] = mb[1];
303 handles[1] = mb[2];
304 handles[2] = mb[3];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305 handles[3] = (uint32_t)RD_MAILBOX_REG(ha, reg, 6);
306 handle_cnt = 4;
307 mb[0] = MBA_SCSI_COMPLETION;
308 break;
309 case MBA_CMPLT_5_16BIT:
Andrew Vasquez9a853f72005-07-06 10:31:27 -0700310 handles[0] = mb[1];
311 handles[1] = mb[2];
312 handles[2] = mb[3];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 handles[3] = (uint32_t)RD_MAILBOX_REG(ha, reg, 6);
314 handles[4] = (uint32_t)RD_MAILBOX_REG(ha, reg, 7);
315 handle_cnt = 5;
316 mb[0] = MBA_SCSI_COMPLETION;
317 break;
318 case MBA_CMPLT_2_32BIT:
Andrew Vasquez9a853f72005-07-06 10:31:27 -0700319 handles[0] = le32_to_cpu((uint32_t)((mb[2] << 16) | mb[1]));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 handles[1] = le32_to_cpu(
321 ((uint32_t)(RD_MAILBOX_REG(ha, reg, 7) << 16)) |
322 RD_MAILBOX_REG(ha, reg, 6));
323 handle_cnt = 2;
324 mb[0] = MBA_SCSI_COMPLETION;
325 break;
326 default:
327 break;
328 }
329
330 switch (mb[0]) {
331 case MBA_SCSI_COMPLETION: /* Fast Post */
332 if (!ha->flags.online)
333 break;
334
335 for (cnt = 0; cnt < handle_cnt; cnt++)
336 qla2x00_process_completed_request(ha, handles[cnt]);
337 break;
338
339 case MBA_RESET: /* Reset */
340 DEBUG2(printk("scsi(%ld): Asynchronous RESET.\n", ha->host_no));
341
342 set_bit(RESET_MARKER_NEEDED, &ha->dpc_flags);
343 break;
344
345 case MBA_SYSTEM_ERR: /* System Error */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 qla_printk(KERN_INFO, ha,
347 "ISP System Error - mbx1=%xh mbx2=%xh mbx3=%xh.\n",
348 mb[1], mb[2], mb[3]);
349
Andrew Vasquezcb8dacb2008-04-03 13:13:19 -0700350 qla2x00_post_hwe_work(ha, mb[0], mb[1], mb[2], mb[3]);
Andrew Vasquezfd34f552007-07-19 15:06:00 -0700351 ha->isp_ops->fw_dump(ha, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352
Andrew Vasqueze4289242007-07-19 15:05:56 -0700353 if (IS_FWI2_CAPABLE(ha)) {
Andrew Vasquez9a853f72005-07-06 10:31:27 -0700354 if (mb[1] == 0 && mb[2] == 0) {
355 qla_printk(KERN_ERR, ha,
356 "Unrecoverable Hardware Error: adapter "
357 "marked OFFLINE!\n");
358 ha->flags.online = 0;
359 } else
360 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
361 } else if (mb[1] == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 qla_printk(KERN_INFO, ha,
363 "Unrecoverable Hardware Error: adapter marked "
364 "OFFLINE!\n");
365 ha->flags.online = 0;
366 } else
367 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
368 break;
369
370 case MBA_REQ_TRANSFER_ERR: /* Request Transfer Error */
371 DEBUG2(printk("scsi(%ld): ISP Request Transfer Error.\n",
372 ha->host_no));
373 qla_printk(KERN_WARNING, ha, "ISP Request Transfer Error.\n");
374
Andrew Vasquezcb8dacb2008-04-03 13:13:19 -0700375 qla2x00_post_hwe_work(ha, mb[0], mb[1], mb[2], mb[3]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
377 break;
378
379 case MBA_RSP_TRANSFER_ERR: /* Response Transfer Error */
380 DEBUG2(printk("scsi(%ld): ISP Response Transfer Error.\n",
381 ha->host_no));
382 qla_printk(KERN_WARNING, ha, "ISP Response Transfer Error.\n");
383
Andrew Vasquezcb8dacb2008-04-03 13:13:19 -0700384 qla2x00_post_hwe_work(ha, mb[0], mb[1], mb[2], mb[3]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
386 break;
387
388 case MBA_WAKEUP_THRES: /* Request Queue Wake-up */
389 DEBUG2(printk("scsi(%ld): Asynchronous WAKEUP_THRES.\n",
390 ha->host_no));
391 break;
392
393 case MBA_LIP_OCCURRED: /* Loop Initialization Procedure */
Bjorn Helgaascc3ef7b2008-09-11 21:22:51 -0700394 DEBUG2(printk("scsi(%ld): LIP occurred (%x).\n", ha->host_no,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 mb[1]));
Bjorn Helgaascc3ef7b2008-09-11 21:22:51 -0700396 qla_printk(KERN_INFO, ha, "LIP occurred (%x).\n", mb[1]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397
398 if (atomic_read(&ha->loop_state) != LOOP_DOWN) {
399 atomic_set(&ha->loop_state, LOOP_DOWN);
400 atomic_set(&ha->loop_down_timer, LOOP_DOWN_TIME);
andrew.vasquez@qlogic.comd97994d2006-01-20 14:53:13 -0800401 qla2x00_mark_all_devices_lost(ha, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 }
403
Seokmann Ju2c3dfe32007-07-05 13:16:51 -0700404 if (ha->parent) {
405 atomic_set(&ha->vp_state, VP_FAILED);
406 fc_vport_set_state(ha->fc_vport, FC_VPORT_FAILED);
407 }
408
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 set_bit(REGISTER_FC4_NEEDED, &ha->dpc_flags);
Andrew Vasquez7e47e5c2008-04-24 15:21:26 -0700410 set_bit(REGISTER_FDMI_NEEDED, &ha->dpc_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411
412 ha->flags.management_server_logged_in = 0;
Andrew Vasquez0971de72008-04-03 13:13:18 -0700413 qla2x00_post_aen_work(ha, FCH_EVT_LIP, mb[1]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414 break;
415
416 case MBA_LOOP_UP: /* Loop Up Event */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 if (IS_QLA2100(ha) || IS_QLA2200(ha)) {
418 link_speed = link_speeds[0];
Andrew Vasquezd8b45212006-10-02 12:00:43 -0700419 ha->link_data_rate = PORT_SPEED_1GB;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 } else {
Andrew Vasquez9a853f72005-07-06 10:31:27 -0700421 link_speed = link_speeds[LS_UNKNOWN];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 if (mb[1] < 5)
423 link_speed = link_speeds[mb[1]];
424 ha->link_data_rate = mb[1];
425 }
426
427 DEBUG2(printk("scsi(%ld): Asynchronous LOOP UP (%s Gbps).\n",
428 ha->host_no, link_speed));
429 qla_printk(KERN_INFO, ha, "LOOP UP detected (%s Gbps).\n",
430 link_speed);
431
432 ha->flags.management_server_logged_in = 0;
Andrew Vasquez0971de72008-04-03 13:13:18 -0700433 qla2x00_post_aen_work(ha, FCH_EVT_LINKUP, ha->link_data_rate);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434 break;
435
436 case MBA_LOOP_DOWN: /* Loop Down Event */
Harihara Kadayam4d4df192008-04-03 13:13:26 -0700437 DEBUG2(printk("scsi(%ld): Asynchronous LOOP DOWN "
438 "(%x %x %x).\n", ha->host_no, mb[1], mb[2], mb[3]));
439 qla_printk(KERN_INFO, ha, "LOOP DOWN detected (%x %x %x).\n",
440 mb[1], mb[2], mb[3]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441
442 if (atomic_read(&ha->loop_state) != LOOP_DOWN) {
443 atomic_set(&ha->loop_state, LOOP_DOWN);
444 atomic_set(&ha->loop_down_timer, LOOP_DOWN_TIME);
445 ha->device_flags |= DFLG_NO_CABLE;
andrew.vasquez@qlogic.comd97994d2006-01-20 14:53:13 -0800446 qla2x00_mark_all_devices_lost(ha, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447 }
448
Seokmann Ju2c3dfe32007-07-05 13:16:51 -0700449 if (ha->parent) {
450 atomic_set(&ha->vp_state, VP_FAILED);
451 fc_vport_set_state(ha->fc_vport, FC_VPORT_FAILED);
452 }
453
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454 ha->flags.management_server_logged_in = 0;
Andrew Vasquezd8b45212006-10-02 12:00:43 -0700455 ha->link_data_rate = PORT_SPEED_UNKNOWN;
Andrew Vasquez0971de72008-04-03 13:13:18 -0700456 qla2x00_post_aen_work(ha, FCH_EVT_LINKDOWN, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 break;
458
459 case MBA_LIP_RESET: /* LIP reset occurred */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460 DEBUG2(printk("scsi(%ld): Asynchronous LIP RESET (%x).\n",
461 ha->host_no, mb[1]));
462 qla_printk(KERN_INFO, ha,
Bjorn Helgaascc3ef7b2008-09-11 21:22:51 -0700463 "LIP reset occurred (%x).\n", mb[1]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464
465 if (atomic_read(&ha->loop_state) != LOOP_DOWN) {
466 atomic_set(&ha->loop_state, LOOP_DOWN);
467 atomic_set(&ha->loop_down_timer, LOOP_DOWN_TIME);
andrew.vasquez@qlogic.comd97994d2006-01-20 14:53:13 -0800468 qla2x00_mark_all_devices_lost(ha, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469 }
470
Seokmann Ju2c3dfe32007-07-05 13:16:51 -0700471 if (ha->parent) {
472 atomic_set(&ha->vp_state, VP_FAILED);
473 fc_vport_set_state(ha->fc_vport, FC_VPORT_FAILED);
474 }
475
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476 set_bit(RESET_MARKER_NEEDED, &ha->dpc_flags);
477
478 ha->operating_mode = LOOP;
479 ha->flags.management_server_logged_in = 0;
Andrew Vasquez0971de72008-04-03 13:13:18 -0700480 qla2x00_post_aen_work(ha, FCH_EVT_LIPRESET, mb[1]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481 break;
482
483 case MBA_POINT_TO_POINT: /* Point-to-Point */
484 if (IS_QLA2100(ha))
485 break;
486
487 DEBUG2(printk("scsi(%ld): Asynchronous P2P MODE received.\n",
488 ha->host_no));
489
490 /*
491 * Until there's a transition from loop down to loop up, treat
492 * this as loop down only.
493 */
494 if (atomic_read(&ha->loop_state) != LOOP_DOWN) {
495 atomic_set(&ha->loop_state, LOOP_DOWN);
496 if (!atomic_read(&ha->loop_down_timer))
497 atomic_set(&ha->loop_down_timer,
498 LOOP_DOWN_TIME);
andrew.vasquez@qlogic.comd97994d2006-01-20 14:53:13 -0800499 qla2x00_mark_all_devices_lost(ha, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500 }
501
Seokmann Ju2c3dfe32007-07-05 13:16:51 -0700502 if (ha->parent) {
503 atomic_set(&ha->vp_state, VP_FAILED);
504 fc_vport_set_state(ha->fc_vport, FC_VPORT_FAILED);
505 }
506
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 if (!(test_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags))) {
508 set_bit(RESET_MARKER_NEEDED, &ha->dpc_flags);
509 }
510 set_bit(REGISTER_FC4_NEEDED, &ha->dpc_flags);
Andrew Vasquez7e47e5c2008-04-24 15:21:26 -0700511 set_bit(REGISTER_FDMI_NEEDED, &ha->dpc_flags);
Andrew Vasquez4346b142006-12-13 19:20:28 -0800512
513 ha->flags.gpsc_supported = 1;
Andrew Vasquez02d638b2007-08-12 18:22:54 -0700514 ha->flags.management_server_logged_in = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515 break;
516
517 case MBA_CHG_IN_CONNECTION: /* Change in connection mode */
518 if (IS_QLA2100(ha))
519 break;
520
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 DEBUG2(printk("scsi(%ld): Asynchronous Change In Connection "
522 "received.\n",
523 ha->host_no));
524 qla_printk(KERN_INFO, ha,
525 "Configuration change detected: value=%x.\n", mb[1]);
526
527 if (atomic_read(&ha->loop_state) != LOOP_DOWN) {
Andrew Vasquezfa2a1ce2005-07-06 10:32:07 -0700528 atomic_set(&ha->loop_state, LOOP_DOWN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529 if (!atomic_read(&ha->loop_down_timer))
530 atomic_set(&ha->loop_down_timer,
531 LOOP_DOWN_TIME);
andrew.vasquez@qlogic.comd97994d2006-01-20 14:53:13 -0800532 qla2x00_mark_all_devices_lost(ha, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533 }
534
Seokmann Ju2c3dfe32007-07-05 13:16:51 -0700535 if (ha->parent) {
536 atomic_set(&ha->vp_state, VP_FAILED);
537 fc_vport_set_state(ha->fc_vport, FC_VPORT_FAILED);
538 }
539
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540 set_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags);
541 set_bit(LOCAL_LOOP_UPDATE, &ha->dpc_flags);
542 break;
543
544 case MBA_PORT_UPDATE: /* Port database update */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545 /*
Bjorn Helgaascc3ef7b2008-09-11 21:22:51 -0700546 * If PORT UPDATE is global (received LIP_OCCURRED/LIP_RESET
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547 * event etc. earlier indicating loop is down) then process
548 * it. Otherwise ignore it and Wait for RSCN to come in.
549 */
550 atomic_set(&ha->loop_down_timer, 0);
551 if (atomic_read(&ha->loop_state) != LOOP_DOWN &&
552 atomic_read(&ha->loop_state) != LOOP_DEAD) {
553 DEBUG2(printk("scsi(%ld): Asynchronous PORT UPDATE "
Andrew Vasquez9a853f72005-07-06 10:31:27 -0700554 "ignored %04x/%04x/%04x.\n", ha->host_no, mb[1],
555 mb[2], mb[3]));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556 break;
557 }
558
559 DEBUG2(printk("scsi(%ld): Asynchronous PORT UPDATE.\n",
560 ha->host_no));
561 DEBUG(printk(KERN_INFO
Andrew Vasquez9a853f72005-07-06 10:31:27 -0700562 "scsi(%ld): Port database changed %04x %04x %04x.\n",
563 ha->host_no, mb[1], mb[2], mb[3]));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564
565 /*
566 * Mark all devices as missing so we will login again.
567 */
568 atomic_set(&ha->loop_state, LOOP_UP);
569
andrew.vasquez@qlogic.comd97994d2006-01-20 14:53:13 -0800570 qla2x00_mark_all_devices_lost(ha, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571
572 ha->flags.rscn_queue_overflow = 1;
573
574 set_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags);
575 set_bit(LOCAL_LOOP_UPDATE, &ha->dpc_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576 break;
577
578 case MBA_RSCN_UPDATE: /* State Change Registration */
Seokmann Ju3c397402008-05-19 14:25:39 -0700579 /* Check if the Vport has issued a SCR */
580 if (ha->parent && test_bit(VP_SCR_NEEDED, &ha->vp_flags))
581 break;
582 /* Only handle SCNs for our Vport index. */
583 if (ha->parent && ha->vp_idx != (mb[3] & 0xff))
584 break;
Seokmann Ju2c3dfe32007-07-05 13:16:51 -0700585
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586 DEBUG2(printk("scsi(%ld): Asynchronous RSCR UPDATE.\n",
587 ha->host_no));
588 DEBUG(printk(KERN_INFO
Shyam Sundarf4a8dbc2007-11-12 10:30:59 -0800589 "scsi(%ld): RSCN database changed -- %04x %04x %04x.\n",
590 ha->host_no, mb[1], mb[2], mb[3]));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591
592 rscn_entry = (mb[1] << 16) | mb[2];
593 host_pid = (ha->d_id.b.domain << 16) | (ha->d_id.b.area << 8) |
594 ha->d_id.b.al_pa;
595 if (rscn_entry == host_pid) {
596 DEBUG(printk(KERN_INFO
597 "scsi(%ld): Ignoring RSCN update to local host "
598 "port ID (%06x)\n",
599 ha->host_no, host_pid));
600 break;
601 }
602
603 rscn_queue_index = ha->rscn_in_ptr + 1;
604 if (rscn_queue_index == MAX_RSCN_COUNT)
605 rscn_queue_index = 0;
606 if (rscn_queue_index != ha->rscn_out_ptr) {
607 ha->rscn_queue[ha->rscn_in_ptr] = rscn_entry;
608 ha->rscn_in_ptr = rscn_queue_index;
609 } else {
610 ha->flags.rscn_queue_overflow = 1;
611 }
612
613 atomic_set(&ha->loop_state, LOOP_UPDATE);
614 atomic_set(&ha->loop_down_timer, 0);
615 ha->flags.management_server_logged_in = 0;
616
617 set_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags);
618 set_bit(RSCN_UPDATE, &ha->dpc_flags);
Andrew Vasquez0971de72008-04-03 13:13:18 -0700619 qla2x00_post_aen_work(ha, FCH_EVT_RSCN, rscn_entry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620 break;
621
622 /* case MBA_RIO_RESPONSE: */
623 case MBA_ZIO_RESPONSE:
624 DEBUG2(printk("scsi(%ld): [R|Z]IO update completion.\n",
625 ha->host_no));
626 DEBUG(printk(KERN_INFO
627 "scsi(%ld): [R|Z]IO update completion.\n",
628 ha->host_no));
629
Andrew Vasqueze4289242007-07-19 15:05:56 -0700630 if (IS_FWI2_CAPABLE(ha))
Andrew Vasquez4fdfefe2005-10-27 11:09:48 -0700631 qla24xx_process_response_queue(ha);
632 else
633 qla2x00_process_response_queue(ha);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634 break;
Andrew Vasquez9a853f72005-07-06 10:31:27 -0700635
636 case MBA_DISCARD_RND_FRAME:
637 DEBUG2(printk("scsi(%ld): Discard RND Frame -- %04x %04x "
638 "%04x.\n", ha->host_no, mb[1], mb[2], mb[3]));
639 break;
Andrew Vasquez45ebeb52006-08-01 13:48:14 -0700640
641 case MBA_TRACE_NOTIFICATION:
642 DEBUG2(printk("scsi(%ld): Trace Notification -- %04x %04x.\n",
643 ha->host_no, mb[1], mb[2]));
644 break;
Harihara Kadayam4d4df192008-04-03 13:13:26 -0700645
646 case MBA_ISP84XX_ALERT:
647 DEBUG2(printk("scsi(%ld): ISP84XX Alert Notification -- "
648 "%04x %04x %04x\n", ha->host_no, mb[1], mb[2], mb[3]));
649
650 spin_lock_irqsave(&ha->cs84xx->access_lock, flags);
651 switch (mb[1]) {
652 case A84_PANIC_RECOVERY:
653 qla_printk(KERN_INFO, ha, "Alert 84XX: panic recovery "
654 "%04x %04x\n", mb[2], mb[3]);
655 break;
656 case A84_OP_LOGIN_COMPLETE:
657 ha->cs84xx->op_fw_version = mb[3] << 16 | mb[2];
658 DEBUG2(qla_printk(KERN_INFO, ha, "Alert 84XX:"
659 "firmware version %x\n", ha->cs84xx->op_fw_version));
660 break;
661 case A84_DIAG_LOGIN_COMPLETE:
662 ha->cs84xx->diag_fw_version = mb[3] << 16 | mb[2];
663 DEBUG2(qla_printk(KERN_INFO, ha, "Alert 84XX:"
664 "diagnostic firmware version %x\n",
665 ha->cs84xx->diag_fw_version));
666 break;
667 case A84_GOLD_LOGIN_COMPLETE:
668 ha->cs84xx->diag_fw_version = mb[3] << 16 | mb[2];
669 ha->cs84xx->fw_update = 1;
670 DEBUG2(qla_printk(KERN_INFO, ha, "Alert 84XX: gold "
671 "firmware version %x\n",
672 ha->cs84xx->gold_fw_version));
673 break;
674 default:
675 qla_printk(KERN_ERR, ha,
676 "Alert 84xx: Invalid Alert %04x %04x %04x\n",
677 mb[1], mb[2], mb[3]);
678 }
679 spin_unlock_irqrestore(&ha->cs84xx->access_lock, flags);
680 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681 }
Seokmann Ju2c3dfe32007-07-05 13:16:51 -0700682
683 if (!ha->parent && ha->num_vhosts)
684 qla2x00_alert_all_vps(ha, mb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685}
686
Andrew Vasquezdf7baa52006-10-13 09:33:39 -0700687static void
688qla2x00_adjust_sdev_qdepth_up(struct scsi_device *sdev, void *data)
689{
690 fc_port_t *fcport = data;
691
692 if (fcport->ha->max_q_depth <= sdev->queue_depth)
693 return;
694
695 if (sdev->ordered_tags)
696 scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG,
697 sdev->queue_depth + 1);
698 else
699 scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG,
700 sdev->queue_depth + 1);
701
702 fcport->last_ramp_up = jiffies;
703
704 DEBUG2(qla_printk(KERN_INFO, fcport->ha,
705 "scsi(%ld:%d:%d:%d): Queue depth adjusted-up to %d.\n",
706 fcport->ha->host_no, sdev->channel, sdev->id, sdev->lun,
707 sdev->queue_depth));
708}
709
710static void
711qla2x00_adjust_sdev_qdepth_down(struct scsi_device *sdev, void *data)
712{
713 fc_port_t *fcport = data;
714
715 if (!scsi_track_queue_full(sdev, sdev->queue_depth - 1))
716 return;
717
718 DEBUG2(qla_printk(KERN_INFO, fcport->ha,
719 "scsi(%ld:%d:%d:%d): Queue depth adjusted-down to %d.\n",
720 fcport->ha->host_no, sdev->channel, sdev->id, sdev->lun,
721 sdev->queue_depth));
722}
723
724static inline void
725qla2x00_ramp_up_queue_depth(scsi_qla_host_t *ha, srb_t *sp)
726{
727 fc_port_t *fcport;
728 struct scsi_device *sdev;
729
730 sdev = sp->cmd->device;
731 if (sdev->queue_depth >= ha->max_q_depth)
732 return;
733
734 fcport = sp->fcport;
735 if (time_before(jiffies,
736 fcport->last_ramp_up + ql2xqfullrampup * HZ))
737 return;
738 if (time_before(jiffies,
739 fcport->last_queue_full + ql2xqfullrampup * HZ))
740 return;
741
Andrew Vasquezdf7baa52006-10-13 09:33:39 -0700742 starget_for_each_device(sdev->sdev_target, fcport,
743 qla2x00_adjust_sdev_qdepth_up);
Andrew Vasquezdf7baa52006-10-13 09:33:39 -0700744}
745
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746/**
747 * qla2x00_process_completed_request() - Process a Fast Post response.
748 * @ha: SCSI driver HA context
749 * @index: SRB index
750 */
751static void
752qla2x00_process_completed_request(struct scsi_qla_host *ha, uint32_t index)
753{
754 srb_t *sp;
755
756 /* Validate handle. */
757 if (index >= MAX_OUTSTANDING_COMMANDS) {
758 DEBUG2(printk("scsi(%ld): Invalid SCSI completion handle %d.\n",
759 ha->host_no, index));
760 qla_printk(KERN_WARNING, ha,
761 "Invalid SCSI completion handle %d.\n", index);
762
763 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
764 return;
765 }
766
767 sp = ha->outstanding_cmds[index];
768 if (sp) {
769 /* Free outstanding command slot. */
770 ha->outstanding_cmds[index] = NULL;
771
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772 CMD_COMPL_STATUS(sp->cmd) = 0L;
773 CMD_SCSI_STATUS(sp->cmd) = 0L;
774
775 /* Save ISP completion status */
776 sp->cmd->result = DID_OK << 16;
Andrew Vasquezdf7baa52006-10-13 09:33:39 -0700777
778 qla2x00_ramp_up_queue_depth(ha, sp);
f4f051e2005-04-17 15:02:26 -0500779 qla2x00_sp_compl(ha, sp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780 } else {
781 DEBUG2(printk("scsi(%ld): Invalid ISP SCSI completion handle\n",
782 ha->host_no));
783 qla_printk(KERN_WARNING, ha,
784 "Invalid ISP SCSI completion handle\n");
785
786 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
787 }
788}
789
790/**
791 * qla2x00_process_response_queue() - Process response queue entries.
792 * @ha: SCSI driver HA context
793 */
794void
795qla2x00_process_response_queue(struct scsi_qla_host *ha)
796{
Andrew Vasquez3d716442005-07-06 10:30:26 -0700797 struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798 sts_entry_t *pkt;
799 uint16_t handle_cnt;
800 uint16_t cnt;
801
802 if (!ha->flags.online)
803 return;
804
805 while (ha->response_ring_ptr->signature != RESPONSE_PROCESSED) {
806 pkt = (sts_entry_t *)ha->response_ring_ptr;
807
808 ha->rsp_ring_index++;
809 if (ha->rsp_ring_index == ha->response_q_length) {
810 ha->rsp_ring_index = 0;
811 ha->response_ring_ptr = ha->response_ring;
812 } else {
813 ha->response_ring_ptr++;
814 }
815
816 if (pkt->entry_status != 0) {
817 DEBUG3(printk(KERN_INFO
818 "scsi(%ld): Process error entry.\n", ha->host_no));
819
820 qla2x00_error_entry(ha, pkt);
821 ((response_t *)pkt)->signature = RESPONSE_PROCESSED;
822 wmb();
823 continue;
824 }
825
826 switch (pkt->entry_type) {
827 case STATUS_TYPE:
828 qla2x00_status_entry(ha, pkt);
829 break;
830 case STATUS_TYPE_21:
831 handle_cnt = ((sts21_entry_t *)pkt)->handle_count;
832 for (cnt = 0; cnt < handle_cnt; cnt++) {
833 qla2x00_process_completed_request(ha,
834 ((sts21_entry_t *)pkt)->handle[cnt]);
835 }
836 break;
837 case STATUS_TYPE_22:
838 handle_cnt = ((sts22_entry_t *)pkt)->handle_count;
839 for (cnt = 0; cnt < handle_cnt; cnt++) {
840 qla2x00_process_completed_request(ha,
841 ((sts22_entry_t *)pkt)->handle[cnt]);
842 }
843 break;
844 case STATUS_CONT_TYPE:
845 qla2x00_status_cont_entry(ha, (sts_cont_entry_t *)pkt);
846 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847 default:
848 /* Type Not Supported. */
849 DEBUG4(printk(KERN_WARNING
850 "scsi(%ld): Received unknown response pkt type %x "
851 "entry status=%x.\n",
852 ha->host_no, pkt->entry_type, pkt->entry_status));
853 break;
854 }
855 ((response_t *)pkt)->signature = RESPONSE_PROCESSED;
856 wmb();
857 }
858
859 /* Adjust ring index */
860 WRT_REG_WORD(ISP_RSP_Q_OUT(ha, reg), ha->rsp_ring_index);
861}
862
Andrew Vasquez4733fcb2008-01-17 09:02:07 -0800863static inline void
864qla2x00_handle_sense(srb_t *sp, uint8_t *sense_data, uint32_t sense_len)
865{
866 struct scsi_cmnd *cp = sp->cmd;
867
868 if (sense_len >= SCSI_SENSE_BUFFERSIZE)
869 sense_len = SCSI_SENSE_BUFFERSIZE;
870
871 CMD_ACTUAL_SNSLEN(cp) = sense_len;
872 sp->request_sense_length = sense_len;
873 sp->request_sense_ptr = cp->sense_buffer;
874 if (sp->request_sense_length > 32)
875 sense_len = 32;
876
877 memcpy(cp->sense_buffer, sense_data, sense_len);
878
879 sp->request_sense_ptr += sense_len;
880 sp->request_sense_length -= sense_len;
881 if (sp->request_sense_length != 0)
Andrew Vasquez19851f12008-08-13 21:37:00 -0700882 sp->fcport->ha->status_srb = sp;
Andrew Vasquez4733fcb2008-01-17 09:02:07 -0800883
884 DEBUG5(printk("%s(): Check condition Sense data, scsi(%ld:%d:%d:%d) "
Andrew Vasquez19851f12008-08-13 21:37:00 -0700885 "cmd=%p pid=%ld\n", __func__, sp->fcport->ha->host_no,
886 cp->device->channel, cp->device->id, cp->device->lun, cp,
887 cp->serial_number));
Andrew Vasquez4733fcb2008-01-17 09:02:07 -0800888 if (sense_len)
889 DEBUG5(qla2x00_dump_buffer(cp->sense_buffer,
890 CMD_ACTUAL_SNSLEN(cp)));
891}
892
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893/**
894 * qla2x00_status_entry() - Process a Status IOCB entry.
895 * @ha: SCSI driver HA context
896 * @pkt: Entry pointer
897 */
898static void
Andrew Vasquez9a853f72005-07-06 10:31:27 -0700899qla2x00_status_entry(scsi_qla_host_t *ha, void *pkt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901 srb_t *sp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902 fc_port_t *fcport;
903 struct scsi_cmnd *cp;
Andrew Vasquez9a853f72005-07-06 10:31:27 -0700904 sts_entry_t *sts;
905 struct sts_entry_24xx *sts24;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906 uint16_t comp_status;
907 uint16_t scsi_status;
908 uint8_t lscsi_status;
909 int32_t resid;
Ravi Ananded17c712006-05-17 15:08:55 -0700910 uint32_t sense_len, rsp_info_len, resid_len, fw_resid_len;
Andrew Vasquez9a853f72005-07-06 10:31:27 -0700911 uint8_t *rsp_info, *sense_data;
912
913 sts = (sts_entry_t *) pkt;
914 sts24 = (struct sts_entry_24xx *) pkt;
Andrew Vasqueze4289242007-07-19 15:05:56 -0700915 if (IS_FWI2_CAPABLE(ha)) {
Andrew Vasquez9a853f72005-07-06 10:31:27 -0700916 comp_status = le16_to_cpu(sts24->comp_status);
917 scsi_status = le16_to_cpu(sts24->scsi_status) & SS_MASK;
918 } else {
919 comp_status = le16_to_cpu(sts->comp_status);
920 scsi_status = le16_to_cpu(sts->scsi_status) & SS_MASK;
921 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922
923 /* Fast path completion. */
Andrew Vasquez9a853f72005-07-06 10:31:27 -0700924 if (comp_status == CS_COMPLETE && scsi_status == 0) {
925 qla2x00_process_completed_request(ha, sts->handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926
927 return;
928 }
929
930 /* Validate handle. */
Andrew Vasquez9a853f72005-07-06 10:31:27 -0700931 if (sts->handle < MAX_OUTSTANDING_COMMANDS) {
932 sp = ha->outstanding_cmds[sts->handle];
933 ha->outstanding_cmds[sts->handle] = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934 } else
935 sp = NULL;
936
937 if (sp == NULL) {
938 DEBUG2(printk("scsi(%ld): Status Entry invalid handle.\n",
939 ha->host_no));
940 qla_printk(KERN_WARNING, ha, "Status Entry invalid handle.\n");
941
942 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
Christoph Hellwig39a11242006-02-14 18:46:22 +0100943 qla2xxx_wake_dpc(ha);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944 return;
945 }
946 cp = sp->cmd;
947 if (cp == NULL) {
948 DEBUG2(printk("scsi(%ld): Command already returned back to OS "
Andrew Vasquez75bc4192006-05-17 15:09:22 -0700949 "pkt->handle=%d sp=%p.\n", ha->host_no, sts->handle, sp));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950 qla_printk(KERN_WARNING, ha,
951 "Command is NULL: already returned to OS (sp=%p)\n", sp);
952
953 return;
954 }
955
Andrew Vasquez9a853f72005-07-06 10:31:27 -0700956 lscsi_status = scsi_status & STATUS_MASK;
957 CMD_ENTRY_STATUS(cp) = sts->entry_status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958 CMD_COMPL_STATUS(cp) = comp_status;
959 CMD_SCSI_STATUS(cp) = scsi_status;
960
bdf79622005-04-17 15:06:53 -0500961 fcport = sp->fcport;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962
Ravi Ananded17c712006-05-17 15:08:55 -0700963 sense_len = rsp_info_len = resid_len = fw_resid_len = 0;
Andrew Vasqueze4289242007-07-19 15:05:56 -0700964 if (IS_FWI2_CAPABLE(ha)) {
Andrew Vasquez9a853f72005-07-06 10:31:27 -0700965 sense_len = le32_to_cpu(sts24->sense_len);
966 rsp_info_len = le32_to_cpu(sts24->rsp_data_len);
967 resid_len = le32_to_cpu(sts24->rsp_residual_count);
Ravi Ananded17c712006-05-17 15:08:55 -0700968 fw_resid_len = le32_to_cpu(sts24->residual_len);
Andrew Vasquez9a853f72005-07-06 10:31:27 -0700969 rsp_info = sts24->data;
970 sense_data = sts24->data;
971 host_to_fcp_swap(sts24->data, sizeof(sts24->data));
972 } else {
973 sense_len = le16_to_cpu(sts->req_sense_length);
974 rsp_info_len = le16_to_cpu(sts->rsp_info_len);
975 resid_len = le32_to_cpu(sts->residual_length);
976 rsp_info = sts->rsp_info;
977 sense_data = sts->req_sense_data;
978 }
979
Linus Torvalds1da177e2005-04-16 15:20:36 -0700980 /* Check for any FCP transport errors. */
981 if (scsi_status & SS_RESPONSE_INFO_LEN_VALID) {
Andrew Vasquez9a853f72005-07-06 10:31:27 -0700982 /* Sense data lies beyond any FCP RESPONSE data. */
Andrew Vasqueze4289242007-07-19 15:05:56 -0700983 if (IS_FWI2_CAPABLE(ha))
Andrew Vasquez9a853f72005-07-06 10:31:27 -0700984 sense_data += rsp_info_len;
985 if (rsp_info_len > 3 && rsp_info[3]) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700986 DEBUG2(printk("scsi(%ld:%d:%d:%d) FCP I/O protocol "
987 "failure (%x/%02x%02x%02x%02x%02x%02x%02x%02x)..."
Andrew Vasquez9a853f72005-07-06 10:31:27 -0700988 "retrying command\n", ha->host_no,
989 cp->device->channel, cp->device->id,
990 cp->device->lun, rsp_info_len, rsp_info[0],
991 rsp_info[1], rsp_info[2], rsp_info[3], rsp_info[4],
992 rsp_info[5], rsp_info[6], rsp_info[7]));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993
994 cp->result = DID_BUS_BUSY << 16;
f4f051e2005-04-17 15:02:26 -0500995 qla2x00_sp_compl(ha, sp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996 return;
997 }
998 }
999
Andrew Vasquez3e8ce322008-02-28 14:06:10 -08001000 /* Check for overrun. */
1001 if (IS_FWI2_CAPABLE(ha) && comp_status == CS_COMPLETE &&
1002 scsi_status & SS_RESIDUAL_OVER)
1003 comp_status = CS_DATA_OVERRUN;
1004
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005 /*
1006 * Based on Host and scsi status generate status code for Linux
1007 */
1008 switch (comp_status) {
1009 case CS_COMPLETE:
Andrew Vasquezdf7baa52006-10-13 09:33:39 -07001010 case CS_QUEUE_FULL:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011 if (scsi_status == 0) {
1012 cp->result = DID_OK << 16;
1013 break;
1014 }
1015 if (scsi_status & (SS_RESIDUAL_UNDER | SS_RESIDUAL_OVER)) {
Andrew Vasquez9a853f72005-07-06 10:31:27 -07001016 resid = resid_len;
FUJITA Tomonori385d70b2007-05-26 01:55:38 +09001017 scsi_set_resid(cp, resid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018 CMD_RESID_LEN(cp) = resid;
Andrew Vasquez0da69df2005-12-06 10:58:06 -08001019
1020 if (!lscsi_status &&
FUJITA Tomonori385d70b2007-05-26 01:55:38 +09001021 ((unsigned)(scsi_bufflen(cp) - resid) <
Andrew Vasquez0da69df2005-12-06 10:58:06 -08001022 cp->underflow)) {
1023 qla_printk(KERN_INFO, ha,
FUJITA Tomonori385d70b2007-05-26 01:55:38 +09001024 "scsi(%ld:%d:%d:%d): Mid-layer underflow "
1025 "detected (%x of %x bytes)...returning "
1026 "error status.\n", ha->host_no,
1027 cp->device->channel, cp->device->id,
1028 cp->device->lun, resid,
1029 scsi_bufflen(cp));
Andrew Vasquez0da69df2005-12-06 10:58:06 -08001030
1031 cp->result = DID_ERROR << 16;
1032 break;
1033 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001034 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001035 cp->result = DID_OK << 16 | lscsi_status;
1036
Andrew Vasquezdf7baa52006-10-13 09:33:39 -07001037 if (lscsi_status == SAM_STAT_TASK_SET_FULL) {
1038 DEBUG2(printk(KERN_INFO
1039 "scsi(%ld): QUEUE FULL status detected "
1040 "0x%x-0x%x.\n", ha->host_no, comp_status,
1041 scsi_status));
1042
1043 /* Adjust queue depth for all luns on the port. */
1044 fcport->last_queue_full = jiffies;
Andrew Vasquezdf7baa52006-10-13 09:33:39 -07001045 starget_for_each_device(cp->device->sdev_target,
1046 fcport, qla2x00_adjust_sdev_qdepth_down);
Andrew Vasquezdf7baa52006-10-13 09:33:39 -07001047 break;
1048 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001049 if (lscsi_status != SS_CHECK_CONDITION)
1050 break;
1051
FUJITA Tomonorib80ca4f2008-01-13 15:46:13 +09001052 memset(cp->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053 if (!(scsi_status & SS_SENSE_LEN_VALID))
1054 break;
1055
Andrew Vasquez4733fcb2008-01-17 09:02:07 -08001056 qla2x00_handle_sense(sp, sense_data, sense_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057 break;
1058
1059 case CS_DATA_UNDERRUN:
Andrew Vasquez9a853f72005-07-06 10:31:27 -07001060 resid = resid_len;
Ravi Ananded17c712006-05-17 15:08:55 -07001061 /* Use F/W calculated residual length. */
Andrew Vasquez6acf8192007-10-19 15:59:18 -07001062 if (IS_FWI2_CAPABLE(ha)) {
Andrew Vasquez2d136932008-09-11 21:22:52 -07001063 if (!(scsi_status & SS_RESIDUAL_UNDER)) {
1064 lscsi_status = 0;
1065 } else if (resid != fw_resid_len) {
Andrew Vasquez6acf8192007-10-19 15:59:18 -07001066 scsi_status &= ~SS_RESIDUAL_UNDER;
1067 lscsi_status = 0;
1068 }
Ravi Ananded17c712006-05-17 15:08:55 -07001069 resid = fw_resid_len;
Andrew Vasquez6acf8192007-10-19 15:59:18 -07001070 }
Ravi Ananded17c712006-05-17 15:08:55 -07001071
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072 if (scsi_status & SS_RESIDUAL_UNDER) {
FUJITA Tomonori385d70b2007-05-26 01:55:38 +09001073 scsi_set_resid(cp, resid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001074 CMD_RESID_LEN(cp) = resid;
andrew.vasquez@qlogic.come038a1b2006-01-13 17:04:59 -08001075 } else {
1076 DEBUG2(printk(KERN_INFO
1077 "scsi(%ld:%d:%d) UNDERRUN status detected "
Ravi Ananded17c712006-05-17 15:08:55 -07001078 "0x%x-0x%x. resid=0x%x fw_resid=0x%x cdb=0x%x "
1079 "os_underflow=0x%x\n", ha->host_no,
1080 cp->device->id, cp->device->lun, comp_status,
1081 scsi_status, resid_len, resid, cp->cmnd[0],
1082 cp->underflow));
andrew.vasquez@qlogic.come038a1b2006-01-13 17:04:59 -08001083
Linus Torvalds1da177e2005-04-16 15:20:36 -07001084 }
1085
1086 /*
Andrew Vasquezfa2a1ce2005-07-06 10:32:07 -07001087 * Check to see if SCSI Status is non zero. If so report SCSI
Linus Torvalds1da177e2005-04-16 15:20:36 -07001088 * Status.
1089 */
1090 if (lscsi_status != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091 cp->result = DID_OK << 16 | lscsi_status;
1092
Andrew Vasquezffec28a2007-01-29 10:22:27 -08001093 if (lscsi_status == SAM_STAT_TASK_SET_FULL) {
1094 DEBUG2(printk(KERN_INFO
1095 "scsi(%ld): QUEUE FULL status detected "
1096 "0x%x-0x%x.\n", ha->host_no, comp_status,
1097 scsi_status));
1098
1099 /*
1100 * Adjust queue depth for all luns on the
1101 * port.
1102 */
1103 fcport->last_queue_full = jiffies;
1104 starget_for_each_device(
1105 cp->device->sdev_target, fcport,
1106 qla2x00_adjust_sdev_qdepth_down);
1107 break;
1108 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001109 if (lscsi_status != SS_CHECK_CONDITION)
1110 break;
1111
FUJITA Tomonorib80ca4f2008-01-13 15:46:13 +09001112 memset(cp->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001113 if (!(scsi_status & SS_SENSE_LEN_VALID))
1114 break;
1115
Andrew Vasquez4733fcb2008-01-17 09:02:07 -08001116 qla2x00_handle_sense(sp, sense_data, sense_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117 } else {
1118 /*
1119 * If RISC reports underrun and target does not report
1120 * it then we must have a lost frame, so tell upper
1121 * layer to retry it by reporting a bus busy.
1122 */
1123 if (!(scsi_status & SS_RESIDUAL_UNDER)) {
1124 DEBUG2(printk("scsi(%ld:%d:%d:%d) Dropped "
FUJITA Tomonori385d70b2007-05-26 01:55:38 +09001125 "frame(s) detected (%x of %x bytes)..."
1126 "retrying command.\n", ha->host_no,
1127 cp->device->channel, cp->device->id,
1128 cp->device->lun, resid,
1129 scsi_bufflen(cp)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130
1131 cp->result = DID_BUS_BUSY << 16;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132 break;
1133 }
1134
1135 /* Handle mid-layer underflow */
FUJITA Tomonori385d70b2007-05-26 01:55:38 +09001136 if ((unsigned)(scsi_bufflen(cp) - resid) <
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137 cp->underflow) {
1138 qla_printk(KERN_INFO, ha,
FUJITA Tomonori385d70b2007-05-26 01:55:38 +09001139 "scsi(%ld:%d:%d:%d): Mid-layer underflow "
1140 "detected (%x of %x bytes)...returning "
1141 "error status.\n", ha->host_no,
1142 cp->device->channel, cp->device->id,
1143 cp->device->lun, resid,
1144 scsi_bufflen(cp));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001145
1146 cp->result = DID_ERROR << 16;
1147 break;
1148 }
1149
1150 /* Everybody online, looking good... */
1151 cp->result = DID_OK << 16;
1152 }
1153 break;
1154
1155 case CS_DATA_OVERRUN:
1156 DEBUG2(printk(KERN_INFO
1157 "scsi(%ld:%d:%d): OVERRUN status detected 0x%x-0x%x\n",
Andrew Vasquez9a853f72005-07-06 10:31:27 -07001158 ha->host_no, cp->device->id, cp->device->lun, comp_status,
1159 scsi_status));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001160 DEBUG2(printk(KERN_INFO
1161 "CDB: 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x\n",
1162 cp->cmnd[0], cp->cmnd[1], cp->cmnd[2], cp->cmnd[3],
1163 cp->cmnd[4], cp->cmnd[5]));
1164 DEBUG2(printk(KERN_INFO
1165 "PID=0x%lx req=0x%x xtra=0x%x -- returning DID_ERROR "
1166 "status!\n",
FUJITA Tomonori385d70b2007-05-26 01:55:38 +09001167 cp->serial_number, scsi_bufflen(cp), resid_len));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001168
1169 cp->result = DID_ERROR << 16;
1170 break;
1171
1172 case CS_PORT_LOGGED_OUT:
1173 case CS_PORT_CONFIG_CHG:
1174 case CS_PORT_BUSY:
1175 case CS_INCOMPLETE:
1176 case CS_PORT_UNAVAILABLE:
1177 /*
1178 * If the port is in Target Down state, return all IOs for this
1179 * Target with DID_NO_CONNECT ELSE Queue the IOs in the
1180 * retry_queue.
1181 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182 DEBUG2(printk("scsi(%ld:%d:%d): status_entry: Port Down "
1183 "pid=%ld, compl status=0x%x, port state=0x%x\n",
Andrew Vasquez9a853f72005-07-06 10:31:27 -07001184 ha->host_no, cp->device->id, cp->device->lun,
1185 cp->serial_number, comp_status,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186 atomic_read(&fcport->state)));
1187
f4f051e2005-04-17 15:02:26 -05001188 cp->result = DID_BUS_BUSY << 16;
Andrew Vasqueza7a28502008-08-13 21:36:57 -07001189 if (atomic_read(&fcport->state) == FCS_ONLINE)
1190 qla2x00_mark_device_lost(fcport->ha, fcport, 1, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001191 break;
1192
1193 case CS_RESET:
1194 DEBUG2(printk(KERN_INFO
1195 "scsi(%ld): RESET status detected 0x%x-0x%x.\n",
1196 ha->host_no, comp_status, scsi_status));
1197
f4f051e2005-04-17 15:02:26 -05001198 cp->result = DID_RESET << 16;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199 break;
1200
1201 case CS_ABORTED:
Andrew Vasquezfa2a1ce2005-07-06 10:32:07 -07001202 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001203 * hv2.19.12 - DID_ABORT does not retry the request if we
1204 * aborted this request then abort otherwise it must be a
1205 * reset.
1206 */
1207 DEBUG2(printk(KERN_INFO
1208 "scsi(%ld): ABORT status detected 0x%x-0x%x.\n",
1209 ha->host_no, comp_status, scsi_status));
1210
1211 cp->result = DID_RESET << 16;
1212 break;
1213
1214 case CS_TIMEOUT:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001215 cp->result = DID_BUS_BUSY << 16;
1216
Andrew Vasqueze4289242007-07-19 15:05:56 -07001217 if (IS_FWI2_CAPABLE(ha)) {
Andrew Vasquez9a853f72005-07-06 10:31:27 -07001218 DEBUG2(printk(KERN_INFO
1219 "scsi(%ld:%d:%d:%d): TIMEOUT status detected "
1220 "0x%x-0x%x\n", ha->host_no, cp->device->channel,
1221 cp->device->id, cp->device->lun, comp_status,
1222 scsi_status));
1223 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001224 }
Andrew Vasquez9a853f72005-07-06 10:31:27 -07001225 DEBUG2(printk(KERN_INFO
1226 "scsi(%ld:%d:%d:%d): TIMEOUT status detected 0x%x-0x%x "
1227 "sflags=%x.\n", ha->host_no, cp->device->channel,
1228 cp->device->id, cp->device->lun, comp_status, scsi_status,
1229 le16_to_cpu(sts->status_flags)));
1230
1231 /* Check to see if logout occurred. */
1232 if ((le16_to_cpu(sts->status_flags) & SF_LOGOUT_SENT))
Andrew Vasqueza7a28502008-08-13 21:36:57 -07001233 qla2x00_mark_device_lost(fcport->ha, fcport, 1, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001234 break;
1235
Linus Torvalds1da177e2005-04-16 15:20:36 -07001236 default:
1237 DEBUG3(printk("scsi(%ld): Error detected (unknown status) "
Andrew Vasquez9a853f72005-07-06 10:31:27 -07001238 "0x%x-0x%x.\n", ha->host_no, comp_status, scsi_status));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001239 qla_printk(KERN_INFO, ha,
1240 "Unknown status detected 0x%x-0x%x.\n",
1241 comp_status, scsi_status);
1242
1243 cp->result = DID_ERROR << 16;
1244 break;
1245 }
1246
1247 /* Place command on done queue. */
1248 if (ha->status_srb == NULL)
f4f051e2005-04-17 15:02:26 -05001249 qla2x00_sp_compl(ha, sp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001250}
1251
1252/**
1253 * qla2x00_status_cont_entry() - Process a Status Continuations entry.
1254 * @ha: SCSI driver HA context
1255 * @pkt: Entry pointer
1256 *
1257 * Extended sense data.
1258 */
1259static void
1260qla2x00_status_cont_entry(scsi_qla_host_t *ha, sts_cont_entry_t *pkt)
1261{
1262 uint8_t sense_sz = 0;
1263 srb_t *sp = ha->status_srb;
1264 struct scsi_cmnd *cp;
1265
1266 if (sp != NULL && sp->request_sense_length != 0) {
1267 cp = sp->cmd;
1268 if (cp == NULL) {
1269 DEBUG2(printk("%s(): Cmd already returned back to OS "
Andrew Vasquez75bc4192006-05-17 15:09:22 -07001270 "sp=%p.\n", __func__, sp));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001271 qla_printk(KERN_INFO, ha,
1272 "cmd is NULL: already returned to OS (sp=%p)\n",
Andrew Vasquezfa2a1ce2005-07-06 10:32:07 -07001273 sp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001274
1275 ha->status_srb = NULL;
1276 return;
1277 }
1278
1279 if (sp->request_sense_length > sizeof(pkt->data)) {
1280 sense_sz = sizeof(pkt->data);
1281 } else {
1282 sense_sz = sp->request_sense_length;
1283 }
1284
1285 /* Move sense data. */
Andrew Vasqueze4289242007-07-19 15:05:56 -07001286 if (IS_FWI2_CAPABLE(ha))
Andrew Vasquez9a853f72005-07-06 10:31:27 -07001287 host_to_fcp_swap(pkt->data, sizeof(pkt->data));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001288 memcpy(sp->request_sense_ptr, pkt->data, sense_sz);
1289 DEBUG5(qla2x00_dump_buffer(sp->request_sense_ptr, sense_sz));
1290
1291 sp->request_sense_ptr += sense_sz;
1292 sp->request_sense_length -= sense_sz;
1293
1294 /* Place command on done queue. */
1295 if (sp->request_sense_length == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001296 ha->status_srb = NULL;
f4f051e2005-04-17 15:02:26 -05001297 qla2x00_sp_compl(ha, sp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001298 }
1299 }
1300}
1301
1302/**
1303 * qla2x00_error_entry() - Process an error entry.
1304 * @ha: SCSI driver HA context
1305 * @pkt: Entry pointer
1306 */
1307static void
Andrew Vasquez9a853f72005-07-06 10:31:27 -07001308qla2x00_error_entry(scsi_qla_host_t *ha, sts_entry_t *pkt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001309{
1310 srb_t *sp;
1311
1312#if defined(QL_DEBUG_LEVEL_2)
1313 if (pkt->entry_status & RF_INV_E_ORDER)
1314 qla_printk(KERN_ERR, ha, "%s: Invalid Entry Order\n", __func__);
1315 else if (pkt->entry_status & RF_INV_E_COUNT)
1316 qla_printk(KERN_ERR, ha, "%s: Invalid Entry Count\n", __func__);
1317 else if (pkt->entry_status & RF_INV_E_PARAM)
Andrew Vasquezfa2a1ce2005-07-06 10:32:07 -07001318 qla_printk(KERN_ERR, ha,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001319 "%s: Invalid Entry Parameter\n", __func__);
1320 else if (pkt->entry_status & RF_INV_E_TYPE)
1321 qla_printk(KERN_ERR, ha, "%s: Invalid Entry Type\n", __func__);
1322 else if (pkt->entry_status & RF_BUSY)
1323 qla_printk(KERN_ERR, ha, "%s: Busy\n", __func__);
1324 else
1325 qla_printk(KERN_ERR, ha, "%s: UNKNOWN flag error\n", __func__);
1326#endif
1327
1328 /* Validate handle. */
1329 if (pkt->handle < MAX_OUTSTANDING_COMMANDS)
1330 sp = ha->outstanding_cmds[pkt->handle];
1331 else
1332 sp = NULL;
1333
1334 if (sp) {
1335 /* Free outstanding command slot. */
1336 ha->outstanding_cmds[pkt->handle] = NULL;
Andrew Vasquez 354d6b22005-04-23 02:47:27 -04001337
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338 /* Bad payload or header */
1339 if (pkt->entry_status &
1340 (RF_INV_E_ORDER | RF_INV_E_COUNT |
1341 RF_INV_E_PARAM | RF_INV_E_TYPE)) {
1342 sp->cmd->result = DID_ERROR << 16;
1343 } else if (pkt->entry_status & RF_BUSY) {
1344 sp->cmd->result = DID_BUS_BUSY << 16;
1345 } else {
1346 sp->cmd->result = DID_ERROR << 16;
1347 }
f4f051e2005-04-17 15:02:26 -05001348 qla2x00_sp_compl(ha, sp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001349
Andrew Vasquez9a853f72005-07-06 10:31:27 -07001350 } else if (pkt->entry_type == COMMAND_A64_TYPE || pkt->entry_type ==
1351 COMMAND_TYPE || pkt->entry_type == COMMAND_TYPE_7) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001352 DEBUG2(printk("scsi(%ld): Error entry - invalid handle\n",
1353 ha->host_no));
1354 qla_printk(KERN_WARNING, ha,
1355 "Error entry - invalid handle\n");
1356
1357 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
Christoph Hellwig39a11242006-02-14 18:46:22 +01001358 qla2xxx_wake_dpc(ha);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001359 }
1360}
1361
1362/**
Andrew Vasquez9a853f72005-07-06 10:31:27 -07001363 * qla24xx_mbx_completion() - Process mailbox command completions.
1364 * @ha: SCSI driver HA context
1365 * @mb0: Mailbox0 register
1366 */
1367static void
1368qla24xx_mbx_completion(scsi_qla_host_t *ha, uint16_t mb0)
1369{
1370 uint16_t cnt;
1371 uint16_t __iomem *wptr;
1372 struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
1373
1374 /* Load return mailbox registers. */
1375 ha->flags.mbox_int = 1;
1376 ha->mailbox_out[0] = mb0;
1377 wptr = (uint16_t __iomem *)&reg->mailbox1;
1378
1379 for (cnt = 1; cnt < ha->mbx_count; cnt++) {
1380 ha->mailbox_out[cnt] = RD_REG_WORD(wptr);
1381 wptr++;
1382 }
1383
1384 if (ha->mcp) {
1385 DEBUG3(printk("%s(%ld): Got mailbox completion. cmd=%x.\n",
1386 __func__, ha->host_no, ha->mcp->mb[0]));
1387 } else {
1388 DEBUG2_3(printk("%s(%ld): MBX pointer ERROR!\n",
1389 __func__, ha->host_no));
1390 }
1391}
1392
1393/**
1394 * qla24xx_process_response_queue() - Process response queue entries.
1395 * @ha: SCSI driver HA context
1396 */
1397void
1398qla24xx_process_response_queue(struct scsi_qla_host *ha)
1399{
1400 struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
1401 struct sts_entry_24xx *pkt;
1402
1403 if (!ha->flags.online)
1404 return;
1405
1406 while (ha->response_ring_ptr->signature != RESPONSE_PROCESSED) {
1407 pkt = (struct sts_entry_24xx *)ha->response_ring_ptr;
1408
1409 ha->rsp_ring_index++;
1410 if (ha->rsp_ring_index == ha->response_q_length) {
1411 ha->rsp_ring_index = 0;
1412 ha->response_ring_ptr = ha->response_ring;
1413 } else {
1414 ha->response_ring_ptr++;
1415 }
1416
1417 if (pkt->entry_status != 0) {
1418 DEBUG3(printk(KERN_INFO
1419 "scsi(%ld): Process error entry.\n", ha->host_no));
1420
Andrew Vasquez9a853f72005-07-06 10:31:27 -07001421 qla2x00_error_entry(ha, (sts_entry_t *) pkt);
1422 ((response_t *)pkt)->signature = RESPONSE_PROCESSED;
1423 wmb();
1424 continue;
1425 }
1426
1427 switch (pkt->entry_type) {
1428 case STATUS_TYPE:
1429 qla2x00_status_entry(ha, pkt);
1430 break;
1431 case STATUS_CONT_TYPE:
1432 qla2x00_status_cont_entry(ha, (sts_cont_entry_t *)pkt);
1433 break;
Seokmann Ju2c3dfe32007-07-05 13:16:51 -07001434 case VP_RPT_ID_IOCB_TYPE:
1435 qla24xx_report_id_acquisition(ha,
1436 (struct vp_rpt_id_entry_24xx *)pkt);
1437 break;
Andrew Vasquez9a853f72005-07-06 10:31:27 -07001438 default:
1439 /* Type Not Supported. */
1440 DEBUG4(printk(KERN_WARNING
1441 "scsi(%ld): Received unknown response pkt type %x "
1442 "entry status=%x.\n",
1443 ha->host_no, pkt->entry_type, pkt->entry_status));
1444 break;
1445 }
1446 ((response_t *)pkt)->signature = RESPONSE_PROCESSED;
1447 wmb();
1448 }
1449
1450 /* Adjust ring index */
1451 WRT_REG_DWORD(&reg->rsp_q_out, ha->rsp_ring_index);
1452}
1453
Andrew Vasquez05236a02007-09-20 14:07:37 -07001454static void
1455qla2xxx_check_risc_status(scsi_qla_host_t *ha)
1456{
1457 int rval;
1458 uint32_t cnt;
1459 struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
1460
1461 if (!IS_QLA25XX(ha))
1462 return;
1463
1464 rval = QLA_SUCCESS;
1465 WRT_REG_DWORD(&reg->iobase_addr, 0x7C00);
1466 RD_REG_DWORD(&reg->iobase_addr);
1467 WRT_REG_DWORD(&reg->iobase_window, 0x0001);
1468 for (cnt = 10000; (RD_REG_DWORD(&reg->iobase_window) & BIT_0) == 0 &&
1469 rval == QLA_SUCCESS; cnt--) {
1470 if (cnt) {
1471 WRT_REG_DWORD(&reg->iobase_window, 0x0001);
1472 udelay(10);
1473 } else
1474 rval = QLA_FUNCTION_TIMEOUT;
1475 }
1476 if (rval == QLA_SUCCESS)
1477 goto next_test;
1478
1479 WRT_REG_DWORD(&reg->iobase_window, 0x0003);
1480 for (cnt = 100; (RD_REG_DWORD(&reg->iobase_window) & BIT_0) == 0 &&
1481 rval == QLA_SUCCESS; cnt--) {
1482 if (cnt) {
1483 WRT_REG_DWORD(&reg->iobase_window, 0x0003);
1484 udelay(10);
1485 } else
1486 rval = QLA_FUNCTION_TIMEOUT;
1487 }
1488 if (rval != QLA_SUCCESS)
1489 goto done;
1490
1491next_test:
1492 if (RD_REG_DWORD(&reg->iobase_c8) & BIT_3)
1493 qla_printk(KERN_INFO, ha, "Additional code -- 0x55AA.\n");
1494
1495done:
1496 WRT_REG_DWORD(&reg->iobase_window, 0x0000);
1497 RD_REG_DWORD(&reg->iobase_window);
1498}
1499
Andrew Vasquez9a853f72005-07-06 10:31:27 -07001500/**
1501 * qla24xx_intr_handler() - Process interrupts for the ISP23xx and ISP63xx.
1502 * @irq:
1503 * @dev_id: SCSI driver HA context
Andrew Vasquez9a853f72005-07-06 10:31:27 -07001504 *
1505 * Called by system whenever the host adapter generates an interrupt.
1506 *
1507 * Returns handled flag.
1508 */
1509irqreturn_t
David Howells7d12e782006-10-05 14:55:46 +01001510qla24xx_intr_handler(int irq, void *dev_id)
Andrew Vasquez9a853f72005-07-06 10:31:27 -07001511{
1512 scsi_qla_host_t *ha;
1513 struct device_reg_24xx __iomem *reg;
1514 int status;
Andrew Vasquez9a853f72005-07-06 10:31:27 -07001515 unsigned long iter;
1516 uint32_t stat;
1517 uint32_t hccr;
1518 uint16_t mb[4];
1519
1520 ha = (scsi_qla_host_t *) dev_id;
1521 if (!ha) {
1522 printk(KERN_INFO
1523 "%s(): NULL host pointer\n", __func__);
1524 return IRQ_NONE;
1525 }
1526
1527 reg = &ha->iobase->isp24;
1528 status = 0;
1529
Andrew Vasquezc6952482008-04-03 13:13:17 -07001530 spin_lock(&ha->hardware_lock);
Andrew Vasquez9a853f72005-07-06 10:31:27 -07001531 for (iter = 50; iter--; ) {
1532 stat = RD_REG_DWORD(&reg->host_status);
1533 if (stat & HSRX_RISC_PAUSED) {
Seokmann Ju14e660e2007-09-20 14:07:36 -07001534 if (pci_channel_offline(ha->pdev))
1535 break;
1536
Andrew Vasquezcb8dacb2008-04-03 13:13:19 -07001537 if (ha->hw_event_pause_errors == 0)
1538 qla2x00_post_hwe_work(ha, HW_EVENT_PARITY_ERR,
1539 0, MSW(stat), LSW(stat));
1540 else if (ha->hw_event_pause_errors < 0xffffffff)
1541 ha->hw_event_pause_errors++;
1542
Andrew Vasquez9a853f72005-07-06 10:31:27 -07001543 hccr = RD_REG_DWORD(&reg->hccr);
1544
1545 qla_printk(KERN_INFO, ha, "RISC paused -- HCCR=%x, "
1546 "Dumping firmware!\n", hccr);
Andrew Vasquez05236a02007-09-20 14:07:37 -07001547
1548 qla2xxx_check_risc_status(ha);
1549
Andrew Vasquezfd34f552007-07-19 15:06:00 -07001550 ha->isp_ops->fw_dump(ha, 1);
Andrew Vasquez9a853f72005-07-06 10:31:27 -07001551 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
1552 break;
1553 } else if ((stat & HSRX_RISC_INT) == 0)
1554 break;
1555
1556 switch (stat & 0xff) {
1557 case 0x1:
1558 case 0x2:
1559 case 0x10:
1560 case 0x11:
1561 qla24xx_mbx_completion(ha, MSW(stat));
1562 status |= MBX_INTERRUPT;
1563
1564 break;
1565 case 0x12:
1566 mb[0] = MSW(stat);
1567 mb[1] = RD_REG_WORD(&reg->mailbox1);
1568 mb[2] = RD_REG_WORD(&reg->mailbox2);
1569 mb[3] = RD_REG_WORD(&reg->mailbox3);
1570 qla2x00_async_event(ha, mb);
1571 break;
1572 case 0x13:
1573 qla24xx_process_response_queue(ha);
1574 break;
1575 default:
1576 DEBUG2(printk("scsi(%ld): Unrecognized interrupt type "
1577 "(%d).\n",
1578 ha->host_no, stat & 0xff));
1579 break;
1580 }
1581 WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
1582 RD_REG_DWORD_RELAXED(&reg->hccr);
1583 }
Andrew Vasquezc6952482008-04-03 13:13:17 -07001584 spin_unlock(&ha->hardware_lock);
Andrew Vasquez9a853f72005-07-06 10:31:27 -07001585
1586 if (test_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags) &&
1587 (status & MBX_INTERRUPT) && ha->flags.mbox_int) {
Andrew Vasquez9a853f72005-07-06 10:31:27 -07001588 set_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
Marcus Barrow0b05a1f2008-01-17 09:02:13 -08001589 complete(&ha->mbx_intr_comp);
Andrew Vasquez9a853f72005-07-06 10:31:27 -07001590 }
1591
1592 return IRQ_HANDLED;
1593}
1594
Andrew Vasqueza8488ab2007-01-29 10:22:19 -08001595static irqreturn_t
1596qla24xx_msix_rsp_q(int irq, void *dev_id)
1597{
1598 scsi_qla_host_t *ha;
1599 struct device_reg_24xx __iomem *reg;
Andrew Vasqueza8488ab2007-01-29 10:22:19 -08001600
1601 ha = dev_id;
1602 reg = &ha->iobase->isp24;
1603
Andrew Vasquez0e973a22008-05-12 22:21:09 -07001604 spin_lock_irq(&ha->hardware_lock);
Andrew Vasqueza8488ab2007-01-29 10:22:19 -08001605
1606 qla24xx_process_response_queue(ha);
Andrew Vasqueza8488ab2007-01-29 10:22:19 -08001607 WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
Andrew Vasqueza8488ab2007-01-29 10:22:19 -08001608
Andrew Vasquez0e973a22008-05-12 22:21:09 -07001609 spin_unlock_irq(&ha->hardware_lock);
Andrew Vasqueza8488ab2007-01-29 10:22:19 -08001610
1611 return IRQ_HANDLED;
1612}
1613
1614static irqreturn_t
1615qla24xx_msix_default(int irq, void *dev_id)
1616{
1617 scsi_qla_host_t *ha;
1618 struct device_reg_24xx __iomem *reg;
1619 int status;
Andrew Vasqueza8488ab2007-01-29 10:22:19 -08001620 uint32_t stat;
1621 uint32_t hccr;
1622 uint16_t mb[4];
1623
1624 ha = dev_id;
1625 reg = &ha->iobase->isp24;
1626 status = 0;
1627
Andrew Vasquez0e973a22008-05-12 22:21:09 -07001628 spin_lock_irq(&ha->hardware_lock);
Andrew Vasquez87f27012007-09-20 14:07:49 -07001629 do {
Andrew Vasqueza8488ab2007-01-29 10:22:19 -08001630 stat = RD_REG_DWORD(&reg->host_status);
1631 if (stat & HSRX_RISC_PAUSED) {
Seokmann Ju14e660e2007-09-20 14:07:36 -07001632 if (pci_channel_offline(ha->pdev))
1633 break;
1634
Andrew Vasquezcb8dacb2008-04-03 13:13:19 -07001635 if (ha->hw_event_pause_errors == 0)
1636 qla2x00_post_hwe_work(ha, HW_EVENT_PARITY_ERR,
1637 0, MSW(stat), LSW(stat));
1638 else if (ha->hw_event_pause_errors < 0xffffffff)
1639 ha->hw_event_pause_errors++;
1640
Andrew Vasqueza8488ab2007-01-29 10:22:19 -08001641 hccr = RD_REG_DWORD(&reg->hccr);
1642
1643 qla_printk(KERN_INFO, ha, "RISC paused -- HCCR=%x, "
1644 "Dumping firmware!\n", hccr);
Andrew Vasquez05236a02007-09-20 14:07:37 -07001645
1646 qla2xxx_check_risc_status(ha);
1647
Andrew Vasquezfd34f552007-07-19 15:06:00 -07001648 ha->isp_ops->fw_dump(ha, 1);
Andrew Vasqueza8488ab2007-01-29 10:22:19 -08001649 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
1650 break;
1651 } else if ((stat & HSRX_RISC_INT) == 0)
1652 break;
1653
1654 switch (stat & 0xff) {
1655 case 0x1:
1656 case 0x2:
1657 case 0x10:
1658 case 0x11:
1659 qla24xx_mbx_completion(ha, MSW(stat));
1660 status |= MBX_INTERRUPT;
1661
1662 break;
1663 case 0x12:
1664 mb[0] = MSW(stat);
1665 mb[1] = RD_REG_WORD(&reg->mailbox1);
1666 mb[2] = RD_REG_WORD(&reg->mailbox2);
1667 mb[3] = RD_REG_WORD(&reg->mailbox3);
1668 qla2x00_async_event(ha, mb);
1669 break;
1670 case 0x13:
1671 qla24xx_process_response_queue(ha);
1672 break;
1673 default:
1674 DEBUG2(printk("scsi(%ld): Unrecognized interrupt type "
1675 "(%d).\n",
1676 ha->host_no, stat & 0xff));
1677 break;
1678 }
1679 WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
Andrew Vasquez87f27012007-09-20 14:07:49 -07001680 } while (0);
Andrew Vasquez0e973a22008-05-12 22:21:09 -07001681 spin_unlock_irq(&ha->hardware_lock);
Andrew Vasqueza8488ab2007-01-29 10:22:19 -08001682
1683 if (test_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags) &&
1684 (status & MBX_INTERRUPT) && ha->flags.mbox_int) {
Andrew Vasqueza8488ab2007-01-29 10:22:19 -08001685 set_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
Marcus Barrow0b05a1f2008-01-17 09:02:13 -08001686 complete(&ha->mbx_intr_comp);
Andrew Vasqueza8488ab2007-01-29 10:22:19 -08001687 }
1688
1689 return IRQ_HANDLED;
1690}
1691
1692/* Interrupt handling helpers. */
1693
1694struct qla_init_msix_entry {
1695 uint16_t entry;
1696 uint16_t index;
1697 const char *name;
Jeff Garzik476834c2007-05-23 14:41:44 -07001698 irq_handler_t handler;
Andrew Vasqueza8488ab2007-01-29 10:22:19 -08001699};
1700
1701static struct qla_init_msix_entry imsix_entries[QLA_MSIX_ENTRIES] = {
1702 { QLA_MSIX_DEFAULT, QLA_MIDX_DEFAULT,
1703 "qla2xxx (default)", qla24xx_msix_default },
1704
1705 { QLA_MSIX_RSP_Q, QLA_MIDX_RSP_Q,
1706 "qla2xxx (rsp_q)", qla24xx_msix_rsp_q },
1707};
1708
1709static void
1710qla24xx_disable_msix(scsi_qla_host_t *ha)
1711{
1712 int i;
1713 struct qla_msix_entry *qentry;
1714
1715 for (i = 0; i < QLA_MSIX_ENTRIES; i++) {
1716 qentry = &ha->msix_entries[imsix_entries[i].index];
1717 if (qentry->have_irq)
1718 free_irq(qentry->msix_vector, ha);
1719 }
1720 pci_disable_msix(ha->pdev);
1721}
1722
1723static int
1724qla24xx_enable_msix(scsi_qla_host_t *ha)
1725{
1726 int i, ret;
1727 struct msix_entry entries[QLA_MSIX_ENTRIES];
1728 struct qla_msix_entry *qentry;
1729
1730 for (i = 0; i < QLA_MSIX_ENTRIES; i++)
1731 entries[i].entry = imsix_entries[i].entry;
1732
1733 ret = pci_enable_msix(ha->pdev, entries, ARRAY_SIZE(entries));
1734 if (ret) {
1735 qla_printk(KERN_WARNING, ha,
1736 "MSI-X: Failed to enable support -- %d/%d\n",
1737 QLA_MSIX_ENTRIES, ret);
1738 goto msix_out;
1739 }
1740 ha->flags.msix_enabled = 1;
1741
1742 for (i = 0; i < QLA_MSIX_ENTRIES; i++) {
1743 qentry = &ha->msix_entries[imsix_entries[i].index];
1744 qentry->msix_vector = entries[i].vector;
1745 qentry->msix_entry = entries[i].entry;
1746 qentry->have_irq = 0;
1747 ret = request_irq(qentry->msix_vector,
1748 imsix_entries[i].handler, 0, imsix_entries[i].name, ha);
1749 if (ret) {
1750 qla_printk(KERN_WARNING, ha,
1751 "MSI-X: Unable to register handler -- %x/%d.\n",
1752 imsix_entries[i].index, ret);
1753 qla24xx_disable_msix(ha);
1754 goto msix_out;
1755 }
1756 qentry->have_irq = 1;
1757 }
1758
1759msix_out:
1760 return ret;
1761}
1762
1763int
1764qla2x00_request_irqs(scsi_qla_host_t *ha)
1765{
1766 int ret;
Andrew Vasquez963b0fd2008-01-31 12:33:50 -08001767 device_reg_t __iomem *reg = ha->iobase;
Andrew Vasqueza8488ab2007-01-29 10:22:19 -08001768
1769 /* If possible, enable MSI-X. */
Harihara Kadayam4d4df192008-04-03 13:13:26 -07001770 if (!IS_QLA2432(ha) && !IS_QLA2532(ha) && !IS_QLA8432(ha))
Andrew Vasqueza8488ab2007-01-29 10:22:19 -08001771 goto skip_msix;
1772
Andrew Vasquezc3a2f0d2007-07-19 20:37:34 -07001773 if (IS_QLA2432(ha) && (ha->chip_revision < QLA_MSIX_CHIP_REV_24XX ||
1774 !QLA_MSIX_FW_MODE_1(ha->fw_attributes))) {
Andrew Vasqueza8488ab2007-01-29 10:22:19 -08001775 DEBUG2(qla_printk(KERN_WARNING, ha,
1776 "MSI-X: Unsupported ISP2432 (0x%X, 0x%X).\n",
1777 ha->chip_revision, ha->fw_attributes));
1778
1779 goto skip_msix;
1780 }
1781
Andrew Vasquezda7429f2008-01-17 09:02:11 -08001782 if (ha->pdev->subsystem_vendor == PCI_VENDOR_ID_HP &&
1783 (ha->pdev->subsystem_device == 0x7040 ||
1784 ha->pdev->subsystem_device == 0x7041 ||
1785 ha->pdev->subsystem_device == 0x1705)) {
1786 DEBUG2(qla_printk(KERN_WARNING, ha,
1787 "MSI-X: Unsupported ISP2432 SSVID/SSDID (0x%X, 0x%X).\n",
1788 ha->pdev->subsystem_vendor,
1789 ha->pdev->subsystem_device));
1790
1791 goto skip_msi;
1792 }
1793
Andrew Vasqueza8488ab2007-01-29 10:22:19 -08001794 ret = qla24xx_enable_msix(ha);
1795 if (!ret) {
1796 DEBUG2(qla_printk(KERN_INFO, ha,
1797 "MSI-X: Enabled (0x%X, 0x%X).\n", ha->chip_revision,
1798 ha->fw_attributes));
Andrew Vasquez963b0fd2008-01-31 12:33:50 -08001799 goto clear_risc_ints;
Andrew Vasqueza8488ab2007-01-29 10:22:19 -08001800 }
1801 qla_printk(KERN_WARNING, ha,
1802 "MSI-X: Falling back-to INTa mode -- %d.\n", ret);
1803skip_msix:
Andrew Vasquezcbedb602007-05-07 07:43:02 -07001804
Harihara Kadayam4d4df192008-04-03 13:13:26 -07001805 if (!IS_QLA24XX(ha) && !IS_QLA2532(ha) && !IS_QLA8432(ha))
Andrew Vasquezcbedb602007-05-07 07:43:02 -07001806 goto skip_msi;
1807
1808 ret = pci_enable_msi(ha->pdev);
1809 if (!ret) {
1810 DEBUG2(qla_printk(KERN_INFO, ha, "MSI: Enabled.\n"));
1811 ha->flags.msi_enabled = 1;
1812 }
1813skip_msi:
1814
Andrew Vasquezfd34f552007-07-19 15:06:00 -07001815 ret = request_irq(ha->pdev->irq, ha->isp_ops->intr_handler,
Andrew Vasqueza8488ab2007-01-29 10:22:19 -08001816 IRQF_DISABLED|IRQF_SHARED, QLA2XXX_DRIVER_NAME, ha);
Andrew Vasquez963b0fd2008-01-31 12:33:50 -08001817 if (ret) {
Andrew Vasqueza8488ab2007-01-29 10:22:19 -08001818 qla_printk(KERN_WARNING, ha,
1819 "Failed to reserve interrupt %d already in use.\n",
1820 ha->pdev->irq);
Andrew Vasquez963b0fd2008-01-31 12:33:50 -08001821 goto fail;
Andrew Vasqueza8488ab2007-01-29 10:22:19 -08001822 }
Andrew Vasquez963b0fd2008-01-31 12:33:50 -08001823 ha->flags.inta_enabled = 1;
1824 ha->host->irq = ha->pdev->irq;
1825clear_risc_ints:
Andrew Vasqueza8488ab2007-01-29 10:22:19 -08001826
Andrew Vasquez963b0fd2008-01-31 12:33:50 -08001827 ha->isp_ops->disable_intrs(ha);
Andrew Vasquezc6952482008-04-03 13:13:17 -07001828 spin_lock_irq(&ha->hardware_lock);
Andrew Vasquez963b0fd2008-01-31 12:33:50 -08001829 if (IS_FWI2_CAPABLE(ha)) {
1830 WRT_REG_DWORD(&reg->isp24.hccr, HCCRX_CLR_HOST_INT);
1831 WRT_REG_DWORD(&reg->isp24.hccr, HCCRX_CLR_RISC_INT);
1832 } else {
1833 WRT_REG_WORD(&reg->isp.semaphore, 0);
1834 WRT_REG_WORD(&reg->isp.hccr, HCCR_CLR_RISC_INT);
1835 WRT_REG_WORD(&reg->isp.hccr, HCCR_CLR_HOST_INT);
1836 }
Andrew Vasquezc6952482008-04-03 13:13:17 -07001837 spin_unlock_irq(&ha->hardware_lock);
Andrew Vasquez963b0fd2008-01-31 12:33:50 -08001838
1839fail:
Andrew Vasqueza8488ab2007-01-29 10:22:19 -08001840 return ret;
1841}
1842
1843void
1844qla2x00_free_irqs(scsi_qla_host_t *ha)
1845{
1846
1847 if (ha->flags.msix_enabled)
1848 qla24xx_disable_msix(ha);
Andrew Vasquezcbedb602007-05-07 07:43:02 -07001849 else if (ha->flags.inta_enabled) {
Andrew Vasqueza8488ab2007-01-29 10:22:19 -08001850 free_irq(ha->host->irq, ha);
Andrew Vasquezcbedb602007-05-07 07:43:02 -07001851 pci_disable_msi(ha->pdev);
1852 }
Andrew Vasqueza8488ab2007-01-29 10:22:19 -08001853}