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_QLA25XX(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); 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 ha->link_data_rate = 0; 406 if (IS_QLA2100(ha) || IS_QLA2200(ha)) { 407 link_speed = link_speeds[0]; 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); 436 } 437 438 ha->flags.management_server_logged_in = 0; 439 ha->link_data_rate = 0; 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); 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); 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); 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 (!IS_QLA2100(ha) && !IS_QLA2200(ha) && !IS_QLA6312(ha) && 523 !IS_QLA6322(ha) && !IS_QLA24XX(ha) && !IS_QLA25XX(ha) && 524 ha->flags.init_done && mb[1] != 0xffff && 525 ((ha->operating_mode == P2P && mb[1] != 0) || 526 (ha->operating_mode != P2P && mb[1] != 527 SNS_FIRST_LOOP_ID)) && (mb[2] == 6 || mb[2] == 7)) { 528 int rval; 529 fc_port_t *rscn_fcport; 530 531 /* Create new fcport for login. */ 532 rscn_fcport = qla2x00_alloc_rscn_fcport(ha, GFP_ATOMIC); 533 if (rscn_fcport) { 534 DEBUG14(printk("scsi(%ld): Port Update -- " 535 "creating RSCN fcport %p for %x/%x/%x.\n", 536 ha->host_no, rscn_fcport, mb[1], mb[2], 537 mb[3])); 538 539 rscn_fcport->loop_id = mb[1]; 540 rscn_fcport->d_id.b24 = INVALID_PORT_ID; 541 atomic_set(&rscn_fcport->state, 542 FCS_DEVICE_LOST); 543 list_add_tail(&rscn_fcport->list, 544 &ha->rscn_fcports); 545 546 rval = qla2x00_handle_port_rscn(ha, 0, 547 rscn_fcport, 1); 548 if (rval == QLA_SUCCESS) 549 break; 550 } else { 551 DEBUG14(printk("scsi(%ld): Port Update -- " 552 "-- unable to allocate RSCN fcport " 553 "login.\n", ha->host_no)); 554 } 555 } 556 557 /* 558 * If PORT UPDATE is global (recieved LIP_OCCURED/LIP_RESET 559 * event etc. earlier indicating loop is down) then process 560 * it. Otherwise ignore it and Wait for RSCN to come in. 561 */ 562 atomic_set(&ha->loop_down_timer, 0); 563 if (atomic_read(&ha->loop_state) != LOOP_DOWN && 564 atomic_read(&ha->loop_state) != LOOP_DEAD) { 565 DEBUG2(printk("scsi(%ld): Asynchronous PORT UPDATE " 566 "ignored %04x/%04x/%04x.\n", ha->host_no, mb[1], 567 mb[2], mb[3])); 568 break; 569 } 570 571 DEBUG2(printk("scsi(%ld): Asynchronous PORT UPDATE.\n", 572 ha->host_no)); 573 DEBUG(printk(KERN_INFO 574 "scsi(%ld): Port database changed %04x %04x %04x.\n", 575 ha->host_no, mb[1], mb[2], mb[3])); 576 577 /* 578 * Mark all devices as missing so we will login again. 579 */ 580 atomic_set(&ha->loop_state, LOOP_UP); 581 582 qla2x00_mark_all_devices_lost(ha); 583 584 ha->flags.rscn_queue_overflow = 1; 585 586 set_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags); 587 set_bit(LOCAL_LOOP_UPDATE, &ha->dpc_flags); 588 589 /* Update AEN queue. */ 590 qla2x00_enqueue_aen(ha, MBA_PORT_UPDATE, NULL); 591 break; 592 593 case MBA_RSCN_UPDATE: /* State Change Registration */ 594 DEBUG2(printk("scsi(%ld): Asynchronous RSCR UPDATE.\n", 595 ha->host_no)); 596 DEBUG(printk(KERN_INFO 597 "scsi(%ld): RSCN database changed -- %04x %04x.\n", 598 ha->host_no, mb[1], mb[2])); 599 600 rscn_entry = (mb[1] << 16) | mb[2]; 601 host_pid = (ha->d_id.b.domain << 16) | (ha->d_id.b.area << 8) | 602 ha->d_id.b.al_pa; 603 if (rscn_entry == host_pid) { 604 DEBUG(printk(KERN_INFO 605 "scsi(%ld): Ignoring RSCN update to local host " 606 "port ID (%06x)\n", 607 ha->host_no, host_pid)); 608 break; 609 } 610 611 rscn_queue_index = ha->rscn_in_ptr + 1; 612 if (rscn_queue_index == MAX_RSCN_COUNT) 613 rscn_queue_index = 0; 614 if (rscn_queue_index != ha->rscn_out_ptr) { 615 ha->rscn_queue[ha->rscn_in_ptr] = rscn_entry; 616 ha->rscn_in_ptr = rscn_queue_index; 617 } else { 618 ha->flags.rscn_queue_overflow = 1; 619 } 620 621 atomic_set(&ha->loop_state, LOOP_UPDATE); 622 atomic_set(&ha->loop_down_timer, 0); 623 ha->flags.management_server_logged_in = 0; 624 625 set_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags); 626 set_bit(RSCN_UPDATE, &ha->dpc_flags); 627 628 /* Update AEN queue. */ 629 qla2x00_enqueue_aen(ha, MBA_RSCN_UPDATE, &mb[0]); 630 break; 631 632 /* case MBA_RIO_RESPONSE: */ 633 case MBA_ZIO_RESPONSE: 634 DEBUG2(printk("scsi(%ld): [R|Z]IO update completion.\n", 635 ha->host_no)); 636 DEBUG(printk(KERN_INFO 637 "scsi(%ld): [R|Z]IO update completion.\n", 638 ha->host_no)); 639 640 if (IS_QLA24XX(ha) || IS_QLA25XX(ha)) 641 qla24xx_process_response_queue(ha); 642 else 643 qla2x00_process_response_queue(ha); 644 break; 645 646 case MBA_DISCARD_RND_FRAME: 647 DEBUG2(printk("scsi(%ld): Discard RND Frame -- %04x %04x " 648 "%04x.\n", ha->host_no, mb[1], mb[2], mb[3])); 649 break; 650 } 651 } 652 653 /** 654 * qla2x00_process_completed_request() - Process a Fast Post response. 655 * @ha: SCSI driver HA context 656 * @index: SRB index 657 */ 658 static void 659 qla2x00_process_completed_request(struct scsi_qla_host *ha, uint32_t index) 660 { 661 srb_t *sp; 662 663 /* Validate handle. */ 664 if (index >= MAX_OUTSTANDING_COMMANDS) { 665 DEBUG2(printk("scsi(%ld): Invalid SCSI completion handle %d.\n", 666 ha->host_no, index)); 667 qla_printk(KERN_WARNING, ha, 668 "Invalid SCSI completion handle %d.\n", index); 669 670 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags); 671 return; 672 } 673 674 sp = ha->outstanding_cmds[index]; 675 if (sp) { 676 /* Free outstanding command slot. */ 677 ha->outstanding_cmds[index] = NULL; 678 679 CMD_COMPL_STATUS(sp->cmd) = 0L; 680 CMD_SCSI_STATUS(sp->cmd) = 0L; 681 682 /* Save ISP completion status */ 683 sp->cmd->result = DID_OK << 16; 684 qla2x00_sp_compl(ha, sp); 685 } else { 686 DEBUG2(printk("scsi(%ld): Invalid ISP SCSI completion handle\n", 687 ha->host_no)); 688 qla_printk(KERN_WARNING, ha, 689 "Invalid ISP SCSI completion handle\n"); 690 691 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags); 692 } 693 } 694 695 /** 696 * qla2x00_process_response_queue() - Process response queue entries. 697 * @ha: SCSI driver HA context 698 */ 699 void 700 qla2x00_process_response_queue(struct scsi_qla_host *ha) 701 { 702 struct device_reg_2xxx __iomem *reg = &ha->iobase->isp; 703 sts_entry_t *pkt; 704 uint16_t handle_cnt; 705 uint16_t cnt; 706 707 if (!ha->flags.online) 708 return; 709 710 while (ha->response_ring_ptr->signature != RESPONSE_PROCESSED) { 711 pkt = (sts_entry_t *)ha->response_ring_ptr; 712 713 ha->rsp_ring_index++; 714 if (ha->rsp_ring_index == ha->response_q_length) { 715 ha->rsp_ring_index = 0; 716 ha->response_ring_ptr = ha->response_ring; 717 } else { 718 ha->response_ring_ptr++; 719 } 720 721 if (pkt->entry_status != 0) { 722 DEBUG3(printk(KERN_INFO 723 "scsi(%ld): Process error entry.\n", ha->host_no)); 724 725 qla2x00_error_entry(ha, pkt); 726 ((response_t *)pkt)->signature = RESPONSE_PROCESSED; 727 wmb(); 728 continue; 729 } 730 731 switch (pkt->entry_type) { 732 case STATUS_TYPE: 733 qla2x00_status_entry(ha, pkt); 734 break; 735 case STATUS_TYPE_21: 736 handle_cnt = ((sts21_entry_t *)pkt)->handle_count; 737 for (cnt = 0; cnt < handle_cnt; cnt++) { 738 qla2x00_process_completed_request(ha, 739 ((sts21_entry_t *)pkt)->handle[cnt]); 740 } 741 break; 742 case STATUS_TYPE_22: 743 handle_cnt = ((sts22_entry_t *)pkt)->handle_count; 744 for (cnt = 0; cnt < handle_cnt; cnt++) { 745 qla2x00_process_completed_request(ha, 746 ((sts22_entry_t *)pkt)->handle[cnt]); 747 } 748 break; 749 case STATUS_CONT_TYPE: 750 qla2x00_status_cont_entry(ha, (sts_cont_entry_t *)pkt); 751 break; 752 case MS_IOCB_TYPE: 753 qla2x00_ms_entry(ha, (ms_iocb_entry_t *)pkt); 754 break; 755 case MBX_IOCB_TYPE: 756 if (!IS_QLA2100(ha) && !IS_QLA2200(ha) && 757 !IS_QLA6312(ha) && !IS_QLA6322(ha)) { 758 if (pkt->sys_define == SOURCE_ASYNC_IOCB) { 759 qla2x00_process_iodesc(ha, 760 (struct mbx_entry *)pkt); 761 } else { 762 /* MBX IOCB Type Not Supported. */ 763 DEBUG4(printk(KERN_WARNING 764 "scsi(%ld): Received unknown MBX " 765 "IOCB response pkt type=%x " 766 "source=%x entry status=%x.\n", 767 ha->host_no, pkt->entry_type, 768 pkt->sys_define, 769 pkt->entry_status)); 770 } 771 break; 772 } 773 /* Fallthrough. */ 774 default: 775 /* Type Not Supported. */ 776 DEBUG4(printk(KERN_WARNING 777 "scsi(%ld): Received unknown response pkt type %x " 778 "entry status=%x.\n", 779 ha->host_no, pkt->entry_type, pkt->entry_status)); 780 break; 781 } 782 ((response_t *)pkt)->signature = RESPONSE_PROCESSED; 783 wmb(); 784 } 785 786 /* Adjust ring index */ 787 WRT_REG_WORD(ISP_RSP_Q_OUT(ha, reg), ha->rsp_ring_index); 788 } 789 790 /** 791 * qla2x00_status_entry() - Process a Status IOCB entry. 792 * @ha: SCSI driver HA context 793 * @pkt: Entry pointer 794 */ 795 static void 796 qla2x00_status_entry(scsi_qla_host_t *ha, void *pkt) 797 { 798 srb_t *sp; 799 fc_port_t *fcport; 800 struct scsi_cmnd *cp; 801 sts_entry_t *sts; 802 struct sts_entry_24xx *sts24; 803 uint16_t comp_status; 804 uint16_t scsi_status; 805 uint8_t lscsi_status; 806 int32_t resid; 807 uint32_t sense_len, rsp_info_len, resid_len; 808 uint8_t *rsp_info, *sense_data; 809 810 sts = (sts_entry_t *) pkt; 811 sts24 = (struct sts_entry_24xx *) pkt; 812 if (IS_QLA24XX(ha) || IS_QLA25XX(ha)) { 813 comp_status = le16_to_cpu(sts24->comp_status); 814 scsi_status = le16_to_cpu(sts24->scsi_status) & SS_MASK; 815 } else { 816 comp_status = le16_to_cpu(sts->comp_status); 817 scsi_status = le16_to_cpu(sts->scsi_status) & SS_MASK; 818 } 819 820 /* Fast path completion. */ 821 if (comp_status == CS_COMPLETE && scsi_status == 0) { 822 qla2x00_process_completed_request(ha, sts->handle); 823 824 return; 825 } 826 827 /* Validate handle. */ 828 if (sts->handle < MAX_OUTSTANDING_COMMANDS) { 829 sp = ha->outstanding_cmds[sts->handle]; 830 ha->outstanding_cmds[sts->handle] = NULL; 831 } else 832 sp = NULL; 833 834 if (sp == NULL) { 835 DEBUG2(printk("scsi(%ld): Status Entry invalid handle.\n", 836 ha->host_no)); 837 qla_printk(KERN_WARNING, ha, "Status Entry invalid handle.\n"); 838 839 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags); 840 if (ha->dpc_wait && !ha->dpc_active) 841 up(ha->dpc_wait); 842 843 return; 844 } 845 cp = sp->cmd; 846 if (cp == NULL) { 847 DEBUG2(printk("scsi(%ld): Command already returned back to OS " 848 "pkt->handle=%d sp=%p sp->state:%d\n", 849 ha->host_no, sts->handle, sp, sp->state)); 850 qla_printk(KERN_WARNING, ha, 851 "Command is NULL: already returned to OS (sp=%p)\n", sp); 852 853 return; 854 } 855 856 lscsi_status = scsi_status & STATUS_MASK; 857 CMD_ENTRY_STATUS(cp) = sts->entry_status; 858 CMD_COMPL_STATUS(cp) = comp_status; 859 CMD_SCSI_STATUS(cp) = scsi_status; 860 861 fcport = sp->fcport; 862 863 sense_len = rsp_info_len = resid_len = 0; 864 if (IS_QLA24XX(ha) || IS_QLA25XX(ha)) { 865 sense_len = le32_to_cpu(sts24->sense_len); 866 rsp_info_len = le32_to_cpu(sts24->rsp_data_len); 867 resid_len = le32_to_cpu(sts24->rsp_residual_count); 868 rsp_info = sts24->data; 869 sense_data = sts24->data; 870 host_to_fcp_swap(sts24->data, sizeof(sts24->data)); 871 } else { 872 sense_len = le16_to_cpu(sts->req_sense_length); 873 rsp_info_len = le16_to_cpu(sts->rsp_info_len); 874 resid_len = le32_to_cpu(sts->residual_length); 875 rsp_info = sts->rsp_info; 876 sense_data = sts->req_sense_data; 877 } 878 879 /* Check for any FCP transport errors. */ 880 if (scsi_status & SS_RESPONSE_INFO_LEN_VALID) { 881 /* Sense data lies beyond any FCP RESPONSE data. */ 882 if (IS_QLA24XX(ha) || IS_QLA25XX(ha)) 883 sense_data += rsp_info_len; 884 if (rsp_info_len > 3 && rsp_info[3]) { 885 DEBUG2(printk("scsi(%ld:%d:%d:%d) FCP I/O protocol " 886 "failure (%x/%02x%02x%02x%02x%02x%02x%02x%02x)..." 887 "retrying command\n", ha->host_no, 888 cp->device->channel, cp->device->id, 889 cp->device->lun, rsp_info_len, rsp_info[0], 890 rsp_info[1], rsp_info[2], rsp_info[3], rsp_info[4], 891 rsp_info[5], rsp_info[6], rsp_info[7])); 892 893 cp->result = DID_BUS_BUSY << 16; 894 qla2x00_sp_compl(ha, sp); 895 return; 896 } 897 } 898 899 /* 900 * Based on Host and scsi status generate status code for Linux 901 */ 902 switch (comp_status) { 903 case CS_COMPLETE: 904 if (scsi_status == 0) { 905 cp->result = DID_OK << 16; 906 break; 907 } 908 if (scsi_status & (SS_RESIDUAL_UNDER | SS_RESIDUAL_OVER)) { 909 resid = resid_len; 910 cp->resid = resid; 911 CMD_RESID_LEN(cp) = resid; 912 913 if (!lscsi_status && 914 ((unsigned)(cp->request_bufflen - resid) < 915 cp->underflow)) { 916 qla_printk(KERN_INFO, ha, 917 "scsi(%ld:%d:%d:%d): Mid-layer underflow " 918 "detected (%x of %x bytes)...returning " 919 "error status.\n", ha->host_no, 920 cp->device->channel, cp->device->id, 921 cp->device->lun, resid, 922 cp->request_bufflen); 923 924 cp->result = DID_ERROR << 16; 925 break; 926 } 927 } 928 cp->result = DID_OK << 16 | lscsi_status; 929 930 if (lscsi_status != SS_CHECK_CONDITION) 931 break; 932 933 /* Copy Sense Data into sense buffer. */ 934 memset(cp->sense_buffer, 0, sizeof(cp->sense_buffer)); 935 936 if (!(scsi_status & SS_SENSE_LEN_VALID)) 937 break; 938 939 if (sense_len >= sizeof(cp->sense_buffer)) 940 sense_len = sizeof(cp->sense_buffer); 941 942 CMD_ACTUAL_SNSLEN(cp) = sense_len; 943 sp->request_sense_length = sense_len; 944 sp->request_sense_ptr = cp->sense_buffer; 945 946 if (sp->request_sense_length > 32) 947 sense_len = 32; 948 949 memcpy(cp->sense_buffer, sense_data, sense_len); 950 951 sp->request_sense_ptr += sense_len; 952 sp->request_sense_length -= sense_len; 953 if (sp->request_sense_length != 0) 954 ha->status_srb = sp; 955 956 DEBUG5(printk("%s(): Check condition Sense data, " 957 "scsi(%ld:%d:%d:%d) cmd=%p pid=%ld\n", __func__, 958 ha->host_no, cp->device->channel, cp->device->id, 959 cp->device->lun, cp, cp->serial_number)); 960 if (sense_len) 961 DEBUG5(qla2x00_dump_buffer(cp->sense_buffer, 962 CMD_ACTUAL_SNSLEN(cp))); 963 break; 964 965 case CS_DATA_UNDERRUN: 966 DEBUG2(printk(KERN_INFO 967 "scsi(%ld:%d:%d) UNDERRUN status detected 0x%x-0x%x.\n", 968 ha->host_no, cp->device->id, cp->device->lun, comp_status, 969 scsi_status)); 970 971 resid = resid_len; 972 if (scsi_status & SS_RESIDUAL_UNDER) { 973 cp->resid = resid; 974 CMD_RESID_LEN(cp) = resid; 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); 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_QLA25XX(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); 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_QLA25XX(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 if (ha->dpc_wait && !ha->dpc_active) 1273 up(ha->dpc_wait); 1274 } 1275 } 1276 1277 /** 1278 * qla2x00_ms_entry() - Process a Management Server entry. 1279 * @ha: SCSI driver HA context 1280 * @index: Response queue out pointer 1281 */ 1282 static void 1283 qla2x00_ms_entry(scsi_qla_host_t *ha, ms_iocb_entry_t *pkt) 1284 { 1285 srb_t *sp; 1286 1287 DEBUG3(printk("%s(%ld): pkt=%p pkthandle=%d.\n", 1288 __func__, ha->host_no, pkt, pkt->handle1)); 1289 1290 /* Validate handle. */ 1291 if (pkt->handle1 < MAX_OUTSTANDING_COMMANDS) 1292 sp = ha->outstanding_cmds[pkt->handle1]; 1293 else 1294 sp = NULL; 1295 1296 if (sp == NULL) { 1297 DEBUG2(printk("scsi(%ld): MS entry - invalid handle\n", 1298 ha->host_no)); 1299 qla_printk(KERN_WARNING, ha, "MS entry - invalid handle\n"); 1300 1301 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags); 1302 return; 1303 } 1304 1305 CMD_COMPL_STATUS(sp->cmd) = le16_to_cpu(pkt->status); 1306 CMD_ENTRY_STATUS(sp->cmd) = pkt->entry_status; 1307 1308 /* Free outstanding command slot. */ 1309 ha->outstanding_cmds[pkt->handle1] = NULL; 1310 1311 qla2x00_sp_compl(ha, sp); 1312 } 1313 1314 1315 /** 1316 * qla24xx_mbx_completion() - Process mailbox command completions. 1317 * @ha: SCSI driver HA context 1318 * @mb0: Mailbox0 register 1319 */ 1320 static void 1321 qla24xx_mbx_completion(scsi_qla_host_t *ha, uint16_t mb0) 1322 { 1323 uint16_t cnt; 1324 uint16_t __iomem *wptr; 1325 struct device_reg_24xx __iomem *reg = &ha->iobase->isp24; 1326 1327 /* Load return mailbox registers. */ 1328 ha->flags.mbox_int = 1; 1329 ha->mailbox_out[0] = mb0; 1330 wptr = (uint16_t __iomem *)®->mailbox1; 1331 1332 for (cnt = 1; cnt < ha->mbx_count; cnt++) { 1333 ha->mailbox_out[cnt] = RD_REG_WORD(wptr); 1334 wptr++; 1335 } 1336 1337 if (ha->mcp) { 1338 DEBUG3(printk("%s(%ld): Got mailbox completion. cmd=%x.\n", 1339 __func__, ha->host_no, ha->mcp->mb[0])); 1340 } else { 1341 DEBUG2_3(printk("%s(%ld): MBX pointer ERROR!\n", 1342 __func__, ha->host_no)); 1343 } 1344 } 1345 1346 /** 1347 * qla24xx_process_response_queue() - Process response queue entries. 1348 * @ha: SCSI driver HA context 1349 */ 1350 void 1351 qla24xx_process_response_queue(struct scsi_qla_host *ha) 1352 { 1353 struct device_reg_24xx __iomem *reg = &ha->iobase->isp24; 1354 struct sts_entry_24xx *pkt; 1355 1356 if (!ha->flags.online) 1357 return; 1358 1359 while (ha->response_ring_ptr->signature != RESPONSE_PROCESSED) { 1360 pkt = (struct sts_entry_24xx *)ha->response_ring_ptr; 1361 1362 ha->rsp_ring_index++; 1363 if (ha->rsp_ring_index == ha->response_q_length) { 1364 ha->rsp_ring_index = 0; 1365 ha->response_ring_ptr = ha->response_ring; 1366 } else { 1367 ha->response_ring_ptr++; 1368 } 1369 1370 if (pkt->entry_status != 0) { 1371 DEBUG3(printk(KERN_INFO 1372 "scsi(%ld): Process error entry.\n", ha->host_no)); 1373 1374 qla2x00_error_entry(ha, (sts_entry_t *) pkt); 1375 ((response_t *)pkt)->signature = RESPONSE_PROCESSED; 1376 wmb(); 1377 continue; 1378 } 1379 1380 switch (pkt->entry_type) { 1381 case STATUS_TYPE: 1382 qla2x00_status_entry(ha, pkt); 1383 break; 1384 case STATUS_CONT_TYPE: 1385 qla2x00_status_cont_entry(ha, (sts_cont_entry_t *)pkt); 1386 break; 1387 case MS_IOCB_TYPE: 1388 qla24xx_ms_entry(ha, (struct ct_entry_24xx *)pkt); 1389 break; 1390 default: 1391 /* Type Not Supported. */ 1392 DEBUG4(printk(KERN_WARNING 1393 "scsi(%ld): Received unknown response pkt type %x " 1394 "entry status=%x.\n", 1395 ha->host_no, pkt->entry_type, pkt->entry_status)); 1396 break; 1397 } 1398 ((response_t *)pkt)->signature = RESPONSE_PROCESSED; 1399 wmb(); 1400 } 1401 1402 /* Adjust ring index */ 1403 WRT_REG_DWORD(®->rsp_q_out, ha->rsp_ring_index); 1404 } 1405 1406 /** 1407 * qla24xx_intr_handler() - Process interrupts for the ISP23xx and ISP63xx. 1408 * @irq: 1409 * @dev_id: SCSI driver HA context 1410 * @regs: 1411 * 1412 * Called by system whenever the host adapter generates an interrupt. 1413 * 1414 * Returns handled flag. 1415 */ 1416 irqreturn_t 1417 qla24xx_intr_handler(int irq, void *dev_id, struct pt_regs *regs) 1418 { 1419 scsi_qla_host_t *ha; 1420 struct device_reg_24xx __iomem *reg; 1421 int status; 1422 unsigned long flags; 1423 unsigned long iter; 1424 uint32_t stat; 1425 uint32_t hccr; 1426 uint16_t mb[4]; 1427 1428 ha = (scsi_qla_host_t *) dev_id; 1429 if (!ha) { 1430 printk(KERN_INFO 1431 "%s(): NULL host pointer\n", __func__); 1432 return IRQ_NONE; 1433 } 1434 1435 reg = &ha->iobase->isp24; 1436 status = 0; 1437 1438 spin_lock_irqsave(&ha->hardware_lock, flags); 1439 for (iter = 50; iter--; ) { 1440 stat = RD_REG_DWORD(®->host_status); 1441 if (stat & HSRX_RISC_PAUSED) { 1442 hccr = RD_REG_DWORD(®->hccr); 1443 1444 qla_printk(KERN_INFO, ha, "RISC paused -- HCCR=%x, " 1445 "Dumping firmware!\n", hccr); 1446 qla24xx_fw_dump(ha, 1); 1447 1448 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags); 1449 break; 1450 } else if ((stat & HSRX_RISC_INT) == 0) 1451 break; 1452 1453 switch (stat & 0xff) { 1454 case 0x1: 1455 case 0x2: 1456 case 0x10: 1457 case 0x11: 1458 qla24xx_mbx_completion(ha, MSW(stat)); 1459 status |= MBX_INTERRUPT; 1460 1461 break; 1462 case 0x12: 1463 mb[0] = MSW(stat); 1464 mb[1] = RD_REG_WORD(®->mailbox1); 1465 mb[2] = RD_REG_WORD(®->mailbox2); 1466 mb[3] = RD_REG_WORD(®->mailbox3); 1467 qla2x00_async_event(ha, mb); 1468 break; 1469 case 0x13: 1470 qla24xx_process_response_queue(ha); 1471 break; 1472 default: 1473 DEBUG2(printk("scsi(%ld): Unrecognized interrupt type " 1474 "(%d).\n", 1475 ha->host_no, stat & 0xff)); 1476 break; 1477 } 1478 WRT_REG_DWORD(®->hccr, HCCRX_CLR_RISC_INT); 1479 RD_REG_DWORD_RELAXED(®->hccr); 1480 } 1481 spin_unlock_irqrestore(&ha->hardware_lock, flags); 1482 1483 if (test_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags) && 1484 (status & MBX_INTERRUPT) && ha->flags.mbox_int) { 1485 spin_lock_irqsave(&ha->mbx_reg_lock, flags); 1486 1487 set_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags); 1488 up(&ha->mbx_intr_sem); 1489 1490 spin_unlock_irqrestore(&ha->mbx_reg_lock, flags); 1491 } 1492 1493 return IRQ_HANDLED; 1494 } 1495 1496 /** 1497 * qla24xx_ms_entry() - Process a Management Server entry. 1498 * @ha: SCSI driver HA context 1499 * @index: Response queue out pointer 1500 */ 1501 static void 1502 qla24xx_ms_entry(scsi_qla_host_t *ha, struct ct_entry_24xx *pkt) 1503 { 1504 srb_t *sp; 1505 1506 DEBUG3(printk("%s(%ld): pkt=%p pkthandle=%d.\n", 1507 __func__, ha->host_no, pkt, pkt->handle)); 1508 1509 DEBUG9(printk("%s: ct pkt dump:\n", __func__);) 1510 DEBUG9(qla2x00_dump_buffer((void *)pkt, sizeof(struct ct_entry_24xx));) 1511 1512 /* Validate handle. */ 1513 if (pkt->handle < MAX_OUTSTANDING_COMMANDS) 1514 sp = ha->outstanding_cmds[pkt->handle]; 1515 else 1516 sp = NULL; 1517 1518 if (sp == NULL) { 1519 DEBUG2(printk("scsi(%ld): MS entry - invalid handle\n", 1520 ha->host_no)); 1521 DEBUG10(printk("scsi(%ld): MS entry - invalid handle\n", 1522 ha->host_no)); 1523 qla_printk(KERN_WARNING, ha, "MS entry - invalid handle %d\n", 1524 pkt->handle); 1525 1526 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags); 1527 return; 1528 } 1529 1530 CMD_COMPL_STATUS(sp->cmd) = le16_to_cpu(pkt->comp_status); 1531 CMD_ENTRY_STATUS(sp->cmd) = pkt->entry_status; 1532 1533 /* Free outstanding command slot. */ 1534 ha->outstanding_cmds[pkt->handle] = NULL; 1535 1536 qla2x00_sp_compl(ha, sp); 1537 } 1538 1539