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 #include <scsi/scsi_tcq.h> 10 11 static void qla2x00_mbx_completion(scsi_qla_host_t *, uint16_t); 12 static void qla2x00_process_completed_request(struct scsi_qla_host *, uint32_t); 13 static void qla2x00_status_entry(scsi_qla_host_t *, void *); 14 static void qla2x00_status_cont_entry(scsi_qla_host_t *, sts_cont_entry_t *); 15 static void qla2x00_error_entry(scsi_qla_host_t *, sts_entry_t *); 16 static void qla2x00_ms_entry(scsi_qla_host_t *, ms_iocb_entry_t *); 17 18 static void qla24xx_ms_entry(scsi_qla_host_t *, struct ct_entry_24xx *); 19 20 /** 21 * qla2100_intr_handler() - Process interrupts for the ISP2100 and ISP2200. 22 * @irq: 23 * @dev_id: SCSI driver HA context 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) 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 set_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags); 89 up(&ha->mbx_intr_sem); 90 } 91 92 return (IRQ_HANDLED); 93 } 94 95 /** 96 * qla2300_intr_handler() - Process interrupts for the ISP23xx and ISP63xx. 97 * @irq: 98 * @dev_id: SCSI driver HA context 99 * 100 * Called by system whenever the host adapter generates an interrupt. 101 * 102 * Returns handled flag. 103 */ 104 irqreturn_t 105 qla2300_intr_handler(int irq, void *dev_id) 106 { 107 scsi_qla_host_t *ha; 108 struct device_reg_2xxx __iomem *reg; 109 int status; 110 unsigned long flags; 111 unsigned long iter; 112 uint32_t stat; 113 uint16_t hccr; 114 uint16_t mb[4]; 115 116 ha = (scsi_qla_host_t *) dev_id; 117 if (!ha) { 118 printk(KERN_INFO 119 "%s(): NULL host pointer\n", __func__); 120 return (IRQ_NONE); 121 } 122 123 reg = &ha->iobase->isp; 124 status = 0; 125 126 spin_lock_irqsave(&ha->hardware_lock, flags); 127 for (iter = 50; iter--; ) { 128 stat = RD_REG_DWORD(®->u.isp2300.host_status); 129 if (stat & HSR_RISC_PAUSED) { 130 hccr = RD_REG_WORD(®->hccr); 131 if (hccr & (BIT_15 | BIT_13 | BIT_11 | BIT_8)) 132 qla_printk(KERN_INFO, ha, "Parity error -- " 133 "HCCR=%x, Dumping firmware!\n", hccr); 134 else 135 qla_printk(KERN_INFO, ha, "RISC paused -- " 136 "HCCR=%x, Dumping firmware!\n", hccr); 137 138 /* 139 * Issue a "HARD" reset in order for the RISC 140 * interrupt bit to be cleared. Schedule a big 141 * hammmer to get out of the RISC PAUSED state. 142 */ 143 WRT_REG_WORD(®->hccr, HCCR_RESET_RISC); 144 RD_REG_WORD(®->hccr); 145 146 ha->isp_ops->fw_dump(ha, 1); 147 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags); 148 break; 149 } else if ((stat & HSR_RISC_INT) == 0) 150 break; 151 152 switch (stat & 0xff) { 153 case 0x1: 154 case 0x2: 155 case 0x10: 156 case 0x11: 157 qla2x00_mbx_completion(ha, MSW(stat)); 158 status |= MBX_INTERRUPT; 159 160 /* Release mailbox registers. */ 161 WRT_REG_WORD(®->semaphore, 0); 162 break; 163 case 0x12: 164 mb[0] = MSW(stat); 165 mb[1] = RD_MAILBOX_REG(ha, reg, 1); 166 mb[2] = RD_MAILBOX_REG(ha, reg, 2); 167 mb[3] = RD_MAILBOX_REG(ha, reg, 3); 168 qla2x00_async_event(ha, mb); 169 break; 170 case 0x13: 171 qla2x00_process_response_queue(ha); 172 break; 173 case 0x15: 174 mb[0] = MBA_CMPLT_1_16BIT; 175 mb[1] = MSW(stat); 176 qla2x00_async_event(ha, mb); 177 break; 178 case 0x16: 179 mb[0] = MBA_SCSI_COMPLETION; 180 mb[1] = MSW(stat); 181 mb[2] = RD_MAILBOX_REG(ha, reg, 2); 182 qla2x00_async_event(ha, mb); 183 break; 184 default: 185 DEBUG2(printk("scsi(%ld): Unrecognized interrupt type " 186 "(%d).\n", 187 ha->host_no, stat & 0xff)); 188 break; 189 } 190 WRT_REG_WORD(®->hccr, HCCR_CLR_RISC_INT); 191 RD_REG_WORD_RELAXED(®->hccr); 192 } 193 spin_unlock_irqrestore(&ha->hardware_lock, flags); 194 195 if (test_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags) && 196 (status & MBX_INTERRUPT) && ha->flags.mbox_int) { 197 set_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags); 198 up(&ha->mbx_intr_sem); 199 } 200 201 return (IRQ_HANDLED); 202 } 203 204 /** 205 * qla2x00_mbx_completion() - Process mailbox command completions. 206 * @ha: SCSI driver HA context 207 * @mb0: Mailbox0 register 208 */ 209 static void 210 qla2x00_mbx_completion(scsi_qla_host_t *ha, uint16_t mb0) 211 { 212 uint16_t cnt; 213 uint16_t __iomem *wptr; 214 struct device_reg_2xxx __iomem *reg = &ha->iobase->isp; 215 216 /* Load return mailbox registers. */ 217 ha->flags.mbox_int = 1; 218 ha->mailbox_out[0] = mb0; 219 wptr = (uint16_t __iomem *)MAILBOX_REG(ha, reg, 1); 220 221 for (cnt = 1; cnt < ha->mbx_count; cnt++) { 222 if (IS_QLA2200(ha) && cnt == 8) 223 wptr = (uint16_t __iomem *)MAILBOX_REG(ha, reg, 8); 224 if (cnt == 4 || cnt == 5) 225 ha->mailbox_out[cnt] = qla2x00_debounce_register(wptr); 226 else 227 ha->mailbox_out[cnt] = RD_REG_WORD(wptr); 228 229 wptr++; 230 } 231 232 if (ha->mcp) { 233 DEBUG3(printk("%s(%ld): Got mailbox completion. cmd=%x.\n", 234 __func__, ha->host_no, ha->mcp->mb[0])); 235 } else { 236 DEBUG2_3(printk("%s(%ld): MBX pointer ERROR!\n", 237 __func__, ha->host_no)); 238 } 239 } 240 241 /** 242 * qla2x00_async_event() - Process aynchronous events. 243 * @ha: SCSI driver HA context 244 * @mb: Mailbox registers (0 - 3) 245 */ 246 void 247 qla2x00_async_event(scsi_qla_host_t *ha, uint16_t *mb) 248 { 249 #define LS_UNKNOWN 2 250 static char *link_speeds[5] = { "1", "2", "?", "4", "8" }; 251 char *link_speed; 252 uint16_t handle_cnt; 253 uint16_t cnt; 254 uint32_t handles[5]; 255 struct device_reg_2xxx __iomem *reg = &ha->iobase->isp; 256 uint32_t rscn_entry, host_pid; 257 uint8_t rscn_queue_index; 258 259 /* Setup to process RIO completion. */ 260 handle_cnt = 0; 261 switch (mb[0]) { 262 case MBA_SCSI_COMPLETION: 263 handles[0] = le32_to_cpu((uint32_t)((mb[2] << 16) | mb[1])); 264 handle_cnt = 1; 265 break; 266 case MBA_CMPLT_1_16BIT: 267 handles[0] = mb[1]; 268 handle_cnt = 1; 269 mb[0] = MBA_SCSI_COMPLETION; 270 break; 271 case MBA_CMPLT_2_16BIT: 272 handles[0] = mb[1]; 273 handles[1] = mb[2]; 274 handle_cnt = 2; 275 mb[0] = MBA_SCSI_COMPLETION; 276 break; 277 case MBA_CMPLT_3_16BIT: 278 handles[0] = mb[1]; 279 handles[1] = mb[2]; 280 handles[2] = mb[3]; 281 handle_cnt = 3; 282 mb[0] = MBA_SCSI_COMPLETION; 283 break; 284 case MBA_CMPLT_4_16BIT: 285 handles[0] = mb[1]; 286 handles[1] = mb[2]; 287 handles[2] = mb[3]; 288 handles[3] = (uint32_t)RD_MAILBOX_REG(ha, reg, 6); 289 handle_cnt = 4; 290 mb[0] = MBA_SCSI_COMPLETION; 291 break; 292 case MBA_CMPLT_5_16BIT: 293 handles[0] = mb[1]; 294 handles[1] = mb[2]; 295 handles[2] = mb[3]; 296 handles[3] = (uint32_t)RD_MAILBOX_REG(ha, reg, 6); 297 handles[4] = (uint32_t)RD_MAILBOX_REG(ha, reg, 7); 298 handle_cnt = 5; 299 mb[0] = MBA_SCSI_COMPLETION; 300 break; 301 case MBA_CMPLT_2_32BIT: 302 handles[0] = le32_to_cpu((uint32_t)((mb[2] << 16) | mb[1])); 303 handles[1] = le32_to_cpu( 304 ((uint32_t)(RD_MAILBOX_REG(ha, reg, 7) << 16)) | 305 RD_MAILBOX_REG(ha, reg, 6)); 306 handle_cnt = 2; 307 mb[0] = MBA_SCSI_COMPLETION; 308 break; 309 default: 310 break; 311 } 312 313 switch (mb[0]) { 314 case MBA_SCSI_COMPLETION: /* Fast Post */ 315 if (!ha->flags.online) 316 break; 317 318 for (cnt = 0; cnt < handle_cnt; cnt++) 319 qla2x00_process_completed_request(ha, handles[cnt]); 320 break; 321 322 case MBA_RESET: /* Reset */ 323 DEBUG2(printk("scsi(%ld): Asynchronous RESET.\n", ha->host_no)); 324 325 set_bit(RESET_MARKER_NEEDED, &ha->dpc_flags); 326 break; 327 328 case MBA_SYSTEM_ERR: /* System Error */ 329 mb[1] = RD_MAILBOX_REG(ha, reg, 1); 330 mb[2] = RD_MAILBOX_REG(ha, reg, 2); 331 mb[3] = RD_MAILBOX_REG(ha, reg, 3); 332 333 qla_printk(KERN_INFO, ha, 334 "ISP System Error - mbx1=%xh mbx2=%xh mbx3=%xh.\n", 335 mb[1], mb[2], mb[3]); 336 337 ha->isp_ops->fw_dump(ha, 1); 338 339 if (IS_FWI2_CAPABLE(ha)) { 340 if (mb[1] == 0 && mb[2] == 0) { 341 qla_printk(KERN_ERR, ha, 342 "Unrecoverable Hardware Error: adapter " 343 "marked OFFLINE!\n"); 344 ha->flags.online = 0; 345 } else 346 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags); 347 } else if (mb[1] == 0) { 348 qla_printk(KERN_INFO, ha, 349 "Unrecoverable Hardware Error: adapter marked " 350 "OFFLINE!\n"); 351 ha->flags.online = 0; 352 } else 353 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags); 354 break; 355 356 case MBA_REQ_TRANSFER_ERR: /* Request Transfer Error */ 357 DEBUG2(printk("scsi(%ld): ISP Request Transfer Error.\n", 358 ha->host_no)); 359 qla_printk(KERN_WARNING, ha, "ISP Request Transfer Error.\n"); 360 361 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags); 362 break; 363 364 case MBA_RSP_TRANSFER_ERR: /* Response Transfer Error */ 365 DEBUG2(printk("scsi(%ld): ISP Response Transfer Error.\n", 366 ha->host_no)); 367 qla_printk(KERN_WARNING, ha, "ISP Response Transfer Error.\n"); 368 369 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags); 370 break; 371 372 case MBA_WAKEUP_THRES: /* Request Queue Wake-up */ 373 DEBUG2(printk("scsi(%ld): Asynchronous WAKEUP_THRES.\n", 374 ha->host_no)); 375 break; 376 377 case MBA_LIP_OCCURRED: /* Loop Initialization Procedure */ 378 DEBUG2(printk("scsi(%ld): LIP occured (%x).\n", ha->host_no, 379 mb[1])); 380 qla_printk(KERN_INFO, ha, "LIP occured (%x).\n", mb[1]); 381 382 if (atomic_read(&ha->loop_state) != LOOP_DOWN) { 383 atomic_set(&ha->loop_state, LOOP_DOWN); 384 atomic_set(&ha->loop_down_timer, LOOP_DOWN_TIME); 385 qla2x00_mark_all_devices_lost(ha, 1); 386 } 387 388 if (ha->parent) { 389 atomic_set(&ha->vp_state, VP_FAILED); 390 fc_vport_set_state(ha->fc_vport, FC_VPORT_FAILED); 391 } 392 393 set_bit(REGISTER_FC4_NEEDED, &ha->dpc_flags); 394 395 ha->flags.management_server_logged_in = 0; 396 break; 397 398 case MBA_LOOP_UP: /* Loop Up Event */ 399 if (IS_QLA2100(ha) || IS_QLA2200(ha)) { 400 link_speed = link_speeds[0]; 401 ha->link_data_rate = PORT_SPEED_1GB; 402 } else { 403 link_speed = link_speeds[LS_UNKNOWN]; 404 if (mb[1] < 5) 405 link_speed = link_speeds[mb[1]]; 406 ha->link_data_rate = mb[1]; 407 } 408 409 DEBUG2(printk("scsi(%ld): Asynchronous LOOP UP (%s Gbps).\n", 410 ha->host_no, link_speed)); 411 qla_printk(KERN_INFO, ha, "LOOP UP detected (%s Gbps).\n", 412 link_speed); 413 414 ha->flags.management_server_logged_in = 0; 415 break; 416 417 case MBA_LOOP_DOWN: /* Loop Down Event */ 418 DEBUG2(printk("scsi(%ld): Asynchronous LOOP DOWN (%x).\n", 419 ha->host_no, mb[1])); 420 qla_printk(KERN_INFO, ha, "LOOP DOWN detected (%x).\n", mb[1]); 421 422 if (atomic_read(&ha->loop_state) != LOOP_DOWN) { 423 atomic_set(&ha->loop_state, LOOP_DOWN); 424 atomic_set(&ha->loop_down_timer, LOOP_DOWN_TIME); 425 ha->device_flags |= DFLG_NO_CABLE; 426 qla2x00_mark_all_devices_lost(ha, 1); 427 } 428 429 if (ha->parent) { 430 atomic_set(&ha->vp_state, VP_FAILED); 431 fc_vport_set_state(ha->fc_vport, FC_VPORT_FAILED); 432 } 433 434 ha->flags.management_server_logged_in = 0; 435 ha->link_data_rate = PORT_SPEED_UNKNOWN; 436 if (ql2xfdmienable) 437 set_bit(REGISTER_FDMI_NEEDED, &ha->dpc_flags); 438 break; 439 440 case MBA_LIP_RESET: /* LIP reset occurred */ 441 DEBUG2(printk("scsi(%ld): Asynchronous LIP RESET (%x).\n", 442 ha->host_no, mb[1])); 443 qla_printk(KERN_INFO, ha, 444 "LIP reset occured (%x).\n", mb[1]); 445 446 if (atomic_read(&ha->loop_state) != LOOP_DOWN) { 447 atomic_set(&ha->loop_state, LOOP_DOWN); 448 atomic_set(&ha->loop_down_timer, LOOP_DOWN_TIME); 449 qla2x00_mark_all_devices_lost(ha, 1); 450 } 451 452 if (ha->parent) { 453 atomic_set(&ha->vp_state, VP_FAILED); 454 fc_vport_set_state(ha->fc_vport, FC_VPORT_FAILED); 455 } 456 457 set_bit(RESET_MARKER_NEEDED, &ha->dpc_flags); 458 459 ha->operating_mode = LOOP; 460 ha->flags.management_server_logged_in = 0; 461 break; 462 463 case MBA_POINT_TO_POINT: /* Point-to-Point */ 464 if (IS_QLA2100(ha)) 465 break; 466 467 DEBUG2(printk("scsi(%ld): Asynchronous P2P MODE received.\n", 468 ha->host_no)); 469 470 /* 471 * Until there's a transition from loop down to loop up, treat 472 * this as loop down only. 473 */ 474 if (atomic_read(&ha->loop_state) != LOOP_DOWN) { 475 atomic_set(&ha->loop_state, LOOP_DOWN); 476 if (!atomic_read(&ha->loop_down_timer)) 477 atomic_set(&ha->loop_down_timer, 478 LOOP_DOWN_TIME); 479 qla2x00_mark_all_devices_lost(ha, 1); 480 } 481 482 if (ha->parent) { 483 atomic_set(&ha->vp_state, VP_FAILED); 484 fc_vport_set_state(ha->fc_vport, FC_VPORT_FAILED); 485 } 486 487 if (!(test_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags))) { 488 set_bit(RESET_MARKER_NEEDED, &ha->dpc_flags); 489 } 490 set_bit(REGISTER_FC4_NEEDED, &ha->dpc_flags); 491 492 ha->flags.gpsc_supported = 1; 493 ha->flags.management_server_logged_in = 0; 494 break; 495 496 case MBA_CHG_IN_CONNECTION: /* Change in connection mode */ 497 if (IS_QLA2100(ha)) 498 break; 499 500 DEBUG2(printk("scsi(%ld): Asynchronous Change In Connection " 501 "received.\n", 502 ha->host_no)); 503 qla_printk(KERN_INFO, ha, 504 "Configuration change detected: value=%x.\n", mb[1]); 505 506 if (atomic_read(&ha->loop_state) != LOOP_DOWN) { 507 atomic_set(&ha->loop_state, LOOP_DOWN); 508 if (!atomic_read(&ha->loop_down_timer)) 509 atomic_set(&ha->loop_down_timer, 510 LOOP_DOWN_TIME); 511 qla2x00_mark_all_devices_lost(ha, 1); 512 } 513 514 if (ha->parent) { 515 atomic_set(&ha->vp_state, VP_FAILED); 516 fc_vport_set_state(ha->fc_vport, FC_VPORT_FAILED); 517 } 518 519 set_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags); 520 set_bit(LOCAL_LOOP_UPDATE, &ha->dpc_flags); 521 break; 522 523 case MBA_PORT_UPDATE: /* Port database update */ 524 /* 525 * If PORT UPDATE is global (recieved LIP_OCCURED/LIP_RESET 526 * event etc. earlier indicating loop is down) then process 527 * it. Otherwise ignore it and Wait for RSCN to come in. 528 */ 529 atomic_set(&ha->loop_down_timer, 0); 530 if (atomic_read(&ha->loop_state) != LOOP_DOWN && 531 atomic_read(&ha->loop_state) != LOOP_DEAD) { 532 DEBUG2(printk("scsi(%ld): Asynchronous PORT UPDATE " 533 "ignored %04x/%04x/%04x.\n", ha->host_no, mb[1], 534 mb[2], mb[3])); 535 break; 536 } 537 538 DEBUG2(printk("scsi(%ld): Asynchronous PORT UPDATE.\n", 539 ha->host_no)); 540 DEBUG(printk(KERN_INFO 541 "scsi(%ld): Port database changed %04x %04x %04x.\n", 542 ha->host_no, mb[1], mb[2], mb[3])); 543 544 /* 545 * Mark all devices as missing so we will login again. 546 */ 547 atomic_set(&ha->loop_state, LOOP_UP); 548 549 qla2x00_mark_all_devices_lost(ha, 1); 550 551 ha->flags.rscn_queue_overflow = 1; 552 553 set_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags); 554 set_bit(LOCAL_LOOP_UPDATE, &ha->dpc_flags); 555 break; 556 557 case MBA_RSCN_UPDATE: /* State Change Registration */ 558 /* Check if the Vport has issued a SCR */ 559 if (ha->parent && test_bit(VP_SCR_NEEDED, &ha->vp_flags)) 560 break; 561 562 DEBUG2(printk("scsi(%ld): Asynchronous RSCR UPDATE.\n", 563 ha->host_no)); 564 DEBUG(printk(KERN_INFO 565 "scsi(%ld): RSCN database changed -- %04x %04x.\n", 566 ha->host_no, mb[1], mb[2])); 567 568 rscn_entry = (mb[1] << 16) | mb[2]; 569 host_pid = (ha->d_id.b.domain << 16) | (ha->d_id.b.area << 8) | 570 ha->d_id.b.al_pa; 571 if (rscn_entry == host_pid) { 572 DEBUG(printk(KERN_INFO 573 "scsi(%ld): Ignoring RSCN update to local host " 574 "port ID (%06x)\n", 575 ha->host_no, host_pid)); 576 break; 577 } 578 579 rscn_queue_index = ha->rscn_in_ptr + 1; 580 if (rscn_queue_index == MAX_RSCN_COUNT) 581 rscn_queue_index = 0; 582 if (rscn_queue_index != ha->rscn_out_ptr) { 583 ha->rscn_queue[ha->rscn_in_ptr] = rscn_entry; 584 ha->rscn_in_ptr = rscn_queue_index; 585 } else { 586 ha->flags.rscn_queue_overflow = 1; 587 } 588 589 atomic_set(&ha->loop_state, LOOP_UPDATE); 590 atomic_set(&ha->loop_down_timer, 0); 591 ha->flags.management_server_logged_in = 0; 592 593 set_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags); 594 set_bit(RSCN_UPDATE, &ha->dpc_flags); 595 break; 596 597 /* case MBA_RIO_RESPONSE: */ 598 case MBA_ZIO_RESPONSE: 599 DEBUG2(printk("scsi(%ld): [R|Z]IO update completion.\n", 600 ha->host_no)); 601 DEBUG(printk(KERN_INFO 602 "scsi(%ld): [R|Z]IO update completion.\n", 603 ha->host_no)); 604 605 if (IS_FWI2_CAPABLE(ha)) 606 qla24xx_process_response_queue(ha); 607 else 608 qla2x00_process_response_queue(ha); 609 break; 610 611 case MBA_DISCARD_RND_FRAME: 612 DEBUG2(printk("scsi(%ld): Discard RND Frame -- %04x %04x " 613 "%04x.\n", ha->host_no, mb[1], mb[2], mb[3])); 614 break; 615 616 case MBA_TRACE_NOTIFICATION: 617 DEBUG2(printk("scsi(%ld): Trace Notification -- %04x %04x.\n", 618 ha->host_no, mb[1], mb[2])); 619 break; 620 } 621 622 if (!ha->parent && ha->num_vhosts) 623 qla2x00_alert_all_vps(ha, mb); 624 } 625 626 static void 627 qla2x00_adjust_sdev_qdepth_up(struct scsi_device *sdev, void *data) 628 { 629 fc_port_t *fcport = data; 630 631 if (fcport->ha->max_q_depth <= sdev->queue_depth) 632 return; 633 634 if (sdev->ordered_tags) 635 scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, 636 sdev->queue_depth + 1); 637 else 638 scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG, 639 sdev->queue_depth + 1); 640 641 fcport->last_ramp_up = jiffies; 642 643 DEBUG2(qla_printk(KERN_INFO, fcport->ha, 644 "scsi(%ld:%d:%d:%d): Queue depth adjusted-up to %d.\n", 645 fcport->ha->host_no, sdev->channel, sdev->id, sdev->lun, 646 sdev->queue_depth)); 647 } 648 649 static void 650 qla2x00_adjust_sdev_qdepth_down(struct scsi_device *sdev, void *data) 651 { 652 fc_port_t *fcport = data; 653 654 if (!scsi_track_queue_full(sdev, sdev->queue_depth - 1)) 655 return; 656 657 DEBUG2(qla_printk(KERN_INFO, fcport->ha, 658 "scsi(%ld:%d:%d:%d): Queue depth adjusted-down to %d.\n", 659 fcport->ha->host_no, sdev->channel, sdev->id, sdev->lun, 660 sdev->queue_depth)); 661 } 662 663 static inline void 664 qla2x00_ramp_up_queue_depth(scsi_qla_host_t *ha, srb_t *sp) 665 { 666 fc_port_t *fcport; 667 struct scsi_device *sdev; 668 669 sdev = sp->cmd->device; 670 if (sdev->queue_depth >= ha->max_q_depth) 671 return; 672 673 fcport = sp->fcport; 674 if (time_before(jiffies, 675 fcport->last_ramp_up + ql2xqfullrampup * HZ)) 676 return; 677 if (time_before(jiffies, 678 fcport->last_queue_full + ql2xqfullrampup * HZ)) 679 return; 680 681 starget_for_each_device(sdev->sdev_target, fcport, 682 qla2x00_adjust_sdev_qdepth_up); 683 } 684 685 /** 686 * qla2x00_process_completed_request() - Process a Fast Post response. 687 * @ha: SCSI driver HA context 688 * @index: SRB index 689 */ 690 static void 691 qla2x00_process_completed_request(struct scsi_qla_host *ha, uint32_t index) 692 { 693 srb_t *sp; 694 695 /* Validate handle. */ 696 if (index >= MAX_OUTSTANDING_COMMANDS) { 697 DEBUG2(printk("scsi(%ld): Invalid SCSI completion handle %d.\n", 698 ha->host_no, index)); 699 qla_printk(KERN_WARNING, ha, 700 "Invalid SCSI completion handle %d.\n", index); 701 702 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags); 703 return; 704 } 705 706 sp = ha->outstanding_cmds[index]; 707 if (sp) { 708 /* Free outstanding command slot. */ 709 ha->outstanding_cmds[index] = NULL; 710 711 CMD_COMPL_STATUS(sp->cmd) = 0L; 712 CMD_SCSI_STATUS(sp->cmd) = 0L; 713 714 /* Save ISP completion status */ 715 sp->cmd->result = DID_OK << 16; 716 717 qla2x00_ramp_up_queue_depth(ha, sp); 718 qla2x00_sp_compl(ha, sp); 719 } else { 720 DEBUG2(printk("scsi(%ld): Invalid ISP SCSI completion handle\n", 721 ha->host_no)); 722 qla_printk(KERN_WARNING, ha, 723 "Invalid ISP SCSI completion handle\n"); 724 725 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags); 726 } 727 } 728 729 /** 730 * qla2x00_process_response_queue() - Process response queue entries. 731 * @ha: SCSI driver HA context 732 */ 733 void 734 qla2x00_process_response_queue(struct scsi_qla_host *ha) 735 { 736 struct device_reg_2xxx __iomem *reg = &ha->iobase->isp; 737 sts_entry_t *pkt; 738 uint16_t handle_cnt; 739 uint16_t cnt; 740 741 if (!ha->flags.online) 742 return; 743 744 while (ha->response_ring_ptr->signature != RESPONSE_PROCESSED) { 745 pkt = (sts_entry_t *)ha->response_ring_ptr; 746 747 ha->rsp_ring_index++; 748 if (ha->rsp_ring_index == ha->response_q_length) { 749 ha->rsp_ring_index = 0; 750 ha->response_ring_ptr = ha->response_ring; 751 } else { 752 ha->response_ring_ptr++; 753 } 754 755 if (pkt->entry_status != 0) { 756 DEBUG3(printk(KERN_INFO 757 "scsi(%ld): Process error entry.\n", ha->host_no)); 758 759 qla2x00_error_entry(ha, pkt); 760 ((response_t *)pkt)->signature = RESPONSE_PROCESSED; 761 wmb(); 762 continue; 763 } 764 765 switch (pkt->entry_type) { 766 case STATUS_TYPE: 767 qla2x00_status_entry(ha, pkt); 768 break; 769 case STATUS_TYPE_21: 770 handle_cnt = ((sts21_entry_t *)pkt)->handle_count; 771 for (cnt = 0; cnt < handle_cnt; cnt++) { 772 qla2x00_process_completed_request(ha, 773 ((sts21_entry_t *)pkt)->handle[cnt]); 774 } 775 break; 776 case STATUS_TYPE_22: 777 handle_cnt = ((sts22_entry_t *)pkt)->handle_count; 778 for (cnt = 0; cnt < handle_cnt; cnt++) { 779 qla2x00_process_completed_request(ha, 780 ((sts22_entry_t *)pkt)->handle[cnt]); 781 } 782 break; 783 case STATUS_CONT_TYPE: 784 qla2x00_status_cont_entry(ha, (sts_cont_entry_t *)pkt); 785 break; 786 case MS_IOCB_TYPE: 787 qla2x00_ms_entry(ha, (ms_iocb_entry_t *)pkt); 788 break; 789 default: 790 /* Type Not Supported. */ 791 DEBUG4(printk(KERN_WARNING 792 "scsi(%ld): Received unknown response pkt type %x " 793 "entry status=%x.\n", 794 ha->host_no, pkt->entry_type, pkt->entry_status)); 795 break; 796 } 797 ((response_t *)pkt)->signature = RESPONSE_PROCESSED; 798 wmb(); 799 } 800 801 /* Adjust ring index */ 802 WRT_REG_WORD(ISP_RSP_Q_OUT(ha, reg), ha->rsp_ring_index); 803 } 804 805 /** 806 * qla2x00_status_entry() - Process a Status IOCB entry. 807 * @ha: SCSI driver HA context 808 * @pkt: Entry pointer 809 */ 810 static void 811 qla2x00_status_entry(scsi_qla_host_t *ha, void *pkt) 812 { 813 srb_t *sp; 814 fc_port_t *fcport; 815 struct scsi_cmnd *cp; 816 sts_entry_t *sts; 817 struct sts_entry_24xx *sts24; 818 uint16_t comp_status; 819 uint16_t scsi_status; 820 uint8_t lscsi_status; 821 int32_t resid; 822 uint32_t sense_len, rsp_info_len, resid_len, fw_resid_len; 823 uint8_t *rsp_info, *sense_data; 824 825 sts = (sts_entry_t *) pkt; 826 sts24 = (struct sts_entry_24xx *) pkt; 827 if (IS_FWI2_CAPABLE(ha)) { 828 comp_status = le16_to_cpu(sts24->comp_status); 829 scsi_status = le16_to_cpu(sts24->scsi_status) & SS_MASK; 830 } else { 831 comp_status = le16_to_cpu(sts->comp_status); 832 scsi_status = le16_to_cpu(sts->scsi_status) & SS_MASK; 833 } 834 835 /* Fast path completion. */ 836 if (comp_status == CS_COMPLETE && scsi_status == 0) { 837 qla2x00_process_completed_request(ha, sts->handle); 838 839 return; 840 } 841 842 /* Validate handle. */ 843 if (sts->handle < MAX_OUTSTANDING_COMMANDS) { 844 sp = ha->outstanding_cmds[sts->handle]; 845 ha->outstanding_cmds[sts->handle] = NULL; 846 } else 847 sp = NULL; 848 849 if (sp == NULL) { 850 DEBUG2(printk("scsi(%ld): Status Entry invalid handle.\n", 851 ha->host_no)); 852 qla_printk(KERN_WARNING, ha, "Status Entry invalid handle.\n"); 853 854 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags); 855 qla2xxx_wake_dpc(ha); 856 return; 857 } 858 cp = sp->cmd; 859 if (cp == NULL) { 860 DEBUG2(printk("scsi(%ld): Command already returned back to OS " 861 "pkt->handle=%d sp=%p.\n", ha->host_no, sts->handle, sp)); 862 qla_printk(KERN_WARNING, ha, 863 "Command is NULL: already returned to OS (sp=%p)\n", sp); 864 865 return; 866 } 867 868 lscsi_status = scsi_status & STATUS_MASK; 869 CMD_ENTRY_STATUS(cp) = sts->entry_status; 870 CMD_COMPL_STATUS(cp) = comp_status; 871 CMD_SCSI_STATUS(cp) = scsi_status; 872 873 fcport = sp->fcport; 874 875 sense_len = rsp_info_len = resid_len = fw_resid_len = 0; 876 if (IS_FWI2_CAPABLE(ha)) { 877 sense_len = le32_to_cpu(sts24->sense_len); 878 rsp_info_len = le32_to_cpu(sts24->rsp_data_len); 879 resid_len = le32_to_cpu(sts24->rsp_residual_count); 880 fw_resid_len = le32_to_cpu(sts24->residual_len); 881 rsp_info = sts24->data; 882 sense_data = sts24->data; 883 host_to_fcp_swap(sts24->data, sizeof(sts24->data)); 884 } else { 885 sense_len = le16_to_cpu(sts->req_sense_length); 886 rsp_info_len = le16_to_cpu(sts->rsp_info_len); 887 resid_len = le32_to_cpu(sts->residual_length); 888 rsp_info = sts->rsp_info; 889 sense_data = sts->req_sense_data; 890 } 891 892 /* Check for any FCP transport errors. */ 893 if (scsi_status & SS_RESPONSE_INFO_LEN_VALID) { 894 /* Sense data lies beyond any FCP RESPONSE data. */ 895 if (IS_FWI2_CAPABLE(ha)) 896 sense_data += rsp_info_len; 897 if (rsp_info_len > 3 && rsp_info[3]) { 898 DEBUG2(printk("scsi(%ld:%d:%d:%d) FCP I/O protocol " 899 "failure (%x/%02x%02x%02x%02x%02x%02x%02x%02x)..." 900 "retrying command\n", ha->host_no, 901 cp->device->channel, cp->device->id, 902 cp->device->lun, rsp_info_len, rsp_info[0], 903 rsp_info[1], rsp_info[2], rsp_info[3], rsp_info[4], 904 rsp_info[5], rsp_info[6], rsp_info[7])); 905 906 cp->result = DID_BUS_BUSY << 16; 907 qla2x00_sp_compl(ha, sp); 908 return; 909 } 910 } 911 912 /* 913 * Based on Host and scsi status generate status code for Linux 914 */ 915 switch (comp_status) { 916 case CS_COMPLETE: 917 case CS_QUEUE_FULL: 918 if (scsi_status == 0) { 919 cp->result = DID_OK << 16; 920 break; 921 } 922 if (scsi_status & (SS_RESIDUAL_UNDER | SS_RESIDUAL_OVER)) { 923 resid = resid_len; 924 scsi_set_resid(cp, resid); 925 CMD_RESID_LEN(cp) = resid; 926 927 if (!lscsi_status && 928 ((unsigned)(scsi_bufflen(cp) - resid) < 929 cp->underflow)) { 930 qla_printk(KERN_INFO, ha, 931 "scsi(%ld:%d:%d:%d): Mid-layer underflow " 932 "detected (%x of %x bytes)...returning " 933 "error status.\n", ha->host_no, 934 cp->device->channel, cp->device->id, 935 cp->device->lun, resid, 936 scsi_bufflen(cp)); 937 938 cp->result = DID_ERROR << 16; 939 break; 940 } 941 } 942 cp->result = DID_OK << 16 | lscsi_status; 943 944 if (lscsi_status == SAM_STAT_TASK_SET_FULL) { 945 DEBUG2(printk(KERN_INFO 946 "scsi(%ld): QUEUE FULL status detected " 947 "0x%x-0x%x.\n", ha->host_no, comp_status, 948 scsi_status)); 949 950 /* Adjust queue depth for all luns on the port. */ 951 fcport->last_queue_full = jiffies; 952 starget_for_each_device(cp->device->sdev_target, 953 fcport, qla2x00_adjust_sdev_qdepth_down); 954 break; 955 } 956 if (lscsi_status != SS_CHECK_CONDITION) 957 break; 958 959 /* Copy Sense Data into sense buffer. */ 960 memset(cp->sense_buffer, 0, sizeof(cp->sense_buffer)); 961 962 if (!(scsi_status & SS_SENSE_LEN_VALID)) 963 break; 964 965 if (sense_len >= sizeof(cp->sense_buffer)) 966 sense_len = sizeof(cp->sense_buffer); 967 968 CMD_ACTUAL_SNSLEN(cp) = sense_len; 969 sp->request_sense_length = sense_len; 970 sp->request_sense_ptr = cp->sense_buffer; 971 972 if (sp->request_sense_length > 32) 973 sense_len = 32; 974 975 memcpy(cp->sense_buffer, sense_data, sense_len); 976 977 sp->request_sense_ptr += sense_len; 978 sp->request_sense_length -= sense_len; 979 if (sp->request_sense_length != 0) 980 ha->status_srb = sp; 981 982 DEBUG5(printk("%s(): Check condition Sense data, " 983 "scsi(%ld:%d:%d:%d) cmd=%p pid=%ld\n", __func__, 984 ha->host_no, cp->device->channel, cp->device->id, 985 cp->device->lun, cp, cp->serial_number)); 986 if (sense_len) 987 DEBUG5(qla2x00_dump_buffer(cp->sense_buffer, 988 CMD_ACTUAL_SNSLEN(cp))); 989 break; 990 991 case CS_DATA_UNDERRUN: 992 resid = resid_len; 993 /* Use F/W calculated residual length. */ 994 if (IS_FWI2_CAPABLE(ha)) 995 resid = fw_resid_len; 996 997 if (scsi_status & SS_RESIDUAL_UNDER) { 998 scsi_set_resid(cp, resid); 999 CMD_RESID_LEN(cp) = resid; 1000 } else { 1001 DEBUG2(printk(KERN_INFO 1002 "scsi(%ld:%d:%d) UNDERRUN status detected " 1003 "0x%x-0x%x. resid=0x%x fw_resid=0x%x cdb=0x%x " 1004 "os_underflow=0x%x\n", ha->host_no, 1005 cp->device->id, cp->device->lun, comp_status, 1006 scsi_status, resid_len, resid, cp->cmnd[0], 1007 cp->underflow)); 1008 1009 } 1010 1011 /* 1012 * Check to see if SCSI Status is non zero. If so report SCSI 1013 * Status. 1014 */ 1015 if (lscsi_status != 0) { 1016 cp->result = DID_OK << 16 | lscsi_status; 1017 1018 if (lscsi_status == SAM_STAT_TASK_SET_FULL) { 1019 DEBUG2(printk(KERN_INFO 1020 "scsi(%ld): QUEUE FULL status detected " 1021 "0x%x-0x%x.\n", ha->host_no, comp_status, 1022 scsi_status)); 1023 1024 /* 1025 * Adjust queue depth for all luns on the 1026 * port. 1027 */ 1028 fcport->last_queue_full = jiffies; 1029 starget_for_each_device( 1030 cp->device->sdev_target, fcport, 1031 qla2x00_adjust_sdev_qdepth_down); 1032 break; 1033 } 1034 if (lscsi_status != SS_CHECK_CONDITION) 1035 break; 1036 1037 /* Copy Sense Data into sense buffer */ 1038 memset(cp->sense_buffer, 0, sizeof(cp->sense_buffer)); 1039 1040 if (!(scsi_status & SS_SENSE_LEN_VALID)) 1041 break; 1042 1043 if (sense_len >= sizeof(cp->sense_buffer)) 1044 sense_len = sizeof(cp->sense_buffer); 1045 1046 CMD_ACTUAL_SNSLEN(cp) = sense_len; 1047 sp->request_sense_length = sense_len; 1048 sp->request_sense_ptr = cp->sense_buffer; 1049 1050 if (sp->request_sense_length > 32) 1051 sense_len = 32; 1052 1053 memcpy(cp->sense_buffer, sense_data, sense_len); 1054 1055 sp->request_sense_ptr += sense_len; 1056 sp->request_sense_length -= sense_len; 1057 if (sp->request_sense_length != 0) 1058 ha->status_srb = sp; 1059 1060 DEBUG5(printk("%s(): Check condition Sense data, " 1061 "scsi(%ld:%d:%d:%d) cmd=%p pid=%ld\n", 1062 __func__, ha->host_no, cp->device->channel, 1063 cp->device->id, cp->device->lun, cp, 1064 cp->serial_number)); 1065 1066 /* 1067 * In case of a Underrun condition, set both the lscsi 1068 * status and the completion status to appropriate 1069 * values. 1070 */ 1071 if (resid && 1072 ((unsigned)(scsi_bufflen(cp) - resid) < 1073 cp->underflow)) { 1074 DEBUG2(qla_printk(KERN_INFO, ha, 1075 "scsi(%ld:%d:%d:%d): Mid-layer underflow " 1076 "detected (%x of %x bytes)...returning " 1077 "error status.\n", ha->host_no, 1078 cp->device->channel, cp->device->id, 1079 cp->device->lun, resid, 1080 scsi_bufflen(cp))); 1081 1082 cp->result = DID_ERROR << 16 | lscsi_status; 1083 } 1084 1085 if (sense_len) 1086 DEBUG5(qla2x00_dump_buffer(cp->sense_buffer, 1087 CMD_ACTUAL_SNSLEN(cp))); 1088 } else { 1089 /* 1090 * If RISC reports underrun and target does not report 1091 * it then we must have a lost frame, so tell upper 1092 * layer to retry it by reporting a bus busy. 1093 */ 1094 if (!(scsi_status & SS_RESIDUAL_UNDER)) { 1095 DEBUG2(printk("scsi(%ld:%d:%d:%d) Dropped " 1096 "frame(s) detected (%x of %x bytes)..." 1097 "retrying command.\n", ha->host_no, 1098 cp->device->channel, cp->device->id, 1099 cp->device->lun, resid, 1100 scsi_bufflen(cp))); 1101 1102 cp->result = DID_BUS_BUSY << 16; 1103 break; 1104 } 1105 1106 /* Handle mid-layer underflow */ 1107 if ((unsigned)(scsi_bufflen(cp) - resid) < 1108 cp->underflow) { 1109 qla_printk(KERN_INFO, ha, 1110 "scsi(%ld:%d:%d:%d): Mid-layer underflow " 1111 "detected (%x of %x bytes)...returning " 1112 "error status.\n", ha->host_no, 1113 cp->device->channel, cp->device->id, 1114 cp->device->lun, resid, 1115 scsi_bufflen(cp)); 1116 1117 cp->result = DID_ERROR << 16; 1118 break; 1119 } 1120 1121 /* Everybody online, looking good... */ 1122 cp->result = DID_OK << 16; 1123 } 1124 break; 1125 1126 case CS_DATA_OVERRUN: 1127 DEBUG2(printk(KERN_INFO 1128 "scsi(%ld:%d:%d): OVERRUN status detected 0x%x-0x%x\n", 1129 ha->host_no, cp->device->id, cp->device->lun, comp_status, 1130 scsi_status)); 1131 DEBUG2(printk(KERN_INFO 1132 "CDB: 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x\n", 1133 cp->cmnd[0], cp->cmnd[1], cp->cmnd[2], cp->cmnd[3], 1134 cp->cmnd[4], cp->cmnd[5])); 1135 DEBUG2(printk(KERN_INFO 1136 "PID=0x%lx req=0x%x xtra=0x%x -- returning DID_ERROR " 1137 "status!\n", 1138 cp->serial_number, scsi_bufflen(cp), resid_len)); 1139 1140 cp->result = DID_ERROR << 16; 1141 break; 1142 1143 case CS_PORT_LOGGED_OUT: 1144 case CS_PORT_CONFIG_CHG: 1145 case CS_PORT_BUSY: 1146 case CS_INCOMPLETE: 1147 case CS_PORT_UNAVAILABLE: 1148 /* 1149 * If the port is in Target Down state, return all IOs for this 1150 * Target with DID_NO_CONNECT ELSE Queue the IOs in the 1151 * retry_queue. 1152 */ 1153 DEBUG2(printk("scsi(%ld:%d:%d): status_entry: Port Down " 1154 "pid=%ld, compl status=0x%x, port state=0x%x\n", 1155 ha->host_no, cp->device->id, cp->device->lun, 1156 cp->serial_number, comp_status, 1157 atomic_read(&fcport->state))); 1158 1159 cp->result = DID_BUS_BUSY << 16; 1160 if (atomic_read(&fcport->state) == FCS_ONLINE) { 1161 qla2x00_mark_device_lost(ha, fcport, 1, 1); 1162 } 1163 break; 1164 1165 case CS_RESET: 1166 DEBUG2(printk(KERN_INFO 1167 "scsi(%ld): RESET status detected 0x%x-0x%x.\n", 1168 ha->host_no, comp_status, scsi_status)); 1169 1170 cp->result = DID_RESET << 16; 1171 break; 1172 1173 case CS_ABORTED: 1174 /* 1175 * hv2.19.12 - DID_ABORT does not retry the request if we 1176 * aborted this request then abort otherwise it must be a 1177 * reset. 1178 */ 1179 DEBUG2(printk(KERN_INFO 1180 "scsi(%ld): ABORT status detected 0x%x-0x%x.\n", 1181 ha->host_no, comp_status, scsi_status)); 1182 1183 cp->result = DID_RESET << 16; 1184 break; 1185 1186 case CS_TIMEOUT: 1187 cp->result = DID_BUS_BUSY << 16; 1188 1189 if (IS_FWI2_CAPABLE(ha)) { 1190 DEBUG2(printk(KERN_INFO 1191 "scsi(%ld:%d:%d:%d): TIMEOUT status detected " 1192 "0x%x-0x%x\n", ha->host_no, cp->device->channel, 1193 cp->device->id, cp->device->lun, comp_status, 1194 scsi_status)); 1195 break; 1196 } 1197 DEBUG2(printk(KERN_INFO 1198 "scsi(%ld:%d:%d:%d): TIMEOUT status detected 0x%x-0x%x " 1199 "sflags=%x.\n", ha->host_no, cp->device->channel, 1200 cp->device->id, cp->device->lun, comp_status, scsi_status, 1201 le16_to_cpu(sts->status_flags))); 1202 1203 /* Check to see if logout occurred. */ 1204 if ((le16_to_cpu(sts->status_flags) & SF_LOGOUT_SENT)) 1205 qla2x00_mark_device_lost(ha, fcport, 1, 1); 1206 break; 1207 1208 default: 1209 DEBUG3(printk("scsi(%ld): Error detected (unknown status) " 1210 "0x%x-0x%x.\n", ha->host_no, comp_status, scsi_status)); 1211 qla_printk(KERN_INFO, ha, 1212 "Unknown status detected 0x%x-0x%x.\n", 1213 comp_status, scsi_status); 1214 1215 cp->result = DID_ERROR << 16; 1216 break; 1217 } 1218 1219 /* Place command on done queue. */ 1220 if (ha->status_srb == NULL) 1221 qla2x00_sp_compl(ha, sp); 1222 } 1223 1224 /** 1225 * qla2x00_status_cont_entry() - Process a Status Continuations entry. 1226 * @ha: SCSI driver HA context 1227 * @pkt: Entry pointer 1228 * 1229 * Extended sense data. 1230 */ 1231 static void 1232 qla2x00_status_cont_entry(scsi_qla_host_t *ha, sts_cont_entry_t *pkt) 1233 { 1234 uint8_t sense_sz = 0; 1235 srb_t *sp = ha->status_srb; 1236 struct scsi_cmnd *cp; 1237 1238 if (sp != NULL && sp->request_sense_length != 0) { 1239 cp = sp->cmd; 1240 if (cp == NULL) { 1241 DEBUG2(printk("%s(): Cmd already returned back to OS " 1242 "sp=%p.\n", __func__, sp)); 1243 qla_printk(KERN_INFO, ha, 1244 "cmd is NULL: already returned to OS (sp=%p)\n", 1245 sp); 1246 1247 ha->status_srb = NULL; 1248 return; 1249 } 1250 1251 if (sp->request_sense_length > sizeof(pkt->data)) { 1252 sense_sz = sizeof(pkt->data); 1253 } else { 1254 sense_sz = sp->request_sense_length; 1255 } 1256 1257 /* Move sense data. */ 1258 if (IS_FWI2_CAPABLE(ha)) 1259 host_to_fcp_swap(pkt->data, sizeof(pkt->data)); 1260 memcpy(sp->request_sense_ptr, pkt->data, sense_sz); 1261 DEBUG5(qla2x00_dump_buffer(sp->request_sense_ptr, sense_sz)); 1262 1263 sp->request_sense_ptr += sense_sz; 1264 sp->request_sense_length -= sense_sz; 1265 1266 /* Place command on done queue. */ 1267 if (sp->request_sense_length == 0) { 1268 ha->status_srb = NULL; 1269 qla2x00_sp_compl(ha, sp); 1270 } 1271 } 1272 } 1273 1274 /** 1275 * qla2x00_error_entry() - Process an error entry. 1276 * @ha: SCSI driver HA context 1277 * @pkt: Entry pointer 1278 */ 1279 static void 1280 qla2x00_error_entry(scsi_qla_host_t *ha, sts_entry_t *pkt) 1281 { 1282 srb_t *sp; 1283 1284 #if defined(QL_DEBUG_LEVEL_2) 1285 if (pkt->entry_status & RF_INV_E_ORDER) 1286 qla_printk(KERN_ERR, ha, "%s: Invalid Entry Order\n", __func__); 1287 else if (pkt->entry_status & RF_INV_E_COUNT) 1288 qla_printk(KERN_ERR, ha, "%s: Invalid Entry Count\n", __func__); 1289 else if (pkt->entry_status & RF_INV_E_PARAM) 1290 qla_printk(KERN_ERR, ha, 1291 "%s: Invalid Entry Parameter\n", __func__); 1292 else if (pkt->entry_status & RF_INV_E_TYPE) 1293 qla_printk(KERN_ERR, ha, "%s: Invalid Entry Type\n", __func__); 1294 else if (pkt->entry_status & RF_BUSY) 1295 qla_printk(KERN_ERR, ha, "%s: Busy\n", __func__); 1296 else 1297 qla_printk(KERN_ERR, ha, "%s: UNKNOWN flag error\n", __func__); 1298 #endif 1299 1300 /* Validate handle. */ 1301 if (pkt->handle < MAX_OUTSTANDING_COMMANDS) 1302 sp = ha->outstanding_cmds[pkt->handle]; 1303 else 1304 sp = NULL; 1305 1306 if (sp) { 1307 /* Free outstanding command slot. */ 1308 ha->outstanding_cmds[pkt->handle] = NULL; 1309 1310 /* Bad payload or header */ 1311 if (pkt->entry_status & 1312 (RF_INV_E_ORDER | RF_INV_E_COUNT | 1313 RF_INV_E_PARAM | RF_INV_E_TYPE)) { 1314 sp->cmd->result = DID_ERROR << 16; 1315 } else if (pkt->entry_status & RF_BUSY) { 1316 sp->cmd->result = DID_BUS_BUSY << 16; 1317 } else { 1318 sp->cmd->result = DID_ERROR << 16; 1319 } 1320 qla2x00_sp_compl(ha, sp); 1321 1322 } else if (pkt->entry_type == COMMAND_A64_TYPE || pkt->entry_type == 1323 COMMAND_TYPE || pkt->entry_type == COMMAND_TYPE_7) { 1324 DEBUG2(printk("scsi(%ld): Error entry - invalid handle\n", 1325 ha->host_no)); 1326 qla_printk(KERN_WARNING, ha, 1327 "Error entry - invalid handle\n"); 1328 1329 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags); 1330 qla2xxx_wake_dpc(ha); 1331 } 1332 } 1333 1334 /** 1335 * qla2x00_ms_entry() - Process a Management Server entry. 1336 * @ha: SCSI driver HA context 1337 * @index: Response queue out pointer 1338 */ 1339 static void 1340 qla2x00_ms_entry(scsi_qla_host_t *ha, ms_iocb_entry_t *pkt) 1341 { 1342 srb_t *sp; 1343 1344 DEBUG3(printk("%s(%ld): pkt=%p pkthandle=%d.\n", 1345 __func__, ha->host_no, pkt, pkt->handle1)); 1346 1347 /* Validate handle. */ 1348 if (pkt->handle1 < MAX_OUTSTANDING_COMMANDS) 1349 sp = ha->outstanding_cmds[pkt->handle1]; 1350 else 1351 sp = NULL; 1352 1353 if (sp == NULL) { 1354 DEBUG2(printk("scsi(%ld): MS entry - invalid handle\n", 1355 ha->host_no)); 1356 qla_printk(KERN_WARNING, ha, "MS entry - invalid handle\n"); 1357 1358 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags); 1359 return; 1360 } 1361 1362 CMD_COMPL_STATUS(sp->cmd) = le16_to_cpu(pkt->status); 1363 CMD_ENTRY_STATUS(sp->cmd) = pkt->entry_status; 1364 1365 /* Free outstanding command slot. */ 1366 ha->outstanding_cmds[pkt->handle1] = NULL; 1367 1368 qla2x00_sp_compl(ha, sp); 1369 } 1370 1371 1372 /** 1373 * qla24xx_mbx_completion() - Process mailbox command completions. 1374 * @ha: SCSI driver HA context 1375 * @mb0: Mailbox0 register 1376 */ 1377 static void 1378 qla24xx_mbx_completion(scsi_qla_host_t *ha, uint16_t mb0) 1379 { 1380 uint16_t cnt; 1381 uint16_t __iomem *wptr; 1382 struct device_reg_24xx __iomem *reg = &ha->iobase->isp24; 1383 1384 /* Load return mailbox registers. */ 1385 ha->flags.mbox_int = 1; 1386 ha->mailbox_out[0] = mb0; 1387 wptr = (uint16_t __iomem *)®->mailbox1; 1388 1389 for (cnt = 1; cnt < ha->mbx_count; cnt++) { 1390 ha->mailbox_out[cnt] = RD_REG_WORD(wptr); 1391 wptr++; 1392 } 1393 1394 if (ha->mcp) { 1395 DEBUG3(printk("%s(%ld): Got mailbox completion. cmd=%x.\n", 1396 __func__, ha->host_no, ha->mcp->mb[0])); 1397 } else { 1398 DEBUG2_3(printk("%s(%ld): MBX pointer ERROR!\n", 1399 __func__, ha->host_no)); 1400 } 1401 } 1402 1403 /** 1404 * qla24xx_process_response_queue() - Process response queue entries. 1405 * @ha: SCSI driver HA context 1406 */ 1407 void 1408 qla24xx_process_response_queue(struct scsi_qla_host *ha) 1409 { 1410 struct device_reg_24xx __iomem *reg = &ha->iobase->isp24; 1411 struct sts_entry_24xx *pkt; 1412 1413 if (!ha->flags.online) 1414 return; 1415 1416 while (ha->response_ring_ptr->signature != RESPONSE_PROCESSED) { 1417 pkt = (struct sts_entry_24xx *)ha->response_ring_ptr; 1418 1419 ha->rsp_ring_index++; 1420 if (ha->rsp_ring_index == ha->response_q_length) { 1421 ha->rsp_ring_index = 0; 1422 ha->response_ring_ptr = ha->response_ring; 1423 } else { 1424 ha->response_ring_ptr++; 1425 } 1426 1427 if (pkt->entry_status != 0) { 1428 DEBUG3(printk(KERN_INFO 1429 "scsi(%ld): Process error entry.\n", ha->host_no)); 1430 1431 qla2x00_error_entry(ha, (sts_entry_t *) pkt); 1432 ((response_t *)pkt)->signature = RESPONSE_PROCESSED; 1433 wmb(); 1434 continue; 1435 } 1436 1437 switch (pkt->entry_type) { 1438 case STATUS_TYPE: 1439 qla2x00_status_entry(ha, pkt); 1440 break; 1441 case STATUS_CONT_TYPE: 1442 qla2x00_status_cont_entry(ha, (sts_cont_entry_t *)pkt); 1443 break; 1444 case MS_IOCB_TYPE: 1445 qla24xx_ms_entry(ha, (struct ct_entry_24xx *)pkt); 1446 break; 1447 case VP_RPT_ID_IOCB_TYPE: 1448 qla24xx_report_id_acquisition(ha, 1449 (struct vp_rpt_id_entry_24xx *)pkt); 1450 break; 1451 default: 1452 /* Type Not Supported. */ 1453 DEBUG4(printk(KERN_WARNING 1454 "scsi(%ld): Received unknown response pkt type %x " 1455 "entry status=%x.\n", 1456 ha->host_no, pkt->entry_type, pkt->entry_status)); 1457 break; 1458 } 1459 ((response_t *)pkt)->signature = RESPONSE_PROCESSED; 1460 wmb(); 1461 } 1462 1463 /* Adjust ring index */ 1464 WRT_REG_DWORD(®->rsp_q_out, ha->rsp_ring_index); 1465 } 1466 1467 /** 1468 * qla24xx_intr_handler() - Process interrupts for the ISP23xx and ISP63xx. 1469 * @irq: 1470 * @dev_id: SCSI driver HA context 1471 * 1472 * Called by system whenever the host adapter generates an interrupt. 1473 * 1474 * Returns handled flag. 1475 */ 1476 irqreturn_t 1477 qla24xx_intr_handler(int irq, void *dev_id) 1478 { 1479 scsi_qla_host_t *ha; 1480 struct device_reg_24xx __iomem *reg; 1481 int status; 1482 unsigned long flags; 1483 unsigned long iter; 1484 uint32_t stat; 1485 uint32_t hccr; 1486 uint16_t mb[4]; 1487 1488 ha = (scsi_qla_host_t *) dev_id; 1489 if (!ha) { 1490 printk(KERN_INFO 1491 "%s(): NULL host pointer\n", __func__); 1492 return IRQ_NONE; 1493 } 1494 1495 reg = &ha->iobase->isp24; 1496 status = 0; 1497 1498 spin_lock_irqsave(&ha->hardware_lock, flags); 1499 for (iter = 50; iter--; ) { 1500 stat = RD_REG_DWORD(®->host_status); 1501 if (stat & HSRX_RISC_PAUSED) { 1502 hccr = RD_REG_DWORD(®->hccr); 1503 1504 qla_printk(KERN_INFO, ha, "RISC paused -- HCCR=%x, " 1505 "Dumping firmware!\n", hccr); 1506 ha->isp_ops->fw_dump(ha, 1); 1507 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags); 1508 break; 1509 } else if ((stat & HSRX_RISC_INT) == 0) 1510 break; 1511 1512 switch (stat & 0xff) { 1513 case 0x1: 1514 case 0x2: 1515 case 0x10: 1516 case 0x11: 1517 qla24xx_mbx_completion(ha, MSW(stat)); 1518 status |= MBX_INTERRUPT; 1519 1520 break; 1521 case 0x12: 1522 mb[0] = MSW(stat); 1523 mb[1] = RD_REG_WORD(®->mailbox1); 1524 mb[2] = RD_REG_WORD(®->mailbox2); 1525 mb[3] = RD_REG_WORD(®->mailbox3); 1526 qla2x00_async_event(ha, mb); 1527 break; 1528 case 0x13: 1529 qla24xx_process_response_queue(ha); 1530 break; 1531 default: 1532 DEBUG2(printk("scsi(%ld): Unrecognized interrupt type " 1533 "(%d).\n", 1534 ha->host_no, stat & 0xff)); 1535 break; 1536 } 1537 WRT_REG_DWORD(®->hccr, HCCRX_CLR_RISC_INT); 1538 RD_REG_DWORD_RELAXED(®->hccr); 1539 } 1540 spin_unlock_irqrestore(&ha->hardware_lock, flags); 1541 1542 if (test_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags) && 1543 (status & MBX_INTERRUPT) && ha->flags.mbox_int) { 1544 set_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags); 1545 up(&ha->mbx_intr_sem); 1546 } 1547 1548 return IRQ_HANDLED; 1549 } 1550 1551 /** 1552 * qla24xx_ms_entry() - Process a Management Server entry. 1553 * @ha: SCSI driver HA context 1554 * @index: Response queue out pointer 1555 */ 1556 static void 1557 qla24xx_ms_entry(scsi_qla_host_t *ha, struct ct_entry_24xx *pkt) 1558 { 1559 srb_t *sp; 1560 1561 DEBUG3(printk("%s(%ld): pkt=%p pkthandle=%d.\n", 1562 __func__, ha->host_no, pkt, pkt->handle)); 1563 1564 DEBUG9(printk("%s: ct pkt dump:\n", __func__)); 1565 DEBUG9(qla2x00_dump_buffer((void *)pkt, sizeof(struct ct_entry_24xx))); 1566 1567 /* Validate handle. */ 1568 if (pkt->handle < MAX_OUTSTANDING_COMMANDS) 1569 sp = ha->outstanding_cmds[pkt->handle]; 1570 else 1571 sp = NULL; 1572 1573 if (sp == NULL) { 1574 DEBUG2(printk("scsi(%ld): MS entry - invalid handle\n", 1575 ha->host_no)); 1576 DEBUG10(printk("scsi(%ld): MS entry - invalid handle\n", 1577 ha->host_no)); 1578 qla_printk(KERN_WARNING, ha, "MS entry - invalid handle %d\n", 1579 pkt->handle); 1580 1581 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags); 1582 return; 1583 } 1584 1585 CMD_COMPL_STATUS(sp->cmd) = le16_to_cpu(pkt->comp_status); 1586 CMD_ENTRY_STATUS(sp->cmd) = pkt->entry_status; 1587 1588 /* Free outstanding command slot. */ 1589 ha->outstanding_cmds[pkt->handle] = NULL; 1590 1591 qla2x00_sp_compl(ha, sp); 1592 } 1593 1594 static irqreturn_t 1595 qla24xx_msix_rsp_q(int irq, void *dev_id) 1596 { 1597 scsi_qla_host_t *ha; 1598 struct device_reg_24xx __iomem *reg; 1599 unsigned long flags; 1600 1601 ha = dev_id; 1602 reg = &ha->iobase->isp24; 1603 1604 spin_lock_irqsave(&ha->hardware_lock, flags); 1605 1606 qla24xx_process_response_queue(ha); 1607 1608 WRT_REG_DWORD(®->hccr, HCCRX_CLR_RISC_INT); 1609 RD_REG_DWORD_RELAXED(®->hccr); 1610 1611 spin_unlock_irqrestore(&ha->hardware_lock, flags); 1612 1613 return IRQ_HANDLED; 1614 } 1615 1616 static irqreturn_t 1617 qla24xx_msix_default(int irq, void *dev_id) 1618 { 1619 scsi_qla_host_t *ha; 1620 struct device_reg_24xx __iomem *reg; 1621 int status; 1622 unsigned long flags; 1623 unsigned long iter; 1624 uint32_t stat; 1625 uint32_t hccr; 1626 uint16_t mb[4]; 1627 1628 ha = dev_id; 1629 reg = &ha->iobase->isp24; 1630 status = 0; 1631 1632 spin_lock_irqsave(&ha->hardware_lock, flags); 1633 for (iter = 50; iter--; ) { 1634 stat = RD_REG_DWORD(®->host_status); 1635 if (stat & HSRX_RISC_PAUSED) { 1636 hccr = RD_REG_DWORD(®->hccr); 1637 1638 qla_printk(KERN_INFO, ha, "RISC paused -- HCCR=%x, " 1639 "Dumping firmware!\n", hccr); 1640 ha->isp_ops->fw_dump(ha, 1); 1641 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags); 1642 break; 1643 } else if ((stat & HSRX_RISC_INT) == 0) 1644 break; 1645 1646 switch (stat & 0xff) { 1647 case 0x1: 1648 case 0x2: 1649 case 0x10: 1650 case 0x11: 1651 qla24xx_mbx_completion(ha, MSW(stat)); 1652 status |= MBX_INTERRUPT; 1653 1654 break; 1655 case 0x12: 1656 mb[0] = MSW(stat); 1657 mb[1] = RD_REG_WORD(®->mailbox1); 1658 mb[2] = RD_REG_WORD(®->mailbox2); 1659 mb[3] = RD_REG_WORD(®->mailbox3); 1660 qla2x00_async_event(ha, mb); 1661 break; 1662 case 0x13: 1663 qla24xx_process_response_queue(ha); 1664 break; 1665 default: 1666 DEBUG2(printk("scsi(%ld): Unrecognized interrupt type " 1667 "(%d).\n", 1668 ha->host_no, stat & 0xff)); 1669 break; 1670 } 1671 WRT_REG_DWORD(®->hccr, HCCRX_CLR_RISC_INT); 1672 RD_REG_DWORD_RELAXED(®->hccr); 1673 } 1674 spin_unlock_irqrestore(&ha->hardware_lock, flags); 1675 1676 if (test_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags) && 1677 (status & MBX_INTERRUPT) && ha->flags.mbox_int) { 1678 set_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags); 1679 up(&ha->mbx_intr_sem); 1680 } 1681 1682 return IRQ_HANDLED; 1683 } 1684 1685 /* Interrupt handling helpers. */ 1686 1687 struct qla_init_msix_entry { 1688 uint16_t entry; 1689 uint16_t index; 1690 const char *name; 1691 irq_handler_t handler; 1692 }; 1693 1694 static struct qla_init_msix_entry imsix_entries[QLA_MSIX_ENTRIES] = { 1695 { QLA_MSIX_DEFAULT, QLA_MIDX_DEFAULT, 1696 "qla2xxx (default)", qla24xx_msix_default }, 1697 1698 { QLA_MSIX_RSP_Q, QLA_MIDX_RSP_Q, 1699 "qla2xxx (rsp_q)", qla24xx_msix_rsp_q }, 1700 }; 1701 1702 static void 1703 qla24xx_disable_msix(scsi_qla_host_t *ha) 1704 { 1705 int i; 1706 struct qla_msix_entry *qentry; 1707 1708 for (i = 0; i < QLA_MSIX_ENTRIES; i++) { 1709 qentry = &ha->msix_entries[imsix_entries[i].index]; 1710 if (qentry->have_irq) 1711 free_irq(qentry->msix_vector, ha); 1712 } 1713 pci_disable_msix(ha->pdev); 1714 } 1715 1716 static int 1717 qla24xx_enable_msix(scsi_qla_host_t *ha) 1718 { 1719 int i, ret; 1720 struct msix_entry entries[QLA_MSIX_ENTRIES]; 1721 struct qla_msix_entry *qentry; 1722 1723 for (i = 0; i < QLA_MSIX_ENTRIES; i++) 1724 entries[i].entry = imsix_entries[i].entry; 1725 1726 ret = pci_enable_msix(ha->pdev, entries, ARRAY_SIZE(entries)); 1727 if (ret) { 1728 qla_printk(KERN_WARNING, ha, 1729 "MSI-X: Failed to enable support -- %d/%d\n", 1730 QLA_MSIX_ENTRIES, ret); 1731 goto msix_out; 1732 } 1733 ha->flags.msix_enabled = 1; 1734 1735 for (i = 0; i < QLA_MSIX_ENTRIES; i++) { 1736 qentry = &ha->msix_entries[imsix_entries[i].index]; 1737 qentry->msix_vector = entries[i].vector; 1738 qentry->msix_entry = entries[i].entry; 1739 qentry->have_irq = 0; 1740 ret = request_irq(qentry->msix_vector, 1741 imsix_entries[i].handler, 0, imsix_entries[i].name, ha); 1742 if (ret) { 1743 qla_printk(KERN_WARNING, ha, 1744 "MSI-X: Unable to register handler -- %x/%d.\n", 1745 imsix_entries[i].index, ret); 1746 qla24xx_disable_msix(ha); 1747 goto msix_out; 1748 } 1749 qentry->have_irq = 1; 1750 } 1751 1752 msix_out: 1753 return ret; 1754 } 1755 1756 int 1757 qla2x00_request_irqs(scsi_qla_host_t *ha) 1758 { 1759 int ret; 1760 1761 /* If possible, enable MSI-X. */ 1762 if (!IS_QLA2432(ha) && !IS_QLA2532(ha)) 1763 goto skip_msix; 1764 1765 if (IS_QLA2432(ha) && (ha->chip_revision < QLA_MSIX_CHIP_REV_24XX || 1766 !QLA_MSIX_FW_MODE_1(ha->fw_attributes))) { 1767 DEBUG2(qla_printk(KERN_WARNING, ha, 1768 "MSI-X: Unsupported ISP2432 (0x%X, 0x%X).\n", 1769 ha->chip_revision, ha->fw_attributes)); 1770 1771 goto skip_msix; 1772 } 1773 1774 ret = qla24xx_enable_msix(ha); 1775 if (!ret) { 1776 DEBUG2(qla_printk(KERN_INFO, ha, 1777 "MSI-X: Enabled (0x%X, 0x%X).\n", ha->chip_revision, 1778 ha->fw_attributes)); 1779 return ret; 1780 } 1781 qla_printk(KERN_WARNING, ha, 1782 "MSI-X: Falling back-to INTa mode -- %d.\n", ret); 1783 skip_msix: 1784 1785 if (!IS_QLA24XX(ha) && !IS_QLA2532(ha)) 1786 goto skip_msi; 1787 1788 ret = pci_enable_msi(ha->pdev); 1789 if (!ret) { 1790 DEBUG2(qla_printk(KERN_INFO, ha, "MSI: Enabled.\n")); 1791 ha->flags.msi_enabled = 1; 1792 } 1793 skip_msi: 1794 1795 ret = request_irq(ha->pdev->irq, ha->isp_ops->intr_handler, 1796 IRQF_DISABLED|IRQF_SHARED, QLA2XXX_DRIVER_NAME, ha); 1797 if (!ret) { 1798 ha->flags.inta_enabled = 1; 1799 ha->host->irq = ha->pdev->irq; 1800 } else { 1801 qla_printk(KERN_WARNING, ha, 1802 "Failed to reserve interrupt %d already in use.\n", 1803 ha->pdev->irq); 1804 } 1805 1806 return ret; 1807 } 1808 1809 void 1810 qla2x00_free_irqs(scsi_qla_host_t *ha) 1811 { 1812 1813 if (ha->flags.msix_enabled) 1814 qla24xx_disable_msix(ha); 1815 else if (ha->flags.inta_enabled) { 1816 free_irq(ha->host->irq, ha); 1817 pci_disable_msi(ha->pdev); 1818 } 1819 } 1820