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