qla_mbx.c revision ae91193cd5bc80b4d62b1d4f0e7f3fea48f41ccd
1/* 2 * QLOGIC LINUX SOFTWARE 3 * 4 * QLogic ISP2x00 device driver for Linux 2.6.x 5 * Copyright (C) 2003-2005 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 23static void 24qla2x00_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 */ 56static int 57qla2x00_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; 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 abort_active = test_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags); 75 76 DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no);) 77 78 /* 79 * Wait for active mailbox commands to finish by waiting at most tov 80 * seconds. This is to serialize actual issuing of mailbox cmds during 81 * non ISP abort time. 82 */ 83 if (!abort_active) { 84 if (qla2x00_down_timeout(&ha->mbx_cmd_sem, mcp->tov * HZ)) { 85 /* Timeout occurred. Return error. */ 86 DEBUG2_3_11(printk("%s(%ld): cmd access timeout. " 87 "Exiting.\n", __func__, ha->host_no);) 88 return QLA_FUNCTION_TIMEOUT; 89 } 90 } 91 92 ha->flags.mbox_busy = 1; 93 /* Save mailbox command for debug */ 94 ha->mcp = mcp; 95 96 /* Try to get mailbox register access */ 97 if (!abort_active) 98 spin_lock_irqsave(&ha->mbx_reg_lock, mbx_flags); 99 100 DEBUG11(printk("scsi(%ld): prepare to issue mbox cmd=0x%x.\n", 101 ha->host_no, mcp->mb[0]);) 102 103 spin_lock_irqsave(&ha->hardware_lock, flags); 104 105 /* Load mailbox registers. */ 106 if (IS_QLA24XX(ha) || IS_QLA25XX(ha)) 107 optr = (uint16_t __iomem *)®->isp24.mailbox0; 108 else 109 optr = (uint16_t __iomem *)MAILBOX_REG(ha, ®->isp, 0); 110 111 iptr = mcp->mb; 112 command = mcp->mb[0]; 113 mboxes = mcp->out_mb; 114 115 for (cnt = 0; cnt < ha->mbx_count; cnt++) { 116 if (IS_QLA2200(ha) && cnt == 8) 117 optr = 118 (uint16_t __iomem *)MAILBOX_REG(ha, ®->isp, 8); 119 if (mboxes & BIT_0) 120 WRT_REG_WORD(optr, *iptr); 121 122 mboxes >>= 1; 123 optr++; 124 iptr++; 125 } 126 127#if defined(QL_DEBUG_LEVEL_1) 128 printk("%s(%ld): Loaded MBX registers (displayed in bytes) = \n", 129 __func__, ha->host_no); 130 qla2x00_dump_buffer((uint8_t *)mcp->mb, 16); 131 printk("\n"); 132 qla2x00_dump_buffer(((uint8_t *)mcp->mb + 0x10), 16); 133 printk("\n"); 134 qla2x00_dump_buffer(((uint8_t *)mcp->mb + 0x20), 8); 135 printk("\n"); 136 printk("%s(%ld): I/O address = %p.\n", __func__, ha->host_no, optr); 137 qla2x00_dump_regs(ha); 138#endif 139 140 /* Issue set host interrupt command to send cmd out. */ 141 ha->flags.mbox_int = 0; 142 clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags); 143 144 /* Unlock mbx registers and wait for interrupt */ 145 DEBUG11(printk("%s(%ld): going to unlock irq & waiting for interrupt. " 146 "jiffies=%lx.\n", __func__, ha->host_no, jiffies);) 147 148 /* Wait for mbx cmd completion until timeout */ 149 150 if (!abort_active && io_lock_on) { 151 /* sleep on completion semaphore */ 152 DEBUG11(printk("%s(%ld): INTERRUPT MODE. Initializing timer.\n", 153 __func__, ha->host_no);) 154 155 init_timer(&tmp_intr_timer); 156 tmp_intr_timer.data = (unsigned long)&ha->mbx_intr_sem; 157 tmp_intr_timer.expires = jiffies + mcp->tov * HZ; 158 tmp_intr_timer.function = 159 (void (*)(unsigned long))qla2x00_mbx_sem_timeout; 160 161 DEBUG11(printk("%s(%ld): Adding timer.\n", __func__, 162 ha->host_no);) 163 add_timer(&tmp_intr_timer); 164 165 DEBUG11(printk("%s(%ld): going to unlock & sleep. " 166 "time=0x%lx.\n", __func__, ha->host_no, jiffies);) 167 168 set_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags); 169 170 if (IS_QLA24XX(ha) || IS_QLA25XX(ha)) 171 WRT_REG_DWORD(®->isp24.hccr, HCCRX_SET_HOST_INT); 172 else 173 WRT_REG_WORD(®->isp.hccr, HCCR_SET_HOST_INT); 174 spin_unlock_irqrestore(&ha->hardware_lock, flags); 175 176 if (!abort_active) 177 spin_unlock_irqrestore(&ha->mbx_reg_lock, mbx_flags); 178 179 /* Wait for either the timer to expire 180 * or the mbox completion interrupt 181 */ 182 down(&ha->mbx_intr_sem); 183 184 DEBUG11(printk("%s(%ld): waking up. time=0x%lx\n", __func__, 185 ha->host_no, jiffies);) 186 clear_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags); 187 188 /* delete the timer */ 189 del_timer(&tmp_intr_timer); 190 } else { 191 DEBUG3_11(printk("%s(%ld): cmd=%x POLLING MODE.\n", __func__, 192 ha->host_no, command);) 193 194 if (IS_QLA24XX(ha) || IS_QLA25XX(ha)) 195 WRT_REG_DWORD(®->isp24.hccr, HCCRX_SET_HOST_INT); 196 else 197 WRT_REG_WORD(®->isp.hccr, HCCR_SET_HOST_INT); 198 spin_unlock_irqrestore(&ha->hardware_lock, flags); 199 if (!abort_active) 200 spin_unlock_irqrestore(&ha->mbx_reg_lock, mbx_flags); 201 202 wait_time = jiffies + mcp->tov * HZ; /* wait at most tov secs */ 203 while (!ha->flags.mbox_int) { 204 if (time_after(jiffies, wait_time)) 205 break; 206 207 /* Check for pending interrupts. */ 208 qla2x00_poll(ha); 209 210 udelay(10); /* v4.27 */ 211 } /* while */ 212 } 213 214 if (!abort_active) 215 spin_lock_irqsave(&ha->mbx_reg_lock, mbx_flags); 216 217 /* Check whether we timed out */ 218 if (ha->flags.mbox_int) { 219 uint16_t *iptr2; 220 221 DEBUG3_11(printk("%s(%ld): cmd %x completed.\n", __func__, 222 ha->host_no, command);) 223 224 /* Got interrupt. Clear the flag. */ 225 ha->flags.mbox_int = 0; 226 clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags); 227 228 if (ha->mailbox_out[0] != MBS_COMMAND_COMPLETE) 229 rval = QLA_FUNCTION_FAILED; 230 231 /* Load return mailbox registers. */ 232 iptr2 = mcp->mb; 233 iptr = (uint16_t *)&ha->mailbox_out[0]; 234 mboxes = mcp->in_mb; 235 for (cnt = 0; cnt < ha->mbx_count; cnt++) { 236 if (mboxes & BIT_0) 237 *iptr2 = *iptr; 238 239 mboxes >>= 1; 240 iptr2++; 241 iptr++; 242 } 243 } else { 244 245#if defined(QL_DEBUG_LEVEL_2) || defined(QL_DEBUG_LEVEL_3) || \ 246 defined(QL_DEBUG_LEVEL_11) 247 uint16_t mb0; 248 uint32_t ictrl; 249 250 if (IS_QLA24XX(ha) || IS_QLA25XX(ha)) { 251 mb0 = RD_REG_WORD(®->isp24.mailbox0); 252 ictrl = RD_REG_DWORD(®->isp24.ictrl); 253 } else { 254 mb0 = RD_MAILBOX_REG(ha, reg->isp, 0); 255 ictrl = RD_REG_WORD(®->isp.ictrl); 256 } 257 printk("%s(%ld): **** MB Command Timeout for cmd %x ****\n", 258 __func__, ha->host_no, command); 259 printk("%s(%ld): icontrol=%x jiffies=%lx\n", __func__, 260 ha->host_no, ictrl, jiffies); 261 printk("%s(%ld): *** mailbox[0] = 0x%x ***\n", __func__, 262 ha->host_no, mb0); 263 qla2x00_dump_regs(ha); 264#endif 265 266 rval = QLA_FUNCTION_TIMEOUT; 267 } 268 269 if (!abort_active) 270 spin_unlock_irqrestore(&ha->mbx_reg_lock, mbx_flags); 271 272 ha->flags.mbox_busy = 0; 273 274 /* Clean up */ 275 ha->mcp = NULL; 276 277 if (!abort_active) { 278 DEBUG11(printk("%s(%ld): checking for additional resp " 279 "interrupt.\n", __func__, ha->host_no);) 280 281 /* polling mode for non isp_abort commands. */ 282 qla2x00_poll(ha); 283 } 284 285 if (rval == QLA_FUNCTION_TIMEOUT && 286 mcp->mb[0] != MBC_GEN_SYSTEM_ERROR) { 287 if (!io_lock_on || (mcp->flags & IOCTL_CMD)) { 288 /* not in dpc. schedule it for dpc to take over. */ 289 DEBUG(printk("%s(%ld): timeout schedule " 290 "isp_abort_needed.\n", __func__, ha->host_no);) 291 DEBUG2_3_11(printk("%s(%ld): timeout schedule " 292 "isp_abort_needed.\n", __func__, ha->host_no);) 293 qla_printk(KERN_WARNING, ha, 294 "Mailbox command timeout occured. Scheduling ISP " 295 "abort.\n"); 296 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags); 297 if (ha->dpc_wait && !ha->dpc_active) 298 up(ha->dpc_wait); 299 300 } else if (!abort_active) { 301 /* call abort directly since we are in the DPC thread */ 302 DEBUG(printk("%s(%ld): timeout calling abort_isp\n", 303 __func__, ha->host_no);) 304 DEBUG2_3_11(printk("%s(%ld): timeout calling " 305 "abort_isp\n", __func__, ha->host_no);) 306 qla_printk(KERN_WARNING, ha, 307 "Mailbox command timeout occured. Issuing ISP " 308 "abort.\n"); 309 310 set_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags); 311 clear_bit(ISP_ABORT_NEEDED, &ha->dpc_flags); 312 if (qla2x00_abort_isp(ha)) { 313 /* Failed. retry later. */ 314 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags); 315 } 316 clear_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags); 317 DEBUG(printk("%s(%ld): finished abort_isp\n", __func__, 318 ha->host_no);) 319 DEBUG2_3_11(printk("%s(%ld): finished abort_isp\n", 320 __func__, ha->host_no);) 321 } 322 } 323 324 /* Allow next mbx cmd to come in. */ 325 if (!abort_active) 326 up(&ha->mbx_cmd_sem); 327 328 if (rval) { 329 DEBUG2_3_11(printk("%s(%ld): **** FAILED. mbx0=%x, mbx1=%x, " 330 "mbx2=%x, cmd=%x ****\n", __func__, ha->host_no, 331 mcp->mb[0], mcp->mb[1], mcp->mb[2], command);) 332 } else { 333 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no);) 334 } 335 336 return rval; 337} 338 339/* 340 * qla2x00_load_ram 341 * Load adapter RAM using DMA. 342 * 343 * Input: 344 * ha = adapter block pointer. 345 * 346 * Returns: 347 * qla2x00 local function return status code. 348 * 349 * Context: 350 * Kernel context. 351 */ 352int 353qla2x00_load_ram(scsi_qla_host_t *ha, dma_addr_t req_dma, uint16_t risc_addr, 354 uint16_t risc_code_size) 355{ 356 int rval; 357 mbx_cmd_t mc; 358 mbx_cmd_t *mcp = &mc; 359 uint32_t req_len; 360 dma_addr_t nml_dma; 361 uint32_t nml_len; 362 uint32_t normalized; 363 364 DEBUG11(printk("qla2x00_load_ram(%ld): entered.\n", 365 ha->host_no);) 366 367 req_len = risc_code_size; 368 nml_dma = 0; 369 nml_len = 0; 370 371 normalized = qla2x00_normalize_dma_addr(&req_dma, &req_len, &nml_dma, 372 &nml_len); 373 374 /* Load first segment */ 375 mcp->mb[0] = MBC_LOAD_RISC_RAM; 376 mcp->mb[1] = risc_addr; 377 mcp->mb[2] = MSW(req_dma); 378 mcp->mb[3] = LSW(req_dma); 379 mcp->mb[4] = (uint16_t)req_len; 380 mcp->mb[6] = MSW(MSD(req_dma)); 381 mcp->mb[7] = LSW(MSD(req_dma)); 382 mcp->out_mb = MBX_7|MBX_6|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0; 383 mcp->in_mb = MBX_0; 384 mcp->tov = 30; 385 mcp->flags = 0; 386 rval = qla2x00_mailbox_command(ha, mcp); 387 388 /* Load second segment - if necessary */ 389 if (normalized && (rval == QLA_SUCCESS)) { 390 mcp->mb[0] = MBC_LOAD_RISC_RAM; 391 mcp->mb[1] = risc_addr + (uint16_t)req_len; 392 mcp->mb[2] = MSW(nml_dma); 393 mcp->mb[3] = LSW(nml_dma); 394 mcp->mb[4] = (uint16_t)nml_len; 395 mcp->mb[6] = MSW(MSD(nml_dma)); 396 mcp->mb[7] = LSW(MSD(nml_dma)); 397 mcp->out_mb = MBX_7|MBX_6|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0; 398 mcp->in_mb = MBX_0; 399 mcp->tov = 30; 400 mcp->flags = 0; 401 rval = qla2x00_mailbox_command(ha, mcp); 402 } 403 404 if (rval == QLA_SUCCESS) { 405 /* Empty */ 406 DEBUG11(printk("qla2x00_load_ram(%ld): done.\n", ha->host_no);) 407 } else { 408 /* Empty */ 409 DEBUG2_3_11(printk("qla2x00_load_ram(%ld): failed. rval=%x " 410 "mb[0]=%x.\n", ha->host_no, rval, mcp->mb[0]);) 411 } 412 return rval; 413} 414 415/* 416 * qla2x00_load_ram_ext 417 * Load adapter extended RAM using DMA. 418 * 419 * Input: 420 * ha = adapter block pointer. 421 * 422 * Returns: 423 * qla2x00 local function return status code. 424 * 425 * Context: 426 * Kernel context. 427 */ 428int 429qla2x00_load_ram_ext(scsi_qla_host_t *ha, dma_addr_t req_dma, 430 uint32_t risc_addr, uint32_t risc_code_size) 431{ 432 int rval; 433 mbx_cmd_t mc; 434 mbx_cmd_t *mcp = &mc; 435 436 DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no)); 437 438 mcp->mb[0] = MBC_LOAD_RISC_RAM_EXTENDED; 439 mcp->mb[1] = LSW(risc_addr); 440 mcp->mb[2] = MSW(req_dma); 441 mcp->mb[3] = LSW(req_dma); 442 mcp->mb[6] = MSW(MSD(req_dma)); 443 mcp->mb[7] = LSW(MSD(req_dma)); 444 mcp->mb[8] = MSW(risc_addr); 445 mcp->out_mb = MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0; 446 if (IS_QLA24XX(ha) || IS_QLA25XX(ha)) { 447 mcp->mb[4] = MSW(risc_code_size); 448 mcp->mb[5] = LSW(risc_code_size); 449 mcp->out_mb |= MBX_5|MBX_4; 450 } else { 451 mcp->mb[4] = LSW(risc_code_size); 452 mcp->out_mb |= MBX_4; 453 } 454 455 mcp->in_mb = MBX_0; 456 mcp->tov = 30; 457 mcp->flags = 0; 458 rval = qla2x00_mailbox_command(ha, mcp); 459 460 if (rval != QLA_SUCCESS) { 461 DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x.\n", __func__, 462 ha->host_no, rval, mcp->mb[0])); 463 } else { 464 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no)); 465 } 466 467 return rval; 468} 469 470/* 471 * qla2x00_execute_fw 472 * Start adapter firmware. 473 * 474 * Input: 475 * ha = adapter block pointer. 476 * TARGET_QUEUE_LOCK must be released. 477 * ADAPTER_STATE_LOCK must be released. 478 * 479 * Returns: 480 * qla2x00 local function return status code. 481 * 482 * Context: 483 * Kernel context. 484 */ 485int 486qla2x00_execute_fw(scsi_qla_host_t *ha, uint32_t risc_addr) 487{ 488 int rval; 489 mbx_cmd_t mc; 490 mbx_cmd_t *mcp = &mc; 491 492 DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no);) 493 494 mcp->mb[0] = MBC_EXECUTE_FIRMWARE; 495 mcp->out_mb = MBX_0; 496 mcp->in_mb = MBX_0; 497 if (IS_QLA24XX(ha) || IS_QLA25XX(ha)) { 498 mcp->mb[1] = MSW(risc_addr); 499 mcp->mb[2] = LSW(risc_addr); 500 mcp->mb[3] = 0; 501 mcp->out_mb |= MBX_3|MBX_2|MBX_1; 502 mcp->in_mb |= MBX_1; 503 } else { 504 mcp->mb[1] = LSW(risc_addr); 505 mcp->out_mb |= MBX_1; 506 if (IS_QLA2322(ha) || IS_QLA6322(ha)) { 507 mcp->mb[2] = 0; 508 mcp->out_mb |= MBX_2; 509 } 510 } 511 512 mcp->tov = 30; 513 mcp->flags = 0; 514 rval = qla2x00_mailbox_command(ha, mcp); 515 516 if (rval != QLA_SUCCESS) { 517 DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x.\n", __func__, 518 ha->host_no, rval, mcp->mb[0])); 519 } else { 520 if (IS_QLA24XX(ha) || IS_QLA25XX(ha)) { 521 DEBUG11(printk("%s(%ld): done exchanges=%x.\n", 522 __func__, ha->host_no, mcp->mb[1]);) 523 } else { 524 DEBUG11(printk("%s(%ld): done.\n", __func__, 525 ha->host_no);) 526 } 527 } 528 529 return rval; 530} 531 532/* 533 * qla2x00_get_fw_version 534 * Get firmware version. 535 * 536 * Input: 537 * ha: adapter state pointer. 538 * major: pointer for major number. 539 * minor: pointer for minor number. 540 * subminor: pointer for subminor number. 541 * 542 * Returns: 543 * qla2x00 local function return status code. 544 * 545 * Context: 546 * Kernel context. 547 */ 548void 549qla2x00_get_fw_version(scsi_qla_host_t *ha, uint16_t *major, uint16_t *minor, 550 uint16_t *subminor, uint16_t *attributes, uint32_t *memory) 551{ 552 int rval; 553 mbx_cmd_t mc; 554 mbx_cmd_t *mcp = &mc; 555 556 DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no)); 557 558 mcp->mb[0] = MBC_GET_FIRMWARE_VERSION; 559 mcp->out_mb = MBX_0; 560 mcp->in_mb = MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0; 561 mcp->flags = 0; 562 mcp->tov = 30; 563 rval = qla2x00_mailbox_command(ha, mcp); 564 565 /* Return mailbox data. */ 566 *major = mcp->mb[1]; 567 *minor = mcp->mb[2]; 568 *subminor = mcp->mb[3]; 569 *attributes = mcp->mb[6]; 570 if (IS_QLA2100(ha) || IS_QLA2200(ha)) 571 *memory = 0x1FFFF; /* Defaults to 128KB. */ 572 else 573 *memory = (mcp->mb[5] << 16) | mcp->mb[4]; 574 575 if (rval != QLA_SUCCESS) { 576 /*EMPTY*/ 577 DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__, 578 ha->host_no, rval)); 579 } else { 580 /*EMPTY*/ 581 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no)); 582 } 583} 584 585/* 586 * qla2x00_get_fw_options 587 * Set firmware options. 588 * 589 * Input: 590 * ha = adapter block pointer. 591 * fwopt = pointer for firmware options. 592 * 593 * Returns: 594 * qla2x00 local function return status code. 595 * 596 * Context: 597 * Kernel context. 598 */ 599int 600qla2x00_get_fw_options(scsi_qla_host_t *ha, uint16_t *fwopts) 601{ 602 int rval; 603 mbx_cmd_t mc; 604 mbx_cmd_t *mcp = &mc; 605 606 DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no)); 607 608 mcp->mb[0] = MBC_GET_FIRMWARE_OPTION; 609 mcp->out_mb = MBX_0; 610 mcp->in_mb = MBX_3|MBX_2|MBX_1|MBX_0; 611 mcp->tov = 30; 612 mcp->flags = 0; 613 rval = qla2x00_mailbox_command(ha, mcp); 614 615 if (rval != QLA_SUCCESS) { 616 /*EMPTY*/ 617 DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__, 618 ha->host_no, rval)); 619 } else { 620 fwopts[0] = mcp->mb[0]; 621 fwopts[1] = mcp->mb[1]; 622 fwopts[2] = mcp->mb[2]; 623 fwopts[3] = mcp->mb[3]; 624 625 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no)); 626 } 627 628 return rval; 629} 630 631 632/* 633 * qla2x00_set_fw_options 634 * Set firmware options. 635 * 636 * Input: 637 * ha = adapter block pointer. 638 * fwopt = pointer for firmware options. 639 * 640 * Returns: 641 * qla2x00 local function return status code. 642 * 643 * Context: 644 * Kernel context. 645 */ 646int 647qla2x00_set_fw_options(scsi_qla_host_t *ha, uint16_t *fwopts) 648{ 649 int rval; 650 mbx_cmd_t mc; 651 mbx_cmd_t *mcp = &mc; 652 653 DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no)); 654 655 mcp->mb[0] = MBC_SET_FIRMWARE_OPTION; 656 mcp->mb[1] = fwopts[1]; 657 mcp->mb[2] = fwopts[2]; 658 mcp->mb[3] = fwopts[3]; 659 mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0; 660 mcp->in_mb = MBX_0; 661 if (IS_QLA24XX(ha) || IS_QLA25XX(ha)) { 662 mcp->in_mb |= MBX_1; 663 } else { 664 mcp->mb[10] = fwopts[10]; 665 mcp->mb[11] = fwopts[11]; 666 mcp->mb[12] = 0; /* Undocumented, but used */ 667 mcp->out_mb |= MBX_12|MBX_11|MBX_10; 668 } 669 mcp->tov = 30; 670 mcp->flags = 0; 671 rval = qla2x00_mailbox_command(ha, mcp); 672 673 fwopts[0] = mcp->mb[0]; 674 675 if (rval != QLA_SUCCESS) { 676 /*EMPTY*/ 677 DEBUG2_3_11(printk("%s(%ld): failed=%x (%x/%x).\n", __func__, 678 ha->host_no, rval, mcp->mb[0], mcp->mb[1])); 679 } else { 680 /*EMPTY*/ 681 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no)); 682 } 683 684 return rval; 685} 686 687/* 688 * qla2x00_mbx_reg_test 689 * Mailbox register wrap test. 690 * 691 * Input: 692 * ha = adapter block pointer. 693 * TARGET_QUEUE_LOCK must be released. 694 * ADAPTER_STATE_LOCK must be released. 695 * 696 * Returns: 697 * qla2x00 local function return status code. 698 * 699 * Context: 700 * Kernel context. 701 */ 702int 703qla2x00_mbx_reg_test(scsi_qla_host_t *ha) 704{ 705 int rval; 706 mbx_cmd_t mc; 707 mbx_cmd_t *mcp = &mc; 708 709 DEBUG11(printk("qla2x00_mbx_reg_test(%ld): entered.\n", ha->host_no);) 710 711 mcp->mb[0] = MBC_MAILBOX_REGISTER_TEST; 712 mcp->mb[1] = 0xAAAA; 713 mcp->mb[2] = 0x5555; 714 mcp->mb[3] = 0xAA55; 715 mcp->mb[4] = 0x55AA; 716 mcp->mb[5] = 0xA5A5; 717 mcp->mb[6] = 0x5A5A; 718 mcp->mb[7] = 0x2525; 719 mcp->out_mb = MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0; 720 mcp->in_mb = MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0; 721 mcp->tov = 30; 722 mcp->flags = 0; 723 rval = qla2x00_mailbox_command(ha, mcp); 724 725 if (rval == QLA_SUCCESS) { 726 if (mcp->mb[1] != 0xAAAA || mcp->mb[2] != 0x5555 || 727 mcp->mb[3] != 0xAA55 || mcp->mb[4] != 0x55AA) 728 rval = QLA_FUNCTION_FAILED; 729 if (mcp->mb[5] != 0xA5A5 || mcp->mb[6] != 0x5A5A || 730 mcp->mb[7] != 0x2525) 731 rval = QLA_FUNCTION_FAILED; 732 } 733 734 if (rval != QLA_SUCCESS) { 735 /*EMPTY*/ 736 DEBUG2_3_11(printk("qla2x00_mbx_reg_test(%ld): failed=%x.\n", 737 ha->host_no, rval);) 738 } else { 739 /*EMPTY*/ 740 DEBUG11(printk("qla2x00_mbx_reg_test(%ld): done.\n", 741 ha->host_no);) 742 } 743 744 return rval; 745} 746 747/* 748 * qla2x00_verify_checksum 749 * Verify firmware checksum. 750 * 751 * Input: 752 * ha = adapter block pointer. 753 * TARGET_QUEUE_LOCK must be released. 754 * ADAPTER_STATE_LOCK must be released. 755 * 756 * Returns: 757 * qla2x00 local function return status code. 758 * 759 * Context: 760 * Kernel context. 761 */ 762int 763qla2x00_verify_checksum(scsi_qla_host_t *ha, uint32_t risc_addr) 764{ 765 int rval; 766 mbx_cmd_t mc; 767 mbx_cmd_t *mcp = &mc; 768 769 DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no);) 770 771 mcp->mb[0] = MBC_VERIFY_CHECKSUM; 772 mcp->out_mb = MBX_0; 773 mcp->in_mb = MBX_0; 774 if (IS_QLA24XX(ha) || IS_QLA25XX(ha)) { 775 mcp->mb[1] = MSW(risc_addr); 776 mcp->mb[2] = LSW(risc_addr); 777 mcp->out_mb |= MBX_2|MBX_1; 778 mcp->in_mb |= MBX_2|MBX_1; 779 } else { 780 mcp->mb[1] = LSW(risc_addr); 781 mcp->out_mb |= MBX_1; 782 mcp->in_mb |= MBX_1; 783 } 784 785 mcp->tov = 30; 786 mcp->flags = 0; 787 rval = qla2x00_mailbox_command(ha, mcp); 788 789 if (rval != QLA_SUCCESS) { 790 DEBUG2_3_11(printk("%s(%ld): failed=%x chk sum=%x.\n", __func__, 791 ha->host_no, rval, (IS_QLA24XX(ha) || IS_QLA25XX(ha) ? 792 (mcp->mb[2] << 16) | mcp->mb[1]: mcp->mb[1]));) 793 } else { 794 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no);) 795 } 796 797 return rval; 798} 799 800/* 801 * qla2x00_issue_iocb 802 * Issue IOCB using mailbox command 803 * 804 * Input: 805 * ha = adapter state pointer. 806 * buffer = buffer pointer. 807 * phys_addr = physical address of buffer. 808 * size = size of buffer. 809 * TARGET_QUEUE_LOCK must be released. 810 * ADAPTER_STATE_LOCK must be released. 811 * 812 * Returns: 813 * qla2x00 local function return status code. 814 * 815 * Context: 816 * Kernel context. 817 */ 818int 819qla2x00_issue_iocb(scsi_qla_host_t *ha, void* buffer, dma_addr_t phys_addr, 820 size_t size) 821{ 822 int rval; 823 mbx_cmd_t mc; 824 mbx_cmd_t *mcp = &mc; 825 826 mcp->mb[0] = MBC_IOCB_COMMAND_A64; 827 mcp->mb[1] = 0; 828 mcp->mb[2] = MSW(phys_addr); 829 mcp->mb[3] = LSW(phys_addr); 830 mcp->mb[6] = MSW(MSD(phys_addr)); 831 mcp->mb[7] = LSW(MSD(phys_addr)); 832 mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0; 833 mcp->in_mb = MBX_2|MBX_0; 834 mcp->tov = 30; 835 mcp->flags = 0; 836 rval = qla2x00_mailbox_command(ha, mcp); 837 838 if (rval != QLA_SUCCESS) { 839 /*EMPTY*/ 840 DEBUG(printk("qla2x00_issue_iocb(%ld): failed rval 0x%x\n", 841 ha->host_no, rval);) 842 DEBUG2(printk("qla2x00_issue_iocb(%ld): failed rval 0x%x\n", 843 ha->host_no, rval);) 844 } else { 845 sts_entry_t *sts_entry = (sts_entry_t *) buffer; 846 847 /* Mask reserved bits. */ 848 sts_entry->entry_status &= 849 IS_QLA24XX(ha) || IS_QLA25XX(ha) ? RF_MASK_24XX :RF_MASK; 850 } 851 852 return rval; 853} 854 855/* 856 * qla2x00_abort_command 857 * Abort command aborts a specified IOCB. 858 * 859 * Input: 860 * ha = adapter block pointer. 861 * sp = SB structure pointer. 862 * 863 * Returns: 864 * qla2x00 local function return status code. 865 * 866 * Context: 867 * Kernel context. 868 */ 869int 870qla2x00_abort_command(scsi_qla_host_t *ha, srb_t *sp) 871{ 872 unsigned long flags = 0; 873 fc_port_t *fcport; 874 int rval; 875 uint32_t handle; 876 mbx_cmd_t mc; 877 mbx_cmd_t *mcp = &mc; 878 879 DEBUG11(printk("qla2x00_abort_command(%ld): entered.\n", ha->host_no);) 880 881 fcport = sp->fcport; 882 if (atomic_read(&ha->loop_state) == LOOP_DOWN || 883 atomic_read(&fcport->state) == FCS_DEVICE_LOST) { 884 return 1; 885 } 886 887 spin_lock_irqsave(&ha->hardware_lock, flags); 888 for (handle = 1; handle < MAX_OUTSTANDING_COMMANDS; handle++) { 889 if (ha->outstanding_cmds[handle] == sp) 890 break; 891 } 892 spin_unlock_irqrestore(&ha->hardware_lock, flags); 893 894 if (handle == MAX_OUTSTANDING_COMMANDS) { 895 /* command not found */ 896 return QLA_FUNCTION_FAILED; 897 } 898 899 mcp->mb[0] = MBC_ABORT_COMMAND; 900 if (HAS_EXTENDED_IDS(ha)) 901 mcp->mb[1] = fcport->loop_id; 902 else 903 mcp->mb[1] = fcport->loop_id << 8; 904 mcp->mb[2] = (uint16_t)handle; 905 mcp->mb[3] = (uint16_t)(handle >> 16); 906 mcp->mb[6] = (uint16_t)sp->cmd->device->lun; 907 mcp->out_mb = MBX_6|MBX_3|MBX_2|MBX_1|MBX_0; 908 mcp->in_mb = MBX_0; 909 mcp->tov = 30; 910 mcp->flags = 0; 911 rval = qla2x00_mailbox_command(ha, mcp); 912 913 if (rval != QLA_SUCCESS) { 914 DEBUG2_3_11(printk("qla2x00_abort_command(%ld): failed=%x.\n", 915 ha->host_no, rval);) 916 } else { 917 sp->flags |= SRB_ABORT_PENDING; 918 DEBUG11(printk("qla2x00_abort_command(%ld): done.\n", 919 ha->host_no);) 920 } 921 922 return rval; 923} 924 925#if USE_ABORT_TGT 926/* 927 * qla2x00_abort_target 928 * Issue abort target mailbox command. 929 * 930 * Input: 931 * ha = adapter block pointer. 932 * 933 * Returns: 934 * qla2x00 local function return status code. 935 * 936 * Context: 937 * Kernel context. 938 */ 939int 940qla2x00_abort_target(fc_port_t *fcport) 941{ 942 int rval; 943 mbx_cmd_t mc; 944 mbx_cmd_t *mcp = &mc; 945 scsi_qla_host_t *ha; 946 947 if (fcport == NULL) 948 return 0; 949 950 DEBUG11(printk("%s(%ld): entered.\n", __func__, fcport->ha->host_no);) 951 952 ha = fcport->ha; 953 mcp->mb[0] = MBC_ABORT_TARGET; 954 mcp->out_mb = MBX_2|MBX_1|MBX_0; 955 if (HAS_EXTENDED_IDS(ha)) { 956 mcp->mb[1] = fcport->loop_id; 957 mcp->mb[10] = 0; 958 mcp->out_mb |= MBX_10; 959 } else { 960 mcp->mb[1] = fcport->loop_id << 8; 961 } 962 mcp->mb[2] = ha->loop_reset_delay; 963 964 mcp->in_mb = MBX_0; 965 mcp->tov = 30; 966 mcp->flags = 0; 967 rval = qla2x00_mailbox_command(ha, mcp); 968 969 /* Issue marker command. */ 970 ha->marker_needed = 1; 971 972 if (rval != QLA_SUCCESS) { 973 DEBUG2_3_11(printk("qla2x00_abort_target(%ld): failed=%x.\n", 974 ha->host_no, rval);) 975 } else { 976 /*EMPTY*/ 977 DEBUG11(printk("qla2x00_abort_target(%ld): done.\n", 978 ha->host_no);) 979 } 980 981 return rval; 982} 983#endif 984 985/* 986 * qla2x00_target_reset 987 * Issue target reset mailbox command. 988 * 989 * Input: 990 * ha = adapter block pointer. 991 * TARGET_QUEUE_LOCK must be released. 992 * ADAPTER_STATE_LOCK must be released. 993 * 994 * Returns: 995 * qla2x00 local function return status code. 996 * 997 * Context: 998 * Kernel context. 999 */ 1000int 1001qla2x00_target_reset(scsi_qla_host_t *ha, struct fc_port *fcport) 1002{ 1003 int rval; 1004 mbx_cmd_t mc; 1005 mbx_cmd_t *mcp = &mc; 1006 1007 DEBUG11(printk("qla2x00_target_reset(%ld): entered.\n", ha->host_no);) 1008 1009 if (atomic_read(&fcport->state) != FCS_ONLINE) 1010 return 0; 1011 1012 mcp->mb[0] = MBC_TARGET_RESET; 1013 if (HAS_EXTENDED_IDS(ha)) 1014 mcp->mb[1] = fcport->loop_id; 1015 else 1016 mcp->mb[1] = fcport->loop_id << 8; 1017 mcp->mb[2] = ha->loop_reset_delay; 1018 mcp->out_mb = MBX_2|MBX_1|MBX_0; 1019 mcp->in_mb = MBX_0; 1020 mcp->tov = 30; 1021 mcp->flags = 0; 1022 rval = qla2x00_mailbox_command(ha, mcp); 1023 1024 if (rval != QLA_SUCCESS) { 1025 /*EMPTY*/ 1026 DEBUG2_3_11(printk("qla2x00_target_reset(%ld): failed=%x.\n", 1027 ha->host_no, rval);) 1028 } else { 1029 /*EMPTY*/ 1030 DEBUG11(printk("qla2x00_target_reset(%ld): done.\n", 1031 ha->host_no);) 1032 } 1033 1034 return rval; 1035} 1036 1037/* 1038 * qla2x00_get_adapter_id 1039 * Get adapter ID and topology. 1040 * 1041 * Input: 1042 * ha = adapter block pointer. 1043 * id = pointer for loop ID. 1044 * al_pa = pointer for AL_PA. 1045 * area = pointer for area. 1046 * domain = pointer for domain. 1047 * top = pointer for topology. 1048 * TARGET_QUEUE_LOCK must be released. 1049 * ADAPTER_STATE_LOCK must be released. 1050 * 1051 * Returns: 1052 * qla2x00 local function return status code. 1053 * 1054 * Context: 1055 * Kernel context. 1056 */ 1057int 1058qla2x00_get_adapter_id(scsi_qla_host_t *ha, uint16_t *id, uint8_t *al_pa, 1059 uint8_t *area, uint8_t *domain, uint16_t *top) 1060{ 1061 int rval; 1062 mbx_cmd_t mc; 1063 mbx_cmd_t *mcp = &mc; 1064 1065 DEBUG11(printk("qla2x00_get_adapter_id(%ld): entered.\n", 1066 ha->host_no);) 1067 1068 mcp->mb[0] = MBC_GET_ADAPTER_LOOP_ID; 1069 mcp->out_mb = MBX_0; 1070 mcp->in_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0; 1071 mcp->tov = 30; 1072 mcp->flags = 0; 1073 rval = qla2x00_mailbox_command(ha, mcp); 1074 1075 /* Return data. */ 1076 *id = mcp->mb[1]; 1077 *al_pa = LSB(mcp->mb[2]); 1078 *area = MSB(mcp->mb[2]); 1079 *domain = LSB(mcp->mb[3]); 1080 *top = mcp->mb[6]; 1081 1082 if (rval != QLA_SUCCESS) { 1083 /*EMPTY*/ 1084 DEBUG2_3_11(printk("qla2x00_get_adapter_id(%ld): failed=%x.\n", 1085 ha->host_no, rval);) 1086 } else { 1087 /*EMPTY*/ 1088 DEBUG11(printk("qla2x00_get_adapter_id(%ld): done.\n", 1089 ha->host_no);) 1090 } 1091 1092 return rval; 1093} 1094 1095/* 1096 * qla2x00_get_retry_cnt 1097 * Get current firmware login retry count and delay. 1098 * 1099 * Input: 1100 * ha = adapter block pointer. 1101 * retry_cnt = pointer to login retry count. 1102 * tov = pointer to login timeout value. 1103 * 1104 * Returns: 1105 * qla2x00 local function return status code. 1106 * 1107 * Context: 1108 * Kernel context. 1109 */ 1110int 1111qla2x00_get_retry_cnt(scsi_qla_host_t *ha, uint8_t *retry_cnt, uint8_t *tov, 1112 uint16_t *r_a_tov) 1113{ 1114 int rval; 1115 uint16_t ratov; 1116 mbx_cmd_t mc; 1117 mbx_cmd_t *mcp = &mc; 1118 1119 DEBUG11(printk("qla2x00_get_retry_cnt(%ld): entered.\n", 1120 ha->host_no);) 1121 1122 mcp->mb[0] = MBC_GET_RETRY_COUNT; 1123 mcp->out_mb = MBX_0; 1124 mcp->in_mb = MBX_3|MBX_2|MBX_1|MBX_0; 1125 mcp->tov = 30; 1126 mcp->flags = 0; 1127 rval = qla2x00_mailbox_command(ha, mcp); 1128 1129 if (rval != QLA_SUCCESS) { 1130 /*EMPTY*/ 1131 DEBUG2_3_11(printk("qla2x00_get_retry_cnt(%ld): failed = %x.\n", 1132 ha->host_no, mcp->mb[0]);) 1133 } else { 1134 /* Convert returned data and check our values. */ 1135 *r_a_tov = mcp->mb[3] / 2; 1136 ratov = (mcp->mb[3]/2) / 10; /* mb[3] value is in 100ms */ 1137 if (mcp->mb[1] * ratov > (*retry_cnt) * (*tov)) { 1138 /* Update to the larger values */ 1139 *retry_cnt = (uint8_t)mcp->mb[1]; 1140 *tov = ratov; 1141 } 1142 1143 DEBUG11(printk("qla2x00_get_retry_cnt(%ld): done. mb3=%d " 1144 "ratov=%d.\n", ha->host_no, mcp->mb[3], ratov);) 1145 } 1146 1147 return rval; 1148} 1149 1150/* 1151 * qla2x00_init_firmware 1152 * Initialize adapter firmware. 1153 * 1154 * Input: 1155 * ha = adapter block pointer. 1156 * dptr = Initialization control block pointer. 1157 * size = size of initialization control block. 1158 * TARGET_QUEUE_LOCK must be released. 1159 * ADAPTER_STATE_LOCK must be released. 1160 * 1161 * Returns: 1162 * qla2x00 local function return status code. 1163 * 1164 * Context: 1165 * Kernel context. 1166 */ 1167int 1168qla2x00_init_firmware(scsi_qla_host_t *ha, uint16_t size) 1169{ 1170 int rval; 1171 mbx_cmd_t mc; 1172 mbx_cmd_t *mcp = &mc; 1173 1174 DEBUG11(printk("qla2x00_init_firmware(%ld): entered.\n", 1175 ha->host_no);) 1176 1177 mcp->mb[0] = MBC_INITIALIZE_FIRMWARE; 1178 mcp->mb[2] = MSW(ha->init_cb_dma); 1179 mcp->mb[3] = LSW(ha->init_cb_dma); 1180 mcp->mb[4] = 0; 1181 mcp->mb[5] = 0; 1182 mcp->mb[6] = MSW(MSD(ha->init_cb_dma)); 1183 mcp->mb[7] = LSW(MSD(ha->init_cb_dma)); 1184 mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_0; 1185 mcp->in_mb = MBX_5|MBX_4|MBX_0; 1186 mcp->buf_size = size; 1187 mcp->flags = MBX_DMA_OUT; 1188 mcp->tov = 30; 1189 rval = qla2x00_mailbox_command(ha, mcp); 1190 1191 if (rval != QLA_SUCCESS) { 1192 /*EMPTY*/ 1193 DEBUG2_3_11(printk("qla2x00_init_firmware(%ld): failed=%x " 1194 "mb0=%x.\n", 1195 ha->host_no, rval, mcp->mb[0]);) 1196 } else { 1197 /*EMPTY*/ 1198 DEBUG11(printk("qla2x00_init_firmware(%ld): done.\n", 1199 ha->host_no);) 1200 } 1201 1202 return rval; 1203} 1204 1205/* 1206 * qla2x00_get_port_database 1207 * Issue normal/enhanced get port database mailbox command 1208 * and copy device name as necessary. 1209 * 1210 * Input: 1211 * ha = adapter state pointer. 1212 * dev = structure pointer. 1213 * opt = enhanced cmd option byte. 1214 * 1215 * Returns: 1216 * qla2x00 local function return status code. 1217 * 1218 * Context: 1219 * Kernel context. 1220 */ 1221int 1222qla2x00_get_port_database(scsi_qla_host_t *ha, fc_port_t *fcport, uint8_t opt) 1223{ 1224 int rval; 1225 mbx_cmd_t mc; 1226 mbx_cmd_t *mcp = &mc; 1227 port_database_t *pd; 1228 struct port_database_24xx *pd24; 1229 dma_addr_t pd_dma; 1230 1231 DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no);) 1232 1233 pd24 = NULL; 1234 pd = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &pd_dma); 1235 if (pd == NULL) { 1236 DEBUG2_3(printk("%s(%ld): failed to allocate Port Database " 1237 "structure.\n", __func__, ha->host_no)); 1238 return QLA_MEMORY_ALLOC_FAILED; 1239 } 1240 memset(pd, 0, max(PORT_DATABASE_SIZE, PORT_DATABASE_24XX_SIZE)); 1241 1242 mcp->mb[0] = MBC_GET_PORT_DATABASE; 1243 if (opt != 0 && !IS_QLA24XX(ha) && !IS_QLA25XX(ha)) 1244 mcp->mb[0] = MBC_ENHANCED_GET_PORT_DATABASE; 1245 mcp->mb[2] = MSW(pd_dma); 1246 mcp->mb[3] = LSW(pd_dma); 1247 mcp->mb[6] = MSW(MSD(pd_dma)); 1248 mcp->mb[7] = LSW(MSD(pd_dma)); 1249 mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_0; 1250 mcp->in_mb = MBX_0; 1251 if (IS_QLA24XX(ha) || IS_QLA25XX(ha)) { 1252 mcp->mb[1] = fcport->loop_id; 1253 mcp->mb[10] = opt; 1254 mcp->out_mb |= MBX_10|MBX_1; 1255 mcp->in_mb |= MBX_1; 1256 } else if (HAS_EXTENDED_IDS(ha)) { 1257 mcp->mb[1] = fcport->loop_id; 1258 mcp->mb[10] = opt; 1259 mcp->out_mb |= MBX_10|MBX_1; 1260 } else { 1261 mcp->mb[1] = fcport->loop_id << 8 | opt; 1262 mcp->out_mb |= MBX_1; 1263 } 1264 mcp->buf_size = (IS_QLA24XX(ha) || IS_QLA25XX(ha) ? 1265 PORT_DATABASE_24XX_SIZE : PORT_DATABASE_SIZE); 1266 mcp->flags = MBX_DMA_IN; 1267 mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2); 1268 rval = qla2x00_mailbox_command(ha, mcp); 1269 if (rval != QLA_SUCCESS) 1270 goto gpd_error_out; 1271 1272 if (IS_QLA24XX(ha) || IS_QLA25XX(ha)) { 1273 pd24 = (struct port_database_24xx *) pd; 1274 1275 /* Check for logged in state. */ 1276 if (pd24->current_login_state != PDS_PRLI_COMPLETE && 1277 pd24->last_login_state != PDS_PRLI_COMPLETE) { 1278 DEBUG2(printk("%s(%ld): Unable to verify " 1279 "login-state (%x/%x) for loop_id %x\n", 1280 __func__, ha->host_no, 1281 pd24->current_login_state, 1282 pd24->last_login_state, fcport->loop_id)); 1283 rval = QLA_FUNCTION_FAILED; 1284 goto gpd_error_out; 1285 } 1286 1287 /* Names are little-endian. */ 1288 memcpy(fcport->node_name, pd24->node_name, WWN_SIZE); 1289 memcpy(fcport->port_name, pd24->port_name, WWN_SIZE); 1290 1291 /* Get port_id of device. */ 1292 fcport->d_id.b.domain = pd24->port_id[0]; 1293 fcport->d_id.b.area = pd24->port_id[1]; 1294 fcport->d_id.b.al_pa = pd24->port_id[2]; 1295 fcport->d_id.b.rsvd_1 = 0; 1296 1297 /* If not target must be initiator or unknown type. */ 1298 if ((pd24->prli_svc_param_word_3[0] & BIT_4) == 0) 1299 fcport->port_type = FCT_INITIATOR; 1300 else 1301 fcport->port_type = FCT_TARGET; 1302 } else { 1303 /* Check for logged in state. */ 1304 if (pd->master_state != PD_STATE_PORT_LOGGED_IN && 1305 pd->slave_state != PD_STATE_PORT_LOGGED_IN) { 1306 rval = QLA_FUNCTION_FAILED; 1307 goto gpd_error_out; 1308 } 1309 1310 /* Names are little-endian. */ 1311 memcpy(fcport->node_name, pd->node_name, WWN_SIZE); 1312 memcpy(fcport->port_name, pd->port_name, WWN_SIZE); 1313 1314 /* Get port_id of device. */ 1315 fcport->d_id.b.domain = pd->port_id[0]; 1316 fcport->d_id.b.area = pd->port_id[3]; 1317 fcport->d_id.b.al_pa = pd->port_id[2]; 1318 fcport->d_id.b.rsvd_1 = 0; 1319 1320 /* Check for device require authentication. */ 1321 pd->common_features & BIT_5 ? (fcport->flags |= FCF_AUTH_REQ) : 1322 (fcport->flags &= ~FCF_AUTH_REQ); 1323 1324 /* If not target must be initiator or unknown type. */ 1325 if ((pd->prli_svc_param_word_3[0] & BIT_4) == 0) 1326 fcport->port_type = FCT_INITIATOR; 1327 else 1328 fcport->port_type = FCT_TARGET; 1329 } 1330 1331gpd_error_out: 1332 dma_pool_free(ha->s_dma_pool, pd, pd_dma); 1333 1334 if (rval != QLA_SUCCESS) { 1335 DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x mb[1]=%x.\n", 1336 __func__, ha->host_no, rval, mcp->mb[0], mcp->mb[1])); 1337 } else { 1338 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no)); 1339 } 1340 1341 return rval; 1342} 1343 1344/* 1345 * qla2x00_get_firmware_state 1346 * Get adapter firmware state. 1347 * 1348 * Input: 1349 * ha = adapter block pointer. 1350 * dptr = pointer for firmware state. 1351 * TARGET_QUEUE_LOCK must be released. 1352 * ADAPTER_STATE_LOCK must be released. 1353 * 1354 * Returns: 1355 * qla2x00 local function return status code. 1356 * 1357 * Context: 1358 * Kernel context. 1359 */ 1360int 1361qla2x00_get_firmware_state(scsi_qla_host_t *ha, uint16_t *dptr) 1362{ 1363 int rval; 1364 mbx_cmd_t mc; 1365 mbx_cmd_t *mcp = &mc; 1366 1367 DEBUG11(printk("qla2x00_get_firmware_state(%ld): entered.\n", 1368 ha->host_no);) 1369 1370 mcp->mb[0] = MBC_GET_FIRMWARE_STATE; 1371 mcp->out_mb = MBX_0; 1372 mcp->in_mb = MBX_2|MBX_1|MBX_0; 1373 mcp->tov = 30; 1374 mcp->flags = 0; 1375 rval = qla2x00_mailbox_command(ha, mcp); 1376 1377 /* Return firmware state. */ 1378 *dptr = mcp->mb[1]; 1379 1380 if (rval != QLA_SUCCESS) { 1381 /*EMPTY*/ 1382 DEBUG2_3_11(printk("qla2x00_get_firmware_state(%ld): " 1383 "failed=%x.\n", ha->host_no, rval);) 1384 } else { 1385 /*EMPTY*/ 1386 DEBUG11(printk("qla2x00_get_firmware_state(%ld): done.\n", 1387 ha->host_no);) 1388 } 1389 1390 return rval; 1391} 1392 1393/* 1394 * qla2x00_get_port_name 1395 * Issue get port name mailbox command. 1396 * Returned name is in big endian format. 1397 * 1398 * Input: 1399 * ha = adapter block pointer. 1400 * loop_id = loop ID of device. 1401 * name = pointer for name. 1402 * TARGET_QUEUE_LOCK must be released. 1403 * ADAPTER_STATE_LOCK must be released. 1404 * 1405 * Returns: 1406 * qla2x00 local function return status code. 1407 * 1408 * Context: 1409 * Kernel context. 1410 */ 1411int 1412qla2x00_get_port_name(scsi_qla_host_t *ha, uint16_t loop_id, uint8_t *name, 1413 uint8_t opt) 1414{ 1415 int rval; 1416 mbx_cmd_t mc; 1417 mbx_cmd_t *mcp = &mc; 1418 1419 DEBUG11(printk("qla2x00_get_port_name(%ld): entered.\n", 1420 ha->host_no);) 1421 1422 mcp->mb[0] = MBC_GET_PORT_NAME; 1423 mcp->out_mb = MBX_1|MBX_0; 1424 if (HAS_EXTENDED_IDS(ha)) { 1425 mcp->mb[1] = loop_id; 1426 mcp->mb[10] = opt; 1427 mcp->out_mb |= MBX_10; 1428 } else { 1429 mcp->mb[1] = loop_id << 8 | opt; 1430 } 1431 1432 mcp->in_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0; 1433 mcp->tov = 30; 1434 mcp->flags = 0; 1435 rval = qla2x00_mailbox_command(ha, mcp); 1436 1437 if (rval != QLA_SUCCESS) { 1438 /*EMPTY*/ 1439 DEBUG2_3_11(printk("qla2x00_get_port_name(%ld): failed=%x.\n", 1440 ha->host_no, rval);) 1441 } else { 1442 if (name != NULL) { 1443 /* This function returns name in big endian. */ 1444 name[0] = LSB(mcp->mb[2]); 1445 name[1] = MSB(mcp->mb[2]); 1446 name[2] = LSB(mcp->mb[3]); 1447 name[3] = MSB(mcp->mb[3]); 1448 name[4] = LSB(mcp->mb[6]); 1449 name[5] = MSB(mcp->mb[6]); 1450 name[6] = LSB(mcp->mb[7]); 1451 name[7] = MSB(mcp->mb[7]); 1452 } 1453 1454 DEBUG11(printk("qla2x00_get_port_name(%ld): done.\n", 1455 ha->host_no);) 1456 } 1457 1458 return rval; 1459} 1460 1461/* 1462 * qla2x00_lip_reset 1463 * Issue LIP reset mailbox command. 1464 * 1465 * Input: 1466 * ha = adapter block pointer. 1467 * TARGET_QUEUE_LOCK must be released. 1468 * ADAPTER_STATE_LOCK must be released. 1469 * 1470 * Returns: 1471 * qla2x00 local function return status code. 1472 * 1473 * Context: 1474 * Kernel context. 1475 */ 1476int 1477qla2x00_lip_reset(scsi_qla_host_t *ha) 1478{ 1479 int rval; 1480 mbx_cmd_t mc; 1481 mbx_cmd_t *mcp = &mc; 1482 1483 DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no);) 1484 1485 if (IS_QLA24XX(ha) || IS_QLA25XX(ha)) { 1486 mcp->mb[0] = MBC_LIP_FULL_LOGIN; 1487 mcp->mb[1] = BIT_0; 1488 mcp->mb[2] = 0xff; 1489 mcp->mb[3] = 0; 1490 mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0; 1491 } else { 1492 mcp->mb[0] = MBC_LIP_RESET; 1493 mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0; 1494 if (HAS_EXTENDED_IDS(ha)) { 1495 mcp->mb[1] = 0x00ff; 1496 mcp->mb[10] = 0; 1497 mcp->out_mb |= MBX_10; 1498 } else { 1499 mcp->mb[1] = 0xff00; 1500 } 1501 mcp->mb[2] = ha->loop_reset_delay; 1502 mcp->mb[3] = 0; 1503 } 1504 mcp->in_mb = MBX_0; 1505 mcp->tov = 30; 1506 mcp->flags = 0; 1507 rval = qla2x00_mailbox_command(ha, mcp); 1508 1509 if (rval != QLA_SUCCESS) { 1510 /*EMPTY*/ 1511 DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", 1512 __func__, ha->host_no, rval);) 1513 } else { 1514 /*EMPTY*/ 1515 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no);) 1516 } 1517 1518 return rval; 1519} 1520 1521/* 1522 * qla2x00_send_sns 1523 * Send SNS command. 1524 * 1525 * Input: 1526 * ha = adapter block pointer. 1527 * sns = pointer for command. 1528 * cmd_size = command size. 1529 * buf_size = response/command size. 1530 * TARGET_QUEUE_LOCK must be released. 1531 * ADAPTER_STATE_LOCK must be released. 1532 * 1533 * Returns: 1534 * qla2x00 local function return status code. 1535 * 1536 * Context: 1537 * Kernel context. 1538 */ 1539int 1540qla2x00_send_sns(scsi_qla_host_t *ha, dma_addr_t sns_phys_address, 1541 uint16_t cmd_size, size_t buf_size) 1542{ 1543 int rval; 1544 mbx_cmd_t mc; 1545 mbx_cmd_t *mcp = &mc; 1546 1547 DEBUG11(printk("qla2x00_send_sns(%ld): entered.\n", 1548 ha->host_no);) 1549 1550 DEBUG11(printk("qla2x00_send_sns: retry cnt=%d ratov=%d total " 1551 "tov=%d.\n", ha->retry_count, ha->login_timeout, mcp->tov);) 1552 1553 mcp->mb[0] = MBC_SEND_SNS_COMMAND; 1554 mcp->mb[1] = cmd_size; 1555 mcp->mb[2] = MSW(sns_phys_address); 1556 mcp->mb[3] = LSW(sns_phys_address); 1557 mcp->mb[6] = MSW(MSD(sns_phys_address)); 1558 mcp->mb[7] = LSW(MSD(sns_phys_address)); 1559 mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0; 1560 mcp->in_mb = MBX_0|MBX_1; 1561 mcp->buf_size = buf_size; 1562 mcp->flags = MBX_DMA_OUT|MBX_DMA_IN; 1563 mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2); 1564 rval = qla2x00_mailbox_command(ha, mcp); 1565 1566 if (rval != QLA_SUCCESS) { 1567 /*EMPTY*/ 1568 DEBUG(printk("qla2x00_send_sns(%ld): failed=%x mb[0]=%x " 1569 "mb[1]=%x.\n", ha->host_no, rval, mcp->mb[0], mcp->mb[1]);) 1570 DEBUG2_3_11(printk("qla2x00_send_sns(%ld): failed=%x mb[0]=%x " 1571 "mb[1]=%x.\n", ha->host_no, rval, mcp->mb[0], mcp->mb[1]);) 1572 } else { 1573 /*EMPTY*/ 1574 DEBUG11(printk("qla2x00_send_sns(%ld): done.\n", ha->host_no);) 1575 } 1576 1577 return rval; 1578} 1579 1580int 1581qla24xx_login_fabric(scsi_qla_host_t *ha, uint16_t loop_id, uint8_t domain, 1582 uint8_t area, uint8_t al_pa, uint16_t *mb, uint8_t opt) 1583{ 1584 int rval; 1585 1586 struct logio_entry_24xx *lg; 1587 dma_addr_t lg_dma; 1588 uint32_t iop[2]; 1589 1590 DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no);) 1591 1592 lg = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &lg_dma); 1593 if (lg == NULL) { 1594 DEBUG2_3(printk("%s(%ld): failed to allocate Login IOCB.\n", 1595 __func__, ha->host_no)); 1596 return QLA_MEMORY_ALLOC_FAILED; 1597 } 1598 memset(lg, 0, sizeof(struct logio_entry_24xx)); 1599 1600 lg->entry_type = LOGINOUT_PORT_IOCB_TYPE; 1601 lg->entry_count = 1; 1602 lg->nport_handle = cpu_to_le16(loop_id); 1603 lg->control_flags = __constant_cpu_to_le16(LCF_COMMAND_PLOGI); 1604 if (opt & BIT_0) 1605 lg->control_flags |= __constant_cpu_to_le16(LCF_COND_PLOGI); 1606 lg->port_id[0] = al_pa; 1607 lg->port_id[1] = area; 1608 lg->port_id[2] = domain; 1609 rval = qla2x00_issue_iocb(ha, lg, lg_dma, 0); 1610 if (rval != QLA_SUCCESS) { 1611 DEBUG2_3_11(printk("%s(%ld): failed to issue Login IOCB " 1612 "(%x).\n", __func__, ha->host_no, rval);) 1613 } else if (lg->entry_status != 0) { 1614 DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB " 1615 "-- error status (%x).\n", __func__, ha->host_no, 1616 lg->entry_status)); 1617 rval = QLA_FUNCTION_FAILED; 1618 } else if (lg->comp_status != __constant_cpu_to_le16(CS_COMPLETE)) { 1619 iop[0] = le32_to_cpu(lg->io_parameter[0]); 1620 iop[1] = le32_to_cpu(lg->io_parameter[1]); 1621 1622 DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB " 1623 "-- completion status (%x) ioparam=%x/%x.\n", __func__, 1624 ha->host_no, le16_to_cpu(lg->comp_status), iop[0], 1625 iop[1])); 1626 1627 switch (iop[0]) { 1628 case LSC_SCODE_PORTID_USED: 1629 mb[0] = MBS_PORT_ID_USED; 1630 mb[1] = LSW(iop[1]); 1631 break; 1632 case LSC_SCODE_NPORT_USED: 1633 mb[0] = MBS_LOOP_ID_USED; 1634 break; 1635 case LSC_SCODE_NOLINK: 1636 case LSC_SCODE_NOIOCB: 1637 case LSC_SCODE_NOXCB: 1638 case LSC_SCODE_CMD_FAILED: 1639 case LSC_SCODE_NOFABRIC: 1640 case LSC_SCODE_FW_NOT_READY: 1641 case LSC_SCODE_NOT_LOGGED_IN: 1642 case LSC_SCODE_NOPCB: 1643 case LSC_SCODE_ELS_REJECT: 1644 case LSC_SCODE_CMD_PARAM_ERR: 1645 case LSC_SCODE_NONPORT: 1646 case LSC_SCODE_LOGGED_IN: 1647 case LSC_SCODE_NOFLOGI_ACC: 1648 default: 1649 mb[0] = MBS_COMMAND_ERROR; 1650 break; 1651 } 1652 } else { 1653 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no);) 1654 1655 iop[0] = le32_to_cpu(lg->io_parameter[0]); 1656 1657 mb[0] = MBS_COMMAND_COMPLETE; 1658 mb[1] = 0; 1659 if (iop[0] & BIT_4) { 1660 if (iop[0] & BIT_8) 1661 mb[1] |= BIT_1; 1662 } else 1663 mb[1] = BIT_0; 1664 } 1665 1666 dma_pool_free(ha->s_dma_pool, lg, lg_dma); 1667 1668 return rval; 1669} 1670 1671/* 1672 * qla2x00_login_fabric 1673 * Issue login fabric port mailbox command. 1674 * 1675 * Input: 1676 * ha = adapter block pointer. 1677 * loop_id = device loop ID. 1678 * domain = device domain. 1679 * area = device area. 1680 * al_pa = device AL_PA. 1681 * status = pointer for return status. 1682 * opt = command options. 1683 * TARGET_QUEUE_LOCK must be released. 1684 * ADAPTER_STATE_LOCK must be released. 1685 * 1686 * Returns: 1687 * qla2x00 local function return status code. 1688 * 1689 * Context: 1690 * Kernel context. 1691 */ 1692int 1693qla2x00_login_fabric(scsi_qla_host_t *ha, uint16_t loop_id, uint8_t domain, 1694 uint8_t area, uint8_t al_pa, uint16_t *mb, uint8_t opt) 1695{ 1696 int rval; 1697 mbx_cmd_t mc; 1698 mbx_cmd_t *mcp = &mc; 1699 1700 DEBUG11(printk("qla2x00_login_fabric(%ld): entered.\n", ha->host_no);) 1701 1702 mcp->mb[0] = MBC_LOGIN_FABRIC_PORT; 1703 mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0; 1704 if (HAS_EXTENDED_IDS(ha)) { 1705 mcp->mb[1] = loop_id; 1706 mcp->mb[10] = opt; 1707 mcp->out_mb |= MBX_10; 1708 } else { 1709 mcp->mb[1] = (loop_id << 8) | opt; 1710 } 1711 mcp->mb[2] = domain; 1712 mcp->mb[3] = area << 8 | al_pa; 1713 1714 mcp->in_mb = MBX_7|MBX_6|MBX_2|MBX_1|MBX_0; 1715 mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2); 1716 mcp->flags = 0; 1717 rval = qla2x00_mailbox_command(ha, mcp); 1718 1719 /* Return mailbox statuses. */ 1720 if (mb != NULL) { 1721 mb[0] = mcp->mb[0]; 1722 mb[1] = mcp->mb[1]; 1723 mb[2] = mcp->mb[2]; 1724 mb[6] = mcp->mb[6]; 1725 mb[7] = mcp->mb[7]; 1726 } 1727 1728 if (rval != QLA_SUCCESS) { 1729 /* RLU tmp code: need to change main mailbox_command function to 1730 * return ok even when the mailbox completion value is not 1731 * SUCCESS. The caller needs to be responsible to interpret 1732 * the return values of this mailbox command if we're not 1733 * to change too much of the existing code. 1734 */ 1735 if (mcp->mb[0] == 0x4001 || mcp->mb[0] == 0x4002 || 1736 mcp->mb[0] == 0x4003 || mcp->mb[0] == 0x4005 || 1737 mcp->mb[0] == 0x4006) 1738 rval = QLA_SUCCESS; 1739 1740 /*EMPTY*/ 1741 DEBUG2_3_11(printk("qla2x00_login_fabric(%ld): failed=%x " 1742 "mb[0]=%x mb[1]=%x mb[2]=%x.\n", ha->host_no, rval, 1743 mcp->mb[0], mcp->mb[1], mcp->mb[2]);) 1744 } else { 1745 /*EMPTY*/ 1746 DEBUG11(printk("qla2x00_login_fabric(%ld): done.\n", 1747 ha->host_no);) 1748 } 1749 1750 return rval; 1751} 1752 1753/* 1754 * qla2x00_login_local_device 1755 * Issue login loop port mailbox command. 1756 * 1757 * Input: 1758 * ha = adapter block pointer. 1759 * loop_id = device loop ID. 1760 * opt = command options. 1761 * 1762 * Returns: 1763 * Return status code. 1764 * 1765 * Context: 1766 * Kernel context. 1767 * 1768 */ 1769int 1770qla2x00_login_local_device(scsi_qla_host_t *ha, uint16_t loop_id, 1771 uint16_t *mb_ret, uint8_t opt) 1772{ 1773 int rval; 1774 mbx_cmd_t mc; 1775 mbx_cmd_t *mcp = &mc; 1776 1777 DEBUG3(printk("%s(%ld): entered.\n", __func__, ha->host_no);) 1778 1779 mcp->mb[0] = MBC_LOGIN_LOOP_PORT; 1780 if (HAS_EXTENDED_IDS(ha)) 1781 mcp->mb[1] = loop_id; 1782 else 1783 mcp->mb[1] = loop_id << 8; 1784 mcp->mb[2] = opt; 1785 mcp->out_mb = MBX_2|MBX_1|MBX_0; 1786 mcp->in_mb = MBX_7|MBX_6|MBX_1|MBX_0; 1787 mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2); 1788 mcp->flags = 0; 1789 rval = qla2x00_mailbox_command(ha, mcp); 1790 1791 /* Return mailbox statuses. */ 1792 if (mb_ret != NULL) { 1793 mb_ret[0] = mcp->mb[0]; 1794 mb_ret[1] = mcp->mb[1]; 1795 mb_ret[6] = mcp->mb[6]; 1796 mb_ret[7] = mcp->mb[7]; 1797 } 1798 1799 if (rval != QLA_SUCCESS) { 1800 /* AV tmp code: need to change main mailbox_command function to 1801 * return ok even when the mailbox completion value is not 1802 * SUCCESS. The caller needs to be responsible to interpret 1803 * the return values of this mailbox command if we're not 1804 * to change too much of the existing code. 1805 */ 1806 if (mcp->mb[0] == 0x4005 || mcp->mb[0] == 0x4006) 1807 rval = QLA_SUCCESS; 1808 1809 DEBUG(printk("%s(%ld): failed=%x mb[0]=%x mb[1]=%x " 1810 "mb[6]=%x mb[7]=%x.\n", __func__, ha->host_no, rval, 1811 mcp->mb[0], mcp->mb[1], mcp->mb[6], mcp->mb[7]);) 1812 DEBUG2_3(printk("%s(%ld): failed=%x mb[0]=%x mb[1]=%x " 1813 "mb[6]=%x mb[7]=%x.\n", __func__, ha->host_no, rval, 1814 mcp->mb[0], mcp->mb[1], mcp->mb[6], mcp->mb[7]);) 1815 } else { 1816 /*EMPTY*/ 1817 DEBUG3(printk("%s(%ld): done.\n", __func__, ha->host_no);) 1818 } 1819 1820 return (rval); 1821} 1822 1823int 1824qla24xx_fabric_logout(scsi_qla_host_t *ha, uint16_t loop_id, uint8_t domain, 1825 uint8_t area, uint8_t al_pa) 1826{ 1827 int rval; 1828 struct logio_entry_24xx *lg; 1829 dma_addr_t lg_dma; 1830 1831 DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no);) 1832 1833 lg = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &lg_dma); 1834 if (lg == NULL) { 1835 DEBUG2_3(printk("%s(%ld): failed to allocate Logout IOCB.\n", 1836 __func__, ha->host_no)); 1837 return QLA_MEMORY_ALLOC_FAILED; 1838 } 1839 memset(lg, 0, sizeof(struct logio_entry_24xx)); 1840 1841 lg->entry_type = LOGINOUT_PORT_IOCB_TYPE; 1842 lg->entry_count = 1; 1843 lg->nport_handle = cpu_to_le16(loop_id); 1844 lg->control_flags = 1845 __constant_cpu_to_le16(LCF_COMMAND_LOGO|LCF_EXPL_LOGO); 1846 lg->port_id[0] = al_pa; 1847 lg->port_id[1] = area; 1848 lg->port_id[2] = domain; 1849 rval = qla2x00_issue_iocb(ha, lg, lg_dma, 0); 1850 if (rval != QLA_SUCCESS) { 1851 DEBUG2_3_11(printk("%s(%ld): failed to issue Logout IOCB " 1852 "(%x).\n", __func__, ha->host_no, rval);) 1853 } else if (lg->entry_status != 0) { 1854 DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB " 1855 "-- error status (%x).\n", __func__, ha->host_no, 1856 lg->entry_status)); 1857 rval = QLA_FUNCTION_FAILED; 1858 } else if (lg->comp_status != __constant_cpu_to_le16(CS_COMPLETE)) { 1859 DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB " 1860 "-- completion status (%x) ioparam=%x/%x.\n", __func__, 1861 ha->host_no, le16_to_cpu(lg->comp_status), 1862 le32_to_cpu(lg->io_parameter[0]), 1863 le32_to_cpu(lg->io_parameter[1]));) 1864 } else { 1865 /*EMPTY*/ 1866 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no);) 1867 } 1868 1869 dma_pool_free(ha->s_dma_pool, lg, lg_dma); 1870 1871 return rval; 1872} 1873 1874/* 1875 * qla2x00_fabric_logout 1876 * Issue logout fabric port mailbox command. 1877 * 1878 * Input: 1879 * ha = adapter block pointer. 1880 * loop_id = device loop ID. 1881 * TARGET_QUEUE_LOCK must be released. 1882 * ADAPTER_STATE_LOCK must be released. 1883 * 1884 * Returns: 1885 * qla2x00 local function return status code. 1886 * 1887 * Context: 1888 * Kernel context. 1889 */ 1890int 1891qla2x00_fabric_logout(scsi_qla_host_t *ha, uint16_t loop_id, uint8_t domain, 1892 uint8_t area, uint8_t al_pa) 1893{ 1894 int rval; 1895 mbx_cmd_t mc; 1896 mbx_cmd_t *mcp = &mc; 1897 1898 DEBUG11(printk("qla2x00_fabric_logout(%ld): entered.\n", 1899 ha->host_no);) 1900 1901 mcp->mb[0] = MBC_LOGOUT_FABRIC_PORT; 1902 mcp->out_mb = MBX_1|MBX_0; 1903 if (HAS_EXTENDED_IDS(ha)) { 1904 mcp->mb[1] = loop_id; 1905 mcp->mb[10] = 0; 1906 mcp->out_mb |= MBX_10; 1907 } else { 1908 mcp->mb[1] = loop_id << 8; 1909 } 1910 1911 mcp->in_mb = MBX_1|MBX_0; 1912 mcp->tov = 30; 1913 mcp->flags = 0; 1914 rval = qla2x00_mailbox_command(ha, mcp); 1915 1916 if (rval != QLA_SUCCESS) { 1917 /*EMPTY*/ 1918 DEBUG2_3_11(printk("qla2x00_fabric_logout(%ld): failed=%x " 1919 "mbx1=%x.\n", ha->host_no, rval, mcp->mb[1]);) 1920 } else { 1921 /*EMPTY*/ 1922 DEBUG11(printk("qla2x00_fabric_logout(%ld): done.\n", 1923 ha->host_no);) 1924 } 1925 1926 return rval; 1927} 1928 1929/* 1930 * qla2x00_full_login_lip 1931 * Issue full login LIP mailbox command. 1932 * 1933 * Input: 1934 * ha = adapter block pointer. 1935 * TARGET_QUEUE_LOCK must be released. 1936 * ADAPTER_STATE_LOCK must be released. 1937 * 1938 * Returns: 1939 * qla2x00 local function return status code. 1940 * 1941 * Context: 1942 * Kernel context. 1943 */ 1944int 1945qla2x00_full_login_lip(scsi_qla_host_t *ha) 1946{ 1947 int rval; 1948 mbx_cmd_t mc; 1949 mbx_cmd_t *mcp = &mc; 1950 1951 DEBUG11(printk("qla2x00_full_login_lip(%ld): entered.\n", 1952 ha->host_no);) 1953 1954 mcp->mb[0] = MBC_LIP_FULL_LOGIN; 1955 mcp->mb[1] = 0; 1956 mcp->mb[2] = 0xff; 1957 mcp->mb[3] = 0; 1958 mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0; 1959 mcp->in_mb = MBX_0; 1960 mcp->tov = 30; 1961 mcp->flags = 0; 1962 rval = qla2x00_mailbox_command(ha, mcp); 1963 1964 if (rval != QLA_SUCCESS) { 1965 /*EMPTY*/ 1966 DEBUG2_3_11(printk("qla2x00_full_login_lip(%ld): failed=%x.\n", 1967 ha->host_no, rval);) 1968 } else { 1969 /*EMPTY*/ 1970 DEBUG11(printk("qla2x00_full_login_lip(%ld): done.\n", 1971 ha->host_no);) 1972 } 1973 1974 return rval; 1975} 1976 1977/* 1978 * qla2x00_get_id_list 1979 * 1980 * Input: 1981 * ha = adapter block pointer. 1982 * 1983 * Returns: 1984 * qla2x00 local function return status code. 1985 * 1986 * Context: 1987 * Kernel context. 1988 */ 1989int 1990qla2x00_get_id_list(scsi_qla_host_t *ha, void *id_list, dma_addr_t id_list_dma, 1991 uint16_t *entries) 1992{ 1993 int rval; 1994 mbx_cmd_t mc; 1995 mbx_cmd_t *mcp = &mc; 1996 1997 DEBUG11(printk("qla2x00_get_id_list(%ld): entered.\n", 1998 ha->host_no);) 1999 2000 if (id_list == NULL) 2001 return QLA_FUNCTION_FAILED; 2002 2003 mcp->mb[0] = MBC_GET_ID_LIST; 2004 mcp->out_mb = MBX_0; 2005 if (IS_QLA24XX(ha) || IS_QLA25XX(ha)) { 2006 mcp->mb[2] = MSW(id_list_dma); 2007 mcp->mb[3] = LSW(id_list_dma); 2008 mcp->mb[6] = MSW(MSD(id_list_dma)); 2009 mcp->mb[7] = LSW(MSD(id_list_dma)); 2010 mcp->out_mb |= MBX_7|MBX_6|MBX_3|MBX_2; 2011 } else { 2012 mcp->mb[1] = MSW(id_list_dma); 2013 mcp->mb[2] = LSW(id_list_dma); 2014 mcp->mb[3] = MSW(MSD(id_list_dma)); 2015 mcp->mb[6] = LSW(MSD(id_list_dma)); 2016 mcp->out_mb |= MBX_6|MBX_3|MBX_2|MBX_1; 2017 } 2018 mcp->in_mb = MBX_1|MBX_0; 2019 mcp->tov = 30; 2020 mcp->flags = 0; 2021 rval = qla2x00_mailbox_command(ha, mcp); 2022 2023 if (rval != QLA_SUCCESS) { 2024 /*EMPTY*/ 2025 DEBUG2_3_11(printk("qla2x00_get_id_list(%ld): failed=%x.\n", 2026 ha->host_no, rval);) 2027 } else { 2028 *entries = mcp->mb[1]; 2029 DEBUG11(printk("qla2x00_get_id_list(%ld): done.\n", 2030 ha->host_no);) 2031 } 2032 2033 return rval; 2034} 2035 2036/* 2037 * qla2x00_get_resource_cnts 2038 * Get current firmware resource counts. 2039 * 2040 * Input: 2041 * ha = adapter block pointer. 2042 * 2043 * Returns: 2044 * qla2x00 local function return status code. 2045 * 2046 * Context: 2047 * Kernel context. 2048 */ 2049int 2050qla2x00_get_resource_cnts(scsi_qla_host_t *ha, uint16_t *cur_xchg_cnt, 2051 uint16_t *orig_xchg_cnt, uint16_t *cur_iocb_cnt, uint16_t *orig_iocb_cnt) 2052{ 2053 int rval; 2054 mbx_cmd_t mc; 2055 mbx_cmd_t *mcp = &mc; 2056 2057 DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no)); 2058 2059 mcp->mb[0] = MBC_GET_RESOURCE_COUNTS; 2060 mcp->out_mb = MBX_0; 2061 mcp->in_mb = MBX_10|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0; 2062 mcp->tov = 30; 2063 mcp->flags = 0; 2064 rval = qla2x00_mailbox_command(ha, mcp); 2065 2066 if (rval != QLA_SUCCESS) { 2067 /*EMPTY*/ 2068 DEBUG2_3_11(printk("%s(%ld): failed = %x.\n", __func__, 2069 ha->host_no, mcp->mb[0]);) 2070 } else { 2071 DEBUG11(printk("%s(%ld): done. mb1=%x mb2=%x mb3=%x mb6=%x " 2072 "mb7=%x mb10=%x.\n", __func__, ha->host_no, 2073 mcp->mb[1], mcp->mb[2], mcp->mb[3], mcp->mb[6], mcp->mb[7], 2074 mcp->mb[10])); 2075 2076 if (cur_xchg_cnt) 2077 *cur_xchg_cnt = mcp->mb[3]; 2078 if (orig_xchg_cnt) 2079 *orig_xchg_cnt = mcp->mb[6]; 2080 if (cur_iocb_cnt) 2081 *cur_iocb_cnt = mcp->mb[7]; 2082 if (orig_iocb_cnt) 2083 *orig_iocb_cnt = mcp->mb[10]; 2084 } 2085 2086 return (rval); 2087} 2088 2089#if defined(QL_DEBUG_LEVEL_3) 2090/* 2091 * qla2x00_get_fcal_position_map 2092 * Get FCAL (LILP) position map using mailbox command 2093 * 2094 * Input: 2095 * ha = adapter state pointer. 2096 * pos_map = buffer pointer (can be NULL). 2097 * 2098 * Returns: 2099 * qla2x00 local function return status code. 2100 * 2101 * Context: 2102 * Kernel context. 2103 */ 2104int 2105qla2x00_get_fcal_position_map(scsi_qla_host_t *ha, char *pos_map) 2106{ 2107 int rval; 2108 mbx_cmd_t mc; 2109 mbx_cmd_t *mcp = &mc; 2110 char *pmap; 2111 dma_addr_t pmap_dma; 2112 2113 pmap = dma_pool_alloc(ha->s_dma_pool, GFP_ATOMIC, &pmap_dma); 2114 if (pmap == NULL) { 2115 DEBUG2_3_11(printk("%s(%ld): **** Mem Alloc Failed ****", 2116 __func__, ha->host_no)); 2117 return QLA_MEMORY_ALLOC_FAILED; 2118 } 2119 memset(pmap, 0, FCAL_MAP_SIZE); 2120 2121 mcp->mb[0] = MBC_GET_FC_AL_POSITION_MAP; 2122 mcp->mb[2] = MSW(pmap_dma); 2123 mcp->mb[3] = LSW(pmap_dma); 2124 mcp->mb[6] = MSW(MSD(pmap_dma)); 2125 mcp->mb[7] = LSW(MSD(pmap_dma)); 2126 mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_0; 2127 mcp->in_mb = MBX_1|MBX_0; 2128 mcp->buf_size = FCAL_MAP_SIZE; 2129 mcp->flags = MBX_DMA_IN; 2130 mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2); 2131 rval = qla2x00_mailbox_command(ha, mcp); 2132 2133 if (rval == QLA_SUCCESS) { 2134 DEBUG11(printk("%s(%ld): (mb0=%x/mb1=%x) FC/AL Position Map " 2135 "size (%x)\n", __func__, ha->host_no, mcp->mb[0], 2136 mcp->mb[1], (unsigned)pmap[0])); 2137 DEBUG11(qla2x00_dump_buffer(pmap, pmap[0] + 1)); 2138 2139 if (pos_map) 2140 memcpy(pos_map, pmap, FCAL_MAP_SIZE); 2141 } 2142 dma_pool_free(ha->s_dma_pool, pmap, pmap_dma); 2143 2144 if (rval != QLA_SUCCESS) { 2145 DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__, 2146 ha->host_no, rval)); 2147 } else { 2148 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no)); 2149 } 2150 2151 return rval; 2152} 2153 2154uint8_t 2155qla24xx_get_isp_stats(scsi_qla_host_t *ha, uint32_t *dwbuf, uint32_t dwords, 2156 uint16_t *status) 2157{ 2158 int rval; 2159 mbx_cmd_t mc; 2160 mbx_cmd_t *mcp = &mc; 2161 uint32_t *sbuf, *siter; 2162 dma_addr_t sbuf_dma; 2163 2164 DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no);) 2165 2166 if (dwords > (DMA_POOL_SIZE / 4)) { 2167 DEBUG2_3_11(printk("%s(%ld): Unabled to retrieve %d DWORDs " 2168 "(max %d).\n", __func__, ha->host_no, dwords, 2169 DMA_POOL_SIZE / 4)); 2170 return BIT_0; 2171 } 2172 sbuf = dma_pool_alloc(ha->s_dma_pool, GFP_ATOMIC, &sbuf_dma); 2173 if (sbuf == NULL) { 2174 DEBUG2_3_11(printk("%s(%ld): Failed to allocate memory.\n", 2175 __func__, ha->host_no)); 2176 return BIT_0; 2177 } 2178 memset(sbuf, 0, DMA_POOL_SIZE); 2179 2180 mcp->mb[0] = MBC_GET_LINK_PRIV_STATS; 2181 mcp->mb[2] = MSW(sbuf_dma); 2182 mcp->mb[3] = LSW(sbuf_dma); 2183 mcp->mb[6] = MSW(MSD(sbuf_dma)); 2184 mcp->mb[7] = LSW(MSD(sbuf_dma)); 2185 mcp->mb[8] = dwords; 2186 mcp->mb[10] = 0; 2187 mcp->out_mb = MBX_10|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_0; 2188 mcp->in_mb = MBX_2|MBX_1|MBX_0; 2189 mcp->tov = 30; 2190 mcp->flags = IOCTL_CMD; 2191 rval = qla2x00_mailbox_command(ha, mcp); 2192 2193 if (rval == QLA_SUCCESS) { 2194 if (mcp->mb[0] != MBS_COMMAND_COMPLETE) { 2195 DEBUG2_3_11(printk("%s(%ld): cmd failed. mbx0=%x.\n", 2196 __func__, ha->host_no, mcp->mb[0])); 2197 status[0] = mcp->mb[0]; 2198 rval = BIT_1; 2199 } else { 2200 /* Copy over data -- firmware data is LE. */ 2201 siter = sbuf; 2202 while (dwords--) 2203 *dwbuf++ = le32_to_cpu(*siter++); 2204 } 2205 } else { 2206 /* Failed. */ 2207 DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__, 2208 ha->host_no, rval)); 2209 rval = BIT_1; 2210 } 2211 2212 dma_pool_free(ha->s_dma_pool, sbuf, sbuf_dma); 2213 2214 return rval; 2215} 2216#endif 2217 2218int 2219qla24xx_abort_command(scsi_qla_host_t *ha, srb_t *sp) 2220{ 2221 int rval; 2222 fc_port_t *fcport; 2223 unsigned long flags = 0; 2224 2225 struct abort_entry_24xx *abt; 2226 dma_addr_t abt_dma; 2227 uint32_t handle; 2228 2229 DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no);) 2230 2231 fcport = sp->fcport; 2232 if (atomic_read(&ha->loop_state) == LOOP_DOWN || 2233 atomic_read(&fcport->state) == FCS_DEVICE_LOST) { 2234 return QLA_FUNCTION_FAILED; 2235 } 2236 2237 spin_lock_irqsave(&ha->hardware_lock, flags); 2238 for (handle = 1; handle < MAX_OUTSTANDING_COMMANDS; handle++) { 2239 if (ha->outstanding_cmds[handle] == sp) 2240 break; 2241 } 2242 spin_unlock_irqrestore(&ha->hardware_lock, flags); 2243 if (handle == MAX_OUTSTANDING_COMMANDS) { 2244 /* Command not found. */ 2245 return QLA_FUNCTION_FAILED; 2246 } 2247 2248 abt = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &abt_dma); 2249 if (abt == NULL) { 2250 DEBUG2_3(printk("%s(%ld): failed to allocate Abort IOCB.\n", 2251 __func__, ha->host_no)); 2252 return QLA_MEMORY_ALLOC_FAILED; 2253 } 2254 memset(abt, 0, sizeof(struct abort_entry_24xx)); 2255 2256 abt->entry_type = ABORT_IOCB_TYPE; 2257 abt->entry_count = 1; 2258 abt->nport_handle = cpu_to_le16(fcport->loop_id); 2259 abt->handle_to_abort = handle; 2260 abt->port_id[0] = fcport->d_id.b.al_pa; 2261 abt->port_id[1] = fcport->d_id.b.area; 2262 abt->port_id[2] = fcport->d_id.b.domain; 2263 rval = qla2x00_issue_iocb(ha, abt, abt_dma, 0); 2264 if (rval != QLA_SUCCESS) { 2265 DEBUG2_3_11(printk("%s(%ld): failed to issue IOCB (%x).\n", 2266 __func__, ha->host_no, rval);) 2267 } else if (abt->entry_status != 0) { 2268 DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB " 2269 "-- error status (%x).\n", __func__, ha->host_no, 2270 abt->entry_status)); 2271 rval = QLA_FUNCTION_FAILED; 2272 } else if (abt->nport_handle != __constant_cpu_to_le16(0)) { 2273 DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB " 2274 "-- completion status (%x).\n", __func__, ha->host_no, 2275 le16_to_cpu(abt->nport_handle));) 2276 rval = QLA_FUNCTION_FAILED; 2277 } else { 2278 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no);) 2279 sp->flags |= SRB_ABORT_PENDING; 2280 } 2281 2282 dma_pool_free(ha->s_dma_pool, abt, abt_dma); 2283 2284 return rval; 2285} 2286 2287struct tsk_mgmt_cmd { 2288 union { 2289 struct tsk_mgmt_entry tsk; 2290 struct sts_entry_24xx sts; 2291 } p; 2292}; 2293 2294int 2295qla24xx_abort_target(fc_port_t *fcport) 2296{ 2297 int rval; 2298 struct tsk_mgmt_cmd *tsk; 2299 dma_addr_t tsk_dma; 2300 scsi_qla_host_t *ha; 2301 2302 if (fcport == NULL) 2303 return 0; 2304 2305 DEBUG11(printk("%s(%ld): entered.\n", __func__, fcport->ha->host_no);) 2306 2307 ha = fcport->ha; 2308 tsk = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &tsk_dma); 2309 if (tsk == NULL) { 2310 DEBUG2_3(printk("%s(%ld): failed to allocate Task Management " 2311 "IOCB.\n", __func__, ha->host_no)); 2312 return QLA_MEMORY_ALLOC_FAILED; 2313 } 2314 memset(tsk, 0, sizeof(struct tsk_mgmt_cmd)); 2315 2316 tsk->p.tsk.entry_type = TSK_MGMT_IOCB_TYPE; 2317 tsk->p.tsk.entry_count = 1; 2318 tsk->p.tsk.nport_handle = cpu_to_le16(fcport->loop_id); 2319 tsk->p.tsk.timeout = __constant_cpu_to_le16(25); 2320 tsk->p.tsk.control_flags = __constant_cpu_to_le32(TCF_TARGET_RESET); 2321 tsk->p.tsk.port_id[0] = fcport->d_id.b.al_pa; 2322 tsk->p.tsk.port_id[1] = fcport->d_id.b.area; 2323 tsk->p.tsk.port_id[2] = fcport->d_id.b.domain; 2324 rval = qla2x00_issue_iocb(ha, tsk, tsk_dma, 0); 2325 if (rval != QLA_SUCCESS) { 2326 DEBUG2_3_11(printk("%s(%ld): failed to issue Target Reset IOCB " 2327 "(%x).\n", __func__, ha->host_no, rval);) 2328 goto atarget_done; 2329 } else if (tsk->p.sts.entry_status != 0) { 2330 DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB " 2331 "-- error status (%x).\n", __func__, ha->host_no, 2332 tsk->p.sts.entry_status)); 2333 rval = QLA_FUNCTION_FAILED; 2334 goto atarget_done; 2335 } else if (tsk->p.sts.comp_status != 2336 __constant_cpu_to_le16(CS_COMPLETE)) { 2337 DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB " 2338 "-- completion status (%x).\n", __func__, 2339 ha->host_no, le16_to_cpu(tsk->p.sts.comp_status));) 2340 rval = QLA_FUNCTION_FAILED; 2341 goto atarget_done; 2342 } 2343 2344 /* Issue marker IOCB. */ 2345 rval = qla2x00_marker(ha, fcport->loop_id, 0, MK_SYNC_ID); 2346 if (rval != QLA_SUCCESS) { 2347 DEBUG2_3_11(printk("%s(%ld): failed to issue Marker IOCB " 2348 "(%x).\n", __func__, ha->host_no, rval);) 2349 } else { 2350 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no);) 2351 } 2352 2353atarget_done: 2354 dma_pool_free(ha->s_dma_pool, tsk, tsk_dma); 2355 2356 return rval; 2357} 2358 2359int 2360qla2x00_system_error(scsi_qla_host_t *ha) 2361{ 2362 int rval; 2363 mbx_cmd_t mc; 2364 mbx_cmd_t *mcp = &mc; 2365 2366 if (!IS_QLA24XX(ha) && !IS_QLA25XX(ha)) 2367 return QLA_FUNCTION_FAILED; 2368 2369 DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no)); 2370 2371 mcp->mb[0] = MBC_GEN_SYSTEM_ERROR; 2372 mcp->out_mb = MBX_0; 2373 mcp->in_mb = MBX_0; 2374 mcp->tov = 5; 2375 mcp->flags = 0; 2376 rval = qla2x00_mailbox_command(ha, mcp); 2377 2378 if (rval != QLA_SUCCESS) { 2379 DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__, 2380 ha->host_no, rval)); 2381 } else { 2382 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no)); 2383 } 2384 2385 return rval; 2386} 2387 2388/** 2389 * qla2x00_get_serdes_params() - 2390 * @ha: HA context 2391 * 2392 * Returns 2393 */ 2394int 2395qla2x00_get_serdes_params(scsi_qla_host_t *ha, uint16_t *sw_em_1g, 2396 uint16_t *sw_em_2g, uint16_t *sw_em_4g) 2397{ 2398 int rval; 2399 mbx_cmd_t mc; 2400 mbx_cmd_t *mcp = &mc; 2401 2402 DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no)); 2403 2404 mcp->mb[0] = MBC_SERDES_PARAMS; 2405 mcp->mb[1] = 0; 2406 mcp->out_mb = MBX_1|MBX_0; 2407 mcp->in_mb = MBX_4|MBX_3|MBX_2|MBX_0; 2408 mcp->tov = 30; 2409 mcp->flags = 0; 2410 rval = qla2x00_mailbox_command(ha, mcp); 2411 2412 if (rval != QLA_SUCCESS) { 2413 /*EMPTY*/ 2414 DEBUG2_3_11(printk("%s(%ld): failed=%x (%x).\n", __func__, 2415 ha->host_no, rval, mcp->mb[0])); 2416 } else { 2417 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no)); 2418 2419 if (sw_em_1g) 2420 *sw_em_1g = mcp->mb[2]; 2421 if (sw_em_2g) 2422 *sw_em_2g = mcp->mb[3]; 2423 if (sw_em_4g) 2424 *sw_em_4g = mcp->mb[4]; 2425 } 2426 2427 return rval; 2428} 2429 2430/** 2431 * qla2x00_set_serdes_params() - 2432 * @ha: HA context 2433 * 2434 * Returns 2435 */ 2436int 2437qla2x00_set_serdes_params(scsi_qla_host_t *ha, uint16_t sw_em_1g, 2438 uint16_t sw_em_2g, uint16_t sw_em_4g) 2439{ 2440 int rval; 2441 mbx_cmd_t mc; 2442 mbx_cmd_t *mcp = &mc; 2443 2444 DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no)); 2445 2446 mcp->mb[0] = MBC_SERDES_PARAMS; 2447 mcp->mb[1] = BIT_0; 2448 mcp->mb[2] = sw_em_1g; 2449 mcp->mb[3] = sw_em_2g; 2450 mcp->mb[4] = sw_em_4g; 2451 mcp->out_mb = MBX_4|MBX_3|MBX_2|MBX_1|MBX_0; 2452 mcp->in_mb = MBX_0; 2453 mcp->tov = 30; 2454 mcp->flags = 0; 2455 rval = qla2x00_mailbox_command(ha, mcp); 2456 2457 if (rval != QLA_SUCCESS) { 2458 /*EMPTY*/ 2459 DEBUG2_3_11(printk("%s(%ld): failed=%x (%x).\n", __func__, 2460 ha->host_no, rval, mcp->mb[0])); 2461 } else { 2462 /*EMPTY*/ 2463 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no)); 2464 } 2465 2466 return rval; 2467} 2468