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