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 #include <linux/delay.h> 22 23 static void 24 qla2x00_mbx_sem_timeout(unsigned long data) 25 { 26 struct semaphore *sem_ptr = (struct semaphore *)data; 27 28 DEBUG11(printk("qla2x00_sem_timeout: entered.\n");) 29 30 if (sem_ptr != NULL) { 31 up(sem_ptr); 32 } 33 34 DEBUG11(printk("qla2x00_mbx_sem_timeout: exiting.\n");) 35 } 36 37 /* 38 * qla2x00_mailbox_command 39 * Issue mailbox command and waits for completion. 40 * 41 * Input: 42 * ha = adapter block pointer. 43 * mcp = driver internal mbx struct pointer. 44 * 45 * Output: 46 * mb[MAX_MAILBOX_REGISTER_COUNT] = returned mailbox data. 47 * 48 * Returns: 49 * 0 : QLA_SUCCESS = cmd performed success 50 * 1 : QLA_FUNCTION_FAILED (error encountered) 51 * 6 : QLA_FUNCTION_TIMEOUT (timeout condition encountered) 52 * 53 * Context: 54 * Kernel context. 55 */ 56 static int 57 qla2x00_mailbox_command(scsi_qla_host_t *ha, mbx_cmd_t *mcp) 58 { 59 int rval; 60 unsigned long flags = 0; 61 device_reg_t __iomem *reg = ha->iobase; 62 struct timer_list tmp_intr_timer; 63 uint8_t abort_active = test_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags); 64 uint8_t io_lock_on = ha->flags.init_done; 65 uint16_t command; 66 uint16_t *iptr; 67 uint16_t __iomem *optr; 68 uint32_t cnt; 69 uint32_t mboxes; 70 unsigned long mbx_flags = 0; 71 unsigned long wait_time; 72 73 rval = QLA_SUCCESS; 74 75 DEBUG11(printk("qla2x00_mailbox_command(%ld): entered.\n", 76 ha->host_no);) 77 /* 78 * Wait for active mailbox commands to finish by waiting at most 79 * tov seconds. This is to serialize actual issuing of mailbox cmds 80 * during non ISP abort time. 81 */ 82 if (!abort_active) { 83 if (qla2x00_down_timeout(&ha->mbx_cmd_sem, mcp->tov * HZ)) { 84 /* Timeout occurred. Return error. */ 85 DEBUG2_3_11(printk("qla2x00_mailbox_command(%ld): cmd " 86 "access timeout. Exiting.\n", ha->host_no);) 87 return QLA_FUNCTION_TIMEOUT; 88 } 89 } 90 91 ha->flags.mbox_busy = 1; 92 /* Save mailbox command for debug */ 93 ha->mcp = mcp; 94 95 /* Try to get mailbox register access */ 96 if (!abort_active) 97 spin_lock_irqsave(&ha->mbx_reg_lock, mbx_flags); 98 99 DEBUG11(printk("scsi%d: prepare to issue mbox cmd=0x%x.\n", 100 (int)ha->host_no, mcp->mb[0]);) 101 102 spin_lock_irqsave(&ha->hardware_lock, flags); 103 104 /* Load mailbox registers. */ 105 optr = (uint16_t __iomem *)MAILBOX_REG(ha, reg, 0); 106 107 iptr = mcp->mb; 108 command = mcp->mb[0]; 109 mboxes = mcp->out_mb; 110 111 for (cnt = 0; cnt < ha->mbx_count; cnt++) { 112 if (IS_QLA2200(ha) && cnt == 8) 113 optr = (uint16_t __iomem *)MAILBOX_REG(ha, reg, 8); 114 if (mboxes & BIT_0) 115 WRT_REG_WORD(optr, *iptr); 116 117 mboxes >>= 1; 118 optr++; 119 iptr++; 120 } 121 122 #if defined(QL_DEBUG_LEVEL_1) 123 printk("qla2x00_mailbox_command: Loaded MBX registers " 124 "(displayed in bytes) = \n"); 125 qla2x00_dump_buffer((uint8_t *)mcp->mb, 16); 126 printk("\n"); 127 qla2x00_dump_buffer(((uint8_t *)mcp->mb + 0x10), 16); 128 printk("\n"); 129 qla2x00_dump_buffer(((uint8_t *)mcp->mb + 0x20), 8); 130 printk("\n"); 131 printk("qla2x00_mailbox_command: I/O address = %lx.\n", 132 (u_long)optr); 133 qla2x00_dump_regs(ha); 134 #endif 135 136 /* Issue set host interrupt command to send cmd out. */ 137 ha->flags.mbox_int = 0; 138 clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags); 139 140 /* Unlock mbx registers and wait for interrupt */ 141 142 DEBUG11(printk("qla2x00_mailbox_command: going to unlock irq & " 143 "waiting for interrupt. jiffies=%lx.\n", jiffies);) 144 145 /* Wait for mbx cmd completion until timeout */ 146 147 if (!abort_active && io_lock_on) { 148 /* sleep on completion semaphore */ 149 DEBUG11(printk("qla2x00_mailbox_command(%ld): " 150 "INTERRUPT MODE. Initializing timer.\n", 151 ha->host_no);) 152 153 init_timer(&tmp_intr_timer); 154 tmp_intr_timer.data = (unsigned long)&ha->mbx_intr_sem; 155 tmp_intr_timer.expires = jiffies + mcp->tov * HZ; 156 tmp_intr_timer.function = 157 (void (*)(unsigned long))qla2x00_mbx_sem_timeout; 158 159 DEBUG11(printk("qla2x00_mailbox_command(%ld): " 160 "Adding timer.\n", ha->host_no);) 161 add_timer(&tmp_intr_timer); 162 163 DEBUG11(printk("qla2x00_mailbox_command: going to " 164 "unlock & sleep. time=0x%lx.\n", jiffies);) 165 166 set_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags); 167 168 WRT_REG_WORD(®->hccr, HCCR_SET_HOST_INT); 169 spin_unlock_irqrestore(&ha->hardware_lock, flags); 170 171 if (!abort_active) 172 spin_unlock_irqrestore(&ha->mbx_reg_lock, mbx_flags); 173 174 /* Wait for either the timer to expire 175 * or the mbox completion interrupt 176 */ 177 down(&ha->mbx_intr_sem); 178 179 DEBUG11(printk("qla2x00_mailbox_command:" 180 "waking up." 181 "time=0x%lx\n", jiffies);) 182 clear_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags); 183 184 /* delete the timer */ 185 del_timer(&tmp_intr_timer); 186 } else { 187 188 DEBUG3_11(printk("qla2x00_mailbox_command(%ld): cmd=%x " 189 "POLLING MODE.\n", ha->host_no, command);) 190 191 WRT_REG_WORD(®->hccr, HCCR_SET_HOST_INT); 192 spin_unlock_irqrestore(&ha->hardware_lock, flags); 193 if (!abort_active) 194 spin_unlock_irqrestore(&ha->mbx_reg_lock, mbx_flags); 195 196 wait_time = jiffies + mcp->tov * HZ; /* wait at most tov secs */ 197 while (!ha->flags.mbox_int) { 198 if (time_after(jiffies, wait_time)) 199 break; 200 201 /* Check for pending interrupts. */ 202 qla2x00_poll(ha); 203 204 udelay(10); /* v4.27 */ 205 } /* while */ 206 } 207 208 if (!abort_active) 209 spin_lock_irqsave(&ha->mbx_reg_lock, mbx_flags); 210 211 /* Check whether we timed out */ 212 if (ha->flags.mbox_int) { 213 uint16_t *iptr2; 214 215 DEBUG3_11(printk("qla2x00_mailbox_cmd: cmd %x completed.\n", 216 command);) 217 218 /* Got interrupt. Clear the flag. */ 219 ha->flags.mbox_int = 0; 220 clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags); 221 222 if (ha->mailbox_out[0] != MBS_COMMAND_COMPLETE) { 223 qla2x00_stats.mboxerr++; 224 rval = QLA_FUNCTION_FAILED; 225 } 226 227 /* Load return mailbox registers. */ 228 iptr2 = mcp->mb; 229 iptr = (uint16_t *)&ha->mailbox_out[0]; 230 mboxes = mcp->in_mb; 231 for (cnt = 0; cnt < ha->mbx_count; cnt++) { 232 if (mboxes & BIT_0) 233 *iptr2 = *iptr; 234 235 mboxes >>= 1; 236 iptr2++; 237 iptr++; 238 } 239 } else { 240 241 #if defined(QL_DEBUG_LEVEL_2) || defined(QL_DEBUG_LEVEL_3) || \ 242 defined(QL_DEBUG_LEVEL_11) 243 printk("qla2x00_mailbox_command(%ld): **** MB Command Timeout " 244 "for cmd %x ****\n", ha->host_no, command); 245 printk("qla2x00_mailbox_command: icontrol=%x jiffies=%lx\n", 246 RD_REG_WORD(®->ictrl), jiffies); 247 printk("qla2x00_mailbox_command: *** mailbox[0] = 0x%x ***\n", 248 RD_REG_WORD(optr)); 249 qla2x00_dump_regs(ha); 250 #endif 251 252 qla2x00_stats.mboxtout++; 253 ha->total_mbx_timeout++; 254 rval = QLA_FUNCTION_TIMEOUT; 255 } 256 257 if (!abort_active) 258 spin_unlock_irqrestore(&ha->mbx_reg_lock, mbx_flags); 259 260 ha->flags.mbox_busy = 0; 261 262 /* Clean up */ 263 ha->mcp = NULL; 264 265 if (!abort_active) { 266 DEBUG11(printk("qla2x00_mailbox_cmd: checking for additional " 267 "resp interrupt.\n");) 268 269 /* polling mode for non isp_abort commands. */ 270 qla2x00_poll(ha); 271 } 272 273 if (rval == QLA_FUNCTION_TIMEOUT) { 274 if (!io_lock_on || (mcp->flags & IOCTL_CMD)) { 275 /* not in dpc. schedule it for dpc to take over. */ 276 DEBUG(printk("qla2x00_mailbox_command(%ld): timeout " 277 "schedule isp_abort_needed.\n", 278 ha->host_no);) 279 DEBUG2_3_11(printk("qla2x00_mailbox_command(%ld): " 280 "timeout schedule isp_abort_needed.\n", 281 ha->host_no);) 282 qla_printk(KERN_WARNING, ha, 283 "Mailbox command timeout occured. Scheduling ISP " 284 "abort.\n"); 285 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags); 286 if (ha->dpc_wait && !ha->dpc_active) 287 up(ha->dpc_wait); 288 289 } else if (!abort_active) { 290 291 /* call abort directly since we are in the DPC thread */ 292 DEBUG(printk("qla2x00_mailbox_command(%ld): timeout " 293 "calling abort_isp\n", ha->host_no);) 294 DEBUG2_3_11(printk("qla2x00_mailbox_command(%ld): " 295 "timeout calling abort_isp\n", ha->host_no);) 296 qla_printk(KERN_WARNING, ha, 297 "Mailbox command timeout occured. Issuing ISP " 298 "abort.\n"); 299 300 set_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags); 301 clear_bit(ISP_ABORT_NEEDED, &ha->dpc_flags); 302 if (qla2x00_abort_isp(ha)) { 303 /* failed. retry later. */ 304 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags); 305 } 306 clear_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags); 307 308 DEBUG(printk("qla2x00_mailbox_command: finished " 309 "abort_isp\n");) 310 DEBUG2_3_11(printk("qla2x00_mailbox_command: finished " 311 "abort_isp\n");) 312 } 313 } 314 315 /* Allow next mbx cmd to come in. */ 316 if (!abort_active) 317 up(&ha->mbx_cmd_sem); 318 319 if (rval) { 320 DEBUG2_3_11(printk("qla2x00_mailbox_command(%ld): **** FAILED. " 321 "mbx0=%x, mbx1=%x, mbx2=%x, cmd=%x ****\n", 322 ha->host_no, mcp->mb[0], mcp->mb[1], mcp->mb[2], command);) 323 } else { 324 DEBUG11(printk("qla2x00_mailbox_command(%ld): done.\n", 325 ha->host_no);) 326 } 327 328 DEBUG11(printk("qla2x00_mailbox_command(%ld): exiting.\n", 329 ha->host_no);) 330 331 return rval; 332 } 333 334 /* 335 * qla2x00_load_ram 336 * Load adapter RAM using DMA. 337 * 338 * Input: 339 * ha = adapter block pointer. 340 * 341 * Returns: 342 * qla2x00 local function return status code. 343 * 344 * Context: 345 * Kernel context. 346 */ 347 int 348 qla2x00_load_ram(scsi_qla_host_t *ha, dma_addr_t req_dma, uint16_t risc_addr, 349 uint16_t risc_code_size) 350 { 351 int rval; 352 mbx_cmd_t mc; 353 mbx_cmd_t *mcp = &mc; 354 uint32_t req_len; 355 dma_addr_t nml_dma; 356 uint32_t nml_len; 357 uint32_t normalized; 358 359 DEBUG11(printk("qla2x00_load_ram(%ld): entered.\n", 360 ha->host_no);) 361 362 req_len = risc_code_size; 363 nml_dma = 0; 364 nml_len = 0; 365 366 normalized = qla2x00_normalize_dma_addr(&req_dma, &req_len, &nml_dma, 367 &nml_len); 368 369 /* Load first segment */ 370 mcp->mb[0] = MBC_LOAD_RISC_RAM; 371 mcp->mb[1] = risc_addr; 372 mcp->mb[2] = MSW(req_dma); 373 mcp->mb[3] = LSW(req_dma); 374 mcp->mb[4] = (uint16_t)req_len; 375 mcp->mb[6] = MSW(MSD(req_dma)); 376 mcp->mb[7] = LSW(MSD(req_dma)); 377 mcp->out_mb = MBX_7|MBX_6|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0; 378 mcp->in_mb = MBX_0; 379 mcp->tov = 30; 380 mcp->flags = 0; 381 rval = qla2x00_mailbox_command(ha, mcp); 382 383 /* Load second segment - if necessary */ 384 if (normalized && (rval == QLA_SUCCESS)) { 385 mcp->mb[0] = MBC_LOAD_RISC_RAM; 386 mcp->mb[1] = risc_addr + (uint16_t)req_len; 387 mcp->mb[2] = MSW(nml_dma); 388 mcp->mb[3] = LSW(nml_dma); 389 mcp->mb[4] = (uint16_t)nml_len; 390 mcp->mb[6] = MSW(MSD(nml_dma)); 391 mcp->mb[7] = LSW(MSD(nml_dma)); 392 mcp->out_mb = MBX_7|MBX_6|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0; 393 mcp->in_mb = MBX_0; 394 mcp->tov = 30; 395 mcp->flags = 0; 396 rval = qla2x00_mailbox_command(ha, mcp); 397 } 398 399 if (rval == QLA_SUCCESS) { 400 /* Empty */ 401 DEBUG11(printk("qla2x00_load_ram(%ld): done.\n", ha->host_no);) 402 } else { 403 /* Empty */ 404 DEBUG2_3_11(printk("qla2x00_load_ram(%ld): failed. rval=%x " 405 "mb[0]=%x.\n", ha->host_no, rval, mcp->mb[0]);) 406 } 407 return rval; 408 } 409 410 /* 411 * qla2x00_load_ram_ext 412 * Load adapter extended RAM using DMA. 413 * 414 * Input: 415 * ha = adapter block pointer. 416 * 417 * Returns: 418 * qla2x00 local function return status code. 419 * 420 * Context: 421 * Kernel context. 422 */ 423 int 424 qla2x00_load_ram_ext(scsi_qla_host_t *ha, dma_addr_t req_dma, 425 uint32_t risc_addr, uint16_t risc_code_size) 426 { 427 int rval; 428 mbx_cmd_t mc; 429 mbx_cmd_t *mcp = &mc; 430 uint32_t req_len; 431 dma_addr_t nml_dma; 432 uint32_t nml_len; 433 uint32_t normalized; 434 435 DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no)); 436 437 req_len = risc_code_size; 438 nml_dma = 0; 439 nml_len = 0; 440 441 normalized = qla2x00_normalize_dma_addr(&req_dma, &req_len, &nml_dma, 442 &nml_len); 443 444 /* Load first segment */ 445 mcp->mb[0] = MBC_LOAD_RISC_RAM_EXTENDED; 446 mcp->mb[1] = LSW(risc_addr); 447 mcp->mb[2] = MSW(req_dma); 448 mcp->mb[3] = LSW(req_dma); 449 mcp->mb[4] = (uint16_t)req_len; 450 mcp->mb[6] = MSW(MSD(req_dma)); 451 mcp->mb[7] = LSW(MSD(req_dma)); 452 mcp->mb[8] = MSW(risc_addr); 453 mcp->out_mb = MBX_8|MBX_7|MBX_6|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0; 454 mcp->in_mb = MBX_0; 455 mcp->tov = 30; 456 mcp->flags = 0; 457 rval = qla2x00_mailbox_command(ha, mcp); 458 459 /* Load second segment - if necessary */ 460 if (normalized && (rval == QLA_SUCCESS)) { 461 risc_addr += req_len; 462 mcp->mb[0] = MBC_LOAD_RISC_RAM_EXTENDED; 463 mcp->mb[1] = LSW(risc_addr); 464 mcp->mb[2] = MSW(nml_dma); 465 mcp->mb[3] = LSW(nml_dma); 466 mcp->mb[4] = (uint16_t)nml_len; 467 mcp->mb[6] = MSW(MSD(nml_dma)); 468 mcp->mb[7] = LSW(MSD(nml_dma)); 469 mcp->mb[8] = MSW(risc_addr); 470 mcp->out_mb = MBX_8|MBX_7|MBX_6|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0; 471 mcp->in_mb = MBX_0; 472 mcp->tov = 30; 473 mcp->flags = 0; 474 rval = qla2x00_mailbox_command(ha, mcp); 475 } 476 477 if (rval != QLA_SUCCESS) { 478 /*EMPTY*/ 479 DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x.\n", 480 __func__, ha->host_no, rval, mcp->mb[0])); 481 } else { 482 /*EMPTY*/ 483 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no)); 484 } 485 486 return rval; 487 } 488 489 /* 490 * qla2x00_execute_fw 491 * Start adapter firmware. 492 * 493 * Input: 494 * ha = adapter block pointer. 495 * TARGET_QUEUE_LOCK must be released. 496 * ADAPTER_STATE_LOCK must be released. 497 * 498 * Returns: 499 * qla2x00 local function return status code. 500 * 501 * Context: 502 * Kernel context. 503 */ 504 int 505 qla2x00_execute_fw(scsi_qla_host_t *ha) 506 { 507 int rval; 508 mbx_cmd_t mc; 509 mbx_cmd_t *mcp = &mc; 510 511 DEBUG11(printk("qla2x00_execute_fw(%ld): entered.\n", ha->host_no);) 512 513 mcp->mb[0] = MBC_EXECUTE_FIRMWARE; 514 mcp->mb[1] = *ha->brd_info->fw_info[0].fwstart; 515 mcp->out_mb = MBX_1|MBX_0; 516 if (IS_QLA2322(ha) || IS_QLA6322(ha)) { 517 mcp->mb[2] = 0; 518 mcp->out_mb |= MBX_2; 519 } 520 521 mcp->in_mb = MBX_0; 522 mcp->tov = 30; 523 mcp->flags = 0; 524 rval = qla2x00_mailbox_command(ha, mcp); 525 526 DEBUG11(printk("qla2x00_execute_fw(%ld): done.\n", ha->host_no);) 527 528 return rval; 529 } 530 531 /* 532 * qla2x00_get_fw_version 533 * Get firmware version. 534 * 535 * Input: 536 * ha: adapter state pointer. 537 * major: pointer for major number. 538 * minor: pointer for minor number. 539 * subminor: pointer for subminor number. 540 * 541 * Returns: 542 * qla2x00 local function return status code. 543 * 544 * Context: 545 * Kernel context. 546 */ 547 void 548 qla2x00_get_fw_version(scsi_qla_host_t *ha, uint16_t *major, uint16_t *minor, 549 uint16_t *subminor, uint16_t *attributes, uint32_t *memory) 550 { 551 int rval; 552 mbx_cmd_t mc; 553 mbx_cmd_t *mcp = &mc; 554 555 DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no)); 556 557 mcp->mb[0] = MBC_GET_FIRMWARE_VERSION; 558 mcp->out_mb = MBX_0; 559 mcp->in_mb = MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0; 560 mcp->flags = 0; 561 mcp->tov = 30; 562 rval = qla2x00_mailbox_command(ha, mcp); 563 564 /* Return mailbox data. */ 565 *major = mcp->mb[1]; 566 *minor = mcp->mb[2]; 567 *subminor = mcp->mb[3]; 568 *attributes = mcp->mb[6]; 569 if (IS_QLA2100(ha) || IS_QLA2200(ha)) 570 *memory = 0x1FFFF; /* Defaults to 128KB. */ 571 else 572 *memory = (mcp->mb[5] << 16) | mcp->mb[4]; 573 574 if (rval != QLA_SUCCESS) { 575 /*EMPTY*/ 576 DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__, 577 ha->host_no, rval)); 578 } else { 579 /*EMPTY*/ 580 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no)); 581 } 582 } 583 584 /* 585 * qla2x00_get_fw_options 586 * Set firmware options. 587 * 588 * Input: 589 * ha = adapter block pointer. 590 * fwopt = pointer for firmware options. 591 * 592 * Returns: 593 * qla2x00 local function return status code. 594 * 595 * Context: 596 * Kernel context. 597 */ 598 int 599 qla2x00_get_fw_options(scsi_qla_host_t *ha, uint16_t *fwopts) 600 { 601 int rval; 602 mbx_cmd_t mc; 603 mbx_cmd_t *mcp = &mc; 604 605 DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no)); 606 607 mcp->mb[0] = MBC_GET_FIRMWARE_OPTION; 608 mcp->out_mb = MBX_0; 609 mcp->in_mb = MBX_3|MBX_2|MBX_1|MBX_0; 610 mcp->tov = 30; 611 mcp->flags = 0; 612 rval = qla2x00_mailbox_command(ha, mcp); 613 614 if (rval != QLA_SUCCESS) { 615 /*EMPTY*/ 616 DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__, 617 ha->host_no, rval)); 618 } else { 619 fwopts[1] = mcp->mb[1]; 620 fwopts[2] = mcp->mb[2]; 621 fwopts[3] = mcp->mb[3]; 622 623 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no)); 624 } 625 626 return rval; 627 } 628 629 630 /* 631 * qla2x00_set_fw_options 632 * Set firmware options. 633 * 634 * Input: 635 * ha = adapter block pointer. 636 * fwopt = pointer for firmware options. 637 * 638 * Returns: 639 * qla2x00 local function return status code. 640 * 641 * Context: 642 * Kernel context. 643 */ 644 int 645 qla2x00_set_fw_options(scsi_qla_host_t *ha, uint16_t *fwopts) 646 { 647 int rval; 648 mbx_cmd_t mc; 649 mbx_cmd_t *mcp = &mc; 650 651 DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no)); 652 653 mcp->mb[0] = MBC_SET_FIRMWARE_OPTION; 654 mcp->mb[1] = fwopts[1]; 655 mcp->mb[2] = fwopts[2]; 656 mcp->mb[3] = fwopts[3]; 657 mcp->mb[10] = fwopts[10]; 658 mcp->mb[11] = fwopts[11]; 659 mcp->mb[12] = 0; /* Undocumented, but used */ 660 mcp->out_mb = MBX_12|MBX_11|MBX_10|MBX_3|MBX_2|MBX_1|MBX_0; 661 mcp->in_mb = MBX_0; 662 mcp->tov = 30; 663 mcp->flags = 0; 664 rval = qla2x00_mailbox_command(ha, mcp); 665 666 if (rval != QLA_SUCCESS) { 667 /*EMPTY*/ 668 DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__, 669 ha->host_no, rval)); 670 } else { 671 /*EMPTY*/ 672 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no)); 673 } 674 675 return rval; 676 } 677 678 /* 679 * qla2x00_mbx_reg_test 680 * Mailbox register wrap test. 681 * 682 * Input: 683 * ha = adapter block pointer. 684 * TARGET_QUEUE_LOCK must be released. 685 * ADAPTER_STATE_LOCK must be released. 686 * 687 * Returns: 688 * qla2x00 local function return status code. 689 * 690 * Context: 691 * Kernel context. 692 */ 693 int 694 qla2x00_mbx_reg_test(scsi_qla_host_t *ha) 695 { 696 int rval; 697 mbx_cmd_t mc; 698 mbx_cmd_t *mcp = &mc; 699 700 DEBUG11(printk("qla2x00_mbx_reg_test(%ld): entered.\n", ha->host_no);) 701 702 mcp->mb[0] = MBC_MAILBOX_REGISTER_TEST; 703 mcp->mb[1] = 0xAAAA; 704 mcp->mb[2] = 0x5555; 705 mcp->mb[3] = 0xAA55; 706 mcp->mb[4] = 0x55AA; 707 mcp->mb[5] = 0xA5A5; 708 mcp->mb[6] = 0x5A5A; 709 mcp->mb[7] = 0x2525; 710 mcp->out_mb = MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0; 711 mcp->in_mb = MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0; 712 mcp->tov = 30; 713 mcp->flags = 0; 714 rval = qla2x00_mailbox_command(ha, mcp); 715 716 if (rval == QLA_SUCCESS) { 717 if (mcp->mb[1] != 0xAAAA || mcp->mb[2] != 0x5555 || 718 mcp->mb[3] != 0xAA55 || mcp->mb[4] != 0x55AA) 719 rval = QLA_FUNCTION_FAILED; 720 if (mcp->mb[5] != 0xA5A5 || mcp->mb[6] != 0x5A5A || 721 mcp->mb[7] != 0x2525) 722 rval = QLA_FUNCTION_FAILED; 723 } 724 725 if (rval != QLA_SUCCESS) { 726 /*EMPTY*/ 727 DEBUG2_3_11(printk("qla2x00_mbx_reg_test(%ld): failed=%x.\n", 728 ha->host_no, rval);) 729 } else { 730 /*EMPTY*/ 731 DEBUG11(printk("qla2x00_mbx_reg_test(%ld): done.\n", 732 ha->host_no);) 733 } 734 735 return rval; 736 } 737 738 /* 739 * qla2x00_verify_checksum 740 * Verify firmware checksum. 741 * 742 * Input: 743 * ha = adapter block pointer. 744 * TARGET_QUEUE_LOCK must be released. 745 * ADAPTER_STATE_LOCK must be released. 746 * 747 * Returns: 748 * qla2x00 local function return status code. 749 * 750 * Context: 751 * Kernel context. 752 */ 753 int 754 qla2x00_verify_checksum(scsi_qla_host_t *ha) 755 { 756 int rval; 757 mbx_cmd_t mc; 758 mbx_cmd_t *mcp = &mc; 759 760 DEBUG11(printk("qla2x00_verify_checksum(%ld): entered.\n", 761 ha->host_no);) 762 763 mcp->mb[0] = MBC_VERIFY_CHECKSUM; 764 mcp->mb[1] = *ha->brd_info->fw_info[0].fwstart; 765 mcp->out_mb = MBX_1|MBX_0; 766 mcp->in_mb = MBX_2|MBX_0; 767 mcp->tov = 30; 768 mcp->flags = 0; 769 rval = qla2x00_mailbox_command(ha, mcp); 770 771 if (rval != QLA_SUCCESS) { 772 /*EMPTY*/ 773 DEBUG2_3_11(printk("qla2x00_verify_checksum(%ld): failed=%x.\n", 774 ha->host_no, rval);) 775 } else { 776 /*EMPTY*/ 777 DEBUG11(printk("qla2x00_verify_checksum(%ld): done.\n", 778 ha->host_no);) 779 } 780 781 return rval; 782 } 783 784 /* 785 * qla2x00_issue_iocb 786 * Issue IOCB using mailbox command 787 * 788 * Input: 789 * ha = adapter state pointer. 790 * buffer = buffer pointer. 791 * phys_addr = physical address of buffer. 792 * size = size of buffer. 793 * TARGET_QUEUE_LOCK must be released. 794 * ADAPTER_STATE_LOCK must be released. 795 * 796 * Returns: 797 * qla2x00 local function return status code. 798 * 799 * Context: 800 * Kernel context. 801 */ 802 int 803 qla2x00_issue_iocb(scsi_qla_host_t *ha, void* buffer, dma_addr_t phys_addr, 804 size_t size) 805 { 806 int rval; 807 mbx_cmd_t mc; 808 mbx_cmd_t *mcp = &mc; 809 810 mcp->mb[0] = MBC_IOCB_COMMAND_A64; 811 mcp->mb[1] = 0; 812 mcp->mb[2] = MSW(phys_addr); 813 mcp->mb[3] = LSW(phys_addr); 814 mcp->mb[6] = MSW(MSD(phys_addr)); 815 mcp->mb[7] = LSW(MSD(phys_addr)); 816 mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0; 817 mcp->in_mb = MBX_2|MBX_0; 818 mcp->tov = 30; 819 mcp->flags = 0; 820 rval = qla2x00_mailbox_command(ha, mcp); 821 822 if (rval != QLA_SUCCESS) { 823 /*EMPTY*/ 824 DEBUG(printk("qla2x00_issue_iocb(%ld): failed rval 0x%x", 825 ha->host_no,rval);) 826 DEBUG2(printk("qla2x00_issue_iocb(%ld): failed rval 0x%x", 827 ha->host_no,rval);) 828 } else { 829 /*EMPTY*/ 830 } 831 832 return rval; 833 } 834 835 /* 836 * qla2x00_abort_command 837 * Abort command aborts a specified IOCB. 838 * 839 * Input: 840 * ha = adapter block pointer. 841 * sp = SB structure pointer. 842 * 843 * Returns: 844 * qla2x00 local function return status code. 845 * 846 * Context: 847 * Kernel context. 848 */ 849 int 850 qla2x00_abort_command(scsi_qla_host_t *ha, srb_t *sp) 851 { 852 unsigned long flags = 0; 853 fc_port_t *fcport; 854 int rval; 855 uint32_t handle; 856 mbx_cmd_t mc; 857 mbx_cmd_t *mcp = &mc; 858 859 DEBUG11(printk("qla2x00_abort_command(%ld): entered.\n", ha->host_no);) 860 861 fcport = sp->fcport; 862 if (atomic_read(&ha->loop_state) == LOOP_DOWN || 863 atomic_read(&fcport->state) == FCS_DEVICE_LOST) { 864 return 1; 865 } 866 867 spin_lock_irqsave(&ha->hardware_lock, flags); 868 for (handle = 1; handle < MAX_OUTSTANDING_COMMANDS; handle++) { 869 if (ha->outstanding_cmds[handle] == sp) 870 break; 871 } 872 spin_unlock_irqrestore(&ha->hardware_lock, flags); 873 874 if (handle == MAX_OUTSTANDING_COMMANDS) { 875 /* command not found */ 876 return QLA_FUNCTION_FAILED; 877 } 878 879 mcp->mb[0] = MBC_ABORT_COMMAND; 880 if (HAS_EXTENDED_IDS(ha)) 881 mcp->mb[1] = fcport->loop_id; 882 else 883 mcp->mb[1] = fcport->loop_id << 8; 884 mcp->mb[2] = (uint16_t)handle; 885 mcp->mb[3] = (uint16_t)(handle >> 16); 886 mcp->mb[6] = (uint16_t)sp->cmd->device->lun; 887 mcp->out_mb = MBX_6|MBX_3|MBX_2|MBX_1|MBX_0; 888 mcp->in_mb = MBX_0; 889 mcp->tov = 30; 890 mcp->flags = 0; 891 rval = qla2x00_mailbox_command(ha, mcp); 892 893 if (rval != QLA_SUCCESS) { 894 DEBUG2_3_11(printk("qla2x00_abort_command(%ld): failed=%x.\n", 895 ha->host_no, rval);) 896 } else { 897 sp->flags |= SRB_ABORT_PENDING; 898 DEBUG11(printk("qla2x00_abort_command(%ld): done.\n", 899 ha->host_no);) 900 } 901 902 return rval; 903 } 904 905 #if USE_ABORT_TGT 906 /* 907 * qla2x00_abort_target 908 * Issue abort target mailbox command. 909 * 910 * Input: 911 * ha = adapter block pointer. 912 * 913 * Returns: 914 * qla2x00 local function return status code. 915 * 916 * Context: 917 * Kernel context. 918 */ 919 int 920 qla2x00_abort_target(fc_port_t *fcport) 921 { 922 int rval; 923 mbx_cmd_t mc; 924 mbx_cmd_t *mcp = &mc; 925 926 DEBUG11(printk("qla2x00_abort_target(%ld): entered.\n", 927 fcport->ha->host_no);) 928 929 if (fcport == NULL) { 930 /* no target to abort */ 931 return 0; 932 } 933 934 mcp->mb[0] = MBC_ABORT_TARGET; 935 mcp->out_mb = MBX_2|MBX_1|MBX_0; 936 if (HAS_EXTENDED_IDS(fcport->ha)) { 937 mcp->mb[1] = fcport->loop_id; 938 mcp->mb[10] = 0; 939 mcp->out_mb |= MBX_10; 940 } else { 941 mcp->mb[1] = fcport->loop_id << 8; 942 } 943 mcp->mb[2] = fcport->ha->loop_reset_delay; 944 945 mcp->in_mb = MBX_0; 946 mcp->tov = 30; 947 mcp->flags = 0; 948 rval = qla2x00_mailbox_command(fcport->ha, mcp); 949 950 /* Issue marker command. */ 951 fcport->ha->marker_needed = 1; 952 953 if (rval != QLA_SUCCESS) { 954 DEBUG2_3_11(printk("qla2x00_abort_target(%ld): failed=%x.\n", 955 fcport->ha->host_no, rval);) 956 } else { 957 /*EMPTY*/ 958 DEBUG11(printk("qla2x00_abort_target(%ld): done.\n", 959 fcport->ha->host_no);) 960 } 961 962 return rval; 963 } 964 #endif 965 966 /* 967 * qla2x00_target_reset 968 * Issue target reset mailbox command. 969 * 970 * Input: 971 * ha = adapter block pointer. 972 * TARGET_QUEUE_LOCK must be released. 973 * ADAPTER_STATE_LOCK must be released. 974 * 975 * Returns: 976 * qla2x00 local function return status code. 977 * 978 * Context: 979 * Kernel context. 980 */ 981 int 982 qla2x00_target_reset(scsi_qla_host_t *ha, struct fc_port *fcport) 983 { 984 int rval; 985 mbx_cmd_t mc; 986 mbx_cmd_t *mcp = &mc; 987 988 DEBUG11(printk("qla2x00_target_reset(%ld): entered.\n", ha->host_no);) 989 990 if (atomic_read(&fcport->state) != FCS_ONLINE) 991 return 0; 992 993 mcp->mb[0] = MBC_TARGET_RESET; 994 if (HAS_EXTENDED_IDS(ha)) 995 mcp->mb[1] = fcport->loop_id; 996 else 997 mcp->mb[1] = fcport->loop_id << 8; 998 mcp->mb[2] = ha->loop_reset_delay; 999 mcp->out_mb = MBX_2|MBX_1|MBX_0; 1000 mcp->in_mb = MBX_0; 1001 mcp->tov = 30; 1002 mcp->flags = 0; 1003 rval = qla2x00_mailbox_command(ha, mcp); 1004 1005 if (rval != QLA_SUCCESS) { 1006 /*EMPTY*/ 1007 DEBUG2_3_11(printk("qla2x00_target_reset(%ld): failed=%x.\n", 1008 ha->host_no, rval);) 1009 } else { 1010 /*EMPTY*/ 1011 DEBUG11(printk("qla2x00_target_reset(%ld): done.\n", 1012 ha->host_no);) 1013 } 1014 1015 return rval; 1016 } 1017 1018 /* 1019 * qla2x00_get_adapter_id 1020 * Get adapter ID and topology. 1021 * 1022 * Input: 1023 * ha = adapter block pointer. 1024 * id = pointer for loop ID. 1025 * al_pa = pointer for AL_PA. 1026 * area = pointer for area. 1027 * domain = pointer for domain. 1028 * top = pointer for topology. 1029 * TARGET_QUEUE_LOCK must be released. 1030 * ADAPTER_STATE_LOCK must be released. 1031 * 1032 * Returns: 1033 * qla2x00 local function return status code. 1034 * 1035 * Context: 1036 * Kernel context. 1037 */ 1038 int 1039 qla2x00_get_adapter_id(scsi_qla_host_t *ha, uint16_t *id, uint8_t *al_pa, 1040 uint8_t *area, uint8_t *domain, uint16_t *top) 1041 { 1042 int rval; 1043 mbx_cmd_t mc; 1044 mbx_cmd_t *mcp = &mc; 1045 1046 DEBUG11(printk("qla2x00_get_adapter_id(%ld): entered.\n", 1047 ha->host_no);) 1048 1049 mcp->mb[0] = MBC_GET_ADAPTER_LOOP_ID; 1050 mcp->out_mb = MBX_0; 1051 mcp->in_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0; 1052 mcp->tov = 30; 1053 mcp->flags = 0; 1054 rval = qla2x00_mailbox_command(ha, mcp); 1055 1056 /* Return data. */ 1057 *id = mcp->mb[1]; 1058 *al_pa = LSB(mcp->mb[2]); 1059 *area = MSB(mcp->mb[2]); 1060 *domain = LSB(mcp->mb[3]); 1061 *top = mcp->mb[6]; 1062 1063 if (rval != QLA_SUCCESS) { 1064 /*EMPTY*/ 1065 DEBUG2_3_11(printk("qla2x00_get_adapter_id(%ld): failed=%x.\n", 1066 ha->host_no, rval);) 1067 } else { 1068 /*EMPTY*/ 1069 DEBUG11(printk("qla2x00_get_adapter_id(%ld): done.\n", 1070 ha->host_no);) 1071 } 1072 1073 return rval; 1074 } 1075 1076 /* 1077 * qla2x00_get_retry_cnt 1078 * Get current firmware login retry count and delay. 1079 * 1080 * Input: 1081 * ha = adapter block pointer. 1082 * retry_cnt = pointer to login retry count. 1083 * tov = pointer to login timeout value. 1084 * 1085 * Returns: 1086 * qla2x00 local function return status code. 1087 * 1088 * Context: 1089 * Kernel context. 1090 */ 1091 int 1092 qla2x00_get_retry_cnt(scsi_qla_host_t *ha, uint8_t *retry_cnt, uint8_t *tov, 1093 uint16_t *r_a_tov) 1094 { 1095 int rval; 1096 uint16_t ratov; 1097 mbx_cmd_t mc; 1098 mbx_cmd_t *mcp = &mc; 1099 1100 DEBUG11(printk("qla2x00_get_retry_cnt(%ld): entered.\n", 1101 ha->host_no);) 1102 1103 mcp->mb[0] = MBC_GET_RETRY_COUNT; 1104 mcp->out_mb = MBX_0; 1105 mcp->in_mb = MBX_3|MBX_2|MBX_1|MBX_0; 1106 mcp->tov = 30; 1107 mcp->flags = 0; 1108 rval = qla2x00_mailbox_command(ha, mcp); 1109 1110 if (rval != QLA_SUCCESS) { 1111 /*EMPTY*/ 1112 DEBUG2_3_11(printk("qla2x00_get_retry_cnt(%ld): failed = %x.\n", 1113 ha->host_no, mcp->mb[0]);) 1114 } else { 1115 /* Convert returned data and check our values. */ 1116 *r_a_tov = mcp->mb[3] / 2; 1117 ratov = (mcp->mb[3]/2) / 10; /* mb[3] value is in 100ms */ 1118 if (mcp->mb[1] * ratov > (*retry_cnt) * (*tov)) { 1119 /* Update to the larger values */ 1120 *retry_cnt = (uint8_t)mcp->mb[1]; 1121 *tov = ratov; 1122 } 1123 1124 DEBUG11(printk("qla2x00_get_retry_cnt(%ld): done. mb3=%d " 1125 "ratov=%d.\n", ha->host_no, mcp->mb[3], ratov);) 1126 } 1127 1128 return rval; 1129 } 1130 1131 /* 1132 * qla2x00_init_firmware 1133 * Initialize adapter firmware. 1134 * 1135 * Input: 1136 * ha = adapter block pointer. 1137 * dptr = Initialization control block pointer. 1138 * size = size of initialization control block. 1139 * TARGET_QUEUE_LOCK must be released. 1140 * ADAPTER_STATE_LOCK must be released. 1141 * 1142 * Returns: 1143 * qla2x00 local function return status code. 1144 * 1145 * Context: 1146 * Kernel context. 1147 */ 1148 int 1149 qla2x00_init_firmware(scsi_qla_host_t *ha, uint16_t size) 1150 { 1151 int rval; 1152 mbx_cmd_t mc; 1153 mbx_cmd_t *mcp = &mc; 1154 1155 DEBUG11(printk("qla2x00_init_firmware(%ld): entered.\n", 1156 ha->host_no);) 1157 1158 mcp->mb[0] = MBC_INITIALIZE_FIRMWARE; 1159 mcp->mb[2] = MSW(ha->init_cb_dma); 1160 mcp->mb[3] = LSW(ha->init_cb_dma); 1161 mcp->mb[4] = 0; 1162 mcp->mb[5] = 0; 1163 mcp->mb[6] = MSW(MSD(ha->init_cb_dma)); 1164 mcp->mb[7] = LSW(MSD(ha->init_cb_dma)); 1165 mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_0; 1166 mcp->in_mb = MBX_5|MBX_4|MBX_0; 1167 mcp->buf_size = size; 1168 mcp->flags = MBX_DMA_OUT; 1169 mcp->tov = 30; 1170 rval = qla2x00_mailbox_command(ha, mcp); 1171 1172 if (rval != QLA_SUCCESS) { 1173 /*EMPTY*/ 1174 DEBUG2_3_11(printk("qla2x00_init_firmware(%ld): failed=%x " 1175 "mb0=%x.\n", 1176 ha->host_no, rval, mcp->mb[0]);) 1177 } else { 1178 /*EMPTY*/ 1179 DEBUG11(printk("qla2x00_init_firmware(%ld): done.\n", 1180 ha->host_no);) 1181 } 1182 1183 return rval; 1184 } 1185 1186 /* 1187 * qla2x00_get_port_database 1188 * Issue normal/enhanced get port database mailbox command 1189 * and copy device name as necessary. 1190 * 1191 * Input: 1192 * ha = adapter state pointer. 1193 * dev = structure pointer. 1194 * opt = enhanced cmd option byte. 1195 * 1196 * Returns: 1197 * qla2x00 local function return status code. 1198 * 1199 * Context: 1200 * Kernel context. 1201 */ 1202 int 1203 qla2x00_get_port_database(scsi_qla_host_t *ha, fc_port_t *fcport, uint8_t opt) 1204 { 1205 int rval; 1206 mbx_cmd_t mc; 1207 mbx_cmd_t *mcp = &mc; 1208 port_database_t *pd; 1209 dma_addr_t pd_dma; 1210 1211 DEBUG11(printk("qla2x00_get_port_database(%ld): entered.\n", 1212 ha->host_no);) 1213 1214 pd = dma_pool_alloc(ha->s_dma_pool, GFP_ATOMIC, &pd_dma); 1215 if (pd == NULL) { 1216 DEBUG2_3_11(printk("qla2x00_get_port_database(%ld): **** " 1217 "Mem Alloc Failed ****", ha->host_no);) 1218 return QLA_MEMORY_ALLOC_FAILED; 1219 } 1220 memset(pd, 0, PORT_DATABASE_SIZE); 1221 1222 if (opt != 0) 1223 mcp->mb[0] = MBC_ENHANCED_GET_PORT_DATABASE; 1224 else 1225 mcp->mb[0] = MBC_GET_PORT_DATABASE; 1226 mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0; 1227 if (HAS_EXTENDED_IDS(ha)) { 1228 mcp->mb[1] = fcport->loop_id; 1229 mcp->mb[10] = opt; 1230 mcp->out_mb |= MBX_10; 1231 } else { 1232 mcp->mb[1] = fcport->loop_id << 8 | opt; 1233 } 1234 mcp->mb[2] = MSW(pd_dma); 1235 mcp->mb[3] = LSW(pd_dma); 1236 mcp->mb[6] = MSW(MSD(pd_dma)); 1237 mcp->mb[7] = LSW(MSD(pd_dma)); 1238 1239 mcp->in_mb = MBX_0; 1240 mcp->buf_size = PORT_DATABASE_SIZE; 1241 mcp->flags = MBX_DMA_IN; 1242 mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2); 1243 rval = qla2x00_mailbox_command(ha, mcp); 1244 if (rval != QLA_SUCCESS) 1245 goto gpd_error_out; 1246 1247 /* Check for logged in state. */ 1248 if (pd->master_state != PD_STATE_PORT_LOGGED_IN && 1249 pd->slave_state != PD_STATE_PORT_LOGGED_IN) { 1250 rval = QLA_FUNCTION_FAILED; 1251 goto gpd_error_out; 1252 } 1253 1254 /* Names are little-endian. */ 1255 memcpy(fcport->node_name, pd->node_name, WWN_SIZE); 1256 memcpy(fcport->port_name, pd->port_name, WWN_SIZE); 1257 1258 /* Get port_id of device. */ 1259 fcport->d_id.b.al_pa = pd->port_id[2]; 1260 fcport->d_id.b.area = pd->port_id[3]; 1261 fcport->d_id.b.domain = pd->port_id[0]; 1262 fcport->d_id.b.rsvd_1 = 0; 1263 1264 /* Check for device require authentication. */ 1265 pd->common_features & BIT_5 ? (fcport->flags |= FCF_AUTH_REQ) : 1266 (fcport->flags &= ~FCF_AUTH_REQ); 1267 1268 /* If not target must be initiator or unknown type. */ 1269 if ((pd->prli_svc_param_word_3[0] & BIT_4) == 0) 1270 fcport->port_type = FCT_INITIATOR; 1271 else 1272 fcport->port_type = FCT_TARGET; 1273 1274 gpd_error_out: 1275 dma_pool_free(ha->s_dma_pool, pd, pd_dma); 1276 1277 if (rval != QLA_SUCCESS) { 1278 /*EMPTY*/ 1279 DEBUG2_3_11(printk("qla2x00_get_port_database(%ld): " 1280 "failed=%x.\n", ha->host_no, rval);) 1281 } else { 1282 /*EMPTY*/ 1283 DEBUG11(printk("qla2x00_get_port_database(%ld): done.\n", 1284 ha->host_no);) 1285 } 1286 1287 return rval; 1288 } 1289 1290 /* 1291 * qla2x00_get_firmware_state 1292 * Get adapter firmware state. 1293 * 1294 * Input: 1295 * ha = adapter block pointer. 1296 * dptr = pointer for firmware state. 1297 * TARGET_QUEUE_LOCK must be released. 1298 * ADAPTER_STATE_LOCK must be released. 1299 * 1300 * Returns: 1301 * qla2x00 local function return status code. 1302 * 1303 * Context: 1304 * Kernel context. 1305 */ 1306 int 1307 qla2x00_get_firmware_state(scsi_qla_host_t *ha, uint16_t *dptr) 1308 { 1309 int rval; 1310 mbx_cmd_t mc; 1311 mbx_cmd_t *mcp = &mc; 1312 1313 DEBUG11(printk("qla2x00_get_firmware_state(%ld): entered.\n", 1314 ha->host_no);) 1315 1316 mcp->mb[0] = MBC_GET_FIRMWARE_STATE; 1317 mcp->out_mb = MBX_0; 1318 mcp->in_mb = MBX_2|MBX_1|MBX_0; 1319 mcp->tov = 30; 1320 mcp->flags = 0; 1321 rval = qla2x00_mailbox_command(ha, mcp); 1322 1323 /* Return firmware state. */ 1324 *dptr = mcp->mb[1]; 1325 1326 if (rval != QLA_SUCCESS) { 1327 /*EMPTY*/ 1328 DEBUG2_3_11(printk("qla2x00_get_firmware_state(%ld): " 1329 "failed=%x.\n", ha->host_no, rval);) 1330 } else { 1331 /*EMPTY*/ 1332 DEBUG11(printk("qla2x00_get_firmware_state(%ld): done.\n", 1333 ha->host_no);) 1334 } 1335 1336 return rval; 1337 } 1338 1339 /* 1340 * qla2x00_get_port_name 1341 * Issue get port name mailbox command. 1342 * Returned name is in big endian format. 1343 * 1344 * Input: 1345 * ha = adapter block pointer. 1346 * loop_id = loop ID of device. 1347 * name = pointer for name. 1348 * TARGET_QUEUE_LOCK must be released. 1349 * ADAPTER_STATE_LOCK must be released. 1350 * 1351 * Returns: 1352 * qla2x00 local function return status code. 1353 * 1354 * Context: 1355 * Kernel context. 1356 */ 1357 int 1358 qla2x00_get_port_name(scsi_qla_host_t *ha, uint16_t loop_id, uint8_t *name, 1359 uint8_t opt) 1360 { 1361 int rval; 1362 mbx_cmd_t mc; 1363 mbx_cmd_t *mcp = &mc; 1364 1365 DEBUG11(printk("qla2x00_get_port_name(%ld): entered.\n", 1366 ha->host_no);) 1367 1368 mcp->mb[0] = MBC_GET_PORT_NAME; 1369 mcp->out_mb = MBX_1|MBX_0; 1370 if (HAS_EXTENDED_IDS(ha)) { 1371 mcp->mb[1] = loop_id; 1372 mcp->mb[10] = opt; 1373 mcp->out_mb |= MBX_10; 1374 } else { 1375 mcp->mb[1] = loop_id << 8 | opt; 1376 } 1377 1378 mcp->in_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0; 1379 mcp->tov = 30; 1380 mcp->flags = 0; 1381 rval = qla2x00_mailbox_command(ha, mcp); 1382 1383 if (rval != QLA_SUCCESS) { 1384 /*EMPTY*/ 1385 DEBUG2_3_11(printk("qla2x00_get_port_name(%ld): failed=%x.\n", 1386 ha->host_no, rval);) 1387 } else { 1388 if (name != NULL) { 1389 /* This function returns name in big endian. */ 1390 name[0] = LSB(mcp->mb[2]); 1391 name[1] = MSB(mcp->mb[2]); 1392 name[2] = LSB(mcp->mb[3]); 1393 name[3] = MSB(mcp->mb[3]); 1394 name[4] = LSB(mcp->mb[6]); 1395 name[5] = MSB(mcp->mb[6]); 1396 name[6] = LSB(mcp->mb[7]); 1397 name[7] = MSB(mcp->mb[7]); 1398 } 1399 1400 DEBUG11(printk("qla2x00_get_port_name(%ld): done.\n", 1401 ha->host_no);) 1402 } 1403 1404 return rval; 1405 } 1406 1407 /* 1408 * qla2x00_lip_reset 1409 * Issue LIP reset mailbox command. 1410 * 1411 * Input: 1412 * ha = adapter block pointer. 1413 * TARGET_QUEUE_LOCK must be released. 1414 * ADAPTER_STATE_LOCK must be released. 1415 * 1416 * Returns: 1417 * qla2x00 local function return status code. 1418 * 1419 * Context: 1420 * Kernel context. 1421 */ 1422 int 1423 qla2x00_lip_reset(scsi_qla_host_t *ha) 1424 { 1425 int rval; 1426 mbx_cmd_t mc; 1427 mbx_cmd_t *mcp = &mc; 1428 1429 DEBUG11(printk("qla2x00_lip_reset(%ld): entered.\n", 1430 ha->host_no);) 1431 1432 mcp->mb[0] = MBC_LIP_RESET; 1433 mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0; 1434 if (HAS_EXTENDED_IDS(ha)) { 1435 mcp->mb[1] = 0x00ff; 1436 mcp->mb[10] = 0; 1437 mcp->out_mb |= MBX_10; 1438 } else { 1439 mcp->mb[1] = 0xff00; 1440 } 1441 mcp->mb[2] = ha->loop_reset_delay; 1442 mcp->mb[3] = 0; 1443 1444 mcp->in_mb = MBX_0; 1445 mcp->tov = 30; 1446 mcp->flags = 0; 1447 rval = qla2x00_mailbox_command(ha, mcp); 1448 1449 if (rval != QLA_SUCCESS) { 1450 /*EMPTY*/ 1451 DEBUG2_3_11(printk("qla2x00_lip_reset(%ld): failed=%x.\n", 1452 ha->host_no, rval);) 1453 } else { 1454 /*EMPTY*/ 1455 DEBUG11(printk("qla2x00_lip_reset(%ld): done.\n", ha->host_no);) 1456 } 1457 1458 return rval; 1459 } 1460 1461 /* 1462 * qla2x00_send_sns 1463 * Send SNS command. 1464 * 1465 * Input: 1466 * ha = adapter block pointer. 1467 * sns = pointer for command. 1468 * cmd_size = command size. 1469 * buf_size = response/command size. 1470 * TARGET_QUEUE_LOCK must be released. 1471 * ADAPTER_STATE_LOCK must be released. 1472 * 1473 * Returns: 1474 * qla2x00 local function return status code. 1475 * 1476 * Context: 1477 * Kernel context. 1478 */ 1479 int 1480 qla2x00_send_sns(scsi_qla_host_t *ha, dma_addr_t sns_phys_address, 1481 uint16_t cmd_size, size_t buf_size) 1482 { 1483 int rval; 1484 mbx_cmd_t mc; 1485 mbx_cmd_t *mcp = &mc; 1486 1487 DEBUG11(printk("qla2x00_send_sns(%ld): entered.\n", 1488 ha->host_no);) 1489 1490 DEBUG11(printk("qla2x00_send_sns: retry cnt=%d ratov=%d total " 1491 "tov=%d.\n", ha->retry_count, ha->login_timeout, mcp->tov);) 1492 1493 mcp->mb[0] = MBC_SEND_SNS_COMMAND; 1494 mcp->mb[1] = cmd_size; 1495 mcp->mb[2] = MSW(sns_phys_address); 1496 mcp->mb[3] = LSW(sns_phys_address); 1497 mcp->mb[6] = MSW(MSD(sns_phys_address)); 1498 mcp->mb[7] = LSW(MSD(sns_phys_address)); 1499 mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0; 1500 mcp->in_mb = MBX_0|MBX_1; 1501 mcp->buf_size = buf_size; 1502 mcp->flags = MBX_DMA_OUT|MBX_DMA_IN; 1503 mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2); 1504 rval = qla2x00_mailbox_command(ha, mcp); 1505 1506 if (rval != QLA_SUCCESS) { 1507 /*EMPTY*/ 1508 DEBUG(printk("qla2x00_send_sns(%ld): failed=%x mb[0]=%x " 1509 "mb[1]=%x.\n", ha->host_no, rval, mcp->mb[0], mcp->mb[1]);) 1510 DEBUG2_3_11(printk("qla2x00_send_sns(%ld): failed=%x mb[0]=%x " 1511 "mb[1]=%x.\n", ha->host_no, rval, mcp->mb[0], mcp->mb[1]);) 1512 } else { 1513 /*EMPTY*/ 1514 DEBUG11(printk("qla2x00_send_sns(%ld): done.\n", ha->host_no);) 1515 } 1516 1517 return rval; 1518 } 1519 1520 /* 1521 * qla2x00_login_fabric 1522 * Issue login fabric port mailbox command. 1523 * 1524 * Input: 1525 * ha = adapter block pointer. 1526 * loop_id = device loop ID. 1527 * domain = device domain. 1528 * area = device area. 1529 * al_pa = device AL_PA. 1530 * status = pointer for return status. 1531 * opt = command options. 1532 * TARGET_QUEUE_LOCK must be released. 1533 * ADAPTER_STATE_LOCK must be released. 1534 * 1535 * Returns: 1536 * qla2x00 local function return status code. 1537 * 1538 * Context: 1539 * Kernel context. 1540 */ 1541 int 1542 qla2x00_login_fabric(scsi_qla_host_t *ha, uint16_t loop_id, uint8_t domain, 1543 uint8_t area, uint8_t al_pa, uint16_t *mb, uint8_t opt) 1544 { 1545 int rval; 1546 mbx_cmd_t mc; 1547 mbx_cmd_t *mcp = &mc; 1548 1549 DEBUG11(printk("qla2x00_login_fabric(%ld): entered.\n", ha->host_no);) 1550 1551 mcp->mb[0] = MBC_LOGIN_FABRIC_PORT; 1552 mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0; 1553 if (HAS_EXTENDED_IDS(ha)) { 1554 mcp->mb[1] = loop_id; 1555 mcp->mb[10] = opt; 1556 mcp->out_mb |= MBX_10; 1557 } else { 1558 mcp->mb[1] = (loop_id << 8) | opt; 1559 } 1560 mcp->mb[2] = domain; 1561 mcp->mb[3] = area << 8 | al_pa; 1562 1563 mcp->in_mb = MBX_7|MBX_6|MBX_2|MBX_1|MBX_0; 1564 mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2); 1565 mcp->flags = 0; 1566 rval = qla2x00_mailbox_command(ha, mcp); 1567 1568 /* Return mailbox statuses. */ 1569 if (mb != NULL) { 1570 mb[0] = mcp->mb[0]; 1571 mb[1] = mcp->mb[1]; 1572 mb[2] = mcp->mb[2]; 1573 mb[6] = mcp->mb[6]; 1574 mb[7] = mcp->mb[7]; 1575 } 1576 1577 if (rval != QLA_SUCCESS) { 1578 /* RLU tmp code: need to change main mailbox_command function to 1579 * return ok even when the mailbox completion value is not 1580 * SUCCESS. The caller needs to be responsible to interpret 1581 * the return values of this mailbox command if we're not 1582 * to change too much of the existing code. 1583 */ 1584 if (mcp->mb[0] == 0x4001 || mcp->mb[0] == 0x4002 || 1585 mcp->mb[0] == 0x4003 || mcp->mb[0] == 0x4005 || 1586 mcp->mb[0] == 0x4006) 1587 rval = QLA_SUCCESS; 1588 1589 /*EMPTY*/ 1590 DEBUG2_3_11(printk("qla2x00_login_fabric(%ld): failed=%x " 1591 "mb[0]=%x mb[1]=%x mb[2]=%x.\n", ha->host_no, rval, 1592 mcp->mb[0], mcp->mb[1], mcp->mb[2]);) 1593 } else { 1594 /*EMPTY*/ 1595 DEBUG11(printk("qla2x00_login_fabric(%ld): done.\n", 1596 ha->host_no);) 1597 } 1598 1599 return rval; 1600 } 1601 1602 /* 1603 * qla2x00_login_local_device 1604 * Issue login loop port mailbox command. 1605 * 1606 * Input: 1607 * ha = adapter block pointer. 1608 * loop_id = device loop ID. 1609 * opt = command options. 1610 * 1611 * Returns: 1612 * Return status code. 1613 * 1614 * Context: 1615 * Kernel context. 1616 * 1617 */ 1618 int 1619 qla2x00_login_local_device(scsi_qla_host_t *ha, uint16_t loop_id, 1620 uint16_t *mb_ret, uint8_t opt) 1621 { 1622 int rval; 1623 mbx_cmd_t mc; 1624 mbx_cmd_t *mcp = &mc; 1625 1626 DEBUG3(printk("%s(%ld): entered.\n", __func__, ha->host_no);) 1627 1628 mcp->mb[0] = MBC_LOGIN_LOOP_PORT; 1629 if (HAS_EXTENDED_IDS(ha)) 1630 mcp->mb[1] = loop_id; 1631 else 1632 mcp->mb[1] = loop_id << 8; 1633 mcp->mb[2] = opt; 1634 mcp->out_mb = MBX_2|MBX_1|MBX_0; 1635 mcp->in_mb = MBX_7|MBX_6|MBX_1|MBX_0; 1636 mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2); 1637 mcp->flags = 0; 1638 rval = qla2x00_mailbox_command(ha, mcp); 1639 1640 /* Return mailbox statuses. */ 1641 if (mb_ret != NULL) { 1642 mb_ret[0] = mcp->mb[0]; 1643 mb_ret[1] = mcp->mb[1]; 1644 mb_ret[6] = mcp->mb[6]; 1645 mb_ret[7] = mcp->mb[7]; 1646 } 1647 1648 if (rval != QLA_SUCCESS) { 1649 /* AV tmp code: need to change main mailbox_command function to 1650 * return ok even when the mailbox completion value is not 1651 * SUCCESS. The caller needs to be responsible to interpret 1652 * the return values of this mailbox command if we're not 1653 * to change too much of the existing code. 1654 */ 1655 if (mcp->mb[0] == 0x4005 || mcp->mb[0] == 0x4006) 1656 rval = QLA_SUCCESS; 1657 1658 DEBUG(printk("%s(%ld): failed=%x mb[0]=%x mb[1]=%x " 1659 "mb[6]=%x mb[7]=%x.\n", __func__, ha->host_no, rval, 1660 mcp->mb[0], mcp->mb[1], mcp->mb[6], mcp->mb[7]);) 1661 DEBUG2_3(printk("%s(%ld): failed=%x mb[0]=%x mb[1]=%x " 1662 "mb[6]=%x mb[7]=%x.\n", __func__, ha->host_no, rval, 1663 mcp->mb[0], mcp->mb[1], mcp->mb[6], mcp->mb[7]);) 1664 } else { 1665 /*EMPTY*/ 1666 DEBUG3(printk("%s(%ld): done.\n", __func__, ha->host_no);) 1667 } 1668 1669 return (rval); 1670 } 1671 1672 /* 1673 * qla2x00_fabric_logout 1674 * Issue logout fabric port mailbox command. 1675 * 1676 * Input: 1677 * ha = adapter block pointer. 1678 * loop_id = device loop ID. 1679 * TARGET_QUEUE_LOCK must be released. 1680 * ADAPTER_STATE_LOCK must be released. 1681 * 1682 * Returns: 1683 * qla2x00 local function return status code. 1684 * 1685 * Context: 1686 * Kernel context. 1687 */ 1688 int 1689 qla2x00_fabric_logout(scsi_qla_host_t *ha, uint16_t loop_id) 1690 { 1691 int rval; 1692 mbx_cmd_t mc; 1693 mbx_cmd_t *mcp = &mc; 1694 1695 DEBUG11(printk("qla2x00_fabric_logout(%ld): entered.\n", 1696 ha->host_no);) 1697 1698 mcp->mb[0] = MBC_LOGOUT_FABRIC_PORT; 1699 mcp->out_mb = MBX_1|MBX_0; 1700 if (HAS_EXTENDED_IDS(ha)) { 1701 mcp->mb[1] = loop_id; 1702 mcp->mb[10] = 0; 1703 mcp->out_mb |= MBX_10; 1704 } else { 1705 mcp->mb[1] = loop_id << 8; 1706 } 1707 1708 mcp->in_mb = MBX_1|MBX_0; 1709 mcp->tov = 30; 1710 mcp->flags = 0; 1711 rval = qla2x00_mailbox_command(ha, mcp); 1712 1713 if (rval != QLA_SUCCESS) { 1714 /*EMPTY*/ 1715 DEBUG2_3_11(printk("qla2x00_fabric_logout(%ld): failed=%x " 1716 "mbx1=%x.\n", ha->host_no, rval, mcp->mb[1]);) 1717 } else { 1718 /*EMPTY*/ 1719 DEBUG11(printk("qla2x00_fabric_logout(%ld): done.\n", 1720 ha->host_no);) 1721 } 1722 1723 return rval; 1724 } 1725 1726 /* 1727 * qla2x00_full_login_lip 1728 * Issue full login LIP mailbox command. 1729 * 1730 * Input: 1731 * ha = adapter block pointer. 1732 * TARGET_QUEUE_LOCK must be released. 1733 * ADAPTER_STATE_LOCK must be released. 1734 * 1735 * Returns: 1736 * qla2x00 local function return status code. 1737 * 1738 * Context: 1739 * Kernel context. 1740 */ 1741 int 1742 qla2x00_full_login_lip(scsi_qla_host_t *ha) 1743 { 1744 int rval; 1745 mbx_cmd_t mc; 1746 mbx_cmd_t *mcp = &mc; 1747 1748 DEBUG11(printk("qla2x00_full_login_lip(%ld): entered.\n", 1749 ha->host_no);) 1750 1751 mcp->mb[0] = MBC_LIP_FULL_LOGIN; 1752 mcp->mb[1] = 0; 1753 mcp->mb[2] = 0; 1754 mcp->mb[3] = 0; 1755 mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0; 1756 mcp->in_mb = MBX_0; 1757 mcp->tov = 30; 1758 mcp->flags = 0; 1759 rval = qla2x00_mailbox_command(ha, mcp); 1760 1761 if (rval != QLA_SUCCESS) { 1762 /*EMPTY*/ 1763 DEBUG2_3_11(printk("qla2x00_full_login_lip(%ld): failed=%x.\n", 1764 ha->instance, rval);) 1765 } else { 1766 /*EMPTY*/ 1767 DEBUG11(printk("qla2x00_full_login_lip(%ld): done.\n", 1768 ha->host_no);) 1769 } 1770 1771 return rval; 1772 } 1773 1774 /* 1775 * qla2x00_get_id_list 1776 * 1777 * Input: 1778 * ha = adapter block pointer. 1779 * 1780 * Returns: 1781 * qla2x00 local function return status code. 1782 * 1783 * Context: 1784 * Kernel context. 1785 */ 1786 int 1787 qla2x00_get_id_list(scsi_qla_host_t *ha, void *id_list, dma_addr_t id_list_dma, 1788 uint16_t *entries) 1789 { 1790 int rval; 1791 mbx_cmd_t mc; 1792 mbx_cmd_t *mcp = &mc; 1793 1794 DEBUG11(printk("qla2x00_get_id_list(%ld): entered.\n", 1795 ha->host_no);) 1796 1797 if (id_list == NULL) 1798 return QLA_FUNCTION_FAILED; 1799 1800 mcp->mb[0] = MBC_GET_ID_LIST; 1801 mcp->mb[1] = MSW(id_list_dma); 1802 mcp->mb[2] = LSW(id_list_dma); 1803 mcp->mb[3] = MSW(MSD(id_list_dma)); 1804 mcp->mb[6] = LSW(MSD(id_list_dma)); 1805 mcp->out_mb = MBX_6|MBX_3|MBX_2|MBX_1|MBX_0; 1806 mcp->in_mb = MBX_1|MBX_0; 1807 mcp->tov = 30; 1808 mcp->flags = 0; 1809 rval = qla2x00_mailbox_command(ha, mcp); 1810 1811 if (rval != QLA_SUCCESS) { 1812 /*EMPTY*/ 1813 DEBUG2_3_11(printk("qla2x00_get_id_list(%ld): failed=%x.\n", 1814 ha->host_no, rval);) 1815 } else { 1816 *entries = mcp->mb[1]; 1817 DEBUG11(printk("qla2x00_get_id_list(%ld): done.\n", 1818 ha->host_no);) 1819 } 1820 1821 return rval; 1822 } 1823 1824 /* 1825 * qla2x00_get_resource_cnts 1826 * Get current firmware resource counts. 1827 * 1828 * Input: 1829 * ha = adapter block pointer. 1830 * 1831 * Returns: 1832 * qla2x00 local function return status code. 1833 * 1834 * Context: 1835 * Kernel context. 1836 */ 1837 int 1838 qla2x00_get_resource_cnts(scsi_qla_host_t *ha, uint16_t *cur_xchg_cnt, 1839 uint16_t *orig_xchg_cnt, uint16_t *cur_iocb_cnt, uint16_t *orig_iocb_cnt) 1840 { 1841 int rval; 1842 mbx_cmd_t mc; 1843 mbx_cmd_t *mcp = &mc; 1844 1845 DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no)); 1846 1847 mcp->mb[0] = MBC_GET_RESOURCE_COUNTS; 1848 mcp->out_mb = MBX_0; 1849 mcp->in_mb = MBX_10|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0; 1850 mcp->tov = 30; 1851 mcp->flags = 0; 1852 rval = qla2x00_mailbox_command(ha, mcp); 1853 1854 if (rval != QLA_SUCCESS) { 1855 /*EMPTY*/ 1856 DEBUG2_3_11(printk("%s(%ld): failed = %x.\n", __func__, 1857 ha->host_no, mcp->mb[0]);) 1858 } else { 1859 DEBUG11(printk("%s(%ld): done. mb1=%x mb2=%x mb3=%x mb6=%x " 1860 "mb7=%x mb10=%x.\n", __func__, ha->host_no, 1861 mcp->mb[1], mcp->mb[2], mcp->mb[3], mcp->mb[6], mcp->mb[7], 1862 mcp->mb[10])); 1863 1864 if (cur_xchg_cnt) 1865 *cur_xchg_cnt = mcp->mb[3]; 1866 if (orig_xchg_cnt) 1867 *orig_xchg_cnt = mcp->mb[6]; 1868 if (cur_iocb_cnt) 1869 *cur_iocb_cnt = mcp->mb[7]; 1870 if (orig_iocb_cnt) 1871 *orig_iocb_cnt = mcp->mb[10]; 1872 } 1873 1874 return (rval); 1875 } 1876 1877 #if defined(QL_DEBUG_LEVEL_3) 1878 /* 1879 * qla2x00_get_fcal_position_map 1880 * Get FCAL (LILP) position map using mailbox command 1881 * 1882 * Input: 1883 * ha = adapter state pointer. 1884 * pos_map = buffer pointer (can be NULL). 1885 * 1886 * Returns: 1887 * qla2x00 local function return status code. 1888 * 1889 * Context: 1890 * Kernel context. 1891 */ 1892 int 1893 qla2x00_get_fcal_position_map(scsi_qla_host_t *ha, char *pos_map) 1894 { 1895 int rval; 1896 mbx_cmd_t mc; 1897 mbx_cmd_t *mcp = &mc; 1898 char *pmap; 1899 dma_addr_t pmap_dma; 1900 1901 pmap = dma_pool_alloc(ha->s_dma_pool, GFP_ATOMIC, &pmap_dma); 1902 if (pmap == NULL) { 1903 DEBUG2_3_11(printk("%s(%ld): **** Mem Alloc Failed ****", 1904 __func__, ha->host_no)); 1905 return QLA_MEMORY_ALLOC_FAILED; 1906 } 1907 memset(pmap, 0, FCAL_MAP_SIZE); 1908 1909 mcp->mb[0] = MBC_GET_FC_AL_POSITION_MAP; 1910 mcp->mb[2] = MSW(pmap_dma); 1911 mcp->mb[3] = LSW(pmap_dma); 1912 mcp->mb[6] = MSW(MSD(pmap_dma)); 1913 mcp->mb[7] = LSW(MSD(pmap_dma)); 1914 mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_0; 1915 mcp->in_mb = MBX_1|MBX_0; 1916 mcp->buf_size = FCAL_MAP_SIZE; 1917 mcp->flags = MBX_DMA_IN; 1918 mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2); 1919 rval = qla2x00_mailbox_command(ha, mcp); 1920 1921 if (rval == QLA_SUCCESS) { 1922 DEBUG11(printk("%s(%ld): (mb0=%x/mb1=%x) FC/AL Position Map " 1923 "size (%x)\n", __func__, ha->host_no, mcp->mb[0], 1924 mcp->mb[1], (unsigned)pmap[0])); 1925 DEBUG11(qla2x00_dump_buffer(pmap, pmap[0] + 1)); 1926 1927 if (pos_map) 1928 memcpy(pos_map, pmap, FCAL_MAP_SIZE); 1929 } 1930 dma_pool_free(ha->s_dma_pool, pmap, pmap_dma); 1931 1932 if (rval != QLA_SUCCESS) { 1933 DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__, 1934 ha->host_no, rval)); 1935 } else { 1936 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no)); 1937 } 1938 1939 return rval; 1940 } 1941 #endif 1942