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