drivers/scsi/qla2xxx/qla_mbx.c

   1 /*
   2  * QLogic Fibre Channel HBA Driver
   3  * Copyright (c)  2003-2008 QLogic Corporation
   4  *
   5  * See LICENSE.qla2xxx for copyright and licensing details.
   6  */
   7 #include "qla_def.h"
   8
   9 #include <linux/delay.h>
  10 #include <linux/gfp.h>
  11
  12
  13 /*
  14  * qla2x00_mailbox_command
  15  *      Issue mailbox command and waits for completion.
  16  *
  17  * Input:
  18  *      ha = adapter block pointer.
  19  *      mcp = driver internal mbx struct pointer.
  20  *
  21  * Output:
  22  *      mb[MAX_MAILBOX_REGISTER_COUNT] = returned mailbox data.
  23  *
  24  * Returns:
  25  *      0 : QLA_SUCCESS = cmd performed success
  26  *      1 : QLA_FUNCTION_FAILED   (error encountered)
  27  *      6 : QLA_FUNCTION_TIMEOUT (timeout condition encountered)
  28  *
  29  * Context:
  30  *      Kernel context.
  31  */
  32 static int
  33 qla2x00_mailbox_command(scsi_qla_host_t *vha, mbx_cmd_t *mcp)
  34 {
  35         int             rval;
  36         unsigned long    flags = 0;
  37         device_reg_t __iomem *reg;
  38         uint8_t         abort_active;
  39         uint8_t         io_lock_on;
  40         uint16_t        command;
  41         uint16_t        *iptr;
  42         uint16_t __iomem *optr;
  43         uint32_t        cnt;
  44         uint32_t        mboxes;
  45         unsigned long   wait_time;
  46         struct qla_hw_data *ha = vha->hw;
  47         scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev);
  48
  49         if (ha->pdev->error_state > pci_channel_io_frozen)
  50                 return QLA_FUNCTION_TIMEOUT;
  51
  52         if (vha->device_flags & DFLG_DEV_FAILED) {
  53                 DEBUG2_3_11(qla_printk(KERN_WARNING, ha,
  54                         "%s(%ld): Device in failed state, "
  55                         "timeout MBX Exiting.\n",
  56                         __func__, base_vha->host_no));
  57                 return QLA_FUNCTION_TIMEOUT;
  58         }
  59
  60         reg = ha->iobase;
  61         io_lock_on = base_vha->flags.init_done;
  62
  63         rval = QLA_SUCCESS;
  64         abort_active = test_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags);
  65
  66         DEBUG11(printk("%s(%ld): entered.\n", __func__, base_vha->host_no));
  67
  68         if (ha->flags.pci_channel_io_perm_failure) {
  69                 DEBUG(printk("%s(%ld): Perm failure on EEH, timeout MBX "
  70                              "Exiting.\n", __func__, vha->host_no));
  71                 return QLA_FUNCTION_TIMEOUT;
  72         }
  73
  74         /*
  75          * Wait for active mailbox commands to finish by waiting at most tov
  76          * seconds. This is to serialize actual issuing of mailbox cmds during
  77          * non ISP abort time.
  78          */
  79         if (!wait_for_completion_timeout(&ha->mbx_cmd_comp, mcp->tov * HZ)) {
  80                 /* Timeout occurred. Return error. */
  81                 DEBUG2_3_11(printk("%s(%ld): cmd access timeout. "
  82                     "Exiting.\n", __func__, base_vha->host_no));
  83                 return QLA_FUNCTION_TIMEOUT;
  84         }
  85
  86         ha->flags.mbox_busy = 1;
  87         /* Save mailbox command for debug */
  88         ha->mcp = mcp;
  89
  90         DEBUG11(printk("scsi(%ld): prepare to issue mbox cmd=0x%x.\n",
  91             base_vha->host_no, mcp->mb[0]));
  92
  93         spin_lock_irqsave(&ha->hardware_lock, flags);
  94
  95         /* Load mailbox registers. */
  96         if (IS_QLA82XX(ha))
  97                 optr = (uint16_t __iomem *)&reg->isp82.mailbox_in[0];
  98         else if (IS_FWI2_CAPABLE(ha) && !IS_QLA82XX(ha))
  99                 optr = (uint16_t __iomem *)&reg->isp24.mailbox0;
 100         else
 101                 optr = (uint16_t __iomem *)MAILBOX_REG(ha, &reg->isp, 0);
 102
 103         iptr = mcp->mb;
 104         command = mcp->mb[0];
 105         mboxes = mcp->out_mb;
 106
 107         for (cnt = 0; cnt < ha->mbx_count; cnt++) {
 108                 if (IS_QLA2200(ha) && cnt == 8)
 109                         optr =
 110                             (uint16_t __iomem *)MAILBOX_REG(ha, &reg->isp, 8);
 111                 if (mboxes & BIT_0)
 112                         WRT_REG_WORD(optr, *iptr);
 113
 114                 mboxes >>= 1;
 115                 optr++;
 116                 iptr++;
 117         }
 118
 119 #if defined(QL_DEBUG_LEVEL_1)
 120         printk("%s(%ld): Loaded MBX registers (displayed in bytes) = \n",
 121             __func__, base_vha->host_no);
 122         qla2x00_dump_buffer((uint8_t *)mcp->mb, 16);
 123         printk("\n");
 124         qla2x00_dump_buffer(((uint8_t *)mcp->mb + 0x10), 16);
 125         printk("\n");
 126         qla2x00_dump_buffer(((uint8_t *)mcp->mb + 0x20), 8);
 127         printk("\n");
 128         printk("%s(%ld): I/O address = %p.\n", __func__, base_vha->host_no,
 129                 optr);
 130         qla2x00_dump_regs(base_vha);
 131 #endif
 132
 133         /* Issue set host interrupt command to send cmd out. */
 134         ha->flags.mbox_int = 0;
 135         clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
 136
 137         /* Unlock mbx registers and wait for interrupt */
 138         DEBUG11(printk("%s(%ld): going to unlock irq & waiting for interrupt. "
 139             "jiffies=%lx.\n", __func__, base_vha->host_no, jiffies));
 140
 141         /* Wait for mbx cmd completion until timeout */
 142
 143         if ((!abort_active && io_lock_on) || IS_NOPOLLING_TYPE(ha)) {
 144                 set_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags);
 145
 146                 if (IS_QLA82XX(ha)) {
 147                         if (RD_REG_DWORD(&reg->isp82.hint) &
 148                                 HINT_MBX_INT_PENDING) {
 149                                 spin_unlock_irqrestore(&ha->hardware_lock,
 150                                         flags);
 151                                 DEBUG2_3_11(printk(KERN_INFO
 152                                     "%s(%ld): Pending Mailbox timeout. "
 153                                     "Exiting.\n", __func__, base_vha->host_no));
 154                                 return QLA_FUNCTION_TIMEOUT;
 155                         }
 156                         WRT_REG_DWORD(&reg->isp82.hint, HINT_MBX_INT_PENDING);
 157                 } else if (IS_FWI2_CAPABLE(ha))
 158                         WRT_REG_DWORD(&reg->isp24.hccr, HCCRX_SET_HOST_INT);
 159                 else
 160                         WRT_REG_WORD(&reg->isp.hccr, HCCR_SET_HOST_INT);
 161                 spin_unlock_irqrestore(&ha->hardware_lock, flags);
 162
 163                 wait_for_completion_timeout(&ha->mbx_intr_comp, mcp->tov * HZ);
 164
 165                 clear_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags);
 166
 167         } else {
 168                 DEBUG3_11(printk("%s(%ld): cmd=%x POLLING MODE.\n", __func__,
 169                     base_vha->host_no, command));
 170
 171                 if (IS_QLA82XX(ha)) {
 172                         if (RD_REG_DWORD(&reg->isp82.hint) &
 173                                 HINT_MBX_INT_PENDING) {
 174                                 spin_unlock_irqrestore(&ha->hardware_lock,
 175                                         flags);
 176                                 DEBUG2_3_11(printk(KERN_INFO
 177                                     "%s(%ld): Pending Mailbox timeout. "
 178                                     "Exiting.\n", __func__, base_vha->host_no));
 179                                 return QLA_FUNCTION_TIMEOUT;
 180                         }
 181                         WRT_REG_DWORD(&reg->isp82.hint, HINT_MBX_INT_PENDING);
 182                 } else if (IS_FWI2_CAPABLE(ha))
 183                         WRT_REG_DWORD(&reg->isp24.hccr, HCCRX_SET_HOST_INT);
 184                 else
 185                         WRT_REG_WORD(&reg->isp.hccr, HCCR_SET_HOST_INT);
 186                 spin_unlock_irqrestore(&ha->hardware_lock, flags);
 187
 188                 wait_time = jiffies + mcp->tov * HZ; /* wait at most tov secs */
 189                 while (!ha->flags.mbox_int) {
 190                         if (time_after(jiffies, wait_time))
 191                                 break;
 192
 193                         /* Check for pending interrupts. */
 194                         qla2x00_poll(ha->rsp_q_map[0]);
 195
 196                         if (!ha->flags.mbox_int &&
 197                             !(IS_QLA2200(ha) &&
 198                             command == MBC_LOAD_RISC_RAM_EXTENDED))
 199                                 msleep(10);
 200                 } /* while */
 201                 DEBUG17(qla_printk(KERN_WARNING, ha,
 202                         "Waited %d sec\n",
 203                         (uint)((jiffies - (wait_time - (mcp->tov * HZ)))/HZ)));
 204         }
 205
 206         /* Check whether we timed out */
 207         if (ha->flags.mbox_int) {
 208                 uint16_t *iptr2;
 209
 210                 DEBUG3_11(printk("%s(%ld): cmd %x completed.\n", __func__,
 211                     base_vha->host_no, command));
 212
 213                 /* Got interrupt. Clear the flag. */
 214                 ha->flags.mbox_int = 0;
 215                 clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
 216
 217                 if (ha->mailbox_out[0] != MBS_COMMAND_COMPLETE)
 218                         rval = QLA_FUNCTION_FAILED;
 219
 220                 /* Load return mailbox registers. */
 221                 iptr2 = mcp->mb;
 222                 iptr = (uint16_t *)&ha->mailbox_out[0];
 223                 mboxes = mcp->in_mb;
 224                 for (cnt = 0; cnt < ha->mbx_count; cnt++) {
 225                         if (mboxes & BIT_0)
 226                                 *iptr2 = *iptr;
 227
 228                         mboxes >>= 1;
 229                         iptr2++;
 230                         iptr++;
 231                 }
 232         } else {
 233
 234 #if defined(QL_DEBUG_LEVEL_2) || defined(QL_DEBUG_LEVEL_3) || \
 235                 defined(QL_DEBUG_LEVEL_11)
 236                 uint16_t mb0;
 237                 uint32_t ictrl;
 238
 239                 if (IS_FWI2_CAPABLE(ha)) {
 240                         mb0 = RD_REG_WORD(&reg->isp24.mailbox0);
 241                         ictrl = RD_REG_DWORD(&reg->isp24.ictrl);
 242                 } else {
 243                         mb0 = RD_MAILBOX_REG(ha, &reg->isp, 0);
 244                         ictrl = RD_REG_WORD(&reg->isp.ictrl);
 245                 }
 246                 printk("%s(%ld): **** MB Command Timeout for cmd %x ****\n",
 247                     __func__, base_vha->host_no, command);
 248                 printk("%s(%ld): icontrol=%x jiffies=%lx\n", __func__,
 249                     base_vha->host_no, ictrl, jiffies);
 250                 printk("%s(%ld): *** mailbox[0] = 0x%x ***\n", __func__,
 251                     base_vha->host_no, mb0);
 252                 qla2x00_dump_regs(base_vha);
 253 #endif
 254
 255                 rval = QLA_FUNCTION_TIMEOUT;
 256         }
 257
 258         ha->flags.mbox_busy = 0;
 259
 260         /* Clean up */
 261         ha->mcp = NULL;
 262
 263         if ((abort_active || !io_lock_on) && !IS_NOPOLLING_TYPE(ha)) {
 264                 DEBUG11(printk("%s(%ld): checking for additional resp "
 265                     "interrupt.\n", __func__, base_vha->host_no));
 266
 267                 /* polling mode for non isp_abort commands. */
 268                 qla2x00_poll(ha->rsp_q_map[0]);
 269         }
 270
 271         if (rval == QLA_FUNCTION_TIMEOUT &&
 272             mcp->mb[0] != MBC_GEN_SYSTEM_ERROR) {
 273                 if (!io_lock_on || (mcp->flags & IOCTL_CMD) ||
 274                     ha->flags.eeh_busy) {
 275                         /* not in dpc. schedule it for dpc to take over. */
 276                         DEBUG(printk("%s(%ld): timeout schedule "
 277                         "isp_abort_needed.\n", __func__,
 278                         base_vha->host_no));
 279                         DEBUG2_3_11(printk("%s(%ld): timeout schedule "
 280                         "isp_abort_needed.\n", __func__,
 281                         base_vha->host_no));
 282                         qla_printk(KERN_WARNING, ha,
 283                             "Mailbox command timeout occurred. Scheduling ISP "
 284                             "abort. eeh_busy: 0x%x\n", ha->flags.eeh_busy);
 285                         set_bit(ISP_ABORT_NEEDED, &base_vha->dpc_flags);
 286                         qla2xxx_wake_dpc(vha);
 287                 } else if (!abort_active) {
 288                         /* call abort directly since we are in the DPC thread */
 289                         DEBUG(printk("%s(%ld): timeout calling abort_isp\n",
 290                             __func__, base_vha->host_no));
 291                         DEBUG2_3_11(printk("%s(%ld): timeout calling "
 292                             "abort_isp\n", __func__, base_vha->host_no));
 293                         qla_printk(KERN_WARNING, ha,
 294                             "Mailbox command timeout occurred. Issuing ISP "
 295                             "abort.\n");
 296
 297                         set_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags);
 298                         clear_bit(ISP_ABORT_NEEDED, &base_vha->dpc_flags);
 299                         if (ha->isp_ops->abort_isp(base_vha)) {
 300                                 /* Failed. retry later. */
 301                                 set_bit(ISP_ABORT_NEEDED, &base_vha->dpc_flags);
 302                         }
 303                         clear_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags);
 304                         DEBUG(printk("%s(%ld): finished abort_isp\n", __func__,
 305                             base_vha->host_no));
 306                         DEBUG2_3_11(printk("%s(%ld): finished abort_isp\n",
 307                             __func__, base_vha->host_no));
 308                 }
 309         }
 310
 311         /* Allow next mbx cmd to come in. */
 312         complete(&ha->mbx_cmd_comp);
 313
 314         if (rval) {
 315                 DEBUG2_3_11(printk("%s(%ld): **** FAILED. mbx0=%x, mbx1=%x, "
 316                     "mbx2=%x, cmd=%x ****\n", __func__, base_vha->host_no,
 317                     mcp->mb[0], mcp->mb[1], mcp->mb[2], command));
 318         } else {
 319                 DEBUG11(printk("%s(%ld): done.\n", __func__,
 320                 base_vha->host_no));
 321         }
 322
 323         return rval;
 324 }
 325
 326 int
 327 qla2x00_load_ram(scsi_qla_host_t *vha, dma_addr_t req_dma, uint32_t risc_addr,
 328     uint32_t risc_code_size)
 329 {
 330         int rval;
 331         struct qla_hw_data *ha = vha->hw;
 332         mbx_cmd_t mc;
 333         mbx_cmd_t *mcp = &mc;
 334
 335         DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
 336
 337         if (MSW(risc_addr) || IS_FWI2_CAPABLE(ha)) {
 338                 mcp->mb[0] = MBC_LOAD_RISC_RAM_EXTENDED;
 339                 mcp->mb[8] = MSW(risc_addr);
 340                 mcp->out_mb = MBX_8|MBX_0;
 341         } else {
 342                 mcp->mb[0] = MBC_LOAD_RISC_RAM;
 343                 mcp->out_mb = MBX_0;
 344         }
 345         mcp->mb[1] = LSW(risc_addr);
 346         mcp->mb[2] = MSW(req_dma);
 347         mcp->mb[3] = LSW(req_dma);
 348         mcp->mb[6] = MSW(MSD(req_dma));
 349         mcp->mb[7] = LSW(MSD(req_dma));
 350         mcp->out_mb |= MBX_7|MBX_6|MBX_3|MBX_2|MBX_1;
 351         if (IS_FWI2_CAPABLE(ha)) {
 352                 mcp->mb[4] = MSW(risc_code_size);
 353                 mcp->mb[5] = LSW(risc_code_size);
 354                 mcp->out_mb |= MBX_5|MBX_4;
 355         } else {
 356                 mcp->mb[4] = LSW(risc_code_size);
 357                 mcp->out_mb |= MBX_4;
 358         }
 359
 360         mcp->in_mb = MBX_0;
 361         mcp->tov = MBX_TOV_SECONDS;
 362         mcp->flags = 0;
 363         rval = qla2x00_mailbox_command(vha, mcp);
 364
 365         if (rval != QLA_SUCCESS) {
 366                 DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x.\n", __func__,
 367                     vha->host_no, rval, mcp->mb[0]));
 368         } else {
 369                 DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
 370         }
 371
 372         return rval;
 373 }
 374
 375 #define EXTENDED_BB_CREDITS     BIT_0
 376 /*
 377  * qla2x00_execute_fw
 378  *     Start adapter firmware.
 379  *
 380  * Input:
 381  *     ha = adapter block pointer.
 382  *     TARGET_QUEUE_LOCK must be released.
 383  *     ADAPTER_STATE_LOCK must be released.
 384  *
 385  * Returns:
 386  *     qla2x00 local function return status code.
 387  *
 388  * Context:
 389  *     Kernel context.
 390  */
 391 int
 392 qla2x00_execute_fw(scsi_qla_host_t *vha, uint32_t risc_addr)
 393 {
 394         int rval;
 395         struct qla_hw_data *ha = vha->hw;
 396         mbx_cmd_t mc;
 397         mbx_cmd_t *mcp = &mc;
 398
 399         DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
 400
 401         mcp->mb[0] = MBC_EXECUTE_FIRMWARE;
 402         mcp->out_mb = MBX_0;
 403         mcp->in_mb = MBX_0;
 404         if (IS_FWI2_CAPABLE(ha)) {
 405                 mcp->mb[1] = MSW(risc_addr);
 406                 mcp->mb[2] = LSW(risc_addr);
 407                 mcp->mb[3] = 0;
 408                 if (IS_QLA81XX(ha)) {
 409                         struct nvram_81xx *nv = ha->nvram;
 410                         mcp->mb[4] = (nv->enhanced_features &
 411                             EXTENDED_BB_CREDITS);
 412                 } else
 413                         mcp->mb[4] = 0;
 414                 mcp->out_mb |= MBX_4|MBX_3|MBX_2|MBX_1;
 415                 mcp->in_mb |= MBX_1;
 416         } else {
 417                 mcp->mb[1] = LSW(risc_addr);
 418                 mcp->out_mb |= MBX_1;
 419                 if (IS_QLA2322(ha) || IS_QLA6322(ha)) {
 420                         mcp->mb[2] = 0;
 421                         mcp->out_mb |= MBX_2;
 422                 }
 423         }
 424
 425         mcp->tov = MBX_TOV_SECONDS;
 426         mcp->flags = 0;
 427         rval = qla2x00_mailbox_command(vha, mcp);
 428
 429         if (rval != QLA_SUCCESS) {
 430                 DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x.\n", __func__,
 431                     vha->host_no, rval, mcp->mb[0]));
 432         } else {
 433                 if (IS_FWI2_CAPABLE(ha)) {
 434                         DEBUG11(printk("%s(%ld): done exchanges=%x.\n",
 435                             __func__, vha->host_no, mcp->mb[1]));
 436                 } else {
 437                         DEBUG11(printk("%s(%ld): done.\n", __func__,
 438                             vha->host_no));
 439                 }
 440         }
 441
 442         return rval;
 443 }
 444
 445 /*
 446  * qla2x00_get_fw_version
 447  *      Get firmware version.
 448  *
 449  * Input:
 450  *      ha:             adapter state pointer.
 451  *      major:          pointer for major number.
 452  *      minor:          pointer for minor number.
 453  *      subminor:       pointer for subminor number.
 454  *
 455  * Returns:
 456  *      qla2x00 local function return status code.
 457  *
 458  * Context:
 459  *      Kernel context.
 460  */
 461 int
 462 qla2x00_get_fw_version(scsi_qla_host_t *vha, uint16_t *major, uint16_t *minor,
 463     uint16_t *subminor, uint16_t *attributes, uint32_t *memory, uint8_t *mpi,
 464     uint32_t *mpi_caps, uint8_t *phy)
 465 {
 466         int             rval;
 467         mbx_cmd_t       mc;
 468         mbx_cmd_t       *mcp = &mc;
 469
 470         DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
 471
 472         mcp->mb[0] = MBC_GET_FIRMWARE_VERSION;
 473         mcp->out_mb = MBX_0;
 474         mcp->in_mb = MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
 475         if (IS_QLA81XX(vha->hw))
 476                 mcp->in_mb |= MBX_13|MBX_12|MBX_11|MBX_10|MBX_9|MBX_8;
 477         mcp->flags = 0;
 478         mcp->tov = MBX_TOV_SECONDS;
 479         rval = qla2x00_mailbox_command(vha, mcp);
 480         if (rval != QLA_SUCCESS)
 481                 goto failed;
 482
 483         /* Return mailbox data. */
 484         *major = mcp->mb[1];
 485         *minor = mcp->mb[2];
 486         *subminor = mcp->mb[3];
 487         *attributes = mcp->mb[6];
 488         if (IS_QLA2100(vha->hw) || IS_QLA2200(vha->hw))
 489                 *memory = 0x1FFFF;                      /* Defaults to 128KB. */
 490         else
 491                 *memory = (mcp->mb[5] << 16) | mcp->mb[4];
 492         if (IS_QLA81XX(vha->hw)) {
 493                 mpi[0] = mcp->mb[10] & 0xff;
 494                 mpi[1] = mcp->mb[11] >> 8;
 495                 mpi[2] = mcp->mb[11] & 0xff;
 496                 *mpi_caps = (mcp->mb[12] << 16) | mcp->mb[13];
 497                 phy[0] = mcp->mb[8] & 0xff;
 498                 phy[1] = mcp->mb[9] >> 8;
 499                 phy[2] = mcp->mb[9] & 0xff;
 500         }
 501 failed:
 502         if (rval != QLA_SUCCESS) {
 503                 /*EMPTY*/
 504                 DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
 505                     vha->host_no, rval));
 506         } else {
 507                 /*EMPTY*/
 508                 DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
 509         }
 510         return rval;
 511 }
 512
 513 /*
 514  * qla2x00_get_fw_options
 515  *      Set firmware options.
 516  *
 517  * Input:
 518  *      ha = adapter block pointer.
 519  *      fwopt = pointer for firmware options.
 520  *
 521  * Returns:
 522  *      qla2x00 local function return status code.
 523  *
 524  * Context:
 525  *      Kernel context.
 526  */
 527 int
 528 qla2x00_get_fw_options(scsi_qla_host_t *vha, uint16_t *fwopts)
 529 {
 530         int rval;
 531         mbx_cmd_t mc;
 532         mbx_cmd_t *mcp = &mc;
 533
 534         DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
 535
 536         mcp->mb[0] = MBC_GET_FIRMWARE_OPTION;
 537         mcp->out_mb = MBX_0;
 538         mcp->in_mb = MBX_3|MBX_2|MBX_1|MBX_0;
 539         mcp->tov = MBX_TOV_SECONDS;
 540         mcp->flags = 0;
 541         rval = qla2x00_mailbox_command(vha, mcp);
 542
 543         if (rval != QLA_SUCCESS) {
 544                 /*EMPTY*/
 545                 DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
 546                     vha->host_no, rval));
 547         } else {
 548                 fwopts[0] = mcp->mb[0];
 549                 fwopts[1] = mcp->mb[1];
 550                 fwopts[2] = mcp->mb[2];
 551                 fwopts[3] = mcp->mb[3];
 552
 553                 DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
 554         }
 555
 556         return rval;
 557 }
 558
 559
 560 /*
 561  * qla2x00_set_fw_options
 562  *      Set firmware options.
 563  *
 564  * Input:
 565  *      ha = adapter block pointer.
 566  *      fwopt = pointer for firmware options.
 567  *
 568  * Returns:
 569  *      qla2x00 local function return status code.
 570  *
 571  * Context:
 572  *      Kernel context.
 573  */
 574 int
 575 qla2x00_set_fw_options(scsi_qla_host_t *vha, uint16_t *fwopts)
 576 {
 577         int rval;
 578         mbx_cmd_t mc;
 579         mbx_cmd_t *mcp = &mc;
 580
 581         DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
 582
 583         mcp->mb[0] = MBC_SET_FIRMWARE_OPTION;
 584         mcp->mb[1] = fwopts[1];
 585         mcp->mb[2] = fwopts[2];
 586         mcp->mb[3] = fwopts[3];
 587         mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
 588         mcp->in_mb = MBX_0;
 589         if (IS_FWI2_CAPABLE(vha->hw)) {
 590                 mcp->in_mb |= MBX_1;
 591         } else {
 592                 mcp->mb[10] = fwopts[10];
 593                 mcp->mb[11] = fwopts[11];
 594                 mcp->mb[12] = 0;        /* Undocumented, but used */
 595                 mcp->out_mb |= MBX_12|MBX_11|MBX_10;
 596         }
 597         mcp->tov = MBX_TOV_SECONDS;
 598         mcp->flags = 0;
 599         rval = qla2x00_mailbox_command(vha, mcp);
 600
 601         fwopts[0] = mcp->mb[0];
 602
 603         if (rval != QLA_SUCCESS) {
 604                 /*EMPTY*/
 605                 DEBUG2_3_11(printk("%s(%ld): failed=%x (%x/%x).\n", __func__,
 606                     vha->host_no, rval, mcp->mb[0], mcp->mb[1]));
 607         } else {
 608                 /*EMPTY*/
 609                 DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
 610         }
 611
 612         return rval;
 613 }
 614
 615 /*
 616  * qla2x00_mbx_reg_test
 617  *      Mailbox register wrap test.
 618  *
 619  * Input:
 620  *      ha = adapter block pointer.
 621  *      TARGET_QUEUE_LOCK must be released.
 622  *      ADAPTER_STATE_LOCK must be released.
 623  *
 624  * Returns:
 625  *      qla2x00 local function return status code.
 626  *
 627  * Context:
 628  *      Kernel context.
 629  */
 630 int
 631 qla2x00_mbx_reg_test(scsi_qla_host_t *vha)
 632 {
 633         int rval;
 634         mbx_cmd_t mc;
 635         mbx_cmd_t *mcp = &mc;
 636
 637         DEBUG11(printk("qla2x00_mbx_reg_test(%ld): entered.\n", vha->host_no));
 638
 639         mcp->mb[0] = MBC_MAILBOX_REGISTER_TEST;
 640         mcp->mb[1] = 0xAAAA;
 641         mcp->mb[2] = 0x5555;
 642         mcp->mb[3] = 0xAA55;
 643         mcp->mb[4] = 0x55AA;
 644         mcp->mb[5] = 0xA5A5;
 645         mcp->mb[6] = 0x5A5A;
 646         mcp->mb[7] = 0x2525;
 647         mcp->out_mb = MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
 648         mcp->in_mb = MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
 649         mcp->tov = MBX_TOV_SECONDS;
 650         mcp->flags = 0;
 651         rval = qla2x00_mailbox_command(vha, mcp);
 652
 653         if (rval == QLA_SUCCESS) {
 654                 if (mcp->mb[1] != 0xAAAA || mcp->mb[2] != 0x5555 ||
 655                     mcp->mb[3] != 0xAA55 || mcp->mb[4] != 0x55AA)
 656                         rval = QLA_FUNCTION_FAILED;
 657                 if (mcp->mb[5] != 0xA5A5 || mcp->mb[6] != 0x5A5A ||
 658                     mcp->mb[7] != 0x2525)
 659                         rval = QLA_FUNCTION_FAILED;
 660         }
 661
 662         if (rval != QLA_SUCCESS) {
 663                 /*EMPTY*/
 664                 DEBUG2_3_11(printk("qla2x00_mbx_reg_test(%ld): failed=%x.\n",
 665                     vha->host_no, rval));
 666         } else {
 667                 /*EMPTY*/
 668                 DEBUG11(printk("qla2x00_mbx_reg_test(%ld): done.\n",
 669                     vha->host_no));
 670         }
 671
 672         return rval;
 673 }
 674
 675 /*
 676  * qla2x00_verify_checksum
 677  *      Verify firmware checksum.
 678  *
 679  * Input:
 680  *      ha = adapter block pointer.
 681  *      TARGET_QUEUE_LOCK must be released.
 682  *      ADAPTER_STATE_LOCK must be released.
 683  *
 684  * Returns:
 685  *      qla2x00 local function return status code.
 686  *
 687  * Context:
 688  *      Kernel context.
 689  */
 690 int
 691 qla2x00_verify_checksum(scsi_qla_host_t *vha, uint32_t risc_addr)
 692 {
 693         int rval;
 694         mbx_cmd_t mc;
 695         mbx_cmd_t *mcp = &mc;
 696
 697         DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
 698
 699         mcp->mb[0] = MBC_VERIFY_CHECKSUM;
 700         mcp->out_mb = MBX_0;
 701         mcp->in_mb = MBX_0;
 702         if (IS_FWI2_CAPABLE(vha->hw)) {
 703                 mcp->mb[1] = MSW(risc_addr);
 704                 mcp->mb[2] = LSW(risc_addr);
 705                 mcp->out_mb |= MBX_2|MBX_1;
 706                 mcp->in_mb |= MBX_2|MBX_1;
 707         } else {
 708                 mcp->mb[1] = LSW(risc_addr);
 709                 mcp->out_mb |= MBX_1;
 710                 mcp->in_mb |= MBX_1;
 711         }
 712
 713         mcp->tov = MBX_TOV_SECONDS;
 714         mcp->flags = 0;
 715         rval = qla2x00_mailbox_command(vha, mcp);
 716
 717         if (rval != QLA_SUCCESS) {
 718                 DEBUG2_3_11(printk("%s(%ld): failed=%x chk sum=%x.\n", __func__,
 719                     vha->host_no, rval, IS_FWI2_CAPABLE(vha->hw) ?
 720                     (mcp->mb[2] << 16) | mcp->mb[1]: mcp->mb[1]));
 721         } else {
 722                 DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
 723         }
 724
 725         return rval;
 726 }
 727
 728 /*
 729  * qla2x00_issue_iocb
 730  *      Issue IOCB using mailbox command
 731  *
 732  * Input:
 733  *      ha = adapter state pointer.
 734  *      buffer = buffer pointer.
 735  *      phys_addr = physical address of buffer.
 736  *      size = size of buffer.
 737  *      TARGET_QUEUE_LOCK must be released.
 738  *      ADAPTER_STATE_LOCK must be released.
 739  *
 740  * Returns:
 741  *      qla2x00 local function return status code.
 742  *
 743  * Context:
 744  *      Kernel context.
 745  */
 746 int
 747 qla2x00_issue_iocb_timeout(scsi_qla_host_t *vha, void *buffer,
 748     dma_addr_t phys_addr, size_t size, uint32_t tov)
 749 {
 750         int             rval;
 751         mbx_cmd_t       mc;
 752         mbx_cmd_t       *mcp = &mc;
 753
 754         mcp->mb[0] = MBC_IOCB_COMMAND_A64;
 755         mcp->mb[1] = 0;
 756         mcp->mb[2] = MSW(phys_addr);
 757         mcp->mb[3] = LSW(phys_addr);
 758         mcp->mb[6] = MSW(MSD(phys_addr));
 759         mcp->mb[7] = LSW(MSD(phys_addr));
 760         mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
 761         mcp->in_mb = MBX_2|MBX_0;
 762         mcp->tov = tov;
 763         mcp->flags = 0;
 764         rval = qla2x00_mailbox_command(vha, mcp);
 765
 766         if (rval != QLA_SUCCESS) {
 767                 /*EMPTY*/
 768                 DEBUG(printk("qla2x00_issue_iocb(%ld): failed rval 0x%x\n",
 769                     vha->host_no, rval));
 770         } else {
 771                 sts_entry_t *sts_entry = (sts_entry_t *) buffer;
 772
 773                 /* Mask reserved bits. */
 774                 sts_entry->entry_status &=
 775                     IS_FWI2_CAPABLE(vha->hw) ? RF_MASK_24XX : RF_MASK;
 776         }
 777
 778         return rval;
 779 }
 780
 781 int
 782 qla2x00_issue_iocb(scsi_qla_host_t *vha, void *buffer, dma_addr_t phys_addr,
 783     size_t size)
 784 {
 785         return qla2x00_issue_iocb_timeout(vha, buffer, phys_addr, size,
 786             MBX_TOV_SECONDS);
 787 }
 788
 789 /*
 790  * qla2x00_abort_command
 791  *      Abort command aborts a specified IOCB.
 792  *
 793  * Input:
 794  *      ha = adapter block pointer.
 795  *      sp = SB structure pointer.
 796  *
 797  * Returns:
 798  *      qla2x00 local function return status code.
 799  *
 800  * Context:
 801  *      Kernel context.
 802  */
 803 int
 804 qla2x00_abort_command(srb_t *sp)
 805 {
 806         unsigned long   flags = 0;
 807         int             rval;
 808         uint32_t        handle = 0;
 809         mbx_cmd_t       mc;
 810         mbx_cmd_t       *mcp = &mc;
 811         fc_port_t       *fcport = sp->fcport;
 812         scsi_qla_host_t *vha = fcport->vha;
 813         struct qla_hw_data *ha = vha->hw;
 814         struct req_que *req = vha->req;
 815
 816         DEBUG11(printk("qla2x00_abort_command(%ld): entered.\n", vha->host_no));
 817
 818         spin_lock_irqsave(&ha->hardware_lock, flags);
 819         for (handle = 1; handle < MAX_OUTSTANDING_COMMANDS; handle++) {
 820                 if (req->outstanding_cmds[handle] == sp)
 821                         break;
 822         }
 823         spin_unlock_irqrestore(&ha->hardware_lock, flags);
 824
 825         if (handle == MAX_OUTSTANDING_COMMANDS) {
 826                 /* command not found */
 827                 return QLA_FUNCTION_FAILED;
 828         }
 829
 830         mcp->mb[0] = MBC_ABORT_COMMAND;
 831         if (HAS_EXTENDED_IDS(ha))
 832                 mcp->mb[1] = fcport->loop_id;
 833         else
 834                 mcp->mb[1] = fcport->loop_id << 8;
 835         mcp->mb[2] = (uint16_t)handle;
 836         mcp->mb[3] = (uint16_t)(handle >> 16);
 837         mcp->mb[6] = (uint16_t)sp->cmd->device->lun;
 838         mcp->out_mb = MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
 839         mcp->in_mb = MBX_0;
 840         mcp->tov = MBX_TOV_SECONDS;
 841         mcp->flags = 0;
 842         rval = qla2x00_mailbox_command(vha, mcp);
 843
 844         if (rval != QLA_SUCCESS) {
 845                 DEBUG2_3_11(printk("qla2x00_abort_command(%ld): failed=%x.\n",
 846                     vha->host_no, rval));
 847         } else {
 848                 DEBUG11(printk("qla2x00_abort_command(%ld): done.\n",
 849                     vha->host_no));
 850         }
 851
 852         return rval;
 853 }
 854
 855 int
 856 qla2x00_abort_target(struct fc_port *fcport, unsigned int l, int tag)
 857 {
 858         int rval, rval2;
 859         mbx_cmd_t  mc;
 860         mbx_cmd_t  *mcp = &mc;
 861         scsi_qla_host_t *vha;
 862         struct req_que *req;
 863         struct rsp_que *rsp;
 864
 865         DEBUG11(printk("%s(%ld): entered.\n", __func__, fcport->vha->host_no));
 866
 867         l = l;
 868         vha = fcport->vha;
 869         req = vha->hw->req_q_map[tag];
 870         rsp = vha->hw->rsp_q_map[tag];
 871         mcp->mb[0] = MBC_ABORT_TARGET;
 872         mcp->out_mb = MBX_9|MBX_2|MBX_1|MBX_0;
 873         if (HAS_EXTENDED_IDS(vha->hw)) {
 874                 mcp->mb[1] = fcport->loop_id;
 875                 mcp->mb[10] = 0;
 876                 mcp->out_mb |= MBX_10;
 877         } else {
 878                 mcp->mb[1] = fcport->loop_id << 8;
 879         }
 880         mcp->mb[2] = vha->hw->loop_reset_delay;
 881         mcp->mb[9] = vha->vp_idx;
 882
 883         mcp->in_mb = MBX_0;
 884         mcp->tov = MBX_TOV_SECONDS;
 885         mcp->flags = 0;
 886         rval = qla2x00_mailbox_command(vha, mcp);
 887         if (rval != QLA_SUCCESS) {
 888                 DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
 889                     vha->host_no, rval));
 890         }
 891
 892         /* Issue marker IOCB. */
 893         rval2 = qla2x00_marker(vha, req, rsp, fcport->loop_id, 0,
 894                                                         MK_SYNC_ID);
 895         if (rval2 != QLA_SUCCESS) {
 896                 DEBUG2_3_11(printk("%s(%ld): failed to issue Marker IOCB "
 897                     "(%x).\n", __func__, vha->host_no, rval2));
 898         } else {
 899                 DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
 900         }
 901
 902         return rval;
 903 }
 904
 905 int
 906 qla2x00_lun_reset(struct fc_port *fcport, unsigned int l, int tag)
 907 {
 908         int rval, rval2;
 909         mbx_cmd_t  mc;
 910         mbx_cmd_t  *mcp = &mc;
 911         scsi_qla_host_t *vha;
 912         struct req_que *req;
 913         struct rsp_que *rsp;
 914
 915         DEBUG11(printk("%s(%ld): entered.\n", __func__, fcport->vha->host_no));
 916
 917         vha = fcport->vha;
 918         req = vha->hw->req_q_map[tag];
 919         rsp = vha->hw->rsp_q_map[tag];
 920         mcp->mb[0] = MBC_LUN_RESET;
 921         mcp->out_mb = MBX_9|MBX_3|MBX_2|MBX_1|MBX_0;
 922         if (HAS_EXTENDED_IDS(vha->hw))
 923                 mcp->mb[1] = fcport->loop_id;
 924         else
 925                 mcp->mb[1] = fcport->loop_id << 8;
 926         mcp->mb[2] = l;
 927         mcp->mb[3] = 0;
 928         mcp->mb[9] = vha->vp_idx;
 929
 930         mcp->in_mb = MBX_0;
 931         mcp->tov = MBX_TOV_SECONDS;
 932         mcp->flags = 0;
 933         rval = qla2x00_mailbox_command(vha, mcp);
 934         if (rval != QLA_SUCCESS) {
 935                 DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
 936                     vha->host_no, rval));
 937         }
 938
 939         /* Issue marker IOCB. */
 940         rval2 = qla2x00_marker(vha, req, rsp, fcport->loop_id, l,
 941                                                                 MK_SYNC_ID_LUN);
 942         if (rval2 != QLA_SUCCESS) {
 943                 DEBUG2_3_11(printk("%s(%ld): failed to issue Marker IOCB "
 944                     "(%x).\n", __func__, vha->host_no, rval2));
 945         } else {
 946                 DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
 947         }
 948
 949         return rval;
 950 }
 951
 952 /*
 953  * qla2x00_get_adapter_id
 954  *      Get adapter ID and topology.
 955  *
 956  * Input:
 957  *      ha = adapter block pointer.
 958  *      id = pointer for loop ID.
 959  *      al_pa = pointer for AL_PA.
 960  *      area = pointer for area.
 961  *      domain = pointer for domain.
 962  *      top = pointer for topology.
 963  *      TARGET_QUEUE_LOCK must be released.
 964  *      ADAPTER_STATE_LOCK must be released.
 965  *
 966  * Returns:
 967  *      qla2x00 local function return status code.
 968  *
 969  * Context:
 970  *      Kernel context.
 971  */
 972 int
 973 qla2x00_get_adapter_id(scsi_qla_host_t *vha, uint16_t *id, uint8_t *al_pa,
 974     uint8_t *area, uint8_t *domain, uint16_t *top, uint16_t *sw_cap)
 975 {
 976         int rval;
 977         mbx_cmd_t mc;
 978         mbx_cmd_t *mcp = &mc;
 979
 980         DEBUG11(printk("qla2x00_get_adapter_id(%ld): entered.\n",
 981             vha->host_no));
 982
 983         mcp->mb[0] = MBC_GET_ADAPTER_LOOP_ID;
 984         mcp->mb[9] = vha->vp_idx;
 985         mcp->out_mb = MBX_9|MBX_0;
 986         mcp->in_mb = MBX_9|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
 987         if (IS_QLA8XXX_TYPE(vha->hw))
 988                 mcp->in_mb |= MBX_13|MBX_12|MBX_11|MBX_10;
 989         mcp->tov = MBX_TOV_SECONDS;
 990         mcp->flags = 0;
 991         rval = qla2x00_mailbox_command(vha, mcp);
 992         if (mcp->mb[0] == MBS_COMMAND_ERROR)
 993                 rval = QLA_COMMAND_ERROR;
 994         else if (mcp->mb[0] == MBS_INVALID_COMMAND)
 995                 rval = QLA_INVALID_COMMAND;
 996
 997         /* Return data. */
 998         *id = mcp->mb[1];
 999         *al_pa = LSB(mcp->mb[2]);
1000         *area = MSB(mcp->mb[2]);
1001         *domain = LSB(mcp->mb[3]);
1002         *top = mcp->mb[6];
1003         *sw_cap = mcp->mb[7];
1004
1005         if (rval != QLA_SUCCESS) {
1006                 /*EMPTY*/
1007                 DEBUG2_3_11(printk("qla2x00_get_adapter_id(%ld): failed=%x.\n",
1008                     vha->host_no, rval));
1009         } else {
1010                 DEBUG11(printk("qla2x00_get_adapter_id(%ld): done.\n",
1011                     vha->host_no));
1012
1013                 if (IS_QLA8XXX_TYPE(vha->hw)) {
1014                         vha->fcoe_vlan_id = mcp->mb[9] & 0xfff;
1015                         vha->fcoe_fcf_idx = mcp->mb[10];
1016                         vha->fcoe_vn_port_mac[5] = mcp->mb[11] >> 8;
1017                         vha->fcoe_vn_port_mac[4] = mcp->mb[11] & 0xff;
1018                         vha->fcoe_vn_port_mac[3] = mcp->mb[12] >> 8;
1019                         vha->fcoe_vn_port_mac[2] = mcp->mb[12] & 0xff;
1020                         vha->fcoe_vn_port_mac[1] = mcp->mb[13] >> 8;
1021                         vha->fcoe_vn_port_mac[0] = mcp->mb[13] & 0xff;
1022                 }
1023         }
1024
1025         return rval;
1026 }
1027
1028 /*
1029  * qla2x00_get_retry_cnt
1030  *      Get current firmware login retry count and delay.
1031  *
1032  * Input:
1033  *      ha = adapter block pointer.
1034  *      retry_cnt = pointer to login retry count.
1035  *      tov = pointer to login timeout value.
1036  *
1037  * Returns:
1038  *      qla2x00 local function return status code.
1039  *
1040  * Context:
1041  *      Kernel context.
1042  */
1043 int
1044 qla2x00_get_retry_cnt(scsi_qla_host_t *vha, uint8_t *retry_cnt, uint8_t *tov,
1045     uint16_t *r_a_tov)
1046 {
1047         int rval;
1048         uint16_t ratov;
1049         mbx_cmd_t mc;
1050         mbx_cmd_t *mcp = &mc;
1051
1052         DEBUG11(printk("qla2x00_get_retry_cnt(%ld): entered.\n",
1053                         vha->host_no));
1054
1055         mcp->mb[0] = MBC_GET_RETRY_COUNT;
1056         mcp->out_mb = MBX_0;
1057         mcp->in_mb = MBX_3|MBX_2|MBX_1|MBX_0;
1058         mcp->tov = MBX_TOV_SECONDS;
1059         mcp->flags = 0;
1060         rval = qla2x00_mailbox_command(vha, mcp);
1061
1062         if (rval != QLA_SUCCESS) {
1063                 /*EMPTY*/
1064                 DEBUG2_3_11(printk("qla2x00_get_retry_cnt(%ld): failed = %x.\n",
1065                     vha->host_no, mcp->mb[0]));
1066         } else {
1067                 /* Convert returned data and check our values. */
1068                 *r_a_tov = mcp->mb[3] / 2;
1069                 ratov = (mcp->mb[3]/2) / 10;  /* mb[3] value is in 100ms */
1070                 if (mcp->mb[1] * ratov > (*retry_cnt) * (*tov)) {
1071                         /* Update to the larger values */
1072                         *retry_cnt = (uint8_t)mcp->mb[1];
1073                         *tov = ratov;
1074                 }
1075
1076                 DEBUG11(printk("qla2x00_get_retry_cnt(%ld): done. mb3=%d "
1077                     "ratov=%d.\n", vha->host_no, mcp->mb[3], ratov));
1078         }
1079
1080         return rval;
1081 }
1082
1083 /*
1084  * qla2x00_init_firmware
1085  *      Initialize adapter firmware.
1086  *
1087  * Input:
1088  *      ha = adapter block pointer.
1089  *      dptr = Initialization control block pointer.
1090  *      size = size of initialization control block.
1091  *      TARGET_QUEUE_LOCK must be released.
1092  *      ADAPTER_STATE_LOCK must be released.
1093  *
1094  * Returns:
1095  *      qla2x00 local function return status code.
1096  *
1097  * Context:
1098  *      Kernel context.
1099  */
1100 int
1101 qla2x00_init_firmware(scsi_qla_host_t *vha, uint16_t size)
1102 {
1103         int rval;
1104         mbx_cmd_t mc;
1105         mbx_cmd_t *mcp = &mc;
1106         struct qla_hw_data *ha = vha->hw;
1107
1108         DEBUG11(printk("qla2x00_init_firmware(%ld): entered.\n",
1109             vha->host_no));
1110
1111         if (IS_QLA82XX(ha) && ql2xdbwr)
1112                 qla82xx_wr_32(ha, ha->nxdb_wr_ptr,
1113                         (0x04 | (ha->portnum << 5) | (0 << 8) | (0 << 16)));
1114
1115         if (ha->flags.npiv_supported)
1116                 mcp->mb[0] = MBC_MID_INITIALIZE_FIRMWARE;
1117         else
1118                 mcp->mb[0] = MBC_INITIALIZE_FIRMWARE;
1119
1120         mcp->mb[1] = 0;
1121         mcp->mb[2] = MSW(ha->init_cb_dma);
1122         mcp->mb[3] = LSW(ha->init_cb_dma);
1123         mcp->mb[6] = MSW(MSD(ha->init_cb_dma));
1124         mcp->mb[7] = LSW(MSD(ha->init_cb_dma));
1125         mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
1126         if (IS_QLA81XX(ha) && ha->ex_init_cb->ex_version) {
1127                 mcp->mb[1] = BIT_0;
1128                 mcp->mb[10] = MSW(ha->ex_init_cb_dma);
1129                 mcp->mb[11] = LSW(ha->ex_init_cb_dma);
1130                 mcp->mb[12] = MSW(MSD(ha->ex_init_cb_dma));
1131                 mcp->mb[13] = LSW(MSD(ha->ex_init_cb_dma));
1132                 mcp->mb[14] = sizeof(*ha->ex_init_cb);
1133                 mcp->out_mb |= MBX_14|MBX_13|MBX_12|MBX_11|MBX_10;
1134         }
1135         mcp->in_mb = MBX_0;
1136         mcp->buf_size = size;
1137         mcp->flags = MBX_DMA_OUT;
1138         mcp->tov = MBX_TOV_SECONDS;
1139         rval = qla2x00_mailbox_command(vha, mcp);
1140
1141         if (rval != QLA_SUCCESS) {
1142                 /*EMPTY*/
1143                 DEBUG2_3_11(printk("qla2x00_init_firmware(%ld): failed=%x "
1144                     "mb0=%x.\n",
1145                     vha->host_no, rval, mcp->mb[0]));
1146         } else {
1147                 /*EMPTY*/
1148                 DEBUG11(printk("qla2x00_init_firmware(%ld): done.\n",
1149                     vha->host_no));
1150         }
1151
1152         return rval;
1153 }
1154
1155 /*
1156  * qla2x00_get_port_database
1157  *      Issue normal/enhanced get port database mailbox command
1158  *      and copy device name as necessary.
1159  *
1160  * Input:
1161  *      ha = adapter state pointer.
1162  *      dev = structure pointer.
1163  *      opt = enhanced cmd option byte.
1164  *
1165  * Returns:
1166  *      qla2x00 local function return status code.
1167  *
1168  * Context:
1169  *      Kernel context.
1170  */
1171 int
1172 qla2x00_get_port_database(scsi_qla_host_t *vha, fc_port_t *fcport, uint8_t opt)
1173 {
1174         int rval;
1175         mbx_cmd_t mc;
1176         mbx_cmd_t *mcp = &mc;
1177         port_database_t *pd;
1178         struct port_database_24xx *pd24;
1179         dma_addr_t pd_dma;
1180         struct qla_hw_data *ha = vha->hw;
1181
1182         DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
1183
1184         pd24 = NULL;
1185         pd = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &pd_dma);
1186         if (pd  == NULL) {
1187                 DEBUG2_3(printk("%s(%ld): failed to allocate Port Database "
1188                     "structure.\n", __func__, vha->host_no));
1189                 return QLA_MEMORY_ALLOC_FAILED;
1190         }
1191         memset(pd, 0, max(PORT_DATABASE_SIZE, PORT_DATABASE_24XX_SIZE));
1192
1193         mcp->mb[0] = MBC_GET_PORT_DATABASE;
1194         if (opt != 0 && !IS_FWI2_CAPABLE(ha))
1195                 mcp->mb[0] = MBC_ENHANCED_GET_PORT_DATABASE;
1196         mcp->mb[2] = MSW(pd_dma);
1197         mcp->mb[3] = LSW(pd_dma);
1198         mcp->mb[6] = MSW(MSD(pd_dma));
1199         mcp->mb[7] = LSW(MSD(pd_dma));
1200         mcp->mb[9] = vha->vp_idx;
1201         mcp->out_mb = MBX_9|MBX_7|MBX_6|MBX_3|MBX_2|MBX_0;
1202         mcp->in_mb = MBX_0;
1203         if (IS_FWI2_CAPABLE(ha)) {
1204                 mcp->mb[1] = fcport->loop_id;
1205                 mcp->mb[10] = opt;
1206                 mcp->out_mb |= MBX_10|MBX_1;
1207                 mcp->in_mb |= MBX_1;
1208         } else if (HAS_EXTENDED_IDS(ha)) {
1209                 mcp->mb[1] = fcport->loop_id;
1210                 mcp->mb[10] = opt;
1211                 mcp->out_mb |= MBX_10|MBX_1;
1212         } else {
1213                 mcp->mb[1] = fcport->loop_id << 8 | opt;
1214                 mcp->out_mb |= MBX_1;
1215         }
1216         mcp->buf_size = IS_FWI2_CAPABLE(ha) ?
1217             PORT_DATABASE_24XX_SIZE : PORT_DATABASE_SIZE;
1218         mcp->flags = MBX_DMA_IN;
1219         mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2);
1220         rval = qla2x00_mailbox_command(vha, mcp);
1221         if (rval != QLA_SUCCESS)
1222                 goto gpd_error_out;
1223
1224         if (IS_FWI2_CAPABLE(ha)) {
1225                 pd24 = (struct port_database_24xx *) pd;
1226
1227                 /* Check for logged in state. */
1228                 if (pd24->current_login_state != PDS_PRLI_COMPLETE &&
1229                     pd24->last_login_state != PDS_PRLI_COMPLETE) {
1230                         DEBUG2(printk("%s(%ld): Unable to verify "
1231                             "login-state (%x/%x) for loop_id %x\n",
1232                             __func__, vha->host_no,
1233                             pd24->current_login_state,
1234                             pd24->last_login_state, fcport->loop_id));
1235                         rval = QLA_FUNCTION_FAILED;
1236                         goto gpd_error_out;
1237                 }
1238
1239                 /* Names are little-endian. */
1240                 memcpy(fcport->node_name, pd24->node_name, WWN_SIZE);
1241                 memcpy(fcport->port_name, pd24->port_name, WWN_SIZE);
1242
1243                 /* Get port_id of device. */
1244                 fcport->d_id.b.domain = pd24->port_id[0];
1245                 fcport->d_id.b.area = pd24->port_id[1];
1246                 fcport->d_id.b.al_pa = pd24->port_id[2];
1247                 fcport->d_id.b.rsvd_1 = 0;
1248
1249                 /* If not target must be initiator or unknown type. */
1250                 if ((pd24->prli_svc_param_word_3[0] & BIT_4) == 0)
1251                         fcport->port_type = FCT_INITIATOR;
1252                 else
1253                         fcport->port_type = FCT_TARGET;
1254         } else {
1255                 /* Check for logged in state. */
1256                 if (pd->master_state != PD_STATE_PORT_LOGGED_IN &&
1257                     pd->slave_state != PD_STATE_PORT_LOGGED_IN) {
1258                         rval = QLA_FUNCTION_FAILED;
1259                         goto gpd_error_out;
1260                 }
1261
1262                 /* Names are little-endian. */
1263                 memcpy(fcport->node_name, pd->node_name, WWN_SIZE);
1264                 memcpy(fcport->port_name, pd->port_name, WWN_SIZE);
1265
1266                 /* Get port_id of device. */
1267                 fcport->d_id.b.domain = pd->port_id[0];
1268                 fcport->d_id.b.area = pd->port_id[3];
1269                 fcport->d_id.b.al_pa = pd->port_id[2];
1270                 fcport->d_id.b.rsvd_1 = 0;
1271
1272                 /* If not target must be initiator or unknown type. */
1273                 if ((pd->prli_svc_param_word_3[0] & BIT_4) == 0)
1274                         fcport->port_type = FCT_INITIATOR;
1275                 else
1276                         fcport->port_type = FCT_TARGET;
1277
1278                 /* Passback COS information. */
1279                 fcport->supported_classes = (pd->options & BIT_4) ?
1280                     FC_COS_CLASS2: FC_COS_CLASS3;
1281         }
1282
1283 gpd_error_out:
1284         dma_pool_free(ha->s_dma_pool, pd, pd_dma);
1285
1286         if (rval != QLA_SUCCESS) {
1287                 DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x mb[1]=%x.\n",
1288                     __func__, vha->host_no, rval, mcp->mb[0], mcp->mb[1]));
1289         } else {
1290                 DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
1291         }
1292
1293         return rval;
1294 }
1295
1296 /*
1297  * qla2x00_get_firmware_state
1298  *      Get adapter firmware state.
1299  *
1300  * Input:
1301  *      ha = adapter block pointer.
1302  *      dptr = pointer for firmware state.
1303  *      TARGET_QUEUE_LOCK must be released.
1304  *      ADAPTER_STATE_LOCK must be released.
1305  *
1306  * Returns:
1307  *      qla2x00 local function return status code.
1308  *
1309  * Context:
1310  *      Kernel context.
1311  */
1312 int
1313 qla2x00_get_firmware_state(scsi_qla_host_t *vha, uint16_t *states)
1314 {
1315         int rval;
1316         mbx_cmd_t mc;
1317         mbx_cmd_t *mcp = &mc;
1318
1319         DEBUG11(printk("qla2x00_get_firmware_state(%ld): entered.\n",
1320             vha->host_no));
1321
1322         mcp->mb[0] = MBC_GET_FIRMWARE_STATE;
1323         mcp->out_mb = MBX_0;
1324         if (IS_FWI2_CAPABLE(vha->hw))
1325                 mcp->in_mb = MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
1326         else
1327                 mcp->in_mb = MBX_1|MBX_0;
1328         mcp->tov = MBX_TOV_SECONDS;
1329         mcp->flags = 0;
1330         rval = qla2x00_mailbox_command(vha, mcp);
1331
1332         /* Return firmware states. */
1333         states[0] = mcp->mb[1];
1334         if (IS_FWI2_CAPABLE(vha->hw)) {
1335                 states[1] = mcp->mb[2];
1336                 states[2] = mcp->mb[3];
1337                 states[3] = mcp->mb[4];
1338                 states[4] = mcp->mb[5];
1339         }
1340
1341         if (rval != QLA_SUCCESS) {
1342                 /*EMPTY*/
1343                 DEBUG2_3_11(printk("qla2x00_get_firmware_state(%ld): "
1344                     "failed=%x.\n", vha->host_no, rval));
1345         } else {
1346                 /*EMPTY*/
1347                 DEBUG11(printk("qla2x00_get_firmware_state(%ld): done.\n",
1348                     vha->host_no));
1349         }
1350
1351         return rval;
1352 }
1353
1354 /*
1355  * qla2x00_get_port_name
1356  *      Issue get port name mailbox command.
1357  *      Returned name is in big endian format.
1358  *
1359  * Input:
1360  *      ha = adapter block pointer.
1361  *      loop_id = loop ID of device.
1362  *      name = pointer for name.
1363  *      TARGET_QUEUE_LOCK must be released.
1364  *      ADAPTER_STATE_LOCK must be released.
1365  *
1366  * Returns:
1367  *      qla2x00 local function return status code.
1368  *
1369  * Context:
1370  *      Kernel context.
1371  */
1372 int
1373 qla2x00_get_port_name(scsi_qla_host_t *vha, uint16_t loop_id, uint8_t *name,
1374     uint8_t opt)
1375 {
1376         int rval;
1377         mbx_cmd_t mc;
1378         mbx_cmd_t *mcp = &mc;
1379
1380         DEBUG11(printk("qla2x00_get_port_name(%ld): entered.\n",
1381             vha->host_no));
1382
1383         mcp->mb[0] = MBC_GET_PORT_NAME;
1384         mcp->mb[9] = vha->vp_idx;
1385         mcp->out_mb = MBX_9|MBX_1|MBX_0;
1386         if (HAS_EXTENDED_IDS(vha->hw)) {
1387                 mcp->mb[1] = loop_id;
1388                 mcp->mb[10] = opt;
1389                 mcp->out_mb |= MBX_10;
1390         } else {
1391                 mcp->mb[1] = loop_id << 8 | opt;
1392         }
1393
1394         mcp->in_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
1395         mcp->tov = MBX_TOV_SECONDS;
1396         mcp->flags = 0;
1397         rval = qla2x00_mailbox_command(vha, mcp);
1398
1399         if (rval != QLA_SUCCESS) {
1400                 /*EMPTY*/
1401                 DEBUG2_3_11(printk("qla2x00_get_port_name(%ld): failed=%x.\n",
1402                     vha->host_no, rval));
1403         } else {
1404                 if (name != NULL) {
1405                         /* This function returns name in big endian. */
1406                         name[0] = MSB(mcp->mb[2]);
1407                         name[1] = LSB(mcp->mb[2]);
1408                         name[2] = MSB(mcp->mb[3]);
1409                         name[3] = LSB(mcp->mb[3]);
1410                         name[4] = MSB(mcp->mb[6]);
1411                         name[5] = LSB(mcp->mb[6]);
1412                         name[6] = MSB(mcp->mb[7]);
1413                         name[7] = LSB(mcp->mb[7]);
1414                 }
1415
1416                 DEBUG11(printk("qla2x00_get_port_name(%ld): done.\n",
1417                     vha->host_no));
1418         }
1419
1420         return rval;
1421 }
1422
1423 /*
1424  * qla2x00_lip_reset
1425  *      Issue LIP reset mailbox command.
1426  *
1427  * Input:
1428  *      ha = adapter block pointer.
1429  *      TARGET_QUEUE_LOCK must be released.
1430  *      ADAPTER_STATE_LOCK must be released.
1431  *
1432  * Returns:
1433  *      qla2x00 local function return status code.
1434  *
1435  * Context:
1436  *      Kernel context.
1437  */
1438 int
1439 qla2x00_lip_reset(scsi_qla_host_t *vha)
1440 {
1441         int rval;
1442         mbx_cmd_t mc;
1443         mbx_cmd_t *mcp = &mc;
1444
1445         DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
1446
1447         if (IS_QLA8XXX_TYPE(vha->hw)) {
1448                 /* Logout across all FCFs. */
1449                 mcp->mb[0] = MBC_LIP_FULL_LOGIN;
1450                 mcp->mb[1] = BIT_1;
1451                 mcp->mb[2] = 0;
1452                 mcp->out_mb = MBX_2|MBX_1|MBX_0;
1453         } else if (IS_FWI2_CAPABLE(vha->hw)) {
1454                 mcp->mb[0] = MBC_LIP_FULL_LOGIN;
1455                 mcp->mb[1] = BIT_6;
1456                 mcp->mb[2] = 0;
1457                 mcp->mb[3] = vha->hw->loop_reset_delay;
1458                 mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
1459         } else {
1460                 mcp->mb[0] = MBC_LIP_RESET;
1461                 mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
1462                 if (HAS_EXTENDED_IDS(vha->hw)) {
1463                         mcp->mb[1] = 0x00ff;
1464                         mcp->mb[10] = 0;
1465                         mcp->out_mb |= MBX_10;
1466                 } else {
1467                         mcp->mb[1] = 0xff00;
1468                 }
1469                 mcp->mb[2] = vha->hw->loop_reset_delay;
1470                 mcp->mb[3] = 0;
1471         }
1472         mcp->in_mb = MBX_0;
1473         mcp->tov = MBX_TOV_SECONDS;
1474         mcp->flags = 0;
1475         rval = qla2x00_mailbox_command(vha, mcp);
1476
1477         if (rval != QLA_SUCCESS) {
1478                 /*EMPTY*/
1479                 DEBUG2_3_11(printk("%s(%ld): failed=%x.\n",
1480                     __func__, vha->host_no, rval));
1481         } else {
1482                 /*EMPTY*/
1483                 DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
1484         }
1485
1486         return rval;
1487 }
1488
1489 /*
1490  * qla2x00_send_sns
1491  *      Send SNS command.
1492  *
1493  * Input:
1494  *      ha = adapter block pointer.
1495  *      sns = pointer for command.
1496  *      cmd_size = command size.
1497  *      buf_size = response/command size.
1498  *      TARGET_QUEUE_LOCK must be released.
1499  *      ADAPTER_STATE_LOCK must be released.
1500  *
1501  * Returns:
1502  *      qla2x00 local function return status code.
1503  *
1504  * Context:
1505  *      Kernel context.
1506  */
1507 int
1508 qla2x00_send_sns(scsi_qla_host_t *vha, dma_addr_t sns_phys_address,
1509     uint16_t cmd_size, size_t buf_size)
1510 {
1511         int rval;
1512         mbx_cmd_t mc;
1513         mbx_cmd_t *mcp = &mc;
1514
1515         DEBUG11(printk("qla2x00_send_sns(%ld): entered.\n",
1516             vha->host_no));
1517
1518         DEBUG11(printk("qla2x00_send_sns: retry cnt=%d ratov=%d total "
1519                 "tov=%d.\n", vha->hw->retry_count, vha->hw->login_timeout,
1520                 mcp->tov));
1521
1522         mcp->mb[0] = MBC_SEND_SNS_COMMAND;
1523         mcp->mb[1] = cmd_size;
1524         mcp->mb[2] = MSW(sns_phys_address);
1525         mcp->mb[3] = LSW(sns_phys_address);
1526         mcp->mb[6] = MSW(MSD(sns_phys_address));
1527         mcp->mb[7] = LSW(MSD(sns_phys_address));
1528         mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
1529         mcp->in_mb = MBX_0|MBX_1;
1530         mcp->buf_size = buf_size;
1531         mcp->flags = MBX_DMA_OUT|MBX_DMA_IN;
1532         mcp->tov = (vha->hw->login_timeout * 2) + (vha->hw->login_timeout / 2);
1533         rval = qla2x00_mailbox_command(vha, mcp);
1534
1535         if (rval != QLA_SUCCESS) {
1536                 /*EMPTY*/
1537                 DEBUG(printk("qla2x00_send_sns(%ld): failed=%x mb[0]=%x "
1538                     "mb[1]=%x.\n", vha->host_no, rval, mcp->mb[0], mcp->mb[1]));
1539                 DEBUG2_3_11(printk("qla2x00_send_sns(%ld): failed=%x mb[0]=%x "
1540                     "mb[1]=%x.\n", vha->host_no, rval, mcp->mb[0], mcp->mb[1]));
1541         } else {
1542                 /*EMPTY*/
1543                 DEBUG11(printk("qla2x00_send_sns(%ld): done.\n", vha->host_no));
1544         }
1545
1546         return rval;
1547 }
1548
1549 int
1550 qla24xx_login_fabric(scsi_qla_host_t *vha, uint16_t loop_id, uint8_t domain,
1551     uint8_t area, uint8_t al_pa, uint16_t *mb, uint8_t opt)
1552 {
1553         int             rval;
1554
1555         struct logio_entry_24xx *lg;
1556         dma_addr_t      lg_dma;
1557         uint32_t        iop[2];
1558         struct qla_hw_data *ha = vha->hw;
1559         struct req_que *req;
1560         struct rsp_que *rsp;
1561
1562         DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
1563
1564         if (ha->flags.cpu_affinity_enabled)
1565                 req = ha->req_q_map[0];
1566         else
1567                 req = vha->req;
1568         rsp = req->rsp;
1569
1570         lg = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &lg_dma);
1571         if (lg == NULL) {
1572                 DEBUG2_3(printk("%s(%ld): failed to allocate Login IOCB.\n",
1573                     __func__, vha->host_no));
1574                 return QLA_MEMORY_ALLOC_FAILED;
1575         }
1576         memset(lg, 0, sizeof(struct logio_entry_24xx));
1577
1578         lg->entry_type = LOGINOUT_PORT_IOCB_TYPE;
1579         lg->entry_count = 1;
1580         lg->handle = MAKE_HANDLE(req->id, lg->handle);
1581         lg->nport_handle = cpu_to_le16(loop_id);
1582         lg->control_flags = __constant_cpu_to_le16(LCF_COMMAND_PLOGI);
1583         if (opt & BIT_0)
1584                 lg->control_flags |= __constant_cpu_to_le16(LCF_COND_PLOGI);
1585         if (opt & BIT_1)
1586                 lg->control_flags |= __constant_cpu_to_le16(LCF_SKIP_PRLI);
1587         lg->port_id[0] = al_pa;
1588         lg->port_id[1] = area;
1589         lg->port_id[2] = domain;
1590         lg->vp_index = vha->vp_idx;
1591         rval = qla2x00_issue_iocb(vha, lg, lg_dma, 0);
1592         if (rval != QLA_SUCCESS) {
1593                 DEBUG2_3_11(printk("%s(%ld): failed to issue Login IOCB "
1594                     "(%x).\n", __func__, vha->host_no, rval));
1595         } else if (lg->entry_status != 0) {
1596                 DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
1597                     "-- error status (%x).\n", __func__, vha->host_no,
1598                     lg->entry_status));
1599                 rval = QLA_FUNCTION_FAILED;
1600         } else if (lg->comp_status != __constant_cpu_to_le16(CS_COMPLETE)) {
1601                 iop[0] = le32_to_cpu(lg->io_parameter[0]);
1602                 iop[1] = le32_to_cpu(lg->io_parameter[1]);
1603
1604                 DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
1605                     "-- completion status (%x)  ioparam=%x/%x.\n", __func__,
1606                     vha->host_no, le16_to_cpu(lg->comp_status), iop[0],
1607                     iop[1]));
1608
1609                 switch (iop[0]) {
1610                 case LSC_SCODE_PORTID_USED:
1611                         mb[0] = MBS_PORT_ID_USED;
1612                         mb[1] = LSW(iop[1]);
1613                         break;
1614                 case LSC_SCODE_NPORT_USED:
1615                         mb[0] = MBS_LOOP_ID_USED;
1616                         break;
1617                 case LSC_SCODE_NOLINK:
1618                 case LSC_SCODE_NOIOCB:
1619                 case LSC_SCODE_NOXCB:
1620                 case LSC_SCODE_CMD_FAILED:
1621                 case LSC_SCODE_NOFABRIC:
1622                 case LSC_SCODE_FW_NOT_READY:
1623                 case LSC_SCODE_NOT_LOGGED_IN:
1624                 case LSC_SCODE_NOPCB:
1625                 case LSC_SCODE_ELS_REJECT:
1626                 case LSC_SCODE_CMD_PARAM_ERR:
1627                 case LSC_SCODE_NONPORT:
1628                 case LSC_SCODE_LOGGED_IN:
1629                 case LSC_SCODE_NOFLOGI_ACC:
1630                 default:
1631                         mb[0] = MBS_COMMAND_ERROR;
1632                         break;
1633                 }
1634         } else {
1635                 DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
1636
1637                 iop[0] = le32_to_cpu(lg->io_parameter[0]);
1638
1639                 mb[0] = MBS_COMMAND_COMPLETE;
1640                 mb[1] = 0;
1641                 if (iop[0] & BIT_4) {
1642                         if (iop[0] & BIT_8)
1643                                 mb[1] |= BIT_1;
1644                 } else
1645                         mb[1] = BIT_0;
1646
1647                 /* Passback COS information. */
1648                 mb[10] = 0;
1649                 if (lg->io_parameter[7] || lg->io_parameter[8])
1650                         mb[10] |= BIT_0;        /* Class 2. */
1651                 if (lg->io_parameter[9] || lg->io_parameter[10])
1652                         mb[10] |= BIT_1;        /* Class 3. */
1653         }
1654
1655         dma_pool_free(ha->s_dma_pool, lg, lg_dma);
1656
1657         return rval;
1658 }
1659
1660 /*
1661  * qla2x00_login_fabric
1662  *      Issue login fabric port mailbox command.
1663  *
1664  * Input:
1665  *      ha = adapter block pointer.
1666  *      loop_id = device loop ID.
1667  *      domain = device domain.
1668  *      area = device area.
1669  *      al_pa = device AL_PA.
1670  *      status = pointer for return status.
1671  *      opt = command options.
1672  *      TARGET_QUEUE_LOCK must be released.
1673  *      ADAPTER_STATE_LOCK must be released.
1674  *
1675  * Returns:
1676  *      qla2x00 local function return status code.
1677  *
1678  * Context:
1679  *      Kernel context.
1680  */
1681 int
1682 qla2x00_login_fabric(scsi_qla_host_t *vha, uint16_t loop_id, uint8_t domain,
1683     uint8_t area, uint8_t al_pa, uint16_t *mb, uint8_t opt)
1684 {
1685         int rval;
1686         mbx_cmd_t mc;
1687         mbx_cmd_t *mcp = &mc;
1688         struct qla_hw_data *ha = vha->hw;
1689
1690         DEBUG11(printk("qla2x00_login_fabric(%ld): entered.\n", vha->host_no));
1691
1692         mcp->mb[0] = MBC_LOGIN_FABRIC_PORT;
1693         mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
1694         if (HAS_EXTENDED_IDS(ha)) {
1695                 mcp->mb[1] = loop_id;
1696                 mcp->mb[10] = opt;
1697                 mcp->out_mb |= MBX_10;
1698         } else {
1699                 mcp->mb[1] = (loop_id << 8) | opt;
1700         }
1701         mcp->mb[2] = domain;
1702         mcp->mb[3] = area << 8 | al_pa;
1703
1704         mcp->in_mb = MBX_7|MBX_6|MBX_2|MBX_1|MBX_0;
1705         mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2);
1706         mcp->flags = 0;
1707         rval = qla2x00_mailbox_command(vha, mcp);
1708
1709         /* Return mailbox statuses. */
1710         if (mb != NULL) {
1711                 mb[0] = mcp->mb[0];
1712                 mb[1] = mcp->mb[1];
1713                 mb[2] = mcp->mb[2];
1714                 mb[6] = mcp->mb[6];
1715                 mb[7] = mcp->mb[7];
1716                 /* COS retrieved from Get-Port-Database mailbox command. */
1717                 mb[10] = 0;
1718         }
1719
1720         if (rval != QLA_SUCCESS) {
1721                 /* RLU tmp code: need to change main mailbox_command function to
1722                  * return ok even when the mailbox completion value is not
1723                  * SUCCESS. The caller needs to be responsible to interpret
1724                  * the return values of this mailbox command if we're not
1725                  * to change too much of the existing code.
1726                  */
1727                 if (mcp->mb[0] == 0x4001 || mcp->mb[0] == 0x4002 ||
1728                     mcp->mb[0] == 0x4003 || mcp->mb[0] == 0x4005 ||
1729                     mcp->mb[0] == 0x4006)
1730                         rval = QLA_SUCCESS;
1731
1732                 /*EMPTY*/
1733                 DEBUG2_3_11(printk("qla2x00_login_fabric(%ld): failed=%x "
1734                     "mb[0]=%x mb[1]=%x mb[2]=%x.\n", vha->host_no, rval,
1735                     mcp->mb[0], mcp->mb[1], mcp->mb[2]));
1736         } else {
1737                 /*EMPTY*/
1738                 DEBUG11(printk("qla2x00_login_fabric(%ld): done.\n",
1739                     vha->host_no));
1740         }
1741
1742         return rval;
1743 }
1744
1745 /*
1746  * qla2x00_login_local_device
1747  *           Issue login loop port mailbox command.
1748  *
1749  * Input:
1750  *           ha = adapter block pointer.
1751  *           loop_id = device loop ID.
1752  *           opt = command options.
1753  *
1754  * Returns:
1755  *            Return status code.
1756  *
1757  * Context:
1758  *            Kernel context.
1759  *
1760  */
1761 int
1762 qla2x00_login_local_device(scsi_qla_host_t *vha, fc_port_t *fcport,
1763     uint16_t *mb_ret, uint8_t opt)
1764 {
1765         int rval;
1766         mbx_cmd_t mc;
1767         mbx_cmd_t *mcp = &mc;
1768         struct qla_hw_data *ha = vha->hw;
1769
1770         if (IS_FWI2_CAPABLE(ha))
1771                 return qla24xx_login_fabric(vha, fcport->loop_id,
1772                     fcport->d_id.b.domain, fcport->d_id.b.area,
1773                     fcport->d_id.b.al_pa, mb_ret, opt);
1774
1775         DEBUG3(printk("%s(%ld): entered.\n", __func__, vha->host_no));
1776
1777         mcp->mb[0] = MBC_LOGIN_LOOP_PORT;
1778         if (HAS_EXTENDED_IDS(ha))
1779                 mcp->mb[1] = fcport->loop_id;
1780         else
1781                 mcp->mb[1] = fcport->loop_id << 8;
1782         mcp->mb[2] = opt;
1783         mcp->out_mb = MBX_2|MBX_1|MBX_0;
1784         mcp->in_mb = MBX_7|MBX_6|MBX_1|MBX_0;
1785         mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2);
1786         mcp->flags = 0;
1787         rval = qla2x00_mailbox_command(vha, mcp);
1788
1789         /* Return mailbox statuses. */
1790         if (mb_ret != NULL) {
1791                 mb_ret[0] = mcp->mb[0];
1792                 mb_ret[1] = mcp->mb[1];
1793                 mb_ret[6] = mcp->mb[6];
1794                 mb_ret[7] = mcp->mb[7];
1795         }
1796
1797         if (rval != QLA_SUCCESS) {
1798                 /* AV tmp code: need to change main mailbox_command function to
1799                  * return ok even when the mailbox completion value is not
1800                  * SUCCESS. The caller needs to be responsible to interpret
1801                  * the return values of this mailbox command if we're not
1802                  * to change too much of the existing code.
1803                  */
1804                 if (mcp->mb[0] == 0x4005 || mcp->mb[0] == 0x4006)
1805                         rval = QLA_SUCCESS;
1806
1807                 DEBUG(printk("%s(%ld): failed=%x mb[0]=%x mb[1]=%x "
1808                     "mb[6]=%x mb[7]=%x.\n", __func__, vha->host_no, rval,
1809                     mcp->mb[0], mcp->mb[1], mcp->mb[6], mcp->mb[7]));
1810                 DEBUG2_3(printk("%s(%ld): failed=%x mb[0]=%x mb[1]=%x "
1811                     "mb[6]=%x mb[7]=%x.\n", __func__, vha->host_no, rval,
1812                     mcp->mb[0], mcp->mb[1], mcp->mb[6], mcp->mb[7]));
1813         } else {
1814                 /*EMPTY*/
1815                 DEBUG3(printk("%s(%ld): done.\n", __func__, vha->host_no));
1816         }
1817
1818         return (rval);
1819 }
1820
1821 int
1822 qla24xx_fabric_logout(scsi_qla_host_t *vha, uint16_t loop_id, uint8_t domain,
1823     uint8_t area, uint8_t al_pa)
1824 {
1825         int             rval;
1826         struct logio_entry_24xx *lg;
1827         dma_addr_t      lg_dma;
1828         struct qla_hw_data *ha = vha->hw;
1829         struct req_que *req;
1830         struct rsp_que *rsp;
1831
1832         DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
1833
1834         lg = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &lg_dma);
1835         if (lg == NULL) {
1836                 DEBUG2_3(printk("%s(%ld): failed to allocate Logout IOCB.\n",
1837                     __func__, vha->host_no));
1838                 return QLA_MEMORY_ALLOC_FAILED;
1839         }
1840         memset(lg, 0, sizeof(struct logio_entry_24xx));
1841
1842         if (ql2xmaxqueues > 1)
1843                 req = ha->req_q_map[0];
1844         else
1845                 req = vha->req;
1846         rsp = req->rsp;
1847         lg->entry_type = LOGINOUT_PORT_IOCB_TYPE;
1848         lg->entry_count = 1;
1849         lg->handle = MAKE_HANDLE(req->id, lg->handle);
1850         lg->nport_handle = cpu_to_le16(loop_id);
1851         lg->control_flags =
1852             __constant_cpu_to_le16(LCF_COMMAND_LOGO|LCF_IMPL_LOGO);
1853         lg->port_id[0] = al_pa;
1854         lg->port_id[1] = area;
1855         lg->port_id[2] = domain;
1856         lg->vp_index = vha->vp_idx;
1857
1858         rval = qla2x00_issue_iocb(vha, lg, lg_dma, 0);
1859         if (rval != QLA_SUCCESS) {
1860                 DEBUG2_3_11(printk("%s(%ld): failed to issue Logout IOCB "
1861                     "(%x).\n", __func__, vha->host_no, rval));
1862         } else if (lg->entry_status != 0) {
1863                 DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
1864                     "-- error status (%x).\n", __func__, vha->host_no,
1865                     lg->entry_status));
1866                 rval = QLA_FUNCTION_FAILED;
1867         } else if (lg->comp_status != __constant_cpu_to_le16(CS_COMPLETE)) {
1868                 DEBUG2_3_11(printk("%s(%ld %d): failed to complete IOCB "
1869                     "-- completion status (%x)  ioparam=%x/%x.\n", __func__,
1870                     vha->host_no, vha->vp_idx, le16_to_cpu(lg->comp_status),
1871                     le32_to_cpu(lg->io_parameter[0]),
1872                     le32_to_cpu(lg->io_parameter[1])));
1873         } else {
1874                 /*EMPTY*/
1875                 DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
1876         }
1877
1878         dma_pool_free(ha->s_dma_pool, lg, lg_dma);
1879
1880         return rval;
1881 }
1882
1883 /*
1884  * qla2x00_fabric_logout
1885  *      Issue logout fabric port mailbox command.
1886  *
1887  * Input:
1888  *      ha = adapter block pointer.
1889  *      loop_id = device loop ID.
1890  *      TARGET_QUEUE_LOCK must be released.
1891  *      ADAPTER_STATE_LOCK must be released.
1892  *
1893  * Returns:
1894  *      qla2x00 local function return status code.
1895  *
1896  * Context:
1897  *      Kernel context.
1898  */
1899 int
1900 qla2x00_fabric_logout(scsi_qla_host_t *vha, uint16_t loop_id, uint8_t domain,
1901     uint8_t area, uint8_t al_pa)
1902 {
1903         int rval;
1904         mbx_cmd_t mc;
1905         mbx_cmd_t *mcp = &mc;
1906
1907         DEBUG11(printk("qla2x00_fabric_logout(%ld): entered.\n",
1908             vha->host_no));
1909
1910         mcp->mb[0] = MBC_LOGOUT_FABRIC_PORT;
1911         mcp->out_mb = MBX_1|MBX_0;
1912         if (HAS_EXTENDED_IDS(vha->hw)) {
1913                 mcp->mb[1] = loop_id;
1914                 mcp->mb[10] = 0;
1915                 mcp->out_mb |= MBX_10;
1916         } else {
1917                 mcp->mb[1] = loop_id << 8;
1918         }
1919
1920         mcp->in_mb = MBX_1|MBX_0;
1921         mcp->tov = MBX_TOV_SECONDS;
1922         mcp->flags = 0;
1923         rval = qla2x00_mailbox_command(vha, mcp);
1924
1925         if (rval != QLA_SUCCESS) {
1926                 /*EMPTY*/
1927                 DEBUG2_3_11(printk("qla2x00_fabric_logout(%ld): failed=%x "
1928                     "mbx1=%x.\n", vha->host_no, rval, mcp->mb[1]));
1929         } else {
1930                 /*EMPTY*/
1931                 DEBUG11(printk("qla2x00_fabric_logout(%ld): done.\n",
1932                     vha->host_no));
1933         }
1934
1935         return rval;
1936 }
1937
1938 /*
1939  * qla2x00_full_login_lip
1940  *      Issue full login LIP mailbox command.
1941  *
1942  * Input:
1943  *      ha = adapter block pointer.
1944  *      TARGET_QUEUE_LOCK must be released.
1945  *      ADAPTER_STATE_LOCK must be released.
1946  *
1947  * Returns:
1948  *      qla2x00 local function return status code.
1949  *
1950  * Context:
1951  *      Kernel context.
1952  */
1953 int
1954 qla2x00_full_login_lip(scsi_qla_host_t *vha)
1955 {
1956         int rval;
1957         mbx_cmd_t mc;
1958         mbx_cmd_t *mcp = &mc;
1959
1960         DEBUG11(printk("qla2x00_full_login_lip(%ld): entered.\n",
1961             vha->host_no));
1962
1963         mcp->mb[0] = MBC_LIP_FULL_LOGIN;
1964         mcp->mb[1] = IS_FWI2_CAPABLE(vha->hw) ? BIT_3 : 0;
1965         mcp->mb[2] = 0;
1966         mcp->mb[3] = 0;
1967         mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
1968         mcp->in_mb = MBX_0;
1969         mcp->tov = MBX_TOV_SECONDS;
1970         mcp->flags = 0;
1971         rval = qla2x00_mailbox_command(vha, mcp);
1972
1973         if (rval != QLA_SUCCESS) {
1974                 /*EMPTY*/
1975                 DEBUG2_3_11(printk("qla2x00_full_login_lip(%ld): failed=%x.\n",
1976                     vha->host_no, rval));
1977         } else {
1978                 /*EMPTY*/
1979                 DEBUG11(printk("qla2x00_full_login_lip(%ld): done.\n",
1980                     vha->host_no));
1981         }
1982
1983         return rval;
1984 }
1985
1986 /*
1987  * qla2x00_get_id_list
1988  *
1989  * Input:
1990  *      ha = adapter block pointer.
1991  *
1992  * Returns:
1993  *      qla2x00 local function return status code.
1994  *
1995  * Context:
1996  *      Kernel context.
1997  */
1998 int
1999 qla2x00_get_id_list(scsi_qla_host_t *vha, void *id_list, dma_addr_t id_list_dma,
2000     uint16_t *entries)
2001 {
2002         int rval;
2003         mbx_cmd_t mc;
2004         mbx_cmd_t *mcp = &mc;
2005
2006         DEBUG11(printk("qla2x00_get_id_list(%ld): entered.\n",
2007             vha->host_no));
2008
2009         if (id_list == NULL)
2010                 return QLA_FUNCTION_FAILED;
2011
2012         mcp->mb[0] = MBC_GET_ID_LIST;
2013         mcp->out_mb = MBX_0;
2014         if (IS_FWI2_CAPABLE(vha->hw)) {
2015                 mcp->mb[2] = MSW(id_list_dma);
2016                 mcp->mb[3] = LSW(id_list_dma);
2017                 mcp->mb[6] = MSW(MSD(id_list_dma));
2018                 mcp->mb[7] = LSW(MSD(id_list_dma));
2019                 mcp->mb[8] = 0;
2020                 mcp->mb[9] = vha->vp_idx;
2021                 mcp->out_mb |= MBX_9|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2;
2022         } else {
2023                 mcp->mb[1] = MSW(id_list_dma);
2024                 mcp->mb[2] = LSW(id_list_dma);
2025                 mcp->mb[3] = MSW(MSD(id_list_dma));
2026                 mcp->mb[6] = LSW(MSD(id_list_dma));
2027                 mcp->out_mb |= MBX_6|MBX_3|MBX_2|MBX_1;
2028         }
2029         mcp->in_mb = MBX_1|MBX_0;
2030         mcp->tov = MBX_TOV_SECONDS;
2031         mcp->flags = 0;
2032         rval = qla2x00_mailbox_command(vha, mcp);
2033
2034         if (rval != QLA_SUCCESS) {
2035                 /*EMPTY*/
2036                 DEBUG2_3_11(printk("qla2x00_get_id_list(%ld): failed=%x.\n",
2037                     vha->host_no, rval));
2038         } else {
2039                 *entries = mcp->mb[1];
2040                 DEBUG11(printk("qla2x00_get_id_list(%ld): done.\n",
2041                     vha->host_no));
2042         }
2043
2044         return rval;
2045 }
2046
2047 /*
2048  * qla2x00_get_resource_cnts
2049  *      Get current firmware resource counts.
2050  *
2051  * Input:
2052  *      ha = adapter block pointer.
2053  *
2054  * Returns:
2055  *      qla2x00 local function return status code.
2056  *
2057  * Context:
2058  *      Kernel context.
2059  */
2060 int
2061 qla2x00_get_resource_cnts(scsi_qla_host_t *vha, uint16_t *cur_xchg_cnt,
2062     uint16_t *orig_xchg_cnt, uint16_t *cur_iocb_cnt,
2063     uint16_t *orig_iocb_cnt, uint16_t *max_npiv_vports, uint16_t *max_fcfs)
2064 {
2065         int rval;
2066         mbx_cmd_t mc;
2067         mbx_cmd_t *mcp = &mc;
2068
2069         DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
2070
2071         mcp->mb[0] = MBC_GET_RESOURCE_COUNTS;
2072         mcp->out_mb = MBX_0;
2073         mcp->in_mb = MBX_11|MBX_10|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
2074         if (IS_QLA81XX(vha->hw))
2075                 mcp->in_mb |= MBX_12;
2076         mcp->tov = MBX_TOV_SECONDS;
2077         mcp->flags = 0;
2078         rval = qla2x00_mailbox_command(vha, mcp);
2079
2080         if (rval != QLA_SUCCESS) {
2081                 /*EMPTY*/
2082                 DEBUG2_3_11(printk("%s(%ld): failed = %x.\n", __func__,
2083                     vha->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 mb11=%x mb12=%x.\n", __func__,
2087                     vha->host_no, mcp->mb[1], mcp->mb[2], mcp->mb[3],
2088                     mcp->mb[6], mcp->mb[7], mcp->mb[10], mcp->mb[11],
2089                     mcp->mb[12]));
2090
2091                 if (cur_xchg_cnt)
2092                         *cur_xchg_cnt = mcp->mb[3];
2093                 if (orig_xchg_cnt)
2094                         *orig_xchg_cnt = mcp->mb[6];
2095                 if (cur_iocb_cnt)
2096                         *cur_iocb_cnt = mcp->mb[7];
2097                 if (orig_iocb_cnt)
2098                         *orig_iocb_cnt = mcp->mb[10];
2099                 if (vha->hw->flags.npiv_supported && max_npiv_vports)
2100                         *max_npiv_vports = mcp->mb[11];
2101                 if (IS_QLA81XX(vha->hw) && max_fcfs)
2102                         *max_fcfs = mcp->mb[12];
2103         }
2104
2105         return (rval);
2106 }
2107
2108 #if defined(QL_DEBUG_LEVEL_3)
2109 /*
2110  * qla2x00_get_fcal_position_map
2111  *      Get FCAL (LILP) position map using mailbox command
2112  *
2113  * Input:
2114  *      ha = adapter state pointer.
2115  *      pos_map = buffer pointer (can be NULL).
2116  *
2117  * Returns:
2118  *      qla2x00 local function return status code.
2119  *
2120  * Context:
2121  *      Kernel context.
2122  */
2123 int
2124 qla2x00_get_fcal_position_map(scsi_qla_host_t *vha, char *pos_map)
2125 {
2126         int rval;
2127         mbx_cmd_t mc;
2128         mbx_cmd_t *mcp = &mc;
2129         char *pmap;
2130         dma_addr_t pmap_dma;
2131         struct qla_hw_data *ha = vha->hw;
2132
2133         pmap = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &pmap_dma);
2134         if (pmap  == NULL) {
2135                 DEBUG2_3_11(printk("%s(%ld): **** Mem Alloc Failed ****",
2136                     __func__, vha->host_no));
2137                 return QLA_MEMORY_ALLOC_FAILED;
2138         }
2139         memset(pmap, 0, FCAL_MAP_SIZE);
2140
2141         mcp->mb[0] = MBC_GET_FC_AL_POSITION_MAP;
2142         mcp->mb[2] = MSW(pmap_dma);
2143         mcp->mb[3] = LSW(pmap_dma);
2144         mcp->mb[6] = MSW(MSD(pmap_dma));
2145         mcp->mb[7] = LSW(MSD(pmap_dma));
2146         mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_0;
2147         mcp->in_mb = MBX_1|MBX_0;
2148         mcp->buf_size = FCAL_MAP_SIZE;
2149         mcp->flags = MBX_DMA_IN;
2150         mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2);
2151         rval = qla2x00_mailbox_command(vha, mcp);
2152
2153         if (rval == QLA_SUCCESS) {
2154                 DEBUG11(printk("%s(%ld): (mb0=%x/mb1=%x) FC/AL Position Map "
2155                     "size (%x)\n", __func__, vha->host_no, mcp->mb[0],
2156                     mcp->mb[1], (unsigned)pmap[0]));
2157                 DEBUG11(qla2x00_dump_buffer(pmap, pmap[0] + 1));
2158
2159                 if (pos_map)
2160                         memcpy(pos_map, pmap, FCAL_MAP_SIZE);
2161         }
2162         dma_pool_free(ha->s_dma_pool, pmap, pmap_dma);
2163
2164         if (rval != QLA_SUCCESS) {
2165                 DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
2166                     vha->host_no, rval));
2167         } else {
2168                 DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
2169         }
2170
2171         return rval;
2172 }
2173 #endif
2174
2175 /*
2176  * qla2x00_get_link_status
2177  *
2178  * Input:
2179  *      ha = adapter block pointer.
2180  *      loop_id = device loop ID.
2181  *      ret_buf = pointer to link status return buffer.
2182  *
2183  * Returns:
2184  *      0 = success.
2185  *      BIT_0 = mem alloc error.
2186  *      BIT_1 = mailbox error.
2187  */
2188 int
2189 qla2x00_get_link_status(scsi_qla_host_t *vha, uint16_t loop_id,
2190     struct link_statistics *stats, dma_addr_t stats_dma)
2191 {
2192         int rval;
2193         mbx_cmd_t mc;
2194         mbx_cmd_t *mcp = &mc;
2195         uint32_t *siter, *diter, dwords;
2196         struct qla_hw_data *ha = vha->hw;
2197
2198         DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
2199
2200         mcp->mb[0] = MBC_GET_LINK_STATUS;
2201         mcp->mb[2] = MSW(stats_dma);
2202         mcp->mb[3] = LSW(stats_dma);
2203         mcp->mb[6] = MSW(MSD(stats_dma));
2204         mcp->mb[7] = LSW(MSD(stats_dma));
2205         mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_0;
2206         mcp->in_mb = MBX_0;
2207         if (IS_FWI2_CAPABLE(ha)) {
2208                 mcp->mb[1] = loop_id;
2209                 mcp->mb[4] = 0;
2210                 mcp->mb[10] = 0;
2211                 mcp->out_mb |= MBX_10|MBX_4|MBX_1;
2212                 mcp->in_mb |= MBX_1;
2213         } else if (HAS_EXTENDED_IDS(ha)) {
2214                 mcp->mb[1] = loop_id;
2215                 mcp->mb[10] = 0;
2216                 mcp->out_mb |= MBX_10|MBX_1;
2217         } else {
2218                 mcp->mb[1] = loop_id << 8;
2219                 mcp->out_mb |= MBX_1;
2220         }
2221         mcp->tov = MBX_TOV_SECONDS;
2222         mcp->flags = IOCTL_CMD;
2223         rval = qla2x00_mailbox_command(vha, mcp);
2224
2225         if (rval == QLA_SUCCESS) {
2226                 if (mcp->mb[0] != MBS_COMMAND_COMPLETE) {
2227                         DEBUG2_3_11(printk("%s(%ld): cmd failed. mbx0=%x.\n",
2228                             __func__, vha->host_no, mcp->mb[0]));
2229                         rval = QLA_FUNCTION_FAILED;
2230                 } else {
2231                         /* Copy over data -- firmware data is LE. */
2232                         dwords = offsetof(struct link_statistics, unused1) / 4;
2233                         siter = diter = &stats->link_fail_cnt;
2234                         while (dwords--)
2235                                 *diter++ = le32_to_cpu(*siter++);
2236                 }
2237         } else {
2238                 /* Failed. */
2239                 DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
2240                     vha->host_no, rval));
2241         }
2242
2243         return rval;
2244 }
2245
2246 int
2247 qla24xx_get_isp_stats(scsi_qla_host_t *vha, struct link_statistics *stats,
2248     dma_addr_t stats_dma)
2249 {
2250         int rval;
2251         mbx_cmd_t mc;
2252         mbx_cmd_t *mcp = &mc;
2253         uint32_t *siter, *diter, dwords;
2254
2255         DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
2256
2257         mcp->mb[0] = MBC_GET_LINK_PRIV_STATS;
2258         mcp->mb[2] = MSW(stats_dma);
2259         mcp->mb[3] = LSW(stats_dma);
2260         mcp->mb[6] = MSW(MSD(stats_dma));
2261         mcp->mb[7] = LSW(MSD(stats_dma));
2262         mcp->mb[8] = sizeof(struct link_statistics) / 4;
2263         mcp->mb[9] = vha->vp_idx;
2264         mcp->mb[10] = 0;
2265         mcp->out_mb = MBX_10|MBX_9|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_0;
2266         mcp->in_mb = MBX_2|MBX_1|MBX_0;
2267         mcp->tov = MBX_TOV_SECONDS;
2268         mcp->flags = IOCTL_CMD;
2269         rval = qla2x00_mailbox_command(vha, mcp);
2270
2271         if (rval == QLA_SUCCESS) {
2272                 if (mcp->mb[0] != MBS_COMMAND_COMPLETE) {
2273                         DEBUG2_3_11(printk("%s(%ld): cmd failed. mbx0=%x.\n",
2274                             __func__, vha->host_no, mcp->mb[0]));
2275                         rval = QLA_FUNCTION_FAILED;
2276                 } else {
2277                         /* Copy over data -- firmware data is LE. */
2278                         dwords = sizeof(struct link_statistics) / 4;
2279                         siter = diter = &stats->link_fail_cnt;
2280                         while (dwords--)
2281                                 *diter++ = le32_to_cpu(*siter++);
2282                 }
2283         } else {
2284                 /* Failed. */
2285                 DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
2286                     vha->host_no, rval));
2287         }
2288
2289         return rval;
2290 }
2291
2292 int
2293 qla24xx_abort_command(srb_t *sp)
2294 {
2295         int             rval;
2296         unsigned long   flags = 0;
2297
2298         struct abort_entry_24xx *abt;
2299         dma_addr_t      abt_dma;
2300         uint32_t        handle;
2301         fc_port_t       *fcport = sp->fcport;
2302         struct scsi_qla_host *vha = fcport->vha;
2303         struct qla_hw_data *ha = vha->hw;
2304         struct req_que *req = vha->req;
2305
2306         DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
2307
2308         spin_lock_irqsave(&ha->hardware_lock, flags);
2309         for (handle = 1; handle < MAX_OUTSTANDING_COMMANDS; handle++) {
2310                 if (req->outstanding_cmds[handle] == sp)
2311                         break;
2312         }
2313         spin_unlock_irqrestore(&ha->hardware_lock, flags);
2314         if (handle == MAX_OUTSTANDING_COMMANDS) {
2315                 /* Command not found. */
2316                 return QLA_FUNCTION_FAILED;
2317         }
2318
2319         abt = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &abt_dma);
2320         if (abt == NULL) {
2321                 DEBUG2_3(printk("%s(%ld): failed to allocate Abort IOCB.\n",
2322                     __func__, vha->host_no));
2323                 return QLA_MEMORY_ALLOC_FAILED;
2324         }
2325         memset(abt, 0, sizeof(struct abort_entry_24xx));
2326
2327         abt->entry_type = ABORT_IOCB_TYPE;
2328         abt->entry_count = 1;
2329         abt->handle = MAKE_HANDLE(req->id, abt->handle);
2330         abt->nport_handle = cpu_to_le16(fcport->loop_id);
2331         abt->handle_to_abort = handle;
2332         abt->port_id[0] = fcport->d_id.b.al_pa;
2333         abt->port_id[1] = fcport->d_id.b.area;
2334         abt->port_id[2] = fcport->d_id.b.domain;
2335         abt->vp_index = fcport->vp_idx;
2336
2337         abt->req_que_no = cpu_to_le16(req->id);
2338
2339         rval = qla2x00_issue_iocb(vha, abt, abt_dma, 0);
2340         if (rval != QLA_SUCCESS) {
2341                 DEBUG2_3_11(printk("%s(%ld): failed to issue IOCB (%x).\n",
2342                     __func__, vha->host_no, rval));
2343         } else if (abt->entry_status != 0) {
2344                 DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
2345                     "-- error status (%x).\n", __func__, vha->host_no,
2346                     abt->entry_status));
2347                 rval = QLA_FUNCTION_FAILED;
2348         } else if (abt->nport_handle != __constant_cpu_to_le16(0)) {
2349                 DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
2350                     "-- completion status (%x).\n", __func__, vha->host_no,
2351                     le16_to_cpu(abt->nport_handle)));
2352                 rval = QLA_FUNCTION_FAILED;
2353         } else {
2354                 DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
2355         }
2356
2357         dma_pool_free(ha->s_dma_pool, abt, abt_dma);
2358
2359         return rval;
2360 }
2361
2362 struct tsk_mgmt_cmd {
2363         union {
2364                 struct tsk_mgmt_entry tsk;
2365                 struct sts_entry_24xx sts;
2366         } p;
2367 };
2368
2369 static int
2370 __qla24xx_issue_tmf(char *name, uint32_t type, struct fc_port *fcport,
2371     unsigned int l, int tag)
2372 {
2373         int             rval, rval2;
2374         struct tsk_mgmt_cmd *tsk;
2375         struct sts_entry_24xx *sts;
2376         dma_addr_t      tsk_dma;
2377         scsi_qla_host_t *vha;
2378         struct qla_hw_data *ha;
2379         struct req_que *req;
2380         struct rsp_que *rsp;
2381
2382         DEBUG11(printk("%s(%ld): entered.\n", __func__, fcport->vha->host_no));
2383
2384         vha = fcport->vha;
2385         ha = vha->hw;
2386         req = vha->req;
2387         if (ha->flags.cpu_affinity_enabled)
2388                 rsp = ha->rsp_q_map[tag + 1];
2389         else
2390                 rsp = req->rsp;
2391         tsk = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &tsk_dma);
2392         if (tsk == NULL) {
2393                 DEBUG2_3(printk("%s(%ld): failed to allocate Task Management "
2394                     "IOCB.\n", __func__, vha->host_no));
2395                 return QLA_MEMORY_ALLOC_FAILED;
2396         }
2397         memset(tsk, 0, sizeof(struct tsk_mgmt_cmd));
2398
2399         tsk->p.tsk.entry_type = TSK_MGMT_IOCB_TYPE;
2400         tsk->p.tsk.entry_count = 1;
2401         tsk->p.tsk.handle = MAKE_HANDLE(req->id, tsk->p.tsk.handle);
2402         tsk->p.tsk.nport_handle = cpu_to_le16(fcport->loop_id);
2403         tsk->p.tsk.timeout = cpu_to_le16(ha->r_a_tov / 10 * 2);
2404         tsk->p.tsk.control_flags = cpu_to_le32(type);
2405         tsk->p.tsk.port_id[0] = fcport->d_id.b.al_pa;
2406         tsk->p.tsk.port_id[1] = fcport->d_id.b.area;
2407         tsk->p.tsk.port_id[2] = fcport->d_id.b.domain;
2408         tsk->p.tsk.vp_index = fcport->vp_idx;
2409         if (type == TCF_LUN_RESET) {
2410                 int_to_scsilun(l, &tsk->p.tsk.lun);
2411                 host_to_fcp_swap((uint8_t *)&tsk->p.tsk.lun,
2412                     sizeof(tsk->p.tsk.lun));
2413         }
2414
2415         sts = &tsk->p.sts;
2416         rval = qla2x00_issue_iocb(vha, tsk, tsk_dma, 0);
2417         if (rval != QLA_SUCCESS) {
2418                 DEBUG2_3_11(printk("%s(%ld): failed to issue %s Reset IOCB "
2419                     "(%x).\n", __func__, vha->host_no, name, rval));
2420         } else if (sts->entry_status != 0) {
2421                 DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
2422                     "-- error status (%x).\n", __func__, vha->host_no,
2423                     sts->entry_status));
2424                 rval = QLA_FUNCTION_FAILED;
2425         } else if (sts->comp_status !=
2426             __constant_cpu_to_le16(CS_COMPLETE)) {
2427                 DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
2428                     "-- completion status (%x).\n", __func__,
2429                     vha->host_no, le16_to_cpu(sts->comp_status)));
2430                 rval = QLA_FUNCTION_FAILED;
2431         } else if (!(le16_to_cpu(sts->scsi_status) &
2432             SS_RESPONSE_INFO_LEN_VALID)) {
2433                 DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
2434                     "-- no response info (%x).\n", __func__, vha->host_no,
2435                     le16_to_cpu(sts->scsi_status)));
2436                 rval = QLA_FUNCTION_FAILED;
2437         } else if (le32_to_cpu(sts->rsp_data_len) < 4) {
2438                 DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
2439                     "-- not enough response info (%d).\n", __func__,
2440                     vha->host_no, le32_to_cpu(sts->rsp_data_len)));
2441                 rval = QLA_FUNCTION_FAILED;
2442         } else if (sts->data[3]) {
2443                 DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
2444                     "-- response (%x).\n", __func__,
2445                     vha->host_no, sts->data[3]));
2446                 rval = QLA_FUNCTION_FAILED;
2447         }
2448
2449         /* Issue marker IOCB. */
2450         rval2 = qla2x00_marker(vha, req, rsp, fcport->loop_id, l,
2451             type == TCF_LUN_RESET ? MK_SYNC_ID_LUN: MK_SYNC_ID);
2452         if (rval2 != QLA_SUCCESS) {
2453                 DEBUG2_3_11(printk("%s(%ld): failed to issue Marker IOCB "
2454                     "(%x).\n", __func__, vha->host_no, rval2));
2455         } else {
2456                 DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
2457         }
2458
2459         dma_pool_free(ha->s_dma_pool, tsk, tsk_dma);
2460
2461         return rval;
2462 }
2463
2464 int
2465 qla24xx_abort_target(struct fc_port *fcport, unsigned int l, int tag)
2466 {
2467         struct qla_hw_data *ha = fcport->vha->hw;
2468
2469         if ((ql2xasynctmfenable) && IS_FWI2_CAPABLE(ha))
2470                 return qla2x00_async_tm_cmd(fcport, TCF_TARGET_RESET, l, tag);
2471
2472         return __qla24xx_issue_tmf("Target", TCF_TARGET_RESET, fcport, l, tag);
2473 }
2474
2475 int
2476 qla24xx_lun_reset(struct fc_port *fcport, unsigned int l, int tag)
2477 {
2478         struct qla_hw_data *ha = fcport->vha->hw;
2479
2480         if ((ql2xasynctmfenable) && IS_FWI2_CAPABLE(ha))
2481                 return qla2x00_async_tm_cmd(fcport, TCF_LUN_RESET, l, tag);
2482
2483         return __qla24xx_issue_tmf("Lun", TCF_LUN_RESET, fcport, l, tag);
2484 }
2485
2486 int
2487 qla2x00_system_error(scsi_qla_host_t *vha)
2488 {
2489         int rval;
2490         mbx_cmd_t mc;
2491         mbx_cmd_t *mcp = &mc;
2492         struct qla_hw_data *ha = vha->hw;
2493
2494         if (!IS_QLA23XX(ha) && !IS_FWI2_CAPABLE(ha))
2495                 return QLA_FUNCTION_FAILED;
2496
2497         DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
2498
2499         mcp->mb[0] = MBC_GEN_SYSTEM_ERROR;
2500         mcp->out_mb = MBX_0;
2501         mcp->in_mb = MBX_0;
2502         mcp->tov = 5;
2503         mcp->flags = 0;
2504         rval = qla2x00_mailbox_command(vha, mcp);
2505
2506         if (rval != QLA_SUCCESS) {
2507                 DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
2508                     vha->host_no, rval));
2509         } else {
2510                 DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
2511         }
2512
2513         return rval;
2514 }
2515
2516 /**
2517  * qla2x00_set_serdes_params() -
2518  * @ha: HA context
2519  *
2520  * Returns
2521  */
2522 int
2523 qla2x00_set_serdes_params(scsi_qla_host_t *vha, uint16_t sw_em_1g,
2524     uint16_t sw_em_2g, uint16_t sw_em_4g)
2525 {
2526         int rval;
2527         mbx_cmd_t mc;
2528         mbx_cmd_t *mcp = &mc;
2529
2530         DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
2531
2532         mcp->mb[0] = MBC_SERDES_PARAMS;
2533         mcp->mb[1] = BIT_0;
2534         mcp->mb[2] = sw_em_1g | BIT_15;
2535         mcp->mb[3] = sw_em_2g | BIT_15;
2536         mcp->mb[4] = sw_em_4g | BIT_15;
2537         mcp->out_mb = MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
2538         mcp->in_mb = MBX_0;
2539         mcp->tov = MBX_TOV_SECONDS;
2540         mcp->flags = 0;
2541         rval = qla2x00_mailbox_command(vha, mcp);
2542
2543         if (rval != QLA_SUCCESS) {
2544                 /*EMPTY*/
2545                 DEBUG2_3_11(printk("%s(%ld): failed=%x (%x).\n", __func__,
2546                     vha->host_no, rval, mcp->mb[0]));
2547         } else {
2548                 /*EMPTY*/
2549                 DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
2550         }
2551
2552         return rval;
2553 }
2554
2555 int
2556 qla2x00_stop_firmware(scsi_qla_host_t *vha)
2557 {
2558         int rval;
2559         mbx_cmd_t mc;
2560         mbx_cmd_t *mcp = &mc;
2561
2562         if (!IS_FWI2_CAPABLE(vha->hw))
2563                 return QLA_FUNCTION_FAILED;
2564
2565         DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
2566
2567         mcp->mb[0] = MBC_STOP_FIRMWARE;
2568         mcp->out_mb = MBX_0;
2569         mcp->in_mb = MBX_0;
2570         mcp->tov = 5;
2571         mcp->flags = 0;
2572         rval = qla2x00_mailbox_command(vha, mcp);
2573
2574         if (rval != QLA_SUCCESS) {
2575                 DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
2576                     vha->host_no, rval));
2577                 if (mcp->mb[0] == MBS_INVALID_COMMAND)
2578                         rval = QLA_INVALID_COMMAND;
2579         } else {
2580                 DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
2581         }
2582
2583         return rval;
2584 }
2585
2586 int
2587 qla2x00_enable_eft_trace(scsi_qla_host_t *vha, dma_addr_t eft_dma,
2588     uint16_t buffers)
2589 {
2590         int rval;
2591         mbx_cmd_t mc;
2592         mbx_cmd_t *mcp = &mc;
2593
2594         if (!IS_FWI2_CAPABLE(vha->hw))
2595                 return QLA_FUNCTION_FAILED;
2596
2597         if (unlikely(pci_channel_offline(vha->hw->pdev)))
2598                 return QLA_FUNCTION_FAILED;
2599
2600         DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
2601
2602         mcp->mb[0] = MBC_TRACE_CONTROL;
2603         mcp->mb[1] = TC_EFT_ENABLE;
2604         mcp->mb[2] = LSW(eft_dma);
2605         mcp->mb[3] = MSW(eft_dma);
2606         mcp->mb[4] = LSW(MSD(eft_dma));
2607         mcp->mb[5] = MSW(MSD(eft_dma));
2608         mcp->mb[6] = buffers;
2609         mcp->mb[7] = TC_AEN_DISABLE;
2610         mcp->out_mb = MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
2611         mcp->in_mb = MBX_1|MBX_0;
2612         mcp->tov = MBX_TOV_SECONDS;
2613         mcp->flags = 0;
2614         rval = qla2x00_mailbox_command(vha, mcp);
2615         if (rval != QLA_SUCCESS) {
2616                 DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x mb[1]=%x.\n",
2617                     __func__, vha->host_no, rval, mcp->mb[0], mcp->mb[1]));
2618         } else {
2619                 DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
2620         }
2621
2622         return rval;
2623 }
2624
2625 int
2626 qla2x00_disable_eft_trace(scsi_qla_host_t *vha)
2627 {
2628         int rval;
2629         mbx_cmd_t mc;
2630         mbx_cmd_t *mcp = &mc;
2631
2632         if (!IS_FWI2_CAPABLE(vha->hw))
2633                 return QLA_FUNCTION_FAILED;
2634
2635         if (unlikely(pci_channel_offline(vha->hw->pdev)))
2636                 return QLA_FUNCTION_FAILED;
2637
2638         DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
2639
2640         mcp->mb[0] = MBC_TRACE_CONTROL;
2641         mcp->mb[1] = TC_EFT_DISABLE;
2642         mcp->out_mb = MBX_1|MBX_0;
2643         mcp->in_mb = MBX_1|MBX_0;
2644         mcp->tov = MBX_TOV_SECONDS;
2645         mcp->flags = 0;
2646         rval = qla2x00_mailbox_command(vha, mcp);
2647         if (rval != QLA_SUCCESS) {
2648                 DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x mb[1]=%x.\n",
2649                     __func__, vha->host_no, rval, mcp->mb[0], mcp->mb[1]));
2650         } else {
2651                 DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
2652         }
2653
2654         return rval;
2655 }
2656
2657 int
2658 qla2x00_enable_fce_trace(scsi_qla_host_t *vha, dma_addr_t fce_dma,
2659     uint16_t buffers, uint16_t *mb, uint32_t *dwords)
2660 {
2661         int rval;
2662         mbx_cmd_t mc;
2663         mbx_cmd_t *mcp = &mc;
2664
2665         if (!IS_QLA25XX(vha->hw) && !IS_QLA81XX(vha->hw))
2666                 return QLA_FUNCTION_FAILED;
2667
2668         if (unlikely(pci_channel_offline(vha->hw->pdev)))
2669                 return QLA_FUNCTION_FAILED;
2670
2671         DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
2672
2673         mcp->mb[0] = MBC_TRACE_CONTROL;
2674         mcp->mb[1] = TC_FCE_ENABLE;
2675         mcp->mb[2] = LSW(fce_dma);
2676         mcp->mb[3] = MSW(fce_dma);
2677         mcp->mb[4] = LSW(MSD(fce_dma));
2678         mcp->mb[5] = MSW(MSD(fce_dma));
2679         mcp->mb[6] = buffers;
2680         mcp->mb[7] = TC_AEN_DISABLE;
2681         mcp->mb[8] = 0;
2682         mcp->mb[9] = TC_FCE_DEFAULT_RX_SIZE;
2683         mcp->mb[10] = TC_FCE_DEFAULT_TX_SIZE;
2684         mcp->out_mb = MBX_10|MBX_9|MBX_8|MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|
2685             MBX_1|MBX_0;
2686         mcp->in_mb = MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
2687         mcp->tov = MBX_TOV_SECONDS;
2688         mcp->flags = 0;
2689         rval = qla2x00_mailbox_command(vha, mcp);
2690         if (rval != QLA_SUCCESS) {
2691                 DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x mb[1]=%x.\n",
2692                     __func__, vha->host_no, rval, mcp->mb[0], mcp->mb[1]));
2693         } else {
2694                 DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
2695
2696                 if (mb)
2697                         memcpy(mb, mcp->mb, 8 * sizeof(*mb));
2698                 if (dwords)
2699                         *dwords = buffers;
2700         }
2701
2702         return rval;
2703 }
2704
2705 int
2706 qla2x00_disable_fce_trace(scsi_qla_host_t *vha, uint64_t *wr, uint64_t *rd)
2707 {
2708         int rval;
2709         mbx_cmd_t mc;
2710         mbx_cmd_t *mcp = &mc;
2711
2712         if (!IS_FWI2_CAPABLE(vha->hw))
2713                 return QLA_FUNCTION_FAILED;
2714
2715         if (unlikely(pci_channel_offline(vha->hw->pdev)))
2716                 return QLA_FUNCTION_FAILED;
2717
2718         DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
2719
2720         mcp->mb[0] = MBC_TRACE_CONTROL;
2721         mcp->mb[1] = TC_FCE_DISABLE;
2722         mcp->mb[2] = TC_FCE_DISABLE_TRACE;
2723         mcp->out_mb = MBX_2|MBX_1|MBX_0;
2724         mcp->in_mb = MBX_9|MBX_8|MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|
2725             MBX_1|MBX_0;
2726         mcp->tov = MBX_TOV_SECONDS;
2727         mcp->flags = 0;
2728         rval = qla2x00_mailbox_command(vha, mcp);
2729         if (rval != QLA_SUCCESS) {
2730                 DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x mb[1]=%x.\n",
2731                     __func__, vha->host_no, rval, mcp->mb[0], mcp->mb[1]));
2732         } else {
2733                 DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
2734
2735                 if (wr)
2736                         *wr = (uint64_t) mcp->mb[5] << 48 |
2737                             (uint64_t) mcp->mb[4] << 32 |
2738                             (uint64_t) mcp->mb[3] << 16 |
2739                             (uint64_t) mcp->mb[2];
2740                 if (rd)
2741                         *rd = (uint64_t) mcp->mb[9] << 48 |
2742                             (uint64_t) mcp->mb[8] << 32 |
2743                             (uint64_t) mcp->mb[7] << 16 |
2744                             (uint64_t) mcp->mb[6];
2745         }
2746
2747         return rval;
2748 }
2749
2750 int
2751 qla2x00_read_sfp(scsi_qla_host_t *vha, dma_addr_t sfp_dma, uint16_t addr,
2752     uint16_t off, uint16_t count)
2753 {
2754         int rval;
2755         mbx_cmd_t mc;
2756         mbx_cmd_t *mcp = &mc;
2757
2758         if (!IS_FWI2_CAPABLE(vha->hw))
2759                 return QLA_FUNCTION_FAILED;
2760
2761         DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
2762
2763         mcp->mb[0] = MBC_READ_SFP;
2764         mcp->mb[1] = addr;
2765         mcp->mb[2] = MSW(sfp_dma);
2766         mcp->mb[3] = LSW(sfp_dma);
2767         mcp->mb[6] = MSW(MSD(sfp_dma));
2768         mcp->mb[7] = LSW(MSD(sfp_dma));
2769         mcp->mb[8] = count;
2770         mcp->mb[9] = off;
2771         mcp->mb[10] = 0;
2772         mcp->out_mb = MBX_10|MBX_9|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
2773         mcp->in_mb = MBX_0;
2774         mcp->tov = MBX_TOV_SECONDS;
2775         mcp->flags = 0;
2776         rval = qla2x00_mailbox_command(vha, mcp);
2777
2778         if (rval != QLA_SUCCESS) {
2779                 DEBUG2_3_11(printk("%s(%ld): failed=%x (%x).\n", __func__,
2780                     vha->host_no, rval, mcp->mb[0]));
2781         } else {
2782                 DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
2783         }
2784
2785         return rval;
2786 }
2787
2788 int
2789 qla2x00_get_idma_speed(scsi_qla_host_t *vha, uint16_t loop_id,
2790         uint16_t *port_speed, uint16_t *mb)
2791 {
2792         int rval;
2793         mbx_cmd_t mc;
2794         mbx_cmd_t *mcp = &mc;
2795
2796         if (!IS_IIDMA_CAPABLE(vha->hw))
2797                 return QLA_FUNCTION_FAILED;
2798
2799         DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
2800
2801         mcp->mb[0] = MBC_PORT_PARAMS;
2802         mcp->mb[1] = loop_id;
2803         mcp->mb[2] = mcp->mb[3] = 0;
2804         mcp->mb[9] = vha->vp_idx;
2805         mcp->out_mb = MBX_9|MBX_3|MBX_2|MBX_1|MBX_0;
2806         mcp->in_mb = MBX_3|MBX_1|MBX_0;
2807         mcp->tov = MBX_TOV_SECONDS;
2808         mcp->flags = 0;
2809         rval = qla2x00_mailbox_command(vha, mcp);
2810
2811         /* Return mailbox statuses. */
2812         if (mb != NULL) {
2813                 mb[0] = mcp->mb[0];
2814                 mb[1] = mcp->mb[1];
2815                 mb[3] = mcp->mb[3];
2816         }
2817
2818         if (rval != QLA_SUCCESS) {
2819                 DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
2820                     vha->host_no, rval));
2821         } else {
2822                 DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
2823                 if (port_speed)
2824                         *port_speed = mcp->mb[3];
2825         }
2826
2827         return rval;
2828 }
2829
2830 int
2831 qla2x00_set_idma_speed(scsi_qla_host_t *vha, uint16_t loop_id,
2832     uint16_t port_speed, uint16_t *mb)
2833 {
2834         int rval;
2835         mbx_cmd_t mc;
2836         mbx_cmd_t *mcp = &mc;
2837
2838         if (!IS_IIDMA_CAPABLE(vha->hw))
2839                 return QLA_FUNCTION_FAILED;
2840
2841         DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
2842
2843         mcp->mb[0] = MBC_PORT_PARAMS;
2844         mcp->mb[1] = loop_id;
2845         mcp->mb[2] = BIT_0;
2846         if (IS_QLA8XXX_TYPE(vha->hw))
2847                 mcp->mb[3] = port_speed & (BIT_5|BIT_4|BIT_3|BIT_2|BIT_1|BIT_0);
2848         else
2849                 mcp->mb[3] = port_speed & (BIT_2|BIT_1|BIT_0);
2850         mcp->mb[9] = vha->vp_idx;
2851         mcp->out_mb = MBX_9|MBX_3|MBX_2|MBX_1|MBX_0;
2852         mcp->in_mb = MBX_3|MBX_1|MBX_0;
2853         mcp->tov = MBX_TOV_SECONDS;
2854         mcp->flags = 0;
2855         rval = qla2x00_mailbox_command(vha, mcp);
2856
2857         /* Return mailbox statuses. */
2858         if (mb != NULL) {
2859                 mb[0] = mcp->mb[0];
2860                 mb[1] = mcp->mb[1];
2861                 mb[3] = mcp->mb[3];
2862         }
2863
2864         if (rval != QLA_SUCCESS) {
2865                 DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
2866                     vha->host_no, rval));
2867         } else {
2868                 DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
2869         }
2870
2871         return rval;
2872 }
2873
2874 void
2875 qla24xx_report_id_acquisition(scsi_qla_host_t *vha,
2876         struct vp_rpt_id_entry_24xx *rptid_entry)
2877 {
2878         uint8_t vp_idx;
2879         uint16_t stat = le16_to_cpu(rptid_entry->vp_idx);
2880         struct qla_hw_data *ha = vha->hw;
2881         scsi_qla_host_t *vp;
2882         scsi_qla_host_t *tvp;
2883
2884         if (rptid_entry->entry_status != 0)
2885                 return;
2886
2887         if (rptid_entry->format == 0) {
2888                 DEBUG15(printk("%s:format 0 : scsi(%ld) number of VPs setup %d,"
2889                         " number of VPs acquired %d\n", __func__, vha->host_no,
2890                         MSB(le16_to_cpu(rptid_entry->vp_count)),
2891                         LSB(le16_to_cpu(rptid_entry->vp_count))));
2892                 DEBUG15(printk("%s primary port id %02x%02x%02x\n", __func__,
2893                         rptid_entry->port_id[2], rptid_entry->port_id[1],
2894                         rptid_entry->port_id[0]));
2895         } else if (rptid_entry->format == 1) {
2896                 vp_idx = LSB(stat);
2897                 DEBUG15(printk("%s:format 1: scsi(%ld): VP[%d] enabled "
2898                     "- status %d - "
2899                     "with port id %02x%02x%02x\n", __func__, vha->host_no,
2900                     vp_idx, MSB(stat),
2901                     rptid_entry->port_id[2], rptid_entry->port_id[1],
2902                     rptid_entry->port_id[0]));
2903
2904                 vp = vha;
2905                 if (vp_idx == 0 && (MSB(stat) != 1))
2906                         goto reg_needed;
2907
2908                 if (MSB(stat) == 1) {
2909                         DEBUG2(printk("scsi(%ld): Could not acquire ID for "
2910                             "VP[%d].\n", vha->host_no, vp_idx));
2911                         return;
2912                 }
2913
2914                 list_for_each_entry_safe(vp, tvp, &ha->vp_list, list)
2915                         if (vp_idx == vp->vp_idx)
2916                                 break;
2917                 if (!vp)
2918                         return;
2919
2920                 vp->d_id.b.domain = rptid_entry->port_id[2];
2921                 vp->d_id.b.area =  rptid_entry->port_id[1];
2922                 vp->d_id.b.al_pa = rptid_entry->port_id[0];
2923
2924                 /*
2925                  * Cannot configure here as we are still sitting on the
2926                  * response queue. Handle it in dpc context.
2927                  */
2928                 set_bit(VP_IDX_ACQUIRED, &vp->vp_flags);
2929
2930 reg_needed:
2931                 set_bit(REGISTER_FC4_NEEDED, &vp->dpc_flags);
2932                 set_bit(REGISTER_FDMI_NEEDED, &vp->dpc_flags);
2933                 set_bit(VP_DPC_NEEDED, &vha->dpc_flags);
2934                 qla2xxx_wake_dpc(vha);
2935         }
2936 }
2937
2938 /*
2939  * qla24xx_modify_vp_config
2940  *      Change VP configuration for vha
2941  *
2942  * Input:
2943  *      vha = adapter block pointer.
2944  *
2945  * Returns:
2946  *      qla2xxx local function return status code.
2947  *
2948  * Context:
2949  *      Kernel context.
2950  */
2951 int
2952 qla24xx_modify_vp_config(scsi_qla_host_t *vha)
2953 {
2954         int             rval;
2955         struct vp_config_entry_24xx *vpmod;
2956         dma_addr_t      vpmod_dma;
2957         struct qla_hw_data *ha = vha->hw;
2958         struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev);
2959
2960         /* This can be called by the parent */
2961
2962         vpmod = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &vpmod_dma);
2963         if (!vpmod) {
2964                 DEBUG2_3(printk("%s(%ld): failed to allocate Modify VP "
2965                     "IOCB.\n", __func__, vha->host_no));
2966                 return QLA_MEMORY_ALLOC_FAILED;
2967         }
2968
2969         memset(vpmod, 0, sizeof(struct vp_config_entry_24xx));
2970         vpmod->entry_type = VP_CONFIG_IOCB_TYPE;
2971         vpmod->entry_count = 1;
2972         vpmod->command = VCT_COMMAND_MOD_ENABLE_VPS;
2973         vpmod->vp_count = 1;
2974         vpmod->vp_index1 = vha->vp_idx;
2975         vpmod->options_idx1 = BIT_3|BIT_4|BIT_5;
2976         memcpy(vpmod->node_name_idx1, vha->node_name, WWN_SIZE);
2977         memcpy(vpmod->port_name_idx1, vha->port_name, WWN_SIZE);
2978         vpmod->entry_count = 1;
2979
2980         rval = qla2x00_issue_iocb(base_vha, vpmod, vpmod_dma, 0);
2981         if (rval != QLA_SUCCESS) {
2982                 DEBUG2_3_11(printk("%s(%ld): failed to issue VP config IOCB"
2983                         "(%x).\n", __func__, base_vha->host_no, rval));
2984         } else if (vpmod->comp_status != 0) {
2985                 DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
2986                         "-- error status (%x).\n", __func__, base_vha->host_no,
2987                         vpmod->comp_status));
2988                 rval = QLA_FUNCTION_FAILED;
2989         } else if (vpmod->comp_status != __constant_cpu_to_le16(CS_COMPLETE)) {
2990                 DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
2991                     "-- completion status (%x).\n", __func__, base_vha->host_no,
2992                     le16_to_cpu(vpmod->comp_status)));
2993                 rval = QLA_FUNCTION_FAILED;
2994         } else {
2995                 /* EMPTY */
2996                 DEBUG11(printk("%s(%ld): done.\n", __func__,
2997                                                         base_vha->host_no));
2998                 fc_vport_set_state(vha->fc_vport, FC_VPORT_INITIALIZING);
2999         }
3000         dma_pool_free(ha->s_dma_pool, vpmod, vpmod_dma);
3001
3002         return rval;
3003 }
3004
3005 /*
3006  * qla24xx_control_vp
3007  *      Enable a virtual port for given host
3008  *
3009  * Input:
3010  *      ha = adapter block pointer.
3011  *      vhba = virtual adapter (unused)
3012  *      index = index number for enabled VP
3013  *
3014  * Returns:
3015  *      qla2xxx local function return status code.
3016  *
3017  * Context:
3018  *      Kernel context.
3019  */
3020 int
3021 qla24xx_control_vp(scsi_qla_host_t *vha, int cmd)
3022 {
3023         int             rval;
3024         int             map, pos;
3025         struct vp_ctrl_entry_24xx   *vce;
3026         dma_addr_t      vce_dma;
3027         struct qla_hw_data *ha = vha->hw;
3028         int     vp_index = vha->vp_idx;
3029         struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev);
3030
3031         DEBUG11(printk("%s(%ld): entered. Enabling index %d\n", __func__,
3032             vha->host_no, vp_index));
3033
3034         if (vp_index == 0 || vp_index >= ha->max_npiv_vports)
3035                 return QLA_PARAMETER_ERROR;
3036
3037         vce = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &vce_dma);
3038         if (!vce) {
3039                 DEBUG2_3(printk("%s(%ld): "
3040                     "failed to allocate VP Control IOCB.\n", __func__,
3041                     base_vha->host_no));
3042                 return QLA_MEMORY_ALLOC_FAILED;
3043         }
3044         memset(vce, 0, sizeof(struct vp_ctrl_entry_24xx));
3045
3046         vce->entry_type = VP_CTRL_IOCB_TYPE;
3047         vce->entry_count = 1;
3048         vce->command = cpu_to_le16(cmd);
3049         vce->vp_count = __constant_cpu_to_le16(1);
3050
3051         /* index map in firmware starts with 1; decrement index
3052          * this is ok as we never use index 0
3053          */
3054         map = (vp_index - 1) / 8;
3055         pos = (vp_index - 1) & 7;
3056         mutex_lock(&ha->vport_lock);
3057         vce->vp_idx_map[map] |= 1 << pos;
3058         mutex_unlock(&ha->vport_lock);
3059
3060         rval = qla2x00_issue_iocb(base_vha, vce, vce_dma, 0);
3061         if (rval != QLA_SUCCESS) {
3062                 DEBUG2_3_11(printk("%s(%ld): failed to issue VP control IOCB"
3063                     "(%x).\n", __func__, base_vha->host_no, rval));
3064                 printk("%s(%ld): failed to issue VP control IOCB"
3065                     "(%x).\n", __func__, base_vha->host_no, rval);
3066         } else if (vce->entry_status != 0) {
3067                 DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
3068                     "-- error status (%x).\n", __func__, base_vha->host_no,
3069                     vce->entry_status));
3070                 printk("%s(%ld): failed to complete IOCB "
3071                     "-- error status (%x).\n", __func__, base_vha->host_no,
3072                     vce->entry_status);
3073                 rval = QLA_FUNCTION_FAILED;
3074         } else if (vce->comp_status != __constant_cpu_to_le16(CS_COMPLETE)) {
3075                 DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
3076                     "-- completion status (%x).\n", __func__, base_vha->host_no,
3077                     le16_to_cpu(vce->comp_status)));
3078                 printk("%s(%ld): failed to complete IOCB "
3079                     "-- completion status (%x).\n", __func__, base_vha->host_no,
3080                     le16_to_cpu(vce->comp_status));
3081                 rval = QLA_FUNCTION_FAILED;
3082         } else {
3083                 DEBUG2(printk("%s(%ld): done.\n", __func__, base_vha->host_no));
3084         }
3085
3086         dma_pool_free(ha->s_dma_pool, vce, vce_dma);
3087
3088         return rval;
3089 }
3090
3091 /*
3092  * qla2x00_send_change_request
3093  *      Receive or disable RSCN request from fabric controller
3094  *
3095  * Input:
3096  *      ha = adapter block pointer
3097  *      format = registration format:
3098  *              0 - Reserved
3099  *              1 - Fabric detected registration
3100  *              2 - N_port detected registration
3101  *              3 - Full registration
3102  *              FF - clear registration
3103  *      vp_idx = Virtual port index
3104  *
3105  * Returns:
3106  *      qla2x00 local function return status code.
3107  *
3108  * Context:
3109  *      Kernel Context
3110  */
3111
3112 int
3113 qla2x00_send_change_request(scsi_qla_host_t *vha, uint16_t format,
3114                             uint16_t vp_idx)
3115 {
3116         int rval;
3117         mbx_cmd_t mc;
3118         mbx_cmd_t *mcp = &mc;
3119
3120         /*
3121          * This command is implicitly executed by firmware during login for the
3122          * physical hosts
3123          */
3124         if (vp_idx == 0)
3125                 return QLA_FUNCTION_FAILED;
3126
3127         mcp->mb[0] = MBC_SEND_CHANGE_REQUEST;
3128         mcp->mb[1] = format;
3129         mcp->mb[9] = vp_idx;
3130         mcp->out_mb = MBX_9|MBX_1|MBX_0;
3131         mcp->in_mb = MBX_0|MBX_1;
3132         mcp->tov = MBX_TOV_SECONDS;
3133         mcp->flags = 0;
3134         rval = qla2x00_mailbox_command(vha, mcp);
3135
3136         if (rval == QLA_SUCCESS) {
3137                 if (mcp->mb[0] != MBS_COMMAND_COMPLETE) {
3138                         rval = BIT_1;
3139                 }
3140         } else
3141                 rval = BIT_1;
3142
3143         return rval;
3144 }
3145
3146 int
3147 qla2x00_dump_ram(scsi_qla_host_t *vha, dma_addr_t req_dma, uint32_t addr,
3148     uint32_t size)
3149 {
3150         int rval;
3151         mbx_cmd_t mc;
3152         mbx_cmd_t *mcp = &mc;
3153
3154         DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
3155
3156         if (MSW(addr) || IS_FWI2_CAPABLE(vha->hw)) {
3157                 mcp->mb[0] = MBC_DUMP_RISC_RAM_EXTENDED;
3158                 mcp->mb[8] = MSW(addr);
3159                 mcp->out_mb = MBX_8|MBX_0;
3160         } else {
3161                 mcp->mb[0] = MBC_DUMP_RISC_RAM;
3162                 mcp->out_mb = MBX_0;
3163         }
3164         mcp->mb[1] = LSW(addr);
3165         mcp->mb[2] = MSW(req_dma);
3166         mcp->mb[3] = LSW(req_dma);
3167         mcp->mb[6] = MSW(MSD(req_dma));
3168         mcp->mb[7] = LSW(MSD(req_dma));
3169         mcp->out_mb |= MBX_7|MBX_6|MBX_3|MBX_2|MBX_1;
3170         if (IS_FWI2_CAPABLE(vha->hw)) {
3171                 mcp->mb[4] = MSW(size);
3172                 mcp->mb[5] = LSW(size);
3173                 mcp->out_mb |= MBX_5|MBX_4;
3174         } else {
3175                 mcp->mb[4] = LSW(size);
3176                 mcp->out_mb |= MBX_4;
3177         }
3178
3179         mcp->in_mb = MBX_0;
3180         mcp->tov = MBX_TOV_SECONDS;
3181         mcp->flags = 0;
3182         rval = qla2x00_mailbox_command(vha, mcp);
3183
3184         if (rval != QLA_SUCCESS) {
3185                 DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x.\n", __func__,
3186                     vha->host_no, rval, mcp->mb[0]));
3187         } else {
3188                 DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
3189         }
3190
3191         return rval;
3192 }
3193
3194 /* 84XX Support **************************************************************/
3195
3196 struct cs84xx_mgmt_cmd {
3197         union {
3198                 struct verify_chip_entry_84xx req;
3199                 struct verify_chip_rsp_84xx rsp;
3200         } p;
3201 };
3202
3203 int
3204 qla84xx_verify_chip(struct scsi_qla_host *vha, uint16_t *status)
3205 {
3206         int rval, retry;
3207         struct cs84xx_mgmt_cmd *mn;
3208         dma_addr_t mn_dma;
3209         uint16_t options;
3210         unsigned long flags;
3211         struct qla_hw_data *ha = vha->hw;
3212
3213         DEBUG16(printk("%s(%ld): entered.\n", __func__, vha->host_no));
3214
3215         mn = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &mn_dma);
3216         if (mn == NULL) {
3217                 DEBUG2_3(printk("%s(%ld): failed to allocate Verify ISP84XX "
3218                     "IOCB.\n", __func__, vha->host_no));
3219                 return QLA_MEMORY_ALLOC_FAILED;
3220         }
3221
3222         /* Force Update? */
3223         options = ha->cs84xx->fw_update ? VCO_FORCE_UPDATE : 0;
3224         /* Diagnostic firmware? */
3225         /* options |= MENLO_DIAG_FW; */
3226         /* We update the firmware with only one data sequence. */
3227         options |= VCO_END_OF_DATA;
3228
3229         do {
3230                 retry = 0;
3231                 memset(mn, 0, sizeof(*mn));
3232                 mn->p.req.entry_type = VERIFY_CHIP_IOCB_TYPE;
3233                 mn->p.req.entry_count = 1;
3234                 mn->p.req.options = cpu_to_le16(options);
3235
3236                 DEBUG16(printk("%s(%ld): Dump of Verify Request.\n", __func__,
3237                     vha->host_no));
3238                 DEBUG16(qla2x00_dump_buffer((uint8_t *)mn,
3239                     sizeof(*mn)));
3240
3241                 rval = qla2x00_issue_iocb_timeout(vha, mn, mn_dma, 0, 120);
3242                 if (rval != QLA_SUCCESS) {
3243                         DEBUG2_16(printk("%s(%ld): failed to issue Verify "
3244                             "IOCB (%x).\n", __func__, vha->host_no, rval));
3245                         goto verify_done;
3246                 }
3247
3248                 DEBUG16(printk("%s(%ld): Dump of Verify Response.\n", __func__,
3249                     vha->host_no));
3250                 DEBUG16(qla2x00_dump_buffer((uint8_t *)mn,
3251                     sizeof(*mn)));
3252
3253                 status[0] = le16_to_cpu(mn->p.rsp.comp_status);
3254                 status[1] = status[0] == CS_VCS_CHIP_FAILURE ?
3255                     le16_to_cpu(mn->p.rsp.failure_code) : 0;
3256                 DEBUG2_16(printk("%s(%ld): cs=%x fc=%x\n", __func__,
3257                     vha->host_no, status[0], status[1]));
3258
3259                 if (status[0] != CS_COMPLETE) {
3260                         rval = QLA_FUNCTION_FAILED;
3261                         if (!(options & VCO_DONT_UPDATE_FW)) {
3262                                 DEBUG2_16(printk("%s(%ld): Firmware update "
3263                                     "failed. Retrying without update "
3264                                     "firmware.\n", __func__, vha->host_no));
3265                                 options |= VCO_DONT_UPDATE_FW;
3266                                 options &= ~VCO_FORCE_UPDATE;
3267                                 retry = 1;
3268                         }
3269                 } else {
3270                         DEBUG2_16(printk("%s(%ld): firmware updated to %x.\n",
3271                             __func__, vha->host_no,
3272                             le32_to_cpu(mn->p.rsp.fw_ver)));
3273
3274                         /* NOTE: we only update OP firmware. */
3275                         spin_lock_irqsave(&ha->cs84xx->access_lock, flags);
3276                         ha->cs84xx->op_fw_version =
3277                             le32_to_cpu(mn->p.rsp.fw_ver);
3278                         spin_unlock_irqrestore(&ha->cs84xx->access_lock,
3279                             flags);
3280                 }
3281         } while (retry);
3282
3283 verify_done:
3284         dma_pool_free(ha->s_dma_pool, mn, mn_dma);
3285
3286         if (rval != QLA_SUCCESS) {
3287                 DEBUG2_16(printk("%s(%ld): failed=%x.\n", __func__,
3288                     vha->host_no, rval));
3289         } else {
3290                 DEBUG16(printk("%s(%ld): done.\n", __func__, vha->host_no));
3291         }
3292
3293         return rval;
3294 }
3295
3296 int
3297 qla25xx_init_req_que(struct scsi_qla_host *vha, struct req_que *req)
3298 {
3299         int rval;
3300         unsigned long flags;
3301         mbx_cmd_t mc;
3302         mbx_cmd_t *mcp = &mc;
3303         struct device_reg_25xxmq __iomem *reg;
3304         struct qla_hw_data *ha = vha->hw;
3305
3306         mcp->mb[0] = MBC_INITIALIZE_MULTIQ;
3307         mcp->mb[1] = req->options;
3308         mcp->mb[2] = MSW(LSD(req->dma));
3309         mcp->mb[3] = LSW(LSD(req->dma));
3310         mcp->mb[6] = MSW(MSD(req->dma));
3311         mcp->mb[7] = LSW(MSD(req->dma));
3312         mcp->mb[5] = req->length;
3313         if (req->rsp)
3314                 mcp->mb[10] = req->rsp->id;
3315         mcp->mb[12] = req->qos;
3316         mcp->mb[11] = req->vp_idx;
3317         mcp->mb[13] = req->rid;
3318
3319         reg = (struct device_reg_25xxmq *)((void *)(ha->mqiobase) +
3320                 QLA_QUE_PAGE * req->id);
3321
3322         mcp->mb[4] = req->id;
3323         /* que in ptr index */
3324         mcp->mb[8] = 0;
3325         /* que out ptr index */
3326         mcp->mb[9] = 0;
3327         mcp->out_mb = MBX_14|MBX_13|MBX_12|MBX_11|MBX_10|MBX_9|MBX_8|MBX_7|
3328                         MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
3329         mcp->in_mb = MBX_0;
3330         mcp->flags = MBX_DMA_OUT;
3331         mcp->tov = 60;
3332
3333         spin_lock_irqsave(&ha->hardware_lock, flags);
3334         if (!(req->options & BIT_0)) {
3335                 WRT_REG_DWORD(&reg->req_q_in, 0);
3336                 WRT_REG_DWORD(&reg->req_q_out, 0);
3337         }
3338         req->req_q_in = &reg->req_q_in;
3339         req->req_q_out = &reg->req_q_out;
3340         spin_unlock_irqrestore(&ha->hardware_lock, flags);
3341
3342         rval = qla2x00_mailbox_command(vha, mcp);
3343         if (rval != QLA_SUCCESS)
3344                 DEBUG2_3_11(printk(KERN_WARNING "%s(%ld): failed=%x mb0=%x.\n",
3345                         __func__, vha->host_no, rval, mcp->mb[0]));
3346         return rval;
3347 }
3348
3349 int
3350 qla25xx_init_rsp_que(struct scsi_qla_host *vha, struct rsp_que *rsp)
3351 {
3352         int rval;
3353         unsigned long flags;
3354         mbx_cmd_t mc;
3355         mbx_cmd_t *mcp = &mc;
3356         struct device_reg_25xxmq __iomem *reg;
3357         struct qla_hw_data *ha = vha->hw;
3358
3359         mcp->mb[0] = MBC_INITIALIZE_MULTIQ;
3360         mcp->mb[1] = rsp->options;
3361         mcp->mb[2] = MSW(LSD(rsp->dma));
3362         mcp->mb[3] = LSW(LSD(rsp->dma));
3363         mcp->mb[6] = MSW(MSD(rsp->dma));
3364         mcp->mb[7] = LSW(MSD(rsp->dma));
3365         mcp->mb[5] = rsp->length;
3366         mcp->mb[14] = rsp->msix->entry;
3367         mcp->mb[13] = rsp->rid;
3368
3369         reg = (struct device_reg_25xxmq *)((void *)(ha->mqiobase) +
3370                 QLA_QUE_PAGE * rsp->id);
3371
3372         mcp->mb[4] = rsp->id;
3373         /* que in ptr index */
3374         mcp->mb[8] = 0;
3375         /* que out ptr index */
3376         mcp->mb[9] = 0;
3377         mcp->out_mb = MBX_14|MBX_13|MBX_9|MBX_8|MBX_7
3378                         |MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
3379         mcp->in_mb = MBX_0;
3380         mcp->flags = MBX_DMA_OUT;
3381         mcp->tov = 60;
3382
3383         spin_lock_irqsave(&ha->hardware_lock, flags);
3384         if (!(rsp->options & BIT_0)) {
3385                 WRT_REG_DWORD(&reg->rsp_q_out, 0);
3386                 WRT_REG_DWORD(&reg->rsp_q_in, 0);
3387         }
3388
3389         spin_unlock_irqrestore(&ha->hardware_lock, flags);
3390
3391         rval = qla2x00_mailbox_command(vha, mcp);
3392         if (rval != QLA_SUCCESS)
3393                 DEBUG2_3_11(printk(KERN_WARNING "%s(%ld): failed=%x "
3394                         "mb0=%x.\n", __func__,
3395                         vha->host_no, rval, mcp->mb[0]));
3396         return rval;
3397 }
3398
3399 int
3400 qla81xx_idc_ack(scsi_qla_host_t *vha, uint16_t *mb)
3401 {
3402         int rval;
3403         mbx_cmd_t mc;
3404         mbx_cmd_t *mcp = &mc;
3405
3406         DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
3407
3408         mcp->mb[0] = MBC_IDC_ACK;
3409         memcpy(&mcp->mb[1], mb, QLA_IDC_ACK_REGS * sizeof(uint16_t));
3410         mcp->out_mb = MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
3411         mcp->in_mb = MBX_0;
3412         mcp->tov = MBX_TOV_SECONDS;
3413         mcp->flags = 0;
3414         rval = qla2x00_mailbox_command(vha, mcp);
3415
3416         if (rval != QLA_SUCCESS) {
3417                 DEBUG2_3_11(printk("%s(%ld): failed=%x (%x).\n", __func__,
3418                     vha->host_no, rval, mcp->mb[0]));
3419         } else {
3420                 DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
3421         }
3422
3423         return rval;
3424 }
3425
3426 int
3427 qla81xx_fac_get_sector_size(scsi_qla_host_t *vha, uint32_t *sector_size)
3428 {
3429         int rval;
3430         mbx_cmd_t mc;
3431         mbx_cmd_t *mcp = &mc;
3432
3433         if (!IS_QLA81XX(vha->hw))
3434                 return QLA_FUNCTION_FAILED;
3435
3436         DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
3437
3438         mcp->mb[0] = MBC_FLASH_ACCESS_CTRL;
3439         mcp->mb[1] = FAC_OPT_CMD_GET_SECTOR_SIZE;
3440         mcp->out_mb = MBX_1|MBX_0;
3441         mcp->in_mb = MBX_1|MBX_0;
3442         mcp->tov = MBX_TOV_SECONDS;
3443         mcp->flags = 0;
3444         rval = qla2x00_mailbox_command(vha, mcp);
3445
3446         if (rval != QLA_SUCCESS) {
3447                 DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x mb[1]=%x.\n",
3448                     __func__, vha->host_no, rval, mcp->mb[0], mcp->mb[1]));
3449         } else {
3450                 DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
3451                 *sector_size = mcp->mb[1];
3452         }
3453
3454         return rval;
3455 }
3456
3457 int
3458 qla81xx_fac_do_write_enable(scsi_qla_host_t *vha, int enable)
3459 {
3460         int rval;
3461         mbx_cmd_t mc;
3462         mbx_cmd_t *mcp = &mc;
3463
3464         if (!IS_QLA81XX(vha->hw))
3465                 return QLA_FUNCTION_FAILED;
3466
3467         DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
3468
3469         mcp->mb[0] = MBC_FLASH_ACCESS_CTRL;
3470         mcp->mb[1] = enable ? FAC_OPT_CMD_WRITE_ENABLE :
3471             FAC_OPT_CMD_WRITE_PROTECT;
3472         mcp->out_mb = MBX_1|MBX_0;
3473         mcp->in_mb = MBX_1|MBX_0;
3474         mcp->tov = MBX_TOV_SECONDS;
3475         mcp->flags = 0;
3476         rval = qla2x00_mailbox_command(vha, mcp);
3477
3478         if (rval != QLA_SUCCESS) {
3479                 DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x mb[1]=%x.\n",
3480                     __func__, vha->host_no, rval, mcp->mb[0], mcp->mb[1]));
3481         } else {
3482                 DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
3483         }
3484
3485         return rval;
3486 }
3487
3488 int
3489 qla81xx_fac_erase_sector(scsi_qla_host_t *vha, uint32_t start, uint32_t finish)
3490 {
3491         int rval;
3492         mbx_cmd_t mc;
3493         mbx_cmd_t *mcp = &mc;
3494
3495         if (!IS_QLA81XX(vha->hw))
3496                 return QLA_FUNCTION_FAILED;
3497
3498         DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
3499
3500         mcp->mb[0] = MBC_FLASH_ACCESS_CTRL;
3501         mcp->mb[1] = FAC_OPT_CMD_ERASE_SECTOR;
3502         mcp->mb[2] = LSW(start);
3503         mcp->mb[3] = MSW(start);
3504         mcp->mb[4] = LSW(finish);
3505         mcp->mb[5] = MSW(finish);
3506         mcp->out_mb = MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
3507         mcp->in_mb = MBX_2|MBX_1|MBX_0;
3508         mcp->tov = MBX_TOV_SECONDS;
3509         mcp->flags = 0;
3510         rval = qla2x00_mailbox_command(vha, mcp);
3511
3512         if (rval != QLA_SUCCESS) {
3513                 DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x mb[1]=%x "
3514                     "mb[2]=%x.\n", __func__, vha->host_no, rval, mcp->mb[0],
3515                     mcp->mb[1], mcp->mb[2]));
3516         } else {
3517                 DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
3518         }
3519
3520         return rval;
3521 }
3522
3523 int
3524 qla81xx_restart_mpi_firmware(scsi_qla_host_t *vha)
3525 {
3526         int rval = 0;
3527         mbx_cmd_t mc;
3528         mbx_cmd_t *mcp = &mc;
3529
3530         DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
3531
3532         mcp->mb[0] = MBC_RESTART_MPI_FW;
3533         mcp->out_mb = MBX_0;
3534         mcp->in_mb = MBX_0|MBX_1;
3535         mcp->tov = MBX_TOV_SECONDS;
3536         mcp->flags = 0;
3537         rval = qla2x00_mailbox_command(vha, mcp);
3538
3539         if (rval != QLA_SUCCESS) {
3540                 DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=0x%x mb[1]=0x%x.\n",
3541                     __func__, vha->host_no, rval, mcp->mb[0], mcp->mb[1]));
3542         } else {
3543                 DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
3544         }
3545
3546         return rval;
3547 }
3548
3549 int
3550 qla2x00_read_edc(scsi_qla_host_t *vha, uint16_t dev, uint16_t adr,
3551     dma_addr_t sfp_dma, uint8_t *sfp, uint16_t len, uint16_t opt)
3552 {
3553         int rval;
3554         mbx_cmd_t mc;
3555         mbx_cmd_t *mcp = &mc;
3556
3557         DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
3558
3559         mcp->mb[0] = MBC_READ_SFP;
3560         mcp->mb[1] = dev;
3561         mcp->mb[2] = MSW(sfp_dma);
3562         mcp->mb[3] = LSW(sfp_dma);
3563         mcp->mb[6] = MSW(MSD(sfp_dma));
3564         mcp->mb[7] = LSW(MSD(sfp_dma));
3565         mcp->mb[8] = len;
3566         mcp->mb[9] = adr;
3567         mcp->mb[10] = opt;
3568         mcp->out_mb = MBX_10|MBX_9|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
3569         mcp->in_mb = MBX_0;
3570         mcp->tov = MBX_TOV_SECONDS;
3571         mcp->flags = 0;
3572         rval = qla2x00_mailbox_command(vha, mcp);
3573
3574         if (opt & BIT_0)
3575                 if (sfp)
3576                         *sfp = mcp->mb[8];
3577
3578         if (rval != QLA_SUCCESS) {
3579                 DEBUG2_3_11(printk("%s(%ld): failed=%x (%x).\n", __func__,
3580                     vha->host_no, rval, mcp->mb[0]));
3581         } else {
3582                 DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
3583         }
3584
3585         return rval;
3586 }
3587
3588 int
3589 qla2x00_write_edc(scsi_qla_host_t *vha, uint16_t dev, uint16_t adr,
3590     dma_addr_t sfp_dma, uint8_t *sfp, uint16_t len, uint16_t opt)
3591 {
3592         int rval;
3593         mbx_cmd_t mc;
3594         mbx_cmd_t *mcp = &mc;
3595
3596         DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
3597
3598         if (opt & BIT_0)
3599                 if (sfp)
3600                         len = *sfp;
3601
3602         mcp->mb[0] = MBC_WRITE_SFP;
3603         mcp->mb[1] = dev;
3604         mcp->mb[2] = MSW(sfp_dma);
3605         mcp->mb[3] = LSW(sfp_dma);
3606         mcp->mb[6] = MSW(MSD(sfp_dma));
3607         mcp->mb[7] = LSW(MSD(sfp_dma));
3608         mcp->mb[8] = len;
3609         mcp->mb[9] = adr;
3610         mcp->mb[10] = opt;
3611         mcp->out_mb = MBX_10|MBX_9|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
3612         mcp->in_mb = MBX_0;
3613         mcp->tov = MBX_TOV_SECONDS;
3614         mcp->flags = 0;
3615         rval = qla2x00_mailbox_command(vha, mcp);
3616
3617         if (rval != QLA_SUCCESS) {
3618                 DEBUG2_3_11(printk("%s(%ld): failed=%x (%x).\n", __func__,
3619                     vha->host_no, rval, mcp->mb[0]));
3620         } else {
3621                 DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
3622         }
3623
3624         return rval;
3625 }
3626
3627 int
3628 qla2x00_get_xgmac_stats(scsi_qla_host_t *vha, dma_addr_t stats_dma,
3629     uint16_t size_in_bytes, uint16_t *actual_size)
3630 {
3631         int rval;
3632         mbx_cmd_t mc;
3633         mbx_cmd_t *mcp = &mc;
3634
3635         if (!IS_QLA8XXX_TYPE(vha->hw))
3636                 return QLA_FUNCTION_FAILED;
3637
3638         DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
3639
3640         mcp->mb[0] = MBC_GET_XGMAC_STATS;
3641         mcp->mb[2] = MSW(stats_dma);
3642         mcp->mb[3] = LSW(stats_dma);
3643         mcp->mb[6] = MSW(MSD(stats_dma));
3644         mcp->mb[7] = LSW(MSD(stats_dma));
3645         mcp->mb[8] = size_in_bytes >> 2;
3646         mcp->out_mb = MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_0;
3647         mcp->in_mb = MBX_2|MBX_1|MBX_0;
3648         mcp->tov = MBX_TOV_SECONDS;
3649         mcp->flags = 0;
3650         rval = qla2x00_mailbox_command(vha, mcp);
3651
3652         if (rval != QLA_SUCCESS) {
3653                 DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=0x%x "
3654                     "mb[1]=0x%x mb[2]=0x%x.\n", __func__, vha->host_no, rval,
3655                     mcp->mb[0], mcp->mb[1], mcp->mb[2]));
3656         } else {
3657                 DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
3658
3659                 *actual_size = mcp->mb[2] << 2;
3660         }
3661
3662         return rval;
3663 }
3664
3665 int
3666 qla2x00_get_dcbx_params(scsi_qla_host_t *vha, dma_addr_t tlv_dma,
3667     uint16_t size)
3668 {
3669         int rval;
3670         mbx_cmd_t mc;
3671         mbx_cmd_t *mcp = &mc;
3672
3673         if (!IS_QLA8XXX_TYPE(vha->hw))
3674                 return QLA_FUNCTION_FAILED;
3675
3676         DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
3677
3678         mcp->mb[0] = MBC_GET_DCBX_PARAMS;
3679         mcp->mb[1] = 0;
3680         mcp->mb[2] = MSW(tlv_dma);
3681         mcp->mb[3] = LSW(tlv_dma);
3682         mcp->mb[6] = MSW(MSD(tlv_dma));
3683         mcp->mb[7] = LSW(MSD(tlv_dma));
3684         mcp->mb[8] = size;
3685         mcp->out_mb = MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
3686         mcp->in_mb = MBX_2|MBX_1|MBX_0;
3687         mcp->tov = MBX_TOV_SECONDS;
3688         mcp->flags = 0;
3689         rval = qla2x00_mailbox_command(vha, mcp);
3690
3691         if (rval != QLA_SUCCESS) {
3692                 DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=0x%x "
3693                     "mb[1]=0x%x mb[2]=0x%x.\n", __func__, vha->host_no, rval,
3694                     mcp->mb[0], mcp->mb[1], mcp->mb[2]));
3695         } else {
3696                 DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
3697         }
3698
3699         return rval;
3700 }
3701
3702 int
3703 qla2x00_read_ram_word(scsi_qla_host_t *vha, uint32_t risc_addr, uint32_t *data)
3704 {
3705         int rval;
3706         mbx_cmd_t mc;
3707         mbx_cmd_t *mcp = &mc;
3708
3709         if (!IS_FWI2_CAPABLE(vha->hw))
3710                 return QLA_FUNCTION_FAILED;
3711
3712         DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
3713
3714         mcp->mb[0] = MBC_READ_RAM_EXTENDED;
3715         mcp->mb[1] = LSW(risc_addr);
3716         mcp->mb[8] = MSW(risc_addr);
3717         mcp->out_mb = MBX_8|MBX_1|MBX_0;
3718         mcp->in_mb = MBX_3|MBX_2|MBX_0;
3719         mcp->tov = 30;
3720         mcp->flags = 0;
3721         rval = qla2x00_mailbox_command(vha, mcp);
3722         if (rval != QLA_SUCCESS) {
3723                 DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x.\n", __func__,
3724                     vha->host_no, rval, mcp->mb[0]));
3725         } else {
3726                 DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
3727                 *data = mcp->mb[3] << 16 | mcp->mb[2];
3728         }
3729
3730         return rval;
3731 }
3732
3733 int
3734 qla2x00_loopback_test(scsi_qla_host_t *vha, struct msg_echo_lb *mreq,
3735         uint16_t *mresp)
3736 {
3737         int rval;
3738         mbx_cmd_t mc;
3739         mbx_cmd_t *mcp = &mc;
3740         uint32_t iter_cnt = 0x1;
3741
3742         DEBUG11(printk("scsi(%ld): entered.\n", vha->host_no));
3743
3744         memset(mcp->mb, 0 , sizeof(mcp->mb));
3745         mcp->mb[0] = MBC_DIAGNOSTIC_LOOP_BACK;
3746         mcp->mb[1] = mreq->options | BIT_6;     // BIT_6 specifies 64 bit addressing
3747
3748         /* transfer count */
3749         mcp->mb[10] = LSW(mreq->transfer_size);
3750         mcp->mb[11] = MSW(mreq->transfer_size);
3751
3752         /* send data address */
3753         mcp->mb[14] = LSW(mreq->send_dma);
3754         mcp->mb[15] = MSW(mreq->send_dma);
3755         mcp->mb[20] = LSW(MSD(mreq->send_dma));
3756         mcp->mb[21] = MSW(MSD(mreq->send_dma));
3757
3758         /* recieve data address */
3759         mcp->mb[16] = LSW(mreq->rcv_dma);
3760         mcp->mb[17] = MSW(mreq->rcv_dma);
3761         mcp->mb[6] = LSW(MSD(mreq->rcv_dma));
3762         mcp->mb[7] = MSW(MSD(mreq->rcv_dma));
3763
3764         /* Iteration count */
3765         mcp->mb[18] = LSW(iter_cnt);
3766         mcp->mb[19] = MSW(iter_cnt);
3767
3768         mcp->out_mb = MBX_21|MBX_20|MBX_19|MBX_18|MBX_17|MBX_16|MBX_15|
3769             MBX_14|MBX_13|MBX_12|MBX_11|MBX_10|MBX_7|MBX_6|MBX_1|MBX_0;
3770         if (IS_QLA8XXX_TYPE(vha->hw))
3771                 mcp->out_mb |= MBX_2;
3772         mcp->in_mb = MBX_19|MBX_18|MBX_3|MBX_2|MBX_1|MBX_0;
3773
3774         mcp->buf_size = mreq->transfer_size;
3775         mcp->tov = MBX_TOV_SECONDS;
3776         mcp->flags = MBX_DMA_OUT|MBX_DMA_IN|IOCTL_CMD;
3777
3778         rval = qla2x00_mailbox_command(vha, mcp);
3779
3780         if (rval != QLA_SUCCESS) {
3781                 DEBUG2(printk(KERN_WARNING
3782                         "(%ld): failed=%x mb[0]=0x%x "
3783                         "mb[1]=0x%x mb[2]=0x%x mb[3]=0x%x mb[18]=0x%x "
3784                         "mb[19]=0x%x.\n",
3785                         vha->host_no, rval, mcp->mb[0], mcp->mb[1], mcp->mb[2],
3786                         mcp->mb[3], mcp->mb[18], mcp->mb[19]));
3787         } else {
3788                 DEBUG2(printk(KERN_WARNING
3789                     "scsi(%ld): done.\n", vha->host_no));
3790         }
3791
3792         /* Copy mailbox information */
3793         memcpy( mresp, mcp->mb, 64);
3794         mresp[3] = mcp->mb[18];
3795         mresp[4] = mcp->mb[19];
3796         return rval;
3797 }
3798
3799 int
3800 qla2x00_echo_test(scsi_qla_host_t *vha, struct msg_echo_lb *mreq,
3801         uint16_t *mresp)
3802 {
3803         int rval;
3804         mbx_cmd_t mc;
3805         mbx_cmd_t *mcp = &mc;
3806         struct qla_hw_data *ha = vha->hw;
3807
3808         DEBUG11(printk("scsi(%ld): entered.\n", vha->host_no));
3809
3810         memset(mcp->mb, 0 , sizeof(mcp->mb));
3811         mcp->mb[0] = MBC_DIAGNOSTIC_ECHO;
3812         mcp->mb[1] = mreq->options | BIT_6;     /* BIT_6 specifies 64bit address */
3813         if (IS_QLA8XXX_TYPE(ha)) {
3814                 mcp->mb[1] |= BIT_15;
3815                 mcp->mb[2] = vha->fcoe_fcf_idx;
3816         }
3817         mcp->mb[16] = LSW(mreq->rcv_dma);
3818         mcp->mb[17] = MSW(mreq->rcv_dma);
3819         mcp->mb[6] = LSW(MSD(mreq->rcv_dma));
3820         mcp->mb[7] = MSW(MSD(mreq->rcv_dma));
3821
3822         mcp->mb[10] = LSW(mreq->transfer_size);
3823
3824         mcp->mb[14] = LSW(mreq->send_dma);
3825         mcp->mb[15] = MSW(mreq->send_dma);
3826         mcp->mb[20] = LSW(MSD(mreq->send_dma));
3827         mcp->mb[21] = MSW(MSD(mreq->send_dma));
3828
3829         mcp->out_mb = MBX_21|MBX_20|MBX_17|MBX_16|MBX_15|
3830             MBX_14|MBX_10|MBX_7|MBX_6|MBX_1|MBX_0;
3831         if (IS_QLA8XXX_TYPE(ha))
3832                 mcp->out_mb |= MBX_2;
3833
3834         mcp->in_mb = MBX_0;
3835         if (IS_QLA24XX_TYPE(ha) || IS_QLA25XX(ha) || IS_QLA8XXX_TYPE(ha))
3836                 mcp->in_mb |= MBX_1;
3837         if (IS_QLA8XXX_TYPE(ha))
3838                 mcp->in_mb |= MBX_3;
3839
3840         mcp->tov = MBX_TOV_SECONDS;
3841         mcp->flags = MBX_DMA_OUT|MBX_DMA_IN|IOCTL_CMD;
3842         mcp->buf_size = mreq->transfer_size;
3843
3844         rval = qla2x00_mailbox_command(vha, mcp);
3845
3846         if (rval != QLA_SUCCESS) {
3847                 DEBUG2(printk(KERN_WARNING
3848                     "(%ld): failed=%x mb[0]=0x%x mb[1]=0x%x.\n",
3849                     vha->host_no, rval, mcp->mb[0], mcp->mb[1]));
3850         } else {
3851                 DEBUG2(printk(KERN_WARNING
3852                     "scsi(%ld): done.\n", vha->host_no));
3853         }
3854
3855         /* Copy mailbox information */
3856         memcpy( mresp, mcp->mb, 32);
3857         return rval;
3858 }
3859 int
3860 qla84xx_reset_chip(scsi_qla_host_t *ha, uint16_t enable_diagnostic)
3861 {
3862         int rval;
3863         mbx_cmd_t mc;
3864         mbx_cmd_t *mcp = &mc;
3865
3866         DEBUG16(printk("%s(%ld): enable_diag=%d entered.\n", __func__,
3867                 ha->host_no, enable_diagnostic));
3868
3869         mcp->mb[0] = MBC_ISP84XX_RESET;
3870         mcp->mb[1] = enable_diagnostic;
3871         mcp->out_mb = MBX_1|MBX_0;
3872         mcp->in_mb = MBX_1|MBX_0;
3873         mcp->tov = MBX_TOV_SECONDS;
3874         mcp->flags = MBX_DMA_OUT|MBX_DMA_IN|IOCTL_CMD;
3875         rval = qla2x00_mailbox_command(ha, mcp);
3876
3877         if (rval != QLA_SUCCESS)
3878                 DEBUG16(printk("%s(%ld): failed=%x.\n", __func__, ha->host_no,
3879                         rval));
3880         else
3881                 DEBUG16(printk("%s(%ld): done.\n", __func__, ha->host_no));
3882
3883         return rval;
3884 }
3885
3886 int
3887 qla2x00_write_ram_word(scsi_qla_host_t *vha, uint32_t risc_addr, uint32_t data)
3888 {
3889         int rval;
3890         mbx_cmd_t mc;
3891         mbx_cmd_t *mcp = &mc;
3892
3893         if (!IS_FWI2_CAPABLE(vha->hw))
3894                 return QLA_FUNCTION_FAILED;
3895
3896         DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
3897
3898         mcp->mb[0] = MBC_WRITE_RAM_WORD_EXTENDED;
3899         mcp->mb[1] = LSW(risc_addr);
3900         mcp->mb[2] = LSW(data);
3901         mcp->mb[3] = MSW(data);
3902         mcp->mb[8] = MSW(risc_addr);
3903         mcp->out_mb = MBX_8|MBX_3|MBX_2|MBX_1|MBX_0;
3904         mcp->in_mb = MBX_0;
3905         mcp->tov = 30;
3906         mcp->flags = 0;
3907         rval = qla2x00_mailbox_command(vha, mcp);
3908         if (rval != QLA_SUCCESS) {
3909                 DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x.\n", __func__,
3910                     vha->host_no, rval, mcp->mb[0]));
3911         } else {
3912                 DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
3913         }
3914
3915         return rval;
3916 }
3917
3918 int
3919 qla2x00_get_data_rate(scsi_qla_host_t *vha)
3920 {
3921         int rval;
3922         mbx_cmd_t mc;
3923         mbx_cmd_t *mcp = &mc;
3924         struct qla_hw_data *ha = vha->hw;
3925
3926         if (!IS_FWI2_CAPABLE(ha))
3927                 return QLA_FUNCTION_FAILED;
3928
3929         DEBUG11(qla_printk(KERN_INFO, ha,
3930                 "%s(%ld): entered.\n", __func__, vha->host_no));
3931
3932         mcp->mb[0] = MBC_DATA_RATE;
3933         mcp->mb[1] = 0;
3934         mcp->out_mb = MBX_1|MBX_0;
3935         mcp->in_mb = MBX_2|MBX_1|MBX_0;
3936         mcp->tov = MBX_TOV_SECONDS;
3937         mcp->flags = 0;
3938         rval = qla2x00_mailbox_command(vha, mcp);
3939         if (rval != QLA_SUCCESS) {
3940                 DEBUG2_3_11(printk(KERN_INFO "%s(%ld): failed=%x mb[0]=%x.\n",
3941                     __func__, vha->host_no, rval, mcp->mb[0]));
3942         } else {
3943                 DEBUG11(printk(KERN_INFO
3944                     "%s(%ld): done.\n", __func__, vha->host_no));
3945                 if (mcp->mb[1] != 0x7)
3946                         ha->link_data_rate = mcp->mb[1];
3947         }
3948
3949         return rval;
3950 }
3951
3952 int
3953 qla24xx_set_fcp_prio(scsi_qla_host_t *vha, uint16_t loop_id, uint16_t priority,
3954                 uint16_t *mb)
3955 {
3956         int rval;
3957         mbx_cmd_t mc;
3958         mbx_cmd_t *mcp = &mc;
3959         struct qla_hw_data *ha = vha->hw;
3960
3961         if (!IS_QLA24XX_TYPE(ha) && !IS_QLA25XX(ha))
3962                 return QLA_FUNCTION_FAILED;
3963
3964         DEBUG11(printk(KERN_INFO
3965             "%s(%ld): entered.\n", __func__, ha->host_no));
3966
3967         mcp->mb[0] = MBC_PORT_PARAMS;
3968         mcp->mb[1] = loop_id;
3969         if (ha->flags.fcp_prio_enabled)
3970                 mcp->mb[2] = BIT_1;
3971         else
3972                 mcp->mb[2] = BIT_2;
3973         mcp->mb[4] = priority & 0xf;
3974         mcp->mb[9] = vha->vp_idx;
3975         mcp->out_mb = MBX_9|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
3976         mcp->in_mb = MBX_4|MBX_3|MBX_1|MBX_0;
3977         mcp->tov = 30;
3978         mcp->flags = 0;
3979         rval = qla2x00_mailbox_command(vha, mcp);
3980         if (mb != NULL) {
3981                 mb[0] = mcp->mb[0];
3982                 mb[1] = mcp->mb[1];
3983                 mb[3] = mcp->mb[3];
3984                 mb[4] = mcp->mb[4];
3985         }
3986
3987         if (rval != QLA_SUCCESS) {
3988                 DEBUG2_3_11(printk(KERN_WARNING
3989                     "%s(%ld): failed=%x.\n", __func__,
3990                     vha->host_no, rval));
3991         } else {
3992                 DEBUG11(printk(KERN_INFO
3993                     "%s(%ld): done.\n", __func__, vha->host_no));
3994         }
3995
3996         return rval;
3997 }
3998
3999 int
4000 qla82xx_mbx_intr_enable(scsi_qla_host_t *vha)
4001 {
4002         int rval;
4003         struct qla_hw_data *ha = vha->hw;
4004         mbx_cmd_t mc;
4005         mbx_cmd_t *mcp = &mc;
4006
4007         if (!IS_FWI2_CAPABLE(ha))
4008                 return QLA_FUNCTION_FAILED;
4009
4010         DEBUG11(qla_printk(KERN_INFO, ha,
4011                 "%s(%ld): entered.\n", __func__, vha->host_no));
4012
4013         memset(mcp, 0, sizeof(mbx_cmd_t));
4014         mcp->mb[0] = MBC_TOGGLE_INTR;
4015         mcp->mb[1] = 1;
4016
4017         mcp->out_mb = MBX_1|MBX_0;
4018         mcp->in_mb = MBX_0;
4019         mcp->tov = 30;
4020         mcp->flags = 0;
4021
4022         rval = qla2x00_mailbox_command(vha, mcp);
4023         if (rval != QLA_SUCCESS) {
4024                 DEBUG2_3_11(qla_printk(KERN_WARNING, ha,
4025                         "%s(%ld): failed=%x mb[0]=%x.\n", __func__,
4026                         vha->host_no, rval, mcp->mb[0]));
4027         } else {
4028                 DEBUG11(qla_printk(KERN_INFO, ha,
4029                         "%s(%ld): done.\n", __func__, vha->host_no));
4030         }
4031
4032         return rval;
4033 }
4034
4035 int
4036 qla82xx_mbx_intr_disable(scsi_qla_host_t *vha)
4037 {
4038         int rval;
4039         struct qla_hw_data *ha = vha->hw;
4040         mbx_cmd_t mc;
4041         mbx_cmd_t *mcp = &mc;
4042
4043         if (!IS_QLA82XX(ha))
4044                 return QLA_FUNCTION_FAILED;
4045
4046         DEBUG11(qla_printk(KERN_INFO, ha,
4047                 "%s(%ld): entered.\n", __func__, vha->host_no));
4048
4049         memset(mcp, 0, sizeof(mbx_cmd_t));
4050         mcp->mb[0] = MBC_TOGGLE_INTR;
4051         mcp->mb[1] = 0;
4052
4053         mcp->out_mb = MBX_1|MBX_0;
4054         mcp->in_mb = MBX_0;
4055         mcp->tov = 30;
4056         mcp->flags = 0;
4057
4058         rval = qla2x00_mailbox_command(vha, mcp);
4059         if (rval != QLA_SUCCESS) {
4060                 DEBUG2_3_11(qla_printk(KERN_WARNING, ha,
4061                         "%s(%ld): failed=%x mb[0]=%x.\n", __func__,
4062                         vha->host_no, rval, mcp->mb[0]));
4063         } else {
4064                 DEBUG11(qla_printk(KERN_INFO, ha,
4065                         "%s(%ld): done.\n", __func__, vha->host_no));
4066         }
4067
4068         return rval;
4069 }