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 <linux/delay.h> 10 11 static void 12 qla2x00_mbx_sem_timeout(unsigned long data) 13 { 14 struct semaphore *sem_ptr = (struct semaphore *)data; 15 16 DEBUG11(printk("qla2x00_sem_timeout: entered.\n")); 17 18 if (sem_ptr != NULL) { 19 up(sem_ptr); 20 } 21 22 DEBUG11(printk("qla2x00_mbx_sem_timeout: exiting.\n")); 23 } 24 25 /* 26 * qla2x00_mailbox_command 27 * Issue mailbox command and waits for completion. 28 * 29 * Input: 30 * ha = adapter block pointer. 31 * mcp = driver internal mbx struct pointer. 32 * 33 * Output: 34 * mb[MAX_MAILBOX_REGISTER_COUNT] = returned mailbox data. 35 * 36 * Returns: 37 * 0 : QLA_SUCCESS = cmd performed success 38 * 1 : QLA_FUNCTION_FAILED (error encountered) 39 * 6 : QLA_FUNCTION_TIMEOUT (timeout condition encountered) 40 * 41 * Context: 42 * Kernel context. 43 */ 44 static int 45 qla2x00_mailbox_command(scsi_qla_host_t *pvha, mbx_cmd_t *mcp) 46 { 47 int rval; 48 unsigned long flags = 0; 49 device_reg_t __iomem *reg; 50 struct timer_list tmp_intr_timer; 51 uint8_t abort_active; 52 uint8_t io_lock_on; 53 uint16_t command; 54 uint16_t *iptr; 55 uint16_t __iomem *optr; 56 uint32_t cnt; 57 uint32_t mboxes; 58 unsigned long wait_time; 59 scsi_qla_host_t *ha = to_qla_parent(pvha); 60 61 reg = ha->iobase; 62 io_lock_on = ha->flags.init_done; 63 64 rval = QLA_SUCCESS; 65 abort_active = test_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags); 66 67 DEBUG11(printk("%s(%ld): entered.\n", __func__, pvha->host_no)); 68 69 /* 70 * Wait for active mailbox commands to finish by waiting at most tov 71 * seconds. This is to serialize actual issuing of mailbox cmds during 72 * non ISP abort time. 73 */ 74 if (!abort_active) { 75 if (qla2x00_down_timeout(&ha->mbx_cmd_sem, mcp->tov * HZ)) { 76 /* Timeout occurred. Return error. */ 77 DEBUG2_3_11(printk("%s(%ld): cmd access timeout. " 78 "Exiting.\n", __func__, ha->host_no)); 79 return QLA_FUNCTION_TIMEOUT; 80 } 81 } 82 83 ha->flags.mbox_busy = 1; 84 /* Save mailbox command for debug */ 85 ha->mcp = mcp; 86 87 DEBUG11(printk("scsi(%ld): prepare to issue mbox cmd=0x%x.\n", 88 ha->host_no, mcp->mb[0])); 89 90 spin_lock_irqsave(&ha->hardware_lock, flags); 91 92 /* Load mailbox registers. */ 93 if (IS_FWI2_CAPABLE(ha)) 94 optr = (uint16_t __iomem *)®->isp24.mailbox0; 95 else 96 optr = (uint16_t __iomem *)MAILBOX_REG(ha, ®->isp, 0); 97 98 iptr = mcp->mb; 99 command = mcp->mb[0]; 100 mboxes = mcp->out_mb; 101 102 for (cnt = 0; cnt < ha->mbx_count; cnt++) { 103 if (IS_QLA2200(ha) && cnt == 8) 104 optr = 105 (uint16_t __iomem *)MAILBOX_REG(ha, ®->isp, 8); 106 if (mboxes & BIT_0) 107 WRT_REG_WORD(optr, *iptr); 108 109 mboxes >>= 1; 110 optr++; 111 iptr++; 112 } 113 114 #if defined(QL_DEBUG_LEVEL_1) 115 printk("%s(%ld): Loaded MBX registers (displayed in bytes) = \n", 116 __func__, ha->host_no); 117 qla2x00_dump_buffer((uint8_t *)mcp->mb, 16); 118 printk("\n"); 119 qla2x00_dump_buffer(((uint8_t *)mcp->mb + 0x10), 16); 120 printk("\n"); 121 qla2x00_dump_buffer(((uint8_t *)mcp->mb + 0x20), 8); 122 printk("\n"); 123 printk("%s(%ld): I/O address = %p.\n", __func__, ha->host_no, optr); 124 qla2x00_dump_regs(ha); 125 #endif 126 127 /* Issue set host interrupt command to send cmd out. */ 128 ha->flags.mbox_int = 0; 129 clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags); 130 131 /* Unlock mbx registers and wait for interrupt */ 132 DEBUG11(printk("%s(%ld): going to unlock irq & waiting for interrupt. " 133 "jiffies=%lx.\n", __func__, ha->host_no, jiffies)); 134 135 /* Wait for mbx cmd completion until timeout */ 136 137 if (!abort_active && io_lock_on) { 138 /* sleep on completion semaphore */ 139 DEBUG11(printk("%s(%ld): INTERRUPT MODE. Initializing timer.\n", 140 __func__, ha->host_no)); 141 142 init_timer(&tmp_intr_timer); 143 tmp_intr_timer.data = (unsigned long)&ha->mbx_intr_sem; 144 tmp_intr_timer.expires = jiffies + mcp->tov * HZ; 145 tmp_intr_timer.function = 146 (void (*)(unsigned long))qla2x00_mbx_sem_timeout; 147 148 DEBUG11(printk("%s(%ld): Adding timer.\n", __func__, 149 ha->host_no)); 150 add_timer(&tmp_intr_timer); 151 152 DEBUG11(printk("%s(%ld): going to unlock & sleep. " 153 "time=0x%lx.\n", __func__, ha->host_no, jiffies)); 154 155 set_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags); 156 157 if (IS_FWI2_CAPABLE(ha)) 158 WRT_REG_DWORD(®->isp24.hccr, HCCRX_SET_HOST_INT); 159 else 160 WRT_REG_WORD(®->isp.hccr, HCCR_SET_HOST_INT); 161 spin_unlock_irqrestore(&ha->hardware_lock, flags); 162 163 /* Wait for either the timer to expire 164 * or the mbox completion interrupt 165 */ 166 down(&ha->mbx_intr_sem); 167 168 DEBUG11(printk("%s(%ld): waking up. time=0x%lx\n", __func__, 169 ha->host_no, jiffies)); 170 clear_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags); 171 172 /* delete the timer */ 173 del_timer(&tmp_intr_timer); 174 } else { 175 DEBUG3_11(printk("%s(%ld): cmd=%x POLLING MODE.\n", __func__, 176 ha->host_no, command)); 177 178 if (IS_FWI2_CAPABLE(ha)) 179 WRT_REG_DWORD(®->isp24.hccr, HCCRX_SET_HOST_INT); 180 else 181 WRT_REG_WORD(®->isp.hccr, HCCR_SET_HOST_INT); 182 spin_unlock_irqrestore(&ha->hardware_lock, flags); 183 184 wait_time = jiffies + mcp->tov * HZ; /* wait at most tov secs */ 185 while (!ha->flags.mbox_int) { 186 if (time_after(jiffies, wait_time)) 187 break; 188 189 /* Check for pending interrupts. */ 190 qla2x00_poll(ha); 191 192 if (command != MBC_LOAD_RISC_RAM_EXTENDED && 193 !ha->flags.mbox_int) 194 msleep(10); 195 } /* while */ 196 } 197 198 /* Check whether we timed out */ 199 if (ha->flags.mbox_int) { 200 uint16_t *iptr2; 201 202 DEBUG3_11(printk("%s(%ld): cmd %x completed.\n", __func__, 203 ha->host_no, command)); 204 205 /* Got interrupt. Clear the flag. */ 206 ha->flags.mbox_int = 0; 207 clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags); 208 209 if (ha->mailbox_out[0] != MBS_COMMAND_COMPLETE) 210 rval = QLA_FUNCTION_FAILED; 211 212 /* Load return mailbox registers. */ 213 iptr2 = mcp->mb; 214 iptr = (uint16_t *)&ha->mailbox_out[0]; 215 mboxes = mcp->in_mb; 216 for (cnt = 0; cnt < ha->mbx_count; cnt++) { 217 if (mboxes & BIT_0) 218 *iptr2 = *iptr; 219 220 mboxes >>= 1; 221 iptr2++; 222 iptr++; 223 } 224 } else { 225 226 #if defined(QL_DEBUG_LEVEL_2) || defined(QL_DEBUG_LEVEL_3) || \ 227 defined(QL_DEBUG_LEVEL_11) 228 uint16_t mb0; 229 uint32_t ictrl; 230 231 if (IS_FWI2_CAPABLE(ha)) { 232 mb0 = RD_REG_WORD(®->isp24.mailbox0); 233 ictrl = RD_REG_DWORD(®->isp24.ictrl); 234 } else { 235 mb0 = RD_MAILBOX_REG(ha, ®->isp, 0); 236 ictrl = RD_REG_WORD(®->isp.ictrl); 237 } 238 printk("%s(%ld): **** MB Command Timeout for cmd %x ****\n", 239 __func__, ha->host_no, command); 240 printk("%s(%ld): icontrol=%x jiffies=%lx\n", __func__, 241 ha->host_no, ictrl, jiffies); 242 printk("%s(%ld): *** mailbox[0] = 0x%x ***\n", __func__, 243 ha->host_no, mb0); 244 qla2x00_dump_regs(ha); 245 #endif 246 247 rval = QLA_FUNCTION_TIMEOUT; 248 } 249 250 ha->flags.mbox_busy = 0; 251 252 /* Clean up */ 253 ha->mcp = NULL; 254 255 if (!abort_active) { 256 DEBUG11(printk("%s(%ld): checking for additional resp " 257 "interrupt.\n", __func__, ha->host_no)); 258 259 /* polling mode for non isp_abort commands. */ 260 qla2x00_poll(ha); 261 } 262 263 if (rval == QLA_FUNCTION_TIMEOUT && 264 mcp->mb[0] != MBC_GEN_SYSTEM_ERROR) { 265 if (!io_lock_on || (mcp->flags & IOCTL_CMD)) { 266 /* not in dpc. schedule it for dpc to take over. */ 267 DEBUG(printk("%s(%ld): timeout schedule " 268 "isp_abort_needed.\n", __func__, ha->host_no)); 269 DEBUG2_3_11(printk("%s(%ld): timeout schedule " 270 "isp_abort_needed.\n", __func__, ha->host_no)); 271 qla_printk(KERN_WARNING, ha, 272 "Mailbox command timeout occured. Scheduling ISP " 273 "abort.\n"); 274 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags); 275 qla2xxx_wake_dpc(ha); 276 } else if (!abort_active) { 277 /* call abort directly since we are in the DPC thread */ 278 DEBUG(printk("%s(%ld): timeout calling abort_isp\n", 279 __func__, ha->host_no)); 280 DEBUG2_3_11(printk("%s(%ld): timeout calling " 281 "abort_isp\n", __func__, ha->host_no)); 282 qla_printk(KERN_WARNING, ha, 283 "Mailbox command timeout occured. Issuing ISP " 284 "abort.\n"); 285 286 set_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags); 287 clear_bit(ISP_ABORT_NEEDED, &ha->dpc_flags); 288 if (qla2x00_abort_isp(ha)) { 289 /* Failed. retry later. */ 290 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags); 291 } 292 clear_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags); 293 DEBUG(printk("%s(%ld): finished abort_isp\n", __func__, 294 ha->host_no)); 295 DEBUG2_3_11(printk("%s(%ld): finished abort_isp\n", 296 __func__, ha->host_no)); 297 } 298 } 299 300 /* Allow next mbx cmd to come in. */ 301 if (!abort_active) 302 up(&ha->mbx_cmd_sem); 303 304 if (rval) { 305 DEBUG2_3_11(printk("%s(%ld): **** FAILED. mbx0=%x, mbx1=%x, " 306 "mbx2=%x, cmd=%x ****\n", __func__, ha->host_no, 307 mcp->mb[0], mcp->mb[1], mcp->mb[2], command)); 308 } else { 309 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no)); 310 } 311 312 return rval; 313 } 314 315 int 316 qla2x00_load_ram(scsi_qla_host_t *ha, dma_addr_t req_dma, uint32_t risc_addr, 317 uint32_t risc_code_size) 318 { 319 int rval; 320 mbx_cmd_t mc; 321 mbx_cmd_t *mcp = &mc; 322 323 DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no)); 324 325 if (MSW(risc_addr) || IS_FWI2_CAPABLE(ha)) { 326 mcp->mb[0] = MBC_LOAD_RISC_RAM_EXTENDED; 327 mcp->mb[8] = MSW(risc_addr); 328 mcp->out_mb = MBX_8|MBX_0; 329 } else { 330 mcp->mb[0] = MBC_LOAD_RISC_RAM; 331 mcp->out_mb = MBX_0; 332 } 333 mcp->mb[1] = LSW(risc_addr); 334 mcp->mb[2] = MSW(req_dma); 335 mcp->mb[3] = LSW(req_dma); 336 mcp->mb[6] = MSW(MSD(req_dma)); 337 mcp->mb[7] = LSW(MSD(req_dma)); 338 mcp->out_mb |= MBX_7|MBX_6|MBX_3|MBX_2|MBX_1; 339 if (IS_FWI2_CAPABLE(ha)) { 340 mcp->mb[4] = MSW(risc_code_size); 341 mcp->mb[5] = LSW(risc_code_size); 342 mcp->out_mb |= MBX_5|MBX_4; 343 } else { 344 mcp->mb[4] = LSW(risc_code_size); 345 mcp->out_mb |= MBX_4; 346 } 347 348 mcp->in_mb = MBX_0; 349 mcp->tov = 30; 350 mcp->flags = 0; 351 rval = qla2x00_mailbox_command(ha, mcp); 352 353 if (rval != QLA_SUCCESS) { 354 DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x.\n", __func__, 355 ha->host_no, rval, mcp->mb[0])); 356 } else { 357 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no)); 358 } 359 360 return rval; 361 } 362 363 /* 364 * qla2x00_execute_fw 365 * Start adapter firmware. 366 * 367 * Input: 368 * ha = adapter block pointer. 369 * TARGET_QUEUE_LOCK must be released. 370 * ADAPTER_STATE_LOCK must be released. 371 * 372 * Returns: 373 * qla2x00 local function return status code. 374 * 375 * Context: 376 * Kernel context. 377 */ 378 int 379 qla2x00_execute_fw(scsi_qla_host_t *ha, uint32_t risc_addr) 380 { 381 int rval; 382 mbx_cmd_t mc; 383 mbx_cmd_t *mcp = &mc; 384 385 DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no)); 386 387 mcp->mb[0] = MBC_EXECUTE_FIRMWARE; 388 mcp->out_mb = MBX_0; 389 mcp->in_mb = MBX_0; 390 if (IS_FWI2_CAPABLE(ha)) { 391 mcp->mb[1] = MSW(risc_addr); 392 mcp->mb[2] = LSW(risc_addr); 393 mcp->mb[3] = 0; 394 mcp->out_mb |= MBX_3|MBX_2|MBX_1; 395 mcp->in_mb |= MBX_1; 396 } else { 397 mcp->mb[1] = LSW(risc_addr); 398 mcp->out_mb |= MBX_1; 399 if (IS_QLA2322(ha) || IS_QLA6322(ha)) { 400 mcp->mb[2] = 0; 401 mcp->out_mb |= MBX_2; 402 } 403 } 404 405 mcp->tov = 30; 406 mcp->flags = 0; 407 rval = qla2x00_mailbox_command(ha, mcp); 408 409 if (rval != QLA_SUCCESS) { 410 DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x.\n", __func__, 411 ha->host_no, rval, mcp->mb[0])); 412 } else { 413 if (IS_FWI2_CAPABLE(ha)) { 414 DEBUG11(printk("%s(%ld): done exchanges=%x.\n", 415 __func__, ha->host_no, mcp->mb[1])); 416 } else { 417 DEBUG11(printk("%s(%ld): done.\n", __func__, 418 ha->host_no)); 419 } 420 } 421 422 return rval; 423 } 424 425 /* 426 * qla2x00_get_fw_version 427 * Get firmware version. 428 * 429 * Input: 430 * ha: adapter state pointer. 431 * major: pointer for major number. 432 * minor: pointer for minor number. 433 * subminor: pointer for subminor number. 434 * 435 * Returns: 436 * qla2x00 local function return status code. 437 * 438 * Context: 439 * Kernel context. 440 */ 441 void 442 qla2x00_get_fw_version(scsi_qla_host_t *ha, uint16_t *major, uint16_t *minor, 443 uint16_t *subminor, uint16_t *attributes, uint32_t *memory) 444 { 445 int rval; 446 mbx_cmd_t mc; 447 mbx_cmd_t *mcp = &mc; 448 449 DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no)); 450 451 mcp->mb[0] = MBC_GET_FIRMWARE_VERSION; 452 mcp->out_mb = MBX_0; 453 mcp->in_mb = MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0; 454 mcp->flags = 0; 455 mcp->tov = 30; 456 rval = qla2x00_mailbox_command(ha, mcp); 457 458 /* Return mailbox data. */ 459 *major = mcp->mb[1]; 460 *minor = mcp->mb[2]; 461 *subminor = mcp->mb[3]; 462 *attributes = mcp->mb[6]; 463 if (IS_QLA2100(ha) || IS_QLA2200(ha)) 464 *memory = 0x1FFFF; /* Defaults to 128KB. */ 465 else 466 *memory = (mcp->mb[5] << 16) | mcp->mb[4]; 467 468 if (rval != QLA_SUCCESS) { 469 /*EMPTY*/ 470 DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__, 471 ha->host_no, rval)); 472 } else { 473 /*EMPTY*/ 474 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no)); 475 } 476 } 477 478 /* 479 * qla2x00_get_fw_options 480 * Set firmware options. 481 * 482 * Input: 483 * ha = adapter block pointer. 484 * fwopt = pointer for firmware options. 485 * 486 * Returns: 487 * qla2x00 local function return status code. 488 * 489 * Context: 490 * Kernel context. 491 */ 492 int 493 qla2x00_get_fw_options(scsi_qla_host_t *ha, uint16_t *fwopts) 494 { 495 int rval; 496 mbx_cmd_t mc; 497 mbx_cmd_t *mcp = &mc; 498 499 DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no)); 500 501 mcp->mb[0] = MBC_GET_FIRMWARE_OPTION; 502 mcp->out_mb = MBX_0; 503 mcp->in_mb = MBX_3|MBX_2|MBX_1|MBX_0; 504 mcp->tov = 30; 505 mcp->flags = 0; 506 rval = qla2x00_mailbox_command(ha, mcp); 507 508 if (rval != QLA_SUCCESS) { 509 /*EMPTY*/ 510 DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__, 511 ha->host_no, rval)); 512 } else { 513 fwopts[0] = mcp->mb[0]; 514 fwopts[1] = mcp->mb[1]; 515 fwopts[2] = mcp->mb[2]; 516 fwopts[3] = mcp->mb[3]; 517 518 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no)); 519 } 520 521 return rval; 522 } 523 524 525 /* 526 * qla2x00_set_fw_options 527 * Set firmware options. 528 * 529 * Input: 530 * ha = adapter block pointer. 531 * fwopt = pointer for firmware options. 532 * 533 * Returns: 534 * qla2x00 local function return status code. 535 * 536 * Context: 537 * Kernel context. 538 */ 539 int 540 qla2x00_set_fw_options(scsi_qla_host_t *ha, uint16_t *fwopts) 541 { 542 int rval; 543 mbx_cmd_t mc; 544 mbx_cmd_t *mcp = &mc; 545 546 DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no)); 547 548 mcp->mb[0] = MBC_SET_FIRMWARE_OPTION; 549 mcp->mb[1] = fwopts[1]; 550 mcp->mb[2] = fwopts[2]; 551 mcp->mb[3] = fwopts[3]; 552 mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0; 553 mcp->in_mb = MBX_0; 554 if (IS_FWI2_CAPABLE(ha)) { 555 mcp->in_mb |= MBX_1; 556 } else { 557 mcp->mb[10] = fwopts[10]; 558 mcp->mb[11] = fwopts[11]; 559 mcp->mb[12] = 0; /* Undocumented, but used */ 560 mcp->out_mb |= MBX_12|MBX_11|MBX_10; 561 } 562 mcp->tov = 30; 563 mcp->flags = 0; 564 rval = qla2x00_mailbox_command(ha, mcp); 565 566 fwopts[0] = mcp->mb[0]; 567 568 if (rval != QLA_SUCCESS) { 569 /*EMPTY*/ 570 DEBUG2_3_11(printk("%s(%ld): failed=%x (%x/%x).\n", __func__, 571 ha->host_no, rval, mcp->mb[0], mcp->mb[1])); 572 } else { 573 /*EMPTY*/ 574 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no)); 575 } 576 577 return rval; 578 } 579 580 /* 581 * qla2x00_mbx_reg_test 582 * Mailbox register wrap test. 583 * 584 * Input: 585 * ha = adapter block pointer. 586 * TARGET_QUEUE_LOCK must be released. 587 * ADAPTER_STATE_LOCK must be released. 588 * 589 * Returns: 590 * qla2x00 local function return status code. 591 * 592 * Context: 593 * Kernel context. 594 */ 595 int 596 qla2x00_mbx_reg_test(scsi_qla_host_t *ha) 597 { 598 int rval; 599 mbx_cmd_t mc; 600 mbx_cmd_t *mcp = &mc; 601 602 DEBUG11(printk("qla2x00_mbx_reg_test(%ld): entered.\n", ha->host_no)); 603 604 mcp->mb[0] = MBC_MAILBOX_REGISTER_TEST; 605 mcp->mb[1] = 0xAAAA; 606 mcp->mb[2] = 0x5555; 607 mcp->mb[3] = 0xAA55; 608 mcp->mb[4] = 0x55AA; 609 mcp->mb[5] = 0xA5A5; 610 mcp->mb[6] = 0x5A5A; 611 mcp->mb[7] = 0x2525; 612 mcp->out_mb = MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0; 613 mcp->in_mb = MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0; 614 mcp->tov = 30; 615 mcp->flags = 0; 616 rval = qla2x00_mailbox_command(ha, mcp); 617 618 if (rval == QLA_SUCCESS) { 619 if (mcp->mb[1] != 0xAAAA || mcp->mb[2] != 0x5555 || 620 mcp->mb[3] != 0xAA55 || mcp->mb[4] != 0x55AA) 621 rval = QLA_FUNCTION_FAILED; 622 if (mcp->mb[5] != 0xA5A5 || mcp->mb[6] != 0x5A5A || 623 mcp->mb[7] != 0x2525) 624 rval = QLA_FUNCTION_FAILED; 625 } 626 627 if (rval != QLA_SUCCESS) { 628 /*EMPTY*/ 629 DEBUG2_3_11(printk("qla2x00_mbx_reg_test(%ld): failed=%x.\n", 630 ha->host_no, rval)); 631 } else { 632 /*EMPTY*/ 633 DEBUG11(printk("qla2x00_mbx_reg_test(%ld): done.\n", 634 ha->host_no)); 635 } 636 637 return rval; 638 } 639 640 /* 641 * qla2x00_verify_checksum 642 * Verify firmware checksum. 643 * 644 * Input: 645 * ha = adapter block pointer. 646 * TARGET_QUEUE_LOCK must be released. 647 * ADAPTER_STATE_LOCK must be released. 648 * 649 * Returns: 650 * qla2x00 local function return status code. 651 * 652 * Context: 653 * Kernel context. 654 */ 655 int 656 qla2x00_verify_checksum(scsi_qla_host_t *ha, uint32_t risc_addr) 657 { 658 int rval; 659 mbx_cmd_t mc; 660 mbx_cmd_t *mcp = &mc; 661 662 DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no)); 663 664 mcp->mb[0] = MBC_VERIFY_CHECKSUM; 665 mcp->out_mb = MBX_0; 666 mcp->in_mb = MBX_0; 667 if (IS_FWI2_CAPABLE(ha)) { 668 mcp->mb[1] = MSW(risc_addr); 669 mcp->mb[2] = LSW(risc_addr); 670 mcp->out_mb |= MBX_2|MBX_1; 671 mcp->in_mb |= MBX_2|MBX_1; 672 } else { 673 mcp->mb[1] = LSW(risc_addr); 674 mcp->out_mb |= MBX_1; 675 mcp->in_mb |= MBX_1; 676 } 677 678 mcp->tov = 30; 679 mcp->flags = 0; 680 rval = qla2x00_mailbox_command(ha, mcp); 681 682 if (rval != QLA_SUCCESS) { 683 DEBUG2_3_11(printk("%s(%ld): failed=%x chk sum=%x.\n", __func__, 684 ha->host_no, rval, IS_FWI2_CAPABLE(ha) ? 685 (mcp->mb[2] << 16) | mcp->mb[1]: mcp->mb[1])); 686 } else { 687 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no)); 688 } 689 690 return rval; 691 } 692 693 /* 694 * qla2x00_issue_iocb 695 * Issue IOCB using mailbox command 696 * 697 * Input: 698 * ha = adapter state pointer. 699 * buffer = buffer pointer. 700 * phys_addr = physical address of buffer. 701 * size = size of buffer. 702 * TARGET_QUEUE_LOCK must be released. 703 * ADAPTER_STATE_LOCK must be released. 704 * 705 * Returns: 706 * qla2x00 local function return status code. 707 * 708 * Context: 709 * Kernel context. 710 */ 711 int 712 qla2x00_issue_iocb(scsi_qla_host_t *ha, void* buffer, dma_addr_t phys_addr, 713 size_t size) 714 { 715 int rval; 716 mbx_cmd_t mc; 717 mbx_cmd_t *mcp = &mc; 718 719 mcp->mb[0] = MBC_IOCB_COMMAND_A64; 720 mcp->mb[1] = 0; 721 mcp->mb[2] = MSW(phys_addr); 722 mcp->mb[3] = LSW(phys_addr); 723 mcp->mb[6] = MSW(MSD(phys_addr)); 724 mcp->mb[7] = LSW(MSD(phys_addr)); 725 mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0; 726 mcp->in_mb = MBX_2|MBX_0; 727 mcp->tov = 30; 728 mcp->flags = 0; 729 rval = qla2x00_mailbox_command(ha, mcp); 730 731 if (rval != QLA_SUCCESS) { 732 /*EMPTY*/ 733 DEBUG(printk("qla2x00_issue_iocb(%ld): failed rval 0x%x\n", 734 ha->host_no, rval)); 735 DEBUG2(printk("qla2x00_issue_iocb(%ld): failed rval 0x%x\n", 736 ha->host_no, rval)); 737 } else { 738 sts_entry_t *sts_entry = (sts_entry_t *) buffer; 739 740 /* Mask reserved bits. */ 741 sts_entry->entry_status &= 742 IS_FWI2_CAPABLE(ha) ? RF_MASK_24XX :RF_MASK; 743 } 744 745 return rval; 746 } 747 748 /* 749 * qla2x00_abort_command 750 * Abort command aborts a specified IOCB. 751 * 752 * Input: 753 * ha = adapter block pointer. 754 * sp = SB structure pointer. 755 * 756 * Returns: 757 * qla2x00 local function return status code. 758 * 759 * Context: 760 * Kernel context. 761 */ 762 int 763 qla2x00_abort_command(scsi_qla_host_t *ha, srb_t *sp) 764 { 765 unsigned long flags = 0; 766 fc_port_t *fcport; 767 int rval; 768 uint32_t handle; 769 mbx_cmd_t mc; 770 mbx_cmd_t *mcp = &mc; 771 772 DEBUG11(printk("qla2x00_abort_command(%ld): entered.\n", ha->host_no)); 773 774 fcport = sp->fcport; 775 776 spin_lock_irqsave(&ha->hardware_lock, flags); 777 for (handle = 1; handle < MAX_OUTSTANDING_COMMANDS; handle++) { 778 if (ha->outstanding_cmds[handle] == sp) 779 break; 780 } 781 spin_unlock_irqrestore(&ha->hardware_lock, flags); 782 783 if (handle == MAX_OUTSTANDING_COMMANDS) { 784 /* command not found */ 785 return QLA_FUNCTION_FAILED; 786 } 787 788 mcp->mb[0] = MBC_ABORT_COMMAND; 789 if (HAS_EXTENDED_IDS(ha)) 790 mcp->mb[1] = fcport->loop_id; 791 else 792 mcp->mb[1] = fcport->loop_id << 8; 793 mcp->mb[2] = (uint16_t)handle; 794 mcp->mb[3] = (uint16_t)(handle >> 16); 795 mcp->mb[6] = (uint16_t)sp->cmd->device->lun; 796 mcp->out_mb = MBX_6|MBX_3|MBX_2|MBX_1|MBX_0; 797 mcp->in_mb = MBX_0; 798 mcp->tov = 30; 799 mcp->flags = 0; 800 rval = qla2x00_mailbox_command(ha, mcp); 801 802 if (rval != QLA_SUCCESS) { 803 DEBUG2_3_11(printk("qla2x00_abort_command(%ld): failed=%x.\n", 804 ha->host_no, rval)); 805 } else { 806 sp->flags |= SRB_ABORT_PENDING; 807 DEBUG11(printk("qla2x00_abort_command(%ld): done.\n", 808 ha->host_no)); 809 } 810 811 return rval; 812 } 813 814 #if USE_ABORT_TGT 815 /* 816 * qla2x00_abort_target 817 * Issue abort target mailbox command. 818 * 819 * Input: 820 * ha = adapter block pointer. 821 * 822 * Returns: 823 * qla2x00 local function return status code. 824 * 825 * Context: 826 * Kernel context. 827 */ 828 int 829 qla2x00_abort_target(fc_port_t *fcport) 830 { 831 int rval; 832 mbx_cmd_t mc; 833 mbx_cmd_t *mcp = &mc; 834 scsi_qla_host_t *ha; 835 836 if (fcport == NULL) 837 return 0; 838 839 DEBUG11(printk("%s(%ld): entered.\n", __func__, fcport->ha->host_no)); 840 841 ha = fcport->ha; 842 mcp->mb[0] = MBC_ABORT_TARGET; 843 mcp->out_mb = MBX_2|MBX_1|MBX_0; 844 if (HAS_EXTENDED_IDS(ha)) { 845 mcp->mb[1] = fcport->loop_id; 846 mcp->mb[10] = 0; 847 mcp->out_mb |= MBX_10; 848 } else { 849 mcp->mb[1] = fcport->loop_id << 8; 850 } 851 mcp->mb[2] = ha->loop_reset_delay; 852 853 mcp->in_mb = MBX_0; 854 mcp->tov = 30; 855 mcp->flags = 0; 856 rval = qla2x00_mailbox_command(ha, mcp); 857 858 /* Issue marker command. */ 859 ha->marker_needed = 1; 860 861 if (rval != QLA_SUCCESS) { 862 DEBUG2_3_11(printk("qla2x00_abort_target(%ld): failed=%x.\n", 863 ha->host_no, rval)); 864 } else { 865 /*EMPTY*/ 866 DEBUG11(printk("qla2x00_abort_target(%ld): done.\n", 867 ha->host_no)); 868 } 869 870 return rval; 871 } 872 #endif 873 874 /* 875 * qla2x00_get_adapter_id 876 * Get adapter ID and topology. 877 * 878 * Input: 879 * ha = adapter block pointer. 880 * id = pointer for loop ID. 881 * al_pa = pointer for AL_PA. 882 * area = pointer for area. 883 * domain = pointer for domain. 884 * top = pointer for topology. 885 * TARGET_QUEUE_LOCK must be released. 886 * ADAPTER_STATE_LOCK must be released. 887 * 888 * Returns: 889 * qla2x00 local function return status code. 890 * 891 * Context: 892 * Kernel context. 893 */ 894 int 895 qla2x00_get_adapter_id(scsi_qla_host_t *ha, uint16_t *id, uint8_t *al_pa, 896 uint8_t *area, uint8_t *domain, uint16_t *top, uint16_t *sw_cap) 897 { 898 int rval; 899 mbx_cmd_t mc; 900 mbx_cmd_t *mcp = &mc; 901 902 DEBUG11(printk("qla2x00_get_adapter_id(%ld): entered.\n", 903 ha->host_no)); 904 905 mcp->mb[0] = MBC_GET_ADAPTER_LOOP_ID; 906 mcp->mb[9] = ha->vp_idx; 907 mcp->out_mb = MBX_0; 908 mcp->in_mb = MBX_9|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0; 909 mcp->tov = 30; 910 mcp->flags = 0; 911 rval = qla2x00_mailbox_command(ha, mcp); 912 if (mcp->mb[0] == MBS_COMMAND_ERROR) 913 rval = QLA_COMMAND_ERROR; 914 915 /* Return data. */ 916 *id = mcp->mb[1]; 917 *al_pa = LSB(mcp->mb[2]); 918 *area = MSB(mcp->mb[2]); 919 *domain = LSB(mcp->mb[3]); 920 *top = mcp->mb[6]; 921 *sw_cap = mcp->mb[7]; 922 923 if (rval != QLA_SUCCESS) { 924 /*EMPTY*/ 925 DEBUG2_3_11(printk("qla2x00_get_adapter_id(%ld): failed=%x.\n", 926 ha->host_no, rval)); 927 } else { 928 /*EMPTY*/ 929 DEBUG11(printk("qla2x00_get_adapter_id(%ld): done.\n", 930 ha->host_no)); 931 } 932 933 return rval; 934 } 935 936 /* 937 * qla2x00_get_retry_cnt 938 * Get current firmware login retry count and delay. 939 * 940 * Input: 941 * ha = adapter block pointer. 942 * retry_cnt = pointer to login retry count. 943 * tov = pointer to login timeout value. 944 * 945 * Returns: 946 * qla2x00 local function return status code. 947 * 948 * Context: 949 * Kernel context. 950 */ 951 int 952 qla2x00_get_retry_cnt(scsi_qla_host_t *ha, uint8_t *retry_cnt, uint8_t *tov, 953 uint16_t *r_a_tov) 954 { 955 int rval; 956 uint16_t ratov; 957 mbx_cmd_t mc; 958 mbx_cmd_t *mcp = &mc; 959 960 DEBUG11(printk("qla2x00_get_retry_cnt(%ld): entered.\n", 961 ha->host_no)); 962 963 mcp->mb[0] = MBC_GET_RETRY_COUNT; 964 mcp->out_mb = MBX_0; 965 mcp->in_mb = MBX_3|MBX_2|MBX_1|MBX_0; 966 mcp->tov = 30; 967 mcp->flags = 0; 968 rval = qla2x00_mailbox_command(ha, mcp); 969 970 if (rval != QLA_SUCCESS) { 971 /*EMPTY*/ 972 DEBUG2_3_11(printk("qla2x00_get_retry_cnt(%ld): failed = %x.\n", 973 ha->host_no, mcp->mb[0])); 974 } else { 975 /* Convert returned data and check our values. */ 976 *r_a_tov = mcp->mb[3] / 2; 977 ratov = (mcp->mb[3]/2) / 10; /* mb[3] value is in 100ms */ 978 if (mcp->mb[1] * ratov > (*retry_cnt) * (*tov)) { 979 /* Update to the larger values */ 980 *retry_cnt = (uint8_t)mcp->mb[1]; 981 *tov = ratov; 982 } 983 984 DEBUG11(printk("qla2x00_get_retry_cnt(%ld): done. mb3=%d " 985 "ratov=%d.\n", ha->host_no, mcp->mb[3], ratov)); 986 } 987 988 return rval; 989 } 990 991 /* 992 * qla2x00_init_firmware 993 * Initialize adapter firmware. 994 * 995 * Input: 996 * ha = adapter block pointer. 997 * dptr = Initialization control block pointer. 998 * size = size of initialization control block. 999 * TARGET_QUEUE_LOCK must be released. 1000 * ADAPTER_STATE_LOCK must be released. 1001 * 1002 * Returns: 1003 * qla2x00 local function return status code. 1004 * 1005 * Context: 1006 * Kernel context. 1007 */ 1008 int 1009 qla2x00_init_firmware(scsi_qla_host_t *ha, uint16_t size) 1010 { 1011 int rval; 1012 mbx_cmd_t mc; 1013 mbx_cmd_t *mcp = &mc; 1014 1015 DEBUG11(printk("qla2x00_init_firmware(%ld): entered.\n", 1016 ha->host_no)); 1017 1018 if (ha->flags.npiv_supported) 1019 mcp->mb[0] = MBC_MID_INITIALIZE_FIRMWARE; 1020 else 1021 mcp->mb[0] = MBC_INITIALIZE_FIRMWARE; 1022 1023 mcp->mb[2] = MSW(ha->init_cb_dma); 1024 mcp->mb[3] = LSW(ha->init_cb_dma); 1025 mcp->mb[4] = 0; 1026 mcp->mb[5] = 0; 1027 mcp->mb[6] = MSW(MSD(ha->init_cb_dma)); 1028 mcp->mb[7] = LSW(MSD(ha->init_cb_dma)); 1029 mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_0; 1030 mcp->in_mb = MBX_5|MBX_4|MBX_0; 1031 mcp->buf_size = size; 1032 mcp->flags = MBX_DMA_OUT; 1033 mcp->tov = 30; 1034 rval = qla2x00_mailbox_command(ha, mcp); 1035 1036 if (rval != QLA_SUCCESS) { 1037 /*EMPTY*/ 1038 DEBUG2_3_11(printk("qla2x00_init_firmware(%ld): failed=%x " 1039 "mb0=%x.\n", 1040 ha->host_no, rval, mcp->mb[0])); 1041 } else { 1042 /*EMPTY*/ 1043 DEBUG11(printk("qla2x00_init_firmware(%ld): done.\n", 1044 ha->host_no)); 1045 } 1046 1047 return rval; 1048 } 1049 1050 /* 1051 * qla2x00_get_port_database 1052 * Issue normal/enhanced get port database mailbox command 1053 * and copy device name as necessary. 1054 * 1055 * Input: 1056 * ha = adapter state pointer. 1057 * dev = structure pointer. 1058 * opt = enhanced cmd option byte. 1059 * 1060 * Returns: 1061 * qla2x00 local function return status code. 1062 * 1063 * Context: 1064 * Kernel context. 1065 */ 1066 int 1067 qla2x00_get_port_database(scsi_qla_host_t *ha, fc_port_t *fcport, uint8_t opt) 1068 { 1069 int rval; 1070 mbx_cmd_t mc; 1071 mbx_cmd_t *mcp = &mc; 1072 port_database_t *pd; 1073 struct port_database_24xx *pd24; 1074 dma_addr_t pd_dma; 1075 1076 DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no)); 1077 1078 pd24 = NULL; 1079 pd = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &pd_dma); 1080 if (pd == NULL) { 1081 DEBUG2_3(printk("%s(%ld): failed to allocate Port Database " 1082 "structure.\n", __func__, ha->host_no)); 1083 return QLA_MEMORY_ALLOC_FAILED; 1084 } 1085 memset(pd, 0, max(PORT_DATABASE_SIZE, PORT_DATABASE_24XX_SIZE)); 1086 1087 mcp->mb[0] = MBC_GET_PORT_DATABASE; 1088 if (opt != 0 && !IS_FWI2_CAPABLE(ha)) 1089 mcp->mb[0] = MBC_ENHANCED_GET_PORT_DATABASE; 1090 mcp->mb[2] = MSW(pd_dma); 1091 mcp->mb[3] = LSW(pd_dma); 1092 mcp->mb[6] = MSW(MSD(pd_dma)); 1093 mcp->mb[7] = LSW(MSD(pd_dma)); 1094 mcp->mb[9] = ha->vp_idx; 1095 mcp->out_mb = MBX_9|MBX_7|MBX_6|MBX_3|MBX_2|MBX_0; 1096 mcp->in_mb = MBX_0; 1097 if (IS_FWI2_CAPABLE(ha)) { 1098 mcp->mb[1] = fcport->loop_id; 1099 mcp->mb[10] = opt; 1100 mcp->out_mb |= MBX_10|MBX_1; 1101 mcp->in_mb |= MBX_1; 1102 } else if (HAS_EXTENDED_IDS(ha)) { 1103 mcp->mb[1] = fcport->loop_id; 1104 mcp->mb[10] = opt; 1105 mcp->out_mb |= MBX_10|MBX_1; 1106 } else { 1107 mcp->mb[1] = fcport->loop_id << 8 | opt; 1108 mcp->out_mb |= MBX_1; 1109 } 1110 mcp->buf_size = IS_FWI2_CAPABLE(ha) ? 1111 PORT_DATABASE_24XX_SIZE : PORT_DATABASE_SIZE; 1112 mcp->flags = MBX_DMA_IN; 1113 mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2); 1114 rval = qla2x00_mailbox_command(ha, mcp); 1115 if (rval != QLA_SUCCESS) 1116 goto gpd_error_out; 1117 1118 if (IS_FWI2_CAPABLE(ha)) { 1119 pd24 = (struct port_database_24xx *) pd; 1120 1121 /* Check for logged in state. */ 1122 if (pd24->current_login_state != PDS_PRLI_COMPLETE && 1123 pd24->last_login_state != PDS_PRLI_COMPLETE) { 1124 DEBUG2(printk("%s(%ld): Unable to verify " 1125 "login-state (%x/%x) for loop_id %x\n", 1126 __func__, ha->host_no, 1127 pd24->current_login_state, 1128 pd24->last_login_state, fcport->loop_id)); 1129 rval = QLA_FUNCTION_FAILED; 1130 goto gpd_error_out; 1131 } 1132 1133 /* Names are little-endian. */ 1134 memcpy(fcport->node_name, pd24->node_name, WWN_SIZE); 1135 memcpy(fcport->port_name, pd24->port_name, WWN_SIZE); 1136 1137 /* Get port_id of device. */ 1138 fcport->d_id.b.domain = pd24->port_id[0]; 1139 fcport->d_id.b.area = pd24->port_id[1]; 1140 fcport->d_id.b.al_pa = pd24->port_id[2]; 1141 fcport->d_id.b.rsvd_1 = 0; 1142 1143 /* If not target must be initiator or unknown type. */ 1144 if ((pd24->prli_svc_param_word_3[0] & BIT_4) == 0) 1145 fcport->port_type = FCT_INITIATOR; 1146 else 1147 fcport->port_type = FCT_TARGET; 1148 } else { 1149 /* Check for logged in state. */ 1150 if (pd->master_state != PD_STATE_PORT_LOGGED_IN && 1151 pd->slave_state != PD_STATE_PORT_LOGGED_IN) { 1152 rval = QLA_FUNCTION_FAILED; 1153 goto gpd_error_out; 1154 } 1155 1156 /* Names are little-endian. */ 1157 memcpy(fcport->node_name, pd->node_name, WWN_SIZE); 1158 memcpy(fcport->port_name, pd->port_name, WWN_SIZE); 1159 1160 /* Get port_id of device. */ 1161 fcport->d_id.b.domain = pd->port_id[0]; 1162 fcport->d_id.b.area = pd->port_id[3]; 1163 fcport->d_id.b.al_pa = pd->port_id[2]; 1164 fcport->d_id.b.rsvd_1 = 0; 1165 1166 /* Check for device require authentication. */ 1167 pd->common_features & BIT_5 ? (fcport->flags |= FCF_AUTH_REQ) : 1168 (fcport->flags &= ~FCF_AUTH_REQ); 1169 1170 /* If not target must be initiator or unknown type. */ 1171 if ((pd->prli_svc_param_word_3[0] & BIT_4) == 0) 1172 fcport->port_type = FCT_INITIATOR; 1173 else 1174 fcport->port_type = FCT_TARGET; 1175 1176 /* Passback COS information. */ 1177 fcport->supported_classes = (pd->options & BIT_4) ? 1178 FC_COS_CLASS2: FC_COS_CLASS3; 1179 } 1180 1181 gpd_error_out: 1182 dma_pool_free(ha->s_dma_pool, pd, pd_dma); 1183 1184 if (rval != QLA_SUCCESS) { 1185 DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x mb[1]=%x.\n", 1186 __func__, ha->host_no, rval, mcp->mb[0], mcp->mb[1])); 1187 } else { 1188 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no)); 1189 } 1190 1191 return rval; 1192 } 1193 1194 /* 1195 * qla2x00_get_firmware_state 1196 * Get adapter firmware state. 1197 * 1198 * Input: 1199 * ha = adapter block pointer. 1200 * dptr = pointer for firmware state. 1201 * TARGET_QUEUE_LOCK must be released. 1202 * ADAPTER_STATE_LOCK must be released. 1203 * 1204 * Returns: 1205 * qla2x00 local function return status code. 1206 * 1207 * Context: 1208 * Kernel context. 1209 */ 1210 int 1211 qla2x00_get_firmware_state(scsi_qla_host_t *ha, uint16_t *dptr) 1212 { 1213 int rval; 1214 mbx_cmd_t mc; 1215 mbx_cmd_t *mcp = &mc; 1216 1217 DEBUG11(printk("qla2x00_get_firmware_state(%ld): entered.\n", 1218 ha->host_no)); 1219 1220 mcp->mb[0] = MBC_GET_FIRMWARE_STATE; 1221 mcp->out_mb = MBX_0; 1222 mcp->in_mb = MBX_2|MBX_1|MBX_0; 1223 mcp->tov = 30; 1224 mcp->flags = 0; 1225 rval = qla2x00_mailbox_command(ha, mcp); 1226 1227 /* Return firmware state. */ 1228 *dptr = mcp->mb[1]; 1229 1230 if (rval != QLA_SUCCESS) { 1231 /*EMPTY*/ 1232 DEBUG2_3_11(printk("qla2x00_get_firmware_state(%ld): " 1233 "failed=%x.\n", ha->host_no, rval)); 1234 } else { 1235 /*EMPTY*/ 1236 DEBUG11(printk("qla2x00_get_firmware_state(%ld): done.\n", 1237 ha->host_no)); 1238 } 1239 1240 return rval; 1241 } 1242 1243 /* 1244 * qla2x00_get_port_name 1245 * Issue get port name mailbox command. 1246 * Returned name is in big endian format. 1247 * 1248 * Input: 1249 * ha = adapter block pointer. 1250 * loop_id = loop ID of device. 1251 * name = pointer for name. 1252 * TARGET_QUEUE_LOCK must be released. 1253 * ADAPTER_STATE_LOCK must be released. 1254 * 1255 * Returns: 1256 * qla2x00 local function return status code. 1257 * 1258 * Context: 1259 * Kernel context. 1260 */ 1261 int 1262 qla2x00_get_port_name(scsi_qla_host_t *ha, uint16_t loop_id, uint8_t *name, 1263 uint8_t opt) 1264 { 1265 int rval; 1266 mbx_cmd_t mc; 1267 mbx_cmd_t *mcp = &mc; 1268 1269 DEBUG11(printk("qla2x00_get_port_name(%ld): entered.\n", 1270 ha->host_no)); 1271 1272 mcp->mb[0] = MBC_GET_PORT_NAME; 1273 mcp->mb[9] = ha->vp_idx; 1274 mcp->out_mb = MBX_9|MBX_1|MBX_0; 1275 if (HAS_EXTENDED_IDS(ha)) { 1276 mcp->mb[1] = loop_id; 1277 mcp->mb[10] = opt; 1278 mcp->out_mb |= MBX_10; 1279 } else { 1280 mcp->mb[1] = loop_id << 8 | opt; 1281 } 1282 1283 mcp->in_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0; 1284 mcp->tov = 30; 1285 mcp->flags = 0; 1286 rval = qla2x00_mailbox_command(ha, mcp); 1287 1288 if (rval != QLA_SUCCESS) { 1289 /*EMPTY*/ 1290 DEBUG2_3_11(printk("qla2x00_get_port_name(%ld): failed=%x.\n", 1291 ha->host_no, rval)); 1292 } else { 1293 if (name != NULL) { 1294 /* This function returns name in big endian. */ 1295 name[0] = MSB(mcp->mb[2]); 1296 name[1] = LSB(mcp->mb[2]); 1297 name[2] = MSB(mcp->mb[3]); 1298 name[3] = LSB(mcp->mb[3]); 1299 name[4] = MSB(mcp->mb[6]); 1300 name[5] = LSB(mcp->mb[6]); 1301 name[6] = MSB(mcp->mb[7]); 1302 name[7] = LSB(mcp->mb[7]); 1303 } 1304 1305 DEBUG11(printk("qla2x00_get_port_name(%ld): done.\n", 1306 ha->host_no)); 1307 } 1308 1309 return rval; 1310 } 1311 1312 /* 1313 * qla2x00_lip_reset 1314 * Issue LIP reset mailbox command. 1315 * 1316 * Input: 1317 * ha = adapter block pointer. 1318 * TARGET_QUEUE_LOCK must be released. 1319 * ADAPTER_STATE_LOCK must be released. 1320 * 1321 * Returns: 1322 * qla2x00 local function return status code. 1323 * 1324 * Context: 1325 * Kernel context. 1326 */ 1327 int 1328 qla2x00_lip_reset(scsi_qla_host_t *ha) 1329 { 1330 int rval; 1331 mbx_cmd_t mc; 1332 mbx_cmd_t *mcp = &mc; 1333 1334 DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no)); 1335 1336 if (IS_FWI2_CAPABLE(ha)) { 1337 mcp->mb[0] = MBC_LIP_FULL_LOGIN; 1338 mcp->mb[1] = BIT_6; 1339 mcp->mb[2] = 0; 1340 mcp->mb[3] = ha->loop_reset_delay; 1341 mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0; 1342 } else { 1343 mcp->mb[0] = MBC_LIP_RESET; 1344 mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0; 1345 if (HAS_EXTENDED_IDS(ha)) { 1346 mcp->mb[1] = 0x00ff; 1347 mcp->mb[10] = 0; 1348 mcp->out_mb |= MBX_10; 1349 } else { 1350 mcp->mb[1] = 0xff00; 1351 } 1352 mcp->mb[2] = ha->loop_reset_delay; 1353 mcp->mb[3] = 0; 1354 } 1355 mcp->in_mb = MBX_0; 1356 mcp->tov = 30; 1357 mcp->flags = 0; 1358 rval = qla2x00_mailbox_command(ha, mcp); 1359 1360 if (rval != QLA_SUCCESS) { 1361 /*EMPTY*/ 1362 DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", 1363 __func__, ha->host_no, rval)); 1364 } else { 1365 /*EMPTY*/ 1366 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no)); 1367 } 1368 1369 return rval; 1370 } 1371 1372 /* 1373 * qla2x00_send_sns 1374 * Send SNS command. 1375 * 1376 * Input: 1377 * ha = adapter block pointer. 1378 * sns = pointer for command. 1379 * cmd_size = command size. 1380 * buf_size = response/command size. 1381 * TARGET_QUEUE_LOCK must be released. 1382 * ADAPTER_STATE_LOCK must be released. 1383 * 1384 * Returns: 1385 * qla2x00 local function return status code. 1386 * 1387 * Context: 1388 * Kernel context. 1389 */ 1390 int 1391 qla2x00_send_sns(scsi_qla_host_t *ha, dma_addr_t sns_phys_address, 1392 uint16_t cmd_size, size_t buf_size) 1393 { 1394 int rval; 1395 mbx_cmd_t mc; 1396 mbx_cmd_t *mcp = &mc; 1397 1398 DEBUG11(printk("qla2x00_send_sns(%ld): entered.\n", 1399 ha->host_no)); 1400 1401 DEBUG11(printk("qla2x00_send_sns: retry cnt=%d ratov=%d total " 1402 "tov=%d.\n", ha->retry_count, ha->login_timeout, mcp->tov)); 1403 1404 mcp->mb[0] = MBC_SEND_SNS_COMMAND; 1405 mcp->mb[1] = cmd_size; 1406 mcp->mb[2] = MSW(sns_phys_address); 1407 mcp->mb[3] = LSW(sns_phys_address); 1408 mcp->mb[6] = MSW(MSD(sns_phys_address)); 1409 mcp->mb[7] = LSW(MSD(sns_phys_address)); 1410 mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0; 1411 mcp->in_mb = MBX_0|MBX_1; 1412 mcp->buf_size = buf_size; 1413 mcp->flags = MBX_DMA_OUT|MBX_DMA_IN; 1414 mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2); 1415 rval = qla2x00_mailbox_command(ha, mcp); 1416 1417 if (rval != QLA_SUCCESS) { 1418 /*EMPTY*/ 1419 DEBUG(printk("qla2x00_send_sns(%ld): failed=%x mb[0]=%x " 1420 "mb[1]=%x.\n", ha->host_no, rval, mcp->mb[0], mcp->mb[1])); 1421 DEBUG2_3_11(printk("qla2x00_send_sns(%ld): failed=%x mb[0]=%x " 1422 "mb[1]=%x.\n", ha->host_no, rval, mcp->mb[0], mcp->mb[1])); 1423 } else { 1424 /*EMPTY*/ 1425 DEBUG11(printk("qla2x00_send_sns(%ld): done.\n", ha->host_no)); 1426 } 1427 1428 return rval; 1429 } 1430 1431 int 1432 qla24xx_login_fabric(scsi_qla_host_t *ha, uint16_t loop_id, uint8_t domain, 1433 uint8_t area, uint8_t al_pa, uint16_t *mb, uint8_t opt) 1434 { 1435 int rval; 1436 1437 struct logio_entry_24xx *lg; 1438 dma_addr_t lg_dma; 1439 uint32_t iop[2]; 1440 1441 DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no)); 1442 1443 lg = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &lg_dma); 1444 if (lg == NULL) { 1445 DEBUG2_3(printk("%s(%ld): failed to allocate Login IOCB.\n", 1446 __func__, ha->host_no)); 1447 return QLA_MEMORY_ALLOC_FAILED; 1448 } 1449 memset(lg, 0, sizeof(struct logio_entry_24xx)); 1450 1451 lg->entry_type = LOGINOUT_PORT_IOCB_TYPE; 1452 lg->entry_count = 1; 1453 lg->nport_handle = cpu_to_le16(loop_id); 1454 lg->control_flags = __constant_cpu_to_le16(LCF_COMMAND_PLOGI); 1455 if (opt & BIT_0) 1456 lg->control_flags |= __constant_cpu_to_le16(LCF_COND_PLOGI); 1457 if (opt & BIT_1) 1458 lg->control_flags |= __constant_cpu_to_le16(LCF_SKIP_PRLI); 1459 lg->port_id[0] = al_pa; 1460 lg->port_id[1] = area; 1461 lg->port_id[2] = domain; 1462 lg->vp_index = cpu_to_le16(ha->vp_idx); 1463 rval = qla2x00_issue_iocb(ha, lg, lg_dma, 0); 1464 if (rval != QLA_SUCCESS) { 1465 DEBUG2_3_11(printk("%s(%ld): failed to issue Login IOCB " 1466 "(%x).\n", __func__, ha->host_no, rval)); 1467 } else if (lg->entry_status != 0) { 1468 DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB " 1469 "-- error status (%x).\n", __func__, ha->host_no, 1470 lg->entry_status)); 1471 rval = QLA_FUNCTION_FAILED; 1472 } else if (lg->comp_status != __constant_cpu_to_le16(CS_COMPLETE)) { 1473 iop[0] = le32_to_cpu(lg->io_parameter[0]); 1474 iop[1] = le32_to_cpu(lg->io_parameter[1]); 1475 1476 DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB " 1477 "-- completion status (%x) ioparam=%x/%x.\n", __func__, 1478 ha->host_no, le16_to_cpu(lg->comp_status), iop[0], 1479 iop[1])); 1480 1481 switch (iop[0]) { 1482 case LSC_SCODE_PORTID_USED: 1483 mb[0] = MBS_PORT_ID_USED; 1484 mb[1] = LSW(iop[1]); 1485 break; 1486 case LSC_SCODE_NPORT_USED: 1487 mb[0] = MBS_LOOP_ID_USED; 1488 break; 1489 case LSC_SCODE_NOLINK: 1490 case LSC_SCODE_NOIOCB: 1491 case LSC_SCODE_NOXCB: 1492 case LSC_SCODE_CMD_FAILED: 1493 case LSC_SCODE_NOFABRIC: 1494 case LSC_SCODE_FW_NOT_READY: 1495 case LSC_SCODE_NOT_LOGGED_IN: 1496 case LSC_SCODE_NOPCB: 1497 case LSC_SCODE_ELS_REJECT: 1498 case LSC_SCODE_CMD_PARAM_ERR: 1499 case LSC_SCODE_NONPORT: 1500 case LSC_SCODE_LOGGED_IN: 1501 case LSC_SCODE_NOFLOGI_ACC: 1502 default: 1503 mb[0] = MBS_COMMAND_ERROR; 1504 break; 1505 } 1506 } else { 1507 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no)); 1508 1509 iop[0] = le32_to_cpu(lg->io_parameter[0]); 1510 1511 mb[0] = MBS_COMMAND_COMPLETE; 1512 mb[1] = 0; 1513 if (iop[0] & BIT_4) { 1514 if (iop[0] & BIT_8) 1515 mb[1] |= BIT_1; 1516 } else 1517 mb[1] = BIT_0; 1518 1519 /* Passback COS information. */ 1520 mb[10] = 0; 1521 if (lg->io_parameter[7] || lg->io_parameter[8]) 1522 mb[10] |= BIT_0; /* Class 2. */ 1523 if (lg->io_parameter[9] || lg->io_parameter[10]) 1524 mb[10] |= BIT_1; /* Class 3. */ 1525 } 1526 1527 dma_pool_free(ha->s_dma_pool, lg, lg_dma); 1528 1529 return rval; 1530 } 1531 1532 /* 1533 * qla2x00_login_fabric 1534 * Issue login fabric port mailbox command. 1535 * 1536 * Input: 1537 * ha = adapter block pointer. 1538 * loop_id = device loop ID. 1539 * domain = device domain. 1540 * area = device area. 1541 * al_pa = device AL_PA. 1542 * status = pointer for return status. 1543 * opt = command options. 1544 * TARGET_QUEUE_LOCK must be released. 1545 * ADAPTER_STATE_LOCK must be released. 1546 * 1547 * Returns: 1548 * qla2x00 local function return status code. 1549 * 1550 * Context: 1551 * Kernel context. 1552 */ 1553 int 1554 qla2x00_login_fabric(scsi_qla_host_t *ha, uint16_t loop_id, uint8_t domain, 1555 uint8_t area, uint8_t al_pa, uint16_t *mb, uint8_t opt) 1556 { 1557 int rval; 1558 mbx_cmd_t mc; 1559 mbx_cmd_t *mcp = &mc; 1560 1561 DEBUG11(printk("qla2x00_login_fabric(%ld): entered.\n", ha->host_no)); 1562 1563 mcp->mb[0] = MBC_LOGIN_FABRIC_PORT; 1564 mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0; 1565 if (HAS_EXTENDED_IDS(ha)) { 1566 mcp->mb[1] = loop_id; 1567 mcp->mb[10] = opt; 1568 mcp->out_mb |= MBX_10; 1569 } else { 1570 mcp->mb[1] = (loop_id << 8) | opt; 1571 } 1572 mcp->mb[2] = domain; 1573 mcp->mb[3] = area << 8 | al_pa; 1574 1575 mcp->in_mb = MBX_7|MBX_6|MBX_2|MBX_1|MBX_0; 1576 mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2); 1577 mcp->flags = 0; 1578 rval = qla2x00_mailbox_command(ha, mcp); 1579 1580 /* Return mailbox statuses. */ 1581 if (mb != NULL) { 1582 mb[0] = mcp->mb[0]; 1583 mb[1] = mcp->mb[1]; 1584 mb[2] = mcp->mb[2]; 1585 mb[6] = mcp->mb[6]; 1586 mb[7] = mcp->mb[7]; 1587 /* COS retrieved from Get-Port-Database mailbox command. */ 1588 mb[10] = 0; 1589 } 1590 1591 if (rval != QLA_SUCCESS) { 1592 /* RLU tmp code: need to change main mailbox_command function to 1593 * return ok even when the mailbox completion value is not 1594 * SUCCESS. The caller needs to be responsible to interpret 1595 * the return values of this mailbox command if we're not 1596 * to change too much of the existing code. 1597 */ 1598 if (mcp->mb[0] == 0x4001 || mcp->mb[0] == 0x4002 || 1599 mcp->mb[0] == 0x4003 || mcp->mb[0] == 0x4005 || 1600 mcp->mb[0] == 0x4006) 1601 rval = QLA_SUCCESS; 1602 1603 /*EMPTY*/ 1604 DEBUG2_3_11(printk("qla2x00_login_fabric(%ld): failed=%x " 1605 "mb[0]=%x mb[1]=%x mb[2]=%x.\n", ha->host_no, rval, 1606 mcp->mb[0], mcp->mb[1], mcp->mb[2])); 1607 } else { 1608 /*EMPTY*/ 1609 DEBUG11(printk("qla2x00_login_fabric(%ld): done.\n", 1610 ha->host_no)); 1611 } 1612 1613 return rval; 1614 } 1615 1616 /* 1617 * qla2x00_login_local_device 1618 * Issue login loop port mailbox command. 1619 * 1620 * Input: 1621 * ha = adapter block pointer. 1622 * loop_id = device loop ID. 1623 * opt = command options. 1624 * 1625 * Returns: 1626 * Return status code. 1627 * 1628 * Context: 1629 * Kernel context. 1630 * 1631 */ 1632 int 1633 qla2x00_login_local_device(scsi_qla_host_t *ha, fc_port_t *fcport, 1634 uint16_t *mb_ret, uint8_t opt) 1635 { 1636 int rval; 1637 mbx_cmd_t mc; 1638 mbx_cmd_t *mcp = &mc; 1639 1640 if (IS_FWI2_CAPABLE(ha)) 1641 return qla24xx_login_fabric(ha, fcport->loop_id, 1642 fcport->d_id.b.domain, fcport->d_id.b.area, 1643 fcport->d_id.b.al_pa, mb_ret, opt); 1644 1645 DEBUG3(printk("%s(%ld): entered.\n", __func__, ha->host_no)); 1646 1647 mcp->mb[0] = MBC_LOGIN_LOOP_PORT; 1648 if (HAS_EXTENDED_IDS(ha)) 1649 mcp->mb[1] = fcport->loop_id; 1650 else 1651 mcp->mb[1] = fcport->loop_id << 8; 1652 mcp->mb[2] = opt; 1653 mcp->out_mb = MBX_2|MBX_1|MBX_0; 1654 mcp->in_mb = MBX_7|MBX_6|MBX_1|MBX_0; 1655 mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2); 1656 mcp->flags = 0; 1657 rval = qla2x00_mailbox_command(ha, mcp); 1658 1659 /* Return mailbox statuses. */ 1660 if (mb_ret != NULL) { 1661 mb_ret[0] = mcp->mb[0]; 1662 mb_ret[1] = mcp->mb[1]; 1663 mb_ret[6] = mcp->mb[6]; 1664 mb_ret[7] = mcp->mb[7]; 1665 } 1666 1667 if (rval != QLA_SUCCESS) { 1668 /* AV tmp code: need to change main mailbox_command function to 1669 * return ok even when the mailbox completion value is not 1670 * SUCCESS. The caller needs to be responsible to interpret 1671 * the return values of this mailbox command if we're not 1672 * to change too much of the existing code. 1673 */ 1674 if (mcp->mb[0] == 0x4005 || mcp->mb[0] == 0x4006) 1675 rval = QLA_SUCCESS; 1676 1677 DEBUG(printk("%s(%ld): failed=%x mb[0]=%x mb[1]=%x " 1678 "mb[6]=%x mb[7]=%x.\n", __func__, ha->host_no, rval, 1679 mcp->mb[0], mcp->mb[1], mcp->mb[6], mcp->mb[7])); 1680 DEBUG2_3(printk("%s(%ld): failed=%x mb[0]=%x mb[1]=%x " 1681 "mb[6]=%x mb[7]=%x.\n", __func__, ha->host_no, rval, 1682 mcp->mb[0], mcp->mb[1], mcp->mb[6], mcp->mb[7])); 1683 } else { 1684 /*EMPTY*/ 1685 DEBUG3(printk("%s(%ld): done.\n", __func__, ha->host_no)); 1686 } 1687 1688 return (rval); 1689 } 1690 1691 int 1692 qla24xx_fabric_logout(scsi_qla_host_t *ha, uint16_t loop_id, uint8_t domain, 1693 uint8_t area, uint8_t al_pa) 1694 { 1695 int rval; 1696 struct logio_entry_24xx *lg; 1697 dma_addr_t lg_dma; 1698 1699 DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no)); 1700 1701 lg = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &lg_dma); 1702 if (lg == NULL) { 1703 DEBUG2_3(printk("%s(%ld): failed to allocate Logout IOCB.\n", 1704 __func__, ha->host_no)); 1705 return QLA_MEMORY_ALLOC_FAILED; 1706 } 1707 memset(lg, 0, sizeof(struct logio_entry_24xx)); 1708 1709 lg->entry_type = LOGINOUT_PORT_IOCB_TYPE; 1710 lg->entry_count = 1; 1711 lg->nport_handle = cpu_to_le16(loop_id); 1712 lg->control_flags = 1713 __constant_cpu_to_le16(LCF_COMMAND_LOGO|LCF_IMPL_LOGO); 1714 lg->port_id[0] = al_pa; 1715 lg->port_id[1] = area; 1716 lg->port_id[2] = domain; 1717 lg->vp_index = cpu_to_le16(ha->vp_idx); 1718 rval = qla2x00_issue_iocb(ha, lg, lg_dma, 0); 1719 if (rval != QLA_SUCCESS) { 1720 DEBUG2_3_11(printk("%s(%ld): failed to issue Logout IOCB " 1721 "(%x).\n", __func__, ha->host_no, rval)); 1722 } else if (lg->entry_status != 0) { 1723 DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB " 1724 "-- error status (%x).\n", __func__, ha->host_no, 1725 lg->entry_status)); 1726 rval = QLA_FUNCTION_FAILED; 1727 } else if (lg->comp_status != __constant_cpu_to_le16(CS_COMPLETE)) { 1728 DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB " 1729 "-- completion status (%x) ioparam=%x/%x.\n", __func__, 1730 ha->host_no, le16_to_cpu(lg->comp_status), 1731 le32_to_cpu(lg->io_parameter[0]), 1732 le32_to_cpu(lg->io_parameter[1]))); 1733 } else { 1734 /*EMPTY*/ 1735 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no)); 1736 } 1737 1738 dma_pool_free(ha->s_dma_pool, lg, lg_dma); 1739 1740 return rval; 1741 } 1742 1743 /* 1744 * qla2x00_fabric_logout 1745 * Issue logout fabric port mailbox command. 1746 * 1747 * Input: 1748 * ha = adapter block pointer. 1749 * loop_id = device loop ID. 1750 * TARGET_QUEUE_LOCK must be released. 1751 * ADAPTER_STATE_LOCK must be released. 1752 * 1753 * Returns: 1754 * qla2x00 local function return status code. 1755 * 1756 * Context: 1757 * Kernel context. 1758 */ 1759 int 1760 qla2x00_fabric_logout(scsi_qla_host_t *ha, uint16_t loop_id, uint8_t domain, 1761 uint8_t area, uint8_t al_pa) 1762 { 1763 int rval; 1764 mbx_cmd_t mc; 1765 mbx_cmd_t *mcp = &mc; 1766 1767 DEBUG11(printk("qla2x00_fabric_logout(%ld): entered.\n", 1768 ha->host_no)); 1769 1770 mcp->mb[0] = MBC_LOGOUT_FABRIC_PORT; 1771 mcp->out_mb = MBX_1|MBX_0; 1772 if (HAS_EXTENDED_IDS(ha)) { 1773 mcp->mb[1] = loop_id; 1774 mcp->mb[10] = 0; 1775 mcp->out_mb |= MBX_10; 1776 } else { 1777 mcp->mb[1] = loop_id << 8; 1778 } 1779 1780 mcp->in_mb = MBX_1|MBX_0; 1781 mcp->tov = 30; 1782 mcp->flags = 0; 1783 rval = qla2x00_mailbox_command(ha, mcp); 1784 1785 if (rval != QLA_SUCCESS) { 1786 /*EMPTY*/ 1787 DEBUG2_3_11(printk("qla2x00_fabric_logout(%ld): failed=%x " 1788 "mbx1=%x.\n", ha->host_no, rval, mcp->mb[1])); 1789 } else { 1790 /*EMPTY*/ 1791 DEBUG11(printk("qla2x00_fabric_logout(%ld): done.\n", 1792 ha->host_no)); 1793 } 1794 1795 return rval; 1796 } 1797 1798 /* 1799 * qla2x00_full_login_lip 1800 * Issue full login LIP mailbox command. 1801 * 1802 * Input: 1803 * ha = adapter block pointer. 1804 * TARGET_QUEUE_LOCK must be released. 1805 * ADAPTER_STATE_LOCK must be released. 1806 * 1807 * Returns: 1808 * qla2x00 local function return status code. 1809 * 1810 * Context: 1811 * Kernel context. 1812 */ 1813 int 1814 qla2x00_full_login_lip(scsi_qla_host_t *ha) 1815 { 1816 int rval; 1817 mbx_cmd_t mc; 1818 mbx_cmd_t *mcp = &mc; 1819 1820 DEBUG11(printk("qla2x00_full_login_lip(%ld): entered.\n", 1821 ha->host_no)); 1822 1823 mcp->mb[0] = MBC_LIP_FULL_LOGIN; 1824 mcp->mb[1] = IS_FWI2_CAPABLE(ha) ? BIT_3: 0; 1825 mcp->mb[2] = 0; 1826 mcp->mb[3] = 0; 1827 mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0; 1828 mcp->in_mb = MBX_0; 1829 mcp->tov = 30; 1830 mcp->flags = 0; 1831 rval = qla2x00_mailbox_command(ha, mcp); 1832 1833 if (rval != QLA_SUCCESS) { 1834 /*EMPTY*/ 1835 DEBUG2_3_11(printk("qla2x00_full_login_lip(%ld): failed=%x.\n", 1836 ha->host_no, rval)); 1837 } else { 1838 /*EMPTY*/ 1839 DEBUG11(printk("qla2x00_full_login_lip(%ld): done.\n", 1840 ha->host_no)); 1841 } 1842 1843 return rval; 1844 } 1845 1846 /* 1847 * qla2x00_get_id_list 1848 * 1849 * Input: 1850 * ha = adapter block pointer. 1851 * 1852 * Returns: 1853 * qla2x00 local function return status code. 1854 * 1855 * Context: 1856 * Kernel context. 1857 */ 1858 int 1859 qla2x00_get_id_list(scsi_qla_host_t *ha, void *id_list, dma_addr_t id_list_dma, 1860 uint16_t *entries) 1861 { 1862 int rval; 1863 mbx_cmd_t mc; 1864 mbx_cmd_t *mcp = &mc; 1865 1866 DEBUG11(printk("qla2x00_get_id_list(%ld): entered.\n", 1867 ha->host_no)); 1868 1869 if (id_list == NULL) 1870 return QLA_FUNCTION_FAILED; 1871 1872 mcp->mb[0] = MBC_GET_ID_LIST; 1873 mcp->out_mb = MBX_0; 1874 if (IS_FWI2_CAPABLE(ha)) { 1875 mcp->mb[2] = MSW(id_list_dma); 1876 mcp->mb[3] = LSW(id_list_dma); 1877 mcp->mb[6] = MSW(MSD(id_list_dma)); 1878 mcp->mb[7] = LSW(MSD(id_list_dma)); 1879 mcp->mb[8] = 0; 1880 mcp->mb[9] = ha->vp_idx; 1881 mcp->out_mb |= MBX_9|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2; 1882 } else { 1883 mcp->mb[1] = MSW(id_list_dma); 1884 mcp->mb[2] = LSW(id_list_dma); 1885 mcp->mb[3] = MSW(MSD(id_list_dma)); 1886 mcp->mb[6] = LSW(MSD(id_list_dma)); 1887 mcp->out_mb |= MBX_6|MBX_3|MBX_2|MBX_1; 1888 } 1889 mcp->in_mb = MBX_1|MBX_0; 1890 mcp->tov = 30; 1891 mcp->flags = 0; 1892 rval = qla2x00_mailbox_command(ha, mcp); 1893 1894 if (rval != QLA_SUCCESS) { 1895 /*EMPTY*/ 1896 DEBUG2_3_11(printk("qla2x00_get_id_list(%ld): failed=%x.\n", 1897 ha->host_no, rval)); 1898 } else { 1899 *entries = mcp->mb[1]; 1900 DEBUG11(printk("qla2x00_get_id_list(%ld): done.\n", 1901 ha->host_no)); 1902 } 1903 1904 return rval; 1905 } 1906 1907 /* 1908 * qla2x00_get_resource_cnts 1909 * Get current firmware resource counts. 1910 * 1911 * Input: 1912 * ha = adapter block pointer. 1913 * 1914 * Returns: 1915 * qla2x00 local function return status code. 1916 * 1917 * Context: 1918 * Kernel context. 1919 */ 1920 int 1921 qla2x00_get_resource_cnts(scsi_qla_host_t *ha, uint16_t *cur_xchg_cnt, 1922 uint16_t *orig_xchg_cnt, uint16_t *cur_iocb_cnt, uint16_t *orig_iocb_cnt) 1923 { 1924 int rval; 1925 mbx_cmd_t mc; 1926 mbx_cmd_t *mcp = &mc; 1927 1928 DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no)); 1929 1930 mcp->mb[0] = MBC_GET_RESOURCE_COUNTS; 1931 mcp->out_mb = MBX_0; 1932 mcp->in_mb = MBX_10|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0; 1933 mcp->tov = 30; 1934 mcp->flags = 0; 1935 rval = qla2x00_mailbox_command(ha, mcp); 1936 1937 if (rval != QLA_SUCCESS) { 1938 /*EMPTY*/ 1939 DEBUG2_3_11(printk("%s(%ld): failed = %x.\n", __func__, 1940 ha->host_no, mcp->mb[0])); 1941 } else { 1942 DEBUG11(printk("%s(%ld): done. mb1=%x mb2=%x mb3=%x mb6=%x " 1943 "mb7=%x mb10=%x.\n", __func__, ha->host_no, 1944 mcp->mb[1], mcp->mb[2], mcp->mb[3], mcp->mb[6], mcp->mb[7], 1945 mcp->mb[10])); 1946 1947 if (cur_xchg_cnt) 1948 *cur_xchg_cnt = mcp->mb[3]; 1949 if (orig_xchg_cnt) 1950 *orig_xchg_cnt = mcp->mb[6]; 1951 if (cur_iocb_cnt) 1952 *cur_iocb_cnt = mcp->mb[7]; 1953 if (orig_iocb_cnt) 1954 *orig_iocb_cnt = mcp->mb[10]; 1955 } 1956 1957 return (rval); 1958 } 1959 1960 #if defined(QL_DEBUG_LEVEL_3) 1961 /* 1962 * qla2x00_get_fcal_position_map 1963 * Get FCAL (LILP) position map using mailbox command 1964 * 1965 * Input: 1966 * ha = adapter state pointer. 1967 * pos_map = buffer pointer (can be NULL). 1968 * 1969 * Returns: 1970 * qla2x00 local function return status code. 1971 * 1972 * Context: 1973 * Kernel context. 1974 */ 1975 int 1976 qla2x00_get_fcal_position_map(scsi_qla_host_t *ha, char *pos_map) 1977 { 1978 int rval; 1979 mbx_cmd_t mc; 1980 mbx_cmd_t *mcp = &mc; 1981 char *pmap; 1982 dma_addr_t pmap_dma; 1983 1984 pmap = dma_pool_alloc(ha->s_dma_pool, GFP_ATOMIC, &pmap_dma); 1985 if (pmap == NULL) { 1986 DEBUG2_3_11(printk("%s(%ld): **** Mem Alloc Failed ****", 1987 __func__, ha->host_no)); 1988 return QLA_MEMORY_ALLOC_FAILED; 1989 } 1990 memset(pmap, 0, FCAL_MAP_SIZE); 1991 1992 mcp->mb[0] = MBC_GET_FC_AL_POSITION_MAP; 1993 mcp->mb[2] = MSW(pmap_dma); 1994 mcp->mb[3] = LSW(pmap_dma); 1995 mcp->mb[6] = MSW(MSD(pmap_dma)); 1996 mcp->mb[7] = LSW(MSD(pmap_dma)); 1997 mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_0; 1998 mcp->in_mb = MBX_1|MBX_0; 1999 mcp->buf_size = FCAL_MAP_SIZE; 2000 mcp->flags = MBX_DMA_IN; 2001 mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2); 2002 rval = qla2x00_mailbox_command(ha, mcp); 2003 2004 if (rval == QLA_SUCCESS) { 2005 DEBUG11(printk("%s(%ld): (mb0=%x/mb1=%x) FC/AL Position Map " 2006 "size (%x)\n", __func__, ha->host_no, mcp->mb[0], 2007 mcp->mb[1], (unsigned)pmap[0])); 2008 DEBUG11(qla2x00_dump_buffer(pmap, pmap[0] + 1)); 2009 2010 if (pos_map) 2011 memcpy(pos_map, pmap, FCAL_MAP_SIZE); 2012 } 2013 dma_pool_free(ha->s_dma_pool, pmap, pmap_dma); 2014 2015 if (rval != QLA_SUCCESS) { 2016 DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__, 2017 ha->host_no, rval)); 2018 } else { 2019 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no)); 2020 } 2021 2022 return rval; 2023 } 2024 #endif 2025 2026 /* 2027 * qla2x00_get_link_status 2028 * 2029 * Input: 2030 * ha = adapter block pointer. 2031 * loop_id = device loop ID. 2032 * ret_buf = pointer to link status return buffer. 2033 * 2034 * Returns: 2035 * 0 = success. 2036 * BIT_0 = mem alloc error. 2037 * BIT_1 = mailbox error. 2038 */ 2039 int 2040 qla2x00_get_link_status(scsi_qla_host_t *ha, uint16_t loop_id, 2041 link_stat_t *ret_buf, uint16_t *status) 2042 { 2043 int rval; 2044 mbx_cmd_t mc; 2045 mbx_cmd_t *mcp = &mc; 2046 link_stat_t *stat_buf; 2047 dma_addr_t stat_buf_dma; 2048 2049 DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no)); 2050 2051 stat_buf = dma_pool_alloc(ha->s_dma_pool, GFP_ATOMIC, &stat_buf_dma); 2052 if (stat_buf == NULL) { 2053 DEBUG2_3_11(printk("%s(%ld): Failed to allocate memory.\n", 2054 __func__, ha->host_no)); 2055 return BIT_0; 2056 } 2057 memset(stat_buf, 0, sizeof(link_stat_t)); 2058 2059 mcp->mb[0] = MBC_GET_LINK_STATUS; 2060 mcp->mb[2] = MSW(stat_buf_dma); 2061 mcp->mb[3] = LSW(stat_buf_dma); 2062 mcp->mb[6] = MSW(MSD(stat_buf_dma)); 2063 mcp->mb[7] = LSW(MSD(stat_buf_dma)); 2064 mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_0; 2065 mcp->in_mb = MBX_0; 2066 if (IS_FWI2_CAPABLE(ha)) { 2067 mcp->mb[1] = loop_id; 2068 mcp->mb[4] = 0; 2069 mcp->mb[10] = 0; 2070 mcp->out_mb |= MBX_10|MBX_4|MBX_1; 2071 mcp->in_mb |= MBX_1; 2072 } else if (HAS_EXTENDED_IDS(ha)) { 2073 mcp->mb[1] = loop_id; 2074 mcp->mb[10] = 0; 2075 mcp->out_mb |= MBX_10|MBX_1; 2076 } else { 2077 mcp->mb[1] = loop_id << 8; 2078 mcp->out_mb |= MBX_1; 2079 } 2080 mcp->tov = 30; 2081 mcp->flags = IOCTL_CMD; 2082 rval = qla2x00_mailbox_command(ha, mcp); 2083 2084 if (rval == QLA_SUCCESS) { 2085 if (mcp->mb[0] != MBS_COMMAND_COMPLETE) { 2086 DEBUG2_3_11(printk("%s(%ld): cmd failed. mbx0=%x.\n", 2087 __func__, ha->host_no, mcp->mb[0])); 2088 status[0] = mcp->mb[0]; 2089 rval = BIT_1; 2090 } else { 2091 /* copy over data -- firmware data is LE. */ 2092 ret_buf->link_fail_cnt = 2093 le32_to_cpu(stat_buf->link_fail_cnt); 2094 ret_buf->loss_sync_cnt = 2095 le32_to_cpu(stat_buf->loss_sync_cnt); 2096 ret_buf->loss_sig_cnt = 2097 le32_to_cpu(stat_buf->loss_sig_cnt); 2098 ret_buf->prim_seq_err_cnt = 2099 le32_to_cpu(stat_buf->prim_seq_err_cnt); 2100 ret_buf->inval_xmit_word_cnt = 2101 le32_to_cpu(stat_buf->inval_xmit_word_cnt); 2102 ret_buf->inval_crc_cnt = 2103 le32_to_cpu(stat_buf->inval_crc_cnt); 2104 2105 DEBUG11(printk("%s(%ld): stat dump: fail_cnt=%d " 2106 "loss_sync=%d loss_sig=%d seq_err=%d " 2107 "inval_xmt_word=%d inval_crc=%d.\n", __func__, 2108 ha->host_no, stat_buf->link_fail_cnt, 2109 stat_buf->loss_sync_cnt, stat_buf->loss_sig_cnt, 2110 stat_buf->prim_seq_err_cnt, 2111 stat_buf->inval_xmit_word_cnt, 2112 stat_buf->inval_crc_cnt)); 2113 } 2114 } else { 2115 /* Failed. */ 2116 DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__, 2117 ha->host_no, rval)); 2118 rval = BIT_1; 2119 } 2120 2121 dma_pool_free(ha->s_dma_pool, stat_buf, stat_buf_dma); 2122 2123 return rval; 2124 } 2125 2126 int 2127 qla24xx_get_isp_stats(scsi_qla_host_t *ha, uint32_t *dwbuf, uint32_t dwords, 2128 uint16_t *status) 2129 { 2130 int rval; 2131 mbx_cmd_t mc; 2132 mbx_cmd_t *mcp = &mc; 2133 uint32_t *sbuf, *siter; 2134 dma_addr_t sbuf_dma; 2135 2136 DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no)); 2137 2138 if (dwords > (DMA_POOL_SIZE / 4)) { 2139 DEBUG2_3_11(printk("%s(%ld): Unabled to retrieve %d DWORDs " 2140 "(max %d).\n", __func__, ha->host_no, dwords, 2141 DMA_POOL_SIZE / 4)); 2142 return BIT_0; 2143 } 2144 sbuf = dma_pool_alloc(ha->s_dma_pool, GFP_ATOMIC, &sbuf_dma); 2145 if (sbuf == NULL) { 2146 DEBUG2_3_11(printk("%s(%ld): Failed to allocate memory.\n", 2147 __func__, ha->host_no)); 2148 return BIT_0; 2149 } 2150 memset(sbuf, 0, DMA_POOL_SIZE); 2151 2152 mcp->mb[0] = MBC_GET_LINK_PRIV_STATS; 2153 mcp->mb[2] = MSW(sbuf_dma); 2154 mcp->mb[3] = LSW(sbuf_dma); 2155 mcp->mb[6] = MSW(MSD(sbuf_dma)); 2156 mcp->mb[7] = LSW(MSD(sbuf_dma)); 2157 mcp->mb[8] = dwords; 2158 mcp->mb[10] = 0; 2159 mcp->out_mb = MBX_10|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_0; 2160 mcp->in_mb = MBX_2|MBX_1|MBX_0; 2161 mcp->tov = 30; 2162 mcp->flags = IOCTL_CMD; 2163 rval = qla2x00_mailbox_command(ha, mcp); 2164 2165 if (rval == QLA_SUCCESS) { 2166 if (mcp->mb[0] != MBS_COMMAND_COMPLETE) { 2167 DEBUG2_3_11(printk("%s(%ld): cmd failed. mbx0=%x.\n", 2168 __func__, ha->host_no, mcp->mb[0])); 2169 status[0] = mcp->mb[0]; 2170 rval = BIT_1; 2171 } else { 2172 /* Copy over data -- firmware data is LE. */ 2173 siter = sbuf; 2174 while (dwords--) 2175 *dwbuf++ = le32_to_cpu(*siter++); 2176 } 2177 } else { 2178 /* Failed. */ 2179 DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__, 2180 ha->host_no, rval)); 2181 rval = BIT_1; 2182 } 2183 2184 dma_pool_free(ha->s_dma_pool, sbuf, sbuf_dma); 2185 2186 return rval; 2187 } 2188 2189 int 2190 qla24xx_abort_command(scsi_qla_host_t *ha, srb_t *sp) 2191 { 2192 int rval; 2193 fc_port_t *fcport; 2194 unsigned long flags = 0; 2195 2196 struct abort_entry_24xx *abt; 2197 dma_addr_t abt_dma; 2198 uint32_t handle; 2199 2200 DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no)); 2201 2202 fcport = sp->fcport; 2203 2204 spin_lock_irqsave(&ha->hardware_lock, flags); 2205 for (handle = 1; handle < MAX_OUTSTANDING_COMMANDS; handle++) { 2206 if (ha->outstanding_cmds[handle] == sp) 2207 break; 2208 } 2209 spin_unlock_irqrestore(&ha->hardware_lock, flags); 2210 if (handle == MAX_OUTSTANDING_COMMANDS) { 2211 /* Command not found. */ 2212 return QLA_FUNCTION_FAILED; 2213 } 2214 2215 abt = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &abt_dma); 2216 if (abt == NULL) { 2217 DEBUG2_3(printk("%s(%ld): failed to allocate Abort IOCB.\n", 2218 __func__, ha->host_no)); 2219 return QLA_MEMORY_ALLOC_FAILED; 2220 } 2221 memset(abt, 0, sizeof(struct abort_entry_24xx)); 2222 2223 abt->entry_type = ABORT_IOCB_TYPE; 2224 abt->entry_count = 1; 2225 abt->nport_handle = cpu_to_le16(fcport->loop_id); 2226 abt->handle_to_abort = handle; 2227 abt->port_id[0] = fcport->d_id.b.al_pa; 2228 abt->port_id[1] = fcport->d_id.b.area; 2229 abt->port_id[2] = fcport->d_id.b.domain; 2230 abt->vp_index = fcport->vp_idx; 2231 rval = qla2x00_issue_iocb(ha, abt, abt_dma, 0); 2232 if (rval != QLA_SUCCESS) { 2233 DEBUG2_3_11(printk("%s(%ld): failed to issue IOCB (%x).\n", 2234 __func__, ha->host_no, rval)); 2235 } else if (abt->entry_status != 0) { 2236 DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB " 2237 "-- error status (%x).\n", __func__, ha->host_no, 2238 abt->entry_status)); 2239 rval = QLA_FUNCTION_FAILED; 2240 } else if (abt->nport_handle != __constant_cpu_to_le16(0)) { 2241 DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB " 2242 "-- completion status (%x).\n", __func__, ha->host_no, 2243 le16_to_cpu(abt->nport_handle))); 2244 rval = QLA_FUNCTION_FAILED; 2245 } else { 2246 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no)); 2247 sp->flags |= SRB_ABORT_PENDING; 2248 } 2249 2250 dma_pool_free(ha->s_dma_pool, abt, abt_dma); 2251 2252 return rval; 2253 } 2254 2255 struct tsk_mgmt_cmd { 2256 union { 2257 struct tsk_mgmt_entry tsk; 2258 struct sts_entry_24xx sts; 2259 } p; 2260 }; 2261 2262 int 2263 qla24xx_abort_target(fc_port_t *fcport) 2264 { 2265 int rval; 2266 struct tsk_mgmt_cmd *tsk; 2267 dma_addr_t tsk_dma; 2268 scsi_qla_host_t *ha, *pha; 2269 2270 if (fcport == NULL) 2271 return 0; 2272 2273 DEBUG11(printk("%s(%ld): entered.\n", __func__, fcport->ha->host_no)); 2274 2275 ha = fcport->ha; 2276 pha = to_qla_parent(ha); 2277 tsk = dma_pool_alloc(pha->s_dma_pool, GFP_KERNEL, &tsk_dma); 2278 if (tsk == NULL) { 2279 DEBUG2_3(printk("%s(%ld): failed to allocate Task Management " 2280 "IOCB.\n", __func__, ha->host_no)); 2281 return QLA_MEMORY_ALLOC_FAILED; 2282 } 2283 memset(tsk, 0, sizeof(struct tsk_mgmt_cmd)); 2284 2285 tsk->p.tsk.entry_type = TSK_MGMT_IOCB_TYPE; 2286 tsk->p.tsk.entry_count = 1; 2287 tsk->p.tsk.nport_handle = cpu_to_le16(fcport->loop_id); 2288 tsk->p.tsk.timeout = __constant_cpu_to_le16(25); 2289 tsk->p.tsk.control_flags = __constant_cpu_to_le32(TCF_TARGET_RESET); 2290 tsk->p.tsk.port_id[0] = fcport->d_id.b.al_pa; 2291 tsk->p.tsk.port_id[1] = fcport->d_id.b.area; 2292 tsk->p.tsk.port_id[2] = fcport->d_id.b.domain; 2293 tsk->p.tsk.vp_index = fcport->vp_idx; 2294 2295 rval = qla2x00_issue_iocb(ha, tsk, tsk_dma, 0); 2296 if (rval != QLA_SUCCESS) { 2297 DEBUG2_3_11(printk("%s(%ld): failed to issue Target Reset IOCB " 2298 "(%x).\n", __func__, ha->host_no, rval)); 2299 goto atarget_done; 2300 } else if (tsk->p.sts.entry_status != 0) { 2301 DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB " 2302 "-- error status (%x).\n", __func__, ha->host_no, 2303 tsk->p.sts.entry_status)); 2304 rval = QLA_FUNCTION_FAILED; 2305 goto atarget_done; 2306 } else if (tsk->p.sts.comp_status != 2307 __constant_cpu_to_le16(CS_COMPLETE)) { 2308 DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB " 2309 "-- completion status (%x).\n", __func__, 2310 ha->host_no, le16_to_cpu(tsk->p.sts.comp_status))); 2311 rval = QLA_FUNCTION_FAILED; 2312 goto atarget_done; 2313 } 2314 2315 /* Issue marker IOCB. */ 2316 rval = qla2x00_marker(ha, fcport->loop_id, 0, MK_SYNC_ID); 2317 if (rval != QLA_SUCCESS) { 2318 DEBUG2_3_11(printk("%s(%ld): failed to issue Marker IOCB " 2319 "(%x).\n", __func__, ha->host_no, rval)); 2320 } else { 2321 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no)); 2322 } 2323 2324 atarget_done: 2325 dma_pool_free(pha->s_dma_pool, tsk, tsk_dma); 2326 2327 return rval; 2328 } 2329 2330 int 2331 qla2x00_system_error(scsi_qla_host_t *ha) 2332 { 2333 int rval; 2334 mbx_cmd_t mc; 2335 mbx_cmd_t *mcp = &mc; 2336 2337 if (!IS_FWI2_CAPABLE(ha)) 2338 return QLA_FUNCTION_FAILED; 2339 2340 DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no)); 2341 2342 mcp->mb[0] = MBC_GEN_SYSTEM_ERROR; 2343 mcp->out_mb = MBX_0; 2344 mcp->in_mb = MBX_0; 2345 mcp->tov = 5; 2346 mcp->flags = 0; 2347 rval = qla2x00_mailbox_command(ha, mcp); 2348 2349 if (rval != QLA_SUCCESS) { 2350 DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__, 2351 ha->host_no, rval)); 2352 } else { 2353 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no)); 2354 } 2355 2356 return rval; 2357 } 2358 2359 /** 2360 * qla2x00_get_serdes_params() - 2361 * @ha: HA context 2362 * 2363 * Returns 2364 */ 2365 int 2366 qla2x00_get_serdes_params(scsi_qla_host_t *ha, uint16_t *sw_em_1g, 2367 uint16_t *sw_em_2g, uint16_t *sw_em_4g) 2368 { 2369 int rval; 2370 mbx_cmd_t mc; 2371 mbx_cmd_t *mcp = &mc; 2372 2373 DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no)); 2374 2375 mcp->mb[0] = MBC_SERDES_PARAMS; 2376 mcp->mb[1] = 0; 2377 mcp->out_mb = MBX_1|MBX_0; 2378 mcp->in_mb = MBX_4|MBX_3|MBX_2|MBX_0; 2379 mcp->tov = 30; 2380 mcp->flags = 0; 2381 rval = qla2x00_mailbox_command(ha, mcp); 2382 2383 if (rval != QLA_SUCCESS) { 2384 /*EMPTY*/ 2385 DEBUG2_3_11(printk("%s(%ld): failed=%x (%x).\n", __func__, 2386 ha->host_no, rval, mcp->mb[0])); 2387 } else { 2388 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no)); 2389 2390 if (sw_em_1g) 2391 *sw_em_1g = mcp->mb[2]; 2392 if (sw_em_2g) 2393 *sw_em_2g = mcp->mb[3]; 2394 if (sw_em_4g) 2395 *sw_em_4g = mcp->mb[4]; 2396 } 2397 2398 return rval; 2399 } 2400 2401 /** 2402 * qla2x00_set_serdes_params() - 2403 * @ha: HA context 2404 * 2405 * Returns 2406 */ 2407 int 2408 qla2x00_set_serdes_params(scsi_qla_host_t *ha, uint16_t sw_em_1g, 2409 uint16_t sw_em_2g, uint16_t sw_em_4g) 2410 { 2411 int rval; 2412 mbx_cmd_t mc; 2413 mbx_cmd_t *mcp = &mc; 2414 2415 DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no)); 2416 2417 mcp->mb[0] = MBC_SERDES_PARAMS; 2418 mcp->mb[1] = BIT_0; 2419 mcp->mb[2] = sw_em_1g | BIT_15; 2420 mcp->mb[3] = sw_em_2g | BIT_15; 2421 mcp->mb[4] = sw_em_4g | BIT_15; 2422 mcp->out_mb = MBX_4|MBX_3|MBX_2|MBX_1|MBX_0; 2423 mcp->in_mb = MBX_0; 2424 mcp->tov = 30; 2425 mcp->flags = 0; 2426 rval = qla2x00_mailbox_command(ha, mcp); 2427 2428 if (rval != QLA_SUCCESS) { 2429 /*EMPTY*/ 2430 DEBUG2_3_11(printk("%s(%ld): failed=%x (%x).\n", __func__, 2431 ha->host_no, rval, mcp->mb[0])); 2432 } else { 2433 /*EMPTY*/ 2434 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no)); 2435 } 2436 2437 return rval; 2438 } 2439 2440 int 2441 qla2x00_stop_firmware(scsi_qla_host_t *ha) 2442 { 2443 int rval; 2444 mbx_cmd_t mc; 2445 mbx_cmd_t *mcp = &mc; 2446 2447 if (!IS_FWI2_CAPABLE(ha)) 2448 return QLA_FUNCTION_FAILED; 2449 2450 DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no)); 2451 2452 mcp->mb[0] = MBC_STOP_FIRMWARE; 2453 mcp->out_mb = MBX_0; 2454 mcp->in_mb = MBX_0; 2455 mcp->tov = 5; 2456 mcp->flags = 0; 2457 rval = qla2x00_mailbox_command(ha, mcp); 2458 2459 if (rval != QLA_SUCCESS) { 2460 DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__, 2461 ha->host_no, rval)); 2462 } else { 2463 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no)); 2464 } 2465 2466 return rval; 2467 } 2468 2469 int 2470 qla2x00_trace_control(scsi_qla_host_t *ha, uint16_t ctrl, dma_addr_t eft_dma, 2471 uint16_t buffers) 2472 { 2473 int rval; 2474 mbx_cmd_t mc; 2475 mbx_cmd_t *mcp = &mc; 2476 2477 if (!IS_FWI2_CAPABLE(ha)) 2478 return QLA_FUNCTION_FAILED; 2479 2480 DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no)); 2481 2482 mcp->mb[0] = MBC_TRACE_CONTROL; 2483 mcp->mb[1] = ctrl; 2484 mcp->out_mb = MBX_1|MBX_0; 2485 mcp->in_mb = MBX_1|MBX_0; 2486 if (ctrl == TC_ENABLE) { 2487 mcp->mb[2] = LSW(eft_dma); 2488 mcp->mb[3] = MSW(eft_dma); 2489 mcp->mb[4] = LSW(MSD(eft_dma)); 2490 mcp->mb[5] = MSW(MSD(eft_dma)); 2491 mcp->mb[6] = buffers; 2492 mcp->mb[7] = 0; 2493 mcp->out_mb |= MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2; 2494 } 2495 mcp->tov = 30; 2496 mcp->flags = 0; 2497 rval = qla2x00_mailbox_command(ha, mcp); 2498 2499 if (rval != QLA_SUCCESS) { 2500 DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x mb[1]=%x.\n", 2501 __func__, ha->host_no, rval, mcp->mb[0], mcp->mb[1])); 2502 } else { 2503 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no)); 2504 } 2505 2506 return rval; 2507 } 2508 2509 int 2510 qla2x00_read_sfp(scsi_qla_host_t *ha, dma_addr_t sfp_dma, uint16_t addr, 2511 uint16_t off, uint16_t count) 2512 { 2513 int rval; 2514 mbx_cmd_t mc; 2515 mbx_cmd_t *mcp = &mc; 2516 2517 if (!IS_FWI2_CAPABLE(ha)) 2518 return QLA_FUNCTION_FAILED; 2519 2520 DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no)); 2521 2522 mcp->mb[0] = MBC_READ_SFP; 2523 mcp->mb[1] = addr; 2524 mcp->mb[2] = MSW(sfp_dma); 2525 mcp->mb[3] = LSW(sfp_dma); 2526 mcp->mb[6] = MSW(MSD(sfp_dma)); 2527 mcp->mb[7] = LSW(MSD(sfp_dma)); 2528 mcp->mb[8] = count; 2529 mcp->mb[9] = off; 2530 mcp->mb[10] = 0; 2531 mcp->out_mb = MBX_10|MBX_9|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0; 2532 mcp->in_mb = MBX_0; 2533 mcp->tov = 30; 2534 mcp->flags = 0; 2535 rval = qla2x00_mailbox_command(ha, mcp); 2536 2537 if (rval != QLA_SUCCESS) { 2538 DEBUG2_3_11(printk("%s(%ld): failed=%x (%x).\n", __func__, 2539 ha->host_no, rval, mcp->mb[0])); 2540 } else { 2541 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no)); 2542 } 2543 2544 return rval; 2545 } 2546 2547 int 2548 qla2x00_get_idma_speed(scsi_qla_host_t *ha, uint16_t loop_id, 2549 uint16_t *port_speed, uint16_t *mb) 2550 { 2551 int rval; 2552 mbx_cmd_t mc; 2553 mbx_cmd_t *mcp = &mc; 2554 2555 if (!IS_IIDMA_CAPABLE(ha)) 2556 return QLA_FUNCTION_FAILED; 2557 2558 DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no)); 2559 2560 mcp->mb[0] = MBC_PORT_PARAMS; 2561 mcp->mb[1] = loop_id; 2562 mcp->mb[2] = mcp->mb[3] = mcp->mb[4] = mcp->mb[5] = 0; 2563 mcp->out_mb = MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0; 2564 mcp->in_mb = MBX_5|MBX_4|MBX_3|MBX_1|MBX_0; 2565 mcp->tov = 30; 2566 mcp->flags = 0; 2567 rval = qla2x00_mailbox_command(ha, mcp); 2568 2569 /* Return mailbox statuses. */ 2570 if (mb != NULL) { 2571 mb[0] = mcp->mb[0]; 2572 mb[1] = mcp->mb[1]; 2573 mb[3] = mcp->mb[3]; 2574 mb[4] = mcp->mb[4]; 2575 mb[5] = mcp->mb[5]; 2576 } 2577 2578 if (rval != QLA_SUCCESS) { 2579 DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__, 2580 ha->host_no, rval)); 2581 } else { 2582 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no)); 2583 if (port_speed) 2584 *port_speed = mcp->mb[3]; 2585 } 2586 2587 return rval; 2588 } 2589 2590 int 2591 qla2x00_set_idma_speed(scsi_qla_host_t *ha, uint16_t loop_id, 2592 uint16_t port_speed, uint16_t *mb) 2593 { 2594 int rval; 2595 mbx_cmd_t mc; 2596 mbx_cmd_t *mcp = &mc; 2597 2598 if (!IS_IIDMA_CAPABLE(ha)) 2599 return QLA_FUNCTION_FAILED; 2600 2601 DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no)); 2602 2603 mcp->mb[0] = MBC_PORT_PARAMS; 2604 mcp->mb[1] = loop_id; 2605 mcp->mb[2] = BIT_0; 2606 mcp->mb[3] = port_speed & (BIT_2|BIT_1|BIT_0); 2607 mcp->mb[4] = mcp->mb[5] = 0; 2608 mcp->out_mb = MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0; 2609 mcp->in_mb = MBX_5|MBX_4|MBX_3|MBX_1|MBX_0; 2610 mcp->tov = 30; 2611 mcp->flags = 0; 2612 rval = qla2x00_mailbox_command(ha, mcp); 2613 2614 /* Return mailbox statuses. */ 2615 if (mb != NULL) { 2616 mb[0] = mcp->mb[0]; 2617 mb[1] = mcp->mb[1]; 2618 mb[3] = mcp->mb[3]; 2619 mb[4] = mcp->mb[4]; 2620 mb[5] = mcp->mb[5]; 2621 } 2622 2623 if (rval != QLA_SUCCESS) { 2624 DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__, 2625 ha->host_no, rval)); 2626 } else { 2627 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no)); 2628 } 2629 2630 return rval; 2631 } 2632 2633 /* 2634 * qla24xx_get_vp_database 2635 * Get the VP's database for all configured ports. 2636 * 2637 * Input: 2638 * ha = adapter block pointer. 2639 * size = size of initialization control block. 2640 * 2641 * Returns: 2642 * qla2x00 local function return status code. 2643 * 2644 * Context: 2645 * Kernel context. 2646 */ 2647 int 2648 qla24xx_get_vp_database(scsi_qla_host_t *ha, uint16_t size) 2649 { 2650 int rval; 2651 mbx_cmd_t mc; 2652 mbx_cmd_t *mcp = &mc; 2653 2654 DEBUG11(printk("scsi(%ld):%s - entered.\n", 2655 ha->host_no, __func__)); 2656 2657 mcp->mb[0] = MBC_MID_GET_VP_DATABASE; 2658 mcp->mb[2] = MSW(ha->init_cb_dma); 2659 mcp->mb[3] = LSW(ha->init_cb_dma); 2660 mcp->mb[4] = 0; 2661 mcp->mb[5] = 0; 2662 mcp->mb[6] = MSW(MSD(ha->init_cb_dma)); 2663 mcp->mb[7] = LSW(MSD(ha->init_cb_dma)); 2664 mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_0; 2665 mcp->in_mb = MBX_1|MBX_0; 2666 mcp->buf_size = size; 2667 mcp->flags = MBX_DMA_OUT; 2668 mcp->tov = MBX_TOV_SECONDS; 2669 rval = qla2x00_mailbox_command(ha, mcp); 2670 2671 if (rval != QLA_SUCCESS) { 2672 /*EMPTY*/ 2673 DEBUG2_3_11(printk("%s(%ld): failed=%x " 2674 "mb0=%x.\n", 2675 __func__, ha->host_no, rval, mcp->mb[0])); 2676 } else { 2677 /*EMPTY*/ 2678 DEBUG11(printk("%s(%ld): done.\n", 2679 __func__, ha->host_no)); 2680 } 2681 2682 return rval; 2683 } 2684 2685 int 2686 qla24xx_get_vp_entry(scsi_qla_host_t *ha, uint16_t size, int vp_id) 2687 { 2688 int rval; 2689 mbx_cmd_t mc; 2690 mbx_cmd_t *mcp = &mc; 2691 2692 DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no)); 2693 2694 mcp->mb[0] = MBC_MID_GET_VP_ENTRY; 2695 mcp->mb[2] = MSW(ha->init_cb_dma); 2696 mcp->mb[3] = LSW(ha->init_cb_dma); 2697 mcp->mb[4] = 0; 2698 mcp->mb[5] = 0; 2699 mcp->mb[6] = MSW(MSD(ha->init_cb_dma)); 2700 mcp->mb[7] = LSW(MSD(ha->init_cb_dma)); 2701 mcp->mb[9] = vp_id; 2702 mcp->out_mb = MBX_9|MBX_7|MBX_6|MBX_3|MBX_2|MBX_0; 2703 mcp->in_mb = MBX_0; 2704 mcp->buf_size = size; 2705 mcp->flags = MBX_DMA_OUT; 2706 mcp->tov = 30; 2707 rval = qla2x00_mailbox_command(ha, mcp); 2708 2709 if (rval != QLA_SUCCESS) { 2710 /*EMPTY*/ 2711 DEBUG2_3_11(printk("qla24xx_get_vp_entry(%ld): failed=%x " 2712 "mb0=%x.\n", 2713 ha->host_no, rval, mcp->mb[0])); 2714 } else { 2715 /*EMPTY*/ 2716 DEBUG11(printk("qla24xx_get_vp_entry(%ld): done.\n", 2717 ha->host_no)); 2718 } 2719 2720 return rval; 2721 } 2722 2723 void 2724 qla24xx_report_id_acquisition(scsi_qla_host_t *ha, 2725 struct vp_rpt_id_entry_24xx *rptid_entry) 2726 { 2727 uint8_t vp_idx; 2728 scsi_qla_host_t *vha; 2729 2730 if (rptid_entry->entry_status != 0) 2731 return; 2732 if (rptid_entry->entry_status != __constant_cpu_to_le16(CS_COMPLETE)) 2733 return; 2734 2735 if (rptid_entry->format == 0) { 2736 DEBUG15(printk("%s:format 0 : scsi(%ld) number of VPs setup %d," 2737 " number of VPs acquired %d\n", __func__, ha->host_no, 2738 MSB(rptid_entry->vp_count), LSB(rptid_entry->vp_count))); 2739 DEBUG15(printk("%s primary port id %02x%02x%02x\n", __func__, 2740 rptid_entry->port_id[2], rptid_entry->port_id[1], 2741 rptid_entry->port_id[0])); 2742 } else if (rptid_entry->format == 1) { 2743 vp_idx = LSB(rptid_entry->vp_idx); 2744 DEBUG15(printk("%s:format 1: scsi(%ld): VP[%d] enabled " 2745 "- status %d - " 2746 "with port id %02x%02x%02x\n",__func__,ha->host_no, 2747 vp_idx, MSB(rptid_entry->vp_idx), 2748 rptid_entry->port_id[2], rptid_entry->port_id[1], 2749 rptid_entry->port_id[0])); 2750 if (vp_idx == 0) 2751 return; 2752 2753 if (MSB(rptid_entry->vp_idx) == 1) 2754 return; 2755 2756 list_for_each_entry(vha, &ha->vp_list, vp_list) 2757 if (vp_idx == vha->vp_idx) 2758 break; 2759 2760 if (!vha) 2761 return; 2762 2763 vha->d_id.b.domain = rptid_entry->port_id[2]; 2764 vha->d_id.b.area = rptid_entry->port_id[1]; 2765 vha->d_id.b.al_pa = rptid_entry->port_id[0]; 2766 2767 /* 2768 * Cannot configure here as we are still sitting on the 2769 * response queue. Handle it in dpc context. 2770 */ 2771 set_bit(VP_IDX_ACQUIRED, &vha->vp_flags); 2772 set_bit(VP_DPC_NEEDED, &ha->dpc_flags); 2773 2774 wake_up_process(ha->dpc_thread); 2775 } 2776 } 2777 2778 /* 2779 * qla24xx_modify_vp_config 2780 * Change VP configuration for vha 2781 * 2782 * Input: 2783 * vha = adapter block pointer. 2784 * 2785 * Returns: 2786 * qla2xxx local function return status code. 2787 * 2788 * Context: 2789 * Kernel context. 2790 */ 2791 int 2792 qla24xx_modify_vp_config(scsi_qla_host_t *vha) 2793 { 2794 int rval; 2795 struct vp_config_entry_24xx *vpmod; 2796 dma_addr_t vpmod_dma; 2797 scsi_qla_host_t *pha; 2798 2799 /* This can be called by the parent */ 2800 pha = to_qla_parent(vha); 2801 2802 vpmod = dma_pool_alloc(pha->s_dma_pool, GFP_KERNEL, &vpmod_dma); 2803 if (!vpmod) { 2804 DEBUG2_3(printk("%s(%ld): failed to allocate Modify VP " 2805 "IOCB.\n", __func__, pha->host_no)); 2806 return QLA_MEMORY_ALLOC_FAILED; 2807 } 2808 2809 memset(vpmod, 0, sizeof(struct vp_config_entry_24xx)); 2810 vpmod->entry_type = VP_CONFIG_IOCB_TYPE; 2811 vpmod->entry_count = 1; 2812 vpmod->command = VCT_COMMAND_MOD_ENABLE_VPS; 2813 vpmod->vp_count = 1; 2814 vpmod->vp_index1 = vha->vp_idx; 2815 vpmod->options_idx1 = BIT_3|BIT_4|BIT_5; 2816 memcpy(vpmod->node_name_idx1, vha->node_name, WWN_SIZE); 2817 memcpy(vpmod->port_name_idx1, vha->port_name, WWN_SIZE); 2818 vpmod->entry_count = 1; 2819 2820 rval = qla2x00_issue_iocb(pha, vpmod, vpmod_dma, 0); 2821 if (rval != QLA_SUCCESS) { 2822 DEBUG2_3_11(printk("%s(%ld): failed to issue VP config IOCB" 2823 "(%x).\n", __func__, pha->host_no, rval)); 2824 } else if (vpmod->comp_status != 0) { 2825 DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB " 2826 "-- error status (%x).\n", __func__, pha->host_no, 2827 vpmod->comp_status)); 2828 rval = QLA_FUNCTION_FAILED; 2829 } else if (vpmod->comp_status != __constant_cpu_to_le16(CS_COMPLETE)) { 2830 DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB " 2831 "-- completion status (%x).\n", __func__, pha->host_no, 2832 le16_to_cpu(vpmod->comp_status))); 2833 rval = QLA_FUNCTION_FAILED; 2834 } else { 2835 /* EMPTY */ 2836 DEBUG11(printk("%s(%ld): done.\n", __func__, pha->host_no)); 2837 fc_vport_set_state(vha->fc_vport, FC_VPORT_INITIALIZING); 2838 } 2839 dma_pool_free(pha->s_dma_pool, vpmod, vpmod_dma); 2840 2841 return rval; 2842 } 2843 2844 /* 2845 * qla24xx_control_vp 2846 * Enable a virtual port for given host 2847 * 2848 * Input: 2849 * ha = adapter block pointer. 2850 * vhba = virtual adapter (unused) 2851 * index = index number for enabled VP 2852 * 2853 * Returns: 2854 * qla2xxx local function return status code. 2855 * 2856 * Context: 2857 * Kernel context. 2858 */ 2859 int 2860 qla24xx_control_vp(scsi_qla_host_t *vha, int cmd) 2861 { 2862 int rval; 2863 int map, pos; 2864 struct vp_ctrl_entry_24xx *vce; 2865 dma_addr_t vce_dma; 2866 scsi_qla_host_t *ha = vha->parent; 2867 int vp_index = vha->vp_idx; 2868 2869 DEBUG11(printk("%s(%ld): entered. Enabling index %d\n", __func__, 2870 ha->host_no, vp_index)); 2871 2872 if (vp_index == 0 || vp_index >= MAX_MULTI_ID_LOOP) 2873 return QLA_PARAMETER_ERROR; 2874 2875 vce = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &vce_dma); 2876 if (!vce) { 2877 DEBUG2_3(printk("%s(%ld): " 2878 "failed to allocate VP Control IOCB.\n", __func__, 2879 ha->host_no)); 2880 return QLA_MEMORY_ALLOC_FAILED; 2881 } 2882 memset(vce, 0, sizeof(struct vp_ctrl_entry_24xx)); 2883 2884 vce->entry_type = VP_CTRL_IOCB_TYPE; 2885 vce->entry_count = 1; 2886 vce->command = cpu_to_le16(cmd); 2887 vce->vp_count = __constant_cpu_to_le16(1); 2888 2889 /* index map in firmware starts with 1; decrement index 2890 * this is ok as we never use index 0 2891 */ 2892 map = (vp_index - 1) / 8; 2893 pos = (vp_index - 1) & 7; 2894 down(&ha->vport_sem); 2895 vce->vp_idx_map[map] |= 1 << pos; 2896 up(&ha->vport_sem); 2897 2898 rval = qla2x00_issue_iocb(ha, vce, vce_dma, 0); 2899 if (rval != QLA_SUCCESS) { 2900 DEBUG2_3_11(printk("%s(%ld): failed to issue VP control IOCB" 2901 "(%x).\n", __func__, ha->host_no, rval)); 2902 printk("%s(%ld): failed to issue VP control IOCB" 2903 "(%x).\n", __func__, ha->host_no, rval); 2904 } else if (vce->entry_status != 0) { 2905 DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB " 2906 "-- error status (%x).\n", __func__, ha->host_no, 2907 vce->entry_status)); 2908 printk("%s(%ld): failed to complete IOCB " 2909 "-- error status (%x).\n", __func__, ha->host_no, 2910 vce->entry_status); 2911 rval = QLA_FUNCTION_FAILED; 2912 } else if (vce->comp_status != __constant_cpu_to_le16(CS_COMPLETE)) { 2913 DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB " 2914 "-- completion status (%x).\n", __func__, ha->host_no, 2915 le16_to_cpu(vce->comp_status))); 2916 printk("%s(%ld): failed to complete IOCB " 2917 "-- completion status (%x).\n", __func__, ha->host_no, 2918 le16_to_cpu(vce->comp_status)); 2919 rval = QLA_FUNCTION_FAILED; 2920 } else { 2921 DEBUG2(printk("%s(%ld): done.\n", __func__, ha->host_no)); 2922 } 2923 2924 dma_pool_free(ha->s_dma_pool, vce, vce_dma); 2925 2926 return rval; 2927 } 2928 2929 /* 2930 * qla2x00_send_change_request 2931 * Receive or disable RSCN request from fabric controller 2932 * 2933 * Input: 2934 * ha = adapter block pointer 2935 * format = registration format: 2936 * 0 - Reserved 2937 * 1 - Fabric detected registration 2938 * 2 - N_port detected registration 2939 * 3 - Full registration 2940 * FF - clear registration 2941 * vp_idx = Virtual port index 2942 * 2943 * Returns: 2944 * qla2x00 local function return status code. 2945 * 2946 * Context: 2947 * Kernel Context 2948 */ 2949 2950 int 2951 qla2x00_send_change_request(scsi_qla_host_t *ha, uint16_t format, 2952 uint16_t vp_idx) 2953 { 2954 int rval; 2955 mbx_cmd_t mc; 2956 mbx_cmd_t *mcp = &mc; 2957 2958 /* 2959 * This command is implicitly executed by firmware during login for the 2960 * physical hosts 2961 */ 2962 if (vp_idx == 0) 2963 return QLA_FUNCTION_FAILED; 2964 2965 mcp->mb[0] = MBC_SEND_CHANGE_REQUEST; 2966 mcp->mb[1] = format; 2967 mcp->mb[9] = vp_idx; 2968 mcp->out_mb = MBX_9|MBX_1|MBX_0; 2969 mcp->in_mb = MBX_0|MBX_1; 2970 mcp->tov = MBX_TOV_SECONDS; 2971 mcp->flags = 0; 2972 rval = qla2x00_mailbox_command(ha, mcp); 2973 2974 if (rval == QLA_SUCCESS) { 2975 if (mcp->mb[0] != MBS_COMMAND_COMPLETE) { 2976 rval = BIT_1; 2977 } 2978 } else 2979 rval = BIT_1; 2980 2981 return rval; 2982 } 2983