?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
WIP FPC-III support
[linux/fpc-iii.git] / drivers / scsi / qla4xxx / ql4_isr.c
bloba51910ae95252a40570929931dcb9a471bbb78a5
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * QLogic iSCSI HBA Driver
4 * Copyright (c) 2003-2013 QLogic Corporation
5 */
6
7 #include "ql4_def.h"
8 #include "ql4_glbl.h"
9 #include "ql4_dbg.h"
10 #include "ql4_inline.h"
11
12 /**
13 * qla4xxx_copy_sense - copy sense data into cmd sense buffer
14 * @ha: Pointer to host adapter structure.
15 * @sts_entry: Pointer to status entry structure.
16 * @srb: Pointer to srb structure.
17 **/
18 static void qla4xxx_copy_sense(struct scsi_qla_host *ha,
19 struct status_entry *sts_entry,
20 struct srb *srb)
21 {
22 struct scsi_cmnd *cmd = srb->cmd;
23 uint16_t sense_len;
24
25 memset(cmd->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
26 sense_len = le16_to_cpu(sts_entry->senseDataByteCnt);
27 if (sense_len == 0) {
28 DEBUG2(ql4_printk(KERN_INFO, ha, "scsi%ld:%d:%d:%llu: %s:"
29 " sense len 0\n", ha->host_no,
30 cmd->device->channel, cmd->device->id,
31 cmd->device->lun, __func__));
32 ha->status_srb = NULL;
33 return;
34 }
35 /* Save total available sense length,
36 * not to exceed cmd's sense buffer size */
37 sense_len = min_t(uint16_t, sense_len, SCSI_SENSE_BUFFERSIZE);
38 srb->req_sense_ptr = cmd->sense_buffer;
39 srb->req_sense_len = sense_len;
40
41 /* Copy sense from sts_entry pkt */
42 sense_len = min_t(uint16_t, sense_len, IOCB_MAX_SENSEDATA_LEN);
43 memcpy(cmd->sense_buffer, sts_entry->senseData, sense_len);
44
45 DEBUG2(printk(KERN_INFO "scsi%ld:%d:%d:%llu: %s: sense key = %x, "
46 "ASL= %02x, ASC/ASCQ = %02x/%02x\n", ha->host_no,
47 cmd->device->channel, cmd->device->id,
48 cmd->device->lun, __func__,
49 sts_entry->senseData[2] & 0x0f,
50 sts_entry->senseData[7],
51 sts_entry->senseData[12],
52 sts_entry->senseData[13]));
53
54 DEBUG5(qla4xxx_dump_buffer(cmd->sense_buffer, sense_len));
55 srb->flags |= SRB_GOT_SENSE;
56
57 /* Update srb, in case a sts_cont pkt follows */
58 srb->req_sense_ptr += sense_len;
59 srb->req_sense_len -= sense_len;
60 if (srb->req_sense_len != 0)
61 ha->status_srb = srb;
62 else
63 ha->status_srb = NULL;
64 }
65
66 /**
67 * qla4xxx_status_cont_entry - Process a Status Continuations entry.
68 * @ha: SCSI driver HA context
69 * @sts_cont: Entry pointer
70 *
71 * Extended sense data.
72 */
73 static void
74 qla4xxx_status_cont_entry(struct scsi_qla_host *ha,
75 struct status_cont_entry *sts_cont)
76 {
77 struct srb *srb = ha->status_srb;
78 struct scsi_cmnd *cmd;
79 uint16_t sense_len;
80
81 if (srb == NULL)
82 return;
83
84 cmd = srb->cmd;
85 if (cmd == NULL) {
86 DEBUG2(printk(KERN_INFO "scsi%ld: %s: Cmd already returned "
87 "back to OS srb=%p srb->state:%d\n", ha->host_no,
88 __func__, srb, srb->state));
89 ha->status_srb = NULL;
90 return;
91 }
92
93 /* Copy sense data. */
94 sense_len = min_t(uint16_t, srb->req_sense_len,
95 IOCB_MAX_EXT_SENSEDATA_LEN);
96 memcpy(srb->req_sense_ptr, sts_cont->ext_sense_data, sense_len);
97 DEBUG5(qla4xxx_dump_buffer(srb->req_sense_ptr, sense_len));
98
99 srb->req_sense_ptr += sense_len;
100 srb->req_sense_len -= sense_len;
101
102 /* Place command on done queue. */
103 if (srb->req_sense_len == 0) {
104 kref_put(&srb->srb_ref, qla4xxx_srb_compl);
105 ha->status_srb = NULL;
106 }
107 }
108
109 /**
110 * qla4xxx_status_entry - processes status IOCBs
111 * @ha: Pointer to host adapter structure.
112 * @sts_entry: Pointer to status entry structure.
113 **/
114 static void qla4xxx_status_entry(struct scsi_qla_host *ha,
115 struct status_entry *sts_entry)
116 {
117 uint8_t scsi_status;
118 struct scsi_cmnd *cmd;
119 struct srb *srb;
120 struct ddb_entry *ddb_entry;
121 uint32_t residual;
122
123 srb = qla4xxx_del_from_active_array(ha, le32_to_cpu(sts_entry->handle));
124 if (!srb) {
125 ql4_printk(KERN_WARNING, ha, "%s invalid status entry: "
126 "handle=0x%0x, srb=%p\n", __func__,
127 sts_entry->handle, srb);
128 if (is_qla80XX(ha))
129 set_bit(DPC_RESET_HA_FW_CONTEXT, &ha->dpc_flags);
130 else
131 set_bit(DPC_RESET_HA, &ha->dpc_flags);
132 return;
133 }
134
135 cmd = srb->cmd;
136 if (cmd == NULL) {
137 DEBUG2(printk("scsi%ld: %s: Command already returned back to "
138 "OS pkt->handle=%d srb=%p srb->state:%d\n",
139 ha->host_no, __func__, sts_entry->handle,
140 srb, srb->state));
141 ql4_printk(KERN_WARNING, ha, "Command is NULL:"
142 " already returned to OS (srb=%p)\n", srb);
143 return;
144 }
145
146 ddb_entry = srb->ddb;
147 if (ddb_entry == NULL) {
148 cmd->result = DID_NO_CONNECT << 16;
149 goto status_entry_exit;
150 }
151
152 residual = le32_to_cpu(sts_entry->residualByteCnt);
153
154 /* Translate ISP error to a Linux SCSI error. */
155 scsi_status = sts_entry->scsiStatus;
156 switch (sts_entry->completionStatus) {
157 case SCS_COMPLETE:
158
159 if (sts_entry->iscsiFlags & ISCSI_FLAG_RESIDUAL_OVER) {
160 cmd->result = DID_ERROR << 16;
161 break;
162 }
163
164 if (sts_entry->iscsiFlags &ISCSI_FLAG_RESIDUAL_UNDER) {
165 scsi_set_resid(cmd, residual);
166 if (!scsi_status && ((scsi_bufflen(cmd) - residual) <
167 cmd->underflow)) {
168
169 cmd->result = DID_ERROR << 16;
170
171 DEBUG2(printk("scsi%ld:%d:%d:%llu: %s: "
172 "Mid-layer Data underrun0, "
173 "xferlen = 0x%x, "
174 "residual = 0x%x\n", ha->host_no,
175 cmd->device->channel,
176 cmd->device->id,
177 cmd->device->lun, __func__,
178 scsi_bufflen(cmd), residual));
179 break;
180 }
181 }
182
183 cmd->result = DID_OK << 16 | scsi_status;
184
185 if (scsi_status != SCSI_CHECK_CONDITION)
186 break;
187
188 /* Copy Sense Data into sense buffer. */
189 qla4xxx_copy_sense(ha, sts_entry, srb);
190 break;
191
192 case SCS_INCOMPLETE:
193 /* Always set the status to DID_ERROR, since
194 * all conditions result in that status anyway */
195 cmd->result = DID_ERROR << 16;
196 break;
197
198 case SCS_RESET_OCCURRED:
199 DEBUG2(printk("scsi%ld:%d:%d:%llu: %s: Device RESET occurred\n",
200 ha->host_no, cmd->device->channel,
201 cmd->device->id, cmd->device->lun, __func__));
202
203 cmd->result = DID_RESET << 16;
204 break;
205
206 case SCS_ABORTED:
207 DEBUG2(printk("scsi%ld:%d:%d:%llu: %s: Abort occurred\n",
208 ha->host_no, cmd->device->channel,
209 cmd->device->id, cmd->device->lun, __func__));
210
211 cmd->result = DID_RESET << 16;
212 break;
213
214 case SCS_TIMEOUT:
215 DEBUG2(printk(KERN_INFO "scsi%ld:%d:%d:%llu: Timeout\n",
216 ha->host_no, cmd->device->channel,
217 cmd->device->id, cmd->device->lun));
218
219 cmd->result = DID_TRANSPORT_DISRUPTED << 16;
220
221 /*
222 * Mark device missing so that we won't continue to send
223 * I/O to this device. We should get a ddb state change
224 * AEN soon.
225 */
226 if (iscsi_is_session_online(ddb_entry->sess))
227 qla4xxx_mark_device_missing(ddb_entry->sess);
228 break;
229
230 case SCS_DATA_UNDERRUN:
231 case SCS_DATA_OVERRUN:
232 if ((sts_entry->iscsiFlags & ISCSI_FLAG_RESIDUAL_OVER) ||
233 (sts_entry->completionStatus == SCS_DATA_OVERRUN)) {
234 DEBUG2(printk("scsi%ld:%d:%d:%llu: %s: " "Data overrun\n",
235 ha->host_no,
236 cmd->device->channel, cmd->device->id,
237 cmd->device->lun, __func__));
238
239 cmd->result = DID_ERROR << 16;
240 break;
241 }
242
243 scsi_set_resid(cmd, residual);
244
245 if (sts_entry->iscsiFlags & ISCSI_FLAG_RESIDUAL_UNDER) {
246
247 /* Both the firmware and target reported UNDERRUN:
248 *
249 * MID-LAYER UNDERFLOW case:
250 * Some kernels do not properly detect midlayer
251 * underflow, so we manually check it and return
252 * ERROR if the minimum required data was not
253 * received.
254 *
255 * ALL OTHER cases:
256 * Fall thru to check scsi_status
257 */
258 if (!scsi_status && (scsi_bufflen(cmd) - residual) <
259 cmd->underflow) {
260 DEBUG2(ql4_printk(KERN_INFO, ha,
261 "scsi%ld:%d:%d:%llu: %s: Mid-layer Data underrun, xferlen = 0x%x,residual = 0x%x\n",
262 ha->host_no,
263 cmd->device->channel,
264 cmd->device->id,
265 cmd->device->lun, __func__,
266 scsi_bufflen(cmd),
267 residual));
268
269 cmd->result = DID_ERROR << 16;
270 break;
271 }
272
273 } else if (scsi_status != SAM_STAT_TASK_SET_FULL &&
274 scsi_status != SAM_STAT_BUSY) {
275
276 /*
277 * The firmware reports UNDERRUN, but the target does
278 * not report it:
279 *
280 * scsi_status | host_byte device_byte
281 * | (19:16) (7:0)
282 * ============= | ========= ===========
283 * TASK_SET_FULL | DID_OK scsi_status
284 * BUSY | DID_OK scsi_status
285 * ALL OTHERS | DID_ERROR scsi_status
286 *
287 * Note: If scsi_status is task set full or busy,
288 * then this else if would fall thru to check the
289 * scsi_status and return DID_OK.
290 */
291
292 DEBUG2(ql4_printk(KERN_INFO, ha,
293 "scsi%ld:%d:%d:%llu: %s: Dropped frame(s) detected (0x%x of 0x%x bytes).\n",
294 ha->host_no,
295 cmd->device->channel,
296 cmd->device->id,
297 cmd->device->lun, __func__,
298 residual,
299 scsi_bufflen(cmd)));
300
301 cmd->result = DID_ERROR << 16 | scsi_status;
302 goto check_scsi_status;
303 }
304
305 cmd->result = DID_OK << 16 | scsi_status;
306
307 check_scsi_status:
308 if (scsi_status == SAM_STAT_CHECK_CONDITION)
309 qla4xxx_copy_sense(ha, sts_entry, srb);
310
311 break;
312
313 case SCS_DEVICE_LOGGED_OUT:
314 case SCS_DEVICE_UNAVAILABLE:
315 DEBUG2(printk(KERN_INFO "scsi%ld:%d:%d:%llu: SCS_DEVICE "
316 "state: 0x%x\n", ha->host_no,
317 cmd->device->channel, cmd->device->id,
318 cmd->device->lun, sts_entry->completionStatus));
319 /*
320 * Mark device missing so that we won't continue to
321 * send I/O to this device. We should get a ddb
322 * state change AEN soon.
323 */
324 if (iscsi_is_session_online(ddb_entry->sess))
325 qla4xxx_mark_device_missing(ddb_entry->sess);
326
327 cmd->result = DID_TRANSPORT_DISRUPTED << 16;
328 break;
329
330 case SCS_QUEUE_FULL:
331 /*
332 * SCSI Mid-Layer handles device queue full
333 */
334 cmd->result = DID_OK << 16 | sts_entry->scsiStatus;
335 DEBUG2(printk("scsi%ld:%d:%llu: %s: QUEUE FULL detected "
336 "compl=%02x, scsi=%02x, state=%02x, iFlags=%02x,"
337 " iResp=%02x\n", ha->host_no, cmd->device->id,
338 cmd->device->lun, __func__,
339 sts_entry->completionStatus,
340 sts_entry->scsiStatus, sts_entry->state_flags,
341 sts_entry->iscsiFlags,
342 sts_entry->iscsiResponse));
343 break;
344
345 default:
346 cmd->result = DID_ERROR << 16;
347 break;
348 }
349
350 status_entry_exit:
351
352 /* complete the request, if not waiting for status_continuation pkt */
353 srb->cc_stat = sts_entry->completionStatus;
354 if (ha->status_srb == NULL)
355 kref_put(&srb->srb_ref, qla4xxx_srb_compl);
356 }
357
358 /**
359 * qla4xxx_passthru_status_entry - processes passthru status IOCBs (0x3C)
360 * @ha: Pointer to host adapter structure.
361 * @sts_entry: Pointer to status entry structure.
362 **/
363 static void qla4xxx_passthru_status_entry(struct scsi_qla_host *ha,
364 struct passthru_status *sts_entry)
365 {
366 struct iscsi_task *task;
367 struct ddb_entry *ddb_entry;
368 struct ql4_task_data *task_data;
369 struct iscsi_cls_conn *cls_conn;
370 struct iscsi_conn *conn;
371 itt_t itt;
372 uint32_t fw_ddb_index;
373
374 itt = sts_entry->handle;
375 fw_ddb_index = le32_to_cpu(sts_entry->target);
376
377 ddb_entry = qla4xxx_lookup_ddb_by_fw_index(ha, fw_ddb_index);
378
379 if (ddb_entry == NULL) {
380 ql4_printk(KERN_ERR, ha, "%s: Invalid target index = 0x%x\n",
381 __func__, sts_entry->target);
382 return;
383 }
384
385 cls_conn = ddb_entry->conn;
386 conn = cls_conn->dd_data;
387 spin_lock(&conn->session->back_lock);
388 task = iscsi_itt_to_task(conn, itt);
389 spin_unlock(&conn->session->back_lock);
390
391 if (task == NULL) {
392 ql4_printk(KERN_ERR, ha, "%s: Task is NULL\n", __func__);
393 return;
394 }
395
396 task_data = task->dd_data;
397 memcpy(&task_data->sts, sts_entry, sizeof(struct passthru_status));
398 ha->iocb_cnt -= task_data->iocb_req_cnt;
399 queue_work(ha->task_wq, &task_data->task_work);
400 }
401
402 static struct mrb *qla4xxx_del_mrb_from_active_array(struct scsi_qla_host *ha,
403 uint32_t index)
404 {
405 struct mrb *mrb = NULL;
406
407 /* validate handle and remove from active array */
408 if (index >= MAX_MRB)
409 return mrb;
410
411 mrb = ha->active_mrb_array[index];
412 ha->active_mrb_array[index] = NULL;
413 if (!mrb)
414 return mrb;
415
416 /* update counters */
417 ha->iocb_cnt -= mrb->iocb_cnt;
418
419 return mrb;
420 }
421
422 static void qla4xxx_mbox_status_entry(struct scsi_qla_host *ha,
423 struct mbox_status_iocb *mbox_sts_entry)
424 {
425 struct mrb *mrb;
426 uint32_t status;
427 uint32_t data_size;
428
429 mrb = qla4xxx_del_mrb_from_active_array(ha,
430 le32_to_cpu(mbox_sts_entry->handle));
431
432 if (mrb == NULL) {
433 ql4_printk(KERN_WARNING, ha, "%s: mrb[%d] is null\n", __func__,
434 mbox_sts_entry->handle);
435 return;
436 }
437
438 switch (mrb->mbox_cmd) {
439 case MBOX_CMD_PING:
440 DEBUG2(ql4_printk(KERN_INFO, ha, "%s: mbox_cmd = 0x%x, "
441 "mbox_sts[0] = 0x%x, mbox_sts[6] = 0x%x\n",
442 __func__, mrb->mbox_cmd,
443 mbox_sts_entry->out_mbox[0],
444 mbox_sts_entry->out_mbox[6]));
445
446 if (mbox_sts_entry->out_mbox[0] == MBOX_STS_COMMAND_COMPLETE)
447 status = ISCSI_PING_SUCCESS;
448 else
449 status = mbox_sts_entry->out_mbox[6];
450
451 data_size = sizeof(mbox_sts_entry->out_mbox);
452
453 qla4xxx_post_ping_evt_work(ha, status, mrb->pid, data_size,
454 (uint8_t *) mbox_sts_entry->out_mbox);
455 break;
456
457 default:
458 DEBUG2(ql4_printk(KERN_WARNING, ha, "%s: invalid mbox_cmd = "
459 "0x%x\n", __func__, mrb->mbox_cmd));
460 }
461
462 kfree(mrb);
463 return;
464 }
465
466 /**
467 * qla4xxx_process_response_queue - process response queue completions
468 * @ha: Pointer to host adapter structure.
469 *
470 * This routine process response queue completions in interrupt context.
471 * Hardware_lock locked upon entry
472 **/
473 void qla4xxx_process_response_queue(struct scsi_qla_host *ha)
474 {
475 uint32_t count = 0;
476 struct srb *srb = NULL;
477 struct status_entry *sts_entry;
478
479 /* Process all responses from response queue */
480 while ((ha->response_ptr->signature != RESPONSE_PROCESSED)) {
481 sts_entry = (struct status_entry *) ha->response_ptr;
482 count++;
483
484 /* Advance pointers for next entry */
485 if (ha->response_out == (RESPONSE_QUEUE_DEPTH - 1)) {
486 ha->response_out = 0;
487 ha->response_ptr = ha->response_ring;
488 } else {
489 ha->response_out++;
490 ha->response_ptr++;
491 }
492
493 /* process entry */
494 switch (sts_entry->hdr.entryType) {
495 case ET_STATUS:
496 /* Common status */
497 qla4xxx_status_entry(ha, sts_entry);
498 break;
499
500 case ET_PASSTHRU_STATUS:
501 if (sts_entry->hdr.systemDefined == SD_ISCSI_PDU)
502 qla4xxx_passthru_status_entry(ha,
503 (struct passthru_status *)sts_entry);
504 else
505 ql4_printk(KERN_ERR, ha,
506 "%s: Invalid status received\n",
507 __func__);
508
509 break;
510
511 case ET_STATUS_CONTINUATION:
512 qla4xxx_status_cont_entry(ha,
513 (struct status_cont_entry *) sts_entry);
514 break;
515
516 case ET_COMMAND:
517 /* ISP device queue is full. Command not
518 * accepted by ISP. Queue command for
519 * later */
520
521 srb = qla4xxx_del_from_active_array(ha,
522 le32_to_cpu(sts_entry->
523 handle));
524 if (srb == NULL)
525 goto exit_prq_invalid_handle;
526
527 DEBUG2(printk("scsi%ld: %s: FW device queue full, "
528 "srb %p\n", ha->host_no, __func__, srb));
529
530 /* ETRY normally by sending it back with
531 * DID_BUS_BUSY */
532 srb->cmd->result = DID_BUS_BUSY << 16;
533 kref_put(&srb->srb_ref, qla4xxx_srb_compl);
534 break;
535
536 case ET_CONTINUE:
537 /* Just throw away the continuation entries */
538 DEBUG2(printk("scsi%ld: %s: Continuation entry - "
539 "ignoring\n", ha->host_no, __func__));
540 break;
541
542 case ET_MBOX_STATUS:
543 DEBUG2(ql4_printk(KERN_INFO, ha,
544 "%s: mbox status IOCB\n", __func__));
545 qla4xxx_mbox_status_entry(ha,
546 (struct mbox_status_iocb *)sts_entry);
547 break;
548
549 default:
550 /*
551 * Invalid entry in response queue, reset RISC
552 * firmware.
553 */
554 DEBUG2(printk("scsi%ld: %s: Invalid entry %x in "
555 "response queue \n", ha->host_no,
556 __func__,
557 sts_entry->hdr.entryType));
558 goto exit_prq_error;
559 }
560 ((struct response *)sts_entry)->signature = RESPONSE_PROCESSED;
561 wmb();
562 }
563
564 /*
565 * Tell ISP we're done with response(s). This also clears the interrupt.
566 */
567 ha->isp_ops->complete_iocb(ha);
568
569 return;
570
571 exit_prq_invalid_handle:
572 DEBUG2(printk("scsi%ld: %s: Invalid handle(srb)=%p type=%x IOCS=%x\n",
573 ha->host_no, __func__, srb, sts_entry->hdr.entryType,
574 sts_entry->completionStatus));
575
576 exit_prq_error:
577 ha->isp_ops->complete_iocb(ha);
578 set_bit(DPC_RESET_HA, &ha->dpc_flags);
579 }
580
581 /**
582 * qla4_83xx_loopback_in_progress: Is loopback in progress?
583 * @ha: Pointer to host adapter structure.
584 * returns: 1 = loopback in progress, 0 = loopback not in progress
585 **/
586 static int qla4_83xx_loopback_in_progress(struct scsi_qla_host *ha)
587 {
588 int rval = 1;
589
590 if (is_qla8032(ha) || is_qla8042(ha)) {
591 if ((ha->idc_info.info2 & ENABLE_INTERNAL_LOOPBACK) ||
592 (ha->idc_info.info2 & ENABLE_EXTERNAL_LOOPBACK)) {
593 DEBUG2(ql4_printk(KERN_INFO, ha,
594 "%s: Loopback diagnostics in progress\n",
595 __func__));
596 rval = 1;
597 } else {
598 DEBUG2(ql4_printk(KERN_INFO, ha,
599 "%s: Loopback diagnostics not in progress\n",
600 __func__));
601 rval = 0;
602 }
603 }
604
605 return rval;
606 }
607
608 static void qla4xxx_update_ipaddr_state(struct scsi_qla_host *ha,
609 uint32_t ipaddr_idx,
610 uint32_t ipaddr_fw_state)
611 {
612 uint8_t ipaddr_state;
613 uint8_t ip_idx;
614
615 ip_idx = ipaddr_idx & 0xF;
616 ipaddr_state = qla4xxx_set_ipaddr_state((uint8_t)ipaddr_fw_state);
617
618 switch (ip_idx) {
619 case 0:
620 ha->ip_config.ipv4_addr_state = ipaddr_state;
621 break;
622 case 1:
623 ha->ip_config.ipv6_link_local_state = ipaddr_state;
624 break;
625 case 2:
626 ha->ip_config.ipv6_addr0_state = ipaddr_state;
627 break;
628 case 3:
629 ha->ip_config.ipv6_addr1_state = ipaddr_state;
630 break;
631 default:
632 ql4_printk(KERN_INFO, ha, "%s: Invalid IPADDR index %d\n",
633 __func__, ip_idx);
634 }
635 }
636
637 static void qla4xxx_default_router_changed(struct scsi_qla_host *ha,
638 uint32_t *mbox_sts)
639 {
640 memcpy(&ha->ip_config.ipv6_default_router_addr.s6_addr32[0],
641 &mbox_sts[2], sizeof(uint32_t));
642 memcpy(&ha->ip_config.ipv6_default_router_addr.s6_addr32[1],
643 &mbox_sts[3], sizeof(uint32_t));
644 memcpy(&ha->ip_config.ipv6_default_router_addr.s6_addr32[2],
645 &mbox_sts[4], sizeof(uint32_t));
646 memcpy(&ha->ip_config.ipv6_default_router_addr.s6_addr32[3],
647 &mbox_sts[5], sizeof(uint32_t));
648 }
649
650 /**
651 * qla4xxx_isr_decode_mailbox - decodes mailbox status
652 * @ha: Pointer to host adapter structure.
653 * @mbox_status: Mailbox status.
654 *
655 * This routine decodes the mailbox status during the ISR.
656 * Hardware_lock locked upon entry. runs in interrupt context.
657 **/
658 static void qla4xxx_isr_decode_mailbox(struct scsi_qla_host * ha,
659 uint32_t mbox_status)
660 {
661 int i;
662 uint32_t mbox_sts[MBOX_AEN_REG_COUNT];
663 __le32 __iomem *mailbox_out;
664 uint32_t opcode = 0;
665
666 if (is_qla8032(ha) || is_qla8042(ha))
667 mailbox_out = &ha->qla4_83xx_reg->mailbox_out[0];
668 else if (is_qla8022(ha))
669 mailbox_out = &ha->qla4_82xx_reg->mailbox_out[0];
670 else
671 mailbox_out = &ha->reg->mailbox[0];
672
673 if ((mbox_status == MBOX_STS_BUSY) ||
674 (mbox_status == MBOX_STS_INTERMEDIATE_COMPLETION) ||
675 (mbox_status >> 12 == MBOX_COMPLETION_STATUS)) {
676 ha->mbox_status[0] = mbox_status;
677
678 if (test_bit(AF_MBOX_COMMAND, &ha->flags)) {
679 /*
680 * Copy all mailbox registers to a temporary
681 * location and set mailbox command done flag
682 */
683 for (i = 0; i < ha->mbox_status_count; i++)
684 ha->mbox_status[i] = readl(&mailbox_out[i]);
685
686 set_bit(AF_MBOX_COMMAND_DONE, &ha->flags);
687
688 if (test_bit(AF_MBOX_COMMAND_NOPOLL, &ha->flags))
689 complete(&ha->mbx_intr_comp);
690 }
691 } else if (mbox_status >> 12 == MBOX_ASYNC_EVENT_STATUS) {
692 for (i = 0; i < MBOX_AEN_REG_COUNT; i++)
693 mbox_sts[i] = readl(&mailbox_out[i]);
694
695 /* Immediately process the AENs that don't require much work.
696 * Only queue the database_changed AENs */
697 if (ha->aen_log.count < MAX_AEN_ENTRIES) {
698 for (i = 0; i < MBOX_AEN_REG_COUNT; i++)
699 ha->aen_log.entry[ha->aen_log.count].mbox_sts[i] =
700 mbox_sts[i];
701 ha->aen_log.count++;
702 }
703 switch (mbox_status) {
704 case MBOX_ASTS_SYSTEM_ERROR:
705 /* Log Mailbox registers */
706 ql4_printk(KERN_INFO, ha, "%s: System Err\n", __func__);
707 qla4xxx_dump_registers(ha);
708
709 if ((is_qla8022(ha) && ql4xdontresethba) ||
710 ((is_qla8032(ha) || is_qla8042(ha)) &&
711 qla4_83xx_idc_dontreset(ha))) {
712 DEBUG2(printk("scsi%ld: %s:Don't Reset HBA\n",
713 ha->host_no, __func__));
714 } else {
715 set_bit(AF_GET_CRASH_RECORD, &ha->flags);
716 set_bit(DPC_RESET_HA, &ha->dpc_flags);
717 }
718 break;
719
720 case MBOX_ASTS_REQUEST_TRANSFER_ERROR:
721 case MBOX_ASTS_RESPONSE_TRANSFER_ERROR:
722 case MBOX_ASTS_NVRAM_INVALID:
723 case MBOX_ASTS_IP_ADDRESS_CHANGED:
724 case MBOX_ASTS_DHCP_LEASE_EXPIRED:
725 DEBUG2(printk("scsi%ld: AEN %04x, ERROR Status, "
726 "Reset HA\n", ha->host_no, mbox_status));
727 if (is_qla80XX(ha))
728 set_bit(DPC_RESET_HA_FW_CONTEXT,
729 &ha->dpc_flags);
730 else
731 set_bit(DPC_RESET_HA, &ha->dpc_flags);
732 break;
733
734 case MBOX_ASTS_LINK_UP:
735 set_bit(AF_LINK_UP, &ha->flags);
736 if (test_bit(AF_INIT_DONE, &ha->flags))
737 set_bit(DPC_LINK_CHANGED, &ha->dpc_flags);
738
739 ql4_printk(KERN_INFO, ha, "%s: LINK UP\n", __func__);
740 qla4xxx_post_aen_work(ha, ISCSI_EVENT_LINKUP,
741 sizeof(mbox_sts),
742 (uint8_t *) mbox_sts);
743
744 if ((is_qla8032(ha) || is_qla8042(ha)) &&
745 ha->notify_link_up_comp)
746 complete(&ha->link_up_comp);
747
748 break;
749
750 case MBOX_ASTS_LINK_DOWN:
751 clear_bit(AF_LINK_UP, &ha->flags);
752 if (test_bit(AF_INIT_DONE, &ha->flags)) {
753 set_bit(DPC_LINK_CHANGED, &ha->dpc_flags);
754 qla4xxx_wake_dpc(ha);
755 }
756
757 ql4_printk(KERN_INFO, ha, "%s: LINK DOWN\n", __func__);
758 qla4xxx_post_aen_work(ha, ISCSI_EVENT_LINKDOWN,
759 sizeof(mbox_sts),
760 (uint8_t *) mbox_sts);
761 break;
762
763 case MBOX_ASTS_HEARTBEAT:
764 ha->seconds_since_last_heartbeat = 0;
765 break;
766
767 case MBOX_ASTS_DHCP_LEASE_ACQUIRED:
768 DEBUG2(printk("scsi%ld: AEN %04x DHCP LEASE "
769 "ACQUIRED\n", ha->host_no, mbox_status));
770 set_bit(DPC_GET_DHCP_IP_ADDR, &ha->dpc_flags);
771 break;
772
773 case MBOX_ASTS_PROTOCOL_STATISTIC_ALARM:
774 case MBOX_ASTS_SCSI_COMMAND_PDU_REJECTED: /* Target
775 * mode
776 * only */
777 case MBOX_ASTS_UNSOLICITED_PDU_RECEIVED: /* Connection mode */
778 case MBOX_ASTS_IPSEC_SYSTEM_FATAL_ERROR:
779 case MBOX_ASTS_SUBNET_STATE_CHANGE:
780 case MBOX_ASTS_DUPLICATE_IP:
781 /* No action */
782 DEBUG2(printk("scsi%ld: AEN %04x\n", ha->host_no,
783 mbox_status));
784 break;
785
786 case MBOX_ASTS_IP_ADDR_STATE_CHANGED:
787 printk("scsi%ld: AEN %04x, mbox_sts[2]=%04x, "
788 "mbox_sts[3]=%04x\n", ha->host_no, mbox_sts[0],
789 mbox_sts[2], mbox_sts[3]);
790
791 qla4xxx_update_ipaddr_state(ha, mbox_sts[5],
792 mbox_sts[3]);
793 /* mbox_sts[2] = Old ACB state
794 * mbox_sts[3] = new ACB state */
795 if ((mbox_sts[3] == IP_ADDRSTATE_PREFERRED) &&
796 ((mbox_sts[2] == IP_ADDRSTATE_TENTATIVE) ||
797 (mbox_sts[2] == IP_ADDRSTATE_ACQUIRING))) {
798 set_bit(DPC_GET_DHCP_IP_ADDR, &ha->dpc_flags);
799 } else if ((mbox_sts[3] == IP_ADDRSTATE_ACQUIRING) &&
800 (mbox_sts[2] == IP_ADDRSTATE_PREFERRED)) {
801 if (is_qla80XX(ha))
802 set_bit(DPC_RESET_HA_FW_CONTEXT,
803 &ha->dpc_flags);
804 else
805 set_bit(DPC_RESET_HA, &ha->dpc_flags);
806 } else if (mbox_sts[3] == IP_ADDRSTATE_DISABLING) {
807 ql4_printk(KERN_INFO, ha, "scsi%ld: %s: ACB in disabling state\n",
808 ha->host_no, __func__);
809 } else if (mbox_sts[3] == IP_ADDRSTATE_UNCONFIGURED) {
810 complete(&ha->disable_acb_comp);
811 ql4_printk(KERN_INFO, ha, "scsi%ld: %s: ACB state unconfigured\n",
812 ha->host_no, __func__);
813 }
814 break;
815
816 case MBOX_ASTS_IPV6_LINK_MTU_CHANGE:
817 case MBOX_ASTS_IPV6_AUTO_PREFIX_IGNORED:
818 case MBOX_ASTS_IPV6_ND_LOCAL_PREFIX_IGNORED:
819 /* No action */
820 DEBUG2(ql4_printk(KERN_INFO, ha, "scsi%ld: AEN %04x\n",
821 ha->host_no, mbox_status));
822 break;
823
824 case MBOX_ASTS_ICMPV6_ERROR_MSG_RCVD:
825 DEBUG2(ql4_printk(KERN_INFO, ha,
826 "scsi%ld: AEN %04x, IPv6 ERROR, "
827 "mbox_sts[1]=%08x, mbox_sts[2]=%08x, mbox_sts[3}=%08x, mbox_sts[4]=%08x mbox_sts[5]=%08x\n",
828 ha->host_no, mbox_sts[0], mbox_sts[1],
829 mbox_sts[2], mbox_sts[3], mbox_sts[4],
830 mbox_sts[5]));
831 break;
832
833 case MBOX_ASTS_MAC_ADDRESS_CHANGED:
834 case MBOX_ASTS_DNS:
835 /* No action */
836 DEBUG2(printk(KERN_INFO "scsi%ld: AEN %04x, "
837 "mbox_sts[1]=%04x, mbox_sts[2]=%04x\n",
838 ha->host_no, mbox_sts[0],
839 mbox_sts[1], mbox_sts[2]));
840 break;
841
842 case MBOX_ASTS_SELF_TEST_FAILED:
843 case MBOX_ASTS_LOGIN_FAILED:
844 /* No action */
845 DEBUG2(printk("scsi%ld: AEN %04x, mbox_sts[1]=%04x, "
846 "mbox_sts[2]=%04x, mbox_sts[3]=%04x\n",
847 ha->host_no, mbox_sts[0], mbox_sts[1],
848 mbox_sts[2], mbox_sts[3]));
849 break;
850
851 case MBOX_ASTS_DATABASE_CHANGED:
852 /* Queue AEN information and process it in the DPC
853 * routine */
854 if (ha->aen_q_count > 0) {
855
856 /* decrement available counter */
857 ha->aen_q_count--;
858
859 for (i = 0; i < MBOX_AEN_REG_COUNT; i++)
860 ha->aen_q[ha->aen_in].mbox_sts[i] =
861 mbox_sts[i];
862
863 /* print debug message */
864 DEBUG2(printk("scsi%ld: AEN[%d] %04x queued "
865 "mb1:0x%x mb2:0x%x mb3:0x%x "
866 "mb4:0x%x mb5:0x%x\n",
867 ha->host_no, ha->aen_in,
868 mbox_sts[0], mbox_sts[1],
869 mbox_sts[2], mbox_sts[3],
870 mbox_sts[4], mbox_sts[5]));
871
872 /* advance pointer */
873 ha->aen_in++;
874 if (ha->aen_in == MAX_AEN_ENTRIES)
875 ha->aen_in = 0;
876
877 /* The DPC routine will process the aen */
878 set_bit(DPC_AEN, &ha->dpc_flags);
879 } else {
880 DEBUG2(printk("scsi%ld: %s: aen %04x, queue "
881 "overflowed! AEN LOST!!\n",
882 ha->host_no, __func__,
883 mbox_sts[0]));
884
885 DEBUG2(printk("scsi%ld: DUMP AEN QUEUE\n",
886 ha->host_no));
887
888 for (i = 0; i < MAX_AEN_ENTRIES; i++) {
889 DEBUG2(printk("AEN[%d] %04x %04x %04x "
890 "%04x\n", i, mbox_sts[0],
891 mbox_sts[1], mbox_sts[2],
892 mbox_sts[3]));
893 }
894 }
895 break;
896
897 case MBOX_ASTS_TXSCVR_INSERTED:
898 DEBUG2(printk(KERN_WARNING
899 "scsi%ld: AEN %04x Transceiver"
900 " inserted\n", ha->host_no, mbox_sts[0]));
901 break;
902
903 case MBOX_ASTS_TXSCVR_REMOVED:
904 DEBUG2(printk(KERN_WARNING
905 "scsi%ld: AEN %04x Transceiver"
906 " removed\n", ha->host_no, mbox_sts[0]));
907 break;
908
909 case MBOX_ASTS_IDC_REQUEST_NOTIFICATION:
910 if (is_qla8032(ha) || is_qla8042(ha)) {
911 DEBUG2(ql4_printk(KERN_INFO, ha,
912 "scsi%ld: AEN %04x, mbox_sts[1]=%08x, mbox_sts[2]=%08x, mbox_sts[3]=%08x, mbox_sts[4]=%08x\n",
913 ha->host_no, mbox_sts[0],
914 mbox_sts[1], mbox_sts[2],
915 mbox_sts[3], mbox_sts[4]));
916 opcode = mbox_sts[1] >> 16;
917 if ((opcode == MBOX_CMD_SET_PORT_CONFIG) ||
918 (opcode == MBOX_CMD_PORT_RESET)) {
919 set_bit(DPC_POST_IDC_ACK,
920 &ha->dpc_flags);
921 ha->idc_info.request_desc = mbox_sts[1];
922 ha->idc_info.info1 = mbox_sts[2];
923 ha->idc_info.info2 = mbox_sts[3];
924 ha->idc_info.info3 = mbox_sts[4];
925 qla4xxx_wake_dpc(ha);
926 }
927 }
928 break;
929
930 case MBOX_ASTS_IDC_COMPLETE:
931 if (is_qla8032(ha) || is_qla8042(ha)) {
932 DEBUG2(ql4_printk(KERN_INFO, ha,
933 "scsi%ld: AEN %04x, mbox_sts[1]=%08x, mbox_sts[2]=%08x, mbox_sts[3]=%08x, mbox_sts[4]=%08x\n",
934 ha->host_no, mbox_sts[0],
935 mbox_sts[1], mbox_sts[2],
936 mbox_sts[3], mbox_sts[4]));
937 DEBUG2(ql4_printk(KERN_INFO, ha,
938 "scsi:%ld: AEN %04x IDC Complete notification\n",
939 ha->host_no, mbox_sts[0]));
940
941 opcode = mbox_sts[1] >> 16;
942 if (ha->notify_idc_comp)
943 complete(&ha->idc_comp);
944
945 if ((opcode == MBOX_CMD_SET_PORT_CONFIG) ||
946 (opcode == MBOX_CMD_PORT_RESET))
947 ha->idc_info.info2 = mbox_sts[3];
948
949 if (qla4_83xx_loopback_in_progress(ha)) {
950 set_bit(AF_LOOPBACK, &ha->flags);
951 } else {
952 clear_bit(AF_LOOPBACK, &ha->flags);
953 if (ha->saved_acb)
954 set_bit(DPC_RESTORE_ACB,
955 &ha->dpc_flags);
956 }
957 qla4xxx_wake_dpc(ha);
958 }
959 break;
960
961 case MBOX_ASTS_IPV6_DEFAULT_ROUTER_CHANGED:
962 DEBUG2(ql4_printk(KERN_INFO, ha,
963 "scsi%ld: AEN %04x, mbox_sts[1]=%08x, mbox_sts[2]=%08x, mbox_sts[3]=%08x, mbox_sts[4]=%08x mbox_sts[5]=%08x\n",
964 ha->host_no, mbox_sts[0], mbox_sts[1],
965 mbox_sts[2], mbox_sts[3], mbox_sts[4],
966 mbox_sts[5]));
967 DEBUG2(ql4_printk(KERN_INFO, ha,
968 "scsi%ld: AEN %04x Received IPv6 default router changed notification\n",
969 ha->host_no, mbox_sts[0]));
970 qla4xxx_default_router_changed(ha, mbox_sts);
971 break;
972
973 case MBOX_ASTS_IDC_TIME_EXTEND_NOTIFICATION:
974 DEBUG2(ql4_printk(KERN_INFO, ha,
975 "scsi%ld: AEN %04x, mbox_sts[1]=%08x, mbox_sts[2]=%08x, mbox_sts[3]=%08x, mbox_sts[4]=%08x mbox_sts[5]=%08x\n",
976 ha->host_no, mbox_sts[0], mbox_sts[1],
977 mbox_sts[2], mbox_sts[3], mbox_sts[4],
978 mbox_sts[5]));
979 DEBUG2(ql4_printk(KERN_INFO, ha,
980 "scsi%ld: AEN %04x Received IDC Extend Timeout notification\n",
981 ha->host_no, mbox_sts[0]));
982 /* new IDC timeout */
983 ha->idc_extend_tmo = mbox_sts[1];
984 break;
985
986 case MBOX_ASTS_INITIALIZATION_FAILED:
987 DEBUG2(ql4_printk(KERN_INFO, ha,
988 "scsi%ld: AEN %04x, mbox_sts[3]=%08x\n",
989 ha->host_no, mbox_sts[0],
990 mbox_sts[3]));
991 break;
992
993 case MBOX_ASTS_SYSTEM_WARNING_EVENT:
994 DEBUG2(ql4_printk(KERN_WARNING, ha,
995 "scsi%ld: AEN %04x, mbox_sts[1]=%08x, mbox_sts[2]=%08x, mbox_sts[3]=%08x, mbox_sts[4]=%08x mbox_sts[5]=%08x\n",
996 ha->host_no, mbox_sts[0], mbox_sts[1],
997 mbox_sts[2], mbox_sts[3], mbox_sts[4],
998 mbox_sts[5]));
999 break;
1000
1001 case MBOX_ASTS_DCBX_CONF_CHANGE:
1002 DEBUG2(ql4_printk(KERN_INFO, ha,
1003 "scsi%ld: AEN %04x, mbox_sts[1]=%08x, mbox_sts[2]=%08x, mbox_sts[3]=%08x, mbox_sts[4]=%08x mbox_sts[5]=%08x\n",
1004 ha->host_no, mbox_sts[0], mbox_sts[1],
1005 mbox_sts[2], mbox_sts[3], mbox_sts[4],
1006 mbox_sts[5]));
1007 DEBUG2(ql4_printk(KERN_INFO, ha,
1008 "scsi%ld: AEN %04x Received DCBX configuration changed notification\n",
1009 ha->host_no, mbox_sts[0]));
1010 break;
1011
1012 default:
1013 DEBUG2(printk(KERN_WARNING
1014 "scsi%ld: AEN %04x UNKNOWN\n",
1015 ha->host_no, mbox_sts[0]));
1016 break;
1017 }
1018 } else {
1019 DEBUG2(printk("scsi%ld: Unknown mailbox status %08X\n",
1020 ha->host_no, mbox_status));
1021
1022 ha->mbox_status[0] = mbox_status;
1023 }
1024 }
1025
1026 void qla4_83xx_interrupt_service_routine(struct scsi_qla_host *ha,
1027 uint32_t intr_status)
1028 {
1029 /* Process mailbox/asynch event interrupt.*/
1030 if (intr_status) {
1031 qla4xxx_isr_decode_mailbox(ha,
1032 readl(&ha->qla4_83xx_reg->mailbox_out[0]));
1033 /* clear the interrupt */
1034 writel(0, &ha->qla4_83xx_reg->risc_intr);
1035 } else {
1036 qla4xxx_process_response_queue(ha);
1037 }
1038
1039 /* clear the interrupt */
1040 writel(0, &ha->qla4_83xx_reg->mb_int_mask);
1041 }
1042
1043 /**
1044 * qla4_82xx_interrupt_service_routine - isr
1045 * @ha: pointer to host adapter structure.
1046 * @intr_status: Local interrupt status/type.
1047 *
1048 * This is the main interrupt service routine.
1049 * hardware_lock locked upon entry. runs in interrupt context.
1050 **/
1051 void qla4_82xx_interrupt_service_routine(struct scsi_qla_host *ha,
1052 uint32_t intr_status)
1053 {
1054 /* Process response queue interrupt. */
1055 if ((intr_status & HSRX_RISC_IOCB_INT) &&
1056 test_bit(AF_INIT_DONE, &ha->flags))
1057 qla4xxx_process_response_queue(ha);
1058
1059 /* Process mailbox/asynch event interrupt.*/
1060 if (intr_status & HSRX_RISC_MB_INT)
1061 qla4xxx_isr_decode_mailbox(ha,
1062 readl(&ha->qla4_82xx_reg->mailbox_out[0]));
1063
1064 /* clear the interrupt */
1065 writel(0, &ha->qla4_82xx_reg->host_int);
1066 readl(&ha->qla4_82xx_reg->host_int);
1067 }
1068
1069 /**
1070 * qla4xxx_interrupt_service_routine - isr
1071 * @ha: pointer to host adapter structure.
1072 * @intr_status: Local interrupt status/type.
1073 *
1074 * This is the main interrupt service routine.
1075 * hardware_lock locked upon entry. runs in interrupt context.
1076 **/
1077 void qla4xxx_interrupt_service_routine(struct scsi_qla_host * ha,
1078 uint32_t intr_status)
1079 {
1080 /* Process response queue interrupt. */
1081 if (intr_status & CSR_SCSI_COMPLETION_INTR)
1082 qla4xxx_process_response_queue(ha);
1083
1084 /* Process mailbox/asynch event interrupt.*/
1085 if (intr_status & CSR_SCSI_PROCESSOR_INTR) {
1086 qla4xxx_isr_decode_mailbox(ha,
1087 readl(&ha->reg->mailbox[0]));
1088
1089 /* Clear Mailbox Interrupt */
1090 writel(set_rmask(CSR_SCSI_PROCESSOR_INTR),
1091 &ha->reg->ctrl_status);
1092 readl(&ha->reg->ctrl_status);
1093 }
1094 }
1095
1096 /**
1097 * qla4_82xx_spurious_interrupt - processes spurious interrupt
1098 * @ha: pointer to host adapter structure.
1099 * @reqs_count: .
1100 *
1101 **/
1102 static void qla4_82xx_spurious_interrupt(struct scsi_qla_host *ha,
1103 uint8_t reqs_count)
1104 {
1105 if (reqs_count)
1106 return;
1107
1108 DEBUG2(ql4_printk(KERN_INFO, ha, "Spurious Interrupt\n"));
1109 if (is_qla8022(ha)) {
1110 writel(0, &ha->qla4_82xx_reg->host_int);
1111 if (!ha->pdev->msi_enabled && !ha->pdev->msix_enabled)
1112 qla4_82xx_wr_32(ha, ha->nx_legacy_intr.tgt_mask_reg,
1113 0xfbff);
1114 }
1115 ha->spurious_int_count++;
1116 }
1117
1118 /**
1119 * qla4xxx_intr_handler - hardware interrupt handler.
1120 * @irq: Unused
1121 * @dev_id: Pointer to host adapter structure
1122 **/
1123 irqreturn_t qla4xxx_intr_handler(int irq, void *dev_id)
1124 {
1125 struct scsi_qla_host *ha;
1126 uint32_t intr_status;
1127 unsigned long flags = 0;
1128 uint8_t reqs_count = 0;
1129
1130 ha = (struct scsi_qla_host *) dev_id;
1131 if (!ha) {
1132 DEBUG2(printk(KERN_INFO
1133 "qla4xxx: Interrupt with NULL host ptr\n"));
1134 return IRQ_NONE;
1135 }
1136
1137 spin_lock_irqsave(&ha->hardware_lock, flags);
1138
1139 ha->isr_count++;
1140 /*
1141 * Repeatedly service interrupts up to a maximum of
1142 * MAX_REQS_SERVICED_PER_INTR
1143 */
1144 while (1) {
1145 /*
1146 * Read interrupt status
1147 */
1148 if (ha->isp_ops->rd_shdw_rsp_q_in(ha) !=
1149 ha->response_out)
1150 intr_status = CSR_SCSI_COMPLETION_INTR;
1151 else
1152 intr_status = readl(&ha->reg->ctrl_status);
1153
1154 if ((intr_status &
1155 (CSR_SCSI_RESET_INTR|CSR_FATAL_ERROR|INTR_PENDING)) == 0) {
1156 if (reqs_count == 0)
1157 ha->spurious_int_count++;
1158 break;
1159 }
1160
1161 if (intr_status & CSR_FATAL_ERROR) {
1162 DEBUG2(printk(KERN_INFO "scsi%ld: Fatal Error, "
1163 "Status 0x%04x\n", ha->host_no,
1164 readl(isp_port_error_status (ha))));
1165
1166 /* Issue Soft Reset to clear this error condition.
1167 * This will prevent the RISC from repeatedly
1168 * interrupting the driver; thus, allowing the DPC to
1169 * get scheduled to continue error recovery.
1170 * NOTE: Disabling RISC interrupts does not work in
1171 * this case, as CSR_FATAL_ERROR overrides
1172 * CSR_SCSI_INTR_ENABLE */
1173 if ((readl(&ha->reg->ctrl_status) &
1174 CSR_SCSI_RESET_INTR) == 0) {
1175 writel(set_rmask(CSR_SOFT_RESET),
1176 &ha->reg->ctrl_status);
1177 readl(&ha->reg->ctrl_status);
1178 }
1179
1180 writel(set_rmask(CSR_FATAL_ERROR),
1181 &ha->reg->ctrl_status);
1182 readl(&ha->reg->ctrl_status);
1183
1184 __qla4xxx_disable_intrs(ha);
1185
1186 set_bit(DPC_RESET_HA, &ha->dpc_flags);
1187
1188 break;
1189 } else if (intr_status & CSR_SCSI_RESET_INTR) {
1190 clear_bit(AF_ONLINE, &ha->flags);
1191 __qla4xxx_disable_intrs(ha);
1192
1193 writel(set_rmask(CSR_SCSI_RESET_INTR),
1194 &ha->reg->ctrl_status);
1195 readl(&ha->reg->ctrl_status);
1196
1197 if (!test_bit(AF_HA_REMOVAL, &ha->flags))
1198 set_bit(DPC_RESET_HA_INTR, &ha->dpc_flags);
1199
1200 break;
1201 } else if (intr_status & INTR_PENDING) {
1202 ha->isp_ops->interrupt_service_routine(ha, intr_status);
1203 ha->total_io_count++;
1204 if (++reqs_count == MAX_REQS_SERVICED_PER_INTR)
1205 break;
1206 }
1207 }
1208
1209 spin_unlock_irqrestore(&ha->hardware_lock, flags);
1210
1211 return IRQ_HANDLED;
1212 }
1213
1214 /**
1215 * qla4_82xx_intr_handler - hardware interrupt handler.
1216 * @irq: Unused
1217 * @dev_id: Pointer to host adapter structure
1218 **/
1219 irqreturn_t qla4_82xx_intr_handler(int irq, void *dev_id)
1220 {
1221 struct scsi_qla_host *ha = dev_id;
1222 uint32_t intr_status;
1223 uint32_t status;
1224 unsigned long flags = 0;
1225 uint8_t reqs_count = 0;
1226
1227 if (unlikely(pci_channel_offline(ha->pdev)))
1228 return IRQ_HANDLED;
1229
1230 ha->isr_count++;
1231 status = qla4_82xx_rd_32(ha, ISR_INT_VECTOR);
1232 if (!(status & ha->nx_legacy_intr.int_vec_bit))
1233 return IRQ_NONE;
1234
1235 status = qla4_82xx_rd_32(ha, ISR_INT_STATE_REG);
1236 if (!ISR_IS_LEGACY_INTR_TRIGGERED(status)) {
1237 DEBUG7(ql4_printk(KERN_INFO, ha,
1238 "%s legacy Int not triggered\n", __func__));
1239 return IRQ_NONE;
1240 }
1241
1242 /* clear the interrupt */
1243 qla4_82xx_wr_32(ha, ha->nx_legacy_intr.tgt_status_reg, 0xffffffff);
1244
1245 /* read twice to ensure write is flushed */
1246 qla4_82xx_rd_32(ha, ISR_INT_VECTOR);
1247 qla4_82xx_rd_32(ha, ISR_INT_VECTOR);
1248
1249 spin_lock_irqsave(&ha->hardware_lock, flags);
1250 while (1) {
1251 if (!(readl(&ha->qla4_82xx_reg->host_int) &
1252 ISRX_82XX_RISC_INT)) {
1253 qla4_82xx_spurious_interrupt(ha, reqs_count);
1254 break;
1255 }
1256 intr_status = readl(&ha->qla4_82xx_reg->host_status);
1257 if ((intr_status &
1258 (HSRX_RISC_MB_INT | HSRX_RISC_IOCB_INT)) == 0) {
1259 qla4_82xx_spurious_interrupt(ha, reqs_count);
1260 break;
1261 }
1262
1263 ha->isp_ops->interrupt_service_routine(ha, intr_status);
1264
1265 /* Enable Interrupt */
1266 qla4_82xx_wr_32(ha, ha->nx_legacy_intr.tgt_mask_reg, 0xfbff);
1267
1268 if (++reqs_count == MAX_REQS_SERVICED_PER_INTR)
1269 break;
1270 }
1271
1272 spin_unlock_irqrestore(&ha->hardware_lock, flags);
1273 return IRQ_HANDLED;
1274 }
1275
1276 #define LEG_INT_PTR_B31 (1 << 31)
1277 #define LEG_INT_PTR_B30 (1 << 30)
1278 #define PF_BITS_MASK (0xF << 16)
1279
1280 /**
1281 * qla4_83xx_intr_handler - hardware interrupt handler.
1282 * @irq: Unused
1283 * @dev_id: Pointer to host adapter structure
1284 **/
1285 irqreturn_t qla4_83xx_intr_handler(int irq, void *dev_id)
1286 {
1287 struct scsi_qla_host *ha = dev_id;
1288 uint32_t leg_int_ptr = 0;
1289 unsigned long flags = 0;
1290
1291 ha->isr_count++;
1292 leg_int_ptr = readl(&ha->qla4_83xx_reg->leg_int_ptr);
1293
1294 /* Legacy interrupt is valid if bit31 of leg_int_ptr is set */
1295 if (!(leg_int_ptr & LEG_INT_PTR_B31)) {
1296 DEBUG7(ql4_printk(KERN_ERR, ha,
1297 "%s: Legacy Interrupt Bit 31 not set, spurious interrupt!\n",
1298 __func__));
1299 return IRQ_NONE;
1300 }
1301
1302 /* Validate the PCIE function ID set in leg_int_ptr bits [19..16] */
1303 if ((leg_int_ptr & PF_BITS_MASK) != ha->pf_bit) {
1304 DEBUG7(ql4_printk(KERN_ERR, ha,
1305 "%s: Incorrect function ID 0x%x in legacy interrupt register, ha->pf_bit = 0x%x\n",
1306 __func__, (leg_int_ptr & PF_BITS_MASK),
1307 ha->pf_bit));
1308 return IRQ_NONE;
1309 }
1310
1311 /* To de-assert legacy interrupt, write 0 to Legacy Interrupt Trigger
1312 * Control register and poll till Legacy Interrupt Pointer register
1313 * bit30 is 0.
1314 */
1315 writel(0, &ha->qla4_83xx_reg->leg_int_trig);
1316 do {
1317 leg_int_ptr = readl(&ha->qla4_83xx_reg->leg_int_ptr);
1318 if ((leg_int_ptr & PF_BITS_MASK) != ha->pf_bit)
1319 break;
1320 } while (leg_int_ptr & LEG_INT_PTR_B30);
1321
1322 spin_lock_irqsave(&ha->hardware_lock, flags);
1323 leg_int_ptr = readl(&ha->qla4_83xx_reg->risc_intr);
1324 ha->isp_ops->interrupt_service_routine(ha, leg_int_ptr);
1325 spin_unlock_irqrestore(&ha->hardware_lock, flags);
1326
1327 return IRQ_HANDLED;
1328 }
1329
1330 irqreturn_t
1331 qla4_8xxx_msi_handler(int irq, void *dev_id)
1332 {
1333 struct scsi_qla_host *ha;
1334
1335 ha = (struct scsi_qla_host *) dev_id;
1336 if (!ha) {
1337 DEBUG2(printk(KERN_INFO
1338 "qla4xxx: MSIX: Interrupt with NULL host ptr\n"));
1339 return IRQ_NONE;
1340 }
1341
1342 ha->isr_count++;
1343 /* clear the interrupt */
1344 qla4_82xx_wr_32(ha, ha->nx_legacy_intr.tgt_status_reg, 0xffffffff);
1345
1346 /* read twice to ensure write is flushed */
1347 qla4_82xx_rd_32(ha, ISR_INT_VECTOR);
1348 qla4_82xx_rd_32(ha, ISR_INT_VECTOR);
1349
1350 return qla4_8xxx_default_intr_handler(irq, dev_id);
1351 }
1352
1353 static irqreturn_t qla4_83xx_mailbox_intr_handler(int irq, void *dev_id)
1354 {
1355 struct scsi_qla_host *ha = dev_id;
1356 unsigned long flags;
1357 uint32_t ival = 0;
1358
1359 spin_lock_irqsave(&ha->hardware_lock, flags);
1360
1361 ival = readl(&ha->qla4_83xx_reg->risc_intr);
1362 if (ival == 0) {
1363 ql4_printk(KERN_INFO, ha,
1364 "%s: It is a spurious mailbox interrupt!\n",
1365 __func__);
1366 ival = readl(&ha->qla4_83xx_reg->mb_int_mask);
1367 ival &= ~INT_MASK_FW_MB;
1368 writel(ival, &ha->qla4_83xx_reg->mb_int_mask);
1369 goto exit;
1370 }
1371
1372 qla4xxx_isr_decode_mailbox(ha,
1373 readl(&ha->qla4_83xx_reg->mailbox_out[0]));
1374 writel(0, &ha->qla4_83xx_reg->risc_intr);
1375 ival = readl(&ha->qla4_83xx_reg->mb_int_mask);
1376 ival &= ~INT_MASK_FW_MB;
1377 writel(ival, &ha->qla4_83xx_reg->mb_int_mask);
1378 ha->isr_count++;
1379 exit:
1380 spin_unlock_irqrestore(&ha->hardware_lock, flags);
1381 return IRQ_HANDLED;
1382 }
1383
1384 /**
1385 * qla4_8xxx_default_intr_handler - hardware interrupt handler.
1386 * @irq: Unused
1387 * @dev_id: Pointer to host adapter structure
1388 *
1389 * This interrupt handler is called directly for MSI-X, and
1390 * called indirectly for MSI.
1391 **/
1392 irqreturn_t
1393 qla4_8xxx_default_intr_handler(int irq, void *dev_id)
1394 {
1395 struct scsi_qla_host *ha = dev_id;
1396 unsigned long flags;
1397 uint32_t intr_status;
1398 uint8_t reqs_count = 0;
1399
1400 if (is_qla8032(ha) || is_qla8042(ha)) {
1401 qla4_83xx_mailbox_intr_handler(irq, dev_id);
1402 } else {
1403 spin_lock_irqsave(&ha->hardware_lock, flags);
1404 while (1) {
1405 if (!(readl(&ha->qla4_82xx_reg->host_int) &
1406 ISRX_82XX_RISC_INT)) {
1407 qla4_82xx_spurious_interrupt(ha, reqs_count);
1408 break;
1409 }
1410
1411 intr_status = readl(&ha->qla4_82xx_reg->host_status);
1412 if ((intr_status &
1413 (HSRX_RISC_MB_INT | HSRX_RISC_IOCB_INT)) == 0) {
1414 qla4_82xx_spurious_interrupt(ha, reqs_count);
1415 break;
1416 }
1417
1418 ha->isp_ops->interrupt_service_routine(ha, intr_status);
1419
1420 if (++reqs_count == MAX_REQS_SERVICED_PER_INTR)
1421 break;
1422 }
1423 ha->isr_count++;
1424 spin_unlock_irqrestore(&ha->hardware_lock, flags);
1425 }
1426 return IRQ_HANDLED;
1427 }
1428
1429 irqreturn_t
1430 qla4_8xxx_msix_rsp_q(int irq, void *dev_id)
1431 {
1432 struct scsi_qla_host *ha = dev_id;
1433 unsigned long flags;
1434 int intr_status;
1435 uint32_t ival = 0;
1436
1437 spin_lock_irqsave(&ha->hardware_lock, flags);
1438 if (is_qla8032(ha) || is_qla8042(ha)) {
1439 ival = readl(&ha->qla4_83xx_reg->iocb_int_mask);
1440 if (ival == 0) {
1441 ql4_printk(KERN_INFO, ha, "%s: It is a spurious iocb interrupt!\n",
1442 __func__);
1443 goto exit_msix_rsp_q;
1444 }
1445 qla4xxx_process_response_queue(ha);
1446 writel(0, &ha->qla4_83xx_reg->iocb_int_mask);
1447 } else {
1448 intr_status = readl(&ha->qla4_82xx_reg->host_status);
1449 if (intr_status & HSRX_RISC_IOCB_INT) {
1450 qla4xxx_process_response_queue(ha);
1451 writel(0, &ha->qla4_82xx_reg->host_int);
1452 } else {
1453 ql4_printk(KERN_INFO, ha, "%s: spurious iocb interrupt...\n",
1454 __func__);
1455 goto exit_msix_rsp_q;
1456 }
1457 }
1458 ha->isr_count++;
1459 exit_msix_rsp_q:
1460 spin_unlock_irqrestore(&ha->hardware_lock, flags);
1461 return IRQ_HANDLED;
1462 }
1463
1464 /**
1465 * qla4xxx_process_aen - processes AENs generated by firmware
1466 * @ha: pointer to host adapter structure.
1467 * @process_aen: type of AENs to process
1468 *
1469 * Processes specific types of Asynchronous Events generated by firmware.
1470 * The type of AENs to process is specified by process_aen and can be
1471 * PROCESS_ALL_AENS 0
1472 * FLUSH_DDB_CHANGED_AENS 1
1473 * RELOGIN_DDB_CHANGED_AENS 2
1474 **/
1475 void qla4xxx_process_aen(struct scsi_qla_host * ha, uint8_t process_aen)
1476 {
1477 uint32_t mbox_sts[MBOX_AEN_REG_COUNT];
1478 struct aen *aen;
1479 int i;
1480 unsigned long flags;
1481
1482 spin_lock_irqsave(&ha->hardware_lock, flags);
1483 while (ha->aen_out != ha->aen_in) {
1484 aen = &ha->aen_q[ha->aen_out];
1485 /* copy aen information to local structure */
1486 for (i = 0; i < MBOX_AEN_REG_COUNT; i++)
1487 mbox_sts[i] = aen->mbox_sts[i];
1488
1489 ha->aen_q_count++;
1490 ha->aen_out++;
1491
1492 if (ha->aen_out == MAX_AEN_ENTRIES)
1493 ha->aen_out = 0;
1494
1495 spin_unlock_irqrestore(&ha->hardware_lock, flags);
1496
1497 DEBUG2(printk("qla4xxx(%ld): AEN[%d]=0x%08x, mbx1=0x%08x mbx2=0x%08x"
1498 " mbx3=0x%08x mbx4=0x%08x\n", ha->host_no,
1499 (ha->aen_out ? (ha->aen_out-1): (MAX_AEN_ENTRIES-1)),
1500 mbox_sts[0], mbox_sts[1], mbox_sts[2],
1501 mbox_sts[3], mbox_sts[4]));
1502
1503 switch (mbox_sts[0]) {
1504 case MBOX_ASTS_DATABASE_CHANGED:
1505 switch (process_aen) {
1506 case FLUSH_DDB_CHANGED_AENS:
1507 DEBUG2(printk("scsi%ld: AEN[%d] %04x, index "
1508 "[%d] state=%04x FLUSHED!\n",
1509 ha->host_no, ha->aen_out,
1510 mbox_sts[0], mbox_sts[2],
1511 mbox_sts[3]));
1512 break;
1513 case PROCESS_ALL_AENS:
1514 default:
1515 /* Specific device. */
1516 if (mbox_sts[1] == 1)
1517 qla4xxx_process_ddb_changed(ha,
1518 mbox_sts[2], mbox_sts[3],
1519 mbox_sts[4]);
1520 break;
1521 }
1522 }
1523 spin_lock_irqsave(&ha->hardware_lock, flags);
1524 }
1525 spin_unlock_irqrestore(&ha->hardware_lock, flags);
1526 }
1527
1528 int qla4xxx_request_irqs(struct scsi_qla_host *ha)
1529 {
1530 int ret = 0;
1531 int rval = QLA_ERROR;
1532
1533 if (is_qla40XX(ha))
1534 goto try_intx;
1535
1536 if (ql4xenablemsix == 2) {
1537 /* Note: MSI Interrupts not supported for ISP8324 and ISP8042 */
1538 if (is_qla8032(ha) || is_qla8042(ha)) {
1539 ql4_printk(KERN_INFO, ha, "%s: MSI Interrupts not supported for ISP%04x, Falling back-to INTx mode\n",
1540 __func__, ha->pdev->device);
1541 goto try_intx;
1542 }
1543 goto try_msi;
1544 }
1545
1546 if (ql4xenablemsix == 0 || ql4xenablemsix != 1)
1547 goto try_intx;
1548
1549 /* Trying MSI-X */
1550 ret = qla4_8xxx_enable_msix(ha);
1551 if (!ret) {
1552 DEBUG2(ql4_printk(KERN_INFO, ha,
1553 "MSI-X: Enabled (0x%X).\n", ha->revision_id));
1554 goto irq_attached;
1555 } else {
1556 if (is_qla8032(ha) || is_qla8042(ha)) {
1557 ql4_printk(KERN_INFO, ha, "%s: ISP%04x: MSI-X: Falling back-to INTx mode. ret = %d\n",
1558 __func__, ha->pdev->device, ret);
1559 goto try_intx;
1560 }
1561 }
1562
1563 ql4_printk(KERN_WARNING, ha,
1564 "MSI-X: Falling back-to MSI mode -- %d.\n", ret);
1565
1566 try_msi:
1567 /* Trying MSI */
1568 ret = pci_alloc_irq_vectors(ha->pdev, 1, 1, PCI_IRQ_MSI);
1569 if (ret > 0) {
1570 ret = request_irq(ha->pdev->irq, qla4_8xxx_msi_handler,
1571 0, DRIVER_NAME, ha);
1572 if (!ret) {
1573 DEBUG2(ql4_printk(KERN_INFO, ha, "MSI: Enabled.\n"));
1574 goto irq_attached;
1575 } else {
1576 ql4_printk(KERN_WARNING, ha,
1577 "MSI: Failed to reserve interrupt %d "
1578 "already in use.\n", ha->pdev->irq);
1579 pci_free_irq_vectors(ha->pdev);
1580 }
1581 }
1582
1583 try_intx:
1584 if (is_qla8022(ha)) {
1585 ql4_printk(KERN_WARNING, ha, "%s: ISP82xx Legacy interrupt not supported\n",
1586 __func__);
1587 goto irq_not_attached;
1588 }
1589
1590 /* Trying INTx */
1591 ret = request_irq(ha->pdev->irq, ha->isp_ops->intr_handler,
1592 IRQF_SHARED, DRIVER_NAME, ha);
1593 if (!ret) {
1594 DEBUG2(ql4_printk(KERN_INFO, ha, "INTx: Enabled.\n"));
1595 goto irq_attached;
1596
1597 } else {
1598 ql4_printk(KERN_WARNING, ha,
1599 "INTx: Failed to reserve interrupt %d already in"
1600 " use.\n", ha->pdev->irq);
1601 goto irq_not_attached;
1602 }
1603
1604 irq_attached:
1605 set_bit(AF_IRQ_ATTACHED, &ha->flags);
1606 ha->host->irq = ha->pdev->irq;
1607 ql4_printk(KERN_INFO, ha, "%s: irq %d attached\n",
1608 __func__, ha->pdev->irq);
1609 rval = QLA_SUCCESS;
1610 irq_not_attached:
1611 return rval;
1612 }
1613
1614 void qla4xxx_free_irqs(struct scsi_qla_host *ha)
1615 {
1616 if (!test_and_clear_bit(AF_IRQ_ATTACHED, &ha->flags))
1617 return;
1618
1619 if (ha->pdev->msix_enabled)
1620 free_irq(pci_irq_vector(ha->pdev, 1), ha);
1621 free_irq(pci_irq_vector(ha->pdev, 0), ha);
1622 pci_free_irq_vectors(ha->pdev);
1623 }
Linux with added FPC-III support