drivers/scsi/qla2xxx/qla_mbx.c

   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
  24 static void
  25 qla2x00_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  */
  57 static int
  58 qla2x00_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 *)&reg->isp24.mailbox0;
 109         else
 110                 optr = (uint16_t __iomem *)MAILBOX_REG(ha, &reg->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, &reg->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(&reg->isp24.hccr, HCCRX_SET_HOST_INT);
 173                 else
 174                         WRT_REG_WORD(&reg->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(&reg->isp24.hccr, HCCRX_SET_HOST_INT);
 197                 else
 198                         WRT_REG_WORD(&reg->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(&reg->isp24.mailbox0);
 253                         ictrl = RD_REG_DWORD(&reg->isp24.ictrl);
 254                 } else {
 255                         mb0 = RD_MAILBOX_REG(ha, &reg->isp, 0);
 256                         ictrl = RD_REG_WORD(&reg->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  */
 353 int
 354 qla2x00_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  */
 429 int
 430 qla2x00_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  */
 486 int
 487 qla2x00_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  */
 549 void
 550 qla2x00_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  */
 600 int
 601 qla2x00_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  */
 647 int
 648 qla2x00_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  */
 703 int
 704 qla2x00_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  */
 763 int
 764 qla2x00_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  */
 819 int
 820 qla2x00_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  */
 870 int
 871 qla2x00_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  */
 940 int
 941 qla2x00_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_target_reset
 988  *      Issue target reset mailbox command.
 989  *
 990  * Input:
 991  *      ha = adapter block pointer.
 992  *      TARGET_QUEUE_LOCK must be released.
 993  *      ADAPTER_STATE_LOCK must be released.
 994  *
 995  * Returns:
 996  *      qla2x00 local function return status code.
 997  *
 998  * Context:
 999  *      Kernel context.
1000  */
1001 int
1002 qla2x00_target_reset(scsi_qla_host_t *ha, struct fc_port *fcport)
1003 {
1004         int rval;
1005         mbx_cmd_t mc;
1006         mbx_cmd_t *mcp = &mc;
1007
1008         DEBUG11(printk("qla2x00_target_reset(%ld): entered.\n", ha->host_no);)
1009
1010         if (atomic_read(&fcport->state) != FCS_ONLINE)
1011                 return 0;
1012
1013         mcp->mb[0] = MBC_TARGET_RESET;
1014         if (HAS_EXTENDED_IDS(ha))
1015                 mcp->mb[1] = fcport->loop_id;
1016         else
1017                 mcp->mb[1] = fcport->loop_id << 8;
1018         mcp->mb[2] = ha->loop_reset_delay;
1019         mcp->out_mb = MBX_2|MBX_1|MBX_0;
1020         mcp->in_mb = MBX_0;
1021         mcp->tov = 30;
1022         mcp->flags = 0;
1023         rval = qla2x00_mailbox_command(ha, mcp);
1024
1025         if (rval != QLA_SUCCESS) {
1026                 /*EMPTY*/
1027                 DEBUG2_3_11(printk("qla2x00_target_reset(%ld): failed=%x.\n",
1028                     ha->host_no, rval);)
1029         } else {
1030                 /*EMPTY*/
1031                 DEBUG11(printk("qla2x00_target_reset(%ld): done.\n",
1032                     ha->host_no);)
1033         }
1034
1035         return rval;
1036 }
1037
1038 /*
1039  * qla2x00_get_adapter_id
1040  *      Get adapter ID and topology.
1041  *
1042  * Input:
1043  *      ha = adapter block pointer.
1044  *      id = pointer for loop ID.
1045  *      al_pa = pointer for AL_PA.
1046  *      area = pointer for area.
1047  *      domain = pointer for domain.
1048  *      top = pointer for topology.
1049  *      TARGET_QUEUE_LOCK must be released.
1050  *      ADAPTER_STATE_LOCK must be released.
1051  *
1052  * Returns:
1053  *      qla2x00 local function return status code.
1054  *
1055  * Context:
1056  *      Kernel context.
1057  */
1058 int
1059 qla2x00_get_adapter_id(scsi_qla_host_t *ha, uint16_t *id, uint8_t *al_pa,
1060     uint8_t *area, uint8_t *domain, uint16_t *top)
1061 {
1062         int rval;
1063         mbx_cmd_t mc;
1064         mbx_cmd_t *mcp = &mc;
1065
1066         DEBUG11(printk("qla2x00_get_adapter_id(%ld): entered.\n",
1067             ha->host_no);)
1068
1069         mcp->mb[0] = MBC_GET_ADAPTER_LOOP_ID;
1070         mcp->out_mb = MBX_0;
1071         mcp->in_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
1072         mcp->tov = 30;
1073         mcp->flags = 0;
1074         rval = qla2x00_mailbox_command(ha, mcp);
1075
1076         /* Return data. */
1077         *id = mcp->mb[1];
1078         *al_pa = LSB(mcp->mb[2]);
1079         *area = MSB(mcp->mb[2]);
1080         *domain = LSB(mcp->mb[3]);
1081         *top = mcp->mb[6];
1082
1083         if (rval != QLA_SUCCESS) {
1084                 /*EMPTY*/
1085                 DEBUG2_3_11(printk("qla2x00_get_adapter_id(%ld): failed=%x.\n",
1086                     ha->host_no, rval);)
1087         } else {
1088                 /*EMPTY*/
1089                 DEBUG11(printk("qla2x00_get_adapter_id(%ld): done.\n",
1090                     ha->host_no);)
1091         }
1092
1093         return rval;
1094 }
1095
1096 /*
1097  * qla2x00_get_retry_cnt
1098  *      Get current firmware login retry count and delay.
1099  *
1100  * Input:
1101  *      ha = adapter block pointer.
1102  *      retry_cnt = pointer to login retry count.
1103  *      tov = pointer to login timeout value.
1104  *
1105  * Returns:
1106  *      qla2x00 local function return status code.
1107  *
1108  * Context:
1109  *      Kernel context.
1110  */
1111 int
1112 qla2x00_get_retry_cnt(scsi_qla_host_t *ha, uint8_t *retry_cnt, uint8_t *tov,
1113     uint16_t *r_a_tov)
1114 {
1115         int rval;
1116         uint16_t ratov;
1117         mbx_cmd_t mc;
1118         mbx_cmd_t *mcp = &mc;
1119
1120         DEBUG11(printk("qla2x00_get_retry_cnt(%ld): entered.\n",
1121                         ha->host_no);)
1122
1123         mcp->mb[0] = MBC_GET_RETRY_COUNT;
1124         mcp->out_mb = MBX_0;
1125         mcp->in_mb = MBX_3|MBX_2|MBX_1|MBX_0;
1126         mcp->tov = 30;
1127         mcp->flags = 0;
1128         rval = qla2x00_mailbox_command(ha, mcp);
1129
1130         if (rval != QLA_SUCCESS) {
1131                 /*EMPTY*/
1132                 DEBUG2_3_11(printk("qla2x00_get_retry_cnt(%ld): failed = %x.\n",
1133                     ha->host_no, mcp->mb[0]);)
1134         } else {
1135                 /* Convert returned data and check our values. */
1136                 *r_a_tov = mcp->mb[3] / 2;
1137                 ratov = (mcp->mb[3]/2) / 10;  /* mb[3] value is in 100ms */
1138                 if (mcp->mb[1] * ratov > (*retry_cnt) * (*tov)) {
1139                         /* Update to the larger values */
1140                         *retry_cnt = (uint8_t)mcp->mb[1];
1141                         *tov = ratov;
1142                 }
1143
1144                 DEBUG11(printk("qla2x00_get_retry_cnt(%ld): done. mb3=%d "
1145                     "ratov=%d.\n", ha->host_no, mcp->mb[3], ratov);)
1146         }
1147
1148         return rval;
1149 }
1150
1151 /*
1152  * qla2x00_init_firmware
1153  *      Initialize adapter firmware.
1154  *
1155  * Input:
1156  *      ha = adapter block pointer.
1157  *      dptr = Initialization control block pointer.
1158  *      size = size of initialization control block.
1159  *      TARGET_QUEUE_LOCK must be released.
1160  *      ADAPTER_STATE_LOCK must be released.
1161  *
1162  * Returns:
1163  *      qla2x00 local function return status code.
1164  *
1165  * Context:
1166  *      Kernel context.
1167  */
1168 int
1169 qla2x00_init_firmware(scsi_qla_host_t *ha, uint16_t size)
1170 {
1171         int rval;
1172         mbx_cmd_t mc;
1173         mbx_cmd_t *mcp = &mc;
1174
1175         DEBUG11(printk("qla2x00_init_firmware(%ld): entered.\n",
1176             ha->host_no);)
1177
1178         mcp->mb[0] = MBC_INITIALIZE_FIRMWARE;
1179         mcp->mb[2] = MSW(ha->init_cb_dma);
1180         mcp->mb[3] = LSW(ha->init_cb_dma);
1181         mcp->mb[4] = 0;
1182         mcp->mb[5] = 0;
1183         mcp->mb[6] = MSW(MSD(ha->init_cb_dma));
1184         mcp->mb[7] = LSW(MSD(ha->init_cb_dma));
1185         mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_0;
1186         mcp->in_mb = MBX_5|MBX_4|MBX_0;
1187         mcp->buf_size = size;
1188         mcp->flags = MBX_DMA_OUT;
1189         mcp->tov = 30;
1190         rval = qla2x00_mailbox_command(ha, mcp);
1191
1192         if (rval != QLA_SUCCESS) {
1193                 /*EMPTY*/
1194                 DEBUG2_3_11(printk("qla2x00_init_firmware(%ld): failed=%x "
1195                     "mb0=%x.\n",
1196                     ha->host_no, rval, mcp->mb[0]);)
1197         } else {
1198                 /*EMPTY*/
1199                 DEBUG11(printk("qla2x00_init_firmware(%ld): done.\n",
1200                     ha->host_no);)
1201         }
1202
1203         return rval;
1204 }
1205
1206 /*
1207  * qla2x00_get_port_database
1208  *      Issue normal/enhanced get port database mailbox command
1209  *      and copy device name as necessary.
1210  *
1211  * Input:
1212  *      ha = adapter state pointer.
1213  *      dev = structure pointer.
1214  *      opt = enhanced cmd option byte.
1215  *
1216  * Returns:
1217  *      qla2x00 local function return status code.
1218  *
1219  * Context:
1220  *      Kernel context.
1221  */
1222 int
1223 qla2x00_get_port_database(scsi_qla_host_t *ha, fc_port_t *fcport, uint8_t opt)
1224 {
1225         int rval;
1226         mbx_cmd_t mc;
1227         mbx_cmd_t *mcp = &mc;
1228         port_database_t *pd;
1229         struct port_database_24xx *pd24;
1230         dma_addr_t pd_dma;
1231
1232         DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no);)
1233
1234         pd24 = NULL;
1235         pd = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &pd_dma);
1236         if (pd  == NULL) {
1237                 DEBUG2_3(printk("%s(%ld): failed to allocate Port Database "
1238                     "structure.\n", __func__, ha->host_no));
1239                 return QLA_MEMORY_ALLOC_FAILED;
1240         }
1241         memset(pd, 0, max(PORT_DATABASE_SIZE, PORT_DATABASE_24XX_SIZE));
1242
1243         mcp->mb[0] = MBC_GET_PORT_DATABASE;
1244         if (opt != 0 && !IS_QLA24XX(ha) && !IS_QLA25XX(ha))
1245                 mcp->mb[0] = MBC_ENHANCED_GET_PORT_DATABASE;
1246         mcp->mb[2] = MSW(pd_dma);
1247         mcp->mb[3] = LSW(pd_dma);
1248         mcp->mb[6] = MSW(MSD(pd_dma));
1249         mcp->mb[7] = LSW(MSD(pd_dma));
1250         mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_0;
1251         mcp->in_mb = MBX_0;
1252         if (IS_QLA24XX(ha) || IS_QLA25XX(ha)) {
1253                 mcp->mb[1] = fcport->loop_id;
1254                 mcp->mb[10] = opt;
1255                 mcp->out_mb |= MBX_10|MBX_1;
1256                 mcp->in_mb |= MBX_1;
1257         } else if (HAS_EXTENDED_IDS(ha)) {
1258                 mcp->mb[1] = fcport->loop_id;
1259                 mcp->mb[10] = opt;
1260                 mcp->out_mb |= MBX_10|MBX_1;
1261         } else {
1262                 mcp->mb[1] = fcport->loop_id << 8 | opt;
1263                 mcp->out_mb |= MBX_1;
1264         }
1265         mcp->buf_size = (IS_QLA24XX(ha) || IS_QLA25XX(ha) ?
1266             PORT_DATABASE_24XX_SIZE : PORT_DATABASE_SIZE);
1267         mcp->flags = MBX_DMA_IN;
1268         mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2);
1269         rval = qla2x00_mailbox_command(ha, mcp);
1270         if (rval != QLA_SUCCESS)
1271                 goto gpd_error_out;
1272
1273         if (IS_QLA24XX(ha) || IS_QLA25XX(ha)) {
1274                 pd24 = (struct port_database_24xx *) pd;
1275
1276                 /* Check for logged in state. */
1277                 if (pd24->current_login_state != PDS_PRLI_COMPLETE &&
1278                     pd24->last_login_state != PDS_PRLI_COMPLETE) {
1279                         DEBUG2(printk("%s(%ld): Unable to verify "
1280                             "login-state (%x/%x) for loop_id %x\n",
1281                             __func__, ha->host_no,
1282                             pd24->current_login_state,
1283                             pd24->last_login_state, fcport->loop_id));
1284                         rval = QLA_FUNCTION_FAILED;
1285                         goto gpd_error_out;
1286                 }
1287
1288                 /* Names are little-endian. */
1289                 memcpy(fcport->node_name, pd24->node_name, WWN_SIZE);
1290                 memcpy(fcport->port_name, pd24->port_name, WWN_SIZE);
1291
1292                 /* Get port_id of device. */
1293                 fcport->d_id.b.domain = pd24->port_id[0];
1294                 fcport->d_id.b.area = pd24->port_id[1];
1295                 fcport->d_id.b.al_pa = pd24->port_id[2];
1296                 fcport->d_id.b.rsvd_1 = 0;
1297
1298                 /* If not target must be initiator or unknown type. */
1299                 if ((pd24->prli_svc_param_word_3[0] & BIT_4) == 0)
1300                         fcport->port_type = FCT_INITIATOR;
1301                 else
1302                         fcport->port_type = FCT_TARGET;
1303         } else {
1304                 /* Check for logged in state. */
1305                 if (pd->master_state != PD_STATE_PORT_LOGGED_IN &&
1306                     pd->slave_state != PD_STATE_PORT_LOGGED_IN) {
1307                         rval = QLA_FUNCTION_FAILED;
1308                         goto gpd_error_out;
1309                 }
1310
1311                 /* Names are little-endian. */
1312                 memcpy(fcport->node_name, pd->node_name, WWN_SIZE);
1313                 memcpy(fcport->port_name, pd->port_name, WWN_SIZE);
1314
1315                 /* Get port_id of device. */
1316                 fcport->d_id.b.domain = pd->port_id[0];
1317                 fcport->d_id.b.area = pd->port_id[3];
1318                 fcport->d_id.b.al_pa = pd->port_id[2];
1319                 fcport->d_id.b.rsvd_1 = 0;
1320
1321                 /* Check for device require authentication. */
1322                 pd->common_features & BIT_5 ? (fcport->flags |= FCF_AUTH_REQ) :
1323                     (fcport->flags &= ~FCF_AUTH_REQ);
1324
1325                 /* If not target must be initiator or unknown type. */
1326                 if ((pd->prli_svc_param_word_3[0] & BIT_4) == 0)
1327                         fcport->port_type = FCT_INITIATOR;
1328                 else
1329                         fcport->port_type = FCT_TARGET;
1330
1331                 /* Passback COS information. */
1332                 fcport->supported_classes = (pd->options & BIT_4) ?
1333                     FC_COS_CLASS2: FC_COS_CLASS3;
1334         }
1335
1336 gpd_error_out:
1337         dma_pool_free(ha->s_dma_pool, pd, pd_dma);
1338
1339         if (rval != QLA_SUCCESS) {
1340                 DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x mb[1]=%x.\n",
1341                     __func__, ha->host_no, rval, mcp->mb[0], mcp->mb[1]));
1342         } else {
1343                 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no));
1344         }
1345
1346         return rval;
1347 }
1348
1349 /*
1350  * qla2x00_get_firmware_state
1351  *      Get adapter firmware state.
1352  *
1353  * Input:
1354  *      ha = adapter block pointer.
1355  *      dptr = pointer for firmware state.
1356  *      TARGET_QUEUE_LOCK must be released.
1357  *      ADAPTER_STATE_LOCK must be released.
1358  *
1359  * Returns:
1360  *      qla2x00 local function return status code.
1361  *
1362  * Context:
1363  *      Kernel context.
1364  */
1365 int
1366 qla2x00_get_firmware_state(scsi_qla_host_t *ha, uint16_t *dptr)
1367 {
1368         int rval;
1369         mbx_cmd_t mc;
1370         mbx_cmd_t *mcp = &mc;
1371
1372         DEBUG11(printk("qla2x00_get_firmware_state(%ld): entered.\n",
1373             ha->host_no);)
1374
1375         mcp->mb[0] = MBC_GET_FIRMWARE_STATE;
1376         mcp->out_mb = MBX_0;
1377         mcp->in_mb = MBX_2|MBX_1|MBX_0;
1378         mcp->tov = 30;
1379         mcp->flags = 0;
1380         rval = qla2x00_mailbox_command(ha, mcp);
1381
1382         /* Return firmware state. */
1383         *dptr = mcp->mb[1];
1384
1385         if (rval != QLA_SUCCESS) {
1386                 /*EMPTY*/
1387                 DEBUG2_3_11(printk("qla2x00_get_firmware_state(%ld): "
1388                     "failed=%x.\n", ha->host_no, rval);)
1389         } else {
1390                 /*EMPTY*/
1391                 DEBUG11(printk("qla2x00_get_firmware_state(%ld): done.\n",
1392                     ha->host_no);)
1393         }
1394
1395         return rval;
1396 }
1397
1398 /*
1399  * qla2x00_get_port_name
1400  *      Issue get port name mailbox command.
1401  *      Returned name is in big endian format.
1402  *
1403  * Input:
1404  *      ha = adapter block pointer.
1405  *      loop_id = loop ID of device.
1406  *      name = pointer for name.
1407  *      TARGET_QUEUE_LOCK must be released.
1408  *      ADAPTER_STATE_LOCK must be released.
1409  *
1410  * Returns:
1411  *      qla2x00 local function return status code.
1412  *
1413  * Context:
1414  *      Kernel context.
1415  */
1416 int
1417 qla2x00_get_port_name(scsi_qla_host_t *ha, uint16_t loop_id, uint8_t *name,
1418     uint8_t opt)
1419 {
1420         int rval;
1421         mbx_cmd_t mc;
1422         mbx_cmd_t *mcp = &mc;
1423
1424         DEBUG11(printk("qla2x00_get_port_name(%ld): entered.\n",
1425             ha->host_no);)
1426
1427         mcp->mb[0] = MBC_GET_PORT_NAME;
1428         mcp->out_mb = MBX_1|MBX_0;
1429         if (HAS_EXTENDED_IDS(ha)) {
1430                 mcp->mb[1] = loop_id;
1431                 mcp->mb[10] = opt;
1432                 mcp->out_mb |= MBX_10;
1433         } else {
1434                 mcp->mb[1] = loop_id << 8 | opt;
1435         }
1436
1437         mcp->in_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
1438         mcp->tov = 30;
1439         mcp->flags = 0;
1440         rval = qla2x00_mailbox_command(ha, mcp);
1441
1442         if (rval != QLA_SUCCESS) {
1443                 /*EMPTY*/
1444                 DEBUG2_3_11(printk("qla2x00_get_port_name(%ld): failed=%x.\n",
1445                     ha->host_no, rval);)
1446         } else {
1447                 if (name != NULL) {
1448                         /* This function returns name in big endian. */
1449                         name[0] = LSB(mcp->mb[2]);
1450                         name[1] = MSB(mcp->mb[2]);
1451                         name[2] = LSB(mcp->mb[3]);
1452                         name[3] = MSB(mcp->mb[3]);
1453                         name[4] = LSB(mcp->mb[6]);
1454                         name[5] = MSB(mcp->mb[6]);
1455                         name[6] = LSB(mcp->mb[7]);
1456                         name[7] = MSB(mcp->mb[7]);
1457                 }
1458
1459                 DEBUG11(printk("qla2x00_get_port_name(%ld): done.\n",
1460                     ha->host_no);)
1461         }
1462
1463         return rval;
1464 }
1465
1466 /*
1467  * qla2x00_lip_reset
1468  *      Issue LIP reset mailbox command.
1469  *
1470  * Input:
1471  *      ha = adapter block pointer.
1472  *      TARGET_QUEUE_LOCK must be released.
1473  *      ADAPTER_STATE_LOCK must be released.
1474  *
1475  * Returns:
1476  *      qla2x00 local function return status code.
1477  *
1478  * Context:
1479  *      Kernel context.
1480  */
1481 int
1482 qla2x00_lip_reset(scsi_qla_host_t *ha)
1483 {
1484         int rval;
1485         mbx_cmd_t mc;
1486         mbx_cmd_t *mcp = &mc;
1487
1488         DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no);)
1489
1490         if (IS_QLA24XX(ha) || IS_QLA25XX(ha)) {
1491                 mcp->mb[0] = MBC_LIP_FULL_LOGIN;
1492                 mcp->mb[1] = BIT_0;
1493                 mcp->mb[2] = 0xff;
1494                 mcp->mb[3] = 0;
1495                 mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
1496         } else {
1497                 mcp->mb[0] = MBC_LIP_RESET;
1498                 mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
1499                 if (HAS_EXTENDED_IDS(ha)) {
1500                         mcp->mb[1] = 0x00ff;
1501                         mcp->mb[10] = 0;
1502                         mcp->out_mb |= MBX_10;
1503                 } else {
1504                         mcp->mb[1] = 0xff00;
1505                 }
1506                 mcp->mb[2] = ha->loop_reset_delay;
1507                 mcp->mb[3] = 0;
1508         }
1509         mcp->in_mb = MBX_0;
1510         mcp->tov = 30;
1511         mcp->flags = 0;
1512         rval = qla2x00_mailbox_command(ha, mcp);
1513
1514         if (rval != QLA_SUCCESS) {
1515                 /*EMPTY*/
1516                 DEBUG2_3_11(printk("%s(%ld): failed=%x.\n",
1517                     __func__, ha->host_no, rval);)
1518         } else {
1519                 /*EMPTY*/
1520                 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no);)
1521         }
1522
1523         return rval;
1524 }
1525
1526 /*
1527  * qla2x00_send_sns
1528  *      Send SNS command.
1529  *
1530  * Input:
1531  *      ha = adapter block pointer.
1532  *      sns = pointer for command.
1533  *      cmd_size = command size.
1534  *      buf_size = response/command size.
1535  *      TARGET_QUEUE_LOCK must be released.
1536  *      ADAPTER_STATE_LOCK must be released.
1537  *
1538  * Returns:
1539  *      qla2x00 local function return status code.
1540  *
1541  * Context:
1542  *      Kernel context.
1543  */
1544 int
1545 qla2x00_send_sns(scsi_qla_host_t *ha, dma_addr_t sns_phys_address,
1546     uint16_t cmd_size, size_t buf_size)
1547 {
1548         int rval;
1549         mbx_cmd_t mc;
1550         mbx_cmd_t *mcp = &mc;
1551
1552         DEBUG11(printk("qla2x00_send_sns(%ld): entered.\n",
1553             ha->host_no);)
1554
1555         DEBUG11(printk("qla2x00_send_sns: retry cnt=%d ratov=%d total "
1556             "tov=%d.\n", ha->retry_count, ha->login_timeout, mcp->tov);)
1557
1558         mcp->mb[0] = MBC_SEND_SNS_COMMAND;
1559         mcp->mb[1] = cmd_size;
1560         mcp->mb[2] = MSW(sns_phys_address);
1561         mcp->mb[3] = LSW(sns_phys_address);
1562         mcp->mb[6] = MSW(MSD(sns_phys_address));
1563         mcp->mb[7] = LSW(MSD(sns_phys_address));
1564         mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
1565         mcp->in_mb = MBX_0|MBX_1;
1566         mcp->buf_size = buf_size;
1567         mcp->flags = MBX_DMA_OUT|MBX_DMA_IN;
1568         mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2);
1569         rval = qla2x00_mailbox_command(ha, mcp);
1570
1571         if (rval != QLA_SUCCESS) {
1572                 /*EMPTY*/
1573                 DEBUG(printk("qla2x00_send_sns(%ld): failed=%x mb[0]=%x "
1574                     "mb[1]=%x.\n", ha->host_no, rval, mcp->mb[0], mcp->mb[1]);)
1575                 DEBUG2_3_11(printk("qla2x00_send_sns(%ld): failed=%x mb[0]=%x "
1576                     "mb[1]=%x.\n", ha->host_no, rval, mcp->mb[0], mcp->mb[1]);)
1577         } else {
1578                 /*EMPTY*/
1579                 DEBUG11(printk("qla2x00_send_sns(%ld): done.\n", ha->host_no);)
1580         }
1581
1582         return rval;
1583 }
1584
1585 int
1586 qla24xx_login_fabric(scsi_qla_host_t *ha, uint16_t loop_id, uint8_t domain,
1587     uint8_t area, uint8_t al_pa, uint16_t *mb, uint8_t opt)
1588 {
1589         int             rval;
1590
1591         struct logio_entry_24xx *lg;
1592         dma_addr_t      lg_dma;
1593         uint32_t        iop[2];
1594
1595         DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no);)
1596
1597         lg = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &lg_dma);
1598         if (lg == NULL) {
1599                 DEBUG2_3(printk("%s(%ld): failed to allocate Login IOCB.\n",
1600                     __func__, ha->host_no));
1601                 return QLA_MEMORY_ALLOC_FAILED;
1602         }
1603         memset(lg, 0, sizeof(struct logio_entry_24xx));
1604
1605         lg->entry_type = LOGINOUT_PORT_IOCB_TYPE;
1606         lg->entry_count = 1;
1607         lg->nport_handle = cpu_to_le16(loop_id);
1608         lg->control_flags = __constant_cpu_to_le16(LCF_COMMAND_PLOGI);
1609         if (opt & BIT_0)
1610                 lg->control_flags |= __constant_cpu_to_le16(LCF_COND_PLOGI);
1611         lg->port_id[0] = al_pa;
1612         lg->port_id[1] = area;
1613         lg->port_id[2] = domain;
1614         rval = qla2x00_issue_iocb(ha, lg, lg_dma, 0);
1615         if (rval != QLA_SUCCESS) {
1616                 DEBUG2_3_11(printk("%s(%ld): failed to issue Login IOCB "
1617                     "(%x).\n", __func__, ha->host_no, rval);)
1618         } else if (lg->entry_status != 0) {
1619                 DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
1620                     "-- error status (%x).\n", __func__, ha->host_no,
1621                     lg->entry_status));
1622                 rval = QLA_FUNCTION_FAILED;
1623         } else if (lg->comp_status != __constant_cpu_to_le16(CS_COMPLETE)) {
1624                 iop[0] = le32_to_cpu(lg->io_parameter[0]);
1625                 iop[1] = le32_to_cpu(lg->io_parameter[1]);
1626
1627                 DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
1628                     "-- completion status (%x)  ioparam=%x/%x.\n", __func__,
1629                     ha->host_no, le16_to_cpu(lg->comp_status), iop[0],
1630                     iop[1]));
1631
1632                 switch (iop[0]) {
1633                 case LSC_SCODE_PORTID_USED:
1634                         mb[0] = MBS_PORT_ID_USED;
1635                         mb[1] = LSW(iop[1]);
1636                         break;
1637                 case LSC_SCODE_NPORT_USED:
1638                         mb[0] = MBS_LOOP_ID_USED;
1639                         break;
1640                 case LSC_SCODE_NOLINK:
1641                 case LSC_SCODE_NOIOCB:
1642                 case LSC_SCODE_NOXCB:
1643                 case LSC_SCODE_CMD_FAILED:
1644                 case LSC_SCODE_NOFABRIC:
1645                 case LSC_SCODE_FW_NOT_READY:
1646                 case LSC_SCODE_NOT_LOGGED_IN:
1647                 case LSC_SCODE_NOPCB:
1648                 case LSC_SCODE_ELS_REJECT:
1649                 case LSC_SCODE_CMD_PARAM_ERR:
1650                 case LSC_SCODE_NONPORT:
1651                 case LSC_SCODE_LOGGED_IN:
1652                 case LSC_SCODE_NOFLOGI_ACC:
1653                 default:
1654                         mb[0] = MBS_COMMAND_ERROR;
1655                         break;
1656                 }
1657         } else {
1658                 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no);)
1659
1660                 iop[0] = le32_to_cpu(lg->io_parameter[0]);
1661
1662                 mb[0] = MBS_COMMAND_COMPLETE;
1663                 mb[1] = 0;
1664                 if (iop[0] & BIT_4) {
1665                         if (iop[0] & BIT_8)
1666                                 mb[1] |= BIT_1;
1667                 } else
1668                         mb[1] = BIT_0;
1669
1670                 /* Passback COS information. */
1671                 mb[10] = 0;
1672                 if (lg->io_parameter[7] || lg->io_parameter[8])
1673                         mb[10] |= BIT_0;        /* Class 2. */
1674                 if (lg->io_parameter[9] || lg->io_parameter[10])
1675                         mb[10] |= BIT_1;        /* Class 3. */
1676         }
1677
1678         dma_pool_free(ha->s_dma_pool, lg, lg_dma);
1679
1680         return rval;
1681 }
1682
1683 /*
1684  * qla2x00_login_fabric
1685  *      Issue login fabric port mailbox command.
1686  *
1687  * Input:
1688  *      ha = adapter block pointer.
1689  *      loop_id = device loop ID.
1690  *      domain = device domain.
1691  *      area = device area.
1692  *      al_pa = device AL_PA.
1693  *      status = pointer for return status.
1694  *      opt = command options.
1695  *      TARGET_QUEUE_LOCK must be released.
1696  *      ADAPTER_STATE_LOCK must be released.
1697  *
1698  * Returns:
1699  *      qla2x00 local function return status code.
1700  *
1701  * Context:
1702  *      Kernel context.
1703  */
1704 int
1705 qla2x00_login_fabric(scsi_qla_host_t *ha, uint16_t loop_id, uint8_t domain,
1706     uint8_t area, uint8_t al_pa, uint16_t *mb, uint8_t opt)
1707 {
1708         int rval;
1709         mbx_cmd_t mc;
1710         mbx_cmd_t *mcp = &mc;
1711
1712         DEBUG11(printk("qla2x00_login_fabric(%ld): entered.\n", ha->host_no);)
1713
1714         mcp->mb[0] = MBC_LOGIN_FABRIC_PORT;
1715         mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
1716         if (HAS_EXTENDED_IDS(ha)) {
1717                 mcp->mb[1] = loop_id;
1718                 mcp->mb[10] = opt;
1719                 mcp->out_mb |= MBX_10;
1720         } else {
1721                 mcp->mb[1] = (loop_id << 8) | opt;
1722         }
1723         mcp->mb[2] = domain;
1724         mcp->mb[3] = area << 8 | al_pa;
1725
1726         mcp->in_mb = MBX_7|MBX_6|MBX_2|MBX_1|MBX_0;
1727         mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2);
1728         mcp->flags = 0;
1729         rval = qla2x00_mailbox_command(ha, mcp);
1730
1731         /* Return mailbox statuses. */
1732         if (mb != NULL) {
1733                 mb[0] = mcp->mb[0];
1734                 mb[1] = mcp->mb[1];
1735                 mb[2] = mcp->mb[2];
1736                 mb[6] = mcp->mb[6];
1737                 mb[7] = mcp->mb[7];
1738                 /* COS retrieved from Get-Port-Database mailbox command. */
1739                 mb[10] = 0;
1740         }
1741
1742         if (rval != QLA_SUCCESS) {
1743                 /* RLU tmp code: need to change main mailbox_command function to
1744                  * return ok even when the mailbox completion value is not
1745                  * SUCCESS. The caller needs to be responsible to interpret
1746                  * the return values of this mailbox command if we're not
1747                  * to change too much of the existing code.
1748                  */
1749                 if (mcp->mb[0] == 0x4001 || mcp->mb[0] == 0x4002 ||
1750                     mcp->mb[0] == 0x4003 || mcp->mb[0] == 0x4005 ||
1751                     mcp->mb[0] == 0x4006)
1752                         rval = QLA_SUCCESS;
1753
1754                 /*EMPTY*/
1755                 DEBUG2_3_11(printk("qla2x00_login_fabric(%ld): failed=%x "
1756                     "mb[0]=%x mb[1]=%x mb[2]=%x.\n", ha->host_no, rval,
1757                     mcp->mb[0], mcp->mb[1], mcp->mb[2]);)
1758         } else {
1759                 /*EMPTY*/
1760                 DEBUG11(printk("qla2x00_login_fabric(%ld): done.\n",
1761                     ha->host_no);)
1762         }
1763
1764         return rval;
1765 }
1766
1767 /*
1768  * qla2x00_login_local_device
1769  *           Issue login loop port mailbox command.
1770  *
1771  * Input:
1772  *           ha = adapter block pointer.
1773  *           loop_id = device loop ID.
1774  *           opt = command options.
1775  *
1776  * Returns:
1777  *            Return status code.
1778  *
1779  * Context:
1780  *            Kernel context.
1781  *
1782  */
1783 int
1784 qla2x00_login_local_device(scsi_qla_host_t *ha, uint16_t loop_id,
1785     uint16_t *mb_ret, uint8_t opt)
1786 {
1787         int rval;
1788         mbx_cmd_t mc;
1789         mbx_cmd_t *mcp = &mc;
1790
1791         DEBUG3(printk("%s(%ld): entered.\n", __func__, ha->host_no);)
1792
1793         mcp->mb[0] = MBC_LOGIN_LOOP_PORT;
1794         if (HAS_EXTENDED_IDS(ha))
1795                 mcp->mb[1] = loop_id;
1796         else
1797                 mcp->mb[1] = loop_id << 8;
1798         mcp->mb[2] = opt;
1799         mcp->out_mb = MBX_2|MBX_1|MBX_0;
1800         mcp->in_mb = MBX_7|MBX_6|MBX_1|MBX_0;
1801         mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2);
1802         mcp->flags = 0;
1803         rval = qla2x00_mailbox_command(ha, mcp);
1804
1805         /* Return mailbox statuses. */
1806         if (mb_ret != NULL) {
1807                 mb_ret[0] = mcp->mb[0];
1808                 mb_ret[1] = mcp->mb[1];
1809                 mb_ret[6] = mcp->mb[6];
1810                 mb_ret[7] = mcp->mb[7];
1811         }
1812
1813         if (rval != QLA_SUCCESS) {
1814                 /* AV tmp code: need to change main mailbox_command function to
1815                  * return ok even when the mailbox completion value is not
1816                  * SUCCESS. The caller needs to be responsible to interpret
1817                  * the return values of this mailbox command if we're not
1818                  * to change too much of the existing code.
1819                  */
1820                 if (mcp->mb[0] == 0x4005 || mcp->mb[0] == 0x4006)
1821                         rval = QLA_SUCCESS;
1822
1823                 DEBUG(printk("%s(%ld): failed=%x mb[0]=%x mb[1]=%x "
1824                     "mb[6]=%x mb[7]=%x.\n", __func__, ha->host_no, rval,
1825                     mcp->mb[0], mcp->mb[1], mcp->mb[6], mcp->mb[7]);)
1826                 DEBUG2_3(printk("%s(%ld): failed=%x mb[0]=%x mb[1]=%x "
1827                     "mb[6]=%x mb[7]=%x.\n", __func__, ha->host_no, rval,
1828                     mcp->mb[0], mcp->mb[1], mcp->mb[6], mcp->mb[7]);)
1829         } else {
1830                 /*EMPTY*/
1831                 DEBUG3(printk("%s(%ld): done.\n", __func__, ha->host_no);)
1832         }
1833
1834         return (rval);
1835 }
1836
1837 int
1838 qla24xx_fabric_logout(scsi_qla_host_t *ha, uint16_t loop_id, uint8_t domain,
1839     uint8_t area, uint8_t al_pa)
1840 {
1841         int             rval;
1842         struct logio_entry_24xx *lg;
1843         dma_addr_t      lg_dma;
1844
1845         DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no);)
1846
1847         lg = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &lg_dma);
1848         if (lg == NULL) {
1849                 DEBUG2_3(printk("%s(%ld): failed to allocate Logout IOCB.\n",
1850                     __func__, ha->host_no));
1851                 return QLA_MEMORY_ALLOC_FAILED;
1852         }
1853         memset(lg, 0, sizeof(struct logio_entry_24xx));
1854
1855         lg->entry_type = LOGINOUT_PORT_IOCB_TYPE;
1856         lg->entry_count = 1;
1857         lg->nport_handle = cpu_to_le16(loop_id);
1858         lg->control_flags =
1859             __constant_cpu_to_le16(LCF_COMMAND_LOGO|LCF_EXPL_LOGO);
1860         lg->port_id[0] = al_pa;
1861         lg->port_id[1] = area;
1862         lg->port_id[2] = domain;
1863         rval = qla2x00_issue_iocb(ha, lg, lg_dma, 0);
1864         if (rval != QLA_SUCCESS) {
1865                 DEBUG2_3_11(printk("%s(%ld): failed to issue Logout IOCB "
1866                     "(%x).\n", __func__, ha->host_no, rval);)
1867         } else if (lg->entry_status != 0) {
1868                 DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
1869                     "-- error status (%x).\n", __func__, ha->host_no,
1870                     lg->entry_status));
1871                 rval = QLA_FUNCTION_FAILED;
1872         } else if (lg->comp_status != __constant_cpu_to_le16(CS_COMPLETE)) {
1873                 DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
1874                     "-- completion status (%x)  ioparam=%x/%x.\n", __func__,
1875                     ha->host_no, le16_to_cpu(lg->comp_status),
1876                     le32_to_cpu(lg->io_parameter[0]),
1877                     le32_to_cpu(lg->io_parameter[1]));)
1878         } else {
1879                 /*EMPTY*/
1880                 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no);)
1881         }
1882
1883         dma_pool_free(ha->s_dma_pool, lg, lg_dma);
1884
1885         return rval;
1886 }
1887
1888 /*
1889  * qla2x00_fabric_logout
1890  *      Issue logout fabric port mailbox command.
1891  *
1892  * Input:
1893  *      ha = adapter block pointer.
1894  *      loop_id = device loop ID.
1895  *      TARGET_QUEUE_LOCK must be released.
1896  *      ADAPTER_STATE_LOCK must be released.
1897  *
1898  * Returns:
1899  *      qla2x00 local function return status code.
1900  *
1901  * Context:
1902  *      Kernel context.
1903  */
1904 int
1905 qla2x00_fabric_logout(scsi_qla_host_t *ha, uint16_t loop_id, uint8_t domain,
1906     uint8_t area, uint8_t al_pa)
1907 {
1908         int rval;
1909         mbx_cmd_t mc;
1910         mbx_cmd_t *mcp = &mc;
1911
1912         DEBUG11(printk("qla2x00_fabric_logout(%ld): entered.\n",
1913             ha->host_no);)
1914
1915         mcp->mb[0] = MBC_LOGOUT_FABRIC_PORT;
1916         mcp->out_mb = MBX_1|MBX_0;
1917         if (HAS_EXTENDED_IDS(ha)) {
1918                 mcp->mb[1] = loop_id;
1919                 mcp->mb[10] = 0;
1920                 mcp->out_mb |= MBX_10;
1921         } else {
1922                 mcp->mb[1] = loop_id << 8;
1923         }
1924
1925         mcp->in_mb = MBX_1|MBX_0;
1926         mcp->tov = 30;
1927         mcp->flags = 0;
1928         rval = qla2x00_mailbox_command(ha, mcp);
1929
1930         if (rval != QLA_SUCCESS) {
1931                 /*EMPTY*/
1932                 DEBUG2_3_11(printk("qla2x00_fabric_logout(%ld): failed=%x "
1933                     "mbx1=%x.\n", ha->host_no, rval, mcp->mb[1]);)
1934         } else {
1935                 /*EMPTY*/
1936                 DEBUG11(printk("qla2x00_fabric_logout(%ld): done.\n",
1937                     ha->host_no);)
1938         }
1939
1940         return rval;
1941 }
1942
1943 /*
1944  * qla2x00_full_login_lip
1945  *      Issue full login LIP mailbox command.
1946  *
1947  * Input:
1948  *      ha = adapter block pointer.
1949  *      TARGET_QUEUE_LOCK must be released.
1950  *      ADAPTER_STATE_LOCK must be released.
1951  *
1952  * Returns:
1953  *      qla2x00 local function return status code.
1954  *
1955  * Context:
1956  *      Kernel context.
1957  */
1958 int
1959 qla2x00_full_login_lip(scsi_qla_host_t *ha)
1960 {
1961         int rval;
1962         mbx_cmd_t mc;
1963         mbx_cmd_t *mcp = &mc;
1964
1965         DEBUG11(printk("qla2x00_full_login_lip(%ld): entered.\n",
1966             ha->host_no);)
1967
1968         mcp->mb[0] = MBC_LIP_FULL_LOGIN;
1969         mcp->mb[1] = 0;
1970         mcp->mb[2] = 0xff;
1971         mcp->mb[3] = 0;
1972         mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
1973         mcp->in_mb = MBX_0;
1974         mcp->tov = 30;
1975         mcp->flags = 0;
1976         rval = qla2x00_mailbox_command(ha, mcp);
1977
1978         if (rval != QLA_SUCCESS) {
1979                 /*EMPTY*/
1980                 DEBUG2_3_11(printk("qla2x00_full_login_lip(%ld): failed=%x.\n",
1981                     ha->host_no, rval);)
1982         } else {
1983                 /*EMPTY*/
1984                 DEBUG11(printk("qla2x00_full_login_lip(%ld): done.\n",
1985                     ha->host_no);)
1986         }
1987
1988         return rval;
1989 }
1990
1991 /*
1992  * qla2x00_get_id_list
1993  *
1994  * Input:
1995  *      ha = adapter block pointer.
1996  *
1997  * Returns:
1998  *      qla2x00 local function return status code.
1999  *
2000  * Context:
2001  *      Kernel context.
2002  */
2003 int
2004 qla2x00_get_id_list(scsi_qla_host_t *ha, void *id_list, dma_addr_t id_list_dma,
2005     uint16_t *entries)
2006 {
2007         int rval;
2008         mbx_cmd_t mc;
2009         mbx_cmd_t *mcp = &mc;
2010
2011         DEBUG11(printk("qla2x00_get_id_list(%ld): entered.\n",
2012             ha->host_no);)
2013
2014         if (id_list == NULL)
2015                 return QLA_FUNCTION_FAILED;
2016
2017         mcp->mb[0] = MBC_GET_ID_LIST;
2018         mcp->out_mb = MBX_0;
2019         if (IS_QLA24XX(ha) || IS_QLA25XX(ha)) {
2020                 mcp->mb[2] = MSW(id_list_dma);
2021                 mcp->mb[3] = LSW(id_list_dma);
2022                 mcp->mb[6] = MSW(MSD(id_list_dma));
2023                 mcp->mb[7] = LSW(MSD(id_list_dma));
2024                 mcp->out_mb |= MBX_7|MBX_6|MBX_3|MBX_2;
2025         } else {
2026                 mcp->mb[1] = MSW(id_list_dma);
2027                 mcp->mb[2] = LSW(id_list_dma);
2028                 mcp->mb[3] = MSW(MSD(id_list_dma));
2029                 mcp->mb[6] = LSW(MSD(id_list_dma));
2030                 mcp->out_mb |= MBX_6|MBX_3|MBX_2|MBX_1;
2031         }
2032         mcp->in_mb = MBX_1|MBX_0;
2033         mcp->tov = 30;
2034         mcp->flags = 0;
2035         rval = qla2x00_mailbox_command(ha, mcp);
2036
2037         if (rval != QLA_SUCCESS) {
2038                 /*EMPTY*/
2039                 DEBUG2_3_11(printk("qla2x00_get_id_list(%ld): failed=%x.\n",
2040                     ha->host_no, rval);)
2041         } else {
2042                 *entries = mcp->mb[1];
2043                 DEBUG11(printk("qla2x00_get_id_list(%ld): done.\n",
2044                     ha->host_no);)
2045         }
2046
2047         return rval;
2048 }
2049
2050 /*
2051  * qla2x00_get_resource_cnts
2052  *      Get current firmware resource counts.
2053  *
2054  * Input:
2055  *      ha = adapter block pointer.
2056  *
2057  * Returns:
2058  *      qla2x00 local function return status code.
2059  *
2060  * Context:
2061  *      Kernel context.
2062  */
2063 int
2064 qla2x00_get_resource_cnts(scsi_qla_host_t *ha, uint16_t *cur_xchg_cnt,
2065     uint16_t *orig_xchg_cnt, uint16_t *cur_iocb_cnt, uint16_t *orig_iocb_cnt)
2066 {
2067         int rval;
2068         mbx_cmd_t mc;
2069         mbx_cmd_t *mcp = &mc;
2070
2071         DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no));
2072
2073         mcp->mb[0] = MBC_GET_RESOURCE_COUNTS;
2074         mcp->out_mb = MBX_0;
2075         mcp->in_mb = MBX_10|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
2076         mcp->tov = 30;
2077         mcp->flags = 0;
2078         rval = qla2x00_mailbox_command(ha, mcp);
2079
2080         if (rval != QLA_SUCCESS) {
2081                 /*EMPTY*/
2082                 DEBUG2_3_11(printk("%s(%ld): failed = %x.\n", __func__,
2083                     ha->host_no, mcp->mb[0]);)
2084         } else {
2085                 DEBUG11(printk("%s(%ld): done. mb1=%x mb2=%x mb3=%x mb6=%x "
2086                     "mb7=%x mb10=%x.\n", __func__, ha->host_no,
2087                     mcp->mb[1], mcp->mb[2], mcp->mb[3], mcp->mb[6], mcp->mb[7],
2088                     mcp->mb[10]));
2089
2090                 if (cur_xchg_cnt)
2091                         *cur_xchg_cnt = mcp->mb[3];
2092                 if (orig_xchg_cnt)
2093                         *orig_xchg_cnt = mcp->mb[6];
2094                 if (cur_iocb_cnt)
2095                         *cur_iocb_cnt = mcp->mb[7];
2096                 if (orig_iocb_cnt)
2097                         *orig_iocb_cnt = mcp->mb[10];
2098         }
2099
2100         return (rval);
2101 }
2102
2103 #if defined(QL_DEBUG_LEVEL_3)
2104 /*
2105  * qla2x00_get_fcal_position_map
2106  *      Get FCAL (LILP) position map using mailbox command
2107  *
2108  * Input:
2109  *      ha = adapter state pointer.
2110  *      pos_map = buffer pointer (can be NULL).
2111  *
2112  * Returns:
2113  *      qla2x00 local function return status code.
2114  *
2115  * Context:
2116  *      Kernel context.
2117  */
2118 int
2119 qla2x00_get_fcal_position_map(scsi_qla_host_t *ha, char *pos_map)
2120 {
2121         int rval;
2122         mbx_cmd_t mc;
2123         mbx_cmd_t *mcp = &mc;
2124         char *pmap;
2125         dma_addr_t pmap_dma;
2126
2127         pmap = dma_pool_alloc(ha->s_dma_pool, GFP_ATOMIC, &pmap_dma);
2128         if (pmap  == NULL) {
2129                 DEBUG2_3_11(printk("%s(%ld): **** Mem Alloc Failed ****",
2130                     __func__, ha->host_no));
2131                 return QLA_MEMORY_ALLOC_FAILED;
2132         }
2133         memset(pmap, 0, FCAL_MAP_SIZE);
2134
2135         mcp->mb[0] = MBC_GET_FC_AL_POSITION_MAP;
2136         mcp->mb[2] = MSW(pmap_dma);
2137         mcp->mb[3] = LSW(pmap_dma);
2138         mcp->mb[6] = MSW(MSD(pmap_dma));
2139         mcp->mb[7] = LSW(MSD(pmap_dma));
2140         mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_0;
2141         mcp->in_mb = MBX_1|MBX_0;
2142         mcp->buf_size = FCAL_MAP_SIZE;
2143         mcp->flags = MBX_DMA_IN;
2144         mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2);
2145         rval = qla2x00_mailbox_command(ha, mcp);
2146
2147         if (rval == QLA_SUCCESS) {
2148                 DEBUG11(printk("%s(%ld): (mb0=%x/mb1=%x) FC/AL Position Map "
2149                     "size (%x)\n", __func__, ha->host_no, mcp->mb[0],
2150                     mcp->mb[1], (unsigned)pmap[0]));
2151                 DEBUG11(qla2x00_dump_buffer(pmap, pmap[0] + 1));
2152
2153                 if (pos_map)
2154                         memcpy(pos_map, pmap, FCAL_MAP_SIZE);
2155         }
2156         dma_pool_free(ha->s_dma_pool, pmap, pmap_dma);
2157
2158         if (rval != QLA_SUCCESS) {
2159                 DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
2160                     ha->host_no, rval));
2161         } else {
2162                 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no));
2163         }
2164
2165         return rval;
2166 }
2167
2168 uint8_t
2169 qla24xx_get_isp_stats(scsi_qla_host_t *ha, uint32_t *dwbuf, uint32_t dwords,
2170     uint16_t *status)
2171 {
2172         int rval;
2173         mbx_cmd_t mc;
2174         mbx_cmd_t *mcp = &mc;
2175         uint32_t *sbuf, *siter;
2176         dma_addr_t sbuf_dma;
2177
2178         DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no);)
2179
2180         if (dwords > (DMA_POOL_SIZE / 4)) {
2181                 DEBUG2_3_11(printk("%s(%ld): Unabled to retrieve %d DWORDs "
2182                     "(max %d).\n", __func__, ha->host_no, dwords,
2183                     DMA_POOL_SIZE / 4));
2184                 return BIT_0;
2185         }
2186         sbuf = dma_pool_alloc(ha->s_dma_pool, GFP_ATOMIC, &sbuf_dma);
2187         if (sbuf == NULL) {
2188                 DEBUG2_3_11(printk("%s(%ld): Failed to allocate memory.\n",
2189                     __func__, ha->host_no));
2190                 return BIT_0;
2191         }
2192         memset(sbuf, 0, DMA_POOL_SIZE);
2193
2194         mcp->mb[0] = MBC_GET_LINK_PRIV_STATS;
2195         mcp->mb[2] = MSW(sbuf_dma);
2196         mcp->mb[3] = LSW(sbuf_dma);
2197         mcp->mb[6] = MSW(MSD(sbuf_dma));
2198         mcp->mb[7] = LSW(MSD(sbuf_dma));
2199         mcp->mb[8] = dwords;
2200         mcp->mb[10] = 0;
2201         mcp->out_mb = MBX_10|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_0;
2202         mcp->in_mb = MBX_2|MBX_1|MBX_0;
2203         mcp->tov = 30;
2204         mcp->flags = IOCTL_CMD;
2205         rval = qla2x00_mailbox_command(ha, mcp);
2206
2207         if (rval == QLA_SUCCESS) {
2208                 if (mcp->mb[0] != MBS_COMMAND_COMPLETE) {
2209                         DEBUG2_3_11(printk("%s(%ld): cmd failed. mbx0=%x.\n",
2210                             __func__, ha->host_no, mcp->mb[0]));
2211                         status[0] = mcp->mb[0];
2212                         rval = BIT_1;
2213                 } else {
2214                         /* Copy over data -- firmware data is LE. */
2215                         siter = sbuf;
2216                         while (dwords--)
2217                                 *dwbuf++ = le32_to_cpu(*siter++);
2218                 }
2219         } else {
2220                 /* Failed. */
2221                 DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
2222                     ha->host_no, rval));
2223                 rval = BIT_1;
2224         }
2225
2226         dma_pool_free(ha->s_dma_pool, sbuf, sbuf_dma);
2227
2228         return rval;
2229 }
2230 #endif
2231
2232 int
2233 qla24xx_abort_command(scsi_qla_host_t *ha, srb_t *sp)
2234 {
2235         int             rval;
2236         fc_port_t       *fcport;
2237         unsigned long   flags = 0;
2238
2239         struct abort_entry_24xx *abt;
2240         dma_addr_t      abt_dma;
2241         uint32_t        handle;
2242
2243         DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no);)
2244
2245         fcport = sp->fcport;
2246         if (atomic_read(&ha->loop_state) == LOOP_DOWN ||
2247             atomic_read(&fcport->state) == FCS_DEVICE_LOST) {
2248                 return QLA_FUNCTION_FAILED;
2249         }
2250
2251         spin_lock_irqsave(&ha->hardware_lock, flags);
2252         for (handle = 1; handle < MAX_OUTSTANDING_COMMANDS; handle++) {
2253                 if (ha->outstanding_cmds[handle] == sp)
2254                         break;
2255         }
2256         spin_unlock_irqrestore(&ha->hardware_lock, flags);
2257         if (handle == MAX_OUTSTANDING_COMMANDS) {
2258                 /* Command not found. */
2259                 return QLA_FUNCTION_FAILED;
2260         }
2261
2262         abt = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &abt_dma);
2263         if (abt == NULL) {
2264                 DEBUG2_3(printk("%s(%ld): failed to allocate Abort IOCB.\n",
2265                     __func__, ha->host_no));
2266                 return QLA_MEMORY_ALLOC_FAILED;
2267         }
2268         memset(abt, 0, sizeof(struct abort_entry_24xx));
2269
2270         abt->entry_type = ABORT_IOCB_TYPE;
2271         abt->entry_count = 1;
2272         abt->nport_handle = cpu_to_le16(fcport->loop_id);
2273         abt->handle_to_abort = handle;
2274         abt->port_id[0] = fcport->d_id.b.al_pa;
2275         abt->port_id[1] = fcport->d_id.b.area;
2276         abt->port_id[2] = fcport->d_id.b.domain;
2277         rval = qla2x00_issue_iocb(ha, abt, abt_dma, 0);
2278         if (rval != QLA_SUCCESS) {
2279                 DEBUG2_3_11(printk("%s(%ld): failed to issue IOCB (%x).\n",
2280                     __func__, ha->host_no, rval);)
2281         } else if (abt->entry_status != 0) {
2282                 DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
2283                     "-- error status (%x).\n", __func__, ha->host_no,
2284                     abt->entry_status));
2285                 rval = QLA_FUNCTION_FAILED;
2286         } else if (abt->nport_handle != __constant_cpu_to_le16(0)) {
2287                 DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
2288                     "-- completion status (%x).\n", __func__, ha->host_no,
2289                     le16_to_cpu(abt->nport_handle));)
2290                 rval = QLA_FUNCTION_FAILED;
2291         } else {
2292                 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no);)
2293                 sp->flags |= SRB_ABORT_PENDING;
2294         }
2295
2296         dma_pool_free(ha->s_dma_pool, abt, abt_dma);
2297
2298         return rval;
2299 }
2300
2301 struct tsk_mgmt_cmd {
2302         union {
2303                 struct tsk_mgmt_entry tsk;
2304                 struct sts_entry_24xx sts;
2305         } p;
2306 };
2307
2308 int
2309 qla24xx_abort_target(fc_port_t *fcport)
2310 {
2311         int             rval;
2312         struct tsk_mgmt_cmd *tsk;
2313         dma_addr_t      tsk_dma;
2314         scsi_qla_host_t *ha;
2315
2316         if (fcport == NULL)
2317                 return 0;
2318
2319         DEBUG11(printk("%s(%ld): entered.\n", __func__, fcport->ha->host_no);)
2320
2321         ha = fcport->ha;
2322         tsk = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &tsk_dma);
2323         if (tsk == NULL) {
2324                 DEBUG2_3(printk("%s(%ld): failed to allocate Task Management "
2325                     "IOCB.\n", __func__, ha->host_no));
2326                 return QLA_MEMORY_ALLOC_FAILED;
2327         }
2328         memset(tsk, 0, sizeof(struct tsk_mgmt_cmd));
2329
2330         tsk->p.tsk.entry_type = TSK_MGMT_IOCB_TYPE;
2331         tsk->p.tsk.entry_count = 1;
2332         tsk->p.tsk.nport_handle = cpu_to_le16(fcport->loop_id);
2333         tsk->p.tsk.timeout = __constant_cpu_to_le16(25);
2334         tsk->p.tsk.control_flags = __constant_cpu_to_le32(TCF_TARGET_RESET);
2335         tsk->p.tsk.port_id[0] = fcport->d_id.b.al_pa;
2336         tsk->p.tsk.port_id[1] = fcport->d_id.b.area;
2337         tsk->p.tsk.port_id[2] = fcport->d_id.b.domain;
2338         rval = qla2x00_issue_iocb(ha, tsk, tsk_dma, 0);
2339         if (rval != QLA_SUCCESS) {
2340                 DEBUG2_3_11(printk("%s(%ld): failed to issue Target Reset IOCB "
2341                     "(%x).\n", __func__, ha->host_no, rval);)
2342                 goto atarget_done;
2343         } else if (tsk->p.sts.entry_status != 0) {
2344                 DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
2345                     "-- error status (%x).\n", __func__, ha->host_no,
2346                     tsk->p.sts.entry_status));
2347                 rval = QLA_FUNCTION_FAILED;
2348                 goto atarget_done;
2349         } else if (tsk->p.sts.comp_status !=
2350             __constant_cpu_to_le16(CS_COMPLETE)) {
2351                 DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
2352                     "-- completion status (%x).\n", __func__,
2353                     ha->host_no, le16_to_cpu(tsk->p.sts.comp_status));)
2354                 rval = QLA_FUNCTION_FAILED;
2355                 goto atarget_done;
2356         }
2357
2358         /* Issue marker IOCB. */
2359         rval = qla2x00_marker(ha, fcport->loop_id, 0, MK_SYNC_ID);
2360         if (rval != QLA_SUCCESS) {
2361                 DEBUG2_3_11(printk("%s(%ld): failed to issue Marker IOCB "
2362                     "(%x).\n", __func__, ha->host_no, rval);)
2363         } else {
2364                 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no);)
2365         }
2366
2367 atarget_done:
2368         dma_pool_free(ha->s_dma_pool, tsk, tsk_dma);
2369
2370         return rval;
2371 }
2372
2373 int
2374 qla2x00_system_error(scsi_qla_host_t *ha)
2375 {
2376         int rval;
2377         mbx_cmd_t mc;
2378         mbx_cmd_t *mcp = &mc;
2379
2380         if (!IS_QLA24XX(ha) && !IS_QLA25XX(ha))
2381                 return QLA_FUNCTION_FAILED;
2382
2383         DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no));
2384
2385         mcp->mb[0] = MBC_GEN_SYSTEM_ERROR;
2386         mcp->out_mb = MBX_0;
2387         mcp->in_mb = MBX_0;
2388         mcp->tov = 5;
2389         mcp->flags = 0;
2390         rval = qla2x00_mailbox_command(ha, mcp);
2391
2392         if (rval != QLA_SUCCESS) {
2393                 DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
2394                     ha->host_no, rval));
2395         } else {
2396                 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no));
2397         }
2398
2399         return rval;
2400 }
2401
2402 /**
2403  * qla2x00_get_serdes_params() -
2404  * @ha: HA context
2405  *
2406  * Returns
2407  */
2408 int
2409 qla2x00_get_serdes_params(scsi_qla_host_t *ha, uint16_t *sw_em_1g,
2410     uint16_t *sw_em_2g, uint16_t *sw_em_4g)
2411 {
2412         int rval;
2413         mbx_cmd_t mc;
2414         mbx_cmd_t *mcp = &mc;
2415
2416         DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no));
2417
2418         mcp->mb[0] = MBC_SERDES_PARAMS;
2419         mcp->mb[1] = 0;
2420         mcp->out_mb = MBX_1|MBX_0;
2421         mcp->in_mb = MBX_4|MBX_3|MBX_2|MBX_0;
2422         mcp->tov = 30;
2423         mcp->flags = 0;
2424         rval = qla2x00_mailbox_command(ha, mcp);
2425
2426         if (rval != QLA_SUCCESS) {
2427                 /*EMPTY*/
2428                 DEBUG2_3_11(printk("%s(%ld): failed=%x (%x).\n", __func__,
2429                     ha->host_no, rval, mcp->mb[0]));
2430         } else {
2431                 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no));
2432
2433                 if (sw_em_1g)
2434                         *sw_em_1g = mcp->mb[2];
2435                 if (sw_em_2g)
2436                         *sw_em_2g = mcp->mb[3];
2437                 if (sw_em_4g)
2438                         *sw_em_4g = mcp->mb[4];
2439         }
2440
2441         return rval;
2442 }
2443
2444 /**
2445  * qla2x00_set_serdes_params() -
2446  * @ha: HA context
2447  *
2448  * Returns
2449  */
2450 int
2451 qla2x00_set_serdes_params(scsi_qla_host_t *ha, uint16_t sw_em_1g,
2452     uint16_t sw_em_2g, uint16_t sw_em_4g)
2453 {
2454         int rval;
2455         mbx_cmd_t mc;
2456         mbx_cmd_t *mcp = &mc;
2457
2458         DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no));
2459
2460         mcp->mb[0] = MBC_SERDES_PARAMS;
2461         mcp->mb[1] = BIT_0;
2462         mcp->mb[2] = sw_em_1g;
2463         mcp->mb[3] = sw_em_2g;
2464         mcp->mb[4] = sw_em_4g;
2465         mcp->out_mb = MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
2466         mcp->in_mb = MBX_0;
2467         mcp->tov = 30;
2468         mcp->flags = 0;
2469         rval = qla2x00_mailbox_command(ha, mcp);
2470
2471         if (rval != QLA_SUCCESS) {
2472                 /*EMPTY*/
2473                 DEBUG2_3_11(printk("%s(%ld): failed=%x (%x).\n", __func__,
2474                     ha->host_no, rval, mcp->mb[0]));
2475         } else {
2476                 /*EMPTY*/
2477                 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no));
2478         }
2479
2480         return rval;
2481 }