drivers/scsi/qla2xxx/qla_mbx.c

   1 /*
   2  * QLogic Fibre Channel HBA Driver
   3  * Copyright (c)  2003-2013 QLogic Corporation
   4  *
   5  * See LICENSE.qla2xxx for copyright and licensing details.
   6  */
   7 #include "qla_def.h"
   8 #include "qla_target.h"
   9
  10 #include <linux/delay.h>
  11 #include <linux/gfp.h>
  12
  13
  14 /*
  15  * qla2x00_mailbox_command
  16  *      Issue mailbox command and waits for completion.
  17  *
  18  * Input:
  19  *      ha = adapter block pointer.
  20  *      mcp = driver internal mbx struct pointer.
  21  *
  22  * Output:
  23  *      mb[MAX_MAILBOX_REGISTER_COUNT] = returned mailbox data.
  24  *
  25  * Returns:
  26  *      0 : QLA_SUCCESS = cmd performed success
  27  *      1 : QLA_FUNCTION_FAILED   (error encountered)
  28  *      6 : QLA_FUNCTION_TIMEOUT (timeout condition encountered)
  29  *
  30  * Context:
  31  *      Kernel context.
  32  */
  33 static int
  34 qla2x00_mailbox_command(scsi_qla_host_t *vha, mbx_cmd_t *mcp)
  35 {
  36         int             rval;
  37         unsigned long    flags = 0;
  38         device_reg_t __iomem *reg;
  39         uint8_t         abort_active;
  40         uint8_t         io_lock_on;
  41         uint16_t        command = 0;
  42         uint16_t        *iptr;
  43         uint16_t __iomem *optr;
  44         uint32_t        cnt;
  45         uint32_t        mboxes;
  46         unsigned long   wait_time;
  47         struct qla_hw_data *ha = vha->hw;
  48         scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev);
  49
  50         ql_dbg(ql_dbg_mbx, vha, 0x1000, "Entered %s.\n", __func__);
  51
  52         if (ha->pdev->error_state > pci_channel_io_frozen) {
  53                 ql_log(ql_log_warn, vha, 0x1001,
  54                     "error_state is greater than pci_channel_io_frozen, "
  55                     "exiting.\n");
  56                 return QLA_FUNCTION_TIMEOUT;
  57         }
  58
  59         if (vha->device_flags & DFLG_DEV_FAILED) {
  60                 ql_log(ql_log_warn, vha, 0x1002,
  61                     "Device in failed state, exiting.\n");
  62                 return QLA_FUNCTION_TIMEOUT;
  63         }
  64
  65         reg = ha->iobase;
  66         io_lock_on = base_vha->flags.init_done;
  67
  68         rval = QLA_SUCCESS;
  69         abort_active = test_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags);
  70
  71
  72         if (ha->flags.pci_channel_io_perm_failure) {
  73                 ql_log(ql_log_warn, vha, 0x1003,
  74                     "Perm failure on EEH timeout MBX, exiting.\n");
  75                 return QLA_FUNCTION_TIMEOUT;
  76         }
  77
  78         if (IS_QLA82XX(ha) && ha->flags.isp82xx_fw_hung) {
  79                 /* Setting Link-Down error */
  80                 mcp->mb[0] = MBS_LINK_DOWN_ERROR;
  81                 ql_log(ql_log_warn, vha, 0x1004,
  82                     "FW hung = %d.\n", ha->flags.isp82xx_fw_hung);
  83                 return QLA_FUNCTION_TIMEOUT;
  84         }
  85
  86         /*
  87          * Wait for active mailbox commands to finish by waiting at most tov
  88          * seconds. This is to serialize actual issuing of mailbox cmds during
  89          * non ISP abort time.
  90          */
  91         if (!wait_for_completion_timeout(&ha->mbx_cmd_comp, mcp->tov * HZ)) {
  92                 /* Timeout occurred. Return error. */
  93                 ql_log(ql_log_warn, vha, 0x1005,
  94                     "Cmd access timeout, cmd=0x%x, Exiting.\n",
  95                     mcp->mb[0]);
  96                 return QLA_FUNCTION_TIMEOUT;
  97         }
  98
  99         ha->flags.mbox_busy = 1;
 100         /* Save mailbox command for debug */
 101         ha->mcp = mcp;
 102
 103         ql_dbg(ql_dbg_mbx, vha, 0x1006,
 104             "Prepare to issue mbox cmd=0x%x.\n", mcp->mb[0]);
 105
 106         spin_lock_irqsave(&ha->hardware_lock, flags);
 107
 108         /* Load mailbox registers. */
 109         if (IS_QLA82XX(ha))
 110                 optr = (uint16_t __iomem *)&reg->isp82.mailbox_in[0];
 111         else if (IS_FWI2_CAPABLE(ha) && !IS_QLA82XX(ha))
 112                 optr = (uint16_t __iomem *)&reg->isp24.mailbox0;
 113         else
 114                 optr = (uint16_t __iomem *)MAILBOX_REG(ha, &reg->isp, 0);
 115
 116         iptr = mcp->mb;
 117         command = mcp->mb[0];
 118         mboxes = mcp->out_mb;
 119
 120         for (cnt = 0; cnt < ha->mbx_count; cnt++) {
 121                 if (IS_QLA2200(ha) && cnt == 8)
 122                         optr =
 123                             (uint16_t __iomem *)MAILBOX_REG(ha, &reg->isp, 8);
 124                 if (mboxes & BIT_0)
 125                         WRT_REG_WORD(optr, *iptr);
 126
 127                 mboxes >>= 1;
 128                 optr++;
 129                 iptr++;
 130         }
 131
 132         ql_dbg(ql_dbg_mbx + ql_dbg_buffer, vha, 0x1111,
 133             "Loaded MBX registers (displayed in bytes) =.\n");
 134         ql_dump_buffer(ql_dbg_mbx + ql_dbg_buffer, vha, 0x1112,
 135             (uint8_t *)mcp->mb, 16);
 136         ql_dbg(ql_dbg_mbx + ql_dbg_buffer, vha, 0x1113,
 137             ".\n");
 138         ql_dump_buffer(ql_dbg_mbx + ql_dbg_buffer, vha, 0x1114,
 139             ((uint8_t *)mcp->mb + 0x10), 16);
 140         ql_dbg(ql_dbg_mbx + ql_dbg_buffer, vha, 0x1115,
 141             ".\n");
 142         ql_dump_buffer(ql_dbg_mbx + ql_dbg_buffer, vha, 0x1116,
 143             ((uint8_t *)mcp->mb + 0x20), 8);
 144         ql_dbg(ql_dbg_mbx + ql_dbg_buffer, vha, 0x1117,
 145             "I/O Address = %p.\n", optr);
 146         ql_dump_regs(ql_dbg_mbx + ql_dbg_buffer, vha, 0x100e);
 147
 148         /* Issue set host interrupt command to send cmd out. */
 149         ha->flags.mbox_int = 0;
 150         clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
 151
 152         /* Unlock mbx registers and wait for interrupt */
 153         ql_dbg(ql_dbg_mbx, vha, 0x100f,
 154             "Going to unlock irq & waiting for interrupts. "
 155             "jiffies=%lx.\n", jiffies);
 156
 157         /* Wait for mbx cmd completion until timeout */
 158
 159         if ((!abort_active && io_lock_on) || IS_NOPOLLING_TYPE(ha)) {
 160                 set_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags);
 161
 162                 if (IS_QLA82XX(ha)) {
 163                         if (RD_REG_DWORD(&reg->isp82.hint) &
 164                                 HINT_MBX_INT_PENDING) {
 165                                 spin_unlock_irqrestore(&ha->hardware_lock,
 166                                         flags);
 167                                 ha->flags.mbox_busy = 0;
 168                                 ql_dbg(ql_dbg_mbx, vha, 0x1010,
 169                                     "Pending mailbox timeout, exiting.\n");
 170                                 rval = QLA_FUNCTION_TIMEOUT;
 171                                 goto premature_exit;
 172                         }
 173                         WRT_REG_DWORD(&reg->isp82.hint, HINT_MBX_INT_PENDING);
 174                 } else if (IS_FWI2_CAPABLE(ha))
 175                         WRT_REG_DWORD(&reg->isp24.hccr, HCCRX_SET_HOST_INT);
 176                 else
 177                         WRT_REG_WORD(&reg->isp.hccr, HCCR_SET_HOST_INT);
 178                 spin_unlock_irqrestore(&ha->hardware_lock, flags);
 179
 180                 if (!wait_for_completion_timeout(&ha->mbx_intr_comp,
 181                     mcp->tov * HZ)) {
 182                         ql_dbg(ql_dbg_mbx, vha, 0x117a,
 183                             "cmd=%x Timeout.\n", command);
 184                         spin_lock_irqsave(&ha->hardware_lock, flags);
 185                         clear_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags);
 186                         spin_unlock_irqrestore(&ha->hardware_lock, flags);
 187                 }
 188         } else {
 189                 ql_dbg(ql_dbg_mbx, vha, 0x1011,
 190                     "Cmd=%x Polling Mode.\n", command);
 191
 192                 if (IS_QLA82XX(ha)) {
 193                         if (RD_REG_DWORD(&reg->isp82.hint) &
 194                                 HINT_MBX_INT_PENDING) {
 195                                 spin_unlock_irqrestore(&ha->hardware_lock,
 196                                         flags);
 197                                 ha->flags.mbox_busy = 0;
 198                                 ql_dbg(ql_dbg_mbx, vha, 0x1012,
 199                                     "Pending mailbox timeout, exiting.\n");
 200                                 rval = QLA_FUNCTION_TIMEOUT;
 201                                 goto premature_exit;
 202                         }
 203                         WRT_REG_DWORD(&reg->isp82.hint, HINT_MBX_INT_PENDING);
 204                 } else if (IS_FWI2_CAPABLE(ha))
 205                         WRT_REG_DWORD(&reg->isp24.hccr, HCCRX_SET_HOST_INT);
 206                 else
 207                         WRT_REG_WORD(&reg->isp.hccr, HCCR_SET_HOST_INT);
 208                 spin_unlock_irqrestore(&ha->hardware_lock, flags);
 209
 210                 wait_time = jiffies + mcp->tov * HZ; /* wait at most tov secs */
 211                 while (!ha->flags.mbox_int) {
 212                         if (time_after(jiffies, wait_time))
 213                                 break;
 214
 215                         /* Check for pending interrupts. */
 216                         qla2x00_poll(ha->rsp_q_map[0]);
 217
 218                         if (!ha->flags.mbox_int &&
 219                             !(IS_QLA2200(ha) &&
 220                             command == MBC_LOAD_RISC_RAM_EXTENDED))
 221                                 msleep(10);
 222                 } /* while */
 223                 ql_dbg(ql_dbg_mbx, vha, 0x1013,
 224                     "Waited %d sec.\n",
 225                     (uint)((jiffies - (wait_time - (mcp->tov * HZ)))/HZ));
 226         }
 227
 228         /* Check whether we timed out */
 229         if (ha->flags.mbox_int) {
 230                 uint16_t *iptr2;
 231
 232                 ql_dbg(ql_dbg_mbx, vha, 0x1014,
 233                     "Cmd=%x completed.\n", command);
 234
 235                 /* Got interrupt. Clear the flag. */
 236                 ha->flags.mbox_int = 0;
 237                 clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
 238
 239                 if ((IS_QLA82XX(ha) && ha->flags.isp82xx_fw_hung)) {
 240                         ha->flags.mbox_busy = 0;
 241                         /* Setting Link-Down error */
 242                         mcp->mb[0] = MBS_LINK_DOWN_ERROR;
 243                         ha->mcp = NULL;
 244                         rval = QLA_FUNCTION_FAILED;
 245                         ql_log(ql_log_warn, vha, 0x1015,
 246                             "FW hung = %d.\n", ha->flags.isp82xx_fw_hung);
 247                         goto premature_exit;
 248                 }
 249
 250                 if (ha->mailbox_out[0] != MBS_COMMAND_COMPLETE)
 251                         rval = QLA_FUNCTION_FAILED;
 252
 253                 /* Load return mailbox registers. */
 254                 iptr2 = mcp->mb;
 255                 iptr = (uint16_t *)&ha->mailbox_out[0];
 256                 mboxes = mcp->in_mb;
 257                 for (cnt = 0; cnt < ha->mbx_count; cnt++) {
 258                         if (mboxes & BIT_0)
 259                                 *iptr2 = *iptr;
 260
 261                         mboxes >>= 1;
 262                         iptr2++;
 263                         iptr++;
 264                 }
 265         } else {
 266
 267                 uint16_t mb0;
 268                 uint32_t ictrl;
 269
 270                 if (IS_FWI2_CAPABLE(ha)) {
 271                         mb0 = RD_REG_WORD(&reg->isp24.mailbox0);
 272                         ictrl = RD_REG_DWORD(&reg->isp24.ictrl);
 273                 } else {
 274                         mb0 = RD_MAILBOX_REG(ha, &reg->isp, 0);
 275                         ictrl = RD_REG_WORD(&reg->isp.ictrl);
 276                 }
 277                 ql_dbg(ql_dbg_mbx + ql_dbg_buffer, vha, 0x1119,
 278                     "MBX Command timeout for cmd %x, iocontrol=%x jiffies=%lx "
 279                     "mb[0]=0x%x\n", command, ictrl, jiffies, mb0);
 280                 ql_dump_regs(ql_dbg_mbx + ql_dbg_buffer, vha, 0x1019);
 281
 282                 /*
 283                  * Attempt to capture a firmware dump for further analysis
 284                  * of the current firmware state
 285                  */
 286                 ha->isp_ops->fw_dump(vha, 0);
 287
 288                 rval = QLA_FUNCTION_TIMEOUT;
 289         }
 290
 291         ha->flags.mbox_busy = 0;
 292
 293         /* Clean up */
 294         ha->mcp = NULL;
 295
 296         if ((abort_active || !io_lock_on) && !IS_NOPOLLING_TYPE(ha)) {
 297                 ql_dbg(ql_dbg_mbx, vha, 0x101a,
 298                     "Checking for additional resp interrupt.\n");
 299
 300                 /* polling mode for non isp_abort commands. */
 301                 qla2x00_poll(ha->rsp_q_map[0]);
 302         }
 303
 304         if (rval == QLA_FUNCTION_TIMEOUT &&
 305             mcp->mb[0] != MBC_GEN_SYSTEM_ERROR) {
 306                 if (!io_lock_on || (mcp->flags & IOCTL_CMD) ||
 307                     ha->flags.eeh_busy) {
 308                         /* not in dpc. schedule it for dpc to take over. */
 309                         ql_dbg(ql_dbg_mbx, vha, 0x101b,
 310                             "Timeout, schedule isp_abort_needed.\n");
 311
 312                         if (!test_bit(ISP_ABORT_NEEDED, &vha->dpc_flags) &&
 313                             !test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags) &&
 314                             !test_bit(ISP_ABORT_RETRY, &vha->dpc_flags)) {
 315                                 if (IS_QLA82XX(ha)) {
 316                                         ql_dbg(ql_dbg_mbx, vha, 0x112a,
 317                                             "disabling pause transmit on port "
 318                                             "0 & 1.\n");
 319                                         qla82xx_wr_32(ha,
 320                                             QLA82XX_CRB_NIU + 0x98,
 321                                             CRB_NIU_XG_PAUSE_CTL_P0|
 322                                             CRB_NIU_XG_PAUSE_CTL_P1);
 323                                 }
 324                                 ql_log(ql_log_info, base_vha, 0x101c,
 325                                     "Mailbox cmd timeout occurred, cmd=0x%x, "
 326                                     "mb[0]=0x%x, eeh_busy=0x%x. Scheduling ISP "
 327                                     "abort.\n", command, mcp->mb[0],
 328                                     ha->flags.eeh_busy);
 329                                 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
 330                                 qla2xxx_wake_dpc(vha);
 331                         }
 332                 } else if (!abort_active) {
 333                         /* call abort directly since we are in the DPC thread */
 334                         ql_dbg(ql_dbg_mbx, vha, 0x101d,
 335                             "Timeout, calling abort_isp.\n");
 336
 337                         if (!test_bit(ISP_ABORT_NEEDED, &vha->dpc_flags) &&
 338                             !test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags) &&
 339                             !test_bit(ISP_ABORT_RETRY, &vha->dpc_flags)) {
 340                                 if (IS_QLA82XX(ha)) {
 341                                         ql_dbg(ql_dbg_mbx, vha, 0x112b,
 342                                             "disabling pause transmit on port "
 343                                             "0 & 1.\n");
 344                                         qla82xx_wr_32(ha,
 345                                             QLA82XX_CRB_NIU + 0x98,
 346                                             CRB_NIU_XG_PAUSE_CTL_P0|
 347                                             CRB_NIU_XG_PAUSE_CTL_P1);
 348                                 }
 349                                 ql_log(ql_log_info, base_vha, 0x101e,
 350                                     "Mailbox cmd timeout occurred, cmd=0x%x, "
 351                                     "mb[0]=0x%x. Scheduling ISP abort ",
 352                                     command, mcp->mb[0]);
 353                                 set_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags);
 354                                 clear_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
 355                                 /* Allow next mbx cmd to come in. */
 356                                 complete(&ha->mbx_cmd_comp);
 357                                 if (ha->isp_ops->abort_isp(vha)) {
 358                                         /* Failed. retry later. */
 359                                         set_bit(ISP_ABORT_NEEDED,
 360                                             &vha->dpc_flags);
 361                                 }
 362                                 clear_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags);
 363                                 ql_dbg(ql_dbg_mbx, vha, 0x101f,
 364                                     "Finished abort_isp.\n");
 365                                 goto mbx_done;
 366                         }
 367                 }
 368         }
 369
 370 premature_exit:
 371         /* Allow next mbx cmd to come in. */
 372         complete(&ha->mbx_cmd_comp);
 373
 374 mbx_done:
 375         if (rval) {
 376                 ql_log(ql_log_warn, base_vha, 0x1020,
 377                     "**** Failed mbx[0]=%x, mb[1]=%x, mb[2]=%x, mb[3]=%x, cmd=%x ****.\n",
 378                     mcp->mb[0], mcp->mb[1], mcp->mb[2], mcp->mb[3], command);
 379         } else {
 380                 ql_dbg(ql_dbg_mbx, base_vha, 0x1021, "Done %s.\n", __func__);
 381         }
 382
 383         return rval;
 384 }
 385
 386 int
 387 qla2x00_load_ram(scsi_qla_host_t *vha, dma_addr_t req_dma, uint32_t risc_addr,
 388     uint32_t risc_code_size)
 389 {
 390         int rval;
 391         struct qla_hw_data *ha = vha->hw;
 392         mbx_cmd_t mc;
 393         mbx_cmd_t *mcp = &mc;
 394
 395         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1022,
 396             "Entered %s.\n", __func__);
 397
 398         if (MSW(risc_addr) || IS_FWI2_CAPABLE(ha)) {
 399                 mcp->mb[0] = MBC_LOAD_RISC_RAM_EXTENDED;
 400                 mcp->mb[8] = MSW(risc_addr);
 401                 mcp->out_mb = MBX_8|MBX_0;
 402         } else {
 403                 mcp->mb[0] = MBC_LOAD_RISC_RAM;
 404                 mcp->out_mb = MBX_0;
 405         }
 406         mcp->mb[1] = LSW(risc_addr);
 407         mcp->mb[2] = MSW(req_dma);
 408         mcp->mb[3] = LSW(req_dma);
 409         mcp->mb[6] = MSW(MSD(req_dma));
 410         mcp->mb[7] = LSW(MSD(req_dma));
 411         mcp->out_mb |= MBX_7|MBX_6|MBX_3|MBX_2|MBX_1;
 412         if (IS_FWI2_CAPABLE(ha)) {
 413                 mcp->mb[4] = MSW(risc_code_size);
 414                 mcp->mb[5] = LSW(risc_code_size);
 415                 mcp->out_mb |= MBX_5|MBX_4;
 416         } else {
 417                 mcp->mb[4] = LSW(risc_code_size);
 418                 mcp->out_mb |= MBX_4;
 419         }
 420
 421         mcp->in_mb = MBX_0;
 422         mcp->tov = MBX_TOV_SECONDS;
 423         mcp->flags = 0;
 424         rval = qla2x00_mailbox_command(vha, mcp);
 425
 426         if (rval != QLA_SUCCESS) {
 427                 ql_dbg(ql_dbg_mbx, vha, 0x1023,
 428                     "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
 429         } else {
 430                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1024,
 431                     "Done %s.\n", __func__);
 432         }
 433
 434         return rval;
 435 }
 436
 437 #define EXTENDED_BB_CREDITS     BIT_0
 438 /*
 439  * qla2x00_execute_fw
 440  *     Start adapter firmware.
 441  *
 442  * Input:
 443  *     ha = adapter block pointer.
 444  *     TARGET_QUEUE_LOCK must be released.
 445  *     ADAPTER_STATE_LOCK must be released.
 446  *
 447  * Returns:
 448  *     qla2x00 local function return status code.
 449  *
 450  * Context:
 451  *     Kernel context.
 452  */
 453 int
 454 qla2x00_execute_fw(scsi_qla_host_t *vha, uint32_t risc_addr)
 455 {
 456         int rval;
 457         struct qla_hw_data *ha = vha->hw;
 458         mbx_cmd_t mc;
 459         mbx_cmd_t *mcp = &mc;
 460
 461         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1025,
 462             "Entered %s.\n", __func__);
 463
 464         mcp->mb[0] = MBC_EXECUTE_FIRMWARE;
 465         mcp->out_mb = MBX_0;
 466         mcp->in_mb = MBX_0;
 467         if (IS_FWI2_CAPABLE(ha)) {
 468                 mcp->mb[1] = MSW(risc_addr);
 469                 mcp->mb[2] = LSW(risc_addr);
 470                 mcp->mb[3] = 0;
 471                 if (IS_QLA81XX(ha) || IS_QLA83XX(ha)) {
 472                         struct nvram_81xx *nv = ha->nvram;
 473                         mcp->mb[4] = (nv->enhanced_features &
 474                             EXTENDED_BB_CREDITS);
 475                 } else
 476                         mcp->mb[4] = 0;
 477                 mcp->out_mb |= MBX_4|MBX_3|MBX_2|MBX_1;
 478                 mcp->in_mb |= MBX_1;
 479         } else {
 480                 mcp->mb[1] = LSW(risc_addr);
 481                 mcp->out_mb |= MBX_1;
 482                 if (IS_QLA2322(ha) || IS_QLA6322(ha)) {
 483                         mcp->mb[2] = 0;
 484                         mcp->out_mb |= MBX_2;
 485                 }
 486         }
 487
 488         mcp->tov = MBX_TOV_SECONDS;
 489         mcp->flags = 0;
 490         rval = qla2x00_mailbox_command(vha, mcp);
 491
 492         if (rval != QLA_SUCCESS) {
 493                 ql_dbg(ql_dbg_mbx, vha, 0x1026,
 494                     "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
 495         } else {
 496                 if (IS_FWI2_CAPABLE(ha)) {
 497                         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1027,
 498                             "Done exchanges=%x.\n", mcp->mb[1]);
 499                 } else {
 500                         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1028,
 501                             "Done %s.\n", __func__);
 502                 }
 503         }
 504
 505         return rval;
 506 }
 507
 508 /*
 509  * qla2x00_get_fw_version
 510  *      Get firmware version.
 511  *
 512  * Input:
 513  *      ha:             adapter state pointer.
 514  *      major:          pointer for major number.
 515  *      minor:          pointer for minor number.
 516  *      subminor:       pointer for subminor number.
 517  *
 518  * Returns:
 519  *      qla2x00 local function return status code.
 520  *
 521  * Context:
 522  *      Kernel context.
 523  */
 524 int
 525 qla2x00_get_fw_version(scsi_qla_host_t *vha)
 526 {
 527         int             rval;
 528         mbx_cmd_t       mc;
 529         mbx_cmd_t       *mcp = &mc;
 530         struct qla_hw_data *ha = vha->hw;
 531
 532         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1029,
 533             "Entered %s.\n", __func__);
 534
 535         mcp->mb[0] = MBC_GET_FIRMWARE_VERSION;
 536         mcp->out_mb = MBX_0;
 537         mcp->in_mb = MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
 538         if (IS_QLA81XX(vha->hw) || IS_QLA8031(ha))
 539                 mcp->in_mb |= MBX_13|MBX_12|MBX_11|MBX_10|MBX_9|MBX_8;
 540         if (IS_FWI2_CAPABLE(ha))
 541                 mcp->in_mb |= MBX_17|MBX_16|MBX_15;
 542         mcp->flags = 0;
 543         mcp->tov = MBX_TOV_SECONDS;
 544         rval = qla2x00_mailbox_command(vha, mcp);
 545         if (rval != QLA_SUCCESS)
 546                 goto failed;
 547
 548         /* Return mailbox data. */
 549         ha->fw_major_version = mcp->mb[1];
 550         ha->fw_minor_version = mcp->mb[2];
 551         ha->fw_subminor_version = mcp->mb[3];
 552         ha->fw_attributes = mcp->mb[6];
 553         if (IS_QLA2100(vha->hw) || IS_QLA2200(vha->hw))
 554                 ha->fw_memory_size = 0x1FFFF;           /* Defaults to 128KB. */
 555         else
 556                 ha->fw_memory_size = (mcp->mb[5] << 16) | mcp->mb[4];
 557         if (IS_QLA81XX(vha->hw) || IS_QLA8031(vha->hw)) {
 558                 ha->mpi_version[0] = mcp->mb[10] & 0xff;
 559                 ha->mpi_version[1] = mcp->mb[11] >> 8;
 560                 ha->mpi_version[2] = mcp->mb[11] & 0xff;
 561                 ha->mpi_capabilities = (mcp->mb[12] << 16) | mcp->mb[13];
 562                 ha->phy_version[0] = mcp->mb[8] & 0xff;
 563                 ha->phy_version[1] = mcp->mb[9] >> 8;
 564                 ha->phy_version[2] = mcp->mb[9] & 0xff;
 565         }
 566         if (IS_FWI2_CAPABLE(ha)) {
 567                 ha->fw_attributes_h = mcp->mb[15];
 568                 ha->fw_attributes_ext[0] = mcp->mb[16];
 569                 ha->fw_attributes_ext[1] = mcp->mb[17];
 570                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1139,
 571                     "%s: FW_attributes Upper: 0x%x, Lower: 0x%x.\n",
 572                     __func__, mcp->mb[15], mcp->mb[6]);
 573                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x112f,
 574                     "%s: Ext_FwAttributes Upper: 0x%x, Lower: 0x%x.\n",
 575                     __func__, mcp->mb[17], mcp->mb[16]);
 576         }
 577
 578 failed:
 579         if (rval != QLA_SUCCESS) {
 580                 /*EMPTY*/
 581                 ql_dbg(ql_dbg_mbx, vha, 0x102a, "Failed=%x.\n", rval);
 582         } else {
 583                 /*EMPTY*/
 584                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x102b,
 585                     "Done %s.\n", __func__);
 586         }
 587         return rval;
 588 }
 589
 590 /*
 591  * qla2x00_get_fw_options
 592  *      Set firmware options.
 593  *
 594  * Input:
 595  *      ha = adapter block pointer.
 596  *      fwopt = pointer for firmware options.
 597  *
 598  * Returns:
 599  *      qla2x00 local function return status code.
 600  *
 601  * Context:
 602  *      Kernel context.
 603  */
 604 int
 605 qla2x00_get_fw_options(scsi_qla_host_t *vha, uint16_t *fwopts)
 606 {
 607         int rval;
 608         mbx_cmd_t mc;
 609         mbx_cmd_t *mcp = &mc;
 610
 611         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x102c,
 612             "Entered %s.\n", __func__);
 613
 614         mcp->mb[0] = MBC_GET_FIRMWARE_OPTION;
 615         mcp->out_mb = MBX_0;
 616         mcp->in_mb = MBX_3|MBX_2|MBX_1|MBX_0;
 617         mcp->tov = MBX_TOV_SECONDS;
 618         mcp->flags = 0;
 619         rval = qla2x00_mailbox_command(vha, mcp);
 620
 621         if (rval != QLA_SUCCESS) {
 622                 /*EMPTY*/
 623                 ql_dbg(ql_dbg_mbx, vha, 0x102d, "Failed=%x.\n", rval);
 624         } else {
 625                 fwopts[0] = mcp->mb[0];
 626                 fwopts[1] = mcp->mb[1];
 627                 fwopts[2] = mcp->mb[2];
 628                 fwopts[3] = mcp->mb[3];
 629
 630                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x102e,
 631                     "Done %s.\n", __func__);
 632         }
 633
 634         return rval;
 635 }
 636
 637
 638 /*
 639  * qla2x00_set_fw_options
 640  *      Set firmware options.
 641  *
 642  * Input:
 643  *      ha = adapter block pointer.
 644  *      fwopt = pointer for firmware options.
 645  *
 646  * Returns:
 647  *      qla2x00 local function return status code.
 648  *
 649  * Context:
 650  *      Kernel context.
 651  */
 652 int
 653 qla2x00_set_fw_options(scsi_qla_host_t *vha, uint16_t *fwopts)
 654 {
 655         int rval;
 656         mbx_cmd_t mc;
 657         mbx_cmd_t *mcp = &mc;
 658
 659         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x102f,
 660             "Entered %s.\n", __func__);
 661
 662         mcp->mb[0] = MBC_SET_FIRMWARE_OPTION;
 663         mcp->mb[1] = fwopts[1];
 664         mcp->mb[2] = fwopts[2];
 665         mcp->mb[3] = fwopts[3];
 666         mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
 667         mcp->in_mb = MBX_0;
 668         if (IS_FWI2_CAPABLE(vha->hw)) {
 669                 mcp->in_mb |= MBX_1;
 670         } else {
 671                 mcp->mb[10] = fwopts[10];
 672                 mcp->mb[11] = fwopts[11];
 673                 mcp->mb[12] = 0;        /* Undocumented, but used */
 674                 mcp->out_mb |= MBX_12|MBX_11|MBX_10;
 675         }
 676         mcp->tov = MBX_TOV_SECONDS;
 677         mcp->flags = 0;
 678         rval = qla2x00_mailbox_command(vha, mcp);
 679
 680         fwopts[0] = mcp->mb[0];
 681
 682         if (rval != QLA_SUCCESS) {
 683                 /*EMPTY*/
 684                 ql_dbg(ql_dbg_mbx, vha, 0x1030,
 685                     "Failed=%x (%x/%x).\n", rval, mcp->mb[0], mcp->mb[1]);
 686         } else {
 687                 /*EMPTY*/
 688                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1031,
 689                     "Done %s.\n", __func__);
 690         }
 691
 692         return rval;
 693 }
 694
 695 /*
 696  * qla2x00_mbx_reg_test
 697  *      Mailbox register wrap test.
 698  *
 699  * Input:
 700  *      ha = adapter block pointer.
 701  *      TARGET_QUEUE_LOCK must be released.
 702  *      ADAPTER_STATE_LOCK must be released.
 703  *
 704  * Returns:
 705  *      qla2x00 local function return status code.
 706  *
 707  * Context:
 708  *      Kernel context.
 709  */
 710 int
 711 qla2x00_mbx_reg_test(scsi_qla_host_t *vha)
 712 {
 713         int rval;
 714         mbx_cmd_t mc;
 715         mbx_cmd_t *mcp = &mc;
 716
 717         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1032,
 718             "Entered %s.\n", __func__);
 719
 720         mcp->mb[0] = MBC_MAILBOX_REGISTER_TEST;
 721         mcp->mb[1] = 0xAAAA;
 722         mcp->mb[2] = 0x5555;
 723         mcp->mb[3] = 0xAA55;
 724         mcp->mb[4] = 0x55AA;
 725         mcp->mb[5] = 0xA5A5;
 726         mcp->mb[6] = 0x5A5A;
 727         mcp->mb[7] = 0x2525;
 728         mcp->out_mb = MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
 729         mcp->in_mb = MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
 730         mcp->tov = MBX_TOV_SECONDS;
 731         mcp->flags = 0;
 732         rval = qla2x00_mailbox_command(vha, mcp);
 733
 734         if (rval == QLA_SUCCESS) {
 735                 if (mcp->mb[1] != 0xAAAA || mcp->mb[2] != 0x5555 ||
 736                     mcp->mb[3] != 0xAA55 || mcp->mb[4] != 0x55AA)
 737                         rval = QLA_FUNCTION_FAILED;
 738                 if (mcp->mb[5] != 0xA5A5 || mcp->mb[6] != 0x5A5A ||
 739                     mcp->mb[7] != 0x2525)
 740                         rval = QLA_FUNCTION_FAILED;
 741         }
 742
 743         if (rval != QLA_SUCCESS) {
 744                 /*EMPTY*/
 745                 ql_dbg(ql_dbg_mbx, vha, 0x1033, "Failed=%x.\n", rval);
 746         } else {
 747                 /*EMPTY*/
 748                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1034,
 749                     "Done %s.\n", __func__);
 750         }
 751
 752         return rval;
 753 }
 754
 755 /*
 756  * qla2x00_verify_checksum
 757  *      Verify firmware checksum.
 758  *
 759  * Input:
 760  *      ha = adapter block pointer.
 761  *      TARGET_QUEUE_LOCK must be released.
 762  *      ADAPTER_STATE_LOCK must be released.
 763  *
 764  * Returns:
 765  *      qla2x00 local function return status code.
 766  *
 767  * Context:
 768  *      Kernel context.
 769  */
 770 int
 771 qla2x00_verify_checksum(scsi_qla_host_t *vha, uint32_t risc_addr)
 772 {
 773         int rval;
 774         mbx_cmd_t mc;
 775         mbx_cmd_t *mcp = &mc;
 776
 777         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1035,
 778             "Entered %s.\n", __func__);
 779
 780         mcp->mb[0] = MBC_VERIFY_CHECKSUM;
 781         mcp->out_mb = MBX_0;
 782         mcp->in_mb = MBX_0;
 783         if (IS_FWI2_CAPABLE(vha->hw)) {
 784                 mcp->mb[1] = MSW(risc_addr);
 785                 mcp->mb[2] = LSW(risc_addr);
 786                 mcp->out_mb |= MBX_2|MBX_1;
 787                 mcp->in_mb |= MBX_2|MBX_1;
 788         } else {
 789                 mcp->mb[1] = LSW(risc_addr);
 790                 mcp->out_mb |= MBX_1;
 791                 mcp->in_mb |= MBX_1;
 792         }
 793
 794         mcp->tov = MBX_TOV_SECONDS;
 795         mcp->flags = 0;
 796         rval = qla2x00_mailbox_command(vha, mcp);
 797
 798         if (rval != QLA_SUCCESS) {
 799                 ql_dbg(ql_dbg_mbx, vha, 0x1036,
 800                     "Failed=%x chm sum=%x.\n", rval, IS_FWI2_CAPABLE(vha->hw) ?
 801                     (mcp->mb[2] << 16) | mcp->mb[1] : mcp->mb[1]);
 802         } else {
 803                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1037,
 804                     "Done %s.\n", __func__);
 805         }
 806
 807         return rval;
 808 }
 809
 810 /*
 811  * qla2x00_issue_iocb
 812  *      Issue IOCB using mailbox command
 813  *
 814  * Input:
 815  *      ha = adapter state pointer.
 816  *      buffer = buffer pointer.
 817  *      phys_addr = physical address of buffer.
 818  *      size = size of buffer.
 819  *      TARGET_QUEUE_LOCK must be released.
 820  *      ADAPTER_STATE_LOCK must be released.
 821  *
 822  * Returns:
 823  *      qla2x00 local function return status code.
 824  *
 825  * Context:
 826  *      Kernel context.
 827  */
 828 int
 829 qla2x00_issue_iocb_timeout(scsi_qla_host_t *vha, void *buffer,
 830     dma_addr_t phys_addr, size_t size, uint32_t tov)
 831 {
 832         int             rval;
 833         mbx_cmd_t       mc;
 834         mbx_cmd_t       *mcp = &mc;
 835
 836         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1038,
 837             "Entered %s.\n", __func__);
 838
 839         mcp->mb[0] = MBC_IOCB_COMMAND_A64;
 840         mcp->mb[1] = 0;
 841         mcp->mb[2] = MSW(phys_addr);
 842         mcp->mb[3] = LSW(phys_addr);
 843         mcp->mb[6] = MSW(MSD(phys_addr));
 844         mcp->mb[7] = LSW(MSD(phys_addr));
 845         mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
 846         mcp->in_mb = MBX_2|MBX_0;
 847         mcp->tov = tov;
 848         mcp->flags = 0;
 849         rval = qla2x00_mailbox_command(vha, mcp);
 850
 851         if (rval != QLA_SUCCESS) {
 852                 /*EMPTY*/
 853                 ql_dbg(ql_dbg_mbx, vha, 0x1039, "Failed=%x.\n", rval);
 854         } else {
 855                 sts_entry_t *sts_entry = (sts_entry_t *) buffer;
 856
 857                 /* Mask reserved bits. */
 858                 sts_entry->entry_status &=
 859                     IS_FWI2_CAPABLE(vha->hw) ? RF_MASK_24XX : RF_MASK;
 860                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x103a,
 861                     "Done %s.\n", __func__);
 862         }
 863
 864         return rval;
 865 }
 866
 867 int
 868 qla2x00_issue_iocb(scsi_qla_host_t *vha, void *buffer, dma_addr_t phys_addr,
 869     size_t size)
 870 {
 871         return qla2x00_issue_iocb_timeout(vha, buffer, phys_addr, size,
 872             MBX_TOV_SECONDS);
 873 }
 874
 875 /*
 876  * qla2x00_abort_command
 877  *      Abort command aborts a specified IOCB.
 878  *
 879  * Input:
 880  *      ha = adapter block pointer.
 881  *      sp = SB structure pointer.
 882  *
 883  * Returns:
 884  *      qla2x00 local function return status code.
 885  *
 886  * Context:
 887  *      Kernel context.
 888  */
 889 int
 890 qla2x00_abort_command(srb_t *sp)
 891 {
 892         unsigned long   flags = 0;
 893         int             rval;
 894         uint32_t        handle = 0;
 895         mbx_cmd_t       mc;
 896         mbx_cmd_t       *mcp = &mc;
 897         fc_port_t       *fcport = sp->fcport;
 898         scsi_qla_host_t *vha = fcport->vha;
 899         struct qla_hw_data *ha = vha->hw;
 900         struct req_que *req = vha->req;
 901         struct scsi_cmnd *cmd = GET_CMD_SP(sp);
 902
 903         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x103b,
 904             "Entered %s.\n", __func__);
 905
 906         spin_lock_irqsave(&ha->hardware_lock, flags);
 907         for (handle = 1; handle < req->num_outstanding_cmds; handle++) {
 908                 if (req->outstanding_cmds[handle] == sp)
 909                         break;
 910         }
 911         spin_unlock_irqrestore(&ha->hardware_lock, flags);
 912
 913         if (handle == req->num_outstanding_cmds) {
 914                 /* command not found */
 915                 return QLA_FUNCTION_FAILED;
 916         }
 917
 918         mcp->mb[0] = MBC_ABORT_COMMAND;
 919         if (HAS_EXTENDED_IDS(ha))
 920                 mcp->mb[1] = fcport->loop_id;
 921         else
 922                 mcp->mb[1] = fcport->loop_id << 8;
 923         mcp->mb[2] = (uint16_t)handle;
 924         mcp->mb[3] = (uint16_t)(handle >> 16);
 925         mcp->mb[6] = (uint16_t)cmd->device->lun;
 926         mcp->out_mb = MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
 927         mcp->in_mb = MBX_0;
 928         mcp->tov = MBX_TOV_SECONDS;
 929         mcp->flags = 0;
 930         rval = qla2x00_mailbox_command(vha, mcp);
 931
 932         if (rval != QLA_SUCCESS) {
 933                 ql_dbg(ql_dbg_mbx, vha, 0x103c, "Failed=%x.\n", rval);
 934         } else {
 935                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x103d,
 936                     "Done %s.\n", __func__);
 937         }
 938
 939         return rval;
 940 }
 941
 942 int
 943 qla2x00_abort_target(struct fc_port *fcport, unsigned int l, int tag)
 944 {
 945         int rval, rval2;
 946         mbx_cmd_t  mc;
 947         mbx_cmd_t  *mcp = &mc;
 948         scsi_qla_host_t *vha;
 949         struct req_que *req;
 950         struct rsp_que *rsp;
 951
 952         l = l;
 953         vha = fcport->vha;
 954
 955         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x103e,
 956             "Entered %s.\n", __func__);
 957
 958         req = vha->hw->req_q_map[0];
 959         rsp = req->rsp;
 960         mcp->mb[0] = MBC_ABORT_TARGET;
 961         mcp->out_mb = MBX_9|MBX_2|MBX_1|MBX_0;
 962         if (HAS_EXTENDED_IDS(vha->hw)) {
 963                 mcp->mb[1] = fcport->loop_id;
 964                 mcp->mb[10] = 0;
 965                 mcp->out_mb |= MBX_10;
 966         } else {
 967                 mcp->mb[1] = fcport->loop_id << 8;
 968         }
 969         mcp->mb[2] = vha->hw->loop_reset_delay;
 970         mcp->mb[9] = vha->vp_idx;
 971
 972         mcp->in_mb = MBX_0;
 973         mcp->tov = MBX_TOV_SECONDS;
 974         mcp->flags = 0;
 975         rval = qla2x00_mailbox_command(vha, mcp);
 976         if (rval != QLA_SUCCESS) {
 977                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x103f,
 978                     "Failed=%x.\n", rval);
 979         }
 980
 981         /* Issue marker IOCB. */
 982         rval2 = qla2x00_marker(vha, req, rsp, fcport->loop_id, 0,
 983                                                         MK_SYNC_ID);
 984         if (rval2 != QLA_SUCCESS) {
 985                 ql_dbg(ql_dbg_mbx, vha, 0x1040,
 986                     "Failed to issue marker IOCB (%x).\n", rval2);
 987         } else {
 988                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1041,
 989                     "Done %s.\n", __func__);
 990         }
 991
 992         return rval;
 993 }
 994
 995 int
 996 qla2x00_lun_reset(struct fc_port *fcport, unsigned int l, int tag)
 997 {
 998         int rval, rval2;
 999         mbx_cmd_t  mc;
1000         mbx_cmd_t  *mcp = &mc;
1001         scsi_qla_host_t *vha;
1002         struct req_que *req;
1003         struct rsp_que *rsp;
1004
1005         vha = fcport->vha;
1006
1007         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1042,
1008             "Entered %s.\n", __func__);
1009
1010         req = vha->hw->req_q_map[0];
1011         rsp = req->rsp;
1012         mcp->mb[0] = MBC_LUN_RESET;
1013         mcp->out_mb = MBX_9|MBX_3|MBX_2|MBX_1|MBX_0;
1014         if (HAS_EXTENDED_IDS(vha->hw))
1015                 mcp->mb[1] = fcport->loop_id;
1016         else
1017                 mcp->mb[1] = fcport->loop_id << 8;
1018         mcp->mb[2] = l;
1019         mcp->mb[3] = 0;
1020         mcp->mb[9] = vha->vp_idx;
1021
1022         mcp->in_mb = MBX_0;
1023         mcp->tov = MBX_TOV_SECONDS;
1024         mcp->flags = 0;
1025         rval = qla2x00_mailbox_command(vha, mcp);
1026         if (rval != QLA_SUCCESS) {
1027                 ql_dbg(ql_dbg_mbx, vha, 0x1043, "Failed=%x.\n", rval);
1028         }
1029
1030         /* Issue marker IOCB. */
1031         rval2 = qla2x00_marker(vha, req, rsp, fcport->loop_id, l,
1032                                                                 MK_SYNC_ID_LUN);
1033         if (rval2 != QLA_SUCCESS) {
1034                 ql_dbg(ql_dbg_mbx, vha, 0x1044,
1035                     "Failed to issue marker IOCB (%x).\n", rval2);
1036         } else {
1037                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1045,
1038                     "Done %s.\n", __func__);
1039         }
1040
1041         return rval;
1042 }
1043
1044 /*
1045  * qla2x00_get_adapter_id
1046  *      Get adapter ID and topology.
1047  *
1048  * Input:
1049  *      ha = adapter block pointer.
1050  *      id = pointer for loop ID.
1051  *      al_pa = pointer for AL_PA.
1052  *      area = pointer for area.
1053  *      domain = pointer for domain.
1054  *      top = pointer for topology.
1055  *      TARGET_QUEUE_LOCK must be released.
1056  *      ADAPTER_STATE_LOCK must be released.
1057  *
1058  * Returns:
1059  *      qla2x00 local function return status code.
1060  *
1061  * Context:
1062  *      Kernel context.
1063  */
1064 int
1065 qla2x00_get_adapter_id(scsi_qla_host_t *vha, uint16_t *id, uint8_t *al_pa,
1066     uint8_t *area, uint8_t *domain, uint16_t *top, uint16_t *sw_cap)
1067 {
1068         int rval;
1069         mbx_cmd_t mc;
1070         mbx_cmd_t *mcp = &mc;
1071
1072         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1046,
1073             "Entered %s.\n", __func__);
1074
1075         mcp->mb[0] = MBC_GET_ADAPTER_LOOP_ID;
1076         mcp->mb[9] = vha->vp_idx;
1077         mcp->out_mb = MBX_9|MBX_0;
1078         mcp->in_mb = MBX_9|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
1079         if (IS_CNA_CAPABLE(vha->hw))
1080                 mcp->in_mb |= MBX_13|MBX_12|MBX_11|MBX_10;
1081         mcp->tov = MBX_TOV_SECONDS;
1082         mcp->flags = 0;
1083         rval = qla2x00_mailbox_command(vha, mcp);
1084         if (mcp->mb[0] == MBS_COMMAND_ERROR)
1085                 rval = QLA_COMMAND_ERROR;
1086         else if (mcp->mb[0] == MBS_INVALID_COMMAND)
1087                 rval = QLA_INVALID_COMMAND;
1088
1089         /* Return data. */
1090         *id = mcp->mb[1];
1091         *al_pa = LSB(mcp->mb[2]);
1092         *area = MSB(mcp->mb[2]);
1093         *domain = LSB(mcp->mb[3]);
1094         *top = mcp->mb[6];
1095         *sw_cap = mcp->mb[7];
1096
1097         if (rval != QLA_SUCCESS) {
1098                 /*EMPTY*/
1099                 ql_dbg(ql_dbg_mbx, vha, 0x1047, "Failed=%x.\n", rval);
1100         } else {
1101                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1048,
1102                     "Done %s.\n", __func__);
1103
1104                 if (IS_CNA_CAPABLE(vha->hw)) {
1105                         vha->fcoe_vlan_id = mcp->mb[9] & 0xfff;
1106                         vha->fcoe_fcf_idx = mcp->mb[10];
1107                         vha->fcoe_vn_port_mac[5] = mcp->mb[11] >> 8;
1108                         vha->fcoe_vn_port_mac[4] = mcp->mb[11] & 0xff;
1109                         vha->fcoe_vn_port_mac[3] = mcp->mb[12] >> 8;
1110                         vha->fcoe_vn_port_mac[2] = mcp->mb[12] & 0xff;
1111                         vha->fcoe_vn_port_mac[1] = mcp->mb[13] >> 8;
1112                         vha->fcoe_vn_port_mac[0] = mcp->mb[13] & 0xff;
1113                 }
1114         }
1115
1116         return rval;
1117 }
1118
1119 /*
1120  * qla2x00_get_retry_cnt
1121  *      Get current firmware login retry count and delay.
1122  *
1123  * Input:
1124  *      ha = adapter block pointer.
1125  *      retry_cnt = pointer to login retry count.
1126  *      tov = pointer to login timeout value.
1127  *
1128  * Returns:
1129  *      qla2x00 local function return status code.
1130  *
1131  * Context:
1132  *      Kernel context.
1133  */
1134 int
1135 qla2x00_get_retry_cnt(scsi_qla_host_t *vha, uint8_t *retry_cnt, uint8_t *tov,
1136     uint16_t *r_a_tov)
1137 {
1138         int rval;
1139         uint16_t ratov;
1140         mbx_cmd_t mc;
1141         mbx_cmd_t *mcp = &mc;
1142
1143         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1049,
1144             "Entered %s.\n", __func__);
1145
1146         mcp->mb[0] = MBC_GET_RETRY_COUNT;
1147         mcp->out_mb = MBX_0;
1148         mcp->in_mb = MBX_3|MBX_2|MBX_1|MBX_0;
1149         mcp->tov = MBX_TOV_SECONDS;
1150         mcp->flags = 0;
1151         rval = qla2x00_mailbox_command(vha, mcp);
1152
1153         if (rval != QLA_SUCCESS) {
1154                 /*EMPTY*/
1155                 ql_dbg(ql_dbg_mbx, vha, 0x104a,
1156                     "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
1157         } else {
1158                 /* Convert returned data and check our values. */
1159                 *r_a_tov = mcp->mb[3] / 2;
1160                 ratov = (mcp->mb[3]/2) / 10;  /* mb[3] value is in 100ms */
1161                 if (mcp->mb[1] * ratov > (*retry_cnt) * (*tov)) {
1162                         /* Update to the larger values */
1163                         *retry_cnt = (uint8_t)mcp->mb[1];
1164                         *tov = ratov;
1165                 }
1166
1167                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x104b,
1168                     "Done %s mb3=%d ratov=%d.\n", __func__, mcp->mb[3], ratov);
1169         }
1170
1171         return rval;
1172 }
1173
1174 /*
1175  * qla2x00_init_firmware
1176  *      Initialize adapter firmware.
1177  *
1178  * Input:
1179  *      ha = adapter block pointer.
1180  *      dptr = Initialization control block pointer.
1181  *      size = size of initialization control block.
1182  *      TARGET_QUEUE_LOCK must be released.
1183  *      ADAPTER_STATE_LOCK must be released.
1184  *
1185  * Returns:
1186  *      qla2x00 local function return status code.
1187  *
1188  * Context:
1189  *      Kernel context.
1190  */
1191 int
1192 qla2x00_init_firmware(scsi_qla_host_t *vha, uint16_t size)
1193 {
1194         int rval;
1195         mbx_cmd_t mc;
1196         mbx_cmd_t *mcp = &mc;
1197         struct qla_hw_data *ha = vha->hw;
1198
1199         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x104c,
1200             "Entered %s.\n", __func__);
1201
1202         if (IS_QLA82XX(ha) && ql2xdbwr)
1203                 qla82xx_wr_32(ha, ha->nxdb_wr_ptr,
1204                         (0x04 | (ha->portnum << 5) | (0 << 8) | (0 << 16)));
1205
1206         if (ha->flags.npiv_supported)
1207                 mcp->mb[0] = MBC_MID_INITIALIZE_FIRMWARE;
1208         else
1209                 mcp->mb[0] = MBC_INITIALIZE_FIRMWARE;
1210
1211         mcp->mb[1] = 0;
1212         mcp->mb[2] = MSW(ha->init_cb_dma);
1213         mcp->mb[3] = LSW(ha->init_cb_dma);
1214         mcp->mb[6] = MSW(MSD(ha->init_cb_dma));
1215         mcp->mb[7] = LSW(MSD(ha->init_cb_dma));
1216         mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
1217         if ((IS_QLA81XX(ha) || IS_QLA83XX(ha)) && ha->ex_init_cb->ex_version) {
1218                 mcp->mb[1] = BIT_0;
1219                 mcp->mb[10] = MSW(ha->ex_init_cb_dma);
1220                 mcp->mb[11] = LSW(ha->ex_init_cb_dma);
1221                 mcp->mb[12] = MSW(MSD(ha->ex_init_cb_dma));
1222                 mcp->mb[13] = LSW(MSD(ha->ex_init_cb_dma));
1223                 mcp->mb[14] = sizeof(*ha->ex_init_cb);
1224                 mcp->out_mb |= MBX_14|MBX_13|MBX_12|MBX_11|MBX_10;
1225         }
1226         /* 1 and 2 should normally be captured. */
1227         mcp->in_mb = MBX_2|MBX_1|MBX_0;
1228         if (IS_QLA83XX(ha))
1229                 /* mb3 is additional info about the installed SFP. */
1230                 mcp->in_mb  |= MBX_3;
1231         mcp->buf_size = size;
1232         mcp->flags = MBX_DMA_OUT;
1233         mcp->tov = MBX_TOV_SECONDS;
1234         rval = qla2x00_mailbox_command(vha, mcp);
1235
1236         if (rval != QLA_SUCCESS) {
1237                 /*EMPTY*/
1238                 ql_dbg(ql_dbg_mbx, vha, 0x104d,
1239                     "Failed=%x mb[0]=%x, mb[1]=%x, mb[2]=%x, mb[3]=%x,.\n",
1240                     rval, mcp->mb[0], mcp->mb[1], mcp->mb[2], mcp->mb[3]);
1241         } else {
1242                 /*EMPTY*/
1243                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x104e,
1244                     "Done %s.\n", __func__);
1245         }
1246
1247         return rval;
1248 }
1249
1250 /*
1251  * qla2x00_get_node_name_list
1252  *      Issue get node name list mailbox command, kmalloc()
1253  *      and return the resulting list. Caller must kfree() it!
1254  *
1255  * Input:
1256  *      ha = adapter state pointer.
1257  *      out_data = resulting list
1258  *      out_len = length of the resulting list
1259  *
1260  * Returns:
1261  *      qla2x00 local function return status code.
1262  *
1263  * Context:
1264  *      Kernel context.
1265  */
1266 int
1267 qla2x00_get_node_name_list(scsi_qla_host_t *vha, void **out_data, int *out_len)
1268 {
1269         struct qla_hw_data *ha = vha->hw;
1270         struct qla_port_24xx_data *list = NULL;
1271         void *pmap;
1272         mbx_cmd_t mc;
1273         dma_addr_t pmap_dma;
1274         ulong dma_size;
1275         int rval, left;
1276
1277         left = 1;
1278         while (left > 0) {
1279                 dma_size = left * sizeof(*list);
1280                 pmap = dma_alloc_coherent(&ha->pdev->dev, dma_size,
1281                                          &pmap_dma, GFP_KERNEL);
1282                 if (!pmap) {
1283                         ql_log(ql_log_warn, vha, 0x113f,
1284                             "%s(%ld): DMA Alloc failed of %ld\n",
1285                             __func__, vha->host_no, dma_size);
1286                         rval = QLA_MEMORY_ALLOC_FAILED;
1287                         goto out;
1288                 }
1289
1290                 mc.mb[0] = MBC_PORT_NODE_NAME_LIST;
1291                 mc.mb[1] = BIT_1 | BIT_3;
1292                 mc.mb[2] = MSW(pmap_dma);
1293                 mc.mb[3] = LSW(pmap_dma);
1294                 mc.mb[6] = MSW(MSD(pmap_dma));
1295                 mc.mb[7] = LSW(MSD(pmap_dma));
1296                 mc.mb[8] = dma_size;
1297                 mc.out_mb = MBX_0|MBX_1|MBX_2|MBX_3|MBX_6|MBX_7|MBX_8;
1298                 mc.in_mb = MBX_0|MBX_1;
1299                 mc.tov = 30;
1300                 mc.flags = MBX_DMA_IN;
1301
1302                 rval = qla2x00_mailbox_command(vha, &mc);
1303                 if (rval != QLA_SUCCESS) {
1304                         if ((mc.mb[0] == MBS_COMMAND_ERROR) &&
1305                             (mc.mb[1] == 0xA)) {
1306                                 left += le16_to_cpu(mc.mb[2]) /
1307                                     sizeof(struct qla_port_24xx_data);
1308                                 goto restart;
1309                         }
1310                         goto out_free;
1311                 }
1312
1313                 left = 0;
1314
1315                 list = kzalloc(dma_size, GFP_KERNEL);
1316                 if (!list) {
1317                         ql_log(ql_log_warn, vha, 0x1140,
1318                             "%s(%ld): failed to allocate node names list "
1319                             "structure.\n", __func__, vha->host_no);
1320                         rval = QLA_MEMORY_ALLOC_FAILED;
1321                         goto out_free;
1322                 }
1323
1324                 memcpy(list, pmap, dma_size);
1325 restart:
1326                 dma_free_coherent(&ha->pdev->dev, dma_size, pmap, pmap_dma);
1327         }
1328
1329         *out_data = list;
1330         *out_len = dma_size;
1331
1332 out:
1333         return rval;
1334
1335 out_free:
1336         dma_free_coherent(&ha->pdev->dev, dma_size, pmap, pmap_dma);
1337         return rval;
1338 }
1339
1340 /*
1341  * qla2x00_get_port_database
1342  *      Issue normal/enhanced get port database mailbox command
1343  *      and copy device name as necessary.
1344  *
1345  * Input:
1346  *      ha = adapter state pointer.
1347  *      dev = structure pointer.
1348  *      opt = enhanced cmd option byte.
1349  *
1350  * Returns:
1351  *      qla2x00 local function return status code.
1352  *
1353  * Context:
1354  *      Kernel context.
1355  */
1356 int
1357 qla2x00_get_port_database(scsi_qla_host_t *vha, fc_port_t *fcport, uint8_t opt)
1358 {
1359         int rval;
1360         mbx_cmd_t mc;
1361         mbx_cmd_t *mcp = &mc;
1362         port_database_t *pd;
1363         struct port_database_24xx *pd24;
1364         dma_addr_t pd_dma;
1365         struct qla_hw_data *ha = vha->hw;
1366
1367         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x104f,
1368             "Entered %s.\n", __func__);
1369
1370         pd24 = NULL;
1371         pd = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &pd_dma);
1372         if (pd  == NULL) {
1373                 ql_log(ql_log_warn, vha, 0x1050,
1374                     "Failed to allocate port database structure.\n");
1375                 return QLA_MEMORY_ALLOC_FAILED;
1376         }
1377         memset(pd, 0, max(PORT_DATABASE_SIZE, PORT_DATABASE_24XX_SIZE));
1378
1379         mcp->mb[0] = MBC_GET_PORT_DATABASE;
1380         if (opt != 0 && !IS_FWI2_CAPABLE(ha))
1381                 mcp->mb[0] = MBC_ENHANCED_GET_PORT_DATABASE;
1382         mcp->mb[2] = MSW(pd_dma);
1383         mcp->mb[3] = LSW(pd_dma);
1384         mcp->mb[6] = MSW(MSD(pd_dma));
1385         mcp->mb[7] = LSW(MSD(pd_dma));
1386         mcp->mb[9] = vha->vp_idx;
1387         mcp->out_mb = MBX_9|MBX_7|MBX_6|MBX_3|MBX_2|MBX_0;
1388         mcp->in_mb = MBX_0;
1389         if (IS_FWI2_CAPABLE(ha)) {
1390                 mcp->mb[1] = fcport->loop_id;
1391                 mcp->mb[10] = opt;
1392                 mcp->out_mb |= MBX_10|MBX_1;
1393                 mcp->in_mb |= MBX_1;
1394         } else if (HAS_EXTENDED_IDS(ha)) {
1395                 mcp->mb[1] = fcport->loop_id;
1396                 mcp->mb[10] = opt;
1397                 mcp->out_mb |= MBX_10|MBX_1;
1398         } else {
1399                 mcp->mb[1] = fcport->loop_id << 8 | opt;
1400                 mcp->out_mb |= MBX_1;
1401         }
1402         mcp->buf_size = IS_FWI2_CAPABLE(ha) ?
1403             PORT_DATABASE_24XX_SIZE : PORT_DATABASE_SIZE;
1404         mcp->flags = MBX_DMA_IN;
1405         mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2);
1406         rval = qla2x00_mailbox_command(vha, mcp);
1407         if (rval != QLA_SUCCESS)
1408                 goto gpd_error_out;
1409
1410         if (IS_FWI2_CAPABLE(ha)) {
1411                 uint64_t zero = 0;
1412                 pd24 = (struct port_database_24xx *) pd;
1413
1414                 /* Check for logged in state. */
1415                 if (pd24->current_login_state != PDS_PRLI_COMPLETE &&
1416                     pd24->last_login_state != PDS_PRLI_COMPLETE) {
1417                         ql_dbg(ql_dbg_mbx, vha, 0x1051,
1418                             "Unable to verify login-state (%x/%x) for "
1419                             "loop_id %x.\n", pd24->current_login_state,
1420                             pd24->last_login_state, fcport->loop_id);
1421                         rval = QLA_FUNCTION_FAILED;
1422                         goto gpd_error_out;
1423                 }
1424
1425                 if (fcport->loop_id == FC_NO_LOOP_ID ||
1426                     (memcmp(fcport->port_name, (uint8_t *)&zero, 8) &&
1427                      memcmp(fcport->port_name, pd24->port_name, 8))) {
1428                         /* We lost the device mid way. */
1429                         rval = QLA_NOT_LOGGED_IN;
1430                         goto gpd_error_out;
1431                 }
1432
1433                 /* Names are little-endian. */
1434                 memcpy(fcport->node_name, pd24->node_name, WWN_SIZE);
1435                 memcpy(fcport->port_name, pd24->port_name, WWN_SIZE);
1436
1437                 /* Get port_id of device. */
1438                 fcport->d_id.b.domain = pd24->port_id[0];
1439                 fcport->d_id.b.area = pd24->port_id[1];
1440                 fcport->d_id.b.al_pa = pd24->port_id[2];
1441                 fcport->d_id.b.rsvd_1 = 0;
1442
1443                 /* If not target must be initiator or unknown type. */
1444                 if ((pd24->prli_svc_param_word_3[0] & BIT_4) == 0)
1445                         fcport->port_type = FCT_INITIATOR;
1446                 else
1447                         fcport->port_type = FCT_TARGET;
1448
1449                 /* Passback COS information. */
1450                 fcport->supported_classes = (pd24->flags & PDF_CLASS_2) ?
1451                                 FC_COS_CLASS2 : FC_COS_CLASS3;
1452
1453                 if (pd24->prli_svc_param_word_3[0] & BIT_7)
1454                         fcport->flags |= FCF_CONF_COMP_SUPPORTED;
1455         } else {
1456                 uint64_t zero = 0;
1457
1458                 /* Check for logged in state. */
1459                 if (pd->master_state != PD_STATE_PORT_LOGGED_IN &&
1460                     pd->slave_state != PD_STATE_PORT_LOGGED_IN) {
1461                         ql_dbg(ql_dbg_mbx, vha, 0x100a,
1462                             "Unable to verify login-state (%x/%x) - "
1463                             "portid=%02x%02x%02x.\n", pd->master_state,
1464                             pd->slave_state, fcport->d_id.b.domain,
1465                             fcport->d_id.b.area, fcport->d_id.b.al_pa);
1466                         rval = QLA_FUNCTION_FAILED;
1467                         goto gpd_error_out;
1468                 }
1469
1470                 if (fcport->loop_id == FC_NO_LOOP_ID ||
1471                     (memcmp(fcport->port_name, (uint8_t *)&zero, 8) &&
1472                      memcmp(fcport->port_name, pd->port_name, 8))) {
1473                         /* We lost the device mid way. */
1474                         rval = QLA_NOT_LOGGED_IN;
1475                         goto gpd_error_out;
1476                 }
1477
1478                 /* Names are little-endian. */
1479                 memcpy(fcport->node_name, pd->node_name, WWN_SIZE);
1480                 memcpy(fcport->port_name, pd->port_name, WWN_SIZE);
1481
1482                 /* Get port_id of device. */
1483                 fcport->d_id.b.domain = pd->port_id[0];
1484                 fcport->d_id.b.area = pd->port_id[3];
1485                 fcport->d_id.b.al_pa = pd->port_id[2];
1486                 fcport->d_id.b.rsvd_1 = 0;
1487
1488                 /* If not target must be initiator or unknown type. */
1489                 if ((pd->prli_svc_param_word_3[0] & BIT_4) == 0)
1490                         fcport->port_type = FCT_INITIATOR;
1491                 else
1492                         fcport->port_type = FCT_TARGET;
1493
1494                 /* Passback COS information. */
1495                 fcport->supported_classes = (pd->options & BIT_4) ?
1496                     FC_COS_CLASS2: FC_COS_CLASS3;
1497         }
1498
1499 gpd_error_out:
1500         dma_pool_free(ha->s_dma_pool, pd, pd_dma);
1501
1502         if (rval != QLA_SUCCESS) {
1503                 ql_dbg(ql_dbg_mbx, vha, 0x1052,
1504                     "Failed=%x mb[0]=%x mb[1]=%x.\n", rval,
1505                     mcp->mb[0], mcp->mb[1]);
1506         } else {
1507                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1053,
1508                     "Done %s.\n", __func__);
1509         }
1510
1511         return rval;
1512 }
1513
1514 /*
1515  * qla2x00_get_firmware_state
1516  *      Get adapter firmware state.
1517  *
1518  * Input:
1519  *      ha = adapter block pointer.
1520  *      dptr = pointer for firmware state.
1521  *      TARGET_QUEUE_LOCK must be released.
1522  *      ADAPTER_STATE_LOCK must be released.
1523  *
1524  * Returns:
1525  *      qla2x00 local function return status code.
1526  *
1527  * Context:
1528  *      Kernel context.
1529  */
1530 int
1531 qla2x00_get_firmware_state(scsi_qla_host_t *vha, uint16_t *states)
1532 {
1533         int rval;
1534         mbx_cmd_t mc;
1535         mbx_cmd_t *mcp = &mc;
1536
1537         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1054,
1538             "Entered %s.\n", __func__);
1539
1540         mcp->mb[0] = MBC_GET_FIRMWARE_STATE;
1541         mcp->out_mb = MBX_0;
1542         if (IS_FWI2_CAPABLE(vha->hw))
1543                 mcp->in_mb = MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
1544         else
1545                 mcp->in_mb = MBX_1|MBX_0;
1546         mcp->tov = MBX_TOV_SECONDS;
1547         mcp->flags = 0;
1548         rval = qla2x00_mailbox_command(vha, mcp);
1549
1550         /* Return firmware states. */
1551         states[0] = mcp->mb[1];
1552         if (IS_FWI2_CAPABLE(vha->hw)) {
1553                 states[1] = mcp->mb[2];
1554                 states[2] = mcp->mb[3];
1555                 states[3] = mcp->mb[4];
1556                 states[4] = mcp->mb[5];
1557         }
1558
1559         if (rval != QLA_SUCCESS) {
1560                 /*EMPTY*/
1561                 ql_dbg(ql_dbg_mbx, vha, 0x1055, "Failed=%x.\n", rval);
1562         } else {
1563                 /*EMPTY*/
1564                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1056,
1565                     "Done %s.\n", __func__);
1566         }
1567
1568         return rval;
1569 }
1570
1571 /*
1572  * qla2x00_get_port_name
1573  *      Issue get port name mailbox command.
1574  *      Returned name is in big endian format.
1575  *
1576  * Input:
1577  *      ha = adapter block pointer.
1578  *      loop_id = loop ID of device.
1579  *      name = pointer for name.
1580  *      TARGET_QUEUE_LOCK must be released.
1581  *      ADAPTER_STATE_LOCK must be released.
1582  *
1583  * Returns:
1584  *      qla2x00 local function return status code.
1585  *
1586  * Context:
1587  *      Kernel context.
1588  */
1589 int
1590 qla2x00_get_port_name(scsi_qla_host_t *vha, uint16_t loop_id, uint8_t *name,
1591     uint8_t opt)
1592 {
1593         int rval;
1594         mbx_cmd_t mc;
1595         mbx_cmd_t *mcp = &mc;
1596
1597         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1057,
1598             "Entered %s.\n", __func__);
1599
1600         mcp->mb[0] = MBC_GET_PORT_NAME;
1601         mcp->mb[9] = vha->vp_idx;
1602         mcp->out_mb = MBX_9|MBX_1|MBX_0;
1603         if (HAS_EXTENDED_IDS(vha->hw)) {
1604                 mcp->mb[1] = loop_id;
1605                 mcp->mb[10] = opt;
1606                 mcp->out_mb |= MBX_10;
1607         } else {
1608                 mcp->mb[1] = loop_id << 8 | opt;
1609         }
1610
1611         mcp->in_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
1612         mcp->tov = MBX_TOV_SECONDS;
1613         mcp->flags = 0;
1614         rval = qla2x00_mailbox_command(vha, mcp);
1615
1616         if (rval != QLA_SUCCESS) {
1617                 /*EMPTY*/
1618                 ql_dbg(ql_dbg_mbx, vha, 0x1058, "Failed=%x.\n", rval);
1619         } else {
1620                 if (name != NULL) {
1621                         /* This function returns name in big endian. */
1622                         name[0] = MSB(mcp->mb[2]);
1623                         name[1] = LSB(mcp->mb[2]);
1624                         name[2] = MSB(mcp->mb[3]);
1625                         name[3] = LSB(mcp->mb[3]);
1626                         name[4] = MSB(mcp->mb[6]);
1627                         name[5] = LSB(mcp->mb[6]);
1628                         name[6] = MSB(mcp->mb[7]);
1629                         name[7] = LSB(mcp->mb[7]);
1630                 }
1631
1632                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1059,
1633                     "Done %s.\n", __func__);
1634         }
1635
1636         return rval;
1637 }
1638
1639 /*
1640  * qla24xx_link_initialization
1641  *      Issue link initialization mailbox command.
1642  *
1643  * Input:
1644  *      ha = adapter block pointer.
1645  *      TARGET_QUEUE_LOCK must be released.
1646  *      ADAPTER_STATE_LOCK must be released.
1647  *
1648  * Returns:
1649  *      qla2x00 local function return status code.
1650  *
1651  * Context:
1652  *      Kernel context.
1653  */
1654 int
1655 qla24xx_link_initialize(scsi_qla_host_t *vha)
1656 {
1657         int rval;
1658         mbx_cmd_t mc;
1659         mbx_cmd_t *mcp = &mc;
1660
1661         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1152,
1662             "Entered %s.\n", __func__);
1663
1664         if (!IS_FWI2_CAPABLE(vha->hw) || IS_CNA_CAPABLE(vha->hw))
1665                 return QLA_FUNCTION_FAILED;
1666
1667         mcp->mb[0] = MBC_LINK_INITIALIZATION;
1668         mcp->mb[1] = BIT_6|BIT_4;
1669         mcp->mb[2] = 0;
1670         mcp->mb[3] = 0;
1671         mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
1672         mcp->in_mb = MBX_0;
1673         mcp->tov = MBX_TOV_SECONDS;
1674         mcp->flags = 0;
1675         rval = qla2x00_mailbox_command(vha, mcp);
1676
1677         if (rval != QLA_SUCCESS) {
1678                 ql_dbg(ql_dbg_mbx, vha, 0x1153, "Failed=%x.\n", rval);
1679         } else {
1680                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1154,
1681                     "Done %s.\n", __func__);
1682         }
1683
1684         return rval;
1685 }
1686
1687 /*
1688  * qla2x00_lip_reset
1689  *      Issue LIP reset mailbox command.
1690  *
1691  * Input:
1692  *      ha = adapter block pointer.
1693  *      TARGET_QUEUE_LOCK must be released.
1694  *      ADAPTER_STATE_LOCK must be released.
1695  *
1696  * Returns:
1697  *      qla2x00 local function return status code.
1698  *
1699  * Context:
1700  *      Kernel context.
1701  */
1702 int
1703 qla2x00_lip_reset(scsi_qla_host_t *vha)
1704 {
1705         int rval;
1706         mbx_cmd_t mc;
1707         mbx_cmd_t *mcp = &mc;
1708
1709         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x105a,
1710             "Entered %s.\n", __func__);
1711
1712         if (IS_CNA_CAPABLE(vha->hw)) {
1713                 /* Logout across all FCFs. */
1714                 mcp->mb[0] = MBC_LIP_FULL_LOGIN;
1715                 mcp->mb[1] = BIT_1;
1716                 mcp->mb[2] = 0;
1717                 mcp->out_mb = MBX_2|MBX_1|MBX_0;
1718         } else if (IS_FWI2_CAPABLE(vha->hw)) {
1719                 mcp->mb[0] = MBC_LIP_FULL_LOGIN;
1720                 mcp->mb[1] = BIT_6;
1721                 mcp->mb[2] = 0;
1722                 mcp->mb[3] = vha->hw->loop_reset_delay;
1723                 mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
1724         } else {
1725                 mcp->mb[0] = MBC_LIP_RESET;
1726                 mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
1727                 if (HAS_EXTENDED_IDS(vha->hw)) {
1728                         mcp->mb[1] = 0x00ff;
1729                         mcp->mb[10] = 0;
1730                         mcp->out_mb |= MBX_10;
1731                 } else {
1732                         mcp->mb[1] = 0xff00;
1733                 }
1734                 mcp->mb[2] = vha->hw->loop_reset_delay;
1735                 mcp->mb[3] = 0;
1736         }
1737         mcp->in_mb = MBX_0;
1738         mcp->tov = MBX_TOV_SECONDS;
1739         mcp->flags = 0;
1740         rval = qla2x00_mailbox_command(vha, mcp);
1741
1742         if (rval != QLA_SUCCESS) {
1743                 /*EMPTY*/
1744                 ql_dbg(ql_dbg_mbx, vha, 0x105b, "Failed=%x.\n", rval);
1745         } else {
1746                 /*EMPTY*/
1747                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x105c,
1748                     "Done %s.\n", __func__);
1749         }
1750
1751         return rval;
1752 }
1753
1754 /*
1755  * qla2x00_send_sns
1756  *      Send SNS command.
1757  *
1758  * Input:
1759  *      ha = adapter block pointer.
1760  *      sns = pointer for command.
1761  *      cmd_size = command size.
1762  *      buf_size = response/command size.
1763  *      TARGET_QUEUE_LOCK must be released.
1764  *      ADAPTER_STATE_LOCK must be released.
1765  *
1766  * Returns:
1767  *      qla2x00 local function return status code.
1768  *
1769  * Context:
1770  *      Kernel context.
1771  */
1772 int
1773 qla2x00_send_sns(scsi_qla_host_t *vha, dma_addr_t sns_phys_address,
1774     uint16_t cmd_size, size_t buf_size)
1775 {
1776         int rval;
1777         mbx_cmd_t mc;
1778         mbx_cmd_t *mcp = &mc;
1779
1780         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x105d,
1781             "Entered %s.\n", __func__);
1782
1783         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x105e,
1784             "Retry cnt=%d ratov=%d total tov=%d.\n",
1785             vha->hw->retry_count, vha->hw->login_timeout, mcp->tov);
1786
1787         mcp->mb[0] = MBC_SEND_SNS_COMMAND;
1788         mcp->mb[1] = cmd_size;
1789         mcp->mb[2] = MSW(sns_phys_address);
1790         mcp->mb[3] = LSW(sns_phys_address);
1791         mcp->mb[6] = MSW(MSD(sns_phys_address));
1792         mcp->mb[7] = LSW(MSD(sns_phys_address));
1793         mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
1794         mcp->in_mb = MBX_0|MBX_1;
1795         mcp->buf_size = buf_size;
1796         mcp->flags = MBX_DMA_OUT|MBX_DMA_IN;
1797         mcp->tov = (vha->hw->login_timeout * 2) + (vha->hw->login_timeout / 2);
1798         rval = qla2x00_mailbox_command(vha, mcp);
1799
1800         if (rval != QLA_SUCCESS) {
1801                 /*EMPTY*/
1802                 ql_dbg(ql_dbg_mbx, vha, 0x105f,
1803                     "Failed=%x mb[0]=%x mb[1]=%x.\n",
1804                     rval, mcp->mb[0], mcp->mb[1]);
1805         } else {
1806                 /*EMPTY*/
1807                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1060,
1808                     "Done %s.\n", __func__);
1809         }
1810
1811         return rval;
1812 }
1813
1814 int
1815 qla24xx_login_fabric(scsi_qla_host_t *vha, uint16_t loop_id, uint8_t domain,
1816     uint8_t area, uint8_t al_pa, uint16_t *mb, uint8_t opt)
1817 {
1818         int             rval;
1819
1820         struct logio_entry_24xx *lg;
1821         dma_addr_t      lg_dma;
1822         uint32_t        iop[2];
1823         struct qla_hw_data *ha = vha->hw;
1824         struct req_que *req;
1825         struct rsp_que *rsp;
1826
1827         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1061,
1828             "Entered %s.\n", __func__);
1829
1830         if (ha->flags.cpu_affinity_enabled)
1831                 req = ha->req_q_map[0];
1832         else
1833                 req = vha->req;
1834         rsp = req->rsp;
1835
1836         lg = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &lg_dma);
1837         if (lg == NULL) {
1838                 ql_log(ql_log_warn, vha, 0x1062,
1839                     "Failed to allocate login IOCB.\n");
1840                 return QLA_MEMORY_ALLOC_FAILED;
1841         }
1842         memset(lg, 0, sizeof(struct logio_entry_24xx));
1843
1844         lg->entry_type = LOGINOUT_PORT_IOCB_TYPE;
1845         lg->entry_count = 1;
1846         lg->handle = MAKE_HANDLE(req->id, lg->handle);
1847         lg->nport_handle = cpu_to_le16(loop_id);
1848         lg->control_flags = __constant_cpu_to_le16(LCF_COMMAND_PLOGI);
1849         if (opt & BIT_0)
1850                 lg->control_flags |= __constant_cpu_to_le16(LCF_COND_PLOGI);
1851         if (opt & BIT_1)
1852                 lg->control_flags |= __constant_cpu_to_le16(LCF_SKIP_PRLI);
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         rval = qla2x00_issue_iocb_timeout(vha, lg, lg_dma, 0,
1858             (ha->r_a_tov / 10 * 2) + 2);
1859         if (rval != QLA_SUCCESS) {
1860                 ql_dbg(ql_dbg_mbx, vha, 0x1063,
1861                     "Failed to issue login IOCB (%x).\n", rval);
1862         } else if (lg->entry_status != 0) {
1863                 ql_dbg(ql_dbg_mbx, vha, 0x1064,
1864                     "Failed to complete IOCB -- error status (%x).\n",
1865                     lg->entry_status);
1866                 rval = QLA_FUNCTION_FAILED;
1867         } else if (lg->comp_status != __constant_cpu_to_le16(CS_COMPLETE)) {
1868                 iop[0] = le32_to_cpu(lg->io_parameter[0]);
1869                 iop[1] = le32_to_cpu(lg->io_parameter[1]);
1870
1871                 ql_dbg(ql_dbg_mbx, vha, 0x1065,
1872                     "Failed to complete IOCB -- completion  status (%x) "
1873                     "ioparam=%x/%x.\n", le16_to_cpu(lg->comp_status),
1874                     iop[0], iop[1]);
1875
1876                 switch (iop[0]) {
1877                 case LSC_SCODE_PORTID_USED:
1878                         mb[0] = MBS_PORT_ID_USED;
1879                         mb[1] = LSW(iop[1]);
1880                         break;
1881                 case LSC_SCODE_NPORT_USED:
1882                         mb[0] = MBS_LOOP_ID_USED;
1883                         break;
1884                 case LSC_SCODE_NOLINK:
1885                 case LSC_SCODE_NOIOCB:
1886                 case LSC_SCODE_NOXCB:
1887                 case LSC_SCODE_CMD_FAILED:
1888                 case LSC_SCODE_NOFABRIC:
1889                 case LSC_SCODE_FW_NOT_READY:
1890                 case LSC_SCODE_NOT_LOGGED_IN:
1891                 case LSC_SCODE_NOPCB:
1892                 case LSC_SCODE_ELS_REJECT:
1893                 case LSC_SCODE_CMD_PARAM_ERR:
1894                 case LSC_SCODE_NONPORT:
1895                 case LSC_SCODE_LOGGED_IN:
1896                 case LSC_SCODE_NOFLOGI_ACC:
1897                 default:
1898                         mb[0] = MBS_COMMAND_ERROR;
1899                         break;
1900                 }
1901         } else {
1902                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1066,
1903                     "Done %s.\n", __func__);
1904
1905                 iop[0] = le32_to_cpu(lg->io_parameter[0]);
1906
1907                 mb[0] = MBS_COMMAND_COMPLETE;
1908                 mb[1] = 0;
1909                 if (iop[0] & BIT_4) {
1910                         if (iop[0] & BIT_8)
1911                                 mb[1] |= BIT_1;
1912                 } else
1913                         mb[1] = BIT_0;
1914
1915                 /* Passback COS information. */
1916                 mb[10] = 0;
1917                 if (lg->io_parameter[7] || lg->io_parameter[8])
1918                         mb[10] |= BIT_0;        /* Class 2. */
1919                 if (lg->io_parameter[9] || lg->io_parameter[10])
1920                         mb[10] |= BIT_1;        /* Class 3. */
1921                 if (lg->io_parameter[0] & __constant_cpu_to_le32(BIT_7))
1922                         mb[10] |= BIT_7;        /* Confirmed Completion
1923                                                  * Allowed
1924                                                  */
1925         }
1926
1927         dma_pool_free(ha->s_dma_pool, lg, lg_dma);
1928
1929         return rval;
1930 }
1931
1932 /*
1933  * qla2x00_login_fabric
1934  *      Issue login fabric port mailbox command.
1935  *
1936  * Input:
1937  *      ha = adapter block pointer.
1938  *      loop_id = device loop ID.
1939  *      domain = device domain.
1940  *      area = device area.
1941  *      al_pa = device AL_PA.
1942  *      status = pointer for return status.
1943  *      opt = command options.
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_login_fabric(scsi_qla_host_t *vha, uint16_t loop_id, uint8_t domain,
1955     uint8_t area, uint8_t al_pa, uint16_t *mb, uint8_t opt)
1956 {
1957         int rval;
1958         mbx_cmd_t mc;
1959         mbx_cmd_t *mcp = &mc;
1960         struct qla_hw_data *ha = vha->hw;
1961
1962         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1067,
1963             "Entered %s.\n", __func__);
1964
1965         mcp->mb[0] = MBC_LOGIN_FABRIC_PORT;
1966         mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
1967         if (HAS_EXTENDED_IDS(ha)) {
1968                 mcp->mb[1] = loop_id;
1969                 mcp->mb[10] = opt;
1970                 mcp->out_mb |= MBX_10;
1971         } else {
1972                 mcp->mb[1] = (loop_id << 8) | opt;
1973         }
1974         mcp->mb[2] = domain;
1975         mcp->mb[3] = area << 8 | al_pa;
1976
1977         mcp->in_mb = MBX_7|MBX_6|MBX_2|MBX_1|MBX_0;
1978         mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2);
1979         mcp->flags = 0;
1980         rval = qla2x00_mailbox_command(vha, mcp);
1981
1982         /* Return mailbox statuses. */
1983         if (mb != NULL) {
1984                 mb[0] = mcp->mb[0];
1985                 mb[1] = mcp->mb[1];
1986                 mb[2] = mcp->mb[2];
1987                 mb[6] = mcp->mb[6];
1988                 mb[7] = mcp->mb[7];
1989                 /* COS retrieved from Get-Port-Database mailbox command. */
1990                 mb[10] = 0;
1991         }
1992
1993         if (rval != QLA_SUCCESS) {
1994                 /* RLU tmp code: need to change main mailbox_command function to
1995                  * return ok even when the mailbox completion value is not
1996                  * SUCCESS. The caller needs to be responsible to interpret
1997                  * the return values of this mailbox command if we're not
1998                  * to change too much of the existing code.
1999                  */
2000                 if (mcp->mb[0] == 0x4001 || mcp->mb[0] == 0x4002 ||
2001                     mcp->mb[0] == 0x4003 || mcp->mb[0] == 0x4005 ||
2002                     mcp->mb[0] == 0x4006)
2003                         rval = QLA_SUCCESS;
2004
2005                 /*EMPTY*/
2006                 ql_dbg(ql_dbg_mbx, vha, 0x1068,
2007                     "Failed=%x mb[0]=%x mb[1]=%x mb[2]=%x.\n",
2008                     rval, mcp->mb[0], mcp->mb[1], mcp->mb[2]);
2009         } else {
2010                 /*EMPTY*/
2011                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1069,
2012                     "Done %s.\n", __func__);
2013         }
2014
2015         return rval;
2016 }
2017
2018 /*
2019  * qla2x00_login_local_device
2020  *           Issue login loop port mailbox command.
2021  *
2022  * Input:
2023  *           ha = adapter block pointer.
2024  *           loop_id = device loop ID.
2025  *           opt = command options.
2026  *
2027  * Returns:
2028  *            Return status code.
2029  *
2030  * Context:
2031  *            Kernel context.
2032  *
2033  */
2034 int
2035 qla2x00_login_local_device(scsi_qla_host_t *vha, fc_port_t *fcport,
2036     uint16_t *mb_ret, uint8_t opt)
2037 {
2038         int rval;
2039         mbx_cmd_t mc;
2040         mbx_cmd_t *mcp = &mc;
2041         struct qla_hw_data *ha = vha->hw;
2042
2043         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x106a,
2044             "Entered %s.\n", __func__);
2045
2046         if (IS_FWI2_CAPABLE(ha))
2047                 return qla24xx_login_fabric(vha, fcport->loop_id,
2048                     fcport->d_id.b.domain, fcport->d_id.b.area,
2049                     fcport->d_id.b.al_pa, mb_ret, opt);
2050
2051         mcp->mb[0] = MBC_LOGIN_LOOP_PORT;
2052         if (HAS_EXTENDED_IDS(ha))
2053                 mcp->mb[1] = fcport->loop_id;
2054         else
2055                 mcp->mb[1] = fcport->loop_id << 8;
2056         mcp->mb[2] = opt;
2057         mcp->out_mb = MBX_2|MBX_1|MBX_0;
2058         mcp->in_mb = MBX_7|MBX_6|MBX_1|MBX_0;
2059         mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2);
2060         mcp->flags = 0;
2061         rval = qla2x00_mailbox_command(vha, mcp);
2062
2063         /* Return mailbox statuses. */
2064         if (mb_ret != NULL) {
2065                 mb_ret[0] = mcp->mb[0];
2066                 mb_ret[1] = mcp->mb[1];
2067                 mb_ret[6] = mcp->mb[6];
2068                 mb_ret[7] = mcp->mb[7];
2069         }
2070
2071         if (rval != QLA_SUCCESS) {
2072                 /* AV tmp code: need to change main mailbox_command function to
2073                  * return ok even when the mailbox completion value is not
2074                  * SUCCESS. The caller needs to be responsible to interpret
2075                  * the return values of this mailbox command if we're not
2076                  * to change too much of the existing code.
2077                  */
2078                 if (mcp->mb[0] == 0x4005 || mcp->mb[0] == 0x4006)
2079                         rval = QLA_SUCCESS;
2080
2081                 ql_dbg(ql_dbg_mbx, vha, 0x106b,
2082                     "Failed=%x mb[0]=%x mb[1]=%x mb[6]=%x mb[7]=%x.\n",
2083                     rval, mcp->mb[0], mcp->mb[1], mcp->mb[6], mcp->mb[7]);
2084         } else {
2085                 /*EMPTY*/
2086                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x106c,
2087                     "Done %s.\n", __func__);
2088         }
2089
2090         return (rval);
2091 }
2092
2093 int
2094 qla24xx_fabric_logout(scsi_qla_host_t *vha, uint16_t loop_id, uint8_t domain,
2095     uint8_t area, uint8_t al_pa)
2096 {
2097         int             rval;
2098         struct logio_entry_24xx *lg;
2099         dma_addr_t      lg_dma;
2100         struct qla_hw_data *ha = vha->hw;
2101         struct req_que *req;
2102         struct rsp_que *rsp;
2103
2104         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x106d,
2105             "Entered %s.\n", __func__);
2106
2107         lg = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &lg_dma);
2108         if (lg == NULL) {
2109                 ql_log(ql_log_warn, vha, 0x106e,
2110                     "Failed to allocate logout IOCB.\n");
2111                 return QLA_MEMORY_ALLOC_FAILED;
2112         }
2113         memset(lg, 0, sizeof(struct logio_entry_24xx));
2114
2115         if (ql2xmaxqueues > 1)
2116                 req = ha->req_q_map[0];
2117         else
2118                 req = vha->req;
2119         rsp = req->rsp;
2120         lg->entry_type = LOGINOUT_PORT_IOCB_TYPE;
2121         lg->entry_count = 1;
2122         lg->handle = MAKE_HANDLE(req->id, lg->handle);
2123         lg->nport_handle = cpu_to_le16(loop_id);
2124         lg->control_flags =
2125             __constant_cpu_to_le16(LCF_COMMAND_LOGO|LCF_IMPL_LOGO|
2126                 LCF_FREE_NPORT);
2127         lg->port_id[0] = al_pa;
2128         lg->port_id[1] = area;
2129         lg->port_id[2] = domain;
2130         lg->vp_index = vha->vp_idx;
2131         rval = qla2x00_issue_iocb_timeout(vha, lg, lg_dma, 0,
2132             (ha->r_a_tov / 10 * 2) + 2);
2133         if (rval != QLA_SUCCESS) {
2134                 ql_dbg(ql_dbg_mbx, vha, 0x106f,
2135                     "Failed to issue logout IOCB (%x).\n", rval);
2136         } else if (lg->entry_status != 0) {
2137                 ql_dbg(ql_dbg_mbx, vha, 0x1070,
2138                     "Failed to complete IOCB -- error status (%x).\n",
2139                     lg->entry_status);
2140                 rval = QLA_FUNCTION_FAILED;
2141         } else if (lg->comp_status != __constant_cpu_to_le16(CS_COMPLETE)) {
2142                 ql_dbg(ql_dbg_mbx, vha, 0x1071,
2143                     "Failed to complete IOCB -- completion status (%x) "
2144                     "ioparam=%x/%x.\n", le16_to_cpu(lg->comp_status),
2145                     le32_to_cpu(lg->io_parameter[0]),
2146                     le32_to_cpu(lg->io_parameter[1]));
2147         } else {
2148                 /*EMPTY*/
2149                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1072,
2150                     "Done %s.\n", __func__);
2151         }
2152
2153         dma_pool_free(ha->s_dma_pool, lg, lg_dma);
2154
2155         return rval;
2156 }
2157
2158 /*
2159  * qla2x00_fabric_logout
2160  *      Issue logout fabric port mailbox command.
2161  *
2162  * Input:
2163  *      ha = adapter block pointer.
2164  *      loop_id = device loop ID.
2165  *      TARGET_QUEUE_LOCK must be released.
2166  *      ADAPTER_STATE_LOCK must be released.
2167  *
2168  * Returns:
2169  *      qla2x00 local function return status code.
2170  *
2171  * Context:
2172  *      Kernel context.
2173  */
2174 int
2175 qla2x00_fabric_logout(scsi_qla_host_t *vha, uint16_t loop_id, uint8_t domain,
2176     uint8_t area, uint8_t al_pa)
2177 {
2178         int rval;
2179         mbx_cmd_t mc;
2180         mbx_cmd_t *mcp = &mc;
2181
2182         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1073,
2183             "Entered %s.\n", __func__);
2184
2185         mcp->mb[0] = MBC_LOGOUT_FABRIC_PORT;
2186         mcp->out_mb = MBX_1|MBX_0;
2187         if (HAS_EXTENDED_IDS(vha->hw)) {
2188                 mcp->mb[1] = loop_id;
2189                 mcp->mb[10] = 0;
2190                 mcp->out_mb |= MBX_10;
2191         } else {
2192                 mcp->mb[1] = loop_id << 8;
2193         }
2194
2195         mcp->in_mb = MBX_1|MBX_0;
2196         mcp->tov = MBX_TOV_SECONDS;
2197         mcp->flags = 0;
2198         rval = qla2x00_mailbox_command(vha, mcp);
2199
2200         if (rval != QLA_SUCCESS) {
2201                 /*EMPTY*/
2202                 ql_dbg(ql_dbg_mbx, vha, 0x1074,
2203                     "Failed=%x mb[1]=%x.\n", rval, mcp->mb[1]);
2204         } else {
2205                 /*EMPTY*/
2206                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1075,
2207                     "Done %s.\n", __func__);
2208         }
2209
2210         return rval;
2211 }
2212
2213 /*
2214  * qla2x00_full_login_lip
2215  *      Issue full login LIP mailbox command.
2216  *
2217  * Input:
2218  *      ha = adapter block pointer.
2219  *      TARGET_QUEUE_LOCK must be released.
2220  *      ADAPTER_STATE_LOCK must be released.
2221  *
2222  * Returns:
2223  *      qla2x00 local function return status code.
2224  *
2225  * Context:
2226  *      Kernel context.
2227  */
2228 int
2229 qla2x00_full_login_lip(scsi_qla_host_t *vha)
2230 {
2231         int rval;
2232         mbx_cmd_t mc;
2233         mbx_cmd_t *mcp = &mc;
2234
2235         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1076,
2236             "Entered %s.\n", __func__);
2237
2238         mcp->mb[0] = MBC_LIP_FULL_LOGIN;
2239         mcp->mb[1] = IS_FWI2_CAPABLE(vha->hw) ? BIT_3 : 0;
2240         mcp->mb[2] = 0;
2241         mcp->mb[3] = 0;
2242         mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
2243         mcp->in_mb = MBX_0;
2244         mcp->tov = MBX_TOV_SECONDS;
2245         mcp->flags = 0;
2246         rval = qla2x00_mailbox_command(vha, mcp);
2247
2248         if (rval != QLA_SUCCESS) {
2249                 /*EMPTY*/
2250                 ql_dbg(ql_dbg_mbx, vha, 0x1077, "Failed=%x.\n", rval);
2251         } else {
2252                 /*EMPTY*/
2253                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1078,
2254                     "Done %s.\n", __func__);
2255         }
2256
2257         return rval;
2258 }
2259
2260 /*
2261  * qla2x00_get_id_list
2262  *
2263  * Input:
2264  *      ha = adapter block pointer.
2265  *
2266  * Returns:
2267  *      qla2x00 local function return status code.
2268  *
2269  * Context:
2270  *      Kernel context.
2271  */
2272 int
2273 qla2x00_get_id_list(scsi_qla_host_t *vha, void *id_list, dma_addr_t id_list_dma,
2274     uint16_t *entries)
2275 {
2276         int rval;
2277         mbx_cmd_t mc;
2278         mbx_cmd_t *mcp = &mc;
2279
2280         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1079,
2281             "Entered %s.\n", __func__);
2282
2283         if (id_list == NULL)
2284                 return QLA_FUNCTION_FAILED;
2285
2286         mcp->mb[0] = MBC_GET_ID_LIST;
2287         mcp->out_mb = MBX_0;
2288         if (IS_FWI2_CAPABLE(vha->hw)) {
2289                 mcp->mb[2] = MSW(id_list_dma);
2290                 mcp->mb[3] = LSW(id_list_dma);
2291                 mcp->mb[6] = MSW(MSD(id_list_dma));
2292                 mcp->mb[7] = LSW(MSD(id_list_dma));
2293                 mcp->mb[8] = 0;
2294                 mcp->mb[9] = vha->vp_idx;
2295                 mcp->out_mb |= MBX_9|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2;
2296         } else {
2297                 mcp->mb[1] = MSW(id_list_dma);
2298                 mcp->mb[2] = LSW(id_list_dma);
2299                 mcp->mb[3] = MSW(MSD(id_list_dma));
2300                 mcp->mb[6] = LSW(MSD(id_list_dma));
2301                 mcp->out_mb |= MBX_6|MBX_3|MBX_2|MBX_1;
2302         }
2303         mcp->in_mb = MBX_1|MBX_0;
2304         mcp->tov = MBX_TOV_SECONDS;
2305         mcp->flags = 0;
2306         rval = qla2x00_mailbox_command(vha, mcp);
2307
2308         if (rval != QLA_SUCCESS) {
2309                 /*EMPTY*/
2310                 ql_dbg(ql_dbg_mbx, vha, 0x107a, "Failed=%x.\n", rval);
2311         } else {
2312                 *entries = mcp->mb[1];
2313                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x107b,
2314                     "Done %s.\n", __func__);
2315         }
2316
2317         return rval;
2318 }
2319
2320 /*
2321  * qla2x00_get_resource_cnts
2322  *      Get current firmware resource counts.
2323  *
2324  * Input:
2325  *      ha = adapter block pointer.
2326  *
2327  * Returns:
2328  *      qla2x00 local function return status code.
2329  *
2330  * Context:
2331  *      Kernel context.
2332  */
2333 int
2334 qla2x00_get_resource_cnts(scsi_qla_host_t *vha, uint16_t *cur_xchg_cnt,
2335     uint16_t *orig_xchg_cnt, uint16_t *cur_iocb_cnt,
2336     uint16_t *orig_iocb_cnt, uint16_t *max_npiv_vports, uint16_t *max_fcfs)
2337 {
2338         int rval;
2339         mbx_cmd_t mc;
2340         mbx_cmd_t *mcp = &mc;
2341
2342         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x107c,
2343             "Entered %s.\n", __func__);
2344
2345         mcp->mb[0] = MBC_GET_RESOURCE_COUNTS;
2346         mcp->out_mb = MBX_0;
2347         mcp->in_mb = MBX_11|MBX_10|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
2348         if (IS_QLA81XX(vha->hw) || IS_QLA83XX(vha->hw))
2349                 mcp->in_mb |= MBX_12;
2350         mcp->tov = MBX_TOV_SECONDS;
2351         mcp->flags = 0;
2352         rval = qla2x00_mailbox_command(vha, mcp);
2353
2354         if (rval != QLA_SUCCESS) {
2355                 /*EMPTY*/
2356                 ql_dbg(ql_dbg_mbx, vha, 0x107d,
2357                     "Failed mb[0]=%x.\n", mcp->mb[0]);
2358         } else {
2359                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x107e,
2360                     "Done %s mb1=%x mb2=%x mb3=%x mb6=%x mb7=%x mb10=%x "
2361                     "mb11=%x mb12=%x.\n", __func__, mcp->mb[1], mcp->mb[2],
2362                     mcp->mb[3], mcp->mb[6], mcp->mb[7], mcp->mb[10],
2363                     mcp->mb[11], mcp->mb[12]);
2364
2365                 if (cur_xchg_cnt)
2366                         *cur_xchg_cnt = mcp->mb[3];
2367                 if (orig_xchg_cnt)
2368                         *orig_xchg_cnt = mcp->mb[6];
2369                 if (cur_iocb_cnt)
2370                         *cur_iocb_cnt = mcp->mb[7];
2371                 if (orig_iocb_cnt)
2372                         *orig_iocb_cnt = mcp->mb[10];
2373                 if (vha->hw->flags.npiv_supported && max_npiv_vports)
2374                         *max_npiv_vports = mcp->mb[11];
2375                 if ((IS_QLA81XX(vha->hw) || IS_QLA83XX(vha->hw)) && max_fcfs)
2376                         *max_fcfs = mcp->mb[12];
2377         }
2378
2379         return (rval);
2380 }
2381
2382 /*
2383  * qla2x00_get_fcal_position_map
2384  *      Get FCAL (LILP) position map using mailbox command
2385  *
2386  * Input:
2387  *      ha = adapter state pointer.
2388  *      pos_map = buffer pointer (can be NULL).
2389  *
2390  * Returns:
2391  *      qla2x00 local function return status code.
2392  *
2393  * Context:
2394  *      Kernel context.
2395  */
2396 int
2397 qla2x00_get_fcal_position_map(scsi_qla_host_t *vha, char *pos_map)
2398 {
2399         int rval;
2400         mbx_cmd_t mc;
2401         mbx_cmd_t *mcp = &mc;
2402         char *pmap;
2403         dma_addr_t pmap_dma;
2404         struct qla_hw_data *ha = vha->hw;
2405
2406         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x107f,
2407             "Entered %s.\n", __func__);
2408
2409         pmap = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &pmap_dma);
2410         if (pmap  == NULL) {
2411                 ql_log(ql_log_warn, vha, 0x1080,
2412                     "Memory alloc failed.\n");
2413                 return QLA_MEMORY_ALLOC_FAILED;
2414         }
2415         memset(pmap, 0, FCAL_MAP_SIZE);
2416
2417         mcp->mb[0] = MBC_GET_FC_AL_POSITION_MAP;
2418         mcp->mb[2] = MSW(pmap_dma);
2419         mcp->mb[3] = LSW(pmap_dma);
2420         mcp->mb[6] = MSW(MSD(pmap_dma));
2421         mcp->mb[7] = LSW(MSD(pmap_dma));
2422         mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_0;
2423         mcp->in_mb = MBX_1|MBX_0;
2424         mcp->buf_size = FCAL_MAP_SIZE;
2425         mcp->flags = MBX_DMA_IN;
2426         mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2);
2427         rval = qla2x00_mailbox_command(vha, mcp);
2428
2429         if (rval == QLA_SUCCESS) {
2430                 ql_dbg(ql_dbg_mbx + ql_dbg_buffer, vha, 0x1081,
2431                     "mb0/mb1=%x/%X FC/AL position map size (%x).\n",
2432                     mcp->mb[0], mcp->mb[1], (unsigned)pmap[0]);
2433                 ql_dump_buffer(ql_dbg_mbx + ql_dbg_buffer, vha, 0x111d,
2434                     pmap, pmap[0] + 1);
2435
2436                 if (pos_map)
2437                         memcpy(pos_map, pmap, FCAL_MAP_SIZE);
2438         }
2439         dma_pool_free(ha->s_dma_pool, pmap, pmap_dma);
2440
2441         if (rval != QLA_SUCCESS) {
2442                 ql_dbg(ql_dbg_mbx, vha, 0x1082, "Failed=%x.\n", rval);
2443         } else {
2444                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1083,
2445                     "Done %s.\n", __func__);
2446         }
2447
2448         return rval;
2449 }
2450
2451 /*
2452  * qla2x00_get_link_status
2453  *
2454  * Input:
2455  *      ha = adapter block pointer.
2456  *      loop_id = device loop ID.
2457  *      ret_buf = pointer to link status return buffer.
2458  *
2459  * Returns:
2460  *      0 = success.
2461  *      BIT_0 = mem alloc error.
2462  *      BIT_1 = mailbox error.
2463  */
2464 int
2465 qla2x00_get_link_status(scsi_qla_host_t *vha, uint16_t loop_id,
2466     struct link_statistics *stats, dma_addr_t stats_dma)
2467 {
2468         int rval;
2469         mbx_cmd_t mc;
2470         mbx_cmd_t *mcp = &mc;
2471         uint32_t *siter, *diter, dwords;
2472         struct qla_hw_data *ha = vha->hw;
2473
2474         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1084,
2475             "Entered %s.\n", __func__);
2476
2477         mcp->mb[0] = MBC_GET_LINK_STATUS;
2478         mcp->mb[2] = MSW(stats_dma);
2479         mcp->mb[3] = LSW(stats_dma);
2480         mcp->mb[6] = MSW(MSD(stats_dma));
2481         mcp->mb[7] = LSW(MSD(stats_dma));
2482         mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_0;
2483         mcp->in_mb = MBX_0;
2484         if (IS_FWI2_CAPABLE(ha)) {
2485                 mcp->mb[1] = loop_id;
2486                 mcp->mb[4] = 0;
2487                 mcp->mb[10] = 0;
2488                 mcp->out_mb |= MBX_10|MBX_4|MBX_1;
2489                 mcp->in_mb |= MBX_1;
2490         } else if (HAS_EXTENDED_IDS(ha)) {
2491                 mcp->mb[1] = loop_id;
2492                 mcp->mb[10] = 0;
2493                 mcp->out_mb |= MBX_10|MBX_1;
2494         } else {
2495                 mcp->mb[1] = loop_id << 8;
2496                 mcp->out_mb |= MBX_1;
2497         }
2498         mcp->tov = MBX_TOV_SECONDS;
2499         mcp->flags = IOCTL_CMD;
2500         rval = qla2x00_mailbox_command(vha, mcp);
2501
2502         if (rval == QLA_SUCCESS) {
2503                 if (mcp->mb[0] != MBS_COMMAND_COMPLETE) {
2504                         ql_dbg(ql_dbg_mbx, vha, 0x1085,
2505                             "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
2506                         rval = QLA_FUNCTION_FAILED;
2507                 } else {
2508                         /* Copy over data -- firmware data is LE. */
2509                         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1086,
2510                             "Done %s.\n", __func__);
2511                         dwords = offsetof(struct link_statistics, unused1) / 4;
2512                         siter = diter = &stats->link_fail_cnt;
2513                         while (dwords--)
2514                                 *diter++ = le32_to_cpu(*siter++);
2515                 }
2516         } else {
2517                 /* Failed. */
2518                 ql_dbg(ql_dbg_mbx, vha, 0x1087, "Failed=%x.\n", rval);
2519         }
2520
2521         return rval;
2522 }
2523
2524 int
2525 qla24xx_get_isp_stats(scsi_qla_host_t *vha, struct link_statistics *stats,
2526     dma_addr_t stats_dma)
2527 {
2528         int rval;
2529         mbx_cmd_t mc;
2530         mbx_cmd_t *mcp = &mc;
2531         uint32_t *siter, *diter, dwords;
2532
2533         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1088,
2534             "Entered %s.\n", __func__);
2535
2536         mcp->mb[0] = MBC_GET_LINK_PRIV_STATS;
2537         mcp->mb[2] = MSW(stats_dma);
2538         mcp->mb[3] = LSW(stats_dma);
2539         mcp->mb[6] = MSW(MSD(stats_dma));
2540         mcp->mb[7] = LSW(MSD(stats_dma));
2541         mcp->mb[8] = sizeof(struct link_statistics) / 4;
2542         mcp->mb[9] = vha->vp_idx;
2543         mcp->mb[10] = 0;
2544         mcp->out_mb = MBX_10|MBX_9|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_0;
2545         mcp->in_mb = MBX_2|MBX_1|MBX_0;
2546         mcp->tov = MBX_TOV_SECONDS;
2547         mcp->flags = IOCTL_CMD;
2548         rval = qla2x00_mailbox_command(vha, mcp);
2549
2550         if (rval == QLA_SUCCESS) {
2551                 if (mcp->mb[0] != MBS_COMMAND_COMPLETE) {
2552                         ql_dbg(ql_dbg_mbx, vha, 0x1089,
2553                             "Failed mb[0]=%x.\n", mcp->mb[0]);
2554                         rval = QLA_FUNCTION_FAILED;
2555                 } else {
2556                         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x108a,
2557                             "Done %s.\n", __func__);
2558                         /* Copy over data -- firmware data is LE. */
2559                         dwords = sizeof(struct link_statistics) / 4;
2560                         siter = diter = &stats->link_fail_cnt;
2561                         while (dwords--)
2562                                 *diter++ = le32_to_cpu(*siter++);
2563                 }
2564         } else {
2565                 /* Failed. */
2566                 ql_dbg(ql_dbg_mbx, vha, 0x108b, "Failed=%x.\n", rval);
2567         }
2568
2569         return rval;
2570 }
2571
2572 int
2573 qla24xx_abort_command(srb_t *sp)
2574 {
2575         int             rval;
2576         unsigned long   flags = 0;
2577
2578         struct abort_entry_24xx *abt;
2579         dma_addr_t      abt_dma;
2580         uint32_t        handle;
2581         fc_port_t       *fcport = sp->fcport;
2582         struct scsi_qla_host *vha = fcport->vha;
2583         struct qla_hw_data *ha = vha->hw;
2584         struct req_que *req = vha->req;
2585
2586         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x108c,
2587             "Entered %s.\n", __func__);
2588
2589         spin_lock_irqsave(&ha->hardware_lock, flags);
2590         for (handle = 1; handle < req->num_outstanding_cmds; handle++) {
2591                 if (req->outstanding_cmds[handle] == sp)
2592                         break;
2593         }
2594         spin_unlock_irqrestore(&ha->hardware_lock, flags);
2595         if (handle == req->num_outstanding_cmds) {
2596                 /* Command not found. */
2597                 return QLA_FUNCTION_FAILED;
2598         }
2599
2600         abt = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &abt_dma);
2601         if (abt == NULL) {
2602                 ql_log(ql_log_warn, vha, 0x108d,
2603                     "Failed to allocate abort IOCB.\n");
2604                 return QLA_MEMORY_ALLOC_FAILED;
2605         }
2606         memset(abt, 0, sizeof(struct abort_entry_24xx));
2607
2608         abt->entry_type = ABORT_IOCB_TYPE;
2609         abt->entry_count = 1;
2610         abt->handle = MAKE_HANDLE(req->id, abt->handle);
2611         abt->nport_handle = cpu_to_le16(fcport->loop_id);
2612         abt->handle_to_abort = MAKE_HANDLE(req->id, handle);
2613         abt->port_id[0] = fcport->d_id.b.al_pa;
2614         abt->port_id[1] = fcport->d_id.b.area;
2615         abt->port_id[2] = fcport->d_id.b.domain;
2616         abt->vp_index = fcport->vha->vp_idx;
2617
2618         abt->req_que_no = cpu_to_le16(req->id);
2619
2620         rval = qla2x00_issue_iocb(vha, abt, abt_dma, 0);
2621         if (rval != QLA_SUCCESS) {
2622                 ql_dbg(ql_dbg_mbx, vha, 0x108e,
2623                     "Failed to issue IOCB (%x).\n", rval);
2624         } else if (abt->entry_status != 0) {
2625                 ql_dbg(ql_dbg_mbx, vha, 0x108f,
2626                     "Failed to complete IOCB -- error status (%x).\n",
2627                     abt->entry_status);
2628                 rval = QLA_FUNCTION_FAILED;
2629         } else if (abt->nport_handle != __constant_cpu_to_le16(0)) {
2630                 ql_dbg(ql_dbg_mbx, vha, 0x1090,
2631                     "Failed to complete IOCB -- completion status (%x).\n",
2632                     le16_to_cpu(abt->nport_handle));
2633                 rval = QLA_FUNCTION_FAILED;
2634         } else {
2635                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1091,
2636                     "Done %s.\n", __func__);
2637         }
2638
2639         dma_pool_free(ha->s_dma_pool, abt, abt_dma);
2640
2641         return rval;
2642 }
2643
2644 struct tsk_mgmt_cmd {
2645         union {
2646                 struct tsk_mgmt_entry tsk;
2647                 struct sts_entry_24xx sts;
2648         } p;
2649 };
2650
2651 static int
2652 __qla24xx_issue_tmf(char *name, uint32_t type, struct fc_port *fcport,
2653     unsigned int l, int tag)
2654 {
2655         int             rval, rval2;
2656         struct tsk_mgmt_cmd *tsk;
2657         struct sts_entry_24xx *sts;
2658         dma_addr_t      tsk_dma;
2659         scsi_qla_host_t *vha;
2660         struct qla_hw_data *ha;
2661         struct req_que *req;
2662         struct rsp_que *rsp;
2663
2664         vha = fcport->vha;
2665         ha = vha->hw;
2666         req = vha->req;
2667
2668         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1092,
2669             "Entered %s.\n", __func__);
2670
2671         if (ha->flags.cpu_affinity_enabled)
2672                 rsp = ha->rsp_q_map[tag + 1];
2673         else
2674                 rsp = req->rsp;
2675         tsk = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &tsk_dma);
2676         if (tsk == NULL) {
2677                 ql_log(ql_log_warn, vha, 0x1093,
2678                     "Failed to allocate task management IOCB.\n");
2679                 return QLA_MEMORY_ALLOC_FAILED;
2680         }
2681         memset(tsk, 0, sizeof(struct tsk_mgmt_cmd));
2682
2683         tsk->p.tsk.entry_type = TSK_MGMT_IOCB_TYPE;
2684         tsk->p.tsk.entry_count = 1;
2685         tsk->p.tsk.handle = MAKE_HANDLE(req->id, tsk->p.tsk.handle);
2686         tsk->p.tsk.nport_handle = cpu_to_le16(fcport->loop_id);
2687         tsk->p.tsk.timeout = cpu_to_le16(ha->r_a_tov / 10 * 2);
2688         tsk->p.tsk.control_flags = cpu_to_le32(type);
2689         tsk->p.tsk.port_id[0] = fcport->d_id.b.al_pa;
2690         tsk->p.tsk.port_id[1] = fcport->d_id.b.area;
2691         tsk->p.tsk.port_id[2] = fcport->d_id.b.domain;
2692         tsk->p.tsk.vp_index = fcport->vha->vp_idx;
2693         if (type == TCF_LUN_RESET) {
2694                 int_to_scsilun(l, &tsk->p.tsk.lun);
2695                 host_to_fcp_swap((uint8_t *)&tsk->p.tsk.lun,
2696                     sizeof(tsk->p.tsk.lun));
2697         }
2698
2699         sts = &tsk->p.sts;
2700         rval = qla2x00_issue_iocb(vha, tsk, tsk_dma, 0);
2701         if (rval != QLA_SUCCESS) {
2702                 ql_dbg(ql_dbg_mbx, vha, 0x1094,
2703                     "Failed to issue %s reset IOCB (%x).\n", name, rval);
2704         } else if (sts->entry_status != 0) {
2705                 ql_dbg(ql_dbg_mbx, vha, 0x1095,
2706                     "Failed to complete IOCB -- error status (%x).\n",
2707                     sts->entry_status);
2708                 rval = QLA_FUNCTION_FAILED;
2709         } else if (sts->comp_status !=
2710             __constant_cpu_to_le16(CS_COMPLETE)) {
2711                 ql_dbg(ql_dbg_mbx, vha, 0x1096,
2712                     "Failed to complete IOCB -- completion status (%x).\n",
2713                     le16_to_cpu(sts->comp_status));
2714                 rval = QLA_FUNCTION_FAILED;
2715         } else if (le16_to_cpu(sts->scsi_status) &
2716             SS_RESPONSE_INFO_LEN_VALID) {
2717                 if (le32_to_cpu(sts->rsp_data_len) < 4) {
2718                         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1097,
2719                             "Ignoring inconsistent data length -- not enough "
2720                             "response info (%d).\n",
2721                             le32_to_cpu(sts->rsp_data_len));
2722                 } else if (sts->data[3]) {
2723                         ql_dbg(ql_dbg_mbx, vha, 0x1098,
2724                             "Failed to complete IOCB -- response (%x).\n",
2725                             sts->data[3]);
2726                         rval = QLA_FUNCTION_FAILED;
2727                 }
2728         }
2729
2730         /* Issue marker IOCB. */
2731         rval2 = qla2x00_marker(vha, req, rsp, fcport->loop_id, l,
2732             type == TCF_LUN_RESET ? MK_SYNC_ID_LUN: MK_SYNC_ID);
2733         if (rval2 != QLA_SUCCESS) {
2734                 ql_dbg(ql_dbg_mbx, vha, 0x1099,
2735                     "Failed to issue marker IOCB (%x).\n", rval2);
2736         } else {
2737                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x109a,
2738                     "Done %s.\n", __func__);
2739         }
2740
2741         dma_pool_free(ha->s_dma_pool, tsk, tsk_dma);
2742
2743         return rval;
2744 }
2745
2746 int
2747 qla24xx_abort_target(struct fc_port *fcport, unsigned int l, int tag)
2748 {
2749         struct qla_hw_data *ha = fcport->vha->hw;
2750
2751         if ((ql2xasynctmfenable) && IS_FWI2_CAPABLE(ha))
2752                 return qla2x00_async_tm_cmd(fcport, TCF_TARGET_RESET, l, tag);
2753
2754         return __qla24xx_issue_tmf("Target", TCF_TARGET_RESET, fcport, l, tag);
2755 }
2756
2757 int
2758 qla24xx_lun_reset(struct fc_port *fcport, unsigned int l, int tag)
2759 {
2760         struct qla_hw_data *ha = fcport->vha->hw;
2761
2762         if ((ql2xasynctmfenable) && IS_FWI2_CAPABLE(ha))
2763                 return qla2x00_async_tm_cmd(fcport, TCF_LUN_RESET, l, tag);
2764
2765         return __qla24xx_issue_tmf("Lun", TCF_LUN_RESET, fcport, l, tag);
2766 }
2767
2768 int
2769 qla2x00_system_error(scsi_qla_host_t *vha)
2770 {
2771         int rval;
2772         mbx_cmd_t mc;
2773         mbx_cmd_t *mcp = &mc;
2774         struct qla_hw_data *ha = vha->hw;
2775
2776         if (!IS_QLA23XX(ha) && !IS_FWI2_CAPABLE(ha))
2777                 return QLA_FUNCTION_FAILED;
2778
2779         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x109b,
2780             "Entered %s.\n", __func__);
2781
2782         mcp->mb[0] = MBC_GEN_SYSTEM_ERROR;
2783         mcp->out_mb = MBX_0;
2784         mcp->in_mb = MBX_0;
2785         mcp->tov = 5;
2786         mcp->flags = 0;
2787         rval = qla2x00_mailbox_command(vha, mcp);
2788
2789         if (rval != QLA_SUCCESS) {
2790                 ql_dbg(ql_dbg_mbx, vha, 0x109c, "Failed=%x.\n", rval);
2791         } else {
2792                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x109d,
2793                     "Done %s.\n", __func__);
2794         }
2795
2796         return rval;
2797 }
2798
2799 /**
2800  * qla2x00_set_serdes_params() -
2801  * @ha: HA context
2802  *
2803  * Returns
2804  */
2805 int
2806 qla2x00_set_serdes_params(scsi_qla_host_t *vha, uint16_t sw_em_1g,
2807     uint16_t sw_em_2g, uint16_t sw_em_4g)
2808 {
2809         int rval;
2810         mbx_cmd_t mc;
2811         mbx_cmd_t *mcp = &mc;
2812
2813         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x109e,
2814             "Entered %s.\n", __func__);
2815
2816         mcp->mb[0] = MBC_SERDES_PARAMS;
2817         mcp->mb[1] = BIT_0;
2818         mcp->mb[2] = sw_em_1g | BIT_15;
2819         mcp->mb[3] = sw_em_2g | BIT_15;
2820         mcp->mb[4] = sw_em_4g | BIT_15;
2821         mcp->out_mb = MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
2822         mcp->in_mb = MBX_0;
2823         mcp->tov = MBX_TOV_SECONDS;
2824         mcp->flags = 0;
2825         rval = qla2x00_mailbox_command(vha, mcp);
2826
2827         if (rval != QLA_SUCCESS) {
2828                 /*EMPTY*/
2829                 ql_dbg(ql_dbg_mbx, vha, 0x109f,
2830                     "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
2831         } else {
2832                 /*EMPTY*/
2833                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10a0,
2834                     "Done %s.\n", __func__);
2835         }
2836
2837         return rval;
2838 }
2839
2840 int
2841 qla2x00_stop_firmware(scsi_qla_host_t *vha)
2842 {
2843         int rval;
2844         mbx_cmd_t mc;
2845         mbx_cmd_t *mcp = &mc;
2846
2847         if (!IS_FWI2_CAPABLE(vha->hw))
2848                 return QLA_FUNCTION_FAILED;
2849
2850         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10a1,
2851             "Entered %s.\n", __func__);
2852
2853         mcp->mb[0] = MBC_STOP_FIRMWARE;
2854         mcp->mb[1] = 0;
2855         mcp->out_mb = MBX_1|MBX_0;
2856         mcp->in_mb = MBX_0;
2857         mcp->tov = 5;
2858         mcp->flags = 0;
2859         rval = qla2x00_mailbox_command(vha, mcp);
2860
2861         if (rval != QLA_SUCCESS) {
2862                 ql_dbg(ql_dbg_mbx, vha, 0x10a2, "Failed=%x.\n", rval);
2863                 if (mcp->mb[0] == MBS_INVALID_COMMAND)
2864                         rval = QLA_INVALID_COMMAND;
2865         } else {
2866                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10a3,
2867                     "Done %s.\n", __func__);
2868         }
2869
2870         return rval;
2871 }
2872
2873 int
2874 qla2x00_enable_eft_trace(scsi_qla_host_t *vha, dma_addr_t eft_dma,
2875     uint16_t buffers)
2876 {
2877         int rval;
2878         mbx_cmd_t mc;
2879         mbx_cmd_t *mcp = &mc;
2880
2881         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10a4,
2882             "Entered %s.\n", __func__);
2883
2884         if (!IS_FWI2_CAPABLE(vha->hw))
2885                 return QLA_FUNCTION_FAILED;
2886
2887         if (unlikely(pci_channel_offline(vha->hw->pdev)))
2888                 return QLA_FUNCTION_FAILED;
2889
2890         mcp->mb[0] = MBC_TRACE_CONTROL;
2891         mcp->mb[1] = TC_EFT_ENABLE;
2892         mcp->mb[2] = LSW(eft_dma);
2893         mcp->mb[3] = MSW(eft_dma);
2894         mcp->mb[4] = LSW(MSD(eft_dma));
2895         mcp->mb[5] = MSW(MSD(eft_dma));
2896         mcp->mb[6] = buffers;
2897         mcp->mb[7] = TC_AEN_DISABLE;
2898         mcp->out_mb = MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
2899         mcp->in_mb = MBX_1|MBX_0;
2900         mcp->tov = MBX_TOV_SECONDS;
2901         mcp->flags = 0;
2902         rval = qla2x00_mailbox_command(vha, mcp);
2903         if (rval != QLA_SUCCESS) {
2904                 ql_dbg(ql_dbg_mbx, vha, 0x10a5,
2905                     "Failed=%x mb[0]=%x mb[1]=%x.\n",
2906                     rval, mcp->mb[0], mcp->mb[1]);
2907         } else {
2908                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10a6,
2909                     "Done %s.\n", __func__);
2910         }
2911
2912         return rval;
2913 }
2914
2915 int
2916 qla2x00_disable_eft_trace(scsi_qla_host_t *vha)
2917 {
2918         int rval;
2919         mbx_cmd_t mc;
2920         mbx_cmd_t *mcp = &mc;
2921
2922         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10a7,
2923             "Entered %s.\n", __func__);
2924
2925         if (!IS_FWI2_CAPABLE(vha->hw))
2926                 return QLA_FUNCTION_FAILED;
2927
2928         if (unlikely(pci_channel_offline(vha->hw->pdev)))
2929                 return QLA_FUNCTION_FAILED;
2930
2931         mcp->mb[0] = MBC_TRACE_CONTROL;
2932         mcp->mb[1] = TC_EFT_DISABLE;
2933         mcp->out_mb = MBX_1|MBX_0;
2934         mcp->in_mb = MBX_1|MBX_0;
2935         mcp->tov = MBX_TOV_SECONDS;
2936         mcp->flags = 0;
2937         rval = qla2x00_mailbox_command(vha, mcp);
2938         if (rval != QLA_SUCCESS) {
2939                 ql_dbg(ql_dbg_mbx, vha, 0x10a8,
2940                     "Failed=%x mb[0]=%x mb[1]=%x.\n",
2941                     rval, mcp->mb[0], mcp->mb[1]);
2942         } else {
2943                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10a9,
2944                     "Done %s.\n", __func__);
2945         }
2946
2947         return rval;
2948 }
2949
2950 int
2951 qla2x00_enable_fce_trace(scsi_qla_host_t *vha, dma_addr_t fce_dma,
2952     uint16_t buffers, uint16_t *mb, uint32_t *dwords)
2953 {
2954         int rval;
2955         mbx_cmd_t mc;
2956         mbx_cmd_t *mcp = &mc;
2957
2958         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10aa,
2959             "Entered %s.\n", __func__);
2960
2961         if (!IS_QLA25XX(vha->hw) && !IS_QLA81XX(vha->hw) &&
2962             !IS_QLA83XX(vha->hw))
2963                 return QLA_FUNCTION_FAILED;
2964
2965         if (unlikely(pci_channel_offline(vha->hw->pdev)))
2966                 return QLA_FUNCTION_FAILED;
2967
2968         mcp->mb[0] = MBC_TRACE_CONTROL;
2969         mcp->mb[1] = TC_FCE_ENABLE;
2970         mcp->mb[2] = LSW(fce_dma);
2971         mcp->mb[3] = MSW(fce_dma);
2972         mcp->mb[4] = LSW(MSD(fce_dma));
2973         mcp->mb[5] = MSW(MSD(fce_dma));
2974         mcp->mb[6] = buffers;
2975         mcp->mb[7] = TC_AEN_DISABLE;
2976         mcp->mb[8] = 0;
2977         mcp->mb[9] = TC_FCE_DEFAULT_RX_SIZE;
2978         mcp->mb[10] = TC_FCE_DEFAULT_TX_SIZE;
2979         mcp->out_mb = MBX_10|MBX_9|MBX_8|MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|
2980             MBX_1|MBX_0;
2981         mcp->in_mb = MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
2982         mcp->tov = MBX_TOV_SECONDS;
2983         mcp->flags = 0;
2984         rval = qla2x00_mailbox_command(vha, mcp);
2985         if (rval != QLA_SUCCESS) {
2986                 ql_dbg(ql_dbg_mbx, vha, 0x10ab,
2987                     "Failed=%x mb[0]=%x mb[1]=%x.\n",
2988                     rval, mcp->mb[0], mcp->mb[1]);
2989         } else {
2990                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10ac,
2991                     "Done %s.\n", __func__);
2992
2993                 if (mb)
2994                         memcpy(mb, mcp->mb, 8 * sizeof(*mb));
2995                 if (dwords)
2996                         *dwords = buffers;
2997         }
2998
2999         return rval;
3000 }
3001
3002 int
3003 qla2x00_disable_fce_trace(scsi_qla_host_t *vha, uint64_t *wr, uint64_t *rd)
3004 {
3005         int rval;
3006         mbx_cmd_t mc;
3007         mbx_cmd_t *mcp = &mc;
3008
3009         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10ad,
3010             "Entered %s.\n", __func__);
3011
3012         if (!IS_FWI2_CAPABLE(vha->hw))
3013                 return QLA_FUNCTION_FAILED;
3014
3015         if (unlikely(pci_channel_offline(vha->hw->pdev)))
3016                 return QLA_FUNCTION_FAILED;
3017
3018         mcp->mb[0] = MBC_TRACE_CONTROL;
3019         mcp->mb[1] = TC_FCE_DISABLE;
3020         mcp->mb[2] = TC_FCE_DISABLE_TRACE;
3021         mcp->out_mb = MBX_2|MBX_1|MBX_0;
3022         mcp->in_mb = MBX_9|MBX_8|MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|
3023             MBX_1|MBX_0;
3024         mcp->tov = MBX_TOV_SECONDS;
3025         mcp->flags = 0;
3026         rval = qla2x00_mailbox_command(vha, mcp);
3027         if (rval != QLA_SUCCESS) {
3028                 ql_dbg(ql_dbg_mbx, vha, 0x10ae,
3029                     "Failed=%x mb[0]=%x mb[1]=%x.\n",
3030                     rval, mcp->mb[0], mcp->mb[1]);
3031         } else {
3032                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10af,
3033                     "Done %s.\n", __func__);
3034
3035                 if (wr)
3036                         *wr = (uint64_t) mcp->mb[5] << 48 |
3037                             (uint64_t) mcp->mb[4] << 32 |
3038                             (uint64_t) mcp->mb[3] << 16 |
3039                             (uint64_t) mcp->mb[2];
3040                 if (rd)
3041                         *rd = (uint64_t) mcp->mb[9] << 48 |
3042                             (uint64_t) mcp->mb[8] << 32 |
3043                             (uint64_t) mcp->mb[7] << 16 |
3044                             (uint64_t) mcp->mb[6];
3045         }
3046
3047         return rval;
3048 }
3049
3050 int
3051 qla2x00_get_idma_speed(scsi_qla_host_t *vha, uint16_t loop_id,
3052         uint16_t *port_speed, uint16_t *mb)
3053 {
3054         int rval;
3055         mbx_cmd_t mc;
3056         mbx_cmd_t *mcp = &mc;
3057
3058         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10b0,
3059             "Entered %s.\n", __func__);
3060
3061         if (!IS_IIDMA_CAPABLE(vha->hw))
3062                 return QLA_FUNCTION_FAILED;
3063
3064         mcp->mb[0] = MBC_PORT_PARAMS;
3065         mcp->mb[1] = loop_id;
3066         mcp->mb[2] = mcp->mb[3] = 0;
3067         mcp->mb[9] = vha->vp_idx;
3068         mcp->out_mb = MBX_9|MBX_3|MBX_2|MBX_1|MBX_0;
3069         mcp->in_mb = MBX_3|MBX_1|MBX_0;
3070         mcp->tov = MBX_TOV_SECONDS;
3071         mcp->flags = 0;
3072         rval = qla2x00_mailbox_command(vha, mcp);
3073
3074         /* Return mailbox statuses. */
3075         if (mb != NULL) {
3076                 mb[0] = mcp->mb[0];
3077                 mb[1] = mcp->mb[1];
3078                 mb[3] = mcp->mb[3];
3079         }
3080
3081         if (rval != QLA_SUCCESS) {
3082                 ql_dbg(ql_dbg_mbx, vha, 0x10b1, "Failed=%x.\n", rval);
3083         } else {
3084                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10b2,
3085                     "Done %s.\n", __func__);
3086                 if (port_speed)
3087                         *port_speed = mcp->mb[3];
3088         }
3089
3090         return rval;
3091 }
3092
3093 int
3094 qla2x00_set_idma_speed(scsi_qla_host_t *vha, uint16_t loop_id,
3095     uint16_t port_speed, uint16_t *mb)
3096 {
3097         int rval;
3098         mbx_cmd_t mc;
3099         mbx_cmd_t *mcp = &mc;
3100
3101         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10b3,
3102             "Entered %s.\n", __func__);
3103
3104         if (!IS_IIDMA_CAPABLE(vha->hw))
3105                 return QLA_FUNCTION_FAILED;
3106
3107         mcp->mb[0] = MBC_PORT_PARAMS;
3108         mcp->mb[1] = loop_id;
3109         mcp->mb[2] = BIT_0;
3110         if (IS_CNA_CAPABLE(vha->hw))
3111                 mcp->mb[3] = port_speed & (BIT_5|BIT_4|BIT_3|BIT_2|BIT_1|BIT_0);
3112         else
3113                 mcp->mb[3] = port_speed & (BIT_2|BIT_1|BIT_0);
3114         mcp->mb[9] = vha->vp_idx;
3115         mcp->out_mb = MBX_9|MBX_3|MBX_2|MBX_1|MBX_0;
3116         mcp->in_mb = MBX_3|MBX_1|MBX_0;
3117         mcp->tov = MBX_TOV_SECONDS;
3118         mcp->flags = 0;
3119         rval = qla2x00_mailbox_command(vha, mcp);
3120
3121         /* Return mailbox statuses. */
3122         if (mb != NULL) {
3123                 mb[0] = mcp->mb[0];
3124                 mb[1] = mcp->mb[1];
3125                 mb[3] = mcp->mb[3];
3126         }
3127
3128         if (rval != QLA_SUCCESS) {
3129                 ql_dbg(ql_dbg_mbx, vha, 0x10b4,
3130                     "Failed=%x.\n", rval);
3131         } else {
3132                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10b5,
3133                     "Done %s.\n", __func__);
3134         }
3135
3136         return rval;
3137 }
3138
3139 void
3140 qla24xx_report_id_acquisition(scsi_qla_host_t *vha,
3141         struct vp_rpt_id_entry_24xx *rptid_entry)
3142 {
3143         uint8_t vp_idx;
3144         uint16_t stat = le16_to_cpu(rptid_entry->vp_idx);
3145         struct qla_hw_data *ha = vha->hw;
3146         scsi_qla_host_t *vp;
3147         unsigned long   flags;
3148         int found;
3149
3150         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10b6,
3151             "Entered %s.\n", __func__);
3152
3153         if (rptid_entry->entry_status != 0)
3154                 return;
3155
3156         if (rptid_entry->format == 0) {
3157                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10b7,
3158                     "Format 0 : Number of VPs setup %d, number of "
3159                     "VPs acquired %d.\n",
3160                     MSB(le16_to_cpu(rptid_entry->vp_count)),
3161                     LSB(le16_to_cpu(rptid_entry->vp_count)));
3162                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10b8,
3163                     "Primary port id %02x%02x%02x.\n",
3164                     rptid_entry->port_id[2], rptid_entry->port_id[1],
3165                     rptid_entry->port_id[0]);
3166         } else if (rptid_entry->format == 1) {
3167                 vp_idx = LSB(stat);
3168                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10b9,
3169                     "Format 1: VP[%d] enabled - status %d - with "
3170                     "port id %02x%02x%02x.\n", vp_idx, MSB(stat),
3171                     rptid_entry->port_id[2], rptid_entry->port_id[1],
3172                     rptid_entry->port_id[0]);
3173
3174                 vp = vha;
3175                 if (vp_idx == 0 && (MSB(stat) != 1))
3176                         goto reg_needed;
3177
3178                 if (MSB(stat) != 0 && MSB(stat) != 2) {
3179                         ql_dbg(ql_dbg_mbx, vha, 0x10ba,
3180                             "Could not acquire ID for VP[%d].\n", vp_idx);
3181                         return;
3182                 }
3183
3184                 found = 0;
3185                 spin_lock_irqsave(&ha->vport_slock, flags);
3186                 list_for_each_entry(vp, &ha->vp_list, list) {
3187                         if (vp_idx == vp->vp_idx) {
3188                                 found = 1;
3189                                 break;
3190                         }
3191                 }
3192                 spin_unlock_irqrestore(&ha->vport_slock, flags);
3193
3194                 if (!found)
3195                         return;
3196
3197                 vp->d_id.b.domain = rptid_entry->port_id[2];
3198                 vp->d_id.b.area =  rptid_entry->port_id[1];
3199                 vp->d_id.b.al_pa = rptid_entry->port_id[0];
3200
3201                 /*
3202                  * Cannot configure here as we are still sitting on the
3203                  * response queue. Handle it in dpc context.
3204                  */
3205                 set_bit(VP_IDX_ACQUIRED, &vp->vp_flags);
3206
3207 reg_needed:
3208                 set_bit(REGISTER_FC4_NEEDED, &vp->dpc_flags);
3209                 set_bit(REGISTER_FDMI_NEEDED, &vp->dpc_flags);
3210                 set_bit(VP_DPC_NEEDED, &vha->dpc_flags);
3211                 qla2xxx_wake_dpc(vha);
3212         }
3213 }
3214
3215 /*
3216  * qla24xx_modify_vp_config
3217  *      Change VP configuration for vha
3218  *
3219  * Input:
3220  *      vha = adapter block pointer.
3221  *
3222  * Returns:
3223  *      qla2xxx local function return status code.
3224  *
3225  * Context:
3226  *      Kernel context.
3227  */
3228 int
3229 qla24xx_modify_vp_config(scsi_qla_host_t *vha)
3230 {
3231         int             rval;
3232         struct vp_config_entry_24xx *vpmod;
3233         dma_addr_t      vpmod_dma;
3234         struct qla_hw_data *ha = vha->hw;
3235         struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev);
3236
3237         /* This can be called by the parent */
3238
3239         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10bb,
3240             "Entered %s.\n", __func__);
3241
3242         vpmod = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &vpmod_dma);
3243         if (!vpmod) {
3244                 ql_log(ql_log_warn, vha, 0x10bc,
3245                     "Failed to allocate modify VP IOCB.\n");
3246                 return QLA_MEMORY_ALLOC_FAILED;
3247         }
3248
3249         memset(vpmod, 0, sizeof(struct vp_config_entry_24xx));
3250         vpmod->entry_type = VP_CONFIG_IOCB_TYPE;
3251         vpmod->entry_count = 1;
3252         vpmod->command = VCT_COMMAND_MOD_ENABLE_VPS;
3253         vpmod->vp_count = 1;
3254         vpmod->vp_index1 = vha->vp_idx;
3255         vpmod->options_idx1 = BIT_3|BIT_4|BIT_5;
3256
3257         qlt_modify_vp_config(vha, vpmod);
3258
3259         memcpy(vpmod->node_name_idx1, vha->node_name, WWN_SIZE);
3260         memcpy(vpmod->port_name_idx1, vha->port_name, WWN_SIZE);
3261         vpmod->entry_count = 1;
3262
3263         rval = qla2x00_issue_iocb(base_vha, vpmod, vpmod_dma, 0);
3264         if (rval != QLA_SUCCESS) {
3265                 ql_dbg(ql_dbg_mbx, vha, 0x10bd,
3266                     "Failed to issue VP config IOCB (%x).\n", rval);
3267         } else if (vpmod->comp_status != 0) {
3268                 ql_dbg(ql_dbg_mbx, vha, 0x10be,
3269                     "Failed to complete IOCB -- error status (%x).\n",
3270                     vpmod->comp_status);
3271                 rval = QLA_FUNCTION_FAILED;
3272         } else if (vpmod->comp_status != __constant_cpu_to_le16(CS_COMPLETE)) {
3273                 ql_dbg(ql_dbg_mbx, vha, 0x10bf,
3274                     "Failed to complete IOCB -- completion status (%x).\n",
3275                     le16_to_cpu(vpmod->comp_status));
3276                 rval = QLA_FUNCTION_FAILED;
3277         } else {
3278                 /* EMPTY */
3279                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10c0,
3280                     "Done %s.\n", __func__);
3281                 fc_vport_set_state(vha->fc_vport, FC_VPORT_INITIALIZING);
3282         }
3283         dma_pool_free(ha->s_dma_pool, vpmod, vpmod_dma);
3284
3285         return rval;
3286 }
3287
3288 /*
3289  * qla24xx_control_vp
3290  *      Enable a virtual port for given host
3291  *
3292  * Input:
3293  *      ha = adapter block pointer.
3294  *      vhba = virtual adapter (unused)
3295  *      index = index number for enabled VP
3296  *
3297  * Returns:
3298  *      qla2xxx local function return status code.
3299  *
3300  * Context:
3301  *      Kernel context.
3302  */
3303 int
3304 qla24xx_control_vp(scsi_qla_host_t *vha, int cmd)
3305 {
3306         int             rval;
3307         int             map, pos;
3308         struct vp_ctrl_entry_24xx   *vce;
3309         dma_addr_t      vce_dma;
3310         struct qla_hw_data *ha = vha->hw;
3311         int     vp_index = vha->vp_idx;
3312         struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev);
3313
3314         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10c1,
3315             "Entered %s enabling index %d.\n", __func__, vp_index);
3316
3317         if (vp_index == 0 || vp_index >= ha->max_npiv_vports)
3318                 return QLA_PARAMETER_ERROR;
3319
3320         vce = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &vce_dma);
3321         if (!vce) {
3322                 ql_log(ql_log_warn, vha, 0x10c2,
3323                     "Failed to allocate VP control IOCB.\n");
3324                 return QLA_MEMORY_ALLOC_FAILED;
3325         }
3326         memset(vce, 0, sizeof(struct vp_ctrl_entry_24xx));
3327
3328         vce->entry_type = VP_CTRL_IOCB_TYPE;
3329         vce->entry_count = 1;
3330         vce->command = cpu_to_le16(cmd);
3331         vce->vp_count = __constant_cpu_to_le16(1);
3332
3333         /* index map in firmware starts with 1; decrement index
3334          * this is ok as we never use index 0
3335          */
3336         map = (vp_index - 1) / 8;
3337         pos = (vp_index - 1) & 7;
3338         mutex_lock(&ha->vport_lock);
3339         vce->vp_idx_map[map] |= 1 << pos;
3340         mutex_unlock(&ha->vport_lock);
3341
3342         rval = qla2x00_issue_iocb(base_vha, vce, vce_dma, 0);
3343         if (rval != QLA_SUCCESS) {
3344                 ql_dbg(ql_dbg_mbx, vha, 0x10c3,
3345                     "Failed to issue VP control IOCB (%x).\n", rval);
3346         } else if (vce->entry_status != 0) {
3347                 ql_dbg(ql_dbg_mbx, vha, 0x10c4,
3348                     "Failed to complete IOCB -- error status (%x).\n",
3349                     vce->entry_status);
3350                 rval = QLA_FUNCTION_FAILED;
3351         } else if (vce->comp_status != __constant_cpu_to_le16(CS_COMPLETE)) {
3352                 ql_dbg(ql_dbg_mbx, vha, 0x10c5,
3353                     "Failed to complet IOCB -- completion status (%x).\n",
3354                     le16_to_cpu(vce->comp_status));
3355                 rval = QLA_FUNCTION_FAILED;
3356         } else {
3357                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10c6,
3358                     "Done %s.\n", __func__);
3359         }
3360
3361         dma_pool_free(ha->s_dma_pool, vce, vce_dma);
3362
3363         return rval;
3364 }
3365
3366 /*
3367  * qla2x00_send_change_request
3368  *      Receive or disable RSCN request from fabric controller
3369  *
3370  * Input:
3371  *      ha = adapter block pointer
3372  *      format = registration format:
3373  *              0 - Reserved
3374  *              1 - Fabric detected registration
3375  *              2 - N_port detected registration
3376  *              3 - Full registration
3377  *              FF - clear registration
3378  *      vp_idx = Virtual port index
3379  *
3380  * Returns:
3381  *      qla2x00 local function return status code.
3382  *
3383  * Context:
3384  *      Kernel Context
3385  */
3386
3387 int
3388 qla2x00_send_change_request(scsi_qla_host_t *vha, uint16_t format,
3389                             uint16_t vp_idx)
3390 {
3391         int rval;
3392         mbx_cmd_t mc;
3393         mbx_cmd_t *mcp = &mc;
3394
3395         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10c7,
3396             "Entered %s.\n", __func__);
3397
3398         mcp->mb[0] = MBC_SEND_CHANGE_REQUEST;
3399         mcp->mb[1] = format;
3400         mcp->mb[9] = vp_idx;
3401         mcp->out_mb = MBX_9|MBX_1|MBX_0;
3402         mcp->in_mb = MBX_0|MBX_1;
3403         mcp->tov = MBX_TOV_SECONDS;
3404         mcp->flags = 0;
3405         rval = qla2x00_mailbox_command(vha, mcp);
3406
3407         if (rval == QLA_SUCCESS) {
3408                 if (mcp->mb[0] != MBS_COMMAND_COMPLETE) {
3409                         rval = BIT_1;
3410                 }
3411         } else
3412                 rval = BIT_1;
3413
3414         return rval;
3415 }
3416
3417 int
3418 qla2x00_dump_ram(scsi_qla_host_t *vha, dma_addr_t req_dma, uint32_t addr,
3419     uint32_t size)
3420 {
3421         int rval;
3422         mbx_cmd_t mc;
3423         mbx_cmd_t *mcp = &mc;
3424
3425         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1009,
3426             "Entered %s.\n", __func__);
3427
3428         if (MSW(addr) || IS_FWI2_CAPABLE(vha->hw)) {
3429                 mcp->mb[0] = MBC_DUMP_RISC_RAM_EXTENDED;
3430                 mcp->mb[8] = MSW(addr);
3431                 mcp->out_mb = MBX_8|MBX_0;
3432         } else {
3433                 mcp->mb[0] = MBC_DUMP_RISC_RAM;
3434                 mcp->out_mb = MBX_0;
3435         }
3436         mcp->mb[1] = LSW(addr);
3437         mcp->mb[2] = MSW(req_dma);
3438         mcp->mb[3] = LSW(req_dma);
3439         mcp->mb[6] = MSW(MSD(req_dma));
3440         mcp->mb[7] = LSW(MSD(req_dma));
3441         mcp->out_mb |= MBX_7|MBX_6|MBX_3|MBX_2|MBX_1;
3442         if (IS_FWI2_CAPABLE(vha->hw)) {
3443                 mcp->mb[4] = MSW(size);
3444                 mcp->mb[5] = LSW(size);
3445                 mcp->out_mb |= MBX_5|MBX_4;
3446         } else {
3447                 mcp->mb[4] = LSW(size);
3448                 mcp->out_mb |= MBX_4;
3449         }
3450
3451         mcp->in_mb = MBX_0;
3452         mcp->tov = MBX_TOV_SECONDS;
3453         mcp->flags = 0;
3454         rval = qla2x00_mailbox_command(vha, mcp);
3455
3456         if (rval != QLA_SUCCESS) {
3457                 ql_dbg(ql_dbg_mbx, vha, 0x1008,
3458                     "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
3459         } else {
3460                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1007,
3461                     "Done %s.\n", __func__);
3462         }
3463
3464         return rval;
3465 }
3466 /* 84XX Support **************************************************************/
3467
3468 struct cs84xx_mgmt_cmd {
3469         union {
3470                 struct verify_chip_entry_84xx req;
3471                 struct verify_chip_rsp_84xx rsp;
3472         } p;
3473 };
3474
3475 int
3476 qla84xx_verify_chip(struct scsi_qla_host *vha, uint16_t *status)
3477 {
3478         int rval, retry;
3479         struct cs84xx_mgmt_cmd *mn;
3480         dma_addr_t mn_dma;
3481         uint16_t options;
3482         unsigned long flags;
3483         struct qla_hw_data *ha = vha->hw;
3484
3485         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10c8,
3486             "Entered %s.\n", __func__);
3487
3488         mn = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &mn_dma);
3489         if (mn == NULL) {
3490                 return QLA_MEMORY_ALLOC_FAILED;
3491         }
3492
3493         /* Force Update? */
3494         options = ha->cs84xx->fw_update ? VCO_FORCE_UPDATE : 0;
3495         /* Diagnostic firmware? */
3496         /* options |= MENLO_DIAG_FW; */
3497         /* We update the firmware with only one data sequence. */
3498         options |= VCO_END_OF_DATA;
3499
3500         do {
3501                 retry = 0;
3502                 memset(mn, 0, sizeof(*mn));
3503                 mn->p.req.entry_type = VERIFY_CHIP_IOCB_TYPE;
3504                 mn->p.req.entry_count = 1;
3505                 mn->p.req.options = cpu_to_le16(options);
3506
3507                 ql_dbg(ql_dbg_mbx + ql_dbg_buffer, vha, 0x111c,
3508                     "Dump of Verify Request.\n");
3509                 ql_dump_buffer(ql_dbg_mbx + ql_dbg_buffer, vha, 0x111e,
3510                     (uint8_t *)mn, sizeof(*mn));
3511
3512                 rval = qla2x00_issue_iocb_timeout(vha, mn, mn_dma, 0, 120);
3513                 if (rval != QLA_SUCCESS) {
3514                         ql_dbg(ql_dbg_mbx, vha, 0x10cb,
3515                             "Failed to issue verify IOCB (%x).\n", rval);
3516                         goto verify_done;
3517                 }
3518
3519                 ql_dbg(ql_dbg_mbx + ql_dbg_buffer, vha, 0x1110,
3520                     "Dump of Verify Response.\n");
3521                 ql_dump_buffer(ql_dbg_mbx + ql_dbg_buffer, vha, 0x1118,
3522                     (uint8_t *)mn, sizeof(*mn));
3523
3524                 status[0] = le16_to_cpu(mn->p.rsp.comp_status);
3525                 status[1] = status[0] == CS_VCS_CHIP_FAILURE ?
3526                     le16_to_cpu(mn->p.rsp.failure_code) : 0;
3527                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10ce,
3528                     "cs=%x fc=%x.\n", status[0], status[1]);
3529
3530                 if (status[0] != CS_COMPLETE) {
3531                         rval = QLA_FUNCTION_FAILED;
3532                         if (!(options & VCO_DONT_UPDATE_FW)) {
3533                                 ql_dbg(ql_dbg_mbx, vha, 0x10cf,
3534                                     "Firmware update failed. Retrying "
3535                                     "without update firmware.\n");
3536                                 options |= VCO_DONT_UPDATE_FW;
3537                                 options &= ~VCO_FORCE_UPDATE;
3538                                 retry = 1;
3539                         }
3540                 } else {
3541                         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10d0,
3542                             "Firmware updated to %x.\n",
3543                             le32_to_cpu(mn->p.rsp.fw_ver));
3544
3545                         /* NOTE: we only update OP firmware. */
3546                         spin_lock_irqsave(&ha->cs84xx->access_lock, flags);
3547                         ha->cs84xx->op_fw_version =
3548                             le32_to_cpu(mn->p.rsp.fw_ver);
3549                         spin_unlock_irqrestore(&ha->cs84xx->access_lock,
3550                             flags);
3551                 }
3552         } while (retry);
3553
3554 verify_done:
3555         dma_pool_free(ha->s_dma_pool, mn, mn_dma);
3556
3557         if (rval != QLA_SUCCESS) {
3558                 ql_dbg(ql_dbg_mbx, vha, 0x10d1,
3559                     "Failed=%x.\n", rval);
3560         } else {
3561                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10d2,
3562                     "Done %s.\n", __func__);
3563         }
3564
3565         return rval;
3566 }
3567
3568 int
3569 qla25xx_init_req_que(struct scsi_qla_host *vha, struct req_que *req)
3570 {
3571         int rval;
3572         unsigned long flags;
3573         mbx_cmd_t mc;
3574         mbx_cmd_t *mcp = &mc;
3575         struct device_reg_25xxmq __iomem *reg;
3576         struct qla_hw_data *ha = vha->hw;
3577
3578         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10d3,
3579             "Entered %s.\n", __func__);
3580
3581         mcp->mb[0] = MBC_INITIALIZE_MULTIQ;
3582         mcp->mb[1] = req->options;
3583         mcp->mb[2] = MSW(LSD(req->dma));
3584         mcp->mb[3] = LSW(LSD(req->dma));
3585         mcp->mb[6] = MSW(MSD(req->dma));
3586         mcp->mb[7] = LSW(MSD(req->dma));
3587         mcp->mb[5] = req->length;
3588         if (req->rsp)
3589                 mcp->mb[10] = req->rsp->id;
3590         mcp->mb[12] = req->qos;
3591         mcp->mb[11] = req->vp_idx;
3592         mcp->mb[13] = req->rid;
3593         if (IS_QLA83XX(ha))
3594                 mcp->mb[15] = 0;
3595
3596         reg = (struct device_reg_25xxmq __iomem *)((ha->mqiobase) +
3597                 QLA_QUE_PAGE * req->id);
3598
3599         mcp->mb[4] = req->id;
3600         /* que in ptr index */
3601         mcp->mb[8] = 0;
3602         /* que out ptr index */
3603         mcp->mb[9] = 0;
3604         mcp->out_mb = MBX_14|MBX_13|MBX_12|MBX_11|MBX_10|MBX_9|MBX_8|MBX_7|
3605                         MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
3606         mcp->in_mb = MBX_0;
3607         mcp->flags = MBX_DMA_OUT;
3608         mcp->tov = MBX_TOV_SECONDS * 2;
3609
3610         if (IS_QLA81XX(ha) || IS_QLA83XX(ha))
3611                 mcp->in_mb |= MBX_1;
3612         if (IS_QLA83XX(ha)) {
3613                 mcp->out_mb |= MBX_15;
3614                 /* debug q create issue in SR-IOV */
3615                 mcp->in_mb |= MBX_9 | MBX_8 | MBX_7;
3616         }
3617
3618         spin_lock_irqsave(&ha->hardware_lock, flags);
3619         if (!(req->options & BIT_0)) {
3620                 WRT_REG_DWORD(&reg->req_q_in, 0);
3621                 if (!IS_QLA83XX(ha))
3622                         WRT_REG_DWORD(&reg->req_q_out, 0);
3623         }
3624         req->req_q_in = &reg->req_q_in;
3625         req->req_q_out = &reg->req_q_out;
3626         spin_unlock_irqrestore(&ha->hardware_lock, flags);
3627
3628         rval = qla2x00_mailbox_command(vha, mcp);
3629         if (rval != QLA_SUCCESS) {
3630                 ql_dbg(ql_dbg_mbx, vha, 0x10d4,
3631                     "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
3632         } else {
3633                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10d5,
3634                     "Done %s.\n", __func__);
3635         }
3636
3637         return rval;
3638 }
3639
3640 int
3641 qla25xx_init_rsp_que(struct scsi_qla_host *vha, struct rsp_que *rsp)
3642 {
3643         int rval;
3644         unsigned long flags;
3645         mbx_cmd_t mc;
3646         mbx_cmd_t *mcp = &mc;
3647         struct device_reg_25xxmq __iomem *reg;
3648         struct qla_hw_data *ha = vha->hw;
3649
3650         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10d6,
3651             "Entered %s.\n", __func__);
3652
3653         mcp->mb[0] = MBC_INITIALIZE_MULTIQ;
3654         mcp->mb[1] = rsp->options;
3655         mcp->mb[2] = MSW(LSD(rsp->dma));
3656         mcp->mb[3] = LSW(LSD(rsp->dma));
3657         mcp->mb[6] = MSW(MSD(rsp->dma));
3658         mcp->mb[7] = LSW(MSD(rsp->dma));
3659         mcp->mb[5] = rsp->length;
3660         mcp->mb[14] = rsp->msix->entry;
3661         mcp->mb[13] = rsp->rid;
3662         if (IS_QLA83XX(ha))
3663                 mcp->mb[15] = 0;
3664
3665         reg = (struct device_reg_25xxmq __iomem *)((ha->mqiobase) +
3666                 QLA_QUE_PAGE * rsp->id);
3667
3668         mcp->mb[4] = rsp->id;
3669         /* que in ptr index */
3670         mcp->mb[8] = 0;
3671         /* que out ptr index */
3672         mcp->mb[9] = 0;
3673         mcp->out_mb = MBX_14|MBX_13|MBX_9|MBX_8|MBX_7
3674                         |MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
3675         mcp->in_mb = MBX_0;
3676         mcp->flags = MBX_DMA_OUT;
3677         mcp->tov = MBX_TOV_SECONDS * 2;
3678
3679         if (IS_QLA81XX(ha)) {
3680                 mcp->out_mb |= MBX_12|MBX_11|MBX_10;
3681                 mcp->in_mb |= MBX_1;
3682         } else if (IS_QLA83XX(ha)) {
3683                 mcp->out_mb |= MBX_15|MBX_12|MBX_11|MBX_10;
3684                 mcp->in_mb |= MBX_1;
3685                 /* debug q create issue in SR-IOV */
3686                 mcp->in_mb |= MBX_9 | MBX_8 | MBX_7;
3687         }
3688
3689         spin_lock_irqsave(&ha->hardware_lock, flags);
3690         if (!(rsp->options & BIT_0)) {
3691                 WRT_REG_DWORD(&reg->rsp_q_out, 0);
3692                 if (!IS_QLA83XX(ha))
3693                         WRT_REG_DWORD(&reg->rsp_q_in, 0);
3694         }
3695
3696         spin_unlock_irqrestore(&ha->hardware_lock, flags);
3697
3698         rval = qla2x00_mailbox_command(vha, mcp);
3699         if (rval != QLA_SUCCESS) {
3700                 ql_dbg(ql_dbg_mbx, vha, 0x10d7,
3701                     "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
3702         } else {
3703                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10d8,
3704                     "Done %s.\n", __func__);
3705         }
3706
3707         return rval;
3708 }
3709
3710 int
3711 qla81xx_idc_ack(scsi_qla_host_t *vha, uint16_t *mb)
3712 {
3713         int rval;
3714         mbx_cmd_t mc;
3715         mbx_cmd_t *mcp = &mc;
3716
3717         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10d9,
3718             "Entered %s.\n", __func__);
3719
3720         mcp->mb[0] = MBC_IDC_ACK;
3721         memcpy(&mcp->mb[1], mb, QLA_IDC_ACK_REGS * sizeof(uint16_t));
3722         mcp->out_mb = MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
3723         mcp->in_mb = MBX_0;
3724         mcp->tov = MBX_TOV_SECONDS;
3725         mcp->flags = 0;
3726         rval = qla2x00_mailbox_command(vha, mcp);
3727
3728         if (rval != QLA_SUCCESS) {
3729                 ql_dbg(ql_dbg_mbx, vha, 0x10da,
3730                     "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
3731         } else {
3732                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10db,
3733                     "Done %s.\n", __func__);
3734         }
3735
3736         return rval;
3737 }
3738
3739 int
3740 qla81xx_fac_get_sector_size(scsi_qla_host_t *vha, uint32_t *sector_size)
3741 {
3742         int rval;
3743         mbx_cmd_t mc;
3744         mbx_cmd_t *mcp = &mc;
3745
3746         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10dc,
3747             "Entered %s.\n", __func__);
3748
3749         if (!IS_QLA81XX(vha->hw) && !IS_QLA83XX(vha->hw))
3750                 return QLA_FUNCTION_FAILED;
3751
3752         mcp->mb[0] = MBC_FLASH_ACCESS_CTRL;
3753         mcp->mb[1] = FAC_OPT_CMD_GET_SECTOR_SIZE;
3754         mcp->out_mb = MBX_1|MBX_0;
3755         mcp->in_mb = MBX_1|MBX_0;
3756         mcp->tov = MBX_TOV_SECONDS;
3757         mcp->flags = 0;
3758         rval = qla2x00_mailbox_command(vha, mcp);
3759
3760         if (rval != QLA_SUCCESS) {
3761                 ql_dbg(ql_dbg_mbx, vha, 0x10dd,
3762                     "Failed=%x mb[0]=%x mb[1]=%x.\n",
3763                     rval, mcp->mb[0], mcp->mb[1]);
3764         } else {
3765                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10de,
3766                     "Done %s.\n", __func__);
3767                 *sector_size = mcp->mb[1];
3768         }
3769
3770         return rval;
3771 }
3772
3773 int
3774 qla81xx_fac_do_write_enable(scsi_qla_host_t *vha, int enable)
3775 {
3776         int rval;
3777         mbx_cmd_t mc;
3778         mbx_cmd_t *mcp = &mc;
3779
3780         if (!IS_QLA81XX(vha->hw) && !IS_QLA83XX(vha->hw))
3781                 return QLA_FUNCTION_FAILED;
3782
3783         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10df,
3784             "Entered %s.\n", __func__);
3785
3786         mcp->mb[0] = MBC_FLASH_ACCESS_CTRL;
3787         mcp->mb[1] = enable ? FAC_OPT_CMD_WRITE_ENABLE :
3788             FAC_OPT_CMD_WRITE_PROTECT;
3789         mcp->out_mb = MBX_1|MBX_0;
3790         mcp->in_mb = MBX_1|MBX_0;
3791         mcp->tov = MBX_TOV_SECONDS;
3792         mcp->flags = 0;
3793         rval = qla2x00_mailbox_command(vha, mcp);
3794
3795         if (rval != QLA_SUCCESS) {
3796                 ql_dbg(ql_dbg_mbx, vha, 0x10e0,
3797                     "Failed=%x mb[0]=%x mb[1]=%x.\n",
3798                     rval, mcp->mb[0], mcp->mb[1]);
3799         } else {
3800                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10e1,
3801                     "Done %s.\n", __func__);
3802         }
3803
3804         return rval;
3805 }
3806
3807 int
3808 qla81xx_fac_erase_sector(scsi_qla_host_t *vha, uint32_t start, uint32_t finish)
3809 {
3810         int rval;
3811         mbx_cmd_t mc;
3812         mbx_cmd_t *mcp = &mc;
3813
3814         if (!IS_QLA81XX(vha->hw) && !IS_QLA83XX(vha->hw))
3815                 return QLA_FUNCTION_FAILED;
3816
3817         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10e2,
3818             "Entered %s.\n", __func__);
3819
3820         mcp->mb[0] = MBC_FLASH_ACCESS_CTRL;
3821         mcp->mb[1] = FAC_OPT_CMD_ERASE_SECTOR;
3822         mcp->mb[2] = LSW(start);
3823         mcp->mb[3] = MSW(start);
3824         mcp->mb[4] = LSW(finish);
3825         mcp->mb[5] = MSW(finish);
3826         mcp->out_mb = MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
3827         mcp->in_mb = MBX_2|MBX_1|MBX_0;
3828         mcp->tov = MBX_TOV_SECONDS;
3829         mcp->flags = 0;
3830         rval = qla2x00_mailbox_command(vha, mcp);
3831
3832         if (rval != QLA_SUCCESS) {
3833                 ql_dbg(ql_dbg_mbx, vha, 0x10e3,
3834                     "Failed=%x mb[0]=%x mb[1]=%x mb[2]=%x.\n",
3835                     rval, mcp->mb[0], mcp->mb[1], mcp->mb[2]);
3836         } else {
3837                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10e4,
3838                     "Done %s.\n", __func__);
3839         }
3840
3841         return rval;
3842 }
3843
3844 int
3845 qla81xx_restart_mpi_firmware(scsi_qla_host_t *vha)
3846 {
3847         int rval = 0;
3848         mbx_cmd_t mc;
3849         mbx_cmd_t *mcp = &mc;
3850
3851         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10e5,
3852             "Entered %s.\n", __func__);
3853
3854         mcp->mb[0] = MBC_RESTART_MPI_FW;
3855         mcp->out_mb = MBX_0;
3856         mcp->in_mb = MBX_0|MBX_1;
3857         mcp->tov = MBX_TOV_SECONDS;
3858         mcp->flags = 0;
3859         rval = qla2x00_mailbox_command(vha, mcp);
3860
3861         if (rval != QLA_SUCCESS) {
3862                 ql_dbg(ql_dbg_mbx, vha, 0x10e6,
3863                     "Failed=%x mb[0]=%x mb[1]=%x.\n",
3864                     rval, mcp->mb[0], mcp->mb[1]);
3865         } else {
3866                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10e7,
3867                     "Done %s.\n", __func__);
3868         }
3869
3870         return rval;
3871 }
3872
3873 static int
3874 qla2x00_read_asic_temperature(scsi_qla_host_t *vha, uint16_t *temp)
3875 {
3876         int rval;
3877         mbx_cmd_t mc;
3878         mbx_cmd_t *mcp = &mc;
3879
3880         if (!IS_FWI2_CAPABLE(vha->hw))
3881                 return QLA_FUNCTION_FAILED;
3882
3883         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1159,
3884             "Entered %s.\n", __func__);
3885
3886         mcp->mb[0] = MBC_GET_RNID_PARAMS;
3887         mcp->mb[1] = RNID_TYPE_ASIC_TEMP << 8;
3888         mcp->out_mb = MBX_1|MBX_0;
3889         mcp->in_mb = MBX_1|MBX_0;
3890         mcp->tov = MBX_TOV_SECONDS;
3891         mcp->flags = 0;
3892         rval = qla2x00_mailbox_command(vha, mcp);
3893         *temp = mcp->mb[1];
3894
3895         if (rval != QLA_SUCCESS) {
3896                 ql_dbg(ql_dbg_mbx, vha, 0x115a,
3897                     "Failed=%x mb[0]=%x,%x.\n", rval, mcp->mb[0], mcp->mb[1]);
3898         } else {
3899                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x115b,
3900                     "Done %s.\n", __func__);
3901         }
3902
3903         return rval;
3904 }
3905
3906 int
3907 qla2x00_read_sfp(scsi_qla_host_t *vha, dma_addr_t sfp_dma, uint8_t *sfp,
3908         uint16_t dev, uint16_t off, uint16_t len, uint16_t opt)
3909 {
3910         int rval;
3911         mbx_cmd_t mc;
3912         mbx_cmd_t *mcp = &mc;
3913         struct qla_hw_data *ha = vha->hw;
3914
3915         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10e8,
3916             "Entered %s.\n", __func__);
3917
3918         if (!IS_FWI2_CAPABLE(ha))
3919                 return QLA_FUNCTION_FAILED;
3920
3921         if (len == 1)
3922                 opt |= BIT_0;
3923
3924         mcp->mb[0] = MBC_READ_SFP;
3925         mcp->mb[1] = dev;
3926         mcp->mb[2] = MSW(sfp_dma);
3927         mcp->mb[3] = LSW(sfp_dma);
3928         mcp->mb[6] = MSW(MSD(sfp_dma));
3929         mcp->mb[7] = LSW(MSD(sfp_dma));
3930         mcp->mb[8] = len;
3931         mcp->mb[9] = off;
3932         mcp->mb[10] = opt;
3933         mcp->out_mb = MBX_10|MBX_9|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
3934         mcp->in_mb = MBX_1|MBX_0;
3935         mcp->tov = MBX_TOV_SECONDS;
3936         mcp->flags = 0;
3937         rval = qla2x00_mailbox_command(vha, mcp);
3938
3939         if (opt & BIT_0)
3940                 *sfp = mcp->mb[1];
3941
3942         if (rval != QLA_SUCCESS) {
3943                 ql_dbg(ql_dbg_mbx, vha, 0x10e9,
3944                     "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
3945         } else {
3946                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10ea,
3947                     "Done %s.\n", __func__);
3948         }
3949
3950         return rval;
3951 }
3952
3953 int
3954 qla2x00_write_sfp(scsi_qla_host_t *vha, dma_addr_t sfp_dma, uint8_t *sfp,
3955         uint16_t dev, uint16_t off, uint16_t len, uint16_t opt)
3956 {
3957         int rval;
3958         mbx_cmd_t mc;
3959         mbx_cmd_t *mcp = &mc;
3960         struct qla_hw_data *ha = vha->hw;
3961
3962         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10eb,
3963             "Entered %s.\n", __func__);
3964
3965         if (!IS_FWI2_CAPABLE(ha))
3966                 return QLA_FUNCTION_FAILED;
3967
3968         if (len == 1)
3969                 opt |= BIT_0;
3970
3971         if (opt & BIT_0)
3972                 len = *sfp;
3973
3974         mcp->mb[0] = MBC_WRITE_SFP;
3975         mcp->mb[1] = dev;
3976         mcp->mb[2] = MSW(sfp_dma);
3977         mcp->mb[3] = LSW(sfp_dma);
3978         mcp->mb[6] = MSW(MSD(sfp_dma));
3979         mcp->mb[7] = LSW(MSD(sfp_dma));
3980         mcp->mb[8] = len;
3981         mcp->mb[9] = off;
3982         mcp->mb[10] = opt;
3983         mcp->out_mb = MBX_10|MBX_9|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
3984         mcp->in_mb = MBX_1|MBX_0;
3985         mcp->tov = MBX_TOV_SECONDS;
3986         mcp->flags = 0;
3987         rval = qla2x00_mailbox_command(vha, mcp);
3988
3989         if (rval != QLA_SUCCESS) {
3990                 ql_dbg(ql_dbg_mbx, vha, 0x10ec,
3991                     "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
3992         } else {
3993                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10ed,
3994                     "Done %s.\n", __func__);
3995         }
3996
3997         return rval;
3998 }
3999
4000 int
4001 qla2x00_get_xgmac_stats(scsi_qla_host_t *vha, dma_addr_t stats_dma,
4002     uint16_t size_in_bytes, uint16_t *actual_size)
4003 {
4004         int rval;
4005         mbx_cmd_t mc;
4006         mbx_cmd_t *mcp = &mc;
4007
4008         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10ee,
4009             "Entered %s.\n", __func__);
4010
4011         if (!IS_CNA_CAPABLE(vha->hw))
4012                 return QLA_FUNCTION_FAILED;
4013
4014         mcp->mb[0] = MBC_GET_XGMAC_STATS;
4015         mcp->mb[2] = MSW(stats_dma);
4016         mcp->mb[3] = LSW(stats_dma);
4017         mcp->mb[6] = MSW(MSD(stats_dma));
4018         mcp->mb[7] = LSW(MSD(stats_dma));
4019         mcp->mb[8] = size_in_bytes >> 2;
4020         mcp->out_mb = MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_0;
4021         mcp->in_mb = MBX_2|MBX_1|MBX_0;
4022         mcp->tov = MBX_TOV_SECONDS;
4023         mcp->flags = 0;
4024         rval = qla2x00_mailbox_command(vha, mcp);
4025
4026         if (rval != QLA_SUCCESS) {
4027                 ql_dbg(ql_dbg_mbx, vha, 0x10ef,
4028                     "Failed=%x mb[0]=%x mb[1]=%x mb[2]=%x.\n",
4029                     rval, mcp->mb[0], mcp->mb[1], mcp->mb[2]);
4030         } else {
4031                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10f0,
4032                     "Done %s.\n", __func__);
4033
4034
4035                 *actual_size = mcp->mb[2] << 2;
4036         }
4037
4038         return rval;
4039 }
4040
4041 int
4042 qla2x00_get_dcbx_params(scsi_qla_host_t *vha, dma_addr_t tlv_dma,
4043     uint16_t size)
4044 {
4045         int rval;
4046         mbx_cmd_t mc;
4047         mbx_cmd_t *mcp = &mc;
4048
4049         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10f1,
4050             "Entered %s.\n", __func__);
4051
4052         if (!IS_CNA_CAPABLE(vha->hw))
4053                 return QLA_FUNCTION_FAILED;
4054
4055         mcp->mb[0] = MBC_GET_DCBX_PARAMS;
4056         mcp->mb[1] = 0;
4057         mcp->mb[2] = MSW(tlv_dma);
4058         mcp->mb[3] = LSW(tlv_dma);
4059         mcp->mb[6] = MSW(MSD(tlv_dma));
4060         mcp->mb[7] = LSW(MSD(tlv_dma));
4061         mcp->mb[8] = size;
4062         mcp->out_mb = MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
4063         mcp->in_mb = MBX_2|MBX_1|MBX_0;
4064         mcp->tov = MBX_TOV_SECONDS;
4065         mcp->flags = 0;
4066         rval = qla2x00_mailbox_command(vha, mcp);
4067
4068         if (rval != QLA_SUCCESS) {
4069                 ql_dbg(ql_dbg_mbx, vha, 0x10f2,
4070                     "Failed=%x mb[0]=%x mb[1]=%x mb[2]=%x.\n",
4071                     rval, mcp->mb[0], mcp->mb[1], mcp->mb[2]);
4072         } else {
4073                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10f3,
4074                     "Done %s.\n", __func__);
4075         }
4076
4077         return rval;
4078 }
4079
4080 int
4081 qla2x00_read_ram_word(scsi_qla_host_t *vha, uint32_t risc_addr, uint32_t *data)
4082 {
4083         int rval;
4084         mbx_cmd_t mc;
4085         mbx_cmd_t *mcp = &mc;
4086
4087         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10f4,
4088             "Entered %s.\n", __func__);
4089
4090         if (!IS_FWI2_CAPABLE(vha->hw))
4091                 return QLA_FUNCTION_FAILED;
4092
4093         mcp->mb[0] = MBC_READ_RAM_EXTENDED;
4094         mcp->mb[1] = LSW(risc_addr);
4095         mcp->mb[8] = MSW(risc_addr);
4096         mcp->out_mb = MBX_8|MBX_1|MBX_0;
4097         mcp->in_mb = MBX_3|MBX_2|MBX_0;
4098         mcp->tov = 30;
4099         mcp->flags = 0;
4100         rval = qla2x00_mailbox_command(vha, mcp);
4101         if (rval != QLA_SUCCESS) {
4102                 ql_dbg(ql_dbg_mbx, vha, 0x10f5,
4103                     "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
4104         } else {
4105                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10f6,
4106                     "Done %s.\n", __func__);
4107                 *data = mcp->mb[3] << 16 | mcp->mb[2];
4108         }
4109
4110         return rval;
4111 }
4112
4113 int
4114 qla2x00_loopback_test(scsi_qla_host_t *vha, struct msg_echo_lb *mreq,
4115         uint16_t *mresp)
4116 {
4117         int rval;
4118         mbx_cmd_t mc;
4119         mbx_cmd_t *mcp = &mc;
4120
4121         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10f7,
4122             "Entered %s.\n", __func__);
4123
4124         memset(mcp->mb, 0 , sizeof(mcp->mb));
4125         mcp->mb[0] = MBC_DIAGNOSTIC_LOOP_BACK;
4126         mcp->mb[1] = mreq->options | BIT_6;     // BIT_6 specifies 64 bit addressing
4127
4128         /* transfer count */
4129         mcp->mb[10] = LSW(mreq->transfer_size);
4130         mcp->mb[11] = MSW(mreq->transfer_size);
4131
4132         /* send data address */
4133         mcp->mb[14] = LSW(mreq->send_dma);
4134         mcp->mb[15] = MSW(mreq->send_dma);
4135         mcp->mb[20] = LSW(MSD(mreq->send_dma));
4136         mcp->mb[21] = MSW(MSD(mreq->send_dma));
4137
4138         /* receive data address */
4139         mcp->mb[16] = LSW(mreq->rcv_dma);
4140         mcp->mb[17] = MSW(mreq->rcv_dma);
4141         mcp->mb[6] = LSW(MSD(mreq->rcv_dma));
4142         mcp->mb[7] = MSW(MSD(mreq->rcv_dma));
4143
4144         /* Iteration count */
4145         mcp->mb[18] = LSW(mreq->iteration_count);
4146         mcp->mb[19] = MSW(mreq->iteration_count);
4147
4148         mcp->out_mb = MBX_21|MBX_20|MBX_19|MBX_18|MBX_17|MBX_16|MBX_15|
4149             MBX_14|MBX_13|MBX_12|MBX_11|MBX_10|MBX_7|MBX_6|MBX_1|MBX_0;
4150         if (IS_CNA_CAPABLE(vha->hw))
4151                 mcp->out_mb |= MBX_2;
4152         mcp->in_mb = MBX_19|MBX_18|MBX_3|MBX_2|MBX_1|MBX_0;
4153
4154         mcp->buf_size = mreq->transfer_size;
4155         mcp->tov = MBX_TOV_SECONDS;
4156         mcp->flags = MBX_DMA_OUT|MBX_DMA_IN|IOCTL_CMD;
4157
4158         rval = qla2x00_mailbox_command(vha, mcp);
4159
4160         if (rval != QLA_SUCCESS) {
4161                 ql_dbg(ql_dbg_mbx, vha, 0x10f8,
4162                     "Failed=%x mb[0]=%x mb[1]=%x mb[2]=%x mb[3]=%x mb[18]=%x "
4163                     "mb[19]=%x.\n", rval, mcp->mb[0], mcp->mb[1], mcp->mb[2],
4164                     mcp->mb[3], mcp->mb[18], mcp->mb[19]);
4165         } else {
4166                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10f9,
4167                     "Done %s.\n", __func__);
4168         }
4169
4170         /* Copy mailbox information */
4171         memcpy( mresp, mcp->mb, 64);
4172         return rval;
4173 }
4174
4175 int
4176 qla2x00_echo_test(scsi_qla_host_t *vha, struct msg_echo_lb *mreq,
4177         uint16_t *mresp)
4178 {
4179         int rval;
4180         mbx_cmd_t mc;
4181         mbx_cmd_t *mcp = &mc;
4182         struct qla_hw_data *ha = vha->hw;
4183
4184         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10fa,
4185             "Entered %s.\n", __func__);
4186
4187         memset(mcp->mb, 0 , sizeof(mcp->mb));
4188         mcp->mb[0] = MBC_DIAGNOSTIC_ECHO;
4189         mcp->mb[1] = mreq->options | BIT_6;     /* BIT_6 specifies 64bit address */
4190         if (IS_CNA_CAPABLE(ha)) {
4191                 mcp->mb[1] |= BIT_15;
4192                 mcp->mb[2] = vha->fcoe_fcf_idx;
4193         }
4194         mcp->mb[16] = LSW(mreq->rcv_dma);
4195         mcp->mb[17] = MSW(mreq->rcv_dma);
4196         mcp->mb[6] = LSW(MSD(mreq->rcv_dma));
4197         mcp->mb[7] = MSW(MSD(mreq->rcv_dma));
4198
4199         mcp->mb[10] = LSW(mreq->transfer_size);
4200
4201         mcp->mb[14] = LSW(mreq->send_dma);
4202         mcp->mb[15] = MSW(mreq->send_dma);
4203         mcp->mb[20] = LSW(MSD(mreq->send_dma));
4204         mcp->mb[21] = MSW(MSD(mreq->send_dma));
4205
4206         mcp->out_mb = MBX_21|MBX_20|MBX_17|MBX_16|MBX_15|
4207             MBX_14|MBX_10|MBX_7|MBX_6|MBX_1|MBX_0;
4208         if (IS_CNA_CAPABLE(ha))
4209                 mcp->out_mb |= MBX_2;
4210
4211         mcp->in_mb = MBX_0;
4212         if (IS_QLA24XX_TYPE(ha) || IS_QLA25XX(ha) ||
4213             IS_CNA_CAPABLE(ha) || IS_QLA2031(ha))
4214                 mcp->in_mb |= MBX_1;
4215         if (IS_CNA_CAPABLE(ha) || IS_QLA2031(ha))
4216                 mcp->in_mb |= MBX_3;
4217
4218         mcp->tov = MBX_TOV_SECONDS;
4219         mcp->flags = MBX_DMA_OUT|MBX_DMA_IN|IOCTL_CMD;
4220         mcp->buf_size = mreq->transfer_size;
4221
4222         rval = qla2x00_mailbox_command(vha, mcp);
4223
4224         if (rval != QLA_SUCCESS) {
4225                 ql_dbg(ql_dbg_mbx, vha, 0x10fb,
4226                     "Failed=%x mb[0]=%x mb[1]=%x.\n",
4227                     rval, mcp->mb[0], mcp->mb[1]);
4228         } else {
4229                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10fc,
4230                     "Done %s.\n", __func__);
4231         }
4232
4233         /* Copy mailbox information */
4234         memcpy(mresp, mcp->mb, 64);
4235         return rval;
4236 }
4237
4238 int
4239 qla84xx_reset_chip(scsi_qla_host_t *vha, uint16_t enable_diagnostic)
4240 {
4241         int rval;
4242         mbx_cmd_t mc;
4243         mbx_cmd_t *mcp = &mc;
4244
4245         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10fd,
4246             "Entered %s enable_diag=%d.\n", __func__, enable_diagnostic);
4247
4248         mcp->mb[0] = MBC_ISP84XX_RESET;
4249         mcp->mb[1] = enable_diagnostic;
4250         mcp->out_mb = MBX_1|MBX_0;
4251         mcp->in_mb = MBX_1|MBX_0;
4252         mcp->tov = MBX_TOV_SECONDS;
4253         mcp->flags = MBX_DMA_OUT|MBX_DMA_IN|IOCTL_CMD;
4254         rval = qla2x00_mailbox_command(vha, mcp);
4255
4256         if (rval != QLA_SUCCESS)
4257                 ql_dbg(ql_dbg_mbx, vha, 0x10fe, "Failed=%x.\n", rval);
4258         else
4259                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10ff,
4260                     "Done %s.\n", __func__);
4261
4262         return rval;
4263 }
4264
4265 int
4266 qla2x00_write_ram_word(scsi_qla_host_t *vha, uint32_t risc_addr, uint32_t data)
4267 {
4268         int rval;
4269         mbx_cmd_t mc;
4270         mbx_cmd_t *mcp = &mc;
4271
4272         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1100,
4273             "Entered %s.\n", __func__);
4274
4275         if (!IS_FWI2_CAPABLE(vha->hw))
4276                 return QLA_FUNCTION_FAILED;
4277
4278         mcp->mb[0] = MBC_WRITE_RAM_WORD_EXTENDED;
4279         mcp->mb[1] = LSW(risc_addr);
4280         mcp->mb[2] = LSW(data);
4281         mcp->mb[3] = MSW(data);
4282         mcp->mb[8] = MSW(risc_addr);
4283         mcp->out_mb = MBX_8|MBX_3|MBX_2|MBX_1|MBX_0;
4284         mcp->in_mb = MBX_0;
4285         mcp->tov = 30;
4286         mcp->flags = 0;
4287         rval = qla2x00_mailbox_command(vha, mcp);
4288         if (rval != QLA_SUCCESS) {
4289                 ql_dbg(ql_dbg_mbx, vha, 0x1101,
4290                     "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
4291         } else {
4292                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1102,
4293                     "Done %s.\n", __func__);
4294         }
4295
4296         return rval;
4297 }
4298
4299 int
4300 qla81xx_write_mpi_register(scsi_qla_host_t *vha, uint16_t *mb)
4301 {
4302         int rval;
4303         uint32_t stat, timer;
4304         uint16_t mb0 = 0;
4305         struct qla_hw_data *ha = vha->hw;
4306         struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
4307
4308         rval = QLA_SUCCESS;
4309
4310         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1103,
4311             "Entered %s.\n", __func__);
4312
4313         clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
4314
4315         /* Write the MBC data to the registers */
4316         WRT_REG_WORD(&reg->mailbox0, MBC_WRITE_MPI_REGISTER);
4317         WRT_REG_WORD(&reg->mailbox1, mb[0]);
4318         WRT_REG_WORD(&reg->mailbox2, mb[1]);
4319         WRT_REG_WORD(&reg->mailbox3, mb[2]);
4320         WRT_REG_WORD(&reg->mailbox4, mb[3]);
4321
4322         WRT_REG_DWORD(&reg->hccr, HCCRX_SET_HOST_INT);
4323
4324         /* Poll for MBC interrupt */
4325         for (timer = 6000000; timer; timer--) {
4326                 /* Check for pending interrupts. */
4327                 stat = RD_REG_DWORD(&reg->host_status);
4328                 if (stat & HSRX_RISC_INT) {
4329                         stat &= 0xff;
4330
4331                         if (stat == 0x1 || stat == 0x2 ||
4332                             stat == 0x10 || stat == 0x11) {
4333                                 set_bit(MBX_INTERRUPT,
4334                                     &ha->mbx_cmd_flags);
4335                                 mb0 = RD_REG_WORD(&reg->mailbox0);
4336                                 WRT_REG_DWORD(&reg->hccr,
4337                                     HCCRX_CLR_RISC_INT);
4338                                 RD_REG_DWORD(&reg->hccr);
4339                                 break;
4340                         }
4341                 }
4342                 udelay(5);
4343         }
4344
4345         if (test_and_clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags))
4346                 rval = mb0 & MBS_MASK;
4347         else
4348                 rval = QLA_FUNCTION_FAILED;
4349
4350         if (rval != QLA_SUCCESS) {
4351                 ql_dbg(ql_dbg_mbx, vha, 0x1104,
4352                     "Failed=%x mb[0]=%x.\n", rval, mb[0]);
4353         } else {
4354                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1105,
4355                     "Done %s.\n", __func__);
4356         }
4357
4358         return rval;
4359 }
4360
4361 int
4362 qla2x00_get_data_rate(scsi_qla_host_t *vha)
4363 {
4364         int rval;
4365         mbx_cmd_t mc;
4366         mbx_cmd_t *mcp = &mc;
4367         struct qla_hw_data *ha = vha->hw;
4368
4369         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1106,
4370             "Entered %s.\n", __func__);
4371
4372         if (!IS_FWI2_CAPABLE(ha))
4373                 return QLA_FUNCTION_FAILED;
4374
4375         mcp->mb[0] = MBC_DATA_RATE;
4376         mcp->mb[1] = 0;
4377         mcp->out_mb = MBX_1|MBX_0;
4378         mcp->in_mb = MBX_2|MBX_1|MBX_0;
4379         if (IS_QLA83XX(ha))
4380                 mcp->in_mb |= MBX_3;
4381         mcp->tov = MBX_TOV_SECONDS;
4382         mcp->flags = 0;
4383         rval = qla2x00_mailbox_command(vha, mcp);
4384         if (rval != QLA_SUCCESS) {
4385                 ql_dbg(ql_dbg_mbx, vha, 0x1107,
4386                     "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
4387         } else {
4388                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1108,
4389                     "Done %s.\n", __func__);
4390                 if (mcp->mb[1] != 0x7)
4391                         ha->link_data_rate = mcp->mb[1];
4392         }
4393
4394         return rval;
4395 }
4396
4397 int
4398 qla81xx_get_port_config(scsi_qla_host_t *vha, uint16_t *mb)
4399 {
4400         int rval;
4401         mbx_cmd_t mc;
4402         mbx_cmd_t *mcp = &mc;
4403         struct qla_hw_data *ha = vha->hw;
4404
4405         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1109,
4406             "Entered %s.\n", __func__);
4407
4408         if (!IS_QLA81XX(ha) && !IS_QLA83XX(ha))
4409                 return QLA_FUNCTION_FAILED;
4410         mcp->mb[0] = MBC_GET_PORT_CONFIG;
4411         mcp->out_mb = MBX_0;
4412         mcp->in_mb = MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
4413         mcp->tov = MBX_TOV_SECONDS;
4414         mcp->flags = 0;
4415
4416         rval = qla2x00_mailbox_command(vha, mcp);
4417
4418         if (rval != QLA_SUCCESS) {
4419                 ql_dbg(ql_dbg_mbx, vha, 0x110a,
4420                     "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
4421         } else {
4422                 /* Copy all bits to preserve original value */
4423                 memcpy(mb, &mcp->mb[1], sizeof(uint16_t) * 4);
4424
4425                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x110b,
4426                     "Done %s.\n", __func__);
4427         }
4428         return rval;
4429 }
4430
4431 int
4432 qla81xx_set_port_config(scsi_qla_host_t *vha, uint16_t *mb)
4433 {
4434         int rval;
4435         mbx_cmd_t mc;
4436         mbx_cmd_t *mcp = &mc;
4437
4438         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x110c,
4439             "Entered %s.\n", __func__);
4440
4441         mcp->mb[0] = MBC_SET_PORT_CONFIG;
4442         /* Copy all bits to preserve original setting */
4443         memcpy(&mcp->mb[1], mb, sizeof(uint16_t) * 4);
4444         mcp->out_mb = MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
4445         mcp->in_mb = MBX_0;
4446         mcp->tov = MBX_TOV_SECONDS;
4447         mcp->flags = 0;
4448         rval = qla2x00_mailbox_command(vha, mcp);
4449
4450         if (rval != QLA_SUCCESS) {
4451                 ql_dbg(ql_dbg_mbx, vha, 0x110d,
4452                     "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
4453         } else
4454                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x110e,
4455                     "Done %s.\n", __func__);
4456
4457         return rval;
4458 }
4459
4460
4461 int
4462 qla24xx_set_fcp_prio(scsi_qla_host_t *vha, uint16_t loop_id, uint16_t priority,
4463                 uint16_t *mb)
4464 {
4465         int rval;
4466         mbx_cmd_t mc;
4467         mbx_cmd_t *mcp = &mc;
4468         struct qla_hw_data *ha = vha->hw;
4469
4470         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x110f,
4471             "Entered %s.\n", __func__);
4472
4473         if (!IS_QLA24XX_TYPE(ha) && !IS_QLA25XX(ha))
4474                 return QLA_FUNCTION_FAILED;
4475
4476         mcp->mb[0] = MBC_PORT_PARAMS;
4477         mcp->mb[1] = loop_id;
4478         if (ha->flags.fcp_prio_enabled)
4479                 mcp->mb[2] = BIT_1;
4480         else
4481                 mcp->mb[2] = BIT_2;
4482         mcp->mb[4] = priority & 0xf;
4483         mcp->mb[9] = vha->vp_idx;
4484         mcp->out_mb = MBX_9|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
4485         mcp->in_mb = MBX_4|MBX_3|MBX_1|MBX_0;
4486         mcp->tov = 30;
4487         mcp->flags = 0;
4488         rval = qla2x00_mailbox_command(vha, mcp);
4489         if (mb != NULL) {
4490                 mb[0] = mcp->mb[0];
4491                 mb[1] = mcp->mb[1];
4492                 mb[3] = mcp->mb[3];
4493                 mb[4] = mcp->mb[4];
4494         }
4495
4496         if (rval != QLA_SUCCESS) {
4497                 ql_dbg(ql_dbg_mbx, vha, 0x10cd, "Failed=%x.\n", rval);
4498         } else {
4499                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10cc,
4500                     "Done %s.\n", __func__);
4501         }
4502
4503         return rval;
4504 }
4505
4506 int
4507 qla2x00_get_thermal_temp(scsi_qla_host_t *vha, uint16_t *temp)
4508 {
4509         int rval = QLA_FUNCTION_FAILED;
4510         struct qla_hw_data *ha = vha->hw;
4511         uint8_t byte;
4512
4513         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10ca,
4514             "Entered %s.\n", __func__);
4515
4516         if (ha->thermal_support & THERMAL_SUPPORT_I2C) {
4517                 rval = qla2x00_read_sfp(vha, 0, &byte,
4518                     0x98, 0x1, 1, BIT_13|BIT_12|BIT_0);
4519                 *temp = byte;
4520                 if (rval == QLA_SUCCESS)
4521                         goto done;
4522
4523                 ql_log(ql_log_warn, vha, 0x10c9,
4524                     "Thermal not supported through I2C bus, trying alternate "
4525                     "method (ISP access).\n");
4526                 ha->thermal_support &= ~THERMAL_SUPPORT_I2C;
4527         }
4528
4529         if (ha->thermal_support & THERMAL_SUPPORT_ISP) {
4530                 rval = qla2x00_read_asic_temperature(vha, temp);
4531                 if (rval == QLA_SUCCESS)
4532                         goto done;
4533
4534                 ql_log(ql_log_warn, vha, 0x1019,
4535                     "Thermal not supported through ISP.\n");
4536                 ha->thermal_support &= ~THERMAL_SUPPORT_ISP;
4537         }
4538
4539         ql_log(ql_log_warn, vha, 0x1150,
4540             "Thermal not supported by this card "
4541             "(ignoring further requests).\n");
4542         return  rval;
4543
4544 done:
4545         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1018,
4546             "Done %s.\n", __func__);
4547         return rval;
4548 }
4549
4550 int
4551 qla82xx_mbx_intr_enable(scsi_qla_host_t *vha)
4552 {
4553         int rval;
4554         struct qla_hw_data *ha = vha->hw;
4555         mbx_cmd_t mc;
4556         mbx_cmd_t *mcp = &mc;
4557
4558         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1017,
4559             "Entered %s.\n", __func__);
4560
4561         if (!IS_FWI2_CAPABLE(ha))
4562                 return QLA_FUNCTION_FAILED;
4563
4564         memset(mcp, 0, sizeof(mbx_cmd_t));
4565         mcp->mb[0] = MBC_TOGGLE_INTERRUPT;
4566         mcp->mb[1] = 1;
4567
4568         mcp->out_mb = MBX_1|MBX_0;
4569         mcp->in_mb = MBX_0;
4570         mcp->tov = 30;
4571         mcp->flags = 0;
4572
4573         rval = qla2x00_mailbox_command(vha, mcp);
4574         if (rval != QLA_SUCCESS) {
4575                 ql_dbg(ql_dbg_mbx, vha, 0x1016,
4576                     "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
4577         } else {
4578                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x100e,
4579                     "Done %s.\n", __func__);
4580         }
4581
4582         return rval;
4583 }
4584
4585 int
4586 qla82xx_mbx_intr_disable(scsi_qla_host_t *vha)
4587 {
4588         int rval;
4589         struct qla_hw_data *ha = vha->hw;
4590         mbx_cmd_t mc;
4591         mbx_cmd_t *mcp = &mc;
4592
4593         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x100d,
4594             "Entered %s.\n", __func__);
4595
4596         if (!IS_QLA82XX(ha))
4597                 return QLA_FUNCTION_FAILED;
4598
4599         memset(mcp, 0, sizeof(mbx_cmd_t));
4600         mcp->mb[0] = MBC_TOGGLE_INTERRUPT;
4601         mcp->mb[1] = 0;
4602
4603         mcp->out_mb = MBX_1|MBX_0;
4604         mcp->in_mb = MBX_0;
4605         mcp->tov = 30;
4606         mcp->flags = 0;
4607
4608         rval = qla2x00_mailbox_command(vha, mcp);
4609         if (rval != QLA_SUCCESS) {
4610                 ql_dbg(ql_dbg_mbx, vha, 0x100c,
4611                     "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
4612         } else {
4613                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x100b,
4614                     "Done %s.\n", __func__);
4615         }
4616
4617         return rval;
4618 }
4619
4620 int
4621 qla82xx_md_get_template_size(scsi_qla_host_t *vha)
4622 {
4623         struct qla_hw_data *ha = vha->hw;
4624         mbx_cmd_t mc;
4625         mbx_cmd_t *mcp = &mc;
4626         int rval = QLA_FUNCTION_FAILED;
4627
4628         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x111f,
4629             "Entered %s.\n", __func__);
4630
4631         memset(mcp->mb, 0 , sizeof(mcp->mb));
4632         mcp->mb[0] = LSW(MBC_DIAGNOSTIC_MINIDUMP_TEMPLATE);
4633         mcp->mb[1] = MSW(MBC_DIAGNOSTIC_MINIDUMP_TEMPLATE);
4634         mcp->mb[2] = LSW(RQST_TMPLT_SIZE);
4635         mcp->mb[3] = MSW(RQST_TMPLT_SIZE);
4636
4637         mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
4638         mcp->in_mb = MBX_14|MBX_13|MBX_12|MBX_11|MBX_10|MBX_9|MBX_8|
4639             MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
4640
4641         mcp->flags = MBX_DMA_OUT|MBX_DMA_IN|IOCTL_CMD;
4642         mcp->tov = MBX_TOV_SECONDS;
4643         rval = qla2x00_mailbox_command(vha, mcp);
4644
4645         /* Always copy back return mailbox values. */
4646         if (rval != QLA_SUCCESS) {
4647                 ql_dbg(ql_dbg_mbx, vha, 0x1120,
4648                     "mailbox command FAILED=0x%x, subcode=%x.\n",
4649                     (mcp->mb[1] << 16) | mcp->mb[0],
4650                     (mcp->mb[3] << 16) | mcp->mb[2]);
4651         } else {
4652                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1121,
4653                     "Done %s.\n", __func__);
4654                 ha->md_template_size = ((mcp->mb[3] << 16) | mcp->mb[2]);
4655                 if (!ha->md_template_size) {
4656                         ql_dbg(ql_dbg_mbx, vha, 0x1122,
4657                             "Null template size obtained.\n");
4658                         rval = QLA_FUNCTION_FAILED;
4659                 }
4660         }
4661         return rval;
4662 }
4663
4664 int
4665 qla82xx_md_get_template(scsi_qla_host_t *vha)
4666 {
4667         struct qla_hw_data *ha = vha->hw;
4668         mbx_cmd_t mc;
4669         mbx_cmd_t *mcp = &mc;
4670         int rval = QLA_FUNCTION_FAILED;
4671
4672         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1123,
4673             "Entered %s.\n", __func__);
4674
4675         ha->md_tmplt_hdr = dma_alloc_coherent(&ha->pdev->dev,
4676            ha->md_template_size, &ha->md_tmplt_hdr_dma, GFP_KERNEL);
4677         if (!ha->md_tmplt_hdr) {
4678                 ql_log(ql_log_warn, vha, 0x1124,
4679                     "Unable to allocate memory for Minidump template.\n");
4680                 return rval;
4681         }
4682
4683         memset(mcp->mb, 0 , sizeof(mcp->mb));
4684         mcp->mb[0] = LSW(MBC_DIAGNOSTIC_MINIDUMP_TEMPLATE);
4685         mcp->mb[1] = MSW(MBC_DIAGNOSTIC_MINIDUMP_TEMPLATE);
4686         mcp->mb[2] = LSW(RQST_TMPLT);
4687         mcp->mb[3] = MSW(RQST_TMPLT);
4688         mcp->mb[4] = LSW(LSD(ha->md_tmplt_hdr_dma));
4689         mcp->mb[5] = MSW(LSD(ha->md_tmplt_hdr_dma));
4690         mcp->mb[6] = LSW(MSD(ha->md_tmplt_hdr_dma));
4691         mcp->mb[7] = MSW(MSD(ha->md_tmplt_hdr_dma));
4692         mcp->mb[8] = LSW(ha->md_template_size);
4693         mcp->mb[9] = MSW(ha->md_template_size);
4694
4695         mcp->flags = MBX_DMA_OUT|MBX_DMA_IN|IOCTL_CMD;
4696         mcp->tov = MBX_TOV_SECONDS;
4697         mcp->out_mb = MBX_11|MBX_10|MBX_9|MBX_8|
4698             MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
4699         mcp->in_mb = MBX_3|MBX_2|MBX_1|MBX_0;
4700         rval = qla2x00_mailbox_command(vha, mcp);
4701
4702         if (rval != QLA_SUCCESS) {
4703                 ql_dbg(ql_dbg_mbx, vha, 0x1125,
4704                     "mailbox command FAILED=0x%x, subcode=%x.\n",
4705                     ((mcp->mb[1] << 16) | mcp->mb[0]),
4706                     ((mcp->mb[3] << 16) | mcp->mb[2]));
4707         } else
4708                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1126,
4709                     "Done %s.\n", __func__);
4710         return rval;
4711 }
4712
4713 int
4714 qla81xx_set_led_config(scsi_qla_host_t *vha, uint16_t *led_cfg)
4715 {
4716         int rval;
4717         struct qla_hw_data *ha = vha->hw;
4718         mbx_cmd_t mc;
4719         mbx_cmd_t *mcp = &mc;
4720
4721         if (!IS_QLA81XX(ha) && !IS_QLA8031(ha))
4722                 return QLA_FUNCTION_FAILED;
4723
4724         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1133,
4725             "Entered %s.\n", __func__);
4726
4727         memset(mcp, 0, sizeof(mbx_cmd_t));
4728         mcp->mb[0] = MBC_SET_LED_CONFIG;
4729         mcp->mb[1] = led_cfg[0];
4730         mcp->mb[2] = led_cfg[1];
4731         if (IS_QLA8031(ha)) {
4732                 mcp->mb[3] = led_cfg[2];
4733                 mcp->mb[4] = led_cfg[3];
4734                 mcp->mb[5] = led_cfg[4];
4735                 mcp->mb[6] = led_cfg[5];
4736         }
4737
4738         mcp->out_mb = MBX_2|MBX_1|MBX_0;
4739         if (IS_QLA8031(ha))
4740                 mcp->out_mb |= MBX_6|MBX_5|MBX_4|MBX_3;
4741         mcp->in_mb = MBX_0;
4742         mcp->tov = 30;
4743         mcp->flags = 0;
4744
4745         rval = qla2x00_mailbox_command(vha, mcp);
4746         if (rval != QLA_SUCCESS) {
4747                 ql_dbg(ql_dbg_mbx, vha, 0x1134,
4748                     "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
4749         } else {
4750                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1135,
4751                     "Done %s.\n", __func__);
4752         }
4753
4754         return rval;
4755 }
4756
4757 int
4758 qla81xx_get_led_config(scsi_qla_host_t *vha, uint16_t *led_cfg)
4759 {
4760         int rval;
4761         struct qla_hw_data *ha = vha->hw;
4762         mbx_cmd_t mc;
4763         mbx_cmd_t *mcp = &mc;
4764
4765         if (!IS_QLA81XX(ha) && !IS_QLA8031(ha))
4766                 return QLA_FUNCTION_FAILED;
4767
4768         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1136,
4769             "Entered %s.\n", __func__);
4770
4771         memset(mcp, 0, sizeof(mbx_cmd_t));
4772         mcp->mb[0] = MBC_GET_LED_CONFIG;
4773
4774         mcp->out_mb = MBX_0;
4775         mcp->in_mb = MBX_2|MBX_1|MBX_0;
4776         if (IS_QLA8031(ha))
4777                 mcp->in_mb |= MBX_6|MBX_5|MBX_4|MBX_3;
4778         mcp->tov = 30;
4779         mcp->flags = 0;
4780
4781         rval = qla2x00_mailbox_command(vha, mcp);
4782         if (rval != QLA_SUCCESS) {
4783                 ql_dbg(ql_dbg_mbx, vha, 0x1137,
4784                     "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
4785         } else {
4786                 led_cfg[0] = mcp->mb[1];
4787                 led_cfg[1] = mcp->mb[2];
4788                 if (IS_QLA8031(ha)) {
4789                         led_cfg[2] = mcp->mb[3];
4790                         led_cfg[3] = mcp->mb[4];
4791                         led_cfg[4] = mcp->mb[5];
4792                         led_cfg[5] = mcp->mb[6];
4793                 }
4794                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1138,
4795                     "Done %s.\n", __func__);
4796         }
4797
4798         return rval;
4799 }
4800
4801 int
4802 qla82xx_mbx_beacon_ctl(scsi_qla_host_t *vha, int enable)
4803 {
4804         int rval;
4805         struct qla_hw_data *ha = vha->hw;
4806         mbx_cmd_t mc;
4807         mbx_cmd_t *mcp = &mc;
4808
4809         if (!IS_QLA82XX(ha))
4810                 return QLA_FUNCTION_FAILED;
4811
4812         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1127,
4813                 "Entered %s.\n", __func__);
4814
4815         memset(mcp, 0, sizeof(mbx_cmd_t));
4816         mcp->mb[0] = MBC_SET_LED_CONFIG;
4817         if (enable)
4818                 mcp->mb[7] = 0xE;
4819         else
4820                 mcp->mb[7] = 0xD;
4821
4822         mcp->out_mb = MBX_7|MBX_0;
4823         mcp->in_mb = MBX_0;
4824         mcp->tov = MBX_TOV_SECONDS;
4825         mcp->flags = 0;
4826
4827         rval = qla2x00_mailbox_command(vha, mcp);
4828         if (rval != QLA_SUCCESS) {
4829                 ql_dbg(ql_dbg_mbx, vha, 0x1128,
4830                     "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
4831         } else {
4832                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1129,
4833                     "Done %s.\n", __func__);
4834         }
4835
4836         return rval;
4837 }
4838
4839 int
4840 qla83xx_wr_reg(scsi_qla_host_t *vha, uint32_t reg, uint32_t data)
4841 {
4842         int rval;
4843         struct qla_hw_data *ha = vha->hw;
4844         mbx_cmd_t mc;
4845         mbx_cmd_t *mcp = &mc;
4846
4847         if (!IS_QLA83XX(ha))
4848                 return QLA_FUNCTION_FAILED;
4849
4850         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1130,
4851             "Entered %s.\n", __func__);
4852
4853         mcp->mb[0] = MBC_WRITE_REMOTE_REG;
4854         mcp->mb[1] = LSW(reg);
4855         mcp->mb[2] = MSW(reg);
4856         mcp->mb[3] = LSW(data);
4857         mcp->mb[4] = MSW(data);
4858         mcp->out_mb = MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
4859
4860         mcp->in_mb = MBX_1|MBX_0;
4861         mcp->tov = MBX_TOV_SECONDS;
4862         mcp->flags = 0;
4863         rval = qla2x00_mailbox_command(vha, mcp);
4864
4865         if (rval != QLA_SUCCESS) {
4866                 ql_dbg(ql_dbg_mbx, vha, 0x1131,
4867                     "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
4868         } else {
4869                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1132,
4870                     "Done %s.\n", __func__);
4871         }
4872
4873         return rval;
4874 }
4875
4876 int
4877 qla2x00_port_logout(scsi_qla_host_t *vha, struct fc_port *fcport)
4878 {
4879         int rval;
4880         struct qla_hw_data *ha = vha->hw;
4881         mbx_cmd_t mc;
4882         mbx_cmd_t *mcp = &mc;
4883
4884         if (IS_QLA2100(ha) || IS_QLA2200(ha)) {
4885                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x113b,
4886                     "Implicit LOGO Unsupported.\n");
4887                 return QLA_FUNCTION_FAILED;
4888         }
4889
4890
4891         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x113c,
4892             "Entering %s.\n",  __func__);
4893
4894         /* Perform Implicit LOGO. */
4895         mcp->mb[0] = MBC_PORT_LOGOUT;
4896         mcp->mb[1] = fcport->loop_id;
4897         mcp->mb[10] = BIT_15;
4898         mcp->out_mb = MBX_10|MBX_1|MBX_0;
4899         mcp->in_mb = MBX_0;
4900         mcp->tov = MBX_TOV_SECONDS;
4901         mcp->flags = 0;
4902         rval = qla2x00_mailbox_command(vha, mcp);
4903         if (rval != QLA_SUCCESS)
4904                 ql_dbg(ql_dbg_mbx, vha, 0x113d,
4905                     "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
4906         else
4907                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x113e,
4908                     "Done %s.\n", __func__);
4909
4910         return rval;
4911 }
4912
4913 int
4914 qla83xx_rd_reg(scsi_qla_host_t *vha, uint32_t reg, uint32_t *data)
4915 {
4916         int rval;
4917         mbx_cmd_t mc;
4918         mbx_cmd_t *mcp = &mc;
4919         struct qla_hw_data *ha = vha->hw;
4920         unsigned long retry_max_time = jiffies + (2 * HZ);
4921
4922         if (!IS_QLA83XX(ha))
4923                 return QLA_FUNCTION_FAILED;
4924
4925         ql_dbg(ql_dbg_mbx, vha, 0x114b, "Entered %s.\n", __func__);
4926
4927 retry_rd_reg:
4928         mcp->mb[0] = MBC_READ_REMOTE_REG;
4929         mcp->mb[1] = LSW(reg);
4930         mcp->mb[2] = MSW(reg);
4931         mcp->out_mb = MBX_2|MBX_1|MBX_0;
4932         mcp->in_mb = MBX_4|MBX_3|MBX_1|MBX_0;
4933         mcp->tov = MBX_TOV_SECONDS;
4934         mcp->flags = 0;
4935         rval = qla2x00_mailbox_command(vha, mcp);
4936
4937         if (rval != QLA_SUCCESS) {
4938                 ql_dbg(ql_dbg_mbx, vha, 0x114c,
4939                     "Failed=%x mb[0]=%x mb[1]=%x.\n",
4940                     rval, mcp->mb[0], mcp->mb[1]);
4941         } else {
4942                 *data = (mcp->mb[3] | (mcp->mb[4] << 16));
4943                 if (*data == QLA8XXX_BAD_VALUE) {
4944                         /*
4945                          * During soft-reset CAMRAM register reads might
4946                          * return 0xbad0bad0. So retry for MAX of 2 sec
4947                          * while reading camram registers.
4948                          */
4949                         if (time_after(jiffies, retry_max_time)) {
4950                                 ql_dbg(ql_dbg_mbx, vha, 0x1141,
4951                                     "Failure to read CAMRAM register. "
4952                                     "data=0x%x.\n", *data);
4953                                 return QLA_FUNCTION_FAILED;
4954                         }
4955                         msleep(100);
4956                         goto retry_rd_reg;
4957                 }
4958                 ql_dbg(ql_dbg_mbx, vha, 0x1142, "Done %s.\n", __func__);
4959         }
4960
4961         return rval;
4962 }
4963
4964 int
4965 qla83xx_restart_nic_firmware(scsi_qla_host_t *vha)
4966 {
4967         int rval;
4968         mbx_cmd_t mc;
4969         mbx_cmd_t *mcp = &mc;
4970         struct qla_hw_data *ha = vha->hw;
4971
4972         if (!IS_QLA83XX(ha))
4973                 return QLA_FUNCTION_FAILED;
4974
4975         ql_dbg(ql_dbg_mbx, vha, 0x1143, "Entered %s.\n", __func__);
4976
4977         mcp->mb[0] = MBC_RESTART_NIC_FIRMWARE;
4978         mcp->out_mb = MBX_0;
4979         mcp->in_mb = MBX_1|MBX_0;
4980         mcp->tov = MBX_TOV_SECONDS;
4981         mcp->flags = 0;
4982         rval = qla2x00_mailbox_command(vha, mcp);
4983
4984         if (rval != QLA_SUCCESS) {
4985                 ql_dbg(ql_dbg_mbx, vha, 0x1144,
4986                     "Failed=%x mb[0]=%x mb[1]=%x.\n",
4987                     rval, mcp->mb[0], mcp->mb[1]);
4988                 ha->isp_ops->fw_dump(vha, 0);
4989         } else {
4990                 ql_dbg(ql_dbg_mbx, vha, 0x1145, "Done %s.\n", __func__);
4991         }
4992
4993         return rval;
4994 }
4995
4996 int
4997 qla83xx_access_control(scsi_qla_host_t *vha, uint16_t options,
4998         uint32_t start_addr, uint32_t end_addr, uint16_t *sector_size)
4999 {
5000         int rval;
5001         mbx_cmd_t mc;
5002         mbx_cmd_t *mcp = &mc;
5003         uint8_t subcode = (uint8_t)options;
5004         struct qla_hw_data *ha = vha->hw;
5005
5006         if (!IS_QLA8031(ha))
5007                 return QLA_FUNCTION_FAILED;
5008
5009         ql_dbg(ql_dbg_mbx, vha, 0x1146, "Entered %s.\n", __func__);
5010
5011         mcp->mb[0] = MBC_SET_ACCESS_CONTROL;
5012         mcp->mb[1] = options;
5013         mcp->out_mb = MBX_1|MBX_0;
5014         if (subcode & BIT_2) {
5015                 mcp->mb[2] = LSW(start_addr);
5016                 mcp->mb[3] = MSW(start_addr);
5017                 mcp->mb[4] = LSW(end_addr);
5018                 mcp->mb[5] = MSW(end_addr);
5019                 mcp->out_mb |= MBX_5|MBX_4|MBX_3|MBX_2;
5020         }
5021         mcp->in_mb = MBX_2|MBX_1|MBX_0;
5022         if (!(subcode & (BIT_2 | BIT_5)))
5023                 mcp->in_mb |= MBX_4|MBX_3;
5024         mcp->tov = MBX_TOV_SECONDS;
5025         mcp->flags = 0;
5026         rval = qla2x00_mailbox_command(vha, mcp);
5027
5028         if (rval != QLA_SUCCESS) {
5029                 ql_dbg(ql_dbg_mbx, vha, 0x1147,
5030                     "Failed=%x mb[0]=%x mb[1]=%x mb[2]=%x mb[3]=%x mb[4]=%x.\n",
5031                     rval, mcp->mb[0], mcp->mb[1], mcp->mb[2], mcp->mb[3],
5032                     mcp->mb[4]);
5033                 ha->isp_ops->fw_dump(vha, 0);
5034         } else {
5035                 if (subcode & BIT_5)
5036                         *sector_size = mcp->mb[1];
5037                 else if (subcode & (BIT_6 | BIT_7)) {
5038                         ql_dbg(ql_dbg_mbx, vha, 0x1148,
5039                             "Driver-lock id=%x%x", mcp->mb[4], mcp->mb[3]);
5040                 } else if (subcode & (BIT_3 | BIT_4)) {
5041                         ql_dbg(ql_dbg_mbx, vha, 0x1149,
5042                             "Flash-lock id=%x%x", mcp->mb[4], mcp->mb[3]);
5043                 }
5044                 ql_dbg(ql_dbg_mbx, vha, 0x114a, "Done %s.\n", __func__);
5045         }
5046
5047         return rval;
5048 }
5049
5050 int
5051 qla2x00_dump_mctp_data(scsi_qla_host_t *vha, dma_addr_t req_dma, uint32_t addr,
5052         uint32_t size)
5053 {
5054         int rval;
5055         mbx_cmd_t mc;
5056         mbx_cmd_t *mcp = &mc;
5057
5058         if (!IS_MCTP_CAPABLE(vha->hw))
5059                 return QLA_FUNCTION_FAILED;
5060
5061         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x114f,
5062             "Entered %s.\n", __func__);
5063
5064         mcp->mb[0] = MBC_DUMP_RISC_RAM_EXTENDED;
5065         mcp->mb[1] = LSW(addr);
5066         mcp->mb[2] = MSW(req_dma);
5067         mcp->mb[3] = LSW(req_dma);
5068         mcp->mb[4] = MSW(size);
5069         mcp->mb[5] = LSW(size);
5070         mcp->mb[6] = MSW(MSD(req_dma));
5071         mcp->mb[7] = LSW(MSD(req_dma));
5072         mcp->mb[8] = MSW(addr);
5073         /* Setting RAM ID to valid */
5074         mcp->mb[10] |= BIT_7;
5075         /* For MCTP RAM ID is 0x40 */
5076         mcp->mb[10] |= 0x40;
5077
5078         mcp->out_mb |= MBX_10|MBX_8|MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|
5079             MBX_0;
5080
5081         mcp->in_mb = MBX_0;
5082         mcp->tov = MBX_TOV_SECONDS;
5083         mcp->flags = 0;
5084         rval = qla2x00_mailbox_command(vha, mcp);
5085
5086         if (rval != QLA_SUCCESS) {
5087                 ql_dbg(ql_dbg_mbx, vha, 0x114e,
5088                     "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
5089         } else {
5090                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x114d,
5091                     "Done %s.\n", __func__);
5092         }
5093
5094         return rval;
5095 }