drivers/scsi/qla2xxx/qla_mbx.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * QLogic Fibre Channel HBA Driver
   4  * Copyright (c)  2003-2014 QLogic Corporation
   5  */
   6 #include "qla_def.h"
   7 #include "qla_target.h"
   8
   9 #include <linux/delay.h>
  10 #include <linux/gfp.h>
  11
  12 #ifdef CONFIG_PPC
  13 #define IS_PPCARCH      true
  14 #else
  15 #define IS_PPCARCH      false
  16 #endif
  17
  18 static struct mb_cmd_name {
  19         uint16_t cmd;
  20         const char *str;
  21 } mb_str[] = {
  22         {MBC_GET_PORT_DATABASE,         "GPDB"},
  23         {MBC_GET_ID_LIST,               "GIDList"},
  24         {MBC_GET_LINK_PRIV_STATS,       "Stats"},
  25         {MBC_GET_RESOURCE_COUNTS,       "ResCnt"},
  26 };
  27
  28 static const char *mb_to_str(uint16_t cmd)
  29 {
  30         int i;
  31         struct mb_cmd_name *e;
  32
  33         for (i = 0; i < ARRAY_SIZE(mb_str); i++) {
  34                 e = mb_str + i;
  35                 if (cmd == e->cmd)
  36                         return e->str;
  37         }
  38         return "unknown";
  39 }
  40
  41 static struct rom_cmd {
  42         uint16_t cmd;
  43 } rom_cmds[] = {
  44         { MBC_LOAD_RAM },
  45         { MBC_EXECUTE_FIRMWARE },
  46         { MBC_READ_RAM_WORD },
  47         { MBC_MAILBOX_REGISTER_TEST },
  48         { MBC_VERIFY_CHECKSUM },
  49         { MBC_GET_FIRMWARE_VERSION },
  50         { MBC_LOAD_RISC_RAM },
  51         { MBC_DUMP_RISC_RAM },
  52         { MBC_LOAD_RISC_RAM_EXTENDED },
  53         { MBC_DUMP_RISC_RAM_EXTENDED },
  54         { MBC_WRITE_RAM_WORD_EXTENDED },
  55         { MBC_READ_RAM_EXTENDED },
  56         { MBC_GET_RESOURCE_COUNTS },
  57         { MBC_SET_FIRMWARE_OPTION },
  58         { MBC_MID_INITIALIZE_FIRMWARE },
  59         { MBC_GET_FIRMWARE_STATE },
  60         { MBC_GET_MEM_OFFLOAD_CNTRL_STAT },
  61         { MBC_GET_RETRY_COUNT },
  62         { MBC_TRACE_CONTROL },
  63         { MBC_INITIALIZE_MULTIQ },
  64         { MBC_IOCB_COMMAND_A64 },
  65         { MBC_GET_ADAPTER_LOOP_ID },
  66         { MBC_READ_SFP },
  67         { MBC_SET_RNID_PARAMS },
  68         { MBC_GET_RNID_PARAMS },
  69         { MBC_GET_SET_ZIO_THRESHOLD },
  70 };
  71
  72 static int is_rom_cmd(uint16_t cmd)
  73 {
  74         int i;
  75         struct  rom_cmd *wc;
  76
  77         for (i = 0; i < ARRAY_SIZE(rom_cmds); i++) {
  78                 wc = rom_cmds + i;
  79                 if (wc->cmd == cmd)
  80                         return 1;
  81         }
  82
  83         return 0;
  84 }
  85
  86 /*
  87  * qla2x00_mailbox_command
  88  *      Issue mailbox command and waits for completion.
  89  *
  90  * Input:
  91  *      ha = adapter block pointer.
  92  *      mcp = driver internal mbx struct pointer.
  93  *
  94  * Output:
  95  *      mb[MAX_MAILBOX_REGISTER_COUNT] = returned mailbox data.
  96  *
  97  * Returns:
  98  *      0 : QLA_SUCCESS = cmd performed success
  99  *      1 : QLA_FUNCTION_FAILED   (error encountered)
 100  *      6 : QLA_FUNCTION_TIMEOUT (timeout condition encountered)
 101  *
 102  * Context:
 103  *      Kernel context.
 104  */
 105 static int
 106 qla2x00_mailbox_command(scsi_qla_host_t *vha, mbx_cmd_t *mcp)
 107 {
 108         int             rval, i;
 109         unsigned long    flags = 0;
 110         device_reg_t *reg;
 111         uint8_t         abort_active, eeh_delay;
 112         uint8_t         io_lock_on;
 113         uint16_t        command = 0;
 114         uint16_t        *iptr;
 115         __le16 __iomem  *optr;
 116         uint32_t        cnt;
 117         uint32_t        mboxes;
 118         unsigned long   wait_time;
 119         struct qla_hw_data *ha = vha->hw;
 120         scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev);
 121         u32 chip_reset;
 122
 123
 124         ql_dbg(ql_dbg_mbx, vha, 0x1000, "Entered %s.\n", __func__);
 125
 126         if (ha->pdev->error_state == pci_channel_io_perm_failure) {
 127                 ql_log(ql_log_warn, vha, 0x1001,
 128                     "PCI channel failed permanently, exiting.\n");
 129                 return QLA_FUNCTION_TIMEOUT;
 130         }
 131
 132         if (vha->device_flags & DFLG_DEV_FAILED) {
 133                 ql_log(ql_log_warn, vha, 0x1002,
 134                     "Device in failed state, exiting.\n");
 135                 return QLA_FUNCTION_TIMEOUT;
 136         }
 137
 138         /* if PCI error, then avoid mbx processing.*/
 139         if (test_bit(PFLG_DISCONNECTED, &base_vha->dpc_flags) &&
 140             test_bit(UNLOADING, &base_vha->dpc_flags)) {
 141                 ql_log(ql_log_warn, vha, 0xd04e,
 142                     "PCI error, exiting.\n");
 143                 return QLA_FUNCTION_TIMEOUT;
 144         }
 145         eeh_delay = 0;
 146         reg = ha->iobase;
 147         io_lock_on = base_vha->flags.init_done;
 148
 149         rval = QLA_SUCCESS;
 150         abort_active = test_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags);
 151         chip_reset = ha->chip_reset;
 152
 153         if (ha->flags.pci_channel_io_perm_failure) {
 154                 ql_log(ql_log_warn, vha, 0x1003,
 155                     "Perm failure on EEH timeout MBX, exiting.\n");
 156                 return QLA_FUNCTION_TIMEOUT;
 157         }
 158
 159         if (IS_P3P_TYPE(ha) && ha->flags.isp82xx_fw_hung) {
 160                 /* Setting Link-Down error */
 161                 mcp->mb[0] = MBS_LINK_DOWN_ERROR;
 162                 ql_log(ql_log_warn, vha, 0x1004,
 163                     "FW hung = %d.\n", ha->flags.isp82xx_fw_hung);
 164                 return QLA_FUNCTION_TIMEOUT;
 165         }
 166
 167         /* check if ISP abort is active and return cmd with timeout */
 168         if (((test_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags) ||
 169               test_bit(ISP_ABORT_RETRY, &base_vha->dpc_flags) ||
 170               test_bit(ISP_ABORT_NEEDED, &base_vha->dpc_flags)) &&
 171               !is_rom_cmd(mcp->mb[0])) || ha->flags.eeh_busy) {
 172                 ql_log(ql_log_info, vha, 0x1005,
 173                     "Cmd 0x%x aborted with timeout since ISP Abort is pending\n",
 174                     mcp->mb[0]);
 175                 return QLA_FUNCTION_TIMEOUT;
 176         }
 177
 178         atomic_inc(&ha->num_pend_mbx_stage1);
 179         /*
 180          * Wait for active mailbox commands to finish by waiting at most tov
 181          * seconds. This is to serialize actual issuing of mailbox cmds during
 182          * non ISP abort time.
 183          */
 184         if (!wait_for_completion_timeout(&ha->mbx_cmd_comp, mcp->tov * HZ)) {
 185                 /* Timeout occurred. Return error. */
 186                 ql_log(ql_log_warn, vha, 0xd035,
 187                     "Cmd access timeout, cmd=0x%x, Exiting.\n",
 188                     mcp->mb[0]);
 189                 vha->hw_err_cnt++;
 190                 atomic_dec(&ha->num_pend_mbx_stage1);
 191                 return QLA_FUNCTION_TIMEOUT;
 192         }
 193         atomic_dec(&ha->num_pend_mbx_stage1);
 194         if (ha->flags.purge_mbox || chip_reset != ha->chip_reset ||
 195             ha->flags.eeh_busy) {
 196                 ql_log(ql_log_warn, vha, 0xd035,
 197                        "Error detected: purge[%d] eeh[%d] cmd=0x%x, Exiting.\n",
 198                        ha->flags.purge_mbox, ha->flags.eeh_busy, mcp->mb[0]);
 199                 rval = QLA_ABORTED;
 200                 goto premature_exit;
 201         }
 202
 203
 204         /* Save mailbox command for debug */
 205         ha->mcp = mcp;
 206
 207         ql_dbg(ql_dbg_mbx, vha, 0x1006,
 208             "Prepare to issue mbox cmd=0x%x.\n", mcp->mb[0]);
 209
 210         spin_lock_irqsave(&ha->hardware_lock, flags);
 211
 212         if (ha->flags.purge_mbox || chip_reset != ha->chip_reset ||
 213             ha->flags.mbox_busy) {
 214                 rval = QLA_ABORTED;
 215                 spin_unlock_irqrestore(&ha->hardware_lock, flags);
 216                 goto premature_exit;
 217         }
 218         ha->flags.mbox_busy = 1;
 219
 220         /* Load mailbox registers. */
 221         if (IS_P3P_TYPE(ha))
 222                 optr = &reg->isp82.mailbox_in[0];
 223         else if (IS_FWI2_CAPABLE(ha) && !(IS_P3P_TYPE(ha)))
 224                 optr = &reg->isp24.mailbox0;
 225         else
 226                 optr = MAILBOX_REG(ha, &reg->isp, 0);
 227
 228         iptr = mcp->mb;
 229         command = mcp->mb[0];
 230         mboxes = mcp->out_mb;
 231
 232         ql_dbg(ql_dbg_mbx, vha, 0x1111,
 233             "Mailbox registers (OUT):\n");
 234         for (cnt = 0; cnt < ha->mbx_count; cnt++) {
 235                 if (IS_QLA2200(ha) && cnt == 8)
 236                         optr = MAILBOX_REG(ha, &reg->isp, 8);
 237                 if (mboxes & BIT_0) {
 238                         ql_dbg(ql_dbg_mbx, vha, 0x1112,
 239                             "mbox[%d]<-0x%04x\n", cnt, *iptr);
 240                         wrt_reg_word(optr, *iptr);
 241                 } else {
 242                         wrt_reg_word(optr, 0);
 243                 }
 244
 245                 mboxes >>= 1;
 246                 optr++;
 247                 iptr++;
 248         }
 249
 250         ql_dbg(ql_dbg_mbx + ql_dbg_buffer, vha, 0x1117,
 251             "I/O Address = %p.\n", optr);
 252
 253         /* Issue set host interrupt command to send cmd out. */
 254         ha->flags.mbox_int = 0;
 255         clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
 256
 257         /* Unlock mbx registers and wait for interrupt */
 258         ql_dbg(ql_dbg_mbx, vha, 0x100f,
 259             "Going to unlock irq & waiting for interrupts. "
 260             "jiffies=%lx.\n", jiffies);
 261
 262         /* Wait for mbx cmd completion until timeout */
 263         atomic_inc(&ha->num_pend_mbx_stage2);
 264         if ((!abort_active && io_lock_on) || IS_NOPOLLING_TYPE(ha)) {
 265                 set_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags);
 266
 267                 if (IS_P3P_TYPE(ha))
 268                         wrt_reg_dword(&reg->isp82.hint, HINT_MBX_INT_PENDING);
 269                 else if (IS_FWI2_CAPABLE(ha))
 270                         wrt_reg_dword(&reg->isp24.hccr, HCCRX_SET_HOST_INT);
 271                 else
 272                         wrt_reg_word(&reg->isp.hccr, HCCR_SET_HOST_INT);
 273                 spin_unlock_irqrestore(&ha->hardware_lock, flags);
 274
 275                 wait_time = jiffies;
 276                 if (!wait_for_completion_timeout(&ha->mbx_intr_comp,
 277                     mcp->tov * HZ)) {
 278                         ql_dbg(ql_dbg_mbx, vha, 0x117a,
 279                             "cmd=%x Timeout.\n", command);
 280                         spin_lock_irqsave(&ha->hardware_lock, flags);
 281                         clear_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags);
 282                         spin_unlock_irqrestore(&ha->hardware_lock, flags);
 283
 284                         if (chip_reset != ha->chip_reset) {
 285                                 eeh_delay = ha->flags.eeh_busy ? 1 : 0;
 286
 287                                 spin_lock_irqsave(&ha->hardware_lock, flags);
 288                                 ha->flags.mbox_busy = 0;
 289                                 spin_unlock_irqrestore(&ha->hardware_lock,
 290                                     flags);
 291                                 atomic_dec(&ha->num_pend_mbx_stage2);
 292                                 rval = QLA_ABORTED;
 293                                 goto premature_exit;
 294                         }
 295                 } else if (ha->flags.purge_mbox ||
 296                     chip_reset != ha->chip_reset) {
 297                         eeh_delay = ha->flags.eeh_busy ? 1 : 0;
 298
 299                         spin_lock_irqsave(&ha->hardware_lock, flags);
 300                         ha->flags.mbox_busy = 0;
 301                         spin_unlock_irqrestore(&ha->hardware_lock, flags);
 302                         atomic_dec(&ha->num_pend_mbx_stage2);
 303                         rval = QLA_ABORTED;
 304                         goto premature_exit;
 305                 }
 306
 307                 if (time_after(jiffies, wait_time + 5 * HZ))
 308                         ql_log(ql_log_warn, vha, 0x1015, "cmd=0x%x, waited %d msecs\n",
 309                             command, jiffies_to_msecs(jiffies - wait_time));
 310         } else {
 311                 ql_dbg(ql_dbg_mbx, vha, 0x1011,
 312                     "Cmd=%x Polling Mode.\n", command);
 313
 314                 if (IS_P3P_TYPE(ha)) {
 315                         if (rd_reg_dword(&reg->isp82.hint) &
 316                                 HINT_MBX_INT_PENDING) {
 317                                 ha->flags.mbox_busy = 0;
 318                                 spin_unlock_irqrestore(&ha->hardware_lock,
 319                                         flags);
 320                                 atomic_dec(&ha->num_pend_mbx_stage2);
 321                                 ql_dbg(ql_dbg_mbx, vha, 0x1012,
 322                                     "Pending mailbox timeout, exiting.\n");
 323                                 vha->hw_err_cnt++;
 324                                 rval = QLA_FUNCTION_TIMEOUT;
 325                                 goto premature_exit;
 326                         }
 327                         wrt_reg_dword(&reg->isp82.hint, HINT_MBX_INT_PENDING);
 328                 } else if (IS_FWI2_CAPABLE(ha))
 329                         wrt_reg_dword(&reg->isp24.hccr, HCCRX_SET_HOST_INT);
 330                 else
 331                         wrt_reg_word(&reg->isp.hccr, HCCR_SET_HOST_INT);
 332                 spin_unlock_irqrestore(&ha->hardware_lock, flags);
 333
 334                 wait_time = jiffies + mcp->tov * HZ; /* wait at most tov secs */
 335                 while (!ha->flags.mbox_int) {
 336                         if (ha->flags.purge_mbox ||
 337                             chip_reset != ha->chip_reset) {
 338                                 eeh_delay = ha->flags.eeh_busy ? 1 : 0;
 339
 340                                 spin_lock_irqsave(&ha->hardware_lock, flags);
 341                                 ha->flags.mbox_busy = 0;
 342                                 spin_unlock_irqrestore(&ha->hardware_lock,
 343                                     flags);
 344                                 atomic_dec(&ha->num_pend_mbx_stage2);
 345                                 rval = QLA_ABORTED;
 346                                 goto premature_exit;
 347                         }
 348
 349                         if (time_after(jiffies, wait_time))
 350                                 break;
 351
 352                         /* Check for pending interrupts. */
 353                         qla2x00_poll(ha->rsp_q_map[0]);
 354
 355                         if (!ha->flags.mbox_int &&
 356                             !(IS_QLA2200(ha) &&
 357                             command == MBC_LOAD_RISC_RAM_EXTENDED))
 358                                 msleep(10);
 359                 } /* while */
 360                 ql_dbg(ql_dbg_mbx, vha, 0x1013,
 361                     "Waited %d sec.\n",
 362                     (uint)((jiffies - (wait_time - (mcp->tov * HZ)))/HZ));
 363         }
 364         atomic_dec(&ha->num_pend_mbx_stage2);
 365
 366         /* Check whether we timed out */
 367         if (ha->flags.mbox_int) {
 368                 uint16_t *iptr2;
 369
 370                 ql_dbg(ql_dbg_mbx, vha, 0x1014,
 371                     "Cmd=%x completed.\n", command);
 372
 373                 /* Got interrupt. Clear the flag. */
 374                 ha->flags.mbox_int = 0;
 375                 clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
 376
 377                 if (IS_P3P_TYPE(ha) && ha->flags.isp82xx_fw_hung) {
 378                         spin_lock_irqsave(&ha->hardware_lock, flags);
 379                         ha->flags.mbox_busy = 0;
 380                         spin_unlock_irqrestore(&ha->hardware_lock, flags);
 381
 382                         /* Setting Link-Down error */
 383                         mcp->mb[0] = MBS_LINK_DOWN_ERROR;
 384                         ha->mcp = NULL;
 385                         rval = QLA_FUNCTION_FAILED;
 386                         ql_log(ql_log_warn, vha, 0xd048,
 387                             "FW hung = %d.\n", ha->flags.isp82xx_fw_hung);
 388                         goto premature_exit;
 389                 }
 390
 391                 if (ha->mailbox_out[0] != MBS_COMMAND_COMPLETE) {
 392                         ql_dbg(ql_dbg_mbx, vha, 0x11ff,
 393                                "mb_out[0] = %#x <> %#x\n", ha->mailbox_out[0],
 394                                MBS_COMMAND_COMPLETE);
 395                         rval = QLA_FUNCTION_FAILED;
 396                 }
 397
 398                 /* Load return mailbox registers. */
 399                 iptr2 = mcp->mb;
 400                 iptr = (uint16_t *)&ha->mailbox_out[0];
 401                 mboxes = mcp->in_mb;
 402
 403                 ql_dbg(ql_dbg_mbx, vha, 0x1113,
 404                     "Mailbox registers (IN):\n");
 405                 for (cnt = 0; cnt < ha->mbx_count; cnt++) {
 406                         if (mboxes & BIT_0) {
 407                                 *iptr2 = *iptr;
 408                                 ql_dbg(ql_dbg_mbx, vha, 0x1114,
 409                                     "mbox[%d]->0x%04x\n", cnt, *iptr2);
 410                         }
 411
 412                         mboxes >>= 1;
 413                         iptr2++;
 414                         iptr++;
 415                 }
 416         } else {
 417
 418                 uint16_t mb[8];
 419                 uint32_t ictrl, host_status, hccr;
 420                 uint16_t        w;
 421
 422                 if (IS_FWI2_CAPABLE(ha)) {
 423                         mb[0] = rd_reg_word(&reg->isp24.mailbox0);
 424                         mb[1] = rd_reg_word(&reg->isp24.mailbox1);
 425                         mb[2] = rd_reg_word(&reg->isp24.mailbox2);
 426                         mb[3] = rd_reg_word(&reg->isp24.mailbox3);
 427                         mb[7] = rd_reg_word(&reg->isp24.mailbox7);
 428                         ictrl = rd_reg_dword(&reg->isp24.ictrl);
 429                         host_status = rd_reg_dword(&reg->isp24.host_status);
 430                         hccr = rd_reg_dword(&reg->isp24.hccr);
 431
 432                         ql_log(ql_log_warn, vha, 0xd04c,
 433                             "MBX Command timeout for cmd %x, iocontrol=%x jiffies=%lx "
 434                             "mb[0-3]=[0x%x 0x%x 0x%x 0x%x] mb7 0x%x host_status 0x%x hccr 0x%x\n",
 435                             command, ictrl, jiffies, mb[0], mb[1], mb[2], mb[3],
 436                             mb[7], host_status, hccr);
 437                         vha->hw_err_cnt++;
 438
 439                 } else {
 440                         mb[0] = RD_MAILBOX_REG(ha, &reg->isp, 0);
 441                         ictrl = rd_reg_word(&reg->isp.ictrl);
 442                         ql_dbg(ql_dbg_mbx + ql_dbg_buffer, vha, 0x1119,
 443                             "MBX Command timeout for cmd %x, iocontrol=%x jiffies=%lx "
 444                             "mb[0]=0x%x\n", command, ictrl, jiffies, mb[0]);
 445                         vha->hw_err_cnt++;
 446                 }
 447                 ql_dump_regs(ql_dbg_mbx + ql_dbg_buffer, vha, 0x1019);
 448
 449                 /* Capture FW dump only, if PCI device active */
 450                 if (!pci_channel_offline(vha->hw->pdev)) {
 451                         pci_read_config_word(ha->pdev, PCI_VENDOR_ID, &w);
 452                         if (w == 0xffff || ictrl == 0xffffffff ||
 453                             (chip_reset != ha->chip_reset)) {
 454                                 /* This is special case if there is unload
 455                                  * of driver happening and if PCI device go
 456                                  * into bad state due to PCI error condition
 457                                  * then only PCI ERR flag would be set.
 458                                  * we will do premature exit for above case.
 459                                  */
 460                                 spin_lock_irqsave(&ha->hardware_lock, flags);
 461                                 ha->flags.mbox_busy = 0;
 462                                 spin_unlock_irqrestore(&ha->hardware_lock,
 463                                     flags);
 464                                 rval = QLA_FUNCTION_TIMEOUT;
 465                                 goto premature_exit;
 466                         }
 467
 468                         /* Attempt to capture firmware dump for further
 469                          * anallysis of the current formware state. we do not
 470                          * need to do this if we are intentionally generating
 471                          * a dump
 472                          */
 473                         if (mcp->mb[0] != MBC_GEN_SYSTEM_ERROR)
 474                                 qla2xxx_dump_fw(vha);
 475                         rval = QLA_FUNCTION_TIMEOUT;
 476                  }
 477         }
 478         spin_lock_irqsave(&ha->hardware_lock, flags);
 479         ha->flags.mbox_busy = 0;
 480         spin_unlock_irqrestore(&ha->hardware_lock, flags);
 481
 482         /* Clean up */
 483         ha->mcp = NULL;
 484
 485         if ((abort_active || !io_lock_on) && !IS_NOPOLLING_TYPE(ha)) {
 486                 ql_dbg(ql_dbg_mbx, vha, 0x101a,
 487                     "Checking for additional resp interrupt.\n");
 488
 489                 /* polling mode for non isp_abort commands. */
 490                 qla2x00_poll(ha->rsp_q_map[0]);
 491         }
 492
 493         if (rval == QLA_FUNCTION_TIMEOUT &&
 494             mcp->mb[0] != MBC_GEN_SYSTEM_ERROR) {
 495                 if (!io_lock_on || (mcp->flags & IOCTL_CMD) ||
 496                     ha->flags.eeh_busy) {
 497                         /* not in dpc. schedule it for dpc to take over. */
 498                         ql_dbg(ql_dbg_mbx, vha, 0x101b,
 499                             "Timeout, schedule isp_abort_needed.\n");
 500
 501                         if (!test_bit(ISP_ABORT_NEEDED, &vha->dpc_flags) &&
 502                             !test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags) &&
 503                             !test_bit(ISP_ABORT_RETRY, &vha->dpc_flags)) {
 504                                 if (IS_QLA82XX(ha)) {
 505                                         ql_dbg(ql_dbg_mbx, vha, 0x112a,
 506                                             "disabling pause transmit on port "
 507                                             "0 & 1.\n");
 508                                         qla82xx_wr_32(ha,
 509                                             QLA82XX_CRB_NIU + 0x98,
 510                                             CRB_NIU_XG_PAUSE_CTL_P0|
 511                                             CRB_NIU_XG_PAUSE_CTL_P1);
 512                                 }
 513                                 ql_log(ql_log_info, base_vha, 0x101c,
 514                                     "Mailbox cmd timeout occurred, cmd=0x%x, "
 515                                     "mb[0]=0x%x, eeh_busy=0x%x. Scheduling ISP "
 516                                     "abort.\n", command, mcp->mb[0],
 517                                     ha->flags.eeh_busy);
 518                                 vha->hw_err_cnt++;
 519                                 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
 520                                 qla2xxx_wake_dpc(vha);
 521                         }
 522                 } else if (current == ha->dpc_thread) {
 523                         /* call abort directly since we are in the DPC thread */
 524                         ql_dbg(ql_dbg_mbx, vha, 0x101d,
 525                             "Timeout, calling abort_isp.\n");
 526
 527                         if (!test_bit(ISP_ABORT_NEEDED, &vha->dpc_flags) &&
 528                             !test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags) &&
 529                             !test_bit(ISP_ABORT_RETRY, &vha->dpc_flags)) {
 530                                 if (IS_QLA82XX(ha)) {
 531                                         ql_dbg(ql_dbg_mbx, vha, 0x112b,
 532                                             "disabling pause transmit on port "
 533                                             "0 & 1.\n");
 534                                         qla82xx_wr_32(ha,
 535                                             QLA82XX_CRB_NIU + 0x98,
 536                                             CRB_NIU_XG_PAUSE_CTL_P0|
 537                                             CRB_NIU_XG_PAUSE_CTL_P1);
 538                                 }
 539                                 ql_log(ql_log_info, base_vha, 0x101e,
 540                                     "Mailbox cmd timeout occurred, cmd=0x%x, "
 541                                     "mb[0]=0x%x. Scheduling ISP abort ",
 542                                     command, mcp->mb[0]);
 543                                 vha->hw_err_cnt++;
 544                                 set_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags);
 545                                 clear_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
 546                                 /* Allow next mbx cmd to come in. */
 547                                 complete(&ha->mbx_cmd_comp);
 548                                 if (ha->isp_ops->abort_isp(vha) &&
 549                                     !ha->flags.eeh_busy) {
 550                                         /* Failed. retry later. */
 551                                         set_bit(ISP_ABORT_NEEDED,
 552                                             &vha->dpc_flags);
 553                                 }
 554                                 clear_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags);
 555                                 ql_dbg(ql_dbg_mbx, vha, 0x101f,
 556                                     "Finished abort_isp.\n");
 557                                 goto mbx_done;
 558                         }
 559                 }
 560         }
 561
 562 premature_exit:
 563         /* Allow next mbx cmd to come in. */
 564         complete(&ha->mbx_cmd_comp);
 565
 566 mbx_done:
 567         if (rval == QLA_ABORTED) {
 568                 ql_log(ql_log_info, vha, 0xd035,
 569                     "Chip Reset in progress. Purging Mbox cmd=0x%x.\n",
 570                     mcp->mb[0]);
 571         } else if (rval) {
 572                 if (ql2xextended_error_logging & (ql_dbg_disc|ql_dbg_mbx)) {
 573                         pr_warn("%s [%s]-%04x:%ld: **** Failed=%x", QL_MSGHDR,
 574                             dev_name(&ha->pdev->dev), 0x1020+0x800,
 575                             vha->host_no, rval);
 576                         mboxes = mcp->in_mb;
 577                         cnt = 4;
 578                         for (i = 0; i < ha->mbx_count && cnt; i++, mboxes >>= 1)
 579                                 if (mboxes & BIT_0) {
 580                                         printk(" mb[%u]=%x", i, mcp->mb[i]);
 581                                         cnt--;
 582                                 }
 583                         pr_warn(" cmd=%x ****\n", command);
 584                 }
 585                 if (IS_FWI2_CAPABLE(ha) && !(IS_P3P_TYPE(ha))) {
 586                         ql_dbg(ql_dbg_mbx, vha, 0x1198,
 587                             "host_status=%#x intr_ctrl=%#x intr_status=%#x\n",
 588                             rd_reg_dword(&reg->isp24.host_status),
 589                             rd_reg_dword(&reg->isp24.ictrl),
 590                             rd_reg_dword(&reg->isp24.istatus));
 591                 } else {
 592                         ql_dbg(ql_dbg_mbx, vha, 0x1206,
 593                             "ctrl_status=%#x ictrl=%#x istatus=%#x\n",
 594                             rd_reg_word(&reg->isp.ctrl_status),
 595                             rd_reg_word(&reg->isp.ictrl),
 596                             rd_reg_word(&reg->isp.istatus));
 597                 }
 598         } else {
 599                 ql_dbg(ql_dbg_mbx, base_vha, 0x1021, "Done %s.\n", __func__);
 600         }
 601
 602         i = 500;
 603         while (i && eeh_delay && (ha->pci_error_state < QLA_PCI_SLOT_RESET)) {
 604                 /*
 605                  * The caller of this mailbox encounter pci error.
 606                  * Hold the thread until PCIE link reset complete to make
 607                  * sure caller does not unmap dma while recovery is
 608                  * in progress.
 609                  */
 610                 msleep(1);
 611                 i--;
 612         }
 613         return rval;
 614 }
 615
 616 int
 617 qla2x00_load_ram(scsi_qla_host_t *vha, dma_addr_t req_dma, uint32_t risc_addr,
 618     uint32_t risc_code_size)
 619 {
 620         int rval;
 621         struct qla_hw_data *ha = vha->hw;
 622         mbx_cmd_t mc;
 623         mbx_cmd_t *mcp = &mc;
 624
 625         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1022,
 626             "Entered %s.\n", __func__);
 627
 628         if (MSW(risc_addr) || IS_FWI2_CAPABLE(ha)) {
 629                 mcp->mb[0] = MBC_LOAD_RISC_RAM_EXTENDED;
 630                 mcp->mb[8] = MSW(risc_addr);
 631                 mcp->out_mb = MBX_8|MBX_0;
 632         } else {
 633                 mcp->mb[0] = MBC_LOAD_RISC_RAM;
 634                 mcp->out_mb = MBX_0;
 635         }
 636         mcp->mb[1] = LSW(risc_addr);
 637         mcp->mb[2] = MSW(req_dma);
 638         mcp->mb[3] = LSW(req_dma);
 639         mcp->mb[6] = MSW(MSD(req_dma));
 640         mcp->mb[7] = LSW(MSD(req_dma));
 641         mcp->out_mb |= MBX_7|MBX_6|MBX_3|MBX_2|MBX_1;
 642         if (IS_FWI2_CAPABLE(ha)) {
 643                 mcp->mb[4] = MSW(risc_code_size);
 644                 mcp->mb[5] = LSW(risc_code_size);
 645                 mcp->out_mb |= MBX_5|MBX_4;
 646         } else {
 647                 mcp->mb[4] = LSW(risc_code_size);
 648                 mcp->out_mb |= MBX_4;
 649         }
 650
 651         mcp->in_mb = MBX_1|MBX_0;
 652         mcp->tov = MBX_TOV_SECONDS;
 653         mcp->flags = 0;
 654         rval = qla2x00_mailbox_command(vha, mcp);
 655
 656         if (rval != QLA_SUCCESS) {
 657                 ql_dbg(ql_dbg_mbx, vha, 0x1023,
 658                     "Failed=%x mb[0]=%x mb[1]=%x.\n",
 659                     rval, mcp->mb[0], mcp->mb[1]);
 660                 vha->hw_err_cnt++;
 661         } else {
 662                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1024,
 663                     "Done %s.\n", __func__);
 664         }
 665
 666         return rval;
 667 }
 668
 669 #define NVME_ENABLE_FLAG        BIT_3
 670 #define EDIF_HW_SUPPORT         BIT_10
 671
 672 /*
 673  * qla2x00_execute_fw
 674  *     Start adapter firmware.
 675  *
 676  * Input:
 677  *     ha = adapter block pointer.
 678  *     TARGET_QUEUE_LOCK must be released.
 679  *     ADAPTER_STATE_LOCK must be released.
 680  *
 681  * Returns:
 682  *     qla2x00 local function return status code.
 683  *
 684  * Context:
 685  *     Kernel context.
 686  */
 687 int
 688 qla2x00_execute_fw(scsi_qla_host_t *vha, uint32_t risc_addr)
 689 {
 690         int rval;
 691         struct qla_hw_data *ha = vha->hw;
 692         mbx_cmd_t mc;
 693         mbx_cmd_t *mcp = &mc;
 694         u8 semaphore = 0;
 695 #define EXE_FW_FORCE_SEMAPHORE BIT_7
 696         u8 retry = 5;
 697
 698         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1025,
 699             "Entered %s.\n", __func__);
 700
 701 again:
 702         mcp->mb[0] = MBC_EXECUTE_FIRMWARE;
 703         mcp->out_mb = MBX_0;
 704         mcp->in_mb = MBX_0;
 705         if (IS_FWI2_CAPABLE(ha)) {
 706                 mcp->mb[1] = MSW(risc_addr);
 707                 mcp->mb[2] = LSW(risc_addr);
 708                 mcp->mb[3] = 0;
 709                 mcp->mb[4] = 0;
 710                 mcp->mb[11] = 0;
 711
 712                 /* Enable BPM? */
 713                 if (ha->flags.lr_detected) {
 714                         mcp->mb[4] = BIT_0;
 715                         if (IS_BPM_RANGE_CAPABLE(ha))
 716                                 mcp->mb[4] |=
 717                                     ha->lr_distance << LR_DIST_FW_POS;
 718                 }
 719
 720                 if (ql2xnvmeenable && (IS_QLA27XX(ha) || IS_QLA28XX(ha)))
 721                         mcp->mb[4] |= NVME_ENABLE_FLAG;
 722
 723                 if (IS_QLA83XX(ha) || IS_QLA27XX(ha) || IS_QLA28XX(ha)) {
 724                         struct nvram_81xx *nv = ha->nvram;
 725                         /* set minimum speed if specified in nvram */
 726                         if (nv->min_supported_speed >= 2 &&
 727                             nv->min_supported_speed <= 5) {
 728                                 mcp->mb[4] |= BIT_4;
 729                                 mcp->mb[11] |= nv->min_supported_speed & 0xF;
 730                                 mcp->out_mb |= MBX_11;
 731                                 mcp->in_mb |= BIT_5;
 732                                 vha->min_supported_speed =
 733                                     nv->min_supported_speed;
 734                         }
 735
 736                         if (IS_PPCARCH)
 737                                 mcp->mb[11] |= BIT_4;
 738                 }
 739
 740                 if (ha->flags.exlogins_enabled)
 741                         mcp->mb[4] |= ENABLE_EXTENDED_LOGIN;
 742
 743                 if (ha->flags.exchoffld_enabled)
 744                         mcp->mb[4] |= ENABLE_EXCHANGE_OFFLD;
 745
 746                 if (semaphore)
 747                         mcp->mb[11] |= EXE_FW_FORCE_SEMAPHORE;
 748
 749                 mcp->out_mb |= MBX_4 | MBX_3 | MBX_2 | MBX_1 | MBX_11;
 750                 mcp->in_mb |= MBX_5 | MBX_3 | MBX_2 | MBX_1;
 751         } else {
 752                 mcp->mb[1] = LSW(risc_addr);
 753                 mcp->out_mb |= MBX_1;
 754                 if (IS_QLA2322(ha) || IS_QLA6322(ha)) {
 755                         mcp->mb[2] = 0;
 756                         mcp->out_mb |= MBX_2;
 757                 }
 758         }
 759
 760         mcp->tov = MBX_TOV_SECONDS;
 761         mcp->flags = 0;
 762         rval = qla2x00_mailbox_command(vha, mcp);
 763
 764         if (rval != QLA_SUCCESS) {
 765                 if (IS_QLA28XX(ha) && rval == QLA_COMMAND_ERROR &&
 766                     mcp->mb[1] == 0x27 && retry) {
 767                         semaphore = 1;
 768                         retry--;
 769                         ql_dbg(ql_dbg_async, vha, 0x1026,
 770                             "Exe FW: force semaphore.\n");
 771                         goto again;
 772                 }
 773
 774                 if (retry) {
 775                         retry--;
 776                         ql_dbg(ql_dbg_async, vha, 0x509d,
 777                             "Exe FW retry: mb[0]=%x retry[%d]\n", mcp->mb[0], retry);
 778                         goto again;
 779                 }
 780                 ql_dbg(ql_dbg_mbx, vha, 0x1026,
 781                     "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
 782                 vha->hw_err_cnt++;
 783                 return rval;
 784         }
 785
 786         if (!IS_FWI2_CAPABLE(ha))
 787                 goto done;
 788
 789         ha->fw_ability_mask = mcp->mb[3] << 16 | mcp->mb[2];
 790         ql_dbg(ql_dbg_mbx, vha, 0x119a,
 791             "fw_ability_mask=%x.\n", ha->fw_ability_mask);
 792         ql_dbg(ql_dbg_mbx, vha, 0x1027, "exchanges=%x.\n", mcp->mb[1]);
 793         if (IS_QLA27XX(ha) || IS_QLA28XX(ha)) {
 794                 ha->max_supported_speed = mcp->mb[2] & (BIT_0|BIT_1);
 795                 ql_dbg(ql_dbg_mbx, vha, 0x119b, "max_supported_speed=%s.\n",
 796                     ha->max_supported_speed == 0 ? "16Gps" :
 797                     ha->max_supported_speed == 1 ? "32Gps" :
 798                     ha->max_supported_speed == 2 ? "64Gps" : "unknown");
 799                 if (vha->min_supported_speed) {
 800                         ha->min_supported_speed = mcp->mb[5] &
 801                             (BIT_0 | BIT_1 | BIT_2);
 802                         ql_dbg(ql_dbg_mbx, vha, 0x119c,
 803                             "min_supported_speed=%s.\n",
 804                             ha->min_supported_speed == 6 ? "64Gps" :
 805                             ha->min_supported_speed == 5 ? "32Gps" :
 806                             ha->min_supported_speed == 4 ? "16Gps" :
 807                             ha->min_supported_speed == 3 ? "8Gps" :
 808                             ha->min_supported_speed == 2 ? "4Gps" : "unknown");
 809                 }
 810         }
 811
 812         if (IS_QLA28XX(ha) && (mcp->mb[5] & EDIF_HW_SUPPORT)) {
 813                 ha->flags.edif_hw = 1;
 814                 ql_log(ql_log_info, vha, 0xffff,
 815                     "%s: edif HW\n", __func__);
 816         }
 817
 818 done:
 819         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1028,
 820             "Done %s.\n", __func__);
 821
 822         return rval;
 823 }
 824
 825 /*
 826  * qla_get_exlogin_status
 827  *      Get extended login status
 828  *      uses the memory offload control/status Mailbox
 829  *
 830  * Input:
 831  *      ha:             adapter state pointer.
 832  *      fwopt:          firmware options
 833  *
 834  * Returns:
 835  *      qla2x00 local function status
 836  *
 837  * Context:
 838  *      Kernel context.
 839  */
 840 #define FETCH_XLOGINS_STAT      0x8
 841 int
 842 qla_get_exlogin_status(scsi_qla_host_t *vha, uint16_t *buf_sz,
 843         uint16_t *ex_logins_cnt)
 844 {
 845         int rval;
 846         mbx_cmd_t       mc;
 847         mbx_cmd_t       *mcp = &mc;
 848
 849         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x118f,
 850             "Entered %s\n", __func__);
 851
 852         memset(mcp->mb, 0 , sizeof(mcp->mb));
 853         mcp->mb[0] = MBC_GET_MEM_OFFLOAD_CNTRL_STAT;
 854         mcp->mb[1] = FETCH_XLOGINS_STAT;
 855         mcp->out_mb = MBX_1|MBX_0;
 856         mcp->in_mb = MBX_10|MBX_4|MBX_0;
 857         mcp->tov = MBX_TOV_SECONDS;
 858         mcp->flags = 0;
 859
 860         rval = qla2x00_mailbox_command(vha, mcp);
 861         if (rval != QLA_SUCCESS) {
 862                 ql_dbg(ql_dbg_mbx, vha, 0x1115, "Failed=%x.\n", rval);
 863         } else {
 864                 *buf_sz = mcp->mb[4];
 865                 *ex_logins_cnt = mcp->mb[10];
 866
 867                 ql_log(ql_log_info, vha, 0x1190,
 868                     "buffer size 0x%x, exchange login count=%d\n",
 869                     mcp->mb[4], mcp->mb[10]);
 870
 871                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1116,
 872                     "Done %s.\n", __func__);
 873         }
 874
 875         return rval;
 876 }
 877
 878 /*
 879  * qla_set_exlogin_mem_cfg
 880  *      set extended login memory configuration
 881  *      Mbx needs to be issues before init_cb is set
 882  *
 883  * Input:
 884  *      ha:             adapter state pointer.
 885  *      buffer:         buffer pointer
 886  *      phys_addr:      physical address of buffer
 887  *      size:           size of buffer
 888  *      TARGET_QUEUE_LOCK must be released
 889  *      ADAPTER_STATE_LOCK must be release
 890  *
 891  * Returns:
 892  *      qla2x00 local funxtion status code.
 893  *
 894  * Context:
 895  *      Kernel context.
 896  */
 897 #define CONFIG_XLOGINS_MEM      0x9
 898 int
 899 qla_set_exlogin_mem_cfg(scsi_qla_host_t *vha, dma_addr_t phys_addr)
 900 {
 901         int             rval;
 902         mbx_cmd_t       mc;
 903         mbx_cmd_t       *mcp = &mc;
 904         struct qla_hw_data *ha = vha->hw;
 905
 906         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x111a,
 907             "Entered %s.\n", __func__);
 908
 909         memset(mcp->mb, 0 , sizeof(mcp->mb));
 910         mcp->mb[0] = MBC_GET_MEM_OFFLOAD_CNTRL_STAT;
 911         mcp->mb[1] = CONFIG_XLOGINS_MEM;
 912         mcp->mb[2] = MSW(phys_addr);
 913         mcp->mb[3] = LSW(phys_addr);
 914         mcp->mb[6] = MSW(MSD(phys_addr));
 915         mcp->mb[7] = LSW(MSD(phys_addr));
 916         mcp->mb[8] = MSW(ha->exlogin_size);
 917         mcp->mb[9] = LSW(ha->exlogin_size);
 918         mcp->out_mb = MBX_9|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
 919         mcp->in_mb = MBX_11|MBX_0;
 920         mcp->tov = MBX_TOV_SECONDS;
 921         mcp->flags = 0;
 922         rval = qla2x00_mailbox_command(vha, mcp);
 923         if (rval != QLA_SUCCESS) {
 924                 ql_dbg(ql_dbg_mbx, vha, 0x111b,
 925                        "EXlogin Failed=%x. MB0=%x MB11=%x\n",
 926                        rval, mcp->mb[0], mcp->mb[11]);
 927         } else {
 928                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x118c,
 929                     "Done %s.\n", __func__);
 930         }
 931
 932         return rval;
 933 }
 934
 935 /*
 936  * qla_get_exchoffld_status
 937  *      Get exchange offload status
 938  *      uses the memory offload control/status Mailbox
 939  *
 940  * Input:
 941  *      ha:             adapter state pointer.
 942  *      fwopt:          firmware options
 943  *
 944  * Returns:
 945  *      qla2x00 local function status
 946  *
 947  * Context:
 948  *      Kernel context.
 949  */
 950 #define FETCH_XCHOFFLD_STAT     0x2
 951 int
 952 qla_get_exchoffld_status(scsi_qla_host_t *vha, uint16_t *buf_sz,
 953         uint16_t *ex_logins_cnt)
 954 {
 955         int rval;
 956         mbx_cmd_t       mc;
 957         mbx_cmd_t       *mcp = &mc;
 958
 959         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1019,
 960             "Entered %s\n", __func__);
 961
 962         memset(mcp->mb, 0 , sizeof(mcp->mb));
 963         mcp->mb[0] = MBC_GET_MEM_OFFLOAD_CNTRL_STAT;
 964         mcp->mb[1] = FETCH_XCHOFFLD_STAT;
 965         mcp->out_mb = MBX_1|MBX_0;
 966         mcp->in_mb = MBX_10|MBX_4|MBX_0;
 967         mcp->tov = MBX_TOV_SECONDS;
 968         mcp->flags = 0;
 969
 970         rval = qla2x00_mailbox_command(vha, mcp);
 971         if (rval != QLA_SUCCESS) {
 972                 ql_dbg(ql_dbg_mbx, vha, 0x1155, "Failed=%x.\n", rval);
 973         } else {
 974                 *buf_sz = mcp->mb[4];
 975                 *ex_logins_cnt = mcp->mb[10];
 976
 977                 ql_log(ql_log_info, vha, 0x118e,
 978                     "buffer size 0x%x, exchange offload count=%d\n",
 979                     mcp->mb[4], mcp->mb[10]);
 980
 981                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1156,
 982                     "Done %s.\n", __func__);
 983         }
 984
 985         return rval;
 986 }
 987
 988 /*
 989  * qla_set_exchoffld_mem_cfg
 990  *      Set exchange offload memory configuration
 991  *      Mbx needs to be issues before init_cb is set
 992  *
 993  * Input:
 994  *      ha:             adapter state pointer.
 995  *      buffer:         buffer pointer
 996  *      phys_addr:      physical address of buffer
 997  *      size:           size of buffer
 998  *      TARGET_QUEUE_LOCK must be released
 999  *      ADAPTER_STATE_LOCK must be release
1000  *
1001  * Returns:
1002  *      qla2x00 local funxtion status code.
1003  *
1004  * Context:
1005  *      Kernel context.
1006  */
1007 #define CONFIG_XCHOFFLD_MEM     0x3
1008 int
1009 qla_set_exchoffld_mem_cfg(scsi_qla_host_t *vha)
1010 {
1011         int             rval;
1012         mbx_cmd_t       mc;
1013         mbx_cmd_t       *mcp = &mc;
1014         struct qla_hw_data *ha = vha->hw;
1015
1016         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1157,
1017             "Entered %s.\n", __func__);
1018
1019         memset(mcp->mb, 0 , sizeof(mcp->mb));
1020         mcp->mb[0] = MBC_GET_MEM_OFFLOAD_CNTRL_STAT;
1021         mcp->mb[1] = CONFIG_XCHOFFLD_MEM;
1022         mcp->mb[2] = MSW(ha->exchoffld_buf_dma);
1023         mcp->mb[3] = LSW(ha->exchoffld_buf_dma);
1024         mcp->mb[6] = MSW(MSD(ha->exchoffld_buf_dma));
1025         mcp->mb[7] = LSW(MSD(ha->exchoffld_buf_dma));
1026         mcp->mb[8] = MSW(ha->exchoffld_size);
1027         mcp->mb[9] = LSW(ha->exchoffld_size);
1028         mcp->out_mb = MBX_9|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
1029         mcp->in_mb = MBX_11|MBX_0;
1030         mcp->tov = MBX_TOV_SECONDS;
1031         mcp->flags = 0;
1032         rval = qla2x00_mailbox_command(vha, mcp);
1033         if (rval != QLA_SUCCESS) {
1034                 /*EMPTY*/
1035                 ql_dbg(ql_dbg_mbx, vha, 0x1158, "Failed=%x.\n", rval);
1036         } else {
1037                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1192,
1038                     "Done %s.\n", __func__);
1039         }
1040
1041         return rval;
1042 }
1043
1044 /*
1045  * qla2x00_get_fw_version
1046  *      Get firmware version.
1047  *
1048  * Input:
1049  *      ha:             adapter state pointer.
1050  *      major:          pointer for major number.
1051  *      minor:          pointer for minor number.
1052  *      subminor:       pointer for subminor number.
1053  *
1054  * Returns:
1055  *      qla2x00 local function return status code.
1056  *
1057  * Context:
1058  *      Kernel context.
1059  */
1060 int
1061 qla2x00_get_fw_version(scsi_qla_host_t *vha)
1062 {
1063         int             rval;
1064         mbx_cmd_t       mc;
1065         mbx_cmd_t       *mcp = &mc;
1066         struct qla_hw_data *ha = vha->hw;
1067
1068         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1029,
1069             "Entered %s.\n", __func__);
1070
1071         mcp->mb[0] = MBC_GET_FIRMWARE_VERSION;
1072         mcp->out_mb = MBX_0;
1073         mcp->in_mb = MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
1074         if (IS_QLA81XX(vha->hw) || IS_QLA8031(ha) || IS_QLA8044(ha))
1075                 mcp->in_mb |= MBX_13|MBX_12|MBX_11|MBX_10|MBX_9|MBX_8;
1076         if (IS_FWI2_CAPABLE(ha))
1077                 mcp->in_mb |= MBX_17|MBX_16|MBX_15;
1078         if (IS_QLA27XX(ha) || IS_QLA28XX(ha))
1079                 mcp->in_mb |=
1080                     MBX_25|MBX_24|MBX_23|MBX_22|MBX_21|MBX_20|MBX_19|MBX_18|
1081                     MBX_14|MBX_13|MBX_11|MBX_10|MBX_9|MBX_8|MBX_7;
1082
1083         mcp->flags = 0;
1084         mcp->tov = MBX_TOV_SECONDS;
1085         rval = qla2x00_mailbox_command(vha, mcp);
1086         if (rval != QLA_SUCCESS)
1087                 goto failed;
1088
1089         /* Return mailbox data. */
1090         ha->fw_major_version = mcp->mb[1];
1091         ha->fw_minor_version = mcp->mb[2];
1092         ha->fw_subminor_version = mcp->mb[3];
1093         ha->fw_attributes = mcp->mb[6];
1094         if (IS_QLA2100(vha->hw) || IS_QLA2200(vha->hw))
1095                 ha->fw_memory_size = 0x1FFFF;           /* Defaults to 128KB. */
1096         else
1097                 ha->fw_memory_size = (mcp->mb[5] << 16) | mcp->mb[4];
1098
1099         if (IS_QLA81XX(vha->hw) || IS_QLA8031(vha->hw) || IS_QLA8044(ha)) {
1100                 ha->mpi_version[0] = mcp->mb[10] & 0xff;
1101                 ha->mpi_version[1] = mcp->mb[11] >> 8;
1102                 ha->mpi_version[2] = mcp->mb[11] & 0xff;
1103                 ha->mpi_capabilities = (mcp->mb[12] << 16) | mcp->mb[13];
1104                 ha->phy_version[0] = mcp->mb[8] & 0xff;
1105                 ha->phy_version[1] = mcp->mb[9] >> 8;
1106                 ha->phy_version[2] = mcp->mb[9] & 0xff;
1107         }
1108
1109         if (IS_FWI2_CAPABLE(ha)) {
1110                 ha->fw_attributes_h = mcp->mb[15];
1111                 ha->fw_attributes_ext[0] = mcp->mb[16];
1112                 ha->fw_attributes_ext[1] = mcp->mb[17];
1113                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1139,
1114                     "%s: FW_attributes Upper: 0x%x, Lower: 0x%x.\n",
1115                     __func__, mcp->mb[15], mcp->mb[6]);
1116                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x112f,
1117                     "%s: Ext_FwAttributes Upper: 0x%x, Lower: 0x%x.\n",
1118                     __func__, mcp->mb[17], mcp->mb[16]);
1119
1120                 if (ha->fw_attributes_h & 0x4)
1121                         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x118d,
1122                             "%s: Firmware supports Extended Login 0x%x\n",
1123                             __func__, ha->fw_attributes_h);
1124
1125                 if (ha->fw_attributes_h & 0x8)
1126                         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1191,
1127                             "%s: Firmware supports Exchange Offload 0x%x\n",
1128                             __func__, ha->fw_attributes_h);
1129
1130                 /*
1131                  * FW supports nvme and driver load parameter requested nvme.
1132                  * BIT 26 of fw_attributes indicates NVMe support.
1133                  */
1134                 if ((ha->fw_attributes_h &
1135                     (FW_ATTR_H_NVME | FW_ATTR_H_NVME_UPDATED)) &&
1136                         ql2xnvmeenable) {
1137                         if (ha->fw_attributes_h & FW_ATTR_H_NVME_FBURST)
1138                                 vha->flags.nvme_first_burst = 1;
1139
1140                         vha->flags.nvme_enabled = 1;
1141                         ql_log(ql_log_info, vha, 0xd302,
1142                             "%s: FC-NVMe is Enabled (0x%x)\n",
1143                              __func__, ha->fw_attributes_h);
1144                 }
1145
1146                 /* BIT_13 of Extended FW Attributes informs about NVMe2 support */
1147                 if (ha->fw_attributes_ext[0] & FW_ATTR_EXT0_NVME2) {
1148                         ql_log(ql_log_info, vha, 0xd302,
1149                                "Firmware supports NVMe2 0x%x\n",
1150                                ha->fw_attributes_ext[0]);
1151                         vha->flags.nvme2_enabled = 1;
1152                 }
1153
1154                 if (IS_QLA28XX(ha) && ha->flags.edif_hw && ql2xsecenable &&
1155                     (ha->fw_attributes_ext[0] & FW_ATTR_EXT0_EDIF)) {
1156                         ha->flags.edif_enabled = 1;
1157                         ql_log(ql_log_info, vha, 0xffff,
1158                                "%s: edif is enabled\n", __func__);
1159                 }
1160         }
1161
1162         if (IS_QLA27XX(ha) || IS_QLA28XX(ha)) {
1163                 ha->serdes_version[0] = mcp->mb[7] & 0xff;
1164                 ha->serdes_version[1] = mcp->mb[8] >> 8;
1165                 ha->serdes_version[2] = mcp->mb[8] & 0xff;
1166                 ha->mpi_version[0] = mcp->mb[10] & 0xff;
1167                 ha->mpi_version[1] = mcp->mb[11] >> 8;
1168                 ha->mpi_version[2] = mcp->mb[11] & 0xff;
1169                 ha->pep_version[0] = mcp->mb[13] & 0xff;
1170                 ha->pep_version[1] = mcp->mb[14] >> 8;
1171                 ha->pep_version[2] = mcp->mb[14] & 0xff;
1172                 ha->fw_shared_ram_start = (mcp->mb[19] << 16) | mcp->mb[18];
1173                 ha->fw_shared_ram_end = (mcp->mb[21] << 16) | mcp->mb[20];
1174                 ha->fw_ddr_ram_start = (mcp->mb[23] << 16) | mcp->mb[22];
1175                 ha->fw_ddr_ram_end = (mcp->mb[25] << 16) | mcp->mb[24];
1176                 if (IS_QLA28XX(ha)) {
1177                         if (mcp->mb[16] & BIT_10)
1178                                 ha->flags.secure_fw = 1;
1179
1180                         ql_log(ql_log_info, vha, 0xffff,
1181                             "Secure Flash Update in FW: %s\n",
1182                             (ha->flags.secure_fw) ? "Supported" :
1183                             "Not Supported");
1184                 }
1185
1186                 if (ha->flags.scm_supported_a &&
1187                     (ha->fw_attributes_ext[0] & FW_ATTR_EXT0_SCM_SUPPORTED)) {
1188                         ha->flags.scm_supported_f = 1;
1189                         ha->sf_init_cb->flags |= cpu_to_le16(BIT_13);
1190                 }
1191                 ql_log(ql_log_info, vha, 0x11a3, "SCM in FW: %s\n",
1192                        (ha->flags.scm_supported_f) ? "Supported" :
1193                        "Not Supported");
1194
1195                 if (vha->flags.nvme2_enabled) {
1196                         /* set BIT_15 of special feature control block for SLER */
1197                         ha->sf_init_cb->flags |= cpu_to_le16(BIT_15);
1198                         /* set BIT_14 of special feature control block for PI CTRL*/
1199                         ha->sf_init_cb->flags |= cpu_to_le16(BIT_14);
1200                 }
1201         }
1202
1203 failed:
1204         if (rval != QLA_SUCCESS) {
1205                 /*EMPTY*/
1206                 ql_dbg(ql_dbg_mbx, vha, 0x102a, "Failed=%x.\n", rval);
1207         } else {
1208                 /*EMPTY*/
1209                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x102b,
1210                     "Done %s.\n", __func__);
1211         }
1212         return rval;
1213 }
1214
1215 /*
1216  * qla2x00_get_fw_options
1217  *      Set firmware options.
1218  *
1219  * Input:
1220  *      ha = adapter block pointer.
1221  *      fwopt = pointer for firmware options.
1222  *
1223  * Returns:
1224  *      qla2x00 local function return status code.
1225  *
1226  * Context:
1227  *      Kernel context.
1228  */
1229 int
1230 qla2x00_get_fw_options(scsi_qla_host_t *vha, uint16_t *fwopts)
1231 {
1232         int rval;
1233         mbx_cmd_t mc;
1234         mbx_cmd_t *mcp = &mc;
1235
1236         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x102c,
1237             "Entered %s.\n", __func__);
1238
1239         mcp->mb[0] = MBC_GET_FIRMWARE_OPTION;
1240         mcp->out_mb = MBX_0;
1241         mcp->in_mb = MBX_3|MBX_2|MBX_1|MBX_0;
1242         mcp->tov = MBX_TOV_SECONDS;
1243         mcp->flags = 0;
1244         rval = qla2x00_mailbox_command(vha, mcp);
1245
1246         if (rval != QLA_SUCCESS) {
1247                 /*EMPTY*/
1248                 ql_dbg(ql_dbg_mbx, vha, 0x102d, "Failed=%x.\n", rval);
1249         } else {
1250                 fwopts[0] = mcp->mb[0];
1251                 fwopts[1] = mcp->mb[1];
1252                 fwopts[2] = mcp->mb[2];
1253                 fwopts[3] = mcp->mb[3];
1254
1255                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x102e,
1256                     "Done %s.\n", __func__);
1257         }
1258
1259         return rval;
1260 }
1261
1262
1263 /*
1264  * qla2x00_set_fw_options
1265  *      Set firmware options.
1266  *
1267  * Input:
1268  *      ha = adapter block pointer.
1269  *      fwopt = pointer for firmware options.
1270  *
1271  * Returns:
1272  *      qla2x00 local function return status code.
1273  *
1274  * Context:
1275  *      Kernel context.
1276  */
1277 int
1278 qla2x00_set_fw_options(scsi_qla_host_t *vha, uint16_t *fwopts)
1279 {
1280         int rval;
1281         mbx_cmd_t mc;
1282         mbx_cmd_t *mcp = &mc;
1283
1284         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x102f,
1285             "Entered %s.\n", __func__);
1286
1287         mcp->mb[0] = MBC_SET_FIRMWARE_OPTION;
1288         mcp->mb[1] = fwopts[1];
1289         mcp->mb[2] = fwopts[2];
1290         mcp->mb[3] = fwopts[3];
1291         mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
1292         mcp->in_mb = MBX_0;
1293         if (IS_FWI2_CAPABLE(vha->hw)) {
1294                 mcp->in_mb |= MBX_1;
1295                 mcp->mb[10] = fwopts[10];
1296                 mcp->out_mb |= MBX_10;
1297         } else {
1298                 mcp->mb[10] = fwopts[10];
1299                 mcp->mb[11] = fwopts[11];
1300                 mcp->mb[12] = 0;        /* Undocumented, but used */
1301                 mcp->out_mb |= MBX_12|MBX_11|MBX_10;
1302         }
1303         mcp->tov = MBX_TOV_SECONDS;
1304         mcp->flags = 0;
1305         rval = qla2x00_mailbox_command(vha, mcp);
1306
1307         fwopts[0] = mcp->mb[0];
1308
1309         if (rval != QLA_SUCCESS) {
1310                 /*EMPTY*/
1311                 ql_dbg(ql_dbg_mbx, vha, 0x1030,
1312                     "Failed=%x (%x/%x).\n", rval, mcp->mb[0], mcp->mb[1]);
1313         } else {
1314                 /*EMPTY*/
1315                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1031,
1316                     "Done %s.\n", __func__);
1317         }
1318
1319         return rval;
1320 }
1321
1322 /*
1323  * qla2x00_mbx_reg_test
1324  *      Mailbox register wrap test.
1325  *
1326  * Input:
1327  *      ha = adapter block pointer.
1328  *      TARGET_QUEUE_LOCK must be released.
1329  *      ADAPTER_STATE_LOCK must be released.
1330  *
1331  * Returns:
1332  *      qla2x00 local function return status code.
1333  *
1334  * Context:
1335  *      Kernel context.
1336  */
1337 int
1338 qla2x00_mbx_reg_test(scsi_qla_host_t *vha)
1339 {
1340         int rval;
1341         mbx_cmd_t mc;
1342         mbx_cmd_t *mcp = &mc;
1343
1344         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1032,
1345             "Entered %s.\n", __func__);
1346
1347         mcp->mb[0] = MBC_MAILBOX_REGISTER_TEST;
1348         mcp->mb[1] = 0xAAAA;
1349         mcp->mb[2] = 0x5555;
1350         mcp->mb[3] = 0xAA55;
1351         mcp->mb[4] = 0x55AA;
1352         mcp->mb[5] = 0xA5A5;
1353         mcp->mb[6] = 0x5A5A;
1354         mcp->mb[7] = 0x2525;
1355         mcp->out_mb = MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
1356         mcp->in_mb = MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
1357         mcp->tov = MBX_TOV_SECONDS;
1358         mcp->flags = 0;
1359         rval = qla2x00_mailbox_command(vha, mcp);
1360
1361         if (rval == QLA_SUCCESS) {
1362                 if (mcp->mb[1] != 0xAAAA || mcp->mb[2] != 0x5555 ||
1363                     mcp->mb[3] != 0xAA55 || mcp->mb[4] != 0x55AA)
1364                         rval = QLA_FUNCTION_FAILED;
1365                 if (mcp->mb[5] != 0xA5A5 || mcp->mb[6] != 0x5A5A ||
1366                     mcp->mb[7] != 0x2525)
1367                         rval = QLA_FUNCTION_FAILED;
1368         }
1369
1370         if (rval != QLA_SUCCESS) {
1371                 /*EMPTY*/
1372                 ql_dbg(ql_dbg_mbx, vha, 0x1033, "Failed=%x.\n", rval);
1373                 vha->hw_err_cnt++;
1374         } else {
1375                 /*EMPTY*/
1376                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1034,
1377                     "Done %s.\n", __func__);
1378         }
1379
1380         return rval;
1381 }
1382
1383 /*
1384  * qla2x00_verify_checksum
1385  *      Verify firmware checksum.
1386  *
1387  * Input:
1388  *      ha = adapter block pointer.
1389  *      TARGET_QUEUE_LOCK must be released.
1390  *      ADAPTER_STATE_LOCK must be released.
1391  *
1392  * Returns:
1393  *      qla2x00 local function return status code.
1394  *
1395  * Context:
1396  *      Kernel context.
1397  */
1398 int
1399 qla2x00_verify_checksum(scsi_qla_host_t *vha, uint32_t risc_addr)
1400 {
1401         int rval;
1402         mbx_cmd_t mc;
1403         mbx_cmd_t *mcp = &mc;
1404
1405         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1035,
1406             "Entered %s.\n", __func__);
1407
1408         mcp->mb[0] = MBC_VERIFY_CHECKSUM;
1409         mcp->out_mb = MBX_0;
1410         mcp->in_mb = MBX_0;
1411         if (IS_FWI2_CAPABLE(vha->hw)) {
1412                 mcp->mb[1] = MSW(risc_addr);
1413                 mcp->mb[2] = LSW(risc_addr);
1414                 mcp->out_mb |= MBX_2|MBX_1;
1415                 mcp->in_mb |= MBX_2|MBX_1;
1416         } else {
1417                 mcp->mb[1] = LSW(risc_addr);
1418                 mcp->out_mb |= MBX_1;
1419                 mcp->in_mb |= MBX_1;
1420         }
1421
1422         mcp->tov = MBX_TOV_SECONDS;
1423         mcp->flags = 0;
1424         rval = qla2x00_mailbox_command(vha, mcp);
1425
1426         if (rval != QLA_SUCCESS) {
1427                 ql_dbg(ql_dbg_mbx, vha, 0x1036,
1428                     "Failed=%x chm sum=%x.\n", rval, IS_FWI2_CAPABLE(vha->hw) ?
1429                     (mcp->mb[2] << 16) | mcp->mb[1] : mcp->mb[1]);
1430         } else {
1431                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1037,
1432                     "Done %s.\n", __func__);
1433         }
1434
1435         return rval;
1436 }
1437
1438 /*
1439  * qla2x00_issue_iocb
1440  *      Issue IOCB using mailbox command
1441  *
1442  * Input:
1443  *      ha = adapter state pointer.
1444  *      buffer = buffer pointer.
1445  *      phys_addr = physical address of buffer.
1446  *      size = size of buffer.
1447  *      TARGET_QUEUE_LOCK must be released.
1448  *      ADAPTER_STATE_LOCK must be released.
1449  *
1450  * Returns:
1451  *      qla2x00 local function return status code.
1452  *
1453  * Context:
1454  *      Kernel context.
1455  */
1456 int
1457 qla2x00_issue_iocb_timeout(scsi_qla_host_t *vha, void *buffer,
1458     dma_addr_t phys_addr, size_t size, uint32_t tov)
1459 {
1460         int             rval;
1461         mbx_cmd_t       mc;
1462         mbx_cmd_t       *mcp = &mc;
1463
1464         if (!vha->hw->flags.fw_started)
1465                 return QLA_INVALID_COMMAND;
1466
1467         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1038,
1468             "Entered %s.\n", __func__);
1469
1470         mcp->mb[0] = MBC_IOCB_COMMAND_A64;
1471         mcp->mb[1] = 0;
1472         mcp->mb[2] = MSW(LSD(phys_addr));
1473         mcp->mb[3] = LSW(LSD(phys_addr));
1474         mcp->mb[6] = MSW(MSD(phys_addr));
1475         mcp->mb[7] = LSW(MSD(phys_addr));
1476         mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
1477         mcp->in_mb = MBX_1|MBX_0;
1478         mcp->tov = tov;
1479         mcp->flags = 0;
1480         rval = qla2x00_mailbox_command(vha, mcp);
1481
1482         if (rval != QLA_SUCCESS) {
1483                 /*EMPTY*/
1484                 ql_dbg(ql_dbg_mbx, vha, 0x1039, "Failed=%x.\n", rval);
1485         } else {
1486                 sts_entry_t *sts_entry = buffer;
1487
1488                 /* Mask reserved bits. */
1489                 sts_entry->entry_status &=
1490                     IS_FWI2_CAPABLE(vha->hw) ? RF_MASK_24XX : RF_MASK;
1491                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x103a,
1492                     "Done %s (status=%x).\n", __func__,
1493                     sts_entry->entry_status);
1494         }
1495
1496         return rval;
1497 }
1498
1499 int
1500 qla2x00_issue_iocb(scsi_qla_host_t *vha, void *buffer, dma_addr_t phys_addr,
1501     size_t size)
1502 {
1503         return qla2x00_issue_iocb_timeout(vha, buffer, phys_addr, size,
1504             MBX_TOV_SECONDS);
1505 }
1506
1507 /*
1508  * qla2x00_abort_command
1509  *      Abort command aborts a specified IOCB.
1510  *
1511  * Input:
1512  *      ha = adapter block pointer.
1513  *      sp = SB structure pointer.
1514  *
1515  * Returns:
1516  *      qla2x00 local function return status code.
1517  *
1518  * Context:
1519  *      Kernel context.
1520  */
1521 int
1522 qla2x00_abort_command(srb_t *sp)
1523 {
1524         unsigned long   flags = 0;
1525         int             rval;
1526         uint32_t        handle = 0;
1527         mbx_cmd_t       mc;
1528         mbx_cmd_t       *mcp = &mc;
1529         fc_port_t       *fcport = sp->fcport;
1530         scsi_qla_host_t *vha = fcport->vha;
1531         struct qla_hw_data *ha = vha->hw;
1532         struct req_que *req;
1533         struct scsi_cmnd *cmd = GET_CMD_SP(sp);
1534
1535         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x103b,
1536             "Entered %s.\n", __func__);
1537
1538         if (sp->qpair)
1539                 req = sp->qpair->req;
1540         else
1541                 req = vha->req;
1542
1543         spin_lock_irqsave(&ha->hardware_lock, flags);
1544         for (handle = 1; handle < req->num_outstanding_cmds; handle++) {
1545                 if (req->outstanding_cmds[handle] == sp)
1546                         break;
1547         }
1548         spin_unlock_irqrestore(&ha->hardware_lock, flags);
1549
1550         if (handle == req->num_outstanding_cmds) {
1551                 /* command not found */
1552                 return QLA_FUNCTION_FAILED;
1553         }
1554
1555         mcp->mb[0] = MBC_ABORT_COMMAND;
1556         if (HAS_EXTENDED_IDS(ha))
1557                 mcp->mb[1] = fcport->loop_id;
1558         else
1559                 mcp->mb[1] = fcport->loop_id << 8;
1560         mcp->mb[2] = (uint16_t)handle;
1561         mcp->mb[3] = (uint16_t)(handle >> 16);
1562         mcp->mb[6] = (uint16_t)cmd->device->lun;
1563         mcp->out_mb = MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
1564         mcp->in_mb = MBX_0;
1565         mcp->tov = MBX_TOV_SECONDS;
1566         mcp->flags = 0;
1567         rval = qla2x00_mailbox_command(vha, mcp);
1568
1569         if (rval != QLA_SUCCESS) {
1570                 ql_dbg(ql_dbg_mbx, vha, 0x103c, "Failed=%x.\n", rval);
1571         } else {
1572                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x103d,
1573                     "Done %s.\n", __func__);
1574         }
1575
1576         return rval;
1577 }
1578
1579 int
1580 qla2x00_abort_target(struct fc_port *fcport, uint64_t l, int tag)
1581 {
1582         int rval, rval2;
1583         mbx_cmd_t  mc;
1584         mbx_cmd_t  *mcp = &mc;
1585         scsi_qla_host_t *vha;
1586
1587         vha = fcport->vha;
1588
1589         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x103e,
1590             "Entered %s.\n", __func__);
1591
1592         mcp->mb[0] = MBC_ABORT_TARGET;
1593         mcp->out_mb = MBX_9|MBX_2|MBX_1|MBX_0;
1594         if (HAS_EXTENDED_IDS(vha->hw)) {
1595                 mcp->mb[1] = fcport->loop_id;
1596                 mcp->mb[10] = 0;
1597                 mcp->out_mb |= MBX_10;
1598         } else {
1599                 mcp->mb[1] = fcport->loop_id << 8;
1600         }
1601         mcp->mb[2] = vha->hw->loop_reset_delay;
1602         mcp->mb[9] = vha->vp_idx;
1603
1604         mcp->in_mb = MBX_0;
1605         mcp->tov = MBX_TOV_SECONDS;
1606         mcp->flags = 0;
1607         rval = qla2x00_mailbox_command(vha, mcp);
1608         if (rval != QLA_SUCCESS) {
1609                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x103f,
1610                     "Failed=%x.\n", rval);
1611         }
1612
1613         /* Issue marker IOCB. */
1614         rval2 = qla2x00_marker(vha, vha->hw->base_qpair, fcport->loop_id, 0,
1615                                                         MK_SYNC_ID);
1616         if (rval2 != QLA_SUCCESS) {
1617                 ql_dbg(ql_dbg_mbx, vha, 0x1040,
1618                     "Failed to issue marker IOCB (%x).\n", rval2);
1619         } else {
1620                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1041,
1621                     "Done %s.\n", __func__);
1622         }
1623
1624         return rval;
1625 }
1626
1627 int
1628 qla2x00_lun_reset(struct fc_port *fcport, uint64_t l, int tag)
1629 {
1630         int rval, rval2;
1631         mbx_cmd_t  mc;
1632         mbx_cmd_t  *mcp = &mc;
1633         scsi_qla_host_t *vha;
1634
1635         vha = fcport->vha;
1636
1637         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1042,
1638             "Entered %s.\n", __func__);
1639
1640         mcp->mb[0] = MBC_LUN_RESET;
1641         mcp->out_mb = MBX_9|MBX_3|MBX_2|MBX_1|MBX_0;
1642         if (HAS_EXTENDED_IDS(vha->hw))
1643                 mcp->mb[1] = fcport->loop_id;
1644         else
1645                 mcp->mb[1] = fcport->loop_id << 8;
1646         mcp->mb[2] = (u32)l;
1647         mcp->mb[3] = 0;
1648         mcp->mb[9] = vha->vp_idx;
1649
1650         mcp->in_mb = MBX_0;
1651         mcp->tov = MBX_TOV_SECONDS;
1652         mcp->flags = 0;
1653         rval = qla2x00_mailbox_command(vha, mcp);
1654         if (rval != QLA_SUCCESS) {
1655                 ql_dbg(ql_dbg_mbx, vha, 0x1043, "Failed=%x.\n", rval);
1656         }
1657
1658         /* Issue marker IOCB. */
1659         rval2 = qla2x00_marker(vha, vha->hw->base_qpair, fcport->loop_id, l,
1660                                                                 MK_SYNC_ID_LUN);
1661         if (rval2 != QLA_SUCCESS) {
1662                 ql_dbg(ql_dbg_mbx, vha, 0x1044,
1663                     "Failed to issue marker IOCB (%x).\n", rval2);
1664         } else {
1665                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1045,
1666                     "Done %s.\n", __func__);
1667         }
1668
1669         return rval;
1670 }
1671
1672 /*
1673  * qla2x00_get_adapter_id
1674  *      Get adapter ID and topology.
1675  *
1676  * Input:
1677  *      ha = adapter block pointer.
1678  *      id = pointer for loop ID.
1679  *      al_pa = pointer for AL_PA.
1680  *      area = pointer for area.
1681  *      domain = pointer for domain.
1682  *      top = pointer for topology.
1683  *      TARGET_QUEUE_LOCK must be released.
1684  *      ADAPTER_STATE_LOCK must be released.
1685  *
1686  * Returns:
1687  *      qla2x00 local function return status code.
1688  *
1689  * Context:
1690  *      Kernel context.
1691  */
1692 int
1693 qla2x00_get_adapter_id(scsi_qla_host_t *vha, uint16_t *id, uint8_t *al_pa,
1694     uint8_t *area, uint8_t *domain, uint16_t *top, uint16_t *sw_cap)
1695 {
1696         int rval;
1697         mbx_cmd_t mc;
1698         mbx_cmd_t *mcp = &mc;
1699
1700         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1046,
1701             "Entered %s.\n", __func__);
1702
1703         mcp->mb[0] = MBC_GET_ADAPTER_LOOP_ID;
1704         mcp->mb[9] = vha->vp_idx;
1705         mcp->out_mb = MBX_9|MBX_0;
1706         mcp->in_mb = MBX_9|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
1707         if (IS_CNA_CAPABLE(vha->hw))
1708                 mcp->in_mb |= MBX_13|MBX_12|MBX_11|MBX_10;
1709         if (IS_FWI2_CAPABLE(vha->hw))
1710                 mcp->in_mb |= MBX_19|MBX_18|MBX_17|MBX_16;
1711         if (IS_QLA27XX(vha->hw) || IS_QLA28XX(vha->hw))
1712                 mcp->in_mb |= MBX_15|MBX_21|MBX_22|MBX_23;
1713
1714         mcp->tov = MBX_TOV_SECONDS;
1715         mcp->flags = 0;
1716         rval = qla2x00_mailbox_command(vha, mcp);
1717         if (mcp->mb[0] == MBS_COMMAND_ERROR)
1718                 rval = QLA_COMMAND_ERROR;
1719         else if (mcp->mb[0] == MBS_INVALID_COMMAND)
1720                 rval = QLA_INVALID_COMMAND;
1721
1722         /* Return data. */
1723         *id = mcp->mb[1];
1724         *al_pa = LSB(mcp->mb[2]);
1725         *area = MSB(mcp->mb[2]);
1726         *domain = LSB(mcp->mb[3]);
1727         *top = mcp->mb[6];
1728         *sw_cap = mcp->mb[7];
1729
1730         if (rval != QLA_SUCCESS) {
1731                 /*EMPTY*/
1732                 ql_dbg(ql_dbg_mbx, vha, 0x1047, "Failed=%x.\n", rval);
1733         } else {
1734                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1048,
1735                     "Done %s.\n", __func__);
1736
1737                 if (IS_CNA_CAPABLE(vha->hw)) {
1738                         vha->fcoe_vlan_id = mcp->mb[9] & 0xfff;
1739                         vha->fcoe_fcf_idx = mcp->mb[10];
1740                         vha->fcoe_vn_port_mac[5] = mcp->mb[11] >> 8;
1741                         vha->fcoe_vn_port_mac[4] = mcp->mb[11] & 0xff;
1742                         vha->fcoe_vn_port_mac[3] = mcp->mb[12] >> 8;
1743                         vha->fcoe_vn_port_mac[2] = mcp->mb[12] & 0xff;
1744                         vha->fcoe_vn_port_mac[1] = mcp->mb[13] >> 8;
1745                         vha->fcoe_vn_port_mac[0] = mcp->mb[13] & 0xff;
1746                 }
1747                 /* If FA-WWN supported */
1748                 if (IS_FAWWN_CAPABLE(vha->hw)) {
1749                         if (mcp->mb[7] & BIT_14) {
1750                                 vha->port_name[0] = MSB(mcp->mb[16]);
1751                                 vha->port_name[1] = LSB(mcp->mb[16]);
1752                                 vha->port_name[2] = MSB(mcp->mb[17]);
1753                                 vha->port_name[3] = LSB(mcp->mb[17]);
1754                                 vha->port_name[4] = MSB(mcp->mb[18]);
1755                                 vha->port_name[5] = LSB(mcp->mb[18]);
1756                                 vha->port_name[6] = MSB(mcp->mb[19]);
1757                                 vha->port_name[7] = LSB(mcp->mb[19]);
1758                                 fc_host_port_name(vha->host) =
1759                                     wwn_to_u64(vha->port_name);
1760                                 ql_dbg(ql_dbg_mbx, vha, 0x10ca,
1761                                     "FA-WWN acquired %016llx\n",
1762                                     wwn_to_u64(vha->port_name));
1763                         }
1764                 }
1765
1766                 if (IS_QLA27XX(vha->hw) || IS_QLA28XX(vha->hw)) {
1767                         vha->bbcr = mcp->mb[15];
1768                         if (mcp->mb[7] & SCM_EDC_ACC_RECEIVED) {
1769                                 ql_log(ql_log_info, vha, 0x11a4,
1770                                        "SCM: EDC ELS completed, flags 0x%x\n",
1771                                        mcp->mb[21]);
1772                         }
1773                         if (mcp->mb[7] & SCM_RDF_ACC_RECEIVED) {
1774                                 vha->hw->flags.scm_enabled = 1;
1775                                 vha->scm_fabric_connection_flags |=
1776                                     SCM_FLAG_RDF_COMPLETED;
1777                                 ql_log(ql_log_info, vha, 0x11a5,
1778                                        "SCM: RDF ELS completed, flags 0x%x\n",
1779                                        mcp->mb[23]);
1780                         }
1781                 }
1782         }
1783
1784         return rval;
1785 }
1786
1787 /*
1788  * qla2x00_get_retry_cnt
1789  *      Get current firmware login retry count and delay.
1790  *
1791  * Input:
1792  *      ha = adapter block pointer.
1793  *      retry_cnt = pointer to login retry count.
1794  *      tov = pointer to login timeout value.
1795  *
1796  * Returns:
1797  *      qla2x00 local function return status code.
1798  *
1799  * Context:
1800  *      Kernel context.
1801  */
1802 int
1803 qla2x00_get_retry_cnt(scsi_qla_host_t *vha, uint8_t *retry_cnt, uint8_t *tov,
1804     uint16_t *r_a_tov)
1805 {
1806         int rval;
1807         uint16_t ratov;
1808         mbx_cmd_t mc;
1809         mbx_cmd_t *mcp = &mc;
1810
1811         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1049,
1812             "Entered %s.\n", __func__);
1813
1814         mcp->mb[0] = MBC_GET_RETRY_COUNT;
1815         mcp->out_mb = MBX_0;
1816         mcp->in_mb = MBX_3|MBX_2|MBX_1|MBX_0;
1817         mcp->tov = MBX_TOV_SECONDS;
1818         mcp->flags = 0;
1819         rval = qla2x00_mailbox_command(vha, mcp);
1820
1821         if (rval != QLA_SUCCESS) {
1822                 /*EMPTY*/
1823                 ql_dbg(ql_dbg_mbx, vha, 0x104a,
1824                     "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
1825         } else {
1826                 /* Convert returned data and check our values. */
1827                 *r_a_tov = mcp->mb[3] / 2;
1828                 ratov = (mcp->mb[3]/2) / 10;  /* mb[3] value is in 100ms */
1829                 if (mcp->mb[1] * ratov > (*retry_cnt) * (*tov)) {
1830                         /* Update to the larger values */
1831                         *retry_cnt = (uint8_t)mcp->mb[1];
1832                         *tov = ratov;
1833                 }
1834
1835                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x104b,
1836                     "Done %s mb3=%d ratov=%d.\n", __func__, mcp->mb[3], ratov);
1837         }
1838
1839         return rval;
1840 }
1841
1842 /*
1843  * qla2x00_init_firmware
1844  *      Initialize adapter firmware.
1845  *
1846  * Input:
1847  *      ha = adapter block pointer.
1848  *      dptr = Initialization control block pointer.
1849  *      size = size of initialization control block.
1850  *      TARGET_QUEUE_LOCK must be released.
1851  *      ADAPTER_STATE_LOCK must be released.
1852  *
1853  * Returns:
1854  *      qla2x00 local function return status code.
1855  *
1856  * Context:
1857  *      Kernel context.
1858  */
1859 int
1860 qla2x00_init_firmware(scsi_qla_host_t *vha, uint16_t size)
1861 {
1862         int rval;
1863         mbx_cmd_t mc;
1864         mbx_cmd_t *mcp = &mc;
1865         struct qla_hw_data *ha = vha->hw;
1866
1867         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x104c,
1868             "Entered %s.\n", __func__);
1869
1870         if (IS_P3P_TYPE(ha) && ql2xdbwr)
1871                 qla82xx_wr_32(ha, (uintptr_t __force)ha->nxdb_wr_ptr,
1872                         (0x04 | (ha->portnum << 5) | (0 << 8) | (0 << 16)));
1873
1874         if (ha->flags.npiv_supported)
1875                 mcp->mb[0] = MBC_MID_INITIALIZE_FIRMWARE;
1876         else
1877                 mcp->mb[0] = MBC_INITIALIZE_FIRMWARE;
1878
1879         mcp->mb[1] = 0;
1880         mcp->mb[2] = MSW(ha->init_cb_dma);
1881         mcp->mb[3] = LSW(ha->init_cb_dma);
1882         mcp->mb[6] = MSW(MSD(ha->init_cb_dma));
1883         mcp->mb[7] = LSW(MSD(ha->init_cb_dma));
1884         mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
1885         if (ha->ex_init_cb && ha->ex_init_cb->ex_version) {
1886                 mcp->mb[1] = BIT_0;
1887                 mcp->mb[10] = MSW(ha->ex_init_cb_dma);
1888                 mcp->mb[11] = LSW(ha->ex_init_cb_dma);
1889                 mcp->mb[12] = MSW(MSD(ha->ex_init_cb_dma));
1890                 mcp->mb[13] = LSW(MSD(ha->ex_init_cb_dma));
1891                 mcp->mb[14] = sizeof(*ha->ex_init_cb);
1892                 mcp->out_mb |= MBX_14|MBX_13|MBX_12|MBX_11|MBX_10;
1893         }
1894
1895         if (ha->flags.scm_supported_f || vha->flags.nvme2_enabled) {
1896                 mcp->mb[1] |= BIT_1;
1897                 mcp->mb[16] = MSW(ha->sf_init_cb_dma);
1898                 mcp->mb[17] = LSW(ha->sf_init_cb_dma);
1899                 mcp->mb[18] = MSW(MSD(ha->sf_init_cb_dma));
1900                 mcp->mb[19] = LSW(MSD(ha->sf_init_cb_dma));
1901                 mcp->mb[15] = sizeof(*ha->sf_init_cb);
1902                 mcp->out_mb |= MBX_19|MBX_18|MBX_17|MBX_16|MBX_15;
1903         }
1904
1905         /* 1 and 2 should normally be captured. */
1906         mcp->in_mb = MBX_2|MBX_1|MBX_0;
1907         if (IS_QLA83XX(ha) || IS_QLA27XX(ha) || IS_QLA28XX(ha))
1908                 /* mb3 is additional info about the installed SFP. */
1909                 mcp->in_mb  |= MBX_3;
1910         mcp->buf_size = size;
1911         mcp->flags = MBX_DMA_OUT;
1912         mcp->tov = MBX_TOV_SECONDS;
1913         rval = qla2x00_mailbox_command(vha, mcp);
1914
1915         if (rval != QLA_SUCCESS) {
1916                 /*EMPTY*/
1917                 ql_dbg(ql_dbg_mbx, vha, 0x104d,
1918                     "Failed=%x mb[0]=%x, mb[1]=%x, mb[2]=%x, mb[3]=%x.\n",
1919                     rval, mcp->mb[0], mcp->mb[1], mcp->mb[2], mcp->mb[3]);
1920                 if (ha->init_cb) {
1921                         ql_dbg(ql_dbg_mbx, vha, 0x104d, "init_cb:\n");
1922                         ql_dump_buffer(ql_dbg_init + ql_dbg_verbose, vha,
1923                             0x0104d, ha->init_cb, sizeof(*ha->init_cb));
1924                 }
1925                 if (ha->ex_init_cb && ha->ex_init_cb->ex_version) {
1926                         ql_dbg(ql_dbg_mbx, vha, 0x104d, "ex_init_cb:\n");
1927                         ql_dump_buffer(ql_dbg_init + ql_dbg_verbose, vha,
1928                             0x0104d, ha->ex_init_cb, sizeof(*ha->ex_init_cb));
1929                 }
1930         } else {
1931                 if (IS_QLA27XX(ha) || IS_QLA28XX(ha)) {
1932                         if (mcp->mb[2] == 6 || mcp->mb[3] == 2)
1933                                 ql_dbg(ql_dbg_mbx, vha, 0x119d,
1934                                     "Invalid SFP/Validation Failed\n");
1935                 }
1936                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x104e,
1937                     "Done %s.\n", __func__);
1938         }
1939
1940         return rval;
1941 }
1942
1943
1944 /*
1945  * qla2x00_get_port_database
1946  *      Issue normal/enhanced get port database mailbox command
1947  *      and copy device name as necessary.
1948  *
1949  * Input:
1950  *      ha = adapter state pointer.
1951  *      dev = structure pointer.
1952  *      opt = enhanced cmd option byte.
1953  *
1954  * Returns:
1955  *      qla2x00 local function return status code.
1956  *
1957  * Context:
1958  *      Kernel context.
1959  */
1960 int
1961 qla2x00_get_port_database(scsi_qla_host_t *vha, fc_port_t *fcport, uint8_t opt)
1962 {
1963         int rval;
1964         mbx_cmd_t mc;
1965         mbx_cmd_t *mcp = &mc;
1966         port_database_t *pd;
1967         struct port_database_24xx *pd24;
1968         dma_addr_t pd_dma;
1969         struct qla_hw_data *ha = vha->hw;
1970
1971         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x104f,
1972             "Entered %s.\n", __func__);
1973
1974         pd24 = NULL;
1975         pd = dma_pool_zalloc(ha->s_dma_pool, GFP_KERNEL, &pd_dma);
1976         if (pd  == NULL) {
1977                 ql_log(ql_log_warn, vha, 0x1050,
1978                     "Failed to allocate port database structure.\n");
1979                 fcport->query = 0;
1980                 return QLA_MEMORY_ALLOC_FAILED;
1981         }
1982
1983         mcp->mb[0] = MBC_GET_PORT_DATABASE;
1984         if (opt != 0 && !IS_FWI2_CAPABLE(ha))
1985                 mcp->mb[0] = MBC_ENHANCED_GET_PORT_DATABASE;
1986         mcp->mb[2] = MSW(pd_dma);
1987         mcp->mb[3] = LSW(pd_dma);
1988         mcp->mb[6] = MSW(MSD(pd_dma));
1989         mcp->mb[7] = LSW(MSD(pd_dma));
1990         mcp->mb[9] = vha->vp_idx;
1991         mcp->out_mb = MBX_9|MBX_7|MBX_6|MBX_3|MBX_2|MBX_0;
1992         mcp->in_mb = MBX_0;
1993         if (IS_FWI2_CAPABLE(ha)) {
1994                 mcp->mb[1] = fcport->loop_id;
1995                 mcp->mb[10] = opt;
1996                 mcp->out_mb |= MBX_10|MBX_1;
1997                 mcp->in_mb |= MBX_1;
1998         } else if (HAS_EXTENDED_IDS(ha)) {
1999                 mcp->mb[1] = fcport->loop_id;
2000                 mcp->mb[10] = opt;
2001                 mcp->out_mb |= MBX_10|MBX_1;
2002         } else {
2003                 mcp->mb[1] = fcport->loop_id << 8 | opt;
2004                 mcp->out_mb |= MBX_1;
2005         }
2006         mcp->buf_size = IS_FWI2_CAPABLE(ha) ?
2007             PORT_DATABASE_24XX_SIZE : PORT_DATABASE_SIZE;
2008         mcp->flags = MBX_DMA_IN;
2009         mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2);
2010         rval = qla2x00_mailbox_command(vha, mcp);
2011         if (rval != QLA_SUCCESS)
2012                 goto gpd_error_out;
2013
2014         if (IS_FWI2_CAPABLE(ha)) {
2015                 uint64_t zero = 0;
2016                 u8 current_login_state, last_login_state;
2017
2018                 pd24 = (struct port_database_24xx *) pd;
2019
2020                 /* Check for logged in state. */
2021                 if (NVME_TARGET(ha, fcport)) {
2022                         current_login_state = pd24->current_login_state >> 4;
2023                         last_login_state = pd24->last_login_state >> 4;
2024                 } else {
2025                         current_login_state = pd24->current_login_state & 0xf;
2026                         last_login_state = pd24->last_login_state & 0xf;
2027                 }
2028                 fcport->current_login_state = pd24->current_login_state;
2029                 fcport->last_login_state = pd24->last_login_state;
2030
2031                 /* Check for logged in state. */
2032                 if (current_login_state != PDS_PRLI_COMPLETE &&
2033                     last_login_state != PDS_PRLI_COMPLETE) {
2034                         ql_dbg(ql_dbg_mbx, vha, 0x119a,
2035                             "Unable to verify login-state (%x/%x) for loop_id %x.\n",
2036                             current_login_state, last_login_state,
2037                             fcport->loop_id);
2038                         rval = QLA_FUNCTION_FAILED;
2039
2040                         if (!fcport->query)
2041                                 goto gpd_error_out;
2042                 }
2043
2044                 if (fcport->loop_id == FC_NO_LOOP_ID ||
2045                     (memcmp(fcport->port_name, (uint8_t *)&zero, 8) &&
2046                      memcmp(fcport->port_name, pd24->port_name, 8))) {
2047                         /* We lost the device mid way. */
2048                         rval = QLA_NOT_LOGGED_IN;
2049                         goto gpd_error_out;
2050                 }
2051
2052                 /* Names are little-endian. */
2053                 memcpy(fcport->node_name, pd24->node_name, WWN_SIZE);
2054                 memcpy(fcport->port_name, pd24->port_name, WWN_SIZE);
2055
2056                 /* Get port_id of device. */
2057                 fcport->d_id.b.domain = pd24->port_id[0];
2058                 fcport->d_id.b.area = pd24->port_id[1];
2059                 fcport->d_id.b.al_pa = pd24->port_id[2];
2060                 fcport->d_id.b.rsvd_1 = 0;
2061
2062                 /* If not target must be initiator or unknown type. */
2063                 if ((pd24->prli_svc_param_word_3[0] & BIT_4) == 0)
2064                         fcport->port_type = FCT_INITIATOR;
2065                 else
2066                         fcport->port_type = FCT_TARGET;
2067
2068                 /* Passback COS information. */
2069                 fcport->supported_classes = (pd24->flags & PDF_CLASS_2) ?
2070                                 FC_COS_CLASS2 : FC_COS_CLASS3;
2071
2072                 if (pd24->prli_svc_param_word_3[0] & BIT_7)
2073                         fcport->flags |= FCF_CONF_COMP_SUPPORTED;
2074         } else {
2075                 uint64_t zero = 0;
2076
2077                 /* Check for logged in state. */
2078                 if (pd->master_state != PD_STATE_PORT_LOGGED_IN &&
2079                     pd->slave_state != PD_STATE_PORT_LOGGED_IN) {
2080                         ql_dbg(ql_dbg_mbx, vha, 0x100a,
2081                             "Unable to verify login-state (%x/%x) - "
2082                             "portid=%02x%02x%02x.\n", pd->master_state,
2083                             pd->slave_state, fcport->d_id.b.domain,
2084                             fcport->d_id.b.area, fcport->d_id.b.al_pa);
2085                         rval = QLA_FUNCTION_FAILED;
2086                         goto gpd_error_out;
2087                 }
2088
2089                 if (fcport->loop_id == FC_NO_LOOP_ID ||
2090                     (memcmp(fcport->port_name, (uint8_t *)&zero, 8) &&
2091                      memcmp(fcport->port_name, pd->port_name, 8))) {
2092                         /* We lost the device mid way. */
2093                         rval = QLA_NOT_LOGGED_IN;
2094                         goto gpd_error_out;
2095                 }
2096
2097                 /* Names are little-endian. */
2098                 memcpy(fcport->node_name, pd->node_name, WWN_SIZE);
2099                 memcpy(fcport->port_name, pd->port_name, WWN_SIZE);
2100
2101                 /* Get port_id of device. */
2102                 fcport->d_id.b.domain = pd->port_id[0];
2103                 fcport->d_id.b.area = pd->port_id[3];
2104                 fcport->d_id.b.al_pa = pd->port_id[2];
2105                 fcport->d_id.b.rsvd_1 = 0;
2106
2107                 /* If not target must be initiator or unknown type. */
2108                 if ((pd->prli_svc_param_word_3[0] & BIT_4) == 0)
2109                         fcport->port_type = FCT_INITIATOR;
2110                 else
2111                         fcport->port_type = FCT_TARGET;
2112
2113                 /* Passback COS information. */
2114                 fcport->supported_classes = (pd->options & BIT_4) ?
2115                     FC_COS_CLASS2 : FC_COS_CLASS3;
2116         }
2117
2118 gpd_error_out:
2119         dma_pool_free(ha->s_dma_pool, pd, pd_dma);
2120         fcport->query = 0;
2121
2122         if (rval != QLA_SUCCESS) {
2123                 ql_dbg(ql_dbg_mbx, vha, 0x1052,
2124                     "Failed=%x mb[0]=%x mb[1]=%x.\n", rval,
2125                     mcp->mb[0], mcp->mb[1]);
2126         } else {
2127                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1053,
2128                     "Done %s.\n", __func__);
2129         }
2130
2131         return rval;
2132 }
2133
2134 int
2135 qla24xx_get_port_database(scsi_qla_host_t *vha, u16 nport_handle,
2136         struct port_database_24xx *pdb)
2137 {
2138         mbx_cmd_t mc;
2139         mbx_cmd_t *mcp = &mc;
2140         dma_addr_t pdb_dma;
2141         int rval;
2142
2143         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1115,
2144             "Entered %s.\n", __func__);
2145
2146         memset(pdb, 0, sizeof(*pdb));
2147
2148         pdb_dma = dma_map_single(&vha->hw->pdev->dev, pdb,
2149             sizeof(*pdb), DMA_FROM_DEVICE);
2150         if (!pdb_dma) {
2151                 ql_log(ql_log_warn, vha, 0x1116, "Failed to map dma buffer.\n");
2152                 return QLA_MEMORY_ALLOC_FAILED;
2153         }
2154
2155         mcp->mb[0] = MBC_GET_PORT_DATABASE;
2156         mcp->mb[1] = nport_handle;
2157         mcp->mb[2] = MSW(LSD(pdb_dma));
2158         mcp->mb[3] = LSW(LSD(pdb_dma));
2159         mcp->mb[6] = MSW(MSD(pdb_dma));
2160         mcp->mb[7] = LSW(MSD(pdb_dma));
2161         mcp->mb[9] = 0;
2162         mcp->mb[10] = 0;
2163         mcp->out_mb = MBX_10|MBX_9|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
2164         mcp->in_mb = MBX_1|MBX_0;
2165         mcp->buf_size = sizeof(*pdb);
2166         mcp->flags = MBX_DMA_IN;
2167         mcp->tov = vha->hw->login_timeout * 2;
2168         rval = qla2x00_mailbox_command(vha, mcp);
2169
2170         if (rval != QLA_SUCCESS) {
2171                 ql_dbg(ql_dbg_mbx, vha, 0x111a,
2172                     "Failed=%x mb[0]=%x mb[1]=%x.\n",
2173                     rval, mcp->mb[0], mcp->mb[1]);
2174         } else {
2175                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x111b,
2176                     "Done %s.\n", __func__);
2177         }
2178
2179         dma_unmap_single(&vha->hw->pdev->dev, pdb_dma,
2180             sizeof(*pdb), DMA_FROM_DEVICE);
2181
2182         return rval;
2183 }
2184
2185 /*
2186  * qla2x00_get_firmware_state
2187  *      Get adapter firmware state.
2188  *
2189  * Input:
2190  *      ha = adapter block pointer.
2191  *      dptr = pointer for firmware state.
2192  *      TARGET_QUEUE_LOCK must be released.
2193  *      ADAPTER_STATE_LOCK must be released.
2194  *
2195  * Returns:
2196  *      qla2x00 local function return status code.
2197  *
2198  * Context:
2199  *      Kernel context.
2200  */
2201 int
2202 qla2x00_get_firmware_state(scsi_qla_host_t *vha, uint16_t *states)
2203 {
2204         int rval;
2205         mbx_cmd_t mc;
2206         mbx_cmd_t *mcp = &mc;
2207         struct qla_hw_data *ha = vha->hw;
2208
2209         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1054,
2210             "Entered %s.\n", __func__);
2211
2212         if (!ha->flags.fw_started)
2213                 return QLA_FUNCTION_FAILED;
2214
2215         mcp->mb[0] = MBC_GET_FIRMWARE_STATE;
2216         mcp->out_mb = MBX_0;
2217         if (IS_FWI2_CAPABLE(vha->hw))
2218                 mcp->in_mb = MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
2219         else
2220                 mcp->in_mb = MBX_1|MBX_0;
2221         mcp->tov = MBX_TOV_SECONDS;
2222         mcp->flags = 0;
2223         rval = qla2x00_mailbox_command(vha, mcp);
2224
2225         /* Return firmware states. */
2226         states[0] = mcp->mb[1];
2227         if (IS_FWI2_CAPABLE(vha->hw)) {
2228                 states[1] = mcp->mb[2];
2229                 states[2] = mcp->mb[3];  /* SFP info */
2230                 states[3] = mcp->mb[4];
2231                 states[4] = mcp->mb[5];
2232                 states[5] = mcp->mb[6];  /* DPORT status */
2233         }
2234
2235         if (rval != QLA_SUCCESS) {
2236                 /*EMPTY*/
2237                 ql_dbg(ql_dbg_mbx, vha, 0x1055, "Failed=%x.\n", rval);
2238         } else {
2239                 if (IS_QLA27XX(ha) || IS_QLA28XX(ha)) {
2240                         if (mcp->mb[2] == 6 || mcp->mb[3] == 2)
2241                                 ql_dbg(ql_dbg_mbx, vha, 0x119e,
2242                                     "Invalid SFP/Validation Failed\n");
2243                 }
2244                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1056,
2245                     "Done %s.\n", __func__);
2246         }
2247
2248         return rval;
2249 }
2250
2251 /*
2252  * qla2x00_get_port_name
2253  *      Issue get port name mailbox command.
2254  *      Returned name is in big endian format.
2255  *
2256  * Input:
2257  *      ha = adapter block pointer.
2258  *      loop_id = loop ID of device.
2259  *      name = pointer for name.
2260  *      TARGET_QUEUE_LOCK must be released.
2261  *      ADAPTER_STATE_LOCK must be released.
2262  *
2263  * Returns:
2264  *      qla2x00 local function return status code.
2265  *
2266  * Context:
2267  *      Kernel context.
2268  */
2269 int
2270 qla2x00_get_port_name(scsi_qla_host_t *vha, uint16_t loop_id, uint8_t *name,
2271     uint8_t opt)
2272 {
2273         int rval;
2274         mbx_cmd_t mc;
2275         mbx_cmd_t *mcp = &mc;
2276
2277         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1057,
2278             "Entered %s.\n", __func__);
2279
2280         mcp->mb[0] = MBC_GET_PORT_NAME;
2281         mcp->mb[9] = vha->vp_idx;
2282         mcp->out_mb = MBX_9|MBX_1|MBX_0;
2283         if (HAS_EXTENDED_IDS(vha->hw)) {
2284                 mcp->mb[1] = loop_id;
2285                 mcp->mb[10] = opt;
2286                 mcp->out_mb |= MBX_10;
2287         } else {
2288                 mcp->mb[1] = loop_id << 8 | opt;
2289         }
2290
2291         mcp->in_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
2292         mcp->tov = MBX_TOV_SECONDS;
2293         mcp->flags = 0;
2294         rval = qla2x00_mailbox_command(vha, mcp);
2295
2296         if (rval != QLA_SUCCESS) {
2297                 /*EMPTY*/
2298                 ql_dbg(ql_dbg_mbx, vha, 0x1058, "Failed=%x.\n", rval);
2299         } else {
2300                 if (name != NULL) {
2301                         /* This function returns name in big endian. */
2302                         name[0] = MSB(mcp->mb[2]);
2303                         name[1] = LSB(mcp->mb[2]);
2304                         name[2] = MSB(mcp->mb[3]);
2305                         name[3] = LSB(mcp->mb[3]);
2306                         name[4] = MSB(mcp->mb[6]);
2307                         name[5] = LSB(mcp->mb[6]);
2308                         name[6] = MSB(mcp->mb[7]);
2309                         name[7] = LSB(mcp->mb[7]);
2310                 }
2311
2312                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1059,
2313                     "Done %s.\n", __func__);
2314         }
2315
2316         return rval;
2317 }
2318
2319 /*
2320  * qla24xx_link_initialization
2321  *      Issue link initialization mailbox command.
2322  *
2323  * Input:
2324  *      ha = adapter block pointer.
2325  *      TARGET_QUEUE_LOCK must be released.
2326  *      ADAPTER_STATE_LOCK must be released.
2327  *
2328  * Returns:
2329  *      qla2x00 local function return status code.
2330  *
2331  * Context:
2332  *      Kernel context.
2333  */
2334 int
2335 qla24xx_link_initialize(scsi_qla_host_t *vha)
2336 {
2337         int rval;
2338         mbx_cmd_t mc;
2339         mbx_cmd_t *mcp = &mc;
2340
2341         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1152,
2342             "Entered %s.\n", __func__);
2343
2344         if (!IS_FWI2_CAPABLE(vha->hw) || IS_CNA_CAPABLE(vha->hw))
2345                 return QLA_FUNCTION_FAILED;
2346
2347         mcp->mb[0] = MBC_LINK_INITIALIZATION;
2348         mcp->mb[1] = BIT_4;
2349         if (vha->hw->operating_mode == LOOP)
2350                 mcp->mb[1] |= BIT_6;
2351         else
2352                 mcp->mb[1] |= BIT_5;
2353         mcp->mb[2] = 0;
2354         mcp->mb[3] = 0;
2355         mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
2356         mcp->in_mb = MBX_0;
2357         mcp->tov = MBX_TOV_SECONDS;
2358         mcp->flags = 0;
2359         rval = qla2x00_mailbox_command(vha, mcp);
2360
2361         if (rval != QLA_SUCCESS) {
2362                 ql_dbg(ql_dbg_mbx, vha, 0x1153, "Failed=%x.\n", rval);
2363         } else {
2364                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1154,
2365                     "Done %s.\n", __func__);
2366         }
2367
2368         return rval;
2369 }
2370
2371 /*
2372  * qla2x00_lip_reset
2373  *      Issue LIP reset mailbox command.
2374  *
2375  * Input:
2376  *      ha = adapter block pointer.
2377  *      TARGET_QUEUE_LOCK must be released.
2378  *      ADAPTER_STATE_LOCK must be released.
2379  *
2380  * Returns:
2381  *      qla2x00 local function return status code.
2382  *
2383  * Context:
2384  *      Kernel context.
2385  */
2386 int
2387 qla2x00_lip_reset(scsi_qla_host_t *vha)
2388 {
2389         int rval;
2390         mbx_cmd_t mc;
2391         mbx_cmd_t *mcp = &mc;
2392
2393         ql_dbg(ql_dbg_disc, vha, 0x105a,
2394             "Entered %s.\n", __func__);
2395
2396         if (IS_CNA_CAPABLE(vha->hw)) {
2397                 /* Logout across all FCFs. */
2398                 mcp->mb[0] = MBC_LIP_FULL_LOGIN;
2399                 mcp->mb[1] = BIT_1;
2400                 mcp->mb[2] = 0;
2401                 mcp->out_mb = MBX_2|MBX_1|MBX_0;
2402         } else if (IS_FWI2_CAPABLE(vha->hw)) {
2403                 mcp->mb[0] = MBC_LIP_FULL_LOGIN;
2404                 mcp->mb[1] = BIT_4;
2405                 mcp->mb[2] = 0;
2406                 mcp->mb[3] = vha->hw->loop_reset_delay;
2407                 mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
2408         } else {
2409                 mcp->mb[0] = MBC_LIP_RESET;
2410                 mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
2411                 if (HAS_EXTENDED_IDS(vha->hw)) {
2412                         mcp->mb[1] = 0x00ff;
2413                         mcp->mb[10] = 0;
2414                         mcp->out_mb |= MBX_10;
2415                 } else {
2416                         mcp->mb[1] = 0xff00;
2417                 }
2418                 mcp->mb[2] = vha->hw->loop_reset_delay;
2419                 mcp->mb[3] = 0;
2420         }
2421         mcp->in_mb = MBX_0;
2422         mcp->tov = MBX_TOV_SECONDS;
2423         mcp->flags = 0;
2424         rval = qla2x00_mailbox_command(vha, mcp);
2425
2426         if (rval != QLA_SUCCESS) {
2427                 /*EMPTY*/
2428                 ql_dbg(ql_dbg_mbx, vha, 0x105b, "Failed=%x.\n", rval);
2429         } else {
2430                 /*EMPTY*/
2431                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x105c,
2432                     "Done %s.\n", __func__);
2433         }
2434
2435         return rval;
2436 }
2437
2438 /*
2439  * qla2x00_send_sns
2440  *      Send SNS command.
2441  *
2442  * Input:
2443  *      ha = adapter block pointer.
2444  *      sns = pointer for command.
2445  *      cmd_size = command size.
2446  *      buf_size = response/command size.
2447  *      TARGET_QUEUE_LOCK must be released.
2448  *      ADAPTER_STATE_LOCK must be released.
2449  *
2450  * Returns:
2451  *      qla2x00 local function return status code.
2452  *
2453  * Context:
2454  *      Kernel context.
2455  */
2456 int
2457 qla2x00_send_sns(scsi_qla_host_t *vha, dma_addr_t sns_phys_address,
2458     uint16_t cmd_size, size_t buf_size)
2459 {
2460         int rval;
2461         mbx_cmd_t mc;
2462         mbx_cmd_t *mcp = &mc;
2463
2464         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x105d,
2465             "Entered %s.\n", __func__);
2466
2467         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x105e,
2468             "Retry cnt=%d ratov=%d total tov=%d.\n",
2469             vha->hw->retry_count, vha->hw->login_timeout, mcp->tov);
2470
2471         mcp->mb[0] = MBC_SEND_SNS_COMMAND;
2472         mcp->mb[1] = cmd_size;
2473         mcp->mb[2] = MSW(sns_phys_address);
2474         mcp->mb[3] = LSW(sns_phys_address);
2475         mcp->mb[6] = MSW(MSD(sns_phys_address));
2476         mcp->mb[7] = LSW(MSD(sns_phys_address));
2477         mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
2478         mcp->in_mb = MBX_0|MBX_1;
2479         mcp->buf_size = buf_size;
2480         mcp->flags = MBX_DMA_OUT|MBX_DMA_IN;
2481         mcp->tov = (vha->hw->login_timeout * 2) + (vha->hw->login_timeout / 2);
2482         rval = qla2x00_mailbox_command(vha, mcp);
2483
2484         if (rval != QLA_SUCCESS) {
2485                 /*EMPTY*/
2486                 ql_dbg(ql_dbg_mbx, vha, 0x105f,
2487                     "Failed=%x mb[0]=%x mb[1]=%x.\n",
2488                     rval, mcp->mb[0], mcp->mb[1]);
2489         } else {
2490                 /*EMPTY*/
2491                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1060,
2492                     "Done %s.\n", __func__);
2493         }
2494
2495         return rval;
2496 }
2497
2498 int
2499 qla24xx_login_fabric(scsi_qla_host_t *vha, uint16_t loop_id, uint8_t domain,
2500     uint8_t area, uint8_t al_pa, uint16_t *mb, uint8_t opt)
2501 {
2502         int             rval;
2503
2504         struct logio_entry_24xx *lg;
2505         dma_addr_t      lg_dma;
2506         uint32_t        iop[2];
2507         struct qla_hw_data *ha = vha->hw;
2508         struct req_que *req;
2509
2510         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1061,
2511             "Entered %s.\n", __func__);
2512
2513         if (vha->vp_idx && vha->qpair)
2514                 req = vha->qpair->req;
2515         else
2516                 req = ha->req_q_map[0];
2517
2518         lg = dma_pool_zalloc(ha->s_dma_pool, GFP_KERNEL, &lg_dma);
2519         if (lg == NULL) {
2520                 ql_log(ql_log_warn, vha, 0x1062,
2521                     "Failed to allocate login IOCB.\n");
2522                 return QLA_MEMORY_ALLOC_FAILED;
2523         }
2524
2525         lg->entry_type = LOGINOUT_PORT_IOCB_TYPE;
2526         lg->entry_count = 1;
2527         lg->handle = make_handle(req->id, lg->handle);
2528         lg->nport_handle = cpu_to_le16(loop_id);
2529         lg->control_flags = cpu_to_le16(LCF_COMMAND_PLOGI);
2530         if (opt & BIT_0)
2531                 lg->control_flags |= cpu_to_le16(LCF_COND_PLOGI);
2532         if (opt & BIT_1)
2533                 lg->control_flags |= cpu_to_le16(LCF_SKIP_PRLI);
2534         lg->port_id[0] = al_pa;
2535         lg->port_id[1] = area;
2536         lg->port_id[2] = domain;
2537         lg->vp_index = vha->vp_idx;
2538         rval = qla2x00_issue_iocb_timeout(vha, lg, lg_dma, 0,
2539             (ha->r_a_tov / 10 * 2) + 2);
2540         if (rval != QLA_SUCCESS) {
2541                 ql_dbg(ql_dbg_mbx, vha, 0x1063,
2542                     "Failed to issue login IOCB (%x).\n", rval);
2543         } else if (lg->entry_status != 0) {
2544                 ql_dbg(ql_dbg_mbx, vha, 0x1064,
2545                     "Failed to complete IOCB -- error status (%x).\n",
2546                     lg->entry_status);
2547                 rval = QLA_FUNCTION_FAILED;
2548         } else if (lg->comp_status != cpu_to_le16(CS_COMPLETE)) {
2549                 iop[0] = le32_to_cpu(lg->io_parameter[0]);
2550                 iop[1] = le32_to_cpu(lg->io_parameter[1]);
2551
2552                 ql_dbg(ql_dbg_mbx, vha, 0x1065,
2553                     "Failed to complete IOCB -- completion  status (%x) "
2554                     "ioparam=%x/%x.\n", le16_to_cpu(lg->comp_status),
2555                     iop[0], iop[1]);
2556
2557                 switch (iop[0]) {
2558                 case LSC_SCODE_PORTID_USED:
2559                         mb[0] = MBS_PORT_ID_USED;
2560                         mb[1] = LSW(iop[1]);
2561                         break;
2562                 case LSC_SCODE_NPORT_USED:
2563                         mb[0] = MBS_LOOP_ID_USED;
2564                         break;
2565                 case LSC_SCODE_NOLINK:
2566                 case LSC_SCODE_NOIOCB:
2567                 case LSC_SCODE_NOXCB:
2568                 case LSC_SCODE_CMD_FAILED:
2569                 case LSC_SCODE_NOFABRIC:
2570                 case LSC_SCODE_FW_NOT_READY:
2571                 case LSC_SCODE_NOT_LOGGED_IN:
2572                 case LSC_SCODE_NOPCB:
2573                 case LSC_SCODE_ELS_REJECT:
2574                 case LSC_SCODE_CMD_PARAM_ERR:
2575                 case LSC_SCODE_NONPORT:
2576                 case LSC_SCODE_LOGGED_IN:
2577                 case LSC_SCODE_NOFLOGI_ACC:
2578                 default:
2579                         mb[0] = MBS_COMMAND_ERROR;
2580                         break;
2581                 }
2582         } else {
2583                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1066,
2584                     "Done %s.\n", __func__);
2585
2586                 iop[0] = le32_to_cpu(lg->io_parameter[0]);
2587
2588                 mb[0] = MBS_COMMAND_COMPLETE;
2589                 mb[1] = 0;
2590                 if (iop[0] & BIT_4) {
2591                         if (iop[0] & BIT_8)
2592                                 mb[1] |= BIT_1;
2593                 } else
2594                         mb[1] = BIT_0;
2595
2596                 /* Passback COS information. */
2597                 mb[10] = 0;
2598                 if (lg->io_parameter[7] || lg->io_parameter[8])
2599                         mb[10] |= BIT_0;        /* Class 2. */
2600                 if (lg->io_parameter[9] || lg->io_parameter[10])
2601                         mb[10] |= BIT_1;        /* Class 3. */
2602                 if (lg->io_parameter[0] & cpu_to_le32(BIT_7))
2603                         mb[10] |= BIT_7;        /* Confirmed Completion
2604                                                  * Allowed
2605                                                  */
2606         }
2607
2608         dma_pool_free(ha->s_dma_pool, lg, lg_dma);
2609
2610         return rval;
2611 }
2612
2613 /*
2614  * qla2x00_login_fabric
2615  *      Issue login fabric port mailbox command.
2616  *
2617  * Input:
2618  *      ha = adapter block pointer.
2619  *      loop_id = device loop ID.
2620  *      domain = device domain.
2621  *      area = device area.
2622  *      al_pa = device AL_PA.
2623  *      status = pointer for return status.
2624  *      opt = command options.
2625  *      TARGET_QUEUE_LOCK must be released.
2626  *      ADAPTER_STATE_LOCK must be released.
2627  *
2628  * Returns:
2629  *      qla2x00 local function return status code.
2630  *
2631  * Context:
2632  *      Kernel context.
2633  */
2634 int
2635 qla2x00_login_fabric(scsi_qla_host_t *vha, uint16_t loop_id, uint8_t domain,
2636     uint8_t area, uint8_t al_pa, uint16_t *mb, uint8_t opt)
2637 {
2638         int rval;
2639         mbx_cmd_t mc;
2640         mbx_cmd_t *mcp = &mc;
2641         struct qla_hw_data *ha = vha->hw;
2642
2643         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1067,
2644             "Entered %s.\n", __func__);
2645
2646         mcp->mb[0] = MBC_LOGIN_FABRIC_PORT;
2647         mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
2648         if (HAS_EXTENDED_IDS(ha)) {
2649                 mcp->mb[1] = loop_id;
2650                 mcp->mb[10] = opt;
2651                 mcp->out_mb |= MBX_10;
2652         } else {
2653                 mcp->mb[1] = (loop_id << 8) | opt;
2654         }
2655         mcp->mb[2] = domain;
2656         mcp->mb[3] = area << 8 | al_pa;
2657
2658         mcp->in_mb = MBX_7|MBX_6|MBX_2|MBX_1|MBX_0;
2659         mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2);
2660         mcp->flags = 0;
2661         rval = qla2x00_mailbox_command(vha, mcp);
2662
2663         /* Return mailbox statuses. */
2664         if (mb != NULL) {
2665                 mb[0] = mcp->mb[0];
2666                 mb[1] = mcp->mb[1];
2667                 mb[2] = mcp->mb[2];
2668                 mb[6] = mcp->mb[6];
2669                 mb[7] = mcp->mb[7];
2670                 /* COS retrieved from Get-Port-Database mailbox command. */
2671                 mb[10] = 0;
2672         }
2673
2674         if (rval != QLA_SUCCESS) {
2675                 /* RLU tmp code: need to change main mailbox_command function to
2676                  * return ok even when the mailbox completion value is not
2677                  * SUCCESS. The caller needs to be responsible to interpret
2678                  * the return values of this mailbox command if we're not
2679                  * to change too much of the existing code.
2680                  */
2681                 if (mcp->mb[0] == 0x4001 || mcp->mb[0] == 0x4002 ||
2682                     mcp->mb[0] == 0x4003 || mcp->mb[0] == 0x4005 ||
2683                     mcp->mb[0] == 0x4006)
2684                         rval = QLA_SUCCESS;
2685
2686                 /*EMPTY*/
2687                 ql_dbg(ql_dbg_mbx, vha, 0x1068,
2688                     "Failed=%x mb[0]=%x mb[1]=%x mb[2]=%x.\n",
2689                     rval, mcp->mb[0], mcp->mb[1], mcp->mb[2]);
2690         } else {
2691                 /*EMPTY*/
2692                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1069,
2693                     "Done %s.\n", __func__);
2694         }
2695
2696         return rval;
2697 }
2698
2699 /*
2700  * qla2x00_login_local_device
2701  *           Issue login loop port mailbox command.
2702  *
2703  * Input:
2704  *           ha = adapter block pointer.
2705  *           loop_id = device loop ID.
2706  *           opt = command options.
2707  *
2708  * Returns:
2709  *            Return status code.
2710  *
2711  * Context:
2712  *            Kernel context.
2713  *
2714  */
2715 int
2716 qla2x00_login_local_device(scsi_qla_host_t *vha, fc_port_t *fcport,
2717     uint16_t *mb_ret, uint8_t opt)
2718 {
2719         int rval;
2720         mbx_cmd_t mc;
2721         mbx_cmd_t *mcp = &mc;
2722         struct qla_hw_data *ha = vha->hw;
2723
2724         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x106a,
2725             "Entered %s.\n", __func__);
2726
2727         if (IS_FWI2_CAPABLE(ha))
2728                 return qla24xx_login_fabric(vha, fcport->loop_id,
2729                     fcport->d_id.b.domain, fcport->d_id.b.area,
2730                     fcport->d_id.b.al_pa, mb_ret, opt);
2731
2732         mcp->mb[0] = MBC_LOGIN_LOOP_PORT;
2733         if (HAS_EXTENDED_IDS(ha))
2734                 mcp->mb[1] = fcport->loop_id;
2735         else
2736                 mcp->mb[1] = fcport->loop_id << 8;
2737         mcp->mb[2] = opt;
2738         mcp->out_mb = MBX_2|MBX_1|MBX_0;
2739         mcp->in_mb = MBX_7|MBX_6|MBX_1|MBX_0;
2740         mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2);
2741         mcp->flags = 0;
2742         rval = qla2x00_mailbox_command(vha, mcp);
2743
2744         /* Return mailbox statuses. */
2745         if (mb_ret != NULL) {
2746                 mb_ret[0] = mcp->mb[0];
2747                 mb_ret[1] = mcp->mb[1];
2748                 mb_ret[6] = mcp->mb[6];
2749                 mb_ret[7] = mcp->mb[7];
2750         }
2751
2752         if (rval != QLA_SUCCESS) {
2753                 /* AV tmp code: need to change main mailbox_command function to
2754                  * return ok even when the mailbox completion value is not
2755                  * SUCCESS. The caller needs to be responsible to interpret
2756                  * the return values of this mailbox command if we're not
2757                  * to change too much of the existing code.
2758                  */
2759                 if (mcp->mb[0] == 0x4005 || mcp->mb[0] == 0x4006)
2760                         rval = QLA_SUCCESS;
2761
2762                 ql_dbg(ql_dbg_mbx, vha, 0x106b,
2763                     "Failed=%x mb[0]=%x mb[1]=%x mb[6]=%x mb[7]=%x.\n",
2764                     rval, mcp->mb[0], mcp->mb[1], mcp->mb[6], mcp->mb[7]);
2765         } else {
2766                 /*EMPTY*/
2767                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x106c,
2768                     "Done %s.\n", __func__);
2769         }
2770
2771         return (rval);
2772 }
2773
2774 int
2775 qla24xx_fabric_logout(scsi_qla_host_t *vha, uint16_t loop_id, uint8_t domain,
2776     uint8_t area, uint8_t al_pa)
2777 {
2778         int             rval;
2779         struct logio_entry_24xx *lg;
2780         dma_addr_t      lg_dma;
2781         struct qla_hw_data *ha = vha->hw;
2782         struct req_que *req;
2783
2784         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x106d,
2785             "Entered %s.\n", __func__);
2786
2787         lg = dma_pool_zalloc(ha->s_dma_pool, GFP_KERNEL, &lg_dma);
2788         if (lg == NULL) {
2789                 ql_log(ql_log_warn, vha, 0x106e,
2790                     "Failed to allocate logout IOCB.\n");
2791                 return QLA_MEMORY_ALLOC_FAILED;
2792         }
2793
2794         req = vha->req;
2795         lg->entry_type = LOGINOUT_PORT_IOCB_TYPE;
2796         lg->entry_count = 1;
2797         lg->handle = make_handle(req->id, lg->handle);
2798         lg->nport_handle = cpu_to_le16(loop_id);
2799         lg->control_flags =
2800             cpu_to_le16(LCF_COMMAND_LOGO|LCF_IMPL_LOGO|
2801                 LCF_FREE_NPORT);
2802         lg->port_id[0] = al_pa;
2803         lg->port_id[1] = area;
2804         lg->port_id[2] = domain;
2805         lg->vp_index = vha->vp_idx;
2806         rval = qla2x00_issue_iocb_timeout(vha, lg, lg_dma, 0,
2807             (ha->r_a_tov / 10 * 2) + 2);
2808         if (rval != QLA_SUCCESS) {
2809                 ql_dbg(ql_dbg_mbx, vha, 0x106f,
2810                     "Failed to issue logout IOCB (%x).\n", rval);
2811         } else if (lg->entry_status != 0) {
2812                 ql_dbg(ql_dbg_mbx, vha, 0x1070,
2813                     "Failed to complete IOCB -- error status (%x).\n",
2814                     lg->entry_status);
2815                 rval = QLA_FUNCTION_FAILED;
2816         } else if (lg->comp_status != cpu_to_le16(CS_COMPLETE)) {
2817                 ql_dbg(ql_dbg_mbx, vha, 0x1071,
2818                     "Failed to complete IOCB -- completion status (%x) "
2819                     "ioparam=%x/%x.\n", le16_to_cpu(lg->comp_status),
2820                     le32_to_cpu(lg->io_parameter[0]),
2821                     le32_to_cpu(lg->io_parameter[1]));
2822         } else {
2823                 /*EMPTY*/
2824                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1072,
2825                     "Done %s.\n", __func__);
2826         }
2827
2828         dma_pool_free(ha->s_dma_pool, lg, lg_dma);
2829
2830         return rval;
2831 }
2832
2833 /*
2834  * qla2x00_fabric_logout
2835  *      Issue logout fabric port mailbox command.
2836  *
2837  * Input:
2838  *      ha = adapter block pointer.
2839  *      loop_id = device loop ID.
2840  *      TARGET_QUEUE_LOCK must be released.
2841  *      ADAPTER_STATE_LOCK must be released.
2842  *
2843  * Returns:
2844  *      qla2x00 local function return status code.
2845  *
2846  * Context:
2847  *      Kernel context.
2848  */
2849 int
2850 qla2x00_fabric_logout(scsi_qla_host_t *vha, uint16_t loop_id, uint8_t domain,
2851     uint8_t area, uint8_t al_pa)
2852 {
2853         int rval;
2854         mbx_cmd_t mc;
2855         mbx_cmd_t *mcp = &mc;
2856
2857         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1073,
2858             "Entered %s.\n", __func__);
2859
2860         mcp->mb[0] = MBC_LOGOUT_FABRIC_PORT;
2861         mcp->out_mb = MBX_1|MBX_0;
2862         if (HAS_EXTENDED_IDS(vha->hw)) {
2863                 mcp->mb[1] = loop_id;
2864                 mcp->mb[10] = 0;
2865                 mcp->out_mb |= MBX_10;
2866         } else {
2867                 mcp->mb[1] = loop_id << 8;
2868         }
2869
2870         mcp->in_mb = MBX_1|MBX_0;
2871         mcp->tov = MBX_TOV_SECONDS;
2872         mcp->flags = 0;
2873         rval = qla2x00_mailbox_command(vha, mcp);
2874
2875         if (rval != QLA_SUCCESS) {
2876                 /*EMPTY*/
2877                 ql_dbg(ql_dbg_mbx, vha, 0x1074,
2878                     "Failed=%x mb[1]=%x.\n", rval, mcp->mb[1]);
2879         } else {
2880                 /*EMPTY*/
2881                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1075,
2882                     "Done %s.\n", __func__);
2883         }
2884
2885         return rval;
2886 }
2887
2888 /*
2889  * qla2x00_full_login_lip
2890  *      Issue full login LIP mailbox command.
2891  *
2892  * Input:
2893  *      ha = adapter block pointer.
2894  *      TARGET_QUEUE_LOCK must be released.
2895  *      ADAPTER_STATE_LOCK must be released.
2896  *
2897  * Returns:
2898  *      qla2x00 local function return status code.
2899  *
2900  * Context:
2901  *      Kernel context.
2902  */
2903 int
2904 qla2x00_full_login_lip(scsi_qla_host_t *vha)
2905 {
2906         int rval;
2907         mbx_cmd_t mc;
2908         mbx_cmd_t *mcp = &mc;
2909
2910         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1076,
2911             "Entered %s.\n", __func__);
2912
2913         mcp->mb[0] = MBC_LIP_FULL_LOGIN;
2914         mcp->mb[1] = IS_FWI2_CAPABLE(vha->hw) ? BIT_4 : 0;
2915         mcp->mb[2] = 0;
2916         mcp->mb[3] = 0;
2917         mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
2918         mcp->in_mb = MBX_0;
2919         mcp->tov = MBX_TOV_SECONDS;
2920         mcp->flags = 0;
2921         rval = qla2x00_mailbox_command(vha, mcp);
2922
2923         if (rval != QLA_SUCCESS) {
2924                 /*EMPTY*/
2925                 ql_dbg(ql_dbg_mbx, vha, 0x1077, "Failed=%x.\n", rval);
2926         } else {
2927                 /*EMPTY*/
2928                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1078,
2929                     "Done %s.\n", __func__);
2930         }
2931
2932         return rval;
2933 }
2934
2935 /*
2936  * qla2x00_get_id_list
2937  *
2938  * Input:
2939  *      ha = adapter block pointer.
2940  *
2941  * Returns:
2942  *      qla2x00 local function return status code.
2943  *
2944  * Context:
2945  *      Kernel context.
2946  */
2947 int
2948 qla2x00_get_id_list(scsi_qla_host_t *vha, void *id_list, dma_addr_t id_list_dma,
2949     uint16_t *entries)
2950 {
2951         int rval;
2952         mbx_cmd_t mc;
2953         mbx_cmd_t *mcp = &mc;
2954
2955         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1079,
2956             "Entered %s.\n", __func__);
2957
2958         if (id_list == NULL)
2959                 return QLA_FUNCTION_FAILED;
2960
2961         mcp->mb[0] = MBC_GET_ID_LIST;
2962         mcp->out_mb = MBX_0;
2963         if (IS_FWI2_CAPABLE(vha->hw)) {
2964                 mcp->mb[2] = MSW(id_list_dma);
2965                 mcp->mb[3] = LSW(id_list_dma);
2966                 mcp->mb[6] = MSW(MSD(id_list_dma));
2967                 mcp->mb[7] = LSW(MSD(id_list_dma));
2968                 mcp->mb[8] = 0;
2969                 mcp->mb[9] = vha->vp_idx;
2970                 mcp->out_mb |= MBX_9|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2;
2971         } else {
2972                 mcp->mb[1] = MSW(id_list_dma);
2973                 mcp->mb[2] = LSW(id_list_dma);
2974                 mcp->mb[3] = MSW(MSD(id_list_dma));
2975                 mcp->mb[6] = LSW(MSD(id_list_dma));
2976                 mcp->out_mb |= MBX_6|MBX_3|MBX_2|MBX_1;
2977         }
2978         mcp->in_mb = MBX_1|MBX_0;
2979         mcp->tov = MBX_TOV_SECONDS;
2980         mcp->flags = 0;
2981         rval = qla2x00_mailbox_command(vha, mcp);
2982
2983         if (rval != QLA_SUCCESS) {
2984                 /*EMPTY*/
2985                 ql_dbg(ql_dbg_mbx, vha, 0x107a, "Failed=%x.\n", rval);
2986         } else {
2987                 *entries = mcp->mb[1];
2988                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x107b,
2989                     "Done %s.\n", __func__);
2990         }
2991
2992         return rval;
2993 }
2994
2995 /*
2996  * qla2x00_get_resource_cnts
2997  *      Get current firmware resource counts.
2998  *
2999  * Input:
3000  *      ha = adapter block pointer.
3001  *
3002  * Returns:
3003  *      qla2x00 local function return status code.
3004  *
3005  * Context:
3006  *      Kernel context.
3007  */
3008 int
3009 qla2x00_get_resource_cnts(scsi_qla_host_t *vha)
3010 {
3011         struct qla_hw_data *ha = vha->hw;
3012         int rval;
3013         mbx_cmd_t mc;
3014         mbx_cmd_t *mcp = &mc;
3015
3016         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x107c,
3017             "Entered %s.\n", __func__);
3018
3019         mcp->mb[0] = MBC_GET_RESOURCE_COUNTS;
3020         mcp->out_mb = MBX_0;
3021         mcp->in_mb = MBX_11|MBX_10|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
3022         if (IS_QLA81XX(ha) || IS_QLA83XX(ha) ||
3023             IS_QLA27XX(ha) || IS_QLA28XX(ha))
3024                 mcp->in_mb |= MBX_12;
3025         mcp->tov = MBX_TOV_SECONDS;
3026         mcp->flags = 0;
3027         rval = qla2x00_mailbox_command(vha, mcp);
3028
3029         if (rval != QLA_SUCCESS) {
3030                 /*EMPTY*/
3031                 ql_dbg(ql_dbg_mbx, vha, 0x107d,
3032                     "Failed mb[0]=%x.\n", mcp->mb[0]);
3033         } else {
3034                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x107e,
3035                     "Done %s mb1=%x mb2=%x mb3=%x mb6=%x mb7=%x mb10=%x "
3036                     "mb11=%x mb12=%x.\n", __func__, mcp->mb[1], mcp->mb[2],
3037                     mcp->mb[3], mcp->mb[6], mcp->mb[7], mcp->mb[10],
3038                     mcp->mb[11], mcp->mb[12]);
3039
3040                 ha->orig_fw_tgt_xcb_count =  mcp->mb[1];
3041                 ha->cur_fw_tgt_xcb_count = mcp->mb[2];
3042                 ha->cur_fw_xcb_count = mcp->mb[3];
3043                 ha->orig_fw_xcb_count = mcp->mb[6];
3044                 ha->cur_fw_iocb_count = mcp->mb[7];
3045                 ha->orig_fw_iocb_count = mcp->mb[10];
3046                 if (ha->flags.npiv_supported)
3047                         ha->max_npiv_vports = mcp->mb[11];
3048                 if (IS_QLA81XX(ha) || IS_QLA83XX(ha))
3049                         ha->fw_max_fcf_count = mcp->mb[12];
3050         }
3051
3052         return (rval);
3053 }
3054
3055 /*
3056  * qla2x00_get_fcal_position_map
3057  *      Get FCAL (LILP) position map using mailbox command
3058  *
3059  * Input:
3060  *      ha = adapter state pointer.
3061  *      pos_map = buffer pointer (can be NULL).
3062  *
3063  * Returns:
3064  *      qla2x00 local function return status code.
3065  *
3066  * Context:
3067  *      Kernel context.
3068  */
3069 int
3070 qla2x00_get_fcal_position_map(scsi_qla_host_t *vha, char *pos_map,
3071                 u8 *num_entries)
3072 {
3073         int rval;
3074         mbx_cmd_t mc;
3075         mbx_cmd_t *mcp = &mc;
3076         char *pmap;
3077         dma_addr_t pmap_dma;
3078         struct qla_hw_data *ha = vha->hw;
3079
3080         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x107f,
3081             "Entered %s.\n", __func__);
3082
3083         pmap = dma_pool_zalloc(ha->s_dma_pool, GFP_KERNEL, &pmap_dma);
3084         if (pmap  == NULL) {
3085                 ql_log(ql_log_warn, vha, 0x1080,
3086                     "Memory alloc failed.\n");
3087                 return QLA_MEMORY_ALLOC_FAILED;
3088         }
3089
3090         mcp->mb[0] = MBC_GET_FC_AL_POSITION_MAP;
3091         mcp->mb[2] = MSW(pmap_dma);
3092         mcp->mb[3] = LSW(pmap_dma);
3093         mcp->mb[6] = MSW(MSD(pmap_dma));
3094         mcp->mb[7] = LSW(MSD(pmap_dma));
3095         mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_0;
3096         mcp->in_mb = MBX_1|MBX_0;
3097         mcp->buf_size = FCAL_MAP_SIZE;
3098         mcp->flags = MBX_DMA_IN;
3099         mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2);
3100         rval = qla2x00_mailbox_command(vha, mcp);
3101
3102         if (rval == QLA_SUCCESS) {
3103                 ql_dbg(ql_dbg_mbx + ql_dbg_buffer, vha, 0x1081,
3104                     "mb0/mb1=%x/%X FC/AL position map size (%x).\n",
3105                     mcp->mb[0], mcp->mb[1], (unsigned)pmap[0]);
3106                 ql_dump_buffer(ql_dbg_mbx + ql_dbg_buffer, vha, 0x111d,
3107                     pmap, pmap[0] + 1);
3108
3109                 if (pos_map)
3110                         memcpy(pos_map, pmap, FCAL_MAP_SIZE);
3111                 if (num_entries)
3112                         *num_entries = pmap[0];
3113         }
3114         dma_pool_free(ha->s_dma_pool, pmap, pmap_dma);
3115
3116         if (rval != QLA_SUCCESS) {
3117                 ql_dbg(ql_dbg_mbx, vha, 0x1082, "Failed=%x.\n", rval);
3118         } else {
3119                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1083,
3120                     "Done %s.\n", __func__);
3121         }
3122
3123         return rval;
3124 }
3125
3126 /*
3127  * qla2x00_get_link_status
3128  *
3129  * Input:
3130  *      ha = adapter block pointer.
3131  *      loop_id = device loop ID.
3132  *      ret_buf = pointer to link status return buffer.
3133  *
3134  * Returns:
3135  *      0 = success.
3136  *      BIT_0 = mem alloc error.
3137  *      BIT_1 = mailbox error.
3138  */
3139 int
3140 qla2x00_get_link_status(scsi_qla_host_t *vha, uint16_t loop_id,
3141     struct link_statistics *stats, dma_addr_t stats_dma)
3142 {
3143         int rval;
3144         mbx_cmd_t mc;
3145         mbx_cmd_t *mcp = &mc;
3146         uint32_t *iter = (uint32_t *)stats;
3147         ushort dwords = offsetof(typeof(*stats), link_up_cnt)/sizeof(*iter);
3148         struct qla_hw_data *ha = vha->hw;
3149
3150         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1084,
3151             "Entered %s.\n", __func__);
3152
3153         mcp->mb[0] = MBC_GET_LINK_STATUS;
3154         mcp->mb[2] = MSW(LSD(stats_dma));
3155         mcp->mb[3] = LSW(LSD(stats_dma));
3156         mcp->mb[6] = MSW(MSD(stats_dma));
3157         mcp->mb[7] = LSW(MSD(stats_dma));
3158         mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_0;
3159         mcp->in_mb = MBX_0;
3160         if (IS_FWI2_CAPABLE(ha)) {
3161                 mcp->mb[1] = loop_id;
3162                 mcp->mb[4] = 0;
3163                 mcp->mb[10] = 0;
3164                 mcp->out_mb |= MBX_10|MBX_4|MBX_1;
3165                 mcp->in_mb |= MBX_1;
3166         } else if (HAS_EXTENDED_IDS(ha)) {
3167                 mcp->mb[1] = loop_id;
3168                 mcp->mb[10] = 0;
3169                 mcp->out_mb |= MBX_10|MBX_1;
3170         } else {
3171                 mcp->mb[1] = loop_id << 8;
3172                 mcp->out_mb |= MBX_1;
3173         }
3174         mcp->tov = MBX_TOV_SECONDS;
3175         mcp->flags = IOCTL_CMD;
3176         rval = qla2x00_mailbox_command(vha, mcp);
3177
3178         if (rval == QLA_SUCCESS) {
3179                 if (mcp->mb[0] != MBS_COMMAND_COMPLETE) {
3180                         ql_dbg(ql_dbg_mbx, vha, 0x1085,
3181                             "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
3182                         rval = QLA_FUNCTION_FAILED;
3183                 } else {
3184                         /* Re-endianize - firmware data is le32. */
3185                         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1086,
3186                             "Done %s.\n", __func__);
3187                         for ( ; dwords--; iter++)
3188                                 le32_to_cpus(iter);
3189                 }
3190         } else {
3191                 /* Failed. */
3192                 ql_dbg(ql_dbg_mbx, vha, 0x1087, "Failed=%x.\n", rval);
3193         }
3194
3195         return rval;
3196 }
3197
3198 int
3199 qla24xx_get_isp_stats(scsi_qla_host_t *vha, struct link_statistics *stats,
3200     dma_addr_t stats_dma, uint16_t options)
3201 {
3202         int rval;
3203         mbx_cmd_t mc;
3204         mbx_cmd_t *mcp = &mc;
3205         uint32_t *iter = (uint32_t *)stats;
3206         ushort dwords = sizeof(*stats)/sizeof(*iter);
3207
3208         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1088,
3209             "Entered %s.\n", __func__);
3210
3211         memset(&mc, 0, sizeof(mc));
3212         mc.mb[0] = MBC_GET_LINK_PRIV_STATS;
3213         mc.mb[2] = MSW(LSD(stats_dma));
3214         mc.mb[3] = LSW(LSD(stats_dma));
3215         mc.mb[6] = MSW(MSD(stats_dma));
3216         mc.mb[7] = LSW(MSD(stats_dma));
3217         mc.mb[8] = dwords;
3218         mc.mb[9] = vha->vp_idx;
3219         mc.mb[10] = options;
3220
3221         rval = qla24xx_send_mb_cmd(vha, &mc);
3222
3223         if (rval == QLA_SUCCESS) {
3224                 if (mcp->mb[0] != MBS_COMMAND_COMPLETE) {
3225                         ql_dbg(ql_dbg_mbx, vha, 0x1089,
3226                             "Failed mb[0]=%x.\n", mcp->mb[0]);
3227                         rval = QLA_FUNCTION_FAILED;
3228                 } else {
3229                         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x108a,
3230                             "Done %s.\n", __func__);
3231                         /* Re-endianize - firmware data is le32. */
3232                         for ( ; dwords--; iter++)
3233                                 le32_to_cpus(iter);
3234                 }
3235         } else {
3236                 /* Failed. */
3237                 ql_dbg(ql_dbg_mbx, vha, 0x108b, "Failed=%x.\n", rval);
3238         }
3239
3240         return rval;
3241 }
3242
3243 int
3244 qla24xx_abort_command(srb_t *sp)
3245 {
3246         int             rval;
3247         unsigned long   flags = 0;
3248
3249         struct abort_entry_24xx *abt;
3250         dma_addr_t      abt_dma;
3251         uint32_t        handle;
3252         fc_port_t       *fcport = sp->fcport;
3253         struct scsi_qla_host *vha = fcport->vha;
3254         struct qla_hw_data *ha = vha->hw;
3255         struct req_que *req;
3256         struct qla_qpair *qpair = sp->qpair;
3257
3258         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x108c,
3259             "Entered %s.\n", __func__);
3260
3261         if (sp->qpair)
3262                 req = sp->qpair->req;
3263         else
3264                 return QLA_ERR_NO_QPAIR;
3265
3266         if (ql2xasynctmfenable)
3267                 return qla24xx_async_abort_command(sp);
3268
3269         spin_lock_irqsave(qpair->qp_lock_ptr, flags);
3270         for (handle = 1; handle < req->num_outstanding_cmds; handle++) {
3271                 if (req->outstanding_cmds[handle] == sp)
3272                         break;
3273         }
3274         spin_unlock_irqrestore(qpair->qp_lock_ptr, flags);
3275         if (handle == req->num_outstanding_cmds) {
3276                 /* Command not found. */
3277                 return QLA_ERR_NOT_FOUND;
3278         }
3279
3280         abt = dma_pool_zalloc(ha->s_dma_pool, GFP_KERNEL, &abt_dma);
3281         if (abt == NULL) {
3282                 ql_log(ql_log_warn, vha, 0x108d,
3283                     "Failed to allocate abort IOCB.\n");
3284                 return QLA_MEMORY_ALLOC_FAILED;
3285         }
3286
3287         abt->entry_type = ABORT_IOCB_TYPE;
3288         abt->entry_count = 1;
3289         abt->handle = make_handle(req->id, abt->handle);
3290         abt->nport_handle = cpu_to_le16(fcport->loop_id);
3291         abt->handle_to_abort = make_handle(req->id, handle);
3292         abt->port_id[0] = fcport->d_id.b.al_pa;
3293         abt->port_id[1] = fcport->d_id.b.area;
3294         abt->port_id[2] = fcport->d_id.b.domain;
3295         abt->vp_index = fcport->vha->vp_idx;
3296
3297         abt->req_que_no = cpu_to_le16(req->id);
3298         /* Need to pass original sp */
3299         qla_nvme_abort_set_option(abt, sp);
3300
3301         rval = qla2x00_issue_iocb(vha, abt, abt_dma, 0);
3302         if (rval != QLA_SUCCESS) {
3303                 ql_dbg(ql_dbg_mbx, vha, 0x108e,
3304                     "Failed to issue IOCB (%x).\n", rval);
3305         } else if (abt->entry_status != 0) {
3306                 ql_dbg(ql_dbg_mbx, vha, 0x108f,
3307                     "Failed to complete IOCB -- error status (%x).\n",
3308                     abt->entry_status);
3309                 rval = QLA_FUNCTION_FAILED;
3310         } else if (abt->nport_handle != cpu_to_le16(0)) {
3311                 ql_dbg(ql_dbg_mbx, vha, 0x1090,
3312                     "Failed to complete IOCB -- completion status (%x).\n",
3313                     le16_to_cpu(abt->nport_handle));
3314                 if (abt->nport_handle == cpu_to_le16(CS_IOCB_ERROR))
3315                         rval = QLA_FUNCTION_PARAMETER_ERROR;
3316                 else
3317                         rval = QLA_FUNCTION_FAILED;
3318         } else {
3319                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1091,
3320                     "Done %s.\n", __func__);
3321         }
3322         if (rval == QLA_SUCCESS)
3323                 qla_nvme_abort_process_comp_status(abt, sp);
3324
3325         qla_wait_nvme_release_cmd_kref(sp);
3326
3327         dma_pool_free(ha->s_dma_pool, abt, abt_dma);
3328
3329         return rval;
3330 }
3331
3332 struct tsk_mgmt_cmd {
3333         union {
3334                 struct tsk_mgmt_entry tsk;
3335                 struct sts_entry_24xx sts;
3336         } p;
3337 };
3338
3339 static int
3340 __qla24xx_issue_tmf(char *name, uint32_t type, struct fc_port *fcport,
3341     uint64_t l, int tag)
3342 {
3343         int             rval, rval2;
3344         struct tsk_mgmt_cmd *tsk;
3345         struct sts_entry_24xx *sts;
3346         dma_addr_t      tsk_dma;
3347         scsi_qla_host_t *vha;
3348         struct qla_hw_data *ha;
3349         struct req_que *req;
3350         struct qla_qpair *qpair;
3351
3352         vha = fcport->vha;
3353         ha = vha->hw;
3354         req = vha->req;
3355
3356         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1092,
3357             "Entered %s.\n", __func__);
3358
3359         if (vha->vp_idx && vha->qpair) {
3360                 /* NPIV port */
3361                 qpair = vha->qpair;
3362                 req = qpair->req;
3363         }
3364
3365         tsk = dma_pool_zalloc(ha->s_dma_pool, GFP_KERNEL, &tsk_dma);
3366         if (tsk == NULL) {
3367                 ql_log(ql_log_warn, vha, 0x1093,
3368                     "Failed to allocate task management IOCB.\n");
3369                 return QLA_MEMORY_ALLOC_FAILED;
3370         }
3371
3372         tsk->p.tsk.entry_type = TSK_MGMT_IOCB_TYPE;
3373         tsk->p.tsk.entry_count = 1;
3374         tsk->p.tsk.handle = make_handle(req->id, tsk->p.tsk.handle);
3375         tsk->p.tsk.nport_handle = cpu_to_le16(fcport->loop_id);
3376         tsk->p.tsk.timeout = cpu_to_le16(ha->r_a_tov / 10 * 2);
3377         tsk->p.tsk.control_flags = cpu_to_le32(type);
3378         tsk->p.tsk.port_id[0] = fcport->d_id.b.al_pa;
3379         tsk->p.tsk.port_id[1] = fcport->d_id.b.area;
3380         tsk->p.tsk.port_id[2] = fcport->d_id.b.domain;
3381         tsk->p.tsk.vp_index = fcport->vha->vp_idx;
3382         if (type == TCF_LUN_RESET) {
3383                 int_to_scsilun(l, &tsk->p.tsk.lun);
3384                 host_to_fcp_swap((uint8_t *)&tsk->p.tsk.lun,
3385                     sizeof(tsk->p.tsk.lun));
3386         }
3387
3388         sts = &tsk->p.sts;
3389         rval = qla2x00_issue_iocb(vha, tsk, tsk_dma, 0);
3390         if (rval != QLA_SUCCESS) {
3391                 ql_dbg(ql_dbg_mbx, vha, 0x1094,
3392                     "Failed to issue %s reset IOCB (%x).\n", name, rval);
3393         } else if (sts->entry_status != 0) {
3394                 ql_dbg(ql_dbg_mbx, vha, 0x1095,
3395                     "Failed to complete IOCB -- error status (%x).\n",
3396                     sts->entry_status);
3397                 rval = QLA_FUNCTION_FAILED;
3398         } else if (sts->comp_status != cpu_to_le16(CS_COMPLETE)) {
3399                 ql_dbg(ql_dbg_mbx, vha, 0x1096,
3400                     "Failed to complete IOCB -- completion status (%x).\n",
3401                     le16_to_cpu(sts->comp_status));
3402                 rval = QLA_FUNCTION_FAILED;
3403         } else if (le16_to_cpu(sts->scsi_status) &
3404             SS_RESPONSE_INFO_LEN_VALID) {
3405                 if (le32_to_cpu(sts->rsp_data_len) < 4) {
3406                         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1097,
3407                             "Ignoring inconsistent data length -- not enough "
3408                             "response info (%d).\n",
3409                             le32_to_cpu(sts->rsp_data_len));
3410                 } else if (sts->data[3]) {
3411                         ql_dbg(ql_dbg_mbx, vha, 0x1098,
3412                             "Failed to complete IOCB -- response (%x).\n",
3413                             sts->data[3]);
3414                         rval = QLA_FUNCTION_FAILED;
3415                 }
3416         }
3417
3418         /* Issue marker IOCB. */
3419         rval2 = qla2x00_marker(vha, ha->base_qpair, fcport->loop_id, l,
3420             type == TCF_LUN_RESET ? MK_SYNC_ID_LUN : MK_SYNC_ID);
3421         if (rval2 != QLA_SUCCESS) {
3422                 ql_dbg(ql_dbg_mbx, vha, 0x1099,
3423                     "Failed to issue marker IOCB (%x).\n", rval2);
3424         } else {
3425                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x109a,
3426                     "Done %s.\n", __func__);
3427         }
3428
3429         dma_pool_free(ha->s_dma_pool, tsk, tsk_dma);
3430
3431         return rval;
3432 }
3433
3434 int
3435 qla24xx_abort_target(struct fc_port *fcport, uint64_t l, int tag)
3436 {
3437         struct qla_hw_data *ha = fcport->vha->hw;
3438
3439         if ((ql2xasynctmfenable) && IS_FWI2_CAPABLE(ha))
3440                 return qla2x00_async_tm_cmd(fcport, TCF_TARGET_RESET, l, tag);
3441
3442         return __qla24xx_issue_tmf("Target", TCF_TARGET_RESET, fcport, l, tag);
3443 }
3444
3445 int
3446 qla24xx_lun_reset(struct fc_port *fcport, uint64_t l, int tag)
3447 {
3448         struct qla_hw_data *ha = fcport->vha->hw;
3449
3450         if ((ql2xasynctmfenable) && IS_FWI2_CAPABLE(ha))
3451                 return qla2x00_async_tm_cmd(fcport, TCF_LUN_RESET, l, tag);
3452
3453         return __qla24xx_issue_tmf("Lun", TCF_LUN_RESET, fcport, l, tag);
3454 }
3455
3456 int
3457 qla2x00_system_error(scsi_qla_host_t *vha)
3458 {
3459         int rval;
3460         mbx_cmd_t mc;
3461         mbx_cmd_t *mcp = &mc;
3462         struct qla_hw_data *ha = vha->hw;
3463
3464         if (!IS_QLA23XX(ha) && !IS_FWI2_CAPABLE(ha))
3465                 return QLA_FUNCTION_FAILED;
3466
3467         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x109b,
3468             "Entered %s.\n", __func__);
3469
3470         mcp->mb[0] = MBC_GEN_SYSTEM_ERROR;
3471         mcp->out_mb = MBX_0;
3472         mcp->in_mb = MBX_0;
3473         mcp->tov = 5;
3474         mcp->flags = 0;
3475         rval = qla2x00_mailbox_command(vha, mcp);
3476
3477         if (rval != QLA_SUCCESS) {
3478                 ql_dbg(ql_dbg_mbx, vha, 0x109c, "Failed=%x.\n", rval);
3479         } else {
3480                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x109d,
3481                     "Done %s.\n", __func__);
3482         }
3483
3484         return rval;
3485 }
3486
3487 int
3488 qla2x00_write_serdes_word(scsi_qla_host_t *vha, uint16_t addr, uint16_t data)
3489 {
3490         int rval;
3491         mbx_cmd_t mc;
3492         mbx_cmd_t *mcp = &mc;
3493
3494         if (!IS_QLA25XX(vha->hw) && !IS_QLA2031(vha->hw) &&
3495             !IS_QLA27XX(vha->hw) && !IS_QLA28XX(vha->hw))
3496                 return QLA_FUNCTION_FAILED;
3497
3498         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1182,
3499             "Entered %s.\n", __func__);
3500
3501         mcp->mb[0] = MBC_WRITE_SERDES;
3502         mcp->mb[1] = addr;
3503         if (IS_QLA2031(vha->hw))
3504                 mcp->mb[2] = data & 0xff;
3505         else
3506                 mcp->mb[2] = data;
3507
3508         mcp->mb[3] = 0;
3509         mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
3510         mcp->in_mb = MBX_0;
3511         mcp->tov = MBX_TOV_SECONDS;
3512         mcp->flags = 0;
3513         rval = qla2x00_mailbox_command(vha, mcp);
3514
3515         if (rval != QLA_SUCCESS) {
3516                 ql_dbg(ql_dbg_mbx, vha, 0x1183,
3517                     "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
3518         } else {
3519                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1184,
3520                     "Done %s.\n", __func__);
3521         }
3522
3523         return rval;
3524 }
3525
3526 int
3527 qla2x00_read_serdes_word(scsi_qla_host_t *vha, uint16_t addr, uint16_t *data)
3528 {
3529         int rval;
3530         mbx_cmd_t mc;
3531         mbx_cmd_t *mcp = &mc;
3532
3533         if (!IS_QLA25XX(vha->hw) && !IS_QLA2031(vha->hw) &&
3534             !IS_QLA27XX(vha->hw) && !IS_QLA28XX(vha->hw))
3535                 return QLA_FUNCTION_FAILED;
3536
3537         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1185,
3538             "Entered %s.\n", __func__);
3539
3540         mcp->mb[0] = MBC_READ_SERDES;
3541         mcp->mb[1] = addr;
3542         mcp->mb[3] = 0;
3543         mcp->out_mb = MBX_3|MBX_1|MBX_0;
3544         mcp->in_mb = MBX_1|MBX_0;
3545         mcp->tov = MBX_TOV_SECONDS;
3546         mcp->flags = 0;
3547         rval = qla2x00_mailbox_command(vha, mcp);
3548
3549         if (IS_QLA2031(vha->hw))
3550                 *data = mcp->mb[1] & 0xff;
3551         else
3552                 *data = mcp->mb[1];
3553
3554         if (rval != QLA_SUCCESS) {
3555                 ql_dbg(ql_dbg_mbx, vha, 0x1186,
3556                     "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
3557         } else {
3558                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1187,
3559                     "Done %s.\n", __func__);
3560         }
3561
3562         return rval;
3563 }
3564
3565 int
3566 qla8044_write_serdes_word(scsi_qla_host_t *vha, uint32_t addr, uint32_t data)
3567 {
3568         int rval;
3569         mbx_cmd_t mc;
3570         mbx_cmd_t *mcp = &mc;
3571
3572         if (!IS_QLA8044(vha->hw))
3573                 return QLA_FUNCTION_FAILED;
3574
3575         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x11a0,
3576             "Entered %s.\n", __func__);
3577
3578         mcp->mb[0] = MBC_SET_GET_ETH_SERDES_REG;
3579         mcp->mb[1] = HCS_WRITE_SERDES;
3580         mcp->mb[3] = LSW(addr);
3581         mcp->mb[4] = MSW(addr);
3582         mcp->mb[5] = LSW(data);
3583         mcp->mb[6] = MSW(data);
3584         mcp->out_mb = MBX_6|MBX_5|MBX_4|MBX_3|MBX_1|MBX_0;
3585         mcp->in_mb = MBX_0;
3586         mcp->tov = MBX_TOV_SECONDS;
3587         mcp->flags = 0;
3588         rval = qla2x00_mailbox_command(vha, mcp);
3589
3590         if (rval != QLA_SUCCESS) {
3591                 ql_dbg(ql_dbg_mbx, vha, 0x11a1,
3592                     "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
3593         } else {
3594                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1188,
3595                     "Done %s.\n", __func__);
3596         }
3597
3598         return rval;
3599 }
3600
3601 int
3602 qla8044_read_serdes_word(scsi_qla_host_t *vha, uint32_t addr, uint32_t *data)
3603 {
3604         int rval;
3605         mbx_cmd_t mc;
3606         mbx_cmd_t *mcp = &mc;
3607
3608         if (!IS_QLA8044(vha->hw))
3609                 return QLA_FUNCTION_FAILED;
3610
3611         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1189,
3612             "Entered %s.\n", __func__);
3613
3614         mcp->mb[0] = MBC_SET_GET_ETH_SERDES_REG;
3615         mcp->mb[1] = HCS_READ_SERDES;
3616         mcp->mb[3] = LSW(addr);
3617         mcp->mb[4] = MSW(addr);
3618         mcp->out_mb = MBX_4|MBX_3|MBX_1|MBX_0;
3619         mcp->in_mb = MBX_2|MBX_1|MBX_0;
3620         mcp->tov = MBX_TOV_SECONDS;
3621         mcp->flags = 0;
3622         rval = qla2x00_mailbox_command(vha, mcp);
3623
3624         *data = mcp->mb[2] << 16 | mcp->mb[1];
3625
3626         if (rval != QLA_SUCCESS) {
3627                 ql_dbg(ql_dbg_mbx, vha, 0x118a,
3628                     "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
3629         } else {
3630                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x118b,
3631                     "Done %s.\n", __func__);
3632         }
3633
3634         return rval;
3635 }
3636
3637 /**
3638  * qla2x00_set_serdes_params() -
3639  * @vha: HA context
3640  * @sw_em_1g: serial link options
3641  * @sw_em_2g: serial link options
3642  * @sw_em_4g: serial link options
3643  *
3644  * Returns
3645  */
3646 int
3647 qla2x00_set_serdes_params(scsi_qla_host_t *vha, uint16_t sw_em_1g,
3648     uint16_t sw_em_2g, uint16_t sw_em_4g)
3649 {
3650         int rval;
3651         mbx_cmd_t mc;
3652         mbx_cmd_t *mcp = &mc;
3653
3654         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x109e,
3655             "Entered %s.\n", __func__);
3656
3657         mcp->mb[0] = MBC_SERDES_PARAMS;
3658         mcp->mb[1] = BIT_0;
3659         mcp->mb[2] = sw_em_1g | BIT_15;
3660         mcp->mb[3] = sw_em_2g | BIT_15;
3661         mcp->mb[4] = sw_em_4g | BIT_15;
3662         mcp->out_mb = MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
3663         mcp->in_mb = MBX_0;
3664         mcp->tov = MBX_TOV_SECONDS;
3665         mcp->flags = 0;
3666         rval = qla2x00_mailbox_command(vha, mcp);
3667
3668         if (rval != QLA_SUCCESS) {
3669                 /*EMPTY*/
3670                 ql_dbg(ql_dbg_mbx, vha, 0x109f,
3671                     "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
3672         } else {
3673                 /*EMPTY*/
3674                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10a0,
3675                     "Done %s.\n", __func__);
3676         }
3677
3678         return rval;
3679 }
3680
3681 int
3682 qla2x00_stop_firmware(scsi_qla_host_t *vha)
3683 {
3684         int rval;
3685         mbx_cmd_t mc;
3686         mbx_cmd_t *mcp = &mc;
3687
3688         if (!IS_FWI2_CAPABLE(vha->hw))
3689                 return QLA_FUNCTION_FAILED;
3690
3691         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10a1,
3692             "Entered %s.\n", __func__);
3693
3694         mcp->mb[0] = MBC_STOP_FIRMWARE;
3695         mcp->mb[1] = 0;
3696         mcp->out_mb = MBX_1|MBX_0;
3697         mcp->in_mb = MBX_0;
3698         mcp->tov = 5;
3699         mcp->flags = 0;
3700         rval = qla2x00_mailbox_command(vha, mcp);
3701
3702         if (rval != QLA_SUCCESS) {
3703                 ql_dbg(ql_dbg_mbx, vha, 0x10a2, "Failed=%x.\n", rval);
3704                 if (mcp->mb[0] == MBS_INVALID_COMMAND)
3705                         rval = QLA_INVALID_COMMAND;
3706         } else {
3707                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10a3,
3708                     "Done %s.\n", __func__);
3709         }
3710
3711         return rval;
3712 }
3713
3714 int
3715 qla2x00_enable_eft_trace(scsi_qla_host_t *vha, dma_addr_t eft_dma,
3716     uint16_t buffers)
3717 {
3718         int rval;
3719         mbx_cmd_t mc;
3720         mbx_cmd_t *mcp = &mc;
3721
3722         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10a4,
3723             "Entered %s.\n", __func__);
3724
3725         if (!IS_FWI2_CAPABLE(vha->hw))
3726                 return QLA_FUNCTION_FAILED;
3727
3728         if (unlikely(pci_channel_offline(vha->hw->pdev)))
3729                 return QLA_FUNCTION_FAILED;
3730
3731         mcp->mb[0] = MBC_TRACE_CONTROL;
3732         mcp->mb[1] = TC_EFT_ENABLE;
3733         mcp->mb[2] = LSW(eft_dma);
3734         mcp->mb[3] = MSW(eft_dma);
3735         mcp->mb[4] = LSW(MSD(eft_dma));
3736         mcp->mb[5] = MSW(MSD(eft_dma));
3737         mcp->mb[6] = buffers;
3738         mcp->mb[7] = TC_AEN_DISABLE;
3739         mcp->out_mb = MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
3740         mcp->in_mb = MBX_1|MBX_0;
3741         mcp->tov = MBX_TOV_SECONDS;
3742         mcp->flags = 0;
3743         rval = qla2x00_mailbox_command(vha, mcp);
3744         if (rval != QLA_SUCCESS) {
3745                 ql_dbg(ql_dbg_mbx, vha, 0x10a5,
3746                     "Failed=%x mb[0]=%x mb[1]=%x.\n",
3747                     rval, mcp->mb[0], mcp->mb[1]);
3748         } else {
3749                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10a6,
3750                     "Done %s.\n", __func__);
3751         }
3752
3753         return rval;
3754 }
3755
3756 int
3757 qla2x00_disable_eft_trace(scsi_qla_host_t *vha)
3758 {
3759         int rval;
3760         mbx_cmd_t mc;
3761         mbx_cmd_t *mcp = &mc;
3762
3763         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10a7,
3764             "Entered %s.\n", __func__);
3765
3766         if (!IS_FWI2_CAPABLE(vha->hw))
3767                 return QLA_FUNCTION_FAILED;
3768
3769         if (unlikely(pci_channel_offline(vha->hw->pdev)))
3770                 return QLA_FUNCTION_FAILED;
3771
3772         mcp->mb[0] = MBC_TRACE_CONTROL;
3773         mcp->mb[1] = TC_EFT_DISABLE;
3774         mcp->out_mb = MBX_1|MBX_0;
3775         mcp->in_mb = MBX_1|MBX_0;
3776         mcp->tov = MBX_TOV_SECONDS;
3777         mcp->flags = 0;
3778         rval = qla2x00_mailbox_command(vha, mcp);
3779         if (rval != QLA_SUCCESS) {
3780                 ql_dbg(ql_dbg_mbx, vha, 0x10a8,
3781                     "Failed=%x mb[0]=%x mb[1]=%x.\n",
3782                     rval, mcp->mb[0], mcp->mb[1]);
3783         } else {
3784                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10a9,
3785                     "Done %s.\n", __func__);
3786         }
3787
3788         return rval;
3789 }
3790
3791 int
3792 qla2x00_enable_fce_trace(scsi_qla_host_t *vha, dma_addr_t fce_dma,
3793     uint16_t buffers, uint16_t *mb, uint32_t *dwords)
3794 {
3795         int rval;
3796         mbx_cmd_t mc;
3797         mbx_cmd_t *mcp = &mc;
3798
3799         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10aa,
3800             "Entered %s.\n", __func__);
3801
3802         if (!IS_QLA25XX(vha->hw) && !IS_QLA81XX(vha->hw) &&
3803             !IS_QLA83XX(vha->hw) && !IS_QLA27XX(vha->hw) &&
3804             !IS_QLA28XX(vha->hw))
3805                 return QLA_FUNCTION_FAILED;
3806
3807         if (unlikely(pci_channel_offline(vha->hw->pdev)))
3808                 return QLA_FUNCTION_FAILED;
3809
3810         mcp->mb[0] = MBC_TRACE_CONTROL;
3811         mcp->mb[1] = TC_FCE_ENABLE;
3812         mcp->mb[2] = LSW(fce_dma);
3813         mcp->mb[3] = MSW(fce_dma);
3814         mcp->mb[4] = LSW(MSD(fce_dma));
3815         mcp->mb[5] = MSW(MSD(fce_dma));
3816         mcp->mb[6] = buffers;
3817         mcp->mb[7] = TC_AEN_DISABLE;
3818         mcp->mb[8] = 0;
3819         mcp->mb[9] = TC_FCE_DEFAULT_RX_SIZE;
3820         mcp->mb[10] = TC_FCE_DEFAULT_TX_SIZE;
3821         mcp->out_mb = MBX_10|MBX_9|MBX_8|MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|
3822             MBX_1|MBX_0;
3823         mcp->in_mb = MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
3824         mcp->tov = MBX_TOV_SECONDS;
3825         mcp->flags = 0;
3826         rval = qla2x00_mailbox_command(vha, mcp);
3827         if (rval != QLA_SUCCESS) {
3828                 ql_dbg(ql_dbg_mbx, vha, 0x10ab,
3829                     "Failed=%x mb[0]=%x mb[1]=%x.\n",
3830                     rval, mcp->mb[0], mcp->mb[1]);
3831         } else {
3832                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10ac,
3833                     "Done %s.\n", __func__);
3834
3835                 if (mb)
3836                         memcpy(mb, mcp->mb, 8 * sizeof(*mb));
3837                 if (dwords)
3838                         *dwords = buffers;
3839         }
3840
3841         return rval;
3842 }
3843
3844 int
3845 qla2x00_disable_fce_trace(scsi_qla_host_t *vha, uint64_t *wr, uint64_t *rd)
3846 {
3847         int rval;
3848         mbx_cmd_t mc;
3849         mbx_cmd_t *mcp = &mc;
3850
3851         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10ad,
3852             "Entered %s.\n", __func__);
3853
3854         if (!IS_FWI2_CAPABLE(vha->hw))
3855                 return QLA_FUNCTION_FAILED;
3856
3857         if (unlikely(pci_channel_offline(vha->hw->pdev)))
3858                 return QLA_FUNCTION_FAILED;
3859
3860         mcp->mb[0] = MBC_TRACE_CONTROL;
3861         mcp->mb[1] = TC_FCE_DISABLE;
3862         mcp->mb[2] = TC_FCE_DISABLE_TRACE;
3863         mcp->out_mb = MBX_2|MBX_1|MBX_0;
3864         mcp->in_mb = MBX_9|MBX_8|MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|
3865             MBX_1|MBX_0;
3866         mcp->tov = MBX_TOV_SECONDS;
3867         mcp->flags = 0;
3868         rval = qla2x00_mailbox_command(vha, mcp);
3869         if (rval != QLA_SUCCESS) {
3870                 ql_dbg(ql_dbg_mbx, vha, 0x10ae,
3871                     "Failed=%x mb[0]=%x mb[1]=%x.\n",
3872                     rval, mcp->mb[0], mcp->mb[1]);
3873         } else {
3874                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10af,
3875                     "Done %s.\n", __func__);
3876
3877                 if (wr)
3878                         *wr = (uint64_t) mcp->mb[5] << 48 |
3879                             (uint64_t) mcp->mb[4] << 32 |
3880                             (uint64_t) mcp->mb[3] << 16 |
3881                             (uint64_t) mcp->mb[2];
3882                 if (rd)
3883                         *rd = (uint64_t) mcp->mb[9] << 48 |
3884                             (uint64_t) mcp->mb[8] << 32 |
3885                             (uint64_t) mcp->mb[7] << 16 |
3886                             (uint64_t) mcp->mb[6];
3887         }
3888
3889         return rval;
3890 }
3891
3892 int
3893 qla2x00_get_idma_speed(scsi_qla_host_t *vha, uint16_t loop_id,
3894         uint16_t *port_speed, uint16_t *mb)
3895 {
3896         int rval;
3897         mbx_cmd_t mc;
3898         mbx_cmd_t *mcp = &mc;
3899
3900         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10b0,
3901             "Entered %s.\n", __func__);
3902
3903         if (!IS_IIDMA_CAPABLE(vha->hw))
3904                 return QLA_FUNCTION_FAILED;
3905
3906         mcp->mb[0] = MBC_PORT_PARAMS;
3907         mcp->mb[1] = loop_id;
3908         mcp->mb[2] = mcp->mb[3] = 0;
3909         mcp->mb[9] = vha->vp_idx;
3910         mcp->out_mb = MBX_9|MBX_3|MBX_2|MBX_1|MBX_0;
3911         mcp->in_mb = MBX_3|MBX_1|MBX_0;
3912         mcp->tov = MBX_TOV_SECONDS;
3913         mcp->flags = 0;
3914         rval = qla2x00_mailbox_command(vha, mcp);
3915
3916         /* Return mailbox statuses. */
3917         if (mb) {
3918                 mb[0] = mcp->mb[0];
3919                 mb[1] = mcp->mb[1];
3920                 mb[3] = mcp->mb[3];
3921         }
3922
3923         if (rval != QLA_SUCCESS) {
3924                 ql_dbg(ql_dbg_mbx, vha, 0x10b1, "Failed=%x.\n", rval);
3925         } else {
3926                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10b2,
3927                     "Done %s.\n", __func__);
3928                 if (port_speed)
3929                         *port_speed = mcp->mb[3];
3930         }
3931
3932         return rval;
3933 }
3934
3935 int
3936 qla2x00_set_idma_speed(scsi_qla_host_t *vha, uint16_t loop_id,
3937     uint16_t port_speed, uint16_t *mb)
3938 {
3939         int rval;
3940         mbx_cmd_t mc;
3941         mbx_cmd_t *mcp = &mc;
3942
3943         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10b3,
3944             "Entered %s.\n", __func__);
3945
3946         if (!IS_IIDMA_CAPABLE(vha->hw))
3947                 return QLA_FUNCTION_FAILED;
3948
3949         mcp->mb[0] = MBC_PORT_PARAMS;
3950         mcp->mb[1] = loop_id;
3951         mcp->mb[2] = BIT_0;
3952         mcp->mb[3] = port_speed & 0x3F;
3953         mcp->mb[9] = vha->vp_idx;
3954         mcp->out_mb = MBX_9|MBX_3|MBX_2|MBX_1|MBX_0;
3955         mcp->in_mb = MBX_3|MBX_1|MBX_0;
3956         mcp->tov = MBX_TOV_SECONDS;
3957         mcp->flags = 0;
3958         rval = qla2x00_mailbox_command(vha, mcp);
3959
3960         /* Return mailbox statuses. */
3961         if (mb) {
3962                 mb[0] = mcp->mb[0];
3963                 mb[1] = mcp->mb[1];
3964                 mb[3] = mcp->mb[3];
3965         }
3966
3967         if (rval != QLA_SUCCESS) {
3968                 ql_dbg(ql_dbg_mbx, vha, 0x10b4,
3969                     "Failed=%x.\n", rval);
3970         } else {
3971                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10b5,
3972                     "Done %s.\n", __func__);
3973         }
3974
3975         return rval;
3976 }
3977
3978 void
3979 qla24xx_report_id_acquisition(scsi_qla_host_t *vha,
3980         struct vp_rpt_id_entry_24xx *rptid_entry)
3981 {
3982         struct qla_hw_data *ha = vha->hw;
3983         scsi_qla_host_t *vp = NULL;
3984         unsigned long   flags;
3985         int found;
3986         port_id_t id;
3987         struct fc_port *fcport;
3988
3989         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10b6,
3990             "Entered %s.\n", __func__);
3991
3992         if (rptid_entry->entry_status != 0)
3993                 return;
3994
3995         id.b.domain = rptid_entry->port_id[2];
3996         id.b.area   = rptid_entry->port_id[1];
3997         id.b.al_pa  = rptid_entry->port_id[0];
3998         id.b.rsvd_1 = 0;
3999         ha->flags.n2n_ae = 0;
4000
4001         if (rptid_entry->format == 0) {
4002                 /* loop */
4003                 ql_dbg(ql_dbg_async, vha, 0x10b7,
4004                     "Format 0 : Number of VPs setup %d, number of "
4005                     "VPs acquired %d.\n", rptid_entry->vp_setup,
4006                     rptid_entry->vp_acquired);
4007                 ql_dbg(ql_dbg_async, vha, 0x10b8,
4008                     "Primary port id %02x%02x%02x.\n",
4009                     rptid_entry->port_id[2], rptid_entry->port_id[1],
4010                     rptid_entry->port_id[0]);
4011                 ha->current_topology = ISP_CFG_NL;
4012                 qla_update_host_map(vha, id);
4013
4014         } else if (rptid_entry->format == 1) {
4015                 /* fabric */
4016                 ql_dbg(ql_dbg_async, vha, 0x10b9,
4017                     "Format 1: VP[%d] enabled - status %d - with "
4018                     "port id %02x%02x%02x.\n", rptid_entry->vp_idx,
4019                         rptid_entry->vp_status,
4020                     rptid_entry->port_id[2], rptid_entry->port_id[1],
4021                     rptid_entry->port_id[0]);
4022                 ql_dbg(ql_dbg_async, vha, 0x5075,
4023                    "Format 1: Remote WWPN %8phC.\n",
4024                    rptid_entry->u.f1.port_name);
4025
4026                 ql_dbg(ql_dbg_async, vha, 0x5075,
4027                    "Format 1: WWPN %8phC.\n",
4028                    vha->port_name);
4029
4030                 switch (rptid_entry->u.f1.flags & TOPO_MASK) {
4031                 case TOPO_N2N:
4032                         ha->current_topology = ISP_CFG_N;
4033                         spin_lock_irqsave(&vha->hw->tgt.sess_lock, flags);
4034                         list_for_each_entry(fcport, &vha->vp_fcports, list) {
4035                                 fcport->scan_state = QLA_FCPORT_SCAN;
4036                                 fcport->n2n_flag = 0;
4037                         }
4038                         id.b24 = 0;
4039                         if (wwn_to_u64(vha->port_name) >
4040                             wwn_to_u64(rptid_entry->u.f1.port_name)) {
4041                                 vha->d_id.b24 = 0;
4042                                 vha->d_id.b.al_pa = 1;
4043                                 ha->flags.n2n_bigger = 1;
4044
4045                                 id.b.al_pa = 2;
4046                                 ql_dbg(ql_dbg_async, vha, 0x5075,
4047                                     "Format 1: assign local id %x remote id %x\n",
4048                                     vha->d_id.b24, id.b24);
4049                         } else {
4050                                 ql_dbg(ql_dbg_async, vha, 0x5075,
4051                                     "Format 1: Remote login - Waiting for WWPN %8phC.\n",
4052                                     rptid_entry->u.f1.port_name);
4053                                 ha->flags.n2n_bigger = 0;
4054                         }
4055
4056                         fcport = qla2x00_find_fcport_by_wwpn(vha,
4057                             rptid_entry->u.f1.port_name, 1);
4058                         spin_unlock_irqrestore(&vha->hw->tgt.sess_lock, flags);
4059
4060
4061                         if (fcport) {
4062                                 fcport->plogi_nack_done_deadline = jiffies + HZ;
4063                                 fcport->dm_login_expire = jiffies +
4064                                         QLA_N2N_WAIT_TIME * HZ;
4065                                 fcport->scan_state = QLA_FCPORT_FOUND;
4066                                 fcport->n2n_flag = 1;
4067                                 fcport->keep_nport_handle = 1;
4068                                 fcport->login_retry = vha->hw->login_retry_count;
4069                                 fcport->fc4_type = FS_FC4TYPE_FCP;
4070                                 if (vha->flags.nvme_enabled)
4071                                         fcport->fc4_type |= FS_FC4TYPE_NVME;
4072
4073                                 if (wwn_to_u64(vha->port_name) >
4074                                     wwn_to_u64(fcport->port_name)) {
4075                                         fcport->d_id = id;
4076                                 }
4077
4078                                 switch (fcport->disc_state) {
4079                                 case DSC_DELETED:
4080                                         set_bit(RELOGIN_NEEDED,
4081                                             &vha->dpc_flags);
4082                                         break;
4083                                 case DSC_DELETE_PEND:
4084                                         break;
4085                                 default:
4086                                         qlt_schedule_sess_for_deletion(fcport);
4087                                         break;
4088                                 }
4089                         } else {
4090                                 qla24xx_post_newsess_work(vha, &id,
4091                                     rptid_entry->u.f1.port_name,
4092                                     rptid_entry->u.f1.node_name,
4093                                     NULL,
4094                                     FS_FCP_IS_N2N);
4095                         }
4096
4097                         /* if our portname is higher then initiate N2N login */
4098
4099                         set_bit(N2N_LOGIN_NEEDED, &vha->dpc_flags);
4100                         return;
4101                 case TOPO_FL:
4102                         ha->current_topology = ISP_CFG_FL;
4103                         break;
4104                 case TOPO_F:
4105                         ha->current_topology = ISP_CFG_F;
4106                         break;
4107                 default:
4108                         break;
4109                 }
4110
4111                 ha->flags.gpsc_supported = 1;
4112                 ha->current_topology = ISP_CFG_F;
4113                 /* buffer to buffer credit flag */
4114                 vha->flags.bbcr_enable = (rptid_entry->u.f1.bbcr & 0xf) != 0;
4115
4116                 if (rptid_entry->vp_idx == 0) {
4117                         if (rptid_entry->vp_status == VP_STAT_COMPL) {
4118                                 /* FA-WWN is only for physical port */
4119                                 if (qla_ini_mode_enabled(vha) &&
4120                                     ha->flags.fawwpn_enabled &&
4121                                     (rptid_entry->u.f1.flags &
4122                                      BIT_6)) {
4123                                         memcpy(vha->port_name,
4124                                             rptid_entry->u.f1.port_name,
4125                                             WWN_SIZE);
4126                                 }
4127
4128                                 qla_update_host_map(vha, id);
4129                         }
4130
4131                         set_bit(REGISTER_FC4_NEEDED, &vha->dpc_flags);
4132                         set_bit(REGISTER_FDMI_NEEDED, &vha->dpc_flags);
4133                 } else {
4134                         if (rptid_entry->vp_status != VP_STAT_COMPL &&
4135                                 rptid_entry->vp_status != VP_STAT_ID_CHG) {
4136                                 ql_dbg(ql_dbg_mbx, vha, 0x10ba,
4137                                     "Could not acquire ID for VP[%d].\n",
4138                                     rptid_entry->vp_idx);
4139                                 return;
4140                         }
4141
4142                         found = 0;
4143                         spin_lock_irqsave(&ha->vport_slock, flags);
4144                         list_for_each_entry(vp, &ha->vp_list, list) {
4145                                 if (rptid_entry->vp_idx == vp->vp_idx) {
4146                                         found = 1;
4147                                         break;
4148                                 }
4149                         }
4150                         spin_unlock_irqrestore(&ha->vport_slock, flags);
4151
4152                         if (!found)
4153                                 return;
4154
4155                         qla_update_host_map(vp, id);
4156
4157                         /*
4158                          * Cannot configure here as we are still sitting on the
4159                          * response queue. Handle it in dpc context.
4160                          */
4161                         set_bit(VP_IDX_ACQUIRED, &vp->vp_flags);
4162                         set_bit(REGISTER_FC4_NEEDED, &vp->dpc_flags);
4163                         set_bit(REGISTER_FDMI_NEEDED, &vp->dpc_flags);
4164                 }
4165                 set_bit(VP_DPC_NEEDED, &vha->dpc_flags);
4166                 qla2xxx_wake_dpc(vha);
4167         } else if (rptid_entry->format == 2) {
4168                 ql_dbg(ql_dbg_async, vha, 0x505f,
4169                     "RIDA: format 2/N2N Primary port id %02x%02x%02x.\n",
4170                     rptid_entry->port_id[2], rptid_entry->port_id[1],
4171                     rptid_entry->port_id[0]);
4172
4173                 ql_dbg(ql_dbg_async, vha, 0x5075,
4174                     "N2N: Remote WWPN %8phC.\n",
4175                     rptid_entry->u.f2.port_name);
4176
4177                 /* N2N.  direct connect */
4178                 ha->current_topology = ISP_CFG_N;
4179                 ha->flags.rida_fmt2 = 1;
4180                 vha->d_id.b.domain = rptid_entry->port_id[2];
4181                 vha->d_id.b.area = rptid_entry->port_id[1];
4182                 vha->d_id.b.al_pa = rptid_entry->port_id[0];
4183
4184                 ha->flags.n2n_ae = 1;
4185                 spin_lock_irqsave(&ha->vport_slock, flags);
4186                 qla_update_vp_map(vha, SET_AL_PA);
4187                 spin_unlock_irqrestore(&ha->vport_slock, flags);
4188
4189                 list_for_each_entry(fcport, &vha->vp_fcports, list) {
4190                         fcport->scan_state = QLA_FCPORT_SCAN;
4191                         fcport->n2n_flag = 0;
4192                 }
4193
4194                 fcport = qla2x00_find_fcport_by_wwpn(vha,
4195                     rptid_entry->u.f2.port_name, 1);
4196
4197                 if (fcport) {
4198                         fcport->login_retry = vha->hw->login_retry_count;
4199                         fcport->plogi_nack_done_deadline = jiffies + HZ;
4200                         fcport->scan_state = QLA_FCPORT_FOUND;
4201                         fcport->keep_nport_handle = 1;
4202                         fcport->n2n_flag = 1;
4203                         fcport->d_id.b.domain =
4204                                 rptid_entry->u.f2.remote_nport_id[2];
4205                         fcport->d_id.b.area =
4206                                 rptid_entry->u.f2.remote_nport_id[1];
4207                         fcport->d_id.b.al_pa =
4208                                 rptid_entry->u.f2.remote_nport_id[0];
4209
4210                         /*
4211                          * For the case where remote port sending PRLO, FW
4212                          * sends up RIDA Format 2 as an indication of session
4213                          * loss. In other word, FW state change from PRLI
4214                          * complete back to PLOGI complete. Delete the
4215                          * session and let relogin drive the reconnect.
4216                          */
4217                         if (atomic_read(&fcport->state) == FCS_ONLINE)
4218                                 qlt_schedule_sess_for_deletion(fcport);
4219                 }
4220         }
4221 }
4222
4223 /*
4224  * qla24xx_modify_vp_config
4225  *      Change VP configuration for vha
4226  *
4227  * Input:
4228  *      vha = adapter block pointer.
4229  *
4230  * Returns:
4231  *      qla2xxx local function return status code.
4232  *
4233  * Context:
4234  *      Kernel context.
4235  */
4236 int
4237 qla24xx_modify_vp_config(scsi_qla_host_t *vha)
4238 {
4239         int             rval;
4240         struct vp_config_entry_24xx *vpmod;
4241         dma_addr_t      vpmod_dma;
4242         struct qla_hw_data *ha = vha->hw;
4243         struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev);
4244
4245         /* This can be called by the parent */
4246
4247         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10bb,
4248             "Entered %s.\n", __func__);
4249
4250         vpmod = dma_pool_zalloc(ha->s_dma_pool, GFP_KERNEL, &vpmod_dma);
4251         if (!vpmod) {
4252                 ql_log(ql_log_warn, vha, 0x10bc,
4253                     "Failed to allocate modify VP IOCB.\n");
4254                 return QLA_MEMORY_ALLOC_FAILED;
4255         }
4256
4257         vpmod->entry_type = VP_CONFIG_IOCB_TYPE;
4258         vpmod->entry_count = 1;
4259         vpmod->command = VCT_COMMAND_MOD_ENABLE_VPS;
4260         vpmod->vp_count = 1;
4261         vpmod->vp_index1 = vha->vp_idx;
4262         vpmod->options_idx1 = BIT_3|BIT_4|BIT_5;
4263
4264         qlt_modify_vp_config(vha, vpmod);
4265
4266         memcpy(vpmod->node_name_idx1, vha->node_name, WWN_SIZE);
4267         memcpy(vpmod->port_name_idx1, vha->port_name, WWN_SIZE);
4268         vpmod->entry_count = 1;
4269
4270         rval = qla2x00_issue_iocb(base_vha, vpmod, vpmod_dma, 0);
4271         if (rval != QLA_SUCCESS) {
4272                 ql_dbg(ql_dbg_mbx, vha, 0x10bd,
4273                     "Failed to issue VP config IOCB (%x).\n", rval);
4274         } else if (vpmod->comp_status != 0) {
4275                 ql_dbg(ql_dbg_mbx, vha, 0x10be,
4276                     "Failed to complete IOCB -- error status (%x).\n",
4277                     vpmod->comp_status);
4278                 rval = QLA_FUNCTION_FAILED;
4279         } else if (vpmod->comp_status != cpu_to_le16(CS_COMPLETE)) {
4280                 ql_dbg(ql_dbg_mbx, vha, 0x10bf,
4281                     "Failed to complete IOCB -- completion status (%x).\n",
4282                     le16_to_cpu(vpmod->comp_status));
4283                 rval = QLA_FUNCTION_FAILED;
4284         } else {
4285                 /* EMPTY */
4286                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10c0,
4287                     "Done %s.\n", __func__);
4288                 fc_vport_set_state(vha->fc_vport, FC_VPORT_INITIALIZING);
4289         }
4290         dma_pool_free(ha->s_dma_pool, vpmod, vpmod_dma);
4291
4292         return rval;
4293 }
4294
4295 /*
4296  * qla2x00_send_change_request
4297  *      Receive or disable RSCN request from fabric controller
4298  *
4299  * Input:
4300  *      ha = adapter block pointer
4301  *      format = registration format:
4302  *              0 - Reserved
4303  *              1 - Fabric detected registration
4304  *              2 - N_port detected registration
4305  *              3 - Full registration
4306  *              FF - clear registration
4307  *      vp_idx = Virtual port index
4308  *
4309  * Returns:
4310  *      qla2x00 local function return status code.
4311  *
4312  * Context:
4313  *      Kernel Context
4314  */
4315
4316 int
4317 qla2x00_send_change_request(scsi_qla_host_t *vha, uint16_t format,
4318                             uint16_t vp_idx)
4319 {
4320         int rval;
4321         mbx_cmd_t mc;
4322         mbx_cmd_t *mcp = &mc;
4323
4324         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10c7,
4325             "Entered %s.\n", __func__);
4326
4327         mcp->mb[0] = MBC_SEND_CHANGE_REQUEST;
4328         mcp->mb[1] = format;
4329         mcp->mb[9] = vp_idx;
4330         mcp->out_mb = MBX_9|MBX_1|MBX_0;
4331         mcp->in_mb = MBX_0|MBX_1;
4332         mcp->tov = MBX_TOV_SECONDS;
4333         mcp->flags = 0;
4334         rval = qla2x00_mailbox_command(vha, mcp);
4335
4336         if (rval == QLA_SUCCESS) {
4337                 if (mcp->mb[0] != MBS_COMMAND_COMPLETE) {
4338                         rval = BIT_1;
4339                 }
4340         } else
4341                 rval = BIT_1;
4342
4343         return rval;
4344 }
4345
4346 int
4347 qla2x00_dump_ram(scsi_qla_host_t *vha, dma_addr_t req_dma, uint32_t addr,
4348     uint32_t size)
4349 {
4350         int rval;
4351         mbx_cmd_t mc;
4352         mbx_cmd_t *mcp = &mc;
4353
4354         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1009,
4355             "Entered %s.\n", __func__);
4356
4357         if (MSW(addr) || IS_FWI2_CAPABLE(vha->hw)) {
4358                 mcp->mb[0] = MBC_DUMP_RISC_RAM_EXTENDED;
4359                 mcp->mb[8] = MSW(addr);
4360                 mcp->mb[10] = 0;
4361                 mcp->out_mb = MBX_10|MBX_8|MBX_0;
4362         } else {
4363                 mcp->mb[0] = MBC_DUMP_RISC_RAM;
4364                 mcp->out_mb = MBX_0;
4365         }
4366         mcp->mb[1] = LSW(addr);
4367         mcp->mb[2] = MSW(req_dma);
4368         mcp->mb[3] = LSW(req_dma);
4369         mcp->mb[6] = MSW(MSD(req_dma));
4370         mcp->mb[7] = LSW(MSD(req_dma));
4371         mcp->out_mb |= MBX_7|MBX_6|MBX_3|MBX_2|MBX_1;
4372         if (IS_FWI2_CAPABLE(vha->hw)) {
4373                 mcp->mb[4] = MSW(size);
4374                 mcp->mb[5] = LSW(size);
4375                 mcp->out_mb |= MBX_5|MBX_4;
4376         } else {
4377                 mcp->mb[4] = LSW(size);
4378                 mcp->out_mb |= MBX_4;
4379         }
4380
4381         mcp->in_mb = MBX_0;
4382         mcp->tov = MBX_TOV_SECONDS;
4383         mcp->flags = 0;
4384         rval = qla2x00_mailbox_command(vha, mcp);
4385
4386         if (rval != QLA_SUCCESS) {
4387                 ql_dbg(ql_dbg_mbx, vha, 0x1008,
4388                     "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
4389         } else {
4390                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1007,
4391                     "Done %s.\n", __func__);
4392         }
4393
4394         return rval;
4395 }
4396 /* 84XX Support **************************************************************/
4397
4398 struct cs84xx_mgmt_cmd {
4399         union {
4400                 struct verify_chip_entry_84xx req;
4401                 struct verify_chip_rsp_84xx rsp;
4402         } p;
4403 };
4404
4405 int
4406 qla84xx_verify_chip(struct scsi_qla_host *vha, uint16_t *status)
4407 {
4408         int rval, retry;
4409         struct cs84xx_mgmt_cmd *mn;
4410         dma_addr_t mn_dma;
4411         uint16_t options;
4412         unsigned long flags;
4413         struct qla_hw_data *ha = vha->hw;
4414
4415         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10c8,
4416             "Entered %s.\n", __func__);
4417
4418         mn = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &mn_dma);
4419         if (mn == NULL) {
4420                 return QLA_MEMORY_ALLOC_FAILED;
4421         }
4422
4423         /* Force Update? */
4424         options = ha->cs84xx->fw_update ? VCO_FORCE_UPDATE : 0;
4425         /* Diagnostic firmware? */
4426         /* options |= MENLO_DIAG_FW; */
4427         /* We update the firmware with only one data sequence. */
4428         options |= VCO_END_OF_DATA;
4429
4430         do {
4431                 retry = 0;
4432                 memset(mn, 0, sizeof(*mn));
4433                 mn->p.req.entry_type = VERIFY_CHIP_IOCB_TYPE;
4434                 mn->p.req.entry_count = 1;
4435                 mn->p.req.options = cpu_to_le16(options);
4436
4437                 ql_dbg(ql_dbg_mbx + ql_dbg_buffer, vha, 0x111c,
4438                     "Dump of Verify Request.\n");
4439                 ql_dump_buffer(ql_dbg_mbx + ql_dbg_buffer, vha, 0x111e,
4440                     mn, sizeof(*mn));
4441
4442                 rval = qla2x00_issue_iocb_timeout(vha, mn, mn_dma, 0, 120);
4443                 if (rval != QLA_SUCCESS) {
4444                         ql_dbg(ql_dbg_mbx, vha, 0x10cb,
4445                             "Failed to issue verify IOCB (%x).\n", rval);
4446                         goto verify_done;
4447                 }
4448
4449                 ql_dbg(ql_dbg_mbx + ql_dbg_buffer, vha, 0x1110,
4450                     "Dump of Verify Response.\n");
4451                 ql_dump_buffer(ql_dbg_mbx + ql_dbg_buffer, vha, 0x1118,
4452                     mn, sizeof(*mn));
4453
4454                 status[0] = le16_to_cpu(mn->p.rsp.comp_status);
4455                 status[1] = status[0] == CS_VCS_CHIP_FAILURE ?
4456                     le16_to_cpu(mn->p.rsp.failure_code) : 0;
4457                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10ce,
4458                     "cs=%x fc=%x.\n", status[0], status[1]);
4459
4460                 if (status[0] != CS_COMPLETE) {
4461                         rval = QLA_FUNCTION_FAILED;
4462                         if (!(options & VCO_DONT_UPDATE_FW)) {
4463                                 ql_dbg(ql_dbg_mbx, vha, 0x10cf,
4464                                     "Firmware update failed. Retrying "
4465                                     "without update firmware.\n");
4466                                 options |= VCO_DONT_UPDATE_FW;
4467                                 options &= ~VCO_FORCE_UPDATE;
4468                                 retry = 1;
4469                         }
4470                 } else {
4471                         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10d0,
4472                             "Firmware updated to %x.\n",
4473                             le32_to_cpu(mn->p.rsp.fw_ver));
4474
4475                         /* NOTE: we only update OP firmware. */
4476                         spin_lock_irqsave(&ha->cs84xx->access_lock, flags);
4477                         ha->cs84xx->op_fw_version =
4478                             le32_to_cpu(mn->p.rsp.fw_ver);
4479                         spin_unlock_irqrestore(&ha->cs84xx->access_lock,
4480                             flags);
4481                 }
4482         } while (retry);
4483
4484 verify_done:
4485         dma_pool_free(ha->s_dma_pool, mn, mn_dma);
4486
4487         if (rval != QLA_SUCCESS) {
4488                 ql_dbg(ql_dbg_mbx, vha, 0x10d1,
4489                     "Failed=%x.\n", rval);
4490         } else {
4491                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10d2,
4492                     "Done %s.\n", __func__);
4493         }
4494
4495         return rval;
4496 }
4497
4498 int
4499 qla25xx_init_req_que(struct scsi_qla_host *vha, struct req_que *req)
4500 {
4501         int rval;
4502         unsigned long flags;
4503         mbx_cmd_t mc;
4504         mbx_cmd_t *mcp = &mc;
4505         struct qla_hw_data *ha = vha->hw;
4506
4507         if (!ha->flags.fw_started)
4508                 return QLA_SUCCESS;
4509
4510         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10d3,
4511             "Entered %s.\n", __func__);
4512
4513         if (IS_SHADOW_REG_CAPABLE(ha))
4514                 req->options |= BIT_13;
4515
4516         mcp->mb[0] = MBC_INITIALIZE_MULTIQ;
4517         mcp->mb[1] = req->options;
4518         mcp->mb[2] = MSW(LSD(req->dma));
4519         mcp->mb[3] = LSW(LSD(req->dma));
4520         mcp->mb[6] = MSW(MSD(req->dma));
4521         mcp->mb[7] = LSW(MSD(req->dma));
4522         mcp->mb[5] = req->length;
4523         if (req->rsp)
4524                 mcp->mb[10] = req->rsp->id;
4525         mcp->mb[12] = req->qos;
4526         mcp->mb[11] = req->vp_idx;
4527         mcp->mb[13] = req->rid;
4528         if (IS_QLA83XX(ha) || IS_QLA27XX(ha) || IS_QLA28XX(ha))
4529                 mcp->mb[15] = 0;
4530
4531         mcp->mb[4] = req->id;
4532         /* que in ptr index */
4533         mcp->mb[8] = 0;
4534         /* que out ptr index */
4535         mcp->mb[9] = *req->out_ptr = 0;
4536         mcp->out_mb = MBX_14|MBX_13|MBX_12|MBX_11|MBX_10|MBX_9|MBX_8|MBX_7|
4537                         MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
4538         mcp->in_mb = MBX_0;
4539         mcp->flags = MBX_DMA_OUT;
4540         mcp->tov = MBX_TOV_SECONDS * 2;
4541
4542         if (IS_QLA81XX(ha) || IS_QLA83XX(ha) || IS_QLA27XX(ha) ||
4543             IS_QLA28XX(ha))
4544                 mcp->in_mb |= MBX_1;
4545         if (IS_QLA83XX(ha) || IS_QLA27XX(ha) || IS_QLA28XX(ha)) {
4546                 mcp->out_mb |= MBX_15;
4547                 /* debug q create issue in SR-IOV */
4548                 mcp->in_mb |= MBX_9 | MBX_8 | MBX_7;
4549         }
4550
4551         spin_lock_irqsave(&ha->hardware_lock, flags);
4552         if (!(req->options & BIT_0)) {
4553                 wrt_reg_dword(req->req_q_in, 0);
4554                 if (!IS_QLA83XX(ha) && !IS_QLA27XX(ha) && !IS_QLA28XX(ha))
4555                         wrt_reg_dword(req->req_q_out, 0);
4556         }
4557         spin_unlock_irqrestore(&ha->hardware_lock, flags);
4558
4559         rval = qla2x00_mailbox_command(vha, mcp);
4560         if (rval != QLA_SUCCESS) {
4561                 ql_dbg(ql_dbg_mbx, vha, 0x10d4,
4562                     "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
4563         } else {
4564                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10d5,
4565                     "Done %s.\n", __func__);
4566         }
4567
4568         return rval;
4569 }
4570
4571 int
4572 qla25xx_init_rsp_que(struct scsi_qla_host *vha, struct rsp_que *rsp)
4573 {
4574         int rval;
4575         unsigned long flags;
4576         mbx_cmd_t mc;
4577         mbx_cmd_t *mcp = &mc;
4578         struct qla_hw_data *ha = vha->hw;
4579
4580         if (!ha->flags.fw_started)
4581                 return QLA_SUCCESS;
4582
4583         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10d6,
4584             "Entered %s.\n", __func__);
4585
4586         if (IS_SHADOW_REG_CAPABLE(ha))
4587                 rsp->options |= BIT_13;
4588
4589         mcp->mb[0] = MBC_INITIALIZE_MULTIQ;
4590         mcp->mb[1] = rsp->options;
4591         mcp->mb[2] = MSW(LSD(rsp->dma));
4592         mcp->mb[3] = LSW(LSD(rsp->dma));
4593         mcp->mb[6] = MSW(MSD(rsp->dma));
4594         mcp->mb[7] = LSW(MSD(rsp->dma));
4595         mcp->mb[5] = rsp->length;
4596         mcp->mb[14] = rsp->msix->entry;
4597         mcp->mb[13] = rsp->rid;
4598         if (IS_QLA83XX(ha) || IS_QLA27XX(ha) || IS_QLA28XX(ha))
4599                 mcp->mb[15] = 0;
4600
4601         mcp->mb[4] = rsp->id;
4602         /* que in ptr index */
4603         mcp->mb[8] = *rsp->in_ptr = 0;
4604         /* que out ptr index */
4605         mcp->mb[9] = 0;
4606         mcp->out_mb = MBX_14|MBX_13|MBX_9|MBX_8|MBX_7
4607                         |MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
4608         mcp->in_mb = MBX_0;
4609         mcp->flags = MBX_DMA_OUT;
4610         mcp->tov = MBX_TOV_SECONDS * 2;
4611
4612         if (IS_QLA81XX(ha)) {
4613                 mcp->out_mb |= MBX_12|MBX_11|MBX_10;
4614                 mcp->in_mb |= MBX_1;
4615         } else if (IS_QLA83XX(ha) || IS_QLA27XX(ha) || IS_QLA28XX(ha)) {
4616                 mcp->out_mb |= MBX_15|MBX_12|MBX_11|MBX_10;
4617                 mcp->in_mb |= MBX_1;
4618                 /* debug q create issue in SR-IOV */
4619                 mcp->in_mb |= MBX_9 | MBX_8 | MBX_7;
4620         }
4621
4622         spin_lock_irqsave(&ha->hardware_lock, flags);
4623         if (!(rsp->options & BIT_0)) {
4624                 wrt_reg_dword(rsp->rsp_q_out, 0);
4625                 if (!IS_QLA83XX(ha) && !IS_QLA27XX(ha) && !IS_QLA28XX(ha))
4626                         wrt_reg_dword(rsp->rsp_q_in, 0);
4627         }
4628
4629         spin_unlock_irqrestore(&ha->hardware_lock, flags);
4630
4631         rval = qla2x00_mailbox_command(vha, mcp);
4632         if (rval != QLA_SUCCESS) {
4633                 ql_dbg(ql_dbg_mbx, vha, 0x10d7,
4634                     "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
4635         } else {
4636                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10d8,
4637                     "Done %s.\n", __func__);
4638         }
4639
4640         return rval;
4641 }
4642
4643 int
4644 qla81xx_idc_ack(scsi_qla_host_t *vha, uint16_t *mb)
4645 {
4646         int rval;
4647         mbx_cmd_t mc;
4648         mbx_cmd_t *mcp = &mc;
4649
4650         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10d9,
4651             "Entered %s.\n", __func__);
4652
4653         mcp->mb[0] = MBC_IDC_ACK;
4654         memcpy(&mcp->mb[1], mb, QLA_IDC_ACK_REGS * sizeof(uint16_t));
4655         mcp->out_mb = MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
4656         mcp->in_mb = MBX_0;
4657         mcp->tov = MBX_TOV_SECONDS;
4658         mcp->flags = 0;
4659         rval = qla2x00_mailbox_command(vha, mcp);
4660
4661         if (rval != QLA_SUCCESS) {
4662                 ql_dbg(ql_dbg_mbx, vha, 0x10da,
4663                     "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
4664         } else {
4665                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10db,
4666                     "Done %s.\n", __func__);
4667         }
4668
4669         return rval;
4670 }
4671
4672 int
4673 qla81xx_fac_get_sector_size(scsi_qla_host_t *vha, uint32_t *sector_size)
4674 {
4675         int rval;
4676         mbx_cmd_t mc;
4677         mbx_cmd_t *mcp = &mc;
4678
4679         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10dc,
4680             "Entered %s.\n", __func__);
4681
4682         if (!IS_QLA81XX(vha->hw) && !IS_QLA83XX(vha->hw) &&
4683             !IS_QLA27XX(vha->hw) && !IS_QLA28XX(vha->hw))
4684                 return QLA_FUNCTION_FAILED;
4685
4686         mcp->mb[0] = MBC_FLASH_ACCESS_CTRL;
4687         mcp->mb[1] = FAC_OPT_CMD_GET_SECTOR_SIZE;
4688         mcp->out_mb = MBX_1|MBX_0;
4689         mcp->in_mb = MBX_1|MBX_0;
4690         mcp->tov = MBX_TOV_SECONDS;
4691         mcp->flags = 0;
4692         rval = qla2x00_mailbox_command(vha, mcp);
4693
4694         if (rval != QLA_SUCCESS) {
4695                 ql_dbg(ql_dbg_mbx, vha, 0x10dd,
4696                     "Failed=%x mb[0]=%x mb[1]=%x.\n",
4697                     rval, mcp->mb[0], mcp->mb[1]);
4698         } else {
4699                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10de,
4700                     "Done %s.\n", __func__);
4701                 *sector_size = mcp->mb[1];
4702         }
4703
4704         return rval;
4705 }
4706
4707 int
4708 qla81xx_fac_do_write_enable(scsi_qla_host_t *vha, int enable)
4709 {
4710         int rval;
4711         mbx_cmd_t mc;
4712         mbx_cmd_t *mcp = &mc;
4713
4714         if (!IS_QLA81XX(vha->hw) && !IS_QLA83XX(vha->hw) &&
4715             !IS_QLA27XX(vha->hw) && !IS_QLA28XX(vha->hw))
4716                 return QLA_FUNCTION_FAILED;
4717
4718         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10df,
4719             "Entered %s.\n", __func__);
4720
4721         mcp->mb[0] = MBC_FLASH_ACCESS_CTRL;
4722         mcp->mb[1] = enable ? FAC_OPT_CMD_WRITE_ENABLE :
4723             FAC_OPT_CMD_WRITE_PROTECT;
4724         mcp->out_mb = MBX_1|MBX_0;
4725         mcp->in_mb = MBX_1|MBX_0;
4726         mcp->tov = MBX_TOV_SECONDS;
4727         mcp->flags = 0;
4728         rval = qla2x00_mailbox_command(vha, mcp);
4729
4730         if (rval != QLA_SUCCESS) {
4731                 ql_dbg(ql_dbg_mbx, vha, 0x10e0,
4732                     "Failed=%x mb[0]=%x mb[1]=%x.\n",
4733                     rval, mcp->mb[0], mcp->mb[1]);
4734         } else {
4735                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10e1,
4736                     "Done %s.\n", __func__);
4737         }
4738
4739         return rval;
4740 }
4741
4742 int
4743 qla81xx_fac_erase_sector(scsi_qla_host_t *vha, uint32_t start, uint32_t finish)
4744 {
4745         int rval;
4746         mbx_cmd_t mc;
4747         mbx_cmd_t *mcp = &mc;
4748
4749         if (!IS_QLA81XX(vha->hw) && !IS_QLA83XX(vha->hw) &&
4750             !IS_QLA27XX(vha->hw) && !IS_QLA28XX(vha->hw))
4751                 return QLA_FUNCTION_FAILED;
4752
4753         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10e2,
4754             "Entered %s.\n", __func__);
4755
4756         mcp->mb[0] = MBC_FLASH_ACCESS_CTRL;
4757         mcp->mb[1] = FAC_OPT_CMD_ERASE_SECTOR;
4758         mcp->mb[2] = LSW(start);
4759         mcp->mb[3] = MSW(start);
4760         mcp->mb[4] = LSW(finish);
4761         mcp->mb[5] = MSW(finish);
4762         mcp->out_mb = MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
4763         mcp->in_mb = MBX_2|MBX_1|MBX_0;
4764         mcp->tov = MBX_TOV_SECONDS;
4765         mcp->flags = 0;
4766         rval = qla2x00_mailbox_command(vha, mcp);
4767
4768         if (rval != QLA_SUCCESS) {
4769                 ql_dbg(ql_dbg_mbx, vha, 0x10e3,
4770                     "Failed=%x mb[0]=%x mb[1]=%x mb[2]=%x.\n",
4771                     rval, mcp->mb[0], mcp->mb[1], mcp->mb[2]);
4772         } else {
4773                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10e4,
4774                     "Done %s.\n", __func__);
4775         }
4776
4777         return rval;
4778 }
4779
4780 int
4781 qla81xx_fac_semaphore_access(scsi_qla_host_t *vha, int lock)
4782 {
4783         int rval = QLA_SUCCESS;
4784         mbx_cmd_t mc;
4785         mbx_cmd_t *mcp = &mc;
4786         struct qla_hw_data *ha = vha->hw;
4787
4788         if (!IS_QLA81XX(ha) && !IS_QLA83XX(ha) &&
4789             !IS_QLA27XX(ha) && !IS_QLA28XX(ha))
4790                 return rval;
4791
4792         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10e2,
4793             "Entered %s.\n", __func__);
4794
4795         mcp->mb[0] = MBC_FLASH_ACCESS_CTRL;
4796         mcp->mb[1] = (lock ? FAC_OPT_CMD_LOCK_SEMAPHORE :
4797             FAC_OPT_CMD_UNLOCK_SEMAPHORE);
4798         mcp->out_mb = MBX_1|MBX_0;
4799         mcp->in_mb = MBX_1|MBX_0;
4800         mcp->tov = MBX_TOV_SECONDS;
4801         mcp->flags = 0;
4802         rval = qla2x00_mailbox_command(vha, mcp);
4803
4804         if (rval != QLA_SUCCESS) {
4805                 ql_dbg(ql_dbg_mbx, vha, 0x10e3,
4806                     "Failed=%x mb[0]=%x mb[1]=%x mb[2]=%x.\n",
4807                     rval, mcp->mb[0], mcp->mb[1], mcp->mb[2]);
4808         } else {
4809                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10e4,
4810                     "Done %s.\n", __func__);
4811         }
4812
4813         return rval;
4814 }
4815
4816 int
4817 qla81xx_restart_mpi_firmware(scsi_qla_host_t *vha)
4818 {
4819         int rval = 0;
4820         mbx_cmd_t mc;
4821         mbx_cmd_t *mcp = &mc;
4822
4823         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10e5,
4824             "Entered %s.\n", __func__);
4825
4826         mcp->mb[0] = MBC_RESTART_MPI_FW;
4827         mcp->out_mb = MBX_0;
4828         mcp->in_mb = MBX_0|MBX_1;
4829         mcp->tov = MBX_TOV_SECONDS;
4830         mcp->flags = 0;
4831         rval = qla2x00_mailbox_command(vha, mcp);
4832
4833         if (rval != QLA_SUCCESS) {
4834                 ql_dbg(ql_dbg_mbx, vha, 0x10e6,
4835                     "Failed=%x mb[0]=%x mb[1]=%x.\n",
4836                     rval, mcp->mb[0], mcp->mb[1]);
4837         } else {
4838                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10e7,
4839                     "Done %s.\n", __func__);
4840         }
4841
4842         return rval;
4843 }
4844
4845 int
4846 qla82xx_set_driver_version(scsi_qla_host_t *vha, char *version)
4847 {
4848         int rval;
4849         mbx_cmd_t mc;
4850         mbx_cmd_t *mcp = &mc;
4851         int i;
4852         int len;
4853         __le16 *str;
4854         struct qla_hw_data *ha = vha->hw;
4855
4856         if (!IS_P3P_TYPE(ha))
4857                 return QLA_FUNCTION_FAILED;
4858
4859         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x117b,
4860             "Entered %s.\n", __func__);
4861
4862         str = (__force __le16 *)version;
4863         len = strlen(version);
4864
4865         mcp->mb[0] = MBC_SET_RNID_PARAMS;
4866         mcp->mb[1] = RNID_TYPE_SET_VERSION << 8;
4867         mcp->out_mb = MBX_1|MBX_0;
4868         for (i = 4; i < 16 && len; i++, str++, len -= 2) {
4869                 mcp->mb[i] = le16_to_cpup(str);
4870                 mcp->out_mb |= 1<<i;
4871         }
4872         for (; i < 16; i++) {
4873                 mcp->mb[i] = 0;
4874                 mcp->out_mb |= 1<<i;
4875         }
4876         mcp->in_mb = MBX_1|MBX_0;
4877         mcp->tov = MBX_TOV_SECONDS;
4878         mcp->flags = 0;
4879         rval = qla2x00_mailbox_command(vha, mcp);
4880
4881         if (rval != QLA_SUCCESS) {
4882                 ql_dbg(ql_dbg_mbx, vha, 0x117c,
4883                     "Failed=%x mb[0]=%x,%x.\n", rval, mcp->mb[0], mcp->mb[1]);
4884         } else {
4885                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x117d,
4886                     "Done %s.\n", __func__);
4887         }
4888
4889         return rval;
4890 }
4891
4892 int
4893 qla25xx_set_driver_version(scsi_qla_host_t *vha, char *version)
4894 {
4895         int rval;
4896         mbx_cmd_t mc;
4897         mbx_cmd_t *mcp = &mc;
4898         int len;
4899         uint16_t dwlen;
4900         uint8_t *str;
4901         dma_addr_t str_dma;
4902         struct qla_hw_data *ha = vha->hw;
4903
4904         if (!IS_FWI2_CAPABLE(ha) || IS_QLA24XX_TYPE(ha) || IS_QLA81XX(ha) ||
4905             IS_P3P_TYPE(ha))
4906                 return QLA_FUNCTION_FAILED;
4907
4908         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x117e,
4909             "Entered %s.\n", __func__);
4910
4911         str = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &str_dma);
4912         if (!str) {
4913                 ql_log(ql_log_warn, vha, 0x117f,
4914                     "Failed to allocate driver version param.\n");
4915                 return QLA_MEMORY_ALLOC_FAILED;
4916         }
4917
4918         memcpy(str, "\x7\x3\x11\x0", 4);
4919         dwlen = str[0];
4920         len = dwlen * 4 - 4;
4921         memset(str + 4, 0, len);
4922         if (len > strlen(version))
4923                 len = strlen(version);
4924         memcpy(str + 4, version, len);
4925
4926         mcp->mb[0] = MBC_SET_RNID_PARAMS;
4927         mcp->mb[1] = RNID_TYPE_SET_VERSION << 8 | dwlen;
4928         mcp->mb[2] = MSW(LSD(str_dma));
4929         mcp->mb[3] = LSW(LSD(str_dma));
4930         mcp->mb[6] = MSW(MSD(str_dma));
4931         mcp->mb[7] = LSW(MSD(str_dma));
4932         mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
4933         mcp->in_mb = MBX_1|MBX_0;
4934         mcp->tov = MBX_TOV_SECONDS;
4935         mcp->flags = 0;
4936         rval = qla2x00_mailbox_command(vha, mcp);
4937
4938         if (rval != QLA_SUCCESS) {
4939                 ql_dbg(ql_dbg_mbx, vha, 0x1180,
4940                     "Failed=%x mb[0]=%x,%x.\n", rval, mcp->mb[0], mcp->mb[1]);
4941         } else {
4942                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1181,
4943                     "Done %s.\n", __func__);
4944         }
4945
4946         dma_pool_free(ha->s_dma_pool, str, str_dma);
4947
4948         return rval;
4949 }
4950
4951 int
4952 qla24xx_get_port_login_templ(scsi_qla_host_t *vha, dma_addr_t buf_dma,
4953                              void *buf, uint16_t bufsiz)
4954 {
4955         int rval, i;
4956         mbx_cmd_t mc;
4957         mbx_cmd_t *mcp = &mc;
4958         uint32_t        *bp;
4959
4960         if (!IS_FWI2_CAPABLE(vha->hw))
4961                 return QLA_FUNCTION_FAILED;
4962
4963         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1159,
4964             "Entered %s.\n", __func__);
4965
4966         mcp->mb[0] = MBC_GET_RNID_PARAMS;
4967         mcp->mb[1] = RNID_TYPE_PORT_LOGIN << 8;
4968         mcp->mb[2] = MSW(buf_dma);
4969         mcp->mb[3] = LSW(buf_dma);
4970         mcp->mb[6] = MSW(MSD(buf_dma));
4971         mcp->mb[7] = LSW(MSD(buf_dma));
4972         mcp->mb[8] = bufsiz/4;
4973         mcp->out_mb = MBX_8|MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
4974         mcp->in_mb = MBX_1|MBX_0;
4975         mcp->tov = MBX_TOV_SECONDS;
4976         mcp->flags = 0;
4977         rval = qla2x00_mailbox_command(vha, mcp);
4978
4979         if (rval != QLA_SUCCESS) {
4980                 ql_dbg(ql_dbg_mbx, vha, 0x115a,
4981                     "Failed=%x mb[0]=%x,%x.\n", rval, mcp->mb[0], mcp->mb[1]);
4982         } else {
4983                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x115b,
4984                     "Done %s.\n", __func__);
4985                 bp = (uint32_t *) buf;
4986                 for (i = 0; i < (bufsiz-4)/4; i++, bp++)
4987                         *bp = le32_to_cpu((__force __le32)*bp);
4988         }
4989
4990         return rval;
4991 }
4992
4993 #define PUREX_CMD_COUNT 4
4994 int
4995 qla25xx_set_els_cmds_supported(scsi_qla_host_t *vha)
4996 {
4997         int rval;
4998         mbx_cmd_t mc;
4999         mbx_cmd_t *mcp = &mc;
5000         uint8_t *els_cmd_map;
5001         uint8_t active_cnt = 0;
5002         dma_addr_t els_cmd_map_dma;
5003         uint8_t cmd_opcode[PUREX_CMD_COUNT];
5004         uint8_t i, index, purex_bit;
5005         struct qla_hw_data *ha = vha->hw;
5006
5007         if (!IS_QLA25XX(ha) && !IS_QLA2031(ha) &&
5008             !IS_QLA27XX(ha) && !IS_QLA28XX(ha))
5009                 return QLA_SUCCESS;
5010
5011         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1197,
5012             "Entered %s.\n", __func__);
5013
5014         els_cmd_map = dma_alloc_coherent(&ha->pdev->dev, ELS_CMD_MAP_SIZE,
5015             &els_cmd_map_dma, GFP_KERNEL);
5016         if (!els_cmd_map) {
5017                 ql_log(ql_log_warn, vha, 0x7101,
5018                     "Failed to allocate RDP els command param.\n");
5019                 return QLA_MEMORY_ALLOC_FAILED;
5020         }
5021
5022         /* List of Purex ELS */
5023         if (ql2xrdpenable) {
5024                 cmd_opcode[active_cnt] = ELS_RDP;
5025                 active_cnt++;
5026         }
5027         if (ha->flags.scm_supported_f) {
5028                 cmd_opcode[active_cnt] = ELS_FPIN;
5029                 active_cnt++;
5030         }
5031         if (ha->flags.edif_enabled) {
5032                 cmd_opcode[active_cnt] = ELS_AUTH_ELS;
5033                 active_cnt++;
5034         }
5035
5036         for (i = 0; i < active_cnt; i++) {
5037                 index = cmd_opcode[i] / 8;
5038                 purex_bit = cmd_opcode[i] % 8;
5039                 els_cmd_map[index] |= 1 << purex_bit;
5040         }
5041
5042         mcp->mb[0] = MBC_SET_RNID_PARAMS;
5043         mcp->mb[1] = RNID_TYPE_ELS_CMD << 8;
5044         mcp->mb[2] = MSW(LSD(els_cmd_map_dma));
5045         mcp->mb[3] = LSW(LSD(els_cmd_map_dma));
5046         mcp->mb[6] = MSW(MSD(els_cmd_map_dma));
5047         mcp->mb[7] = LSW(MSD(els_cmd_map_dma));
5048         mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
5049         mcp->in_mb = MBX_1|MBX_0;
5050         mcp->tov = MBX_TOV_SECONDS;
5051         mcp->flags = MBX_DMA_OUT;
5052         mcp->buf_size = ELS_CMD_MAP_SIZE;
5053         rval = qla2x00_mailbox_command(vha, mcp);
5054
5055         if (rval != QLA_SUCCESS) {
5056                 ql_dbg(ql_dbg_mbx, vha, 0x118d,
5057                     "Failed=%x (%x,%x).\n", rval, mcp->mb[0], mcp->mb[1]);
5058         } else {
5059                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x118c,
5060                     "Done %s.\n", __func__);
5061         }
5062
5063         dma_free_coherent(&ha->pdev->dev, ELS_CMD_MAP_SIZE,
5064            els_cmd_map, els_cmd_map_dma);
5065
5066         return rval;
5067 }
5068
5069 static int
5070 qla2x00_read_asic_temperature(scsi_qla_host_t *vha, uint16_t *temp)
5071 {
5072         int rval;
5073         mbx_cmd_t mc;
5074         mbx_cmd_t *mcp = &mc;
5075
5076         if (!IS_FWI2_CAPABLE(vha->hw))
5077                 return QLA_FUNCTION_FAILED;
5078
5079         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1159,
5080             "Entered %s.\n", __func__);
5081
5082         mcp->mb[0] = MBC_GET_RNID_PARAMS;
5083         mcp->mb[1] = RNID_TYPE_ASIC_TEMP << 8;
5084         mcp->out_mb = MBX_1|MBX_0;
5085         mcp->in_mb = MBX_1|MBX_0;
5086         mcp->tov = MBX_TOV_SECONDS;
5087         mcp->flags = 0;
5088         rval = qla2x00_mailbox_command(vha, mcp);
5089         *temp = mcp->mb[1];
5090
5091         if (rval != QLA_SUCCESS) {
5092                 ql_dbg(ql_dbg_mbx, vha, 0x115a,
5093                     "Failed=%x mb[0]=%x,%x.\n", rval, mcp->mb[0], mcp->mb[1]);
5094         } else {
5095                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x115b,
5096                     "Done %s.\n", __func__);
5097         }
5098
5099         return rval;
5100 }
5101
5102 int
5103 qla2x00_read_sfp(scsi_qla_host_t *vha, dma_addr_t sfp_dma, uint8_t *sfp,
5104         uint16_t dev, uint16_t off, uint16_t len, uint16_t opt)
5105 {
5106         int rval;
5107         mbx_cmd_t mc;
5108         mbx_cmd_t *mcp = &mc;
5109         struct qla_hw_data *ha = vha->hw;
5110
5111         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10e8,
5112             "Entered %s.\n", __func__);
5113
5114         if (!IS_FWI2_CAPABLE(ha))
5115                 return QLA_FUNCTION_FAILED;
5116
5117         if (len == 1)
5118                 opt |= BIT_0;
5119
5120         mcp->mb[0] = MBC_READ_SFP;
5121         mcp->mb[1] = dev;
5122         mcp->mb[2] = MSW(LSD(sfp_dma));
5123         mcp->mb[3] = LSW(LSD(sfp_dma));
5124         mcp->mb[6] = MSW(MSD(sfp_dma));
5125         mcp->mb[7] = LSW(MSD(sfp_dma));
5126         mcp->mb[8] = len;
5127         mcp->mb[9] = off;
5128         mcp->mb[10] = opt;
5129         mcp->out_mb = MBX_10|MBX_9|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
5130         mcp->in_mb = MBX_1|MBX_0;
5131         mcp->tov = MBX_TOV_SECONDS;
5132         mcp->flags = 0;
5133         rval = qla2x00_mailbox_command(vha, mcp);
5134
5135         if (opt & BIT_0)
5136                 *sfp = mcp->mb[1];
5137
5138         if (rval != QLA_SUCCESS) {
5139                 ql_dbg(ql_dbg_mbx, vha, 0x10e9,
5140                     "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
5141                 if (mcp->mb[0] == MBS_COMMAND_ERROR && mcp->mb[1] == 0x22) {
5142                         /* sfp is not there */
5143                         rval = QLA_INTERFACE_ERROR;
5144                 }
5145         } else {
5146                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10ea,
5147                     "Done %s.\n", __func__);
5148         }
5149
5150         return rval;
5151 }
5152
5153 int
5154 qla2x00_write_sfp(scsi_qla_host_t *vha, dma_addr_t sfp_dma, uint8_t *sfp,
5155         uint16_t dev, uint16_t off, uint16_t len, uint16_t opt)
5156 {
5157         int rval;
5158         mbx_cmd_t mc;
5159         mbx_cmd_t *mcp = &mc;
5160         struct qla_hw_data *ha = vha->hw;
5161
5162         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10eb,
5163             "Entered %s.\n", __func__);
5164
5165         if (!IS_FWI2_CAPABLE(ha))
5166                 return QLA_FUNCTION_FAILED;
5167
5168         if (len == 1)
5169                 opt |= BIT_0;
5170
5171         if (opt & BIT_0)
5172                 len = *sfp;
5173
5174         mcp->mb[0] = MBC_WRITE_SFP;
5175         mcp->mb[1] = dev;
5176         mcp->mb[2] = MSW(LSD(sfp_dma));
5177         mcp->mb[3] = LSW(LSD(sfp_dma));
5178         mcp->mb[6] = MSW(MSD(sfp_dma));
5179         mcp->mb[7] = LSW(MSD(sfp_dma));
5180         mcp->mb[8] = len;
5181         mcp->mb[9] = off;
5182         mcp->mb[10] = opt;
5183         mcp->out_mb = MBX_10|MBX_9|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
5184         mcp->in_mb = MBX_1|MBX_0;
5185         mcp->tov = MBX_TOV_SECONDS;
5186         mcp->flags = 0;
5187         rval = qla2x00_mailbox_command(vha, mcp);
5188
5189         if (rval != QLA_SUCCESS) {
5190                 ql_dbg(ql_dbg_mbx, vha, 0x10ec,
5191                     "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
5192         } else {
5193                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10ed,
5194                     "Done %s.\n", __func__);
5195         }
5196
5197         return rval;
5198 }
5199
5200 int
5201 qla2x00_get_xgmac_stats(scsi_qla_host_t *vha, dma_addr_t stats_dma,
5202     uint16_t size_in_bytes, uint16_t *actual_size)
5203 {
5204         int rval;
5205         mbx_cmd_t mc;
5206         mbx_cmd_t *mcp = &mc;
5207
5208         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10ee,
5209             "Entered %s.\n", __func__);
5210
5211         if (!IS_CNA_CAPABLE(vha->hw))
5212                 return QLA_FUNCTION_FAILED;
5213
5214         mcp->mb[0] = MBC_GET_XGMAC_STATS;
5215         mcp->mb[2] = MSW(stats_dma);
5216         mcp->mb[3] = LSW(stats_dma);
5217         mcp->mb[6] = MSW(MSD(stats_dma));
5218         mcp->mb[7] = LSW(MSD(stats_dma));
5219         mcp->mb[8] = size_in_bytes >> 2;
5220         mcp->out_mb = MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_0;
5221         mcp->in_mb = MBX_2|MBX_1|MBX_0;
5222         mcp->tov = MBX_TOV_SECONDS;
5223         mcp->flags = 0;
5224         rval = qla2x00_mailbox_command(vha, mcp);
5225
5226         if (rval != QLA_SUCCESS) {
5227                 ql_dbg(ql_dbg_mbx, vha, 0x10ef,
5228                     "Failed=%x mb[0]=%x mb[1]=%x mb[2]=%x.\n",
5229                     rval, mcp->mb[0], mcp->mb[1], mcp->mb[2]);
5230         } else {
5231                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10f0,
5232                     "Done %s.\n", __func__);
5233
5234
5235                 *actual_size = mcp->mb[2] << 2;
5236         }
5237
5238         return rval;
5239 }
5240
5241 int
5242 qla2x00_get_dcbx_params(scsi_qla_host_t *vha, dma_addr_t tlv_dma,
5243     uint16_t size)
5244 {
5245         int rval;
5246         mbx_cmd_t mc;
5247         mbx_cmd_t *mcp = &mc;
5248
5249         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10f1,
5250             "Entered %s.\n", __func__);
5251
5252         if (!IS_CNA_CAPABLE(vha->hw))
5253                 return QLA_FUNCTION_FAILED;
5254
5255         mcp->mb[0] = MBC_GET_DCBX_PARAMS;
5256         mcp->mb[1] = 0;
5257         mcp->mb[2] = MSW(tlv_dma);
5258         mcp->mb[3] = LSW(tlv_dma);
5259         mcp->mb[6] = MSW(MSD(tlv_dma));
5260         mcp->mb[7] = LSW(MSD(tlv_dma));
5261         mcp->mb[8] = size;
5262         mcp->out_mb = MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
5263         mcp->in_mb = MBX_2|MBX_1|MBX_0;
5264         mcp->tov = MBX_TOV_SECONDS;
5265         mcp->flags = 0;
5266         rval = qla2x00_mailbox_command(vha, mcp);
5267
5268         if (rval != QLA_SUCCESS) {
5269                 ql_dbg(ql_dbg_mbx, vha, 0x10f2,
5270                     "Failed=%x mb[0]=%x mb[1]=%x mb[2]=%x.\n",
5271                     rval, mcp->mb[0], mcp->mb[1], mcp->mb[2]);
5272         } else {
5273                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10f3,
5274                     "Done %s.\n", __func__);
5275         }
5276
5277         return rval;
5278 }
5279
5280 int
5281 qla2x00_read_ram_word(scsi_qla_host_t *vha, uint32_t risc_addr, uint32_t *data)
5282 {
5283         int rval;
5284         mbx_cmd_t mc;
5285         mbx_cmd_t *mcp = &mc;
5286
5287         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10f4,
5288             "Entered %s.\n", __func__);
5289
5290         if (!IS_FWI2_CAPABLE(vha->hw))
5291                 return QLA_FUNCTION_FAILED;
5292
5293         mcp->mb[0] = MBC_READ_RAM_EXTENDED;
5294         mcp->mb[1] = LSW(risc_addr);
5295         mcp->mb[8] = MSW(risc_addr);
5296         mcp->out_mb = MBX_8|MBX_1|MBX_0;
5297         mcp->in_mb = MBX_3|MBX_2|MBX_0;
5298         mcp->tov = MBX_TOV_SECONDS;
5299         mcp->flags = 0;
5300         rval = qla2x00_mailbox_command(vha, mcp);
5301         if (rval != QLA_SUCCESS) {
5302                 ql_dbg(ql_dbg_mbx, vha, 0x10f5,
5303                     "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
5304         } else {
5305                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10f6,
5306                     "Done %s.\n", __func__);
5307                 *data = mcp->mb[3] << 16 | mcp->mb[2];
5308         }
5309
5310         return rval;
5311 }
5312
5313 int
5314 qla2x00_loopback_test(scsi_qla_host_t *vha, struct msg_echo_lb *mreq,
5315         uint16_t *mresp)
5316 {
5317         int rval;
5318         mbx_cmd_t mc;
5319         mbx_cmd_t *mcp = &mc;
5320
5321         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10f7,
5322             "Entered %s.\n", __func__);
5323
5324         memset(mcp->mb, 0 , sizeof(mcp->mb));
5325         mcp->mb[0] = MBC_DIAGNOSTIC_LOOP_BACK;
5326         mcp->mb[1] = mreq->options | BIT_6;     // BIT_6 specifies 64 bit addressing
5327
5328         /* transfer count */
5329         mcp->mb[10] = LSW(mreq->transfer_size);
5330         mcp->mb[11] = MSW(mreq->transfer_size);
5331
5332         /* send data address */
5333         mcp->mb[14] = LSW(mreq->send_dma);
5334         mcp->mb[15] = MSW(mreq->send_dma);
5335         mcp->mb[20] = LSW(MSD(mreq->send_dma));
5336         mcp->mb[21] = MSW(MSD(mreq->send_dma));
5337
5338         /* receive data address */
5339         mcp->mb[16] = LSW(mreq->rcv_dma);
5340         mcp->mb[17] = MSW(mreq->rcv_dma);
5341         mcp->mb[6] = LSW(MSD(mreq->rcv_dma));
5342         mcp->mb[7] = MSW(MSD(mreq->rcv_dma));
5343
5344         /* Iteration count */
5345         mcp->mb[18] = LSW(mreq->iteration_count);
5346         mcp->mb[19] = MSW(mreq->iteration_count);
5347
5348         mcp->out_mb = MBX_21|MBX_20|MBX_19|MBX_18|MBX_17|MBX_16|MBX_15|
5349             MBX_14|MBX_13|MBX_12|MBX_11|MBX_10|MBX_7|MBX_6|MBX_1|MBX_0;
5350         if (IS_CNA_CAPABLE(vha->hw))
5351                 mcp->out_mb |= MBX_2;
5352         mcp->in_mb = MBX_19|MBX_18|MBX_3|MBX_2|MBX_1|MBX_0;
5353
5354         mcp->buf_size = mreq->transfer_size;
5355         mcp->tov = MBX_TOV_SECONDS;
5356         mcp->flags = MBX_DMA_OUT|MBX_DMA_IN|IOCTL_CMD;
5357
5358         rval = qla2x00_mailbox_command(vha, mcp);
5359
5360         if (rval != QLA_SUCCESS) {
5361                 ql_dbg(ql_dbg_mbx, vha, 0x10f8,
5362                     "Failed=%x mb[0]=%x mb[1]=%x mb[2]=%x mb[3]=%x mb[18]=%x "
5363                     "mb[19]=%x.\n", rval, mcp->mb[0], mcp->mb[1], mcp->mb[2],
5364                     mcp->mb[3], mcp->mb[18], mcp->mb[19]);
5365         } else {
5366                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10f9,
5367                     "Done %s.\n", __func__);
5368         }
5369
5370         /* Copy mailbox information */
5371         memcpy( mresp, mcp->mb, 64);
5372         return rval;
5373 }
5374
5375 int
5376 qla2x00_echo_test(scsi_qla_host_t *vha, struct msg_echo_lb *mreq,
5377         uint16_t *mresp)
5378 {
5379         int rval;
5380         mbx_cmd_t mc;
5381         mbx_cmd_t *mcp = &mc;
5382         struct qla_hw_data *ha = vha->hw;
5383
5384         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10fa,
5385             "Entered %s.\n", __func__);
5386
5387         memset(mcp->mb, 0 , sizeof(mcp->mb));
5388         mcp->mb[0] = MBC_DIAGNOSTIC_ECHO;
5389         /* BIT_6 specifies 64bit address */
5390         mcp->mb[1] = mreq->options | BIT_15 | BIT_6;
5391         if (IS_CNA_CAPABLE(ha)) {
5392                 mcp->mb[2] = vha->fcoe_fcf_idx;
5393         }
5394         mcp->mb[16] = LSW(mreq->rcv_dma);
5395         mcp->mb[17] = MSW(mreq->rcv_dma);
5396         mcp->mb[6] = LSW(MSD(mreq->rcv_dma));
5397         mcp->mb[7] = MSW(MSD(mreq->rcv_dma));
5398
5399         mcp->mb[10] = LSW(mreq->transfer_size);
5400
5401         mcp->mb[14] = LSW(mreq->send_dma);
5402         mcp->mb[15] = MSW(mreq->send_dma);
5403         mcp->mb[20] = LSW(MSD(mreq->send_dma));
5404         mcp->mb[21] = MSW(MSD(mreq->send_dma));
5405
5406         mcp->out_mb = MBX_21|MBX_20|MBX_17|MBX_16|MBX_15|
5407             MBX_14|MBX_10|MBX_7|MBX_6|MBX_1|MBX_0;
5408         if (IS_CNA_CAPABLE(ha))
5409                 mcp->out_mb |= MBX_2;
5410
5411         mcp->in_mb = MBX_0;
5412         if (IS_CNA_CAPABLE(ha) || IS_QLA24XX_TYPE(ha) || IS_QLA25XX(ha) ||
5413             IS_QLA2031(ha) || IS_QLA27XX(ha) || IS_QLA28XX(ha))
5414                 mcp->in_mb |= MBX_1;
5415         if (IS_CNA_CAPABLE(ha) || IS_QLA2031(ha) || IS_QLA27XX(ha) ||
5416             IS_QLA28XX(ha))
5417                 mcp->in_mb |= MBX_3;
5418
5419         mcp->tov = MBX_TOV_SECONDS;
5420         mcp->flags = MBX_DMA_OUT|MBX_DMA_IN|IOCTL_CMD;
5421         mcp->buf_size = mreq->transfer_size;
5422
5423         rval = qla2x00_mailbox_command(vha, mcp);
5424
5425         if (rval != QLA_SUCCESS) {
5426                 ql_dbg(ql_dbg_mbx, vha, 0x10fb,
5427                     "Failed=%x mb[0]=%x mb[1]=%x.\n",
5428                     rval, mcp->mb[0], mcp->mb[1]);
5429         } else {
5430                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10fc,
5431                     "Done %s.\n", __func__);
5432         }
5433
5434         /* Copy mailbox information */
5435         memcpy(mresp, mcp->mb, 64);
5436         return rval;
5437 }
5438
5439 int
5440 qla84xx_reset_chip(scsi_qla_host_t *vha, uint16_t enable_diagnostic)
5441 {
5442         int rval;
5443         mbx_cmd_t mc;
5444         mbx_cmd_t *mcp = &mc;
5445
5446         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10fd,
5447             "Entered %s enable_diag=%d.\n", __func__, enable_diagnostic);
5448
5449         mcp->mb[0] = MBC_ISP84XX_RESET;
5450         mcp->mb[1] = enable_diagnostic;
5451         mcp->out_mb = MBX_1|MBX_0;
5452         mcp->in_mb = MBX_1|MBX_0;
5453         mcp->tov = MBX_TOV_SECONDS;
5454         mcp->flags = MBX_DMA_OUT|MBX_DMA_IN|IOCTL_CMD;
5455         rval = qla2x00_mailbox_command(vha, mcp);
5456
5457         if (rval != QLA_SUCCESS)
5458                 ql_dbg(ql_dbg_mbx, vha, 0x10fe, "Failed=%x.\n", rval);
5459         else
5460                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10ff,
5461                     "Done %s.\n", __func__);
5462
5463         return rval;
5464 }
5465
5466 int
5467 qla2x00_write_ram_word(scsi_qla_host_t *vha, uint32_t risc_addr, uint32_t data)
5468 {
5469         int rval;
5470         mbx_cmd_t mc;
5471         mbx_cmd_t *mcp = &mc;
5472
5473         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1100,
5474             "Entered %s.\n", __func__);
5475
5476         if (!IS_FWI2_CAPABLE(vha->hw))
5477                 return QLA_FUNCTION_FAILED;
5478
5479         mcp->mb[0] = MBC_WRITE_RAM_WORD_EXTENDED;
5480         mcp->mb[1] = LSW(risc_addr);
5481         mcp->mb[2] = LSW(data);
5482         mcp->mb[3] = MSW(data);
5483         mcp->mb[8] = MSW(risc_addr);
5484         mcp->out_mb = MBX_8|MBX_3|MBX_2|MBX_1|MBX_0;
5485         mcp->in_mb = MBX_1|MBX_0;
5486         mcp->tov = MBX_TOV_SECONDS;
5487         mcp->flags = 0;
5488         rval = qla2x00_mailbox_command(vha, mcp);
5489         if (rval != QLA_SUCCESS) {
5490                 ql_dbg(ql_dbg_mbx, vha, 0x1101,
5491                     "Failed=%x mb[0]=%x mb[1]=%x.\n",
5492                     rval, mcp->mb[0], mcp->mb[1]);
5493         } else {
5494                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1102,
5495                     "Done %s.\n", __func__);
5496         }
5497
5498         return rval;
5499 }
5500
5501 int
5502 qla81xx_write_mpi_register(scsi_qla_host_t *vha, uint16_t *mb)
5503 {
5504         int rval;
5505         uint32_t stat, timer;
5506         uint16_t mb0 = 0;
5507         struct qla_hw_data *ha = vha->hw;
5508         struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
5509
5510         rval = QLA_SUCCESS;
5511
5512         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1103,
5513             "Entered %s.\n", __func__);
5514
5515         clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
5516
5517         /* Write the MBC data to the registers */
5518         wrt_reg_word(&reg->mailbox0, MBC_WRITE_MPI_REGISTER);
5519         wrt_reg_word(&reg->mailbox1, mb[0]);
5520         wrt_reg_word(&reg->mailbox2, mb[1]);
5521         wrt_reg_word(&reg->mailbox3, mb[2]);
5522         wrt_reg_word(&reg->mailbox4, mb[3]);
5523
5524         wrt_reg_dword(&reg->hccr, HCCRX_SET_HOST_INT);
5525
5526         /* Poll for MBC interrupt */
5527         for (timer = 6000000; timer; timer--) {
5528                 /* Check for pending interrupts. */
5529                 stat = rd_reg_dword(&reg->host_status);
5530                 if (stat & HSRX_RISC_INT) {
5531                         stat &= 0xff;
5532
5533                         if (stat == 0x1 || stat == 0x2 ||
5534                             stat == 0x10 || stat == 0x11) {
5535                                 set_bit(MBX_INTERRUPT,
5536                                     &ha->mbx_cmd_flags);
5537                                 mb0 = rd_reg_word(&reg->mailbox0);
5538                                 wrt_reg_dword(&reg->hccr,
5539                                     HCCRX_CLR_RISC_INT);
5540                                 rd_reg_dword(&reg->hccr);
5541                                 break;
5542                         }
5543                 }
5544                 udelay(5);
5545         }
5546
5547         if (test_and_clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags))
5548                 rval = mb0 & MBS_MASK;
5549         else
5550                 rval = QLA_FUNCTION_FAILED;
5551
5552         if (rval != QLA_SUCCESS) {
5553                 ql_dbg(ql_dbg_mbx, vha, 0x1104,
5554                     "Failed=%x mb[0]=%x.\n", rval, mb[0]);
5555         } else {
5556                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1105,
5557                     "Done %s.\n", __func__);
5558         }
5559
5560         return rval;
5561 }
5562
5563 /* Set the specified data rate */
5564 int
5565 qla2x00_set_data_rate(scsi_qla_host_t *vha, uint16_t mode)
5566 {
5567         int rval;
5568         mbx_cmd_t mc;
5569         mbx_cmd_t *mcp = &mc;
5570         struct qla_hw_data *ha = vha->hw;
5571         uint16_t val;
5572
5573         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1106,
5574             "Entered %s speed:0x%x mode:0x%x.\n", __func__, ha->set_data_rate,
5575             mode);
5576
5577         if (!IS_FWI2_CAPABLE(ha))
5578                 return QLA_FUNCTION_FAILED;
5579
5580         memset(mcp, 0, sizeof(*mcp));
5581         switch (ha->set_data_rate) {
5582         case PORT_SPEED_AUTO:
5583         case PORT_SPEED_4GB:
5584         case PORT_SPEED_8GB:
5585         case PORT_SPEED_16GB:
5586         case PORT_SPEED_32GB:
5587                 val = ha->set_data_rate;
5588                 break;
5589         default:
5590                 ql_log(ql_log_warn, vha, 0x1199,
5591                     "Unrecognized speed setting:%d. Setting Autoneg\n",
5592                     ha->set_data_rate);
5593                 val = ha->set_data_rate = PORT_SPEED_AUTO;
5594                 break;
5595         }
5596
5597         mcp->mb[0] = MBC_DATA_RATE;
5598         mcp->mb[1] = mode;
5599         mcp->mb[2] = val;
5600
5601         mcp->out_mb = MBX_2|MBX_1|MBX_0;
5602         mcp->in_mb = MBX_2|MBX_1|MBX_0;
5603         if (IS_QLA83XX(ha) || IS_QLA27XX(ha) || IS_QLA28XX(ha))
5604                 mcp->in_mb |= MBX_4|MBX_3;
5605         mcp->tov = MBX_TOV_SECONDS;
5606         mcp->flags = 0;
5607         rval = qla2x00_mailbox_command(vha, mcp);
5608         if (rval != QLA_SUCCESS) {
5609                 ql_dbg(ql_dbg_mbx, vha, 0x1107,
5610                     "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
5611         } else {
5612                 if (mcp->mb[1] != 0x7)
5613                         ql_dbg(ql_dbg_mbx, vha, 0x1179,
5614                                 "Speed set:0x%x\n", mcp->mb[1]);
5615
5616                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1108,
5617                     "Done %s.\n", __func__);
5618         }
5619
5620         return rval;
5621 }
5622
5623 int
5624 qla2x00_get_data_rate(scsi_qla_host_t *vha)
5625 {
5626         int rval;
5627         mbx_cmd_t mc;
5628         mbx_cmd_t *mcp = &mc;
5629         struct qla_hw_data *ha = vha->hw;
5630
5631         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1106,
5632             "Entered %s.\n", __func__);
5633
5634         if (!IS_FWI2_CAPABLE(ha))
5635                 return QLA_FUNCTION_FAILED;
5636
5637         mcp->mb[0] = MBC_DATA_RATE;
5638         mcp->mb[1] = QLA_GET_DATA_RATE;
5639         mcp->out_mb = MBX_1|MBX_0;
5640         mcp->in_mb = MBX_2|MBX_1|MBX_0;
5641         if (IS_QLA83XX(ha) || IS_QLA27XX(ha) || IS_QLA28XX(ha))
5642                 mcp->in_mb |= MBX_4|MBX_3;
5643         mcp->tov = MBX_TOV_SECONDS;
5644         mcp->flags = 0;
5645         rval = qla2x00_mailbox_command(vha, mcp);
5646         if (rval != QLA_SUCCESS) {
5647                 ql_dbg(ql_dbg_mbx, vha, 0x1107,
5648                     "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
5649         } else {
5650                 if (mcp->mb[1] != 0x7)
5651                         ha->link_data_rate = mcp->mb[1];
5652
5653                 if (IS_QLA83XX(ha) || IS_QLA27XX(ha) || IS_QLA28XX(ha)) {
5654                         if (mcp->mb[4] & BIT_0)
5655                                 ql_log(ql_log_info, vha, 0x11a2,
5656                                     "FEC=enabled (data rate).\n");
5657                 }
5658
5659                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1108,
5660                     "Done %s.\n", __func__);
5661                 if (mcp->mb[1] != 0x7)
5662                         ha->link_data_rate = mcp->mb[1];
5663         }
5664
5665         return rval;
5666 }
5667
5668 int
5669 qla81xx_get_port_config(scsi_qla_host_t *vha, uint16_t *mb)
5670 {
5671         int rval;
5672         mbx_cmd_t mc;
5673         mbx_cmd_t *mcp = &mc;
5674         struct qla_hw_data *ha = vha->hw;
5675
5676         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1109,
5677             "Entered %s.\n", __func__);
5678
5679         if (!IS_QLA81XX(ha) && !IS_QLA83XX(ha) && !IS_QLA8044(ha) &&
5680             !IS_QLA27XX(ha) && !IS_QLA28XX(ha))
5681                 return QLA_FUNCTION_FAILED;
5682         mcp->mb[0] = MBC_GET_PORT_CONFIG;
5683         mcp->out_mb = MBX_0;
5684         mcp->in_mb = MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
5685         mcp->tov = MBX_TOV_SECONDS;
5686         mcp->flags = 0;
5687
5688         rval = qla2x00_mailbox_command(vha, mcp);
5689
5690         if (rval != QLA_SUCCESS) {
5691                 ql_dbg(ql_dbg_mbx, vha, 0x110a,
5692                     "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
5693         } else {
5694                 /* Copy all bits to preserve original value */
5695                 memcpy(mb, &mcp->mb[1], sizeof(uint16_t) * 4);
5696
5697                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x110b,
5698                     "Done %s.\n", __func__);
5699         }
5700         return rval;
5701 }
5702
5703 int
5704 qla81xx_set_port_config(scsi_qla_host_t *vha, uint16_t *mb)
5705 {
5706         int rval;
5707         mbx_cmd_t mc;
5708         mbx_cmd_t *mcp = &mc;
5709
5710         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x110c,
5711             "Entered %s.\n", __func__);
5712
5713         mcp->mb[0] = MBC_SET_PORT_CONFIG;
5714         /* Copy all bits to preserve original setting */
5715         memcpy(&mcp->mb[1], mb, sizeof(uint16_t) * 4);
5716         mcp->out_mb = MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
5717         mcp->in_mb = MBX_0;
5718         mcp->tov = MBX_TOV_SECONDS;
5719         mcp->flags = 0;
5720         rval = qla2x00_mailbox_command(vha, mcp);
5721
5722         if (rval != QLA_SUCCESS) {
5723                 ql_dbg(ql_dbg_mbx, vha, 0x110d,
5724                     "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
5725         } else
5726                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x110e,
5727                     "Done %s.\n", __func__);
5728
5729         return rval;
5730 }
5731
5732
5733 int
5734 qla24xx_set_fcp_prio(scsi_qla_host_t *vha, uint16_t loop_id, uint16_t priority,
5735                 uint16_t *mb)
5736 {
5737         int rval;
5738         mbx_cmd_t mc;
5739         mbx_cmd_t *mcp = &mc;
5740         struct qla_hw_data *ha = vha->hw;
5741
5742         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x110f,
5743             "Entered %s.\n", __func__);
5744
5745         if (!IS_QLA24XX_TYPE(ha) && !IS_QLA25XX(ha))
5746                 return QLA_FUNCTION_FAILED;
5747
5748         mcp->mb[0] = MBC_PORT_PARAMS;
5749         mcp->mb[1] = loop_id;
5750         if (ha->flags.fcp_prio_enabled)
5751                 mcp->mb[2] = BIT_1;
5752         else
5753                 mcp->mb[2] = BIT_2;
5754         mcp->mb[4] = priority & 0xf;
5755         mcp->mb[9] = vha->vp_idx;
5756         mcp->out_mb = MBX_9|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
5757         mcp->in_mb = MBX_4|MBX_3|MBX_1|MBX_0;
5758         mcp->tov = MBX_TOV_SECONDS;
5759         mcp->flags = 0;
5760         rval = qla2x00_mailbox_command(vha, mcp);
5761         if (mb != NULL) {
5762                 mb[0] = mcp->mb[0];
5763                 mb[1] = mcp->mb[1];
5764                 mb[3] = mcp->mb[3];
5765                 mb[4] = mcp->mb[4];
5766         }
5767
5768         if (rval != QLA_SUCCESS) {
5769                 ql_dbg(ql_dbg_mbx, vha, 0x10cd, "Failed=%x.\n", rval);
5770         } else {
5771                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10cc,
5772                     "Done %s.\n", __func__);
5773         }
5774
5775         return rval;
5776 }
5777
5778 int
5779 qla2x00_get_thermal_temp(scsi_qla_host_t *vha, uint16_t *temp)
5780 {
5781         int rval = QLA_FUNCTION_FAILED;
5782         struct qla_hw_data *ha = vha->hw;
5783         uint8_t byte;
5784
5785         if (!IS_FWI2_CAPABLE(ha) || IS_QLA24XX_TYPE(ha) || IS_QLA81XX(ha)) {
5786                 ql_dbg(ql_dbg_mbx, vha, 0x1150,
5787                     "Thermal not supported by this card.\n");
5788                 return rval;
5789         }
5790
5791         if (IS_QLA25XX(ha)) {
5792                 if (ha->pdev->subsystem_vendor == PCI_VENDOR_ID_QLOGIC &&
5793                     ha->pdev->subsystem_device == 0x0175) {
5794                         rval = qla2x00_read_sfp(vha, 0, &byte,
5795                             0x98, 0x1, 1, BIT_13|BIT_0);
5796                         *temp = byte;
5797                         return rval;
5798                 }
5799                 if (ha->pdev->subsystem_vendor == PCI_VENDOR_ID_HP &&
5800                     ha->pdev->subsystem_device == 0x338e) {
5801                         rval = qla2x00_read_sfp(vha, 0, &byte,
5802                             0x98, 0x1, 1, BIT_15|BIT_14|BIT_0);
5803                         *temp = byte;
5804                         return rval;
5805                 }
5806                 ql_dbg(ql_dbg_mbx, vha, 0x10c9,
5807                     "Thermal not supported by this card.\n");
5808                 return rval;
5809         }
5810
5811         if (IS_QLA82XX(ha)) {
5812                 *temp = qla82xx_read_temperature(vha);
5813                 rval = QLA_SUCCESS;
5814                 return rval;
5815         } else if (IS_QLA8044(ha)) {
5816                 *temp = qla8044_read_temperature(vha);
5817                 rval = QLA_SUCCESS;
5818                 return rval;
5819         }
5820
5821         rval = qla2x00_read_asic_temperature(vha, temp);
5822         return rval;
5823 }
5824
5825 int
5826 qla82xx_mbx_intr_enable(scsi_qla_host_t *vha)
5827 {
5828         int rval;
5829         struct qla_hw_data *ha = vha->hw;
5830         mbx_cmd_t mc;
5831         mbx_cmd_t *mcp = &mc;
5832
5833         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1017,
5834             "Entered %s.\n", __func__);
5835
5836         if (!IS_FWI2_CAPABLE(ha))
5837                 return QLA_FUNCTION_FAILED;
5838
5839         memset(mcp, 0, sizeof(mbx_cmd_t));
5840         mcp->mb[0] = MBC_TOGGLE_INTERRUPT;
5841         mcp->mb[1] = 1;
5842
5843         mcp->out_mb = MBX_1|MBX_0;
5844         mcp->in_mb = MBX_0;
5845         mcp->tov = MBX_TOV_SECONDS;
5846         mcp->flags = 0;
5847
5848         rval = qla2x00_mailbox_command(vha, mcp);
5849         if (rval != QLA_SUCCESS) {
5850                 ql_dbg(ql_dbg_mbx, vha, 0x1016,
5851                     "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
5852         } else {
5853                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x100e,
5854                     "Done %s.\n", __func__);
5855         }
5856
5857         return rval;
5858 }
5859
5860 int
5861 qla82xx_mbx_intr_disable(scsi_qla_host_t *vha)
5862 {
5863         int rval;
5864         struct qla_hw_data *ha = vha->hw;
5865         mbx_cmd_t mc;
5866         mbx_cmd_t *mcp = &mc;
5867
5868         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x100d,
5869             "Entered %s.\n", __func__);
5870
5871         if (!IS_P3P_TYPE(ha))
5872                 return QLA_FUNCTION_FAILED;
5873
5874         memset(mcp, 0, sizeof(mbx_cmd_t));
5875         mcp->mb[0] = MBC_TOGGLE_INTERRUPT;
5876         mcp->mb[1] = 0;
5877
5878         mcp->out_mb = MBX_1|MBX_0;
5879         mcp->in_mb = MBX_0;
5880         mcp->tov = MBX_TOV_SECONDS;
5881         mcp->flags = 0;
5882
5883         rval = qla2x00_mailbox_command(vha, mcp);
5884         if (rval != QLA_SUCCESS) {
5885                 ql_dbg(ql_dbg_mbx, vha, 0x100c,
5886                     "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
5887         } else {
5888                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x100b,
5889                     "Done %s.\n", __func__);
5890         }
5891
5892         return rval;
5893 }
5894
5895 int
5896 qla82xx_md_get_template_size(scsi_qla_host_t *vha)
5897 {
5898         struct qla_hw_data *ha = vha->hw;
5899         mbx_cmd_t mc;
5900         mbx_cmd_t *mcp = &mc;
5901         int rval = QLA_FUNCTION_FAILED;
5902
5903         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x111f,
5904             "Entered %s.\n", __func__);
5905
5906         memset(mcp->mb, 0 , sizeof(mcp->mb));
5907         mcp->mb[0] = LSW(MBC_DIAGNOSTIC_MINIDUMP_TEMPLATE);
5908         mcp->mb[1] = MSW(MBC_DIAGNOSTIC_MINIDUMP_TEMPLATE);
5909         mcp->mb[2] = LSW(RQST_TMPLT_SIZE);
5910         mcp->mb[3] = MSW(RQST_TMPLT_SIZE);
5911
5912         mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
5913         mcp->in_mb = MBX_14|MBX_13|MBX_12|MBX_11|MBX_10|MBX_9|MBX_8|
5914             MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
5915
5916         mcp->flags = MBX_DMA_OUT|MBX_DMA_IN|IOCTL_CMD;
5917         mcp->tov = MBX_TOV_SECONDS;
5918         rval = qla2x00_mailbox_command(vha, mcp);
5919
5920         /* Always copy back return mailbox values. */
5921         if (rval != QLA_SUCCESS) {
5922                 ql_dbg(ql_dbg_mbx, vha, 0x1120,
5923                     "mailbox command FAILED=0x%x, subcode=%x.\n",
5924                     (mcp->mb[1] << 16) | mcp->mb[0],
5925                     (mcp->mb[3] << 16) | mcp->mb[2]);
5926         } else {
5927                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1121,
5928                     "Done %s.\n", __func__);
5929                 ha->md_template_size = ((mcp->mb[3] << 16) | mcp->mb[2]);
5930                 if (!ha->md_template_size) {
5931                         ql_dbg(ql_dbg_mbx, vha, 0x1122,
5932                             "Null template size obtained.\n");
5933                         rval = QLA_FUNCTION_FAILED;
5934                 }
5935         }
5936         return rval;
5937 }
5938
5939 int
5940 qla82xx_md_get_template(scsi_qla_host_t *vha)
5941 {
5942         struct qla_hw_data *ha = vha->hw;
5943         mbx_cmd_t mc;
5944         mbx_cmd_t *mcp = &mc;
5945         int rval = QLA_FUNCTION_FAILED;
5946
5947         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1123,
5948             "Entered %s.\n", __func__);
5949
5950         ha->md_tmplt_hdr = dma_alloc_coherent(&ha->pdev->dev,
5951            ha->md_template_size, &ha->md_tmplt_hdr_dma, GFP_KERNEL);
5952         if (!ha->md_tmplt_hdr) {
5953                 ql_log(ql_log_warn, vha, 0x1124,
5954                     "Unable to allocate memory for Minidump template.\n");
5955                 return rval;
5956         }
5957
5958         memset(mcp->mb, 0 , sizeof(mcp->mb));
5959         mcp->mb[0] = LSW(MBC_DIAGNOSTIC_MINIDUMP_TEMPLATE);
5960         mcp->mb[1] = MSW(MBC_DIAGNOSTIC_MINIDUMP_TEMPLATE);
5961         mcp->mb[2] = LSW(RQST_TMPLT);
5962         mcp->mb[3] = MSW(RQST_TMPLT);
5963         mcp->mb[4] = LSW(LSD(ha->md_tmplt_hdr_dma));
5964         mcp->mb[5] = MSW(LSD(ha->md_tmplt_hdr_dma));
5965         mcp->mb[6] = LSW(MSD(ha->md_tmplt_hdr_dma));
5966         mcp->mb[7] = MSW(MSD(ha->md_tmplt_hdr_dma));
5967         mcp->mb[8] = LSW(ha->md_template_size);
5968         mcp->mb[9] = MSW(ha->md_template_size);
5969
5970         mcp->flags = MBX_DMA_OUT|MBX_DMA_IN|IOCTL_CMD;
5971         mcp->tov = MBX_TOV_SECONDS;
5972         mcp->out_mb = MBX_11|MBX_10|MBX_9|MBX_8|
5973             MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
5974         mcp->in_mb = MBX_3|MBX_2|MBX_1|MBX_0;
5975         rval = qla2x00_mailbox_command(vha, mcp);
5976
5977         if (rval != QLA_SUCCESS) {
5978                 ql_dbg(ql_dbg_mbx, vha, 0x1125,
5979                     "mailbox command FAILED=0x%x, subcode=%x.\n",
5980                     ((mcp->mb[1] << 16) | mcp->mb[0]),
5981                     ((mcp->mb[3] << 16) | mcp->mb[2]));
5982         } else
5983                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1126,
5984                     "Done %s.\n", __func__);
5985         return rval;
5986 }
5987
5988 int
5989 qla8044_md_get_template(scsi_qla_host_t *vha)
5990 {
5991         struct qla_hw_data *ha = vha->hw;
5992         mbx_cmd_t mc;
5993         mbx_cmd_t *mcp = &mc;
5994         int rval = QLA_FUNCTION_FAILED;
5995         int offset = 0, size = MINIDUMP_SIZE_36K;
5996
5997         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0xb11f,
5998             "Entered %s.\n", __func__);
5999
6000         ha->md_tmplt_hdr = dma_alloc_coherent(&ha->pdev->dev,
6001            ha->md_template_size, &ha->md_tmplt_hdr_dma, GFP_KERNEL);
6002         if (!ha->md_tmplt_hdr) {
6003                 ql_log(ql_log_warn, vha, 0xb11b,
6004                     "Unable to allocate memory for Minidump template.\n");
6005                 return rval;
6006         }
6007
6008         memset(mcp->mb, 0 , sizeof(mcp->mb));
6009         while (offset < ha->md_template_size) {
6010                 mcp->mb[0] = LSW(MBC_DIAGNOSTIC_MINIDUMP_TEMPLATE);
6011                 mcp->mb[1] = MSW(MBC_DIAGNOSTIC_MINIDUMP_TEMPLATE);
6012                 mcp->mb[2] = LSW(RQST_TMPLT);
6013                 mcp->mb[3] = MSW(RQST_TMPLT);
6014                 mcp->mb[4] = LSW(LSD(ha->md_tmplt_hdr_dma + offset));
6015                 mcp->mb[5] = MSW(LSD(ha->md_tmplt_hdr_dma + offset));
6016                 mcp->mb[6] = LSW(MSD(ha->md_tmplt_hdr_dma + offset));
6017                 mcp->mb[7] = MSW(MSD(ha->md_tmplt_hdr_dma + offset));
6018                 mcp->mb[8] = LSW(size);
6019                 mcp->mb[9] = MSW(size);
6020                 mcp->mb[10] = offset & 0x0000FFFF;
6021                 mcp->mb[11] = offset & 0xFFFF0000;
6022                 mcp->flags = MBX_DMA_OUT|MBX_DMA_IN|IOCTL_CMD;
6023                 mcp->tov = MBX_TOV_SECONDS;
6024                 mcp->out_mb = MBX_11|MBX_10|MBX_9|MBX_8|
6025                         MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
6026                 mcp->in_mb = MBX_3|MBX_2|MBX_1|MBX_0;
6027                 rval = qla2x00_mailbox_command(vha, mcp);
6028
6029                 if (rval != QLA_SUCCESS) {
6030                         ql_dbg(ql_dbg_mbx, vha, 0xb11c,
6031                                 "mailbox command FAILED=0x%x, subcode=%x.\n",
6032                                 ((mcp->mb[1] << 16) | mcp->mb[0]),
6033                                 ((mcp->mb[3] << 16) | mcp->mb[2]));
6034                         return rval;
6035                 } else
6036                         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0xb11d,
6037                                 "Done %s.\n", __func__);
6038                 offset = offset + size;
6039         }
6040         return rval;
6041 }
6042
6043 int
6044 qla81xx_set_led_config(scsi_qla_host_t *vha, uint16_t *led_cfg)
6045 {
6046         int rval;
6047         struct qla_hw_data *ha = vha->hw;
6048         mbx_cmd_t mc;
6049         mbx_cmd_t *mcp = &mc;
6050
6051         if (!IS_QLA81XX(ha) && !IS_QLA8031(ha))
6052                 return QLA_FUNCTION_FAILED;
6053
6054         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1133,
6055             "Entered %s.\n", __func__);
6056
6057         memset(mcp, 0, sizeof(mbx_cmd_t));
6058         mcp->mb[0] = MBC_SET_LED_CONFIG;
6059         mcp->mb[1] = led_cfg[0];
6060         mcp->mb[2] = led_cfg[1];
6061         if (IS_QLA8031(ha)) {
6062                 mcp->mb[3] = led_cfg[2];
6063                 mcp->mb[4] = led_cfg[3];
6064                 mcp->mb[5] = led_cfg[4];
6065                 mcp->mb[6] = led_cfg[5];
6066         }
6067
6068         mcp->out_mb = MBX_2|MBX_1|MBX_0;
6069         if (IS_QLA8031(ha))
6070                 mcp->out_mb |= MBX_6|MBX_5|MBX_4|MBX_3;
6071         mcp->in_mb = MBX_0;
6072         mcp->tov = MBX_TOV_SECONDS;
6073         mcp->flags = 0;
6074
6075         rval = qla2x00_mailbox_command(vha, mcp);
6076         if (rval != QLA_SUCCESS) {
6077                 ql_dbg(ql_dbg_mbx, vha, 0x1134,
6078                     "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
6079         } else {
6080                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1135,
6081                     "Done %s.\n", __func__);
6082         }
6083
6084         return rval;
6085 }
6086
6087 int
6088 qla81xx_get_led_config(scsi_qla_host_t *vha, uint16_t *led_cfg)
6089 {
6090         int rval;
6091         struct qla_hw_data *ha = vha->hw;
6092         mbx_cmd_t mc;
6093         mbx_cmd_t *mcp = &mc;
6094
6095         if (!IS_QLA81XX(ha) && !IS_QLA8031(ha))
6096                 return QLA_FUNCTION_FAILED;
6097
6098         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1136,
6099             "Entered %s.\n", __func__);
6100
6101         memset(mcp, 0, sizeof(mbx_cmd_t));
6102         mcp->mb[0] = MBC_GET_LED_CONFIG;
6103
6104         mcp->out_mb = MBX_0;
6105         mcp->in_mb = MBX_2|MBX_1|MBX_0;
6106         if (IS_QLA8031(ha))
6107                 mcp->in_mb |= MBX_6|MBX_5|MBX_4|MBX_3;
6108         mcp->tov = MBX_TOV_SECONDS;
6109         mcp->flags = 0;
6110
6111         rval = qla2x00_mailbox_command(vha, mcp);
6112         if (rval != QLA_SUCCESS) {
6113                 ql_dbg(ql_dbg_mbx, vha, 0x1137,
6114                     "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
6115         } else {
6116                 led_cfg[0] = mcp->mb[1];
6117                 led_cfg[1] = mcp->mb[2];
6118                 if (IS_QLA8031(ha)) {
6119                         led_cfg[2] = mcp->mb[3];
6120                         led_cfg[3] = mcp->mb[4];
6121                         led_cfg[4] = mcp->mb[5];
6122                         led_cfg[5] = mcp->mb[6];
6123                 }
6124                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1138,
6125                     "Done %s.\n", __func__);
6126         }
6127
6128         return rval;
6129 }
6130
6131 int
6132 qla82xx_mbx_beacon_ctl(scsi_qla_host_t *vha, int enable)
6133 {
6134         int rval;
6135         struct qla_hw_data *ha = vha->hw;
6136         mbx_cmd_t mc;
6137         mbx_cmd_t *mcp = &mc;
6138
6139         if (!IS_P3P_TYPE(ha))
6140                 return QLA_FUNCTION_FAILED;
6141
6142         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1127,
6143                 "Entered %s.\n", __func__);
6144
6145         memset(mcp, 0, sizeof(mbx_cmd_t));
6146         mcp->mb[0] = MBC_SET_LED_CONFIG;
6147         if (enable)
6148                 mcp->mb[7] = 0xE;
6149         else
6150                 mcp->mb[7] = 0xD;
6151
6152         mcp->out_mb = MBX_7|MBX_0;
6153         mcp->in_mb = MBX_0;
6154         mcp->tov = MBX_TOV_SECONDS;
6155         mcp->flags = 0;
6156
6157         rval = qla2x00_mailbox_command(vha, mcp);
6158         if (rval != QLA_SUCCESS) {
6159                 ql_dbg(ql_dbg_mbx, vha, 0x1128,
6160                     "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
6161         } else {
6162                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1129,
6163                     "Done %s.\n", __func__);
6164         }
6165
6166         return rval;
6167 }
6168
6169 int
6170 qla83xx_wr_reg(scsi_qla_host_t *vha, uint32_t reg, uint32_t data)
6171 {
6172         int rval;
6173         struct qla_hw_data *ha = vha->hw;
6174         mbx_cmd_t mc;
6175         mbx_cmd_t *mcp = &mc;
6176
6177         if (!IS_QLA83XX(ha) && !IS_QLA27XX(ha) && !IS_QLA28XX(ha))
6178                 return QLA_FUNCTION_FAILED;
6179
6180         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1130,
6181             "Entered %s.\n", __func__);
6182
6183         mcp->mb[0] = MBC_WRITE_REMOTE_REG;
6184         mcp->mb[1] = LSW(reg);
6185         mcp->mb[2] = MSW(reg);
6186         mcp->mb[3] = LSW(data);
6187         mcp->mb[4] = MSW(data);
6188         mcp->out_mb = MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
6189
6190         mcp->in_mb = MBX_1|MBX_0;
6191         mcp->tov = MBX_TOV_SECONDS;
6192         mcp->flags = 0;
6193         rval = qla2x00_mailbox_command(vha, mcp);
6194
6195         if (rval != QLA_SUCCESS) {
6196                 ql_dbg(ql_dbg_mbx, vha, 0x1131,
6197                     "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
6198         } else {
6199                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1132,
6200                     "Done %s.\n", __func__);
6201         }
6202
6203         return rval;
6204 }
6205
6206 int
6207 qla2x00_port_logout(scsi_qla_host_t *vha, struct fc_port *fcport)
6208 {
6209         int rval;
6210         struct qla_hw_data *ha = vha->hw;
6211         mbx_cmd_t mc;
6212         mbx_cmd_t *mcp = &mc;
6213
6214         if (IS_QLA2100(ha) || IS_QLA2200(ha)) {
6215                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x113b,
6216                     "Implicit LOGO Unsupported.\n");
6217                 return QLA_FUNCTION_FAILED;
6218         }
6219
6220
6221         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x113c,
6222             "Entering %s.\n",  __func__);
6223
6224         /* Perform Implicit LOGO. */
6225         mcp->mb[0] = MBC_PORT_LOGOUT;
6226         mcp->mb[1] = fcport->loop_id;
6227         mcp->mb[10] = BIT_15;
6228         mcp->out_mb = MBX_10|MBX_1|MBX_0;
6229         mcp->in_mb = MBX_0;
6230         mcp->tov = MBX_TOV_SECONDS;
6231         mcp->flags = 0;
6232         rval = qla2x00_mailbox_command(vha, mcp);
6233         if (rval != QLA_SUCCESS)
6234                 ql_dbg(ql_dbg_mbx, vha, 0x113d,
6235                     "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
6236         else
6237                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x113e,
6238                     "Done %s.\n", __func__);
6239
6240         return rval;
6241 }
6242
6243 int
6244 qla83xx_rd_reg(scsi_qla_host_t *vha, uint32_t reg, uint32_t *data)
6245 {
6246         int rval;
6247         mbx_cmd_t mc;
6248         mbx_cmd_t *mcp = &mc;
6249         struct qla_hw_data *ha = vha->hw;
6250         unsigned long retry_max_time = jiffies + (2 * HZ);
6251
6252         if (!IS_QLA83XX(ha) && !IS_QLA27XX(ha) && !IS_QLA28XX(ha))
6253                 return QLA_FUNCTION_FAILED;
6254
6255         ql_dbg(ql_dbg_mbx, vha, 0x114b, "Entered %s.\n", __func__);
6256
6257 retry_rd_reg:
6258         mcp->mb[0] = MBC_READ_REMOTE_REG;
6259         mcp->mb[1] = LSW(reg);
6260         mcp->mb[2] = MSW(reg);
6261         mcp->out_mb = MBX_2|MBX_1|MBX_0;
6262         mcp->in_mb = MBX_4|MBX_3|MBX_1|MBX_0;
6263         mcp->tov = MBX_TOV_SECONDS;
6264         mcp->flags = 0;
6265         rval = qla2x00_mailbox_command(vha, mcp);
6266
6267         if (rval != QLA_SUCCESS) {
6268                 ql_dbg(ql_dbg_mbx, vha, 0x114c,
6269                     "Failed=%x mb[0]=%x mb[1]=%x.\n",
6270                     rval, mcp->mb[0], mcp->mb[1]);
6271         } else {
6272                 *data = (mcp->mb[3] | (mcp->mb[4] << 16));
6273                 if (*data == QLA8XXX_BAD_VALUE) {
6274                         /*
6275                          * During soft-reset CAMRAM register reads might
6276                          * return 0xbad0bad0. So retry for MAX of 2 sec
6277                          * while reading camram registers.
6278                          */
6279                         if (time_after(jiffies, retry_max_time)) {
6280                                 ql_dbg(ql_dbg_mbx, vha, 0x1141,
6281                                     "Failure to read CAMRAM register. "
6282                                     "data=0x%x.\n", *data);
6283                                 return QLA_FUNCTION_FAILED;
6284                         }
6285                         msleep(100);
6286                         goto retry_rd_reg;
6287                 }
6288                 ql_dbg(ql_dbg_mbx, vha, 0x1142, "Done %s.\n", __func__);
6289         }
6290
6291         return rval;
6292 }
6293
6294 int
6295 qla83xx_restart_nic_firmware(scsi_qla_host_t *vha)
6296 {
6297         int rval;
6298         mbx_cmd_t mc;
6299         mbx_cmd_t *mcp = &mc;
6300         struct qla_hw_data *ha = vha->hw;
6301
6302         if (!IS_QLA83XX(ha))
6303                 return QLA_FUNCTION_FAILED;
6304
6305         ql_dbg(ql_dbg_mbx, vha, 0x1143, "Entered %s.\n", __func__);
6306
6307         mcp->mb[0] = MBC_RESTART_NIC_FIRMWARE;
6308         mcp->out_mb = MBX_0;
6309         mcp->in_mb = MBX_1|MBX_0;
6310         mcp->tov = MBX_TOV_SECONDS;
6311         mcp->flags = 0;
6312         rval = qla2x00_mailbox_command(vha, mcp);
6313
6314         if (rval != QLA_SUCCESS) {
6315                 ql_dbg(ql_dbg_mbx, vha, 0x1144,
6316                     "Failed=%x mb[0]=%x mb[1]=%x.\n",
6317                     rval, mcp->mb[0], mcp->mb[1]);
6318                 qla2xxx_dump_fw(vha);
6319         } else {
6320                 ql_dbg(ql_dbg_mbx, vha, 0x1145, "Done %s.\n", __func__);
6321         }
6322
6323         return rval;
6324 }
6325
6326 int
6327 qla83xx_access_control(scsi_qla_host_t *vha, uint16_t options,
6328         uint32_t start_addr, uint32_t end_addr, uint16_t *sector_size)
6329 {
6330         int rval;
6331         mbx_cmd_t mc;
6332         mbx_cmd_t *mcp = &mc;
6333         uint8_t subcode = (uint8_t)options;
6334         struct qla_hw_data *ha = vha->hw;
6335
6336         if (!IS_QLA8031(ha))
6337                 return QLA_FUNCTION_FAILED;
6338
6339         ql_dbg(ql_dbg_mbx, vha, 0x1146, "Entered %s.\n", __func__);
6340
6341         mcp->mb[0] = MBC_SET_ACCESS_CONTROL;
6342         mcp->mb[1] = options;
6343         mcp->out_mb = MBX_1|MBX_0;
6344         if (subcode & BIT_2) {
6345                 mcp->mb[2] = LSW(start_addr);
6346                 mcp->mb[3] = MSW(start_addr);
6347                 mcp->mb[4] = LSW(end_addr);
6348                 mcp->mb[5] = MSW(end_addr);
6349                 mcp->out_mb |= MBX_5|MBX_4|MBX_3|MBX_2;
6350         }
6351         mcp->in_mb = MBX_2|MBX_1|MBX_0;
6352         if (!(subcode & (BIT_2 | BIT_5)))
6353                 mcp->in_mb |= MBX_4|MBX_3;
6354         mcp->tov = MBX_TOV_SECONDS;
6355         mcp->flags = 0;
6356         rval = qla2x00_mailbox_command(vha, mcp);
6357
6358         if (rval != QLA_SUCCESS) {
6359                 ql_dbg(ql_dbg_mbx, vha, 0x1147,
6360                     "Failed=%x mb[0]=%x mb[1]=%x mb[2]=%x mb[3]=%x mb[4]=%x.\n",
6361                     rval, mcp->mb[0], mcp->mb[1], mcp->mb[2], mcp->mb[3],
6362                     mcp->mb[4]);
6363                 qla2xxx_dump_fw(vha);
6364         } else {
6365                 if (subcode & BIT_5)
6366                         *sector_size = mcp->mb[1];
6367                 else if (subcode & (BIT_6 | BIT_7)) {
6368                         ql_dbg(ql_dbg_mbx, vha, 0x1148,
6369                             "Driver-lock id=%x%x", mcp->mb[4], mcp->mb[3]);
6370                 } else if (subcode & (BIT_3 | BIT_4)) {
6371                         ql_dbg(ql_dbg_mbx, vha, 0x1149,
6372                             "Flash-lock id=%x%x", mcp->mb[4], mcp->mb[3]);
6373                 }
6374                 ql_dbg(ql_dbg_mbx, vha, 0x114a, "Done %s.\n", __func__);
6375         }
6376
6377         return rval;
6378 }
6379
6380 int
6381 qla2x00_dump_mctp_data(scsi_qla_host_t *vha, dma_addr_t req_dma, uint32_t addr,
6382         uint32_t size)
6383 {
6384         int rval;
6385         mbx_cmd_t mc;
6386         mbx_cmd_t *mcp = &mc;
6387
6388         if (!IS_MCTP_CAPABLE(vha->hw))
6389                 return QLA_FUNCTION_FAILED;
6390
6391         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x114f,
6392             "Entered %s.\n", __func__);
6393
6394         mcp->mb[0] = MBC_DUMP_RISC_RAM_EXTENDED;
6395         mcp->mb[1] = LSW(addr);
6396         mcp->mb[2] = MSW(req_dma);
6397         mcp->mb[3] = LSW(req_dma);
6398         mcp->mb[4] = MSW(size);
6399         mcp->mb[5] = LSW(size);
6400         mcp->mb[6] = MSW(MSD(req_dma));
6401         mcp->mb[7] = LSW(MSD(req_dma));
6402         mcp->mb[8] = MSW(addr);
6403         /* Setting RAM ID to valid */
6404         /* For MCTP RAM ID is 0x40 */
6405         mcp->mb[10] = BIT_7 | 0x40;
6406
6407         mcp->out_mb |= MBX_10|MBX_8|MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|
6408             MBX_0;
6409
6410         mcp->in_mb = MBX_0;
6411         mcp->tov = MBX_TOV_SECONDS;
6412         mcp->flags = 0;
6413         rval = qla2x00_mailbox_command(vha, mcp);
6414
6415         if (rval != QLA_SUCCESS) {
6416                 ql_dbg(ql_dbg_mbx, vha, 0x114e,
6417                     "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
6418         } else {
6419                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x114d,
6420                     "Done %s.\n", __func__);
6421         }
6422
6423         return rval;
6424 }
6425
6426 int
6427 qla26xx_dport_diagnostics(scsi_qla_host_t *vha,
6428         void *dd_buf, uint size, uint options)
6429 {
6430         int rval;
6431         mbx_cmd_t mc;
6432         mbx_cmd_t *mcp = &mc;
6433         dma_addr_t dd_dma;
6434
6435         if (!IS_QLA83XX(vha->hw) && !IS_QLA27XX(vha->hw) &&
6436             !IS_QLA28XX(vha->hw))
6437                 return QLA_FUNCTION_FAILED;
6438
6439         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x119f,
6440             "Entered %s.\n", __func__);
6441
6442         dd_dma = dma_map_single(&vha->hw->pdev->dev,
6443             dd_buf, size, DMA_FROM_DEVICE);
6444         if (dma_mapping_error(&vha->hw->pdev->dev, dd_dma)) {
6445                 ql_log(ql_log_warn, vha, 0x1194, "Failed to map dma buffer.\n");
6446                 return QLA_MEMORY_ALLOC_FAILED;
6447         }
6448
6449         memset(dd_buf, 0, size);
6450
6451         mcp->mb[0] = MBC_DPORT_DIAGNOSTICS;
6452         mcp->mb[1] = options;
6453         mcp->mb[2] = MSW(LSD(dd_dma));
6454         mcp->mb[3] = LSW(LSD(dd_dma));
6455         mcp->mb[6] = MSW(MSD(dd_dma));
6456         mcp->mb[7] = LSW(MSD(dd_dma));
6457         mcp->mb[8] = size;
6458         mcp->out_mb = MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
6459         mcp->in_mb = MBX_3|MBX_2|MBX_1|MBX_0;
6460         mcp->buf_size = size;
6461         mcp->flags = MBX_DMA_IN;
6462         mcp->tov = MBX_TOV_SECONDS * 4;
6463         rval = qla2x00_mailbox_command(vha, mcp);
6464
6465         if (rval != QLA_SUCCESS) {
6466                 ql_dbg(ql_dbg_mbx, vha, 0x1195, "Failed=%x.\n", rval);
6467         } else {
6468                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1196,
6469                     "Done %s.\n", __func__);
6470         }
6471
6472         dma_unmap_single(&vha->hw->pdev->dev, dd_dma,
6473             size, DMA_FROM_DEVICE);
6474
6475         return rval;
6476 }
6477
6478 int
6479 qla26xx_dport_diagnostics_v2(scsi_qla_host_t *vha,
6480                              struct qla_dport_diag_v2 *dd,  mbx_cmd_t *mcp)
6481 {
6482         int rval;
6483         dma_addr_t dd_dma;
6484         uint size = sizeof(dd->buf);
6485         uint16_t options = dd->options;
6486
6487         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x119f,
6488                "Entered %s.\n", __func__);
6489
6490         dd_dma = dma_map_single(&vha->hw->pdev->dev,
6491                                 dd->buf, size, DMA_FROM_DEVICE);
6492         if (dma_mapping_error(&vha->hw->pdev->dev, dd_dma)) {
6493                 ql_log(ql_log_warn, vha, 0x1194,
6494                        "Failed to map dma buffer.\n");
6495                 return QLA_MEMORY_ALLOC_FAILED;
6496         }
6497
6498         memset(dd->buf, 0, size);
6499
6500         mcp->mb[0] = MBC_DPORT_DIAGNOSTICS;
6501         mcp->mb[1] = options;
6502         mcp->mb[2] = MSW(LSD(dd_dma));
6503         mcp->mb[3] = LSW(LSD(dd_dma));
6504         mcp->mb[6] = MSW(MSD(dd_dma));
6505         mcp->mb[7] = LSW(MSD(dd_dma));
6506         mcp->mb[8] = size;
6507         mcp->out_mb = MBX_8 | MBX_7 | MBX_6 | MBX_3 | MBX_2 | MBX_1 | MBX_0;
6508         mcp->in_mb = MBX_3 | MBX_2 | MBX_1 | MBX_0;
6509         mcp->buf_size = size;
6510         mcp->flags = MBX_DMA_IN;
6511         mcp->tov = MBX_TOV_SECONDS * 4;
6512         rval = qla2x00_mailbox_command(vha, mcp);
6513
6514         if (rval != QLA_SUCCESS) {
6515                 ql_dbg(ql_dbg_mbx, vha, 0x1195, "Failed=%x.\n", rval);
6516         } else {
6517                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1196,
6518                        "Done %s.\n", __func__);
6519         }
6520
6521         dma_unmap_single(&vha->hw->pdev->dev, dd_dma, size, DMA_FROM_DEVICE);
6522
6523         return rval;
6524 }
6525
6526 static void qla2x00_async_mb_sp_done(srb_t *sp, int res)
6527 {
6528         sp->u.iocb_cmd.u.mbx.rc = res;
6529
6530         complete(&sp->u.iocb_cmd.u.mbx.comp);
6531         /* don't free sp here. Let the caller do the free */
6532 }
6533
6534 /*
6535  * This mailbox uses the iocb interface to send MB command.
6536  * This allows non-critial (non chip setup) command to go
6537  * out in parrallel.
6538  */
6539 int qla24xx_send_mb_cmd(struct scsi_qla_host *vha, mbx_cmd_t *mcp)
6540 {
6541         int rval = QLA_FUNCTION_FAILED;
6542         srb_t *sp;
6543         struct srb_iocb *c;
6544
6545         if (!vha->hw->flags.fw_started)
6546                 goto done;
6547
6548         /* ref: INIT */
6549         sp = qla2x00_get_sp(vha, NULL, GFP_KERNEL);
6550         if (!sp)
6551                 goto done;
6552
6553         c = &sp->u.iocb_cmd;
6554         init_completion(&c->u.mbx.comp);
6555
6556         sp->type = SRB_MB_IOCB;
6557         sp->name = mb_to_str(mcp->mb[0]);
6558         qla2x00_init_async_sp(sp, qla2x00_get_async_timeout(vha) + 2,
6559                               qla2x00_async_mb_sp_done);
6560
6561         memcpy(sp->u.iocb_cmd.u.mbx.out_mb, mcp->mb, SIZEOF_IOCB_MB_REG);
6562
6563         rval = qla2x00_start_sp(sp);
6564         if (rval != QLA_SUCCESS) {
6565                 ql_dbg(ql_dbg_mbx, vha, 0x1018,
6566                     "%s: %s Failed submission. %x.\n",
6567                     __func__, sp->name, rval);
6568                 goto done_free_sp;
6569         }
6570
6571         ql_dbg(ql_dbg_mbx, vha, 0x113f, "MB:%s hndl %x submitted\n",
6572             sp->name, sp->handle);
6573
6574         wait_for_completion(&c->u.mbx.comp);
6575         memcpy(mcp->mb, sp->u.iocb_cmd.u.mbx.in_mb, SIZEOF_IOCB_MB_REG);
6576
6577         rval = c->u.mbx.rc;
6578         switch (rval) {
6579         case QLA_FUNCTION_TIMEOUT:
6580                 ql_dbg(ql_dbg_mbx, vha, 0x1140, "%s: %s Timeout. %x.\n",
6581                     __func__, sp->name, rval);
6582                 break;
6583         case  QLA_SUCCESS:
6584                 ql_dbg(ql_dbg_mbx, vha, 0x119d, "%s: %s done.\n",
6585                     __func__, sp->name);
6586                 break;
6587         default:
6588                 ql_dbg(ql_dbg_mbx, vha, 0x119e, "%s: %s Failed. %x.\n",
6589                     __func__, sp->name, rval);
6590                 break;
6591         }
6592
6593 done_free_sp:
6594         /* ref: INIT */
6595         kref_put(&sp->cmd_kref, qla2x00_sp_release);
6596 done:
6597         return rval;
6598 }
6599
6600 /*
6601  * qla24xx_gpdb_wait
6602  * NOTE: Do not call this routine from DPC thread
6603  */
6604 int qla24xx_gpdb_wait(struct scsi_qla_host *vha, fc_port_t *fcport, u8 opt)
6605 {
6606         int rval = QLA_FUNCTION_FAILED;
6607         dma_addr_t pd_dma;
6608         struct port_database_24xx *pd;
6609         struct qla_hw_data *ha = vha->hw;
6610         mbx_cmd_t mc;
6611
6612         if (!vha->hw->flags.fw_started)
6613                 goto done;
6614
6615         pd = dma_pool_zalloc(ha->s_dma_pool, GFP_KERNEL, &pd_dma);
6616         if (pd  == NULL) {
6617                 ql_log(ql_log_warn, vha, 0xd047,
6618                     "Failed to allocate port database structure.\n");
6619                 goto done_free_sp;
6620         }
6621
6622         memset(&mc, 0, sizeof(mc));
6623         mc.mb[0] = MBC_GET_PORT_DATABASE;
6624         mc.mb[1] = fcport->loop_id;
6625         mc.mb[2] = MSW(pd_dma);
6626         mc.mb[3] = LSW(pd_dma);
6627         mc.mb[6] = MSW(MSD(pd_dma));
6628         mc.mb[7] = LSW(MSD(pd_dma));
6629         mc.mb[9] = vha->vp_idx;
6630         mc.mb[10] = opt;
6631
6632         rval = qla24xx_send_mb_cmd(vha, &mc);
6633         if (rval != QLA_SUCCESS) {
6634                 ql_dbg(ql_dbg_mbx, vha, 0x1193,
6635                     "%s: %8phC fail\n", __func__, fcport->port_name);
6636                 goto done_free_sp;
6637         }
6638
6639         rval = __qla24xx_parse_gpdb(vha, fcport, pd);
6640
6641         ql_dbg(ql_dbg_mbx, vha, 0x1197, "%s: %8phC done\n",
6642             __func__, fcport->port_name);
6643
6644 done_free_sp:
6645         if (pd)
6646                 dma_pool_free(ha->s_dma_pool, pd, pd_dma);
6647 done:
6648         return rval;
6649 }
6650
6651 int __qla24xx_parse_gpdb(struct scsi_qla_host *vha, fc_port_t *fcport,
6652     struct port_database_24xx *pd)
6653 {
6654         int rval = QLA_SUCCESS;
6655         uint64_t zero = 0;
6656         u8 current_login_state, last_login_state;
6657
6658         if (NVME_TARGET(vha->hw, fcport)) {
6659                 current_login_state = pd->current_login_state >> 4;
6660                 last_login_state = pd->last_login_state >> 4;
6661         } else {
6662                 current_login_state = pd->current_login_state & 0xf;
6663                 last_login_state = pd->last_login_state & 0xf;
6664         }
6665
6666         /* Check for logged in state. */
6667         if (current_login_state != PDS_PRLI_COMPLETE) {
6668                 ql_dbg(ql_dbg_mbx, vha, 0x119a,
6669                     "Unable to verify login-state (%x/%x) for loop_id %x.\n",
6670                     current_login_state, last_login_state, fcport->loop_id);
6671                 rval = QLA_FUNCTION_FAILED;
6672                 goto gpd_error_out;
6673         }
6674
6675         if (fcport->loop_id == FC_NO_LOOP_ID ||
6676             (memcmp(fcport->port_name, (uint8_t *)&zero, 8) &&
6677              memcmp(fcport->port_name, pd->port_name, 8))) {
6678                 /* We lost the device mid way. */
6679                 rval = QLA_NOT_LOGGED_IN;
6680                 goto gpd_error_out;
6681         }
6682
6683         /* Names are little-endian. */
6684         memcpy(fcport->node_name, pd->node_name, WWN_SIZE);
6685         memcpy(fcport->port_name, pd->port_name, WWN_SIZE);
6686
6687         /* Get port_id of device. */
6688         fcport->d_id.b.domain = pd->port_id[0];
6689         fcport->d_id.b.area = pd->port_id[1];
6690         fcport->d_id.b.al_pa = pd->port_id[2];
6691         fcport->d_id.b.rsvd_1 = 0;
6692
6693         ql_dbg(ql_dbg_disc, vha, 0x2062,
6694              "%8phC SVC Param w3 %02x%02x",
6695              fcport->port_name,
6696              pd->prli_svc_param_word_3[1],
6697              pd->prli_svc_param_word_3[0]);
6698
6699         if (NVME_TARGET(vha->hw, fcport)) {
6700                 fcport->port_type = FCT_NVME;
6701                 if ((pd->prli_svc_param_word_3[0] & BIT_5) == 0)
6702                         fcport->port_type |= FCT_NVME_INITIATOR;
6703                 if ((pd->prli_svc_param_word_3[0] & BIT_4) == 0)
6704                         fcport->port_type |= FCT_NVME_TARGET;
6705                 if ((pd->prli_svc_param_word_3[0] & BIT_3) == 0)
6706                         fcport->port_type |= FCT_NVME_DISCOVERY;
6707         } else {
6708                 /* If not target must be initiator or unknown type. */
6709                 if ((pd->prli_svc_param_word_3[0] & BIT_4) == 0)
6710                         fcport->port_type = FCT_INITIATOR;
6711                 else
6712                         fcport->port_type = FCT_TARGET;
6713         }
6714         /* Passback COS information. */
6715         fcport->supported_classes = (pd->flags & PDF_CLASS_2) ?
6716                 FC_COS_CLASS2 : FC_COS_CLASS3;
6717
6718         if (pd->prli_svc_param_word_3[0] & BIT_7) {
6719                 fcport->flags |= FCF_CONF_COMP_SUPPORTED;
6720                 fcport->conf_compl_supported = 1;
6721         }
6722
6723 gpd_error_out:
6724         return rval;
6725 }
6726
6727 /*
6728  * qla24xx_gidlist__wait
6729  * NOTE: don't call this routine from DPC thread.
6730  */
6731 int qla24xx_gidlist_wait(struct scsi_qla_host *vha,
6732         void *id_list, dma_addr_t id_list_dma, uint16_t *entries)
6733 {
6734         int rval = QLA_FUNCTION_FAILED;
6735         mbx_cmd_t mc;
6736
6737         if (!vha->hw->flags.fw_started)
6738                 goto done;
6739
6740         memset(&mc, 0, sizeof(mc));
6741         mc.mb[0] = MBC_GET_ID_LIST;
6742         mc.mb[2] = MSW(id_list_dma);
6743         mc.mb[3] = LSW(id_list_dma);
6744         mc.mb[6] = MSW(MSD(id_list_dma));
6745         mc.mb[7] = LSW(MSD(id_list_dma));
6746         mc.mb[8] = 0;
6747         mc.mb[9] = vha->vp_idx;
6748
6749         rval = qla24xx_send_mb_cmd(vha, &mc);
6750         if (rval != QLA_SUCCESS) {
6751                 ql_dbg(ql_dbg_mbx, vha, 0x119b,
6752                     "%s:  fail\n", __func__);
6753         } else {
6754                 *entries = mc.mb[1];
6755                 ql_dbg(ql_dbg_mbx, vha, 0x119c,
6756                     "%s:  done\n", __func__);
6757         }
6758 done:
6759         return rval;
6760 }
6761
6762 int qla27xx_set_zio_threshold(scsi_qla_host_t *vha, uint16_t value)
6763 {
6764         int rval;
6765         mbx_cmd_t       mc;
6766         mbx_cmd_t       *mcp = &mc;
6767
6768         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1200,
6769             "Entered %s\n", __func__);
6770
6771         memset(mcp->mb, 0 , sizeof(mcp->mb));
6772         mcp->mb[0] = MBC_GET_SET_ZIO_THRESHOLD;
6773         mcp->mb[1] = 1;
6774         mcp->mb[2] = value;
6775         mcp->out_mb = MBX_2 | MBX_1 | MBX_0;
6776         mcp->in_mb = MBX_2 | MBX_0;
6777         mcp->tov = MBX_TOV_SECONDS;
6778         mcp->flags = 0;
6779
6780         rval = qla2x00_mailbox_command(vha, mcp);
6781
6782         ql_dbg(ql_dbg_mbx, vha, 0x1201, "%s %x\n",
6783             (rval != QLA_SUCCESS) ? "Failed"  : "Done", rval);
6784
6785         return rval;
6786 }
6787
6788 int qla27xx_get_zio_threshold(scsi_qla_host_t *vha, uint16_t *value)
6789 {
6790         int rval;
6791         mbx_cmd_t       mc;
6792         mbx_cmd_t       *mcp = &mc;
6793
6794         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1203,
6795             "Entered %s\n", __func__);
6796
6797         memset(mcp->mb, 0, sizeof(mcp->mb));
6798         mcp->mb[0] = MBC_GET_SET_ZIO_THRESHOLD;
6799         mcp->mb[1] = 0;
6800         mcp->out_mb = MBX_1 | MBX_0;
6801         mcp->in_mb = MBX_2 | MBX_0;
6802         mcp->tov = MBX_TOV_SECONDS;
6803         mcp->flags = 0;
6804
6805         rval = qla2x00_mailbox_command(vha, mcp);
6806         if (rval == QLA_SUCCESS)
6807                 *value = mc.mb[2];
6808
6809         ql_dbg(ql_dbg_mbx, vha, 0x1205, "%s %x\n",
6810             (rval != QLA_SUCCESS) ? "Failed" : "Done", rval);
6811
6812         return rval;
6813 }
6814
6815 int
6816 qla2x00_read_sfp_dev(struct scsi_qla_host *vha, char *buf, int count)
6817 {
6818         struct qla_hw_data *ha = vha->hw;
6819         uint16_t iter, addr, offset;
6820         dma_addr_t phys_addr;
6821         int rval, c;
6822         u8 *sfp_data;
6823
6824         memset(ha->sfp_data, 0, SFP_DEV_SIZE);
6825         addr = 0xa0;
6826         phys_addr = ha->sfp_data_dma;
6827         sfp_data = ha->sfp_data;
6828         offset = c = 0;
6829
6830         for (iter = 0; iter < SFP_DEV_SIZE / SFP_BLOCK_SIZE; iter++) {
6831                 if (iter == 4) {
6832                         /* Skip to next device address. */
6833                         addr = 0xa2;
6834                         offset = 0;
6835                 }
6836
6837                 rval = qla2x00_read_sfp(vha, phys_addr, sfp_data,
6838                     addr, offset, SFP_BLOCK_SIZE, BIT_1);
6839                 if (rval != QLA_SUCCESS) {
6840                         ql_log(ql_log_warn, vha, 0x706d,
6841                             "Unable to read SFP data (%x/%x/%x).\n", rval,
6842                             addr, offset);
6843
6844                         return rval;
6845                 }
6846
6847                 if (buf && (c < count)) {
6848                         u16 sz;
6849
6850                         if ((count - c) >= SFP_BLOCK_SIZE)
6851                                 sz = SFP_BLOCK_SIZE;
6852                         else
6853                                 sz = count - c;
6854
6855                         memcpy(buf, sfp_data, sz);
6856                         buf += SFP_BLOCK_SIZE;
6857                         c += sz;
6858                 }
6859                 phys_addr += SFP_BLOCK_SIZE;
6860                 sfp_data  += SFP_BLOCK_SIZE;
6861                 offset += SFP_BLOCK_SIZE;
6862         }
6863
6864         return rval;
6865 }
6866
6867 int qla24xx_res_count_wait(struct scsi_qla_host *vha,
6868     uint16_t *out_mb, int out_mb_sz)
6869 {
6870         int rval = QLA_FUNCTION_FAILED;
6871         mbx_cmd_t mc;
6872
6873         if (!vha->hw->flags.fw_started)
6874                 goto done;
6875
6876         memset(&mc, 0, sizeof(mc));
6877         mc.mb[0] = MBC_GET_RESOURCE_COUNTS;
6878
6879         rval = qla24xx_send_mb_cmd(vha, &mc);
6880         if (rval != QLA_SUCCESS) {
6881                 ql_dbg(ql_dbg_mbx, vha, 0xffff,
6882                         "%s:  fail\n", __func__);
6883         } else {
6884                 if (out_mb_sz <= SIZEOF_IOCB_MB_REG)
6885                         memcpy(out_mb, mc.mb, out_mb_sz);
6886                 else
6887                         memcpy(out_mb, mc.mb, SIZEOF_IOCB_MB_REG);
6888
6889                 ql_dbg(ql_dbg_mbx, vha, 0xffff,
6890                         "%s:  done\n", __func__);
6891         }
6892 done:
6893         return rval;
6894 }
6895
6896 int qla28xx_secure_flash_update(scsi_qla_host_t *vha, uint16_t opts,
6897     uint16_t region, uint32_t len, dma_addr_t sfub_dma_addr,
6898     uint32_t sfub_len)
6899 {
6900         int             rval;
6901         mbx_cmd_t mc;
6902         mbx_cmd_t *mcp = &mc;
6903
6904         mcp->mb[0] = MBC_SECURE_FLASH_UPDATE;
6905         mcp->mb[1] = opts;
6906         mcp->mb[2] = region;
6907         mcp->mb[3] = MSW(len);
6908         mcp->mb[4] = LSW(len);
6909         mcp->mb[5] = MSW(sfub_dma_addr);
6910         mcp->mb[6] = LSW(sfub_dma_addr);
6911         mcp->mb[7] = MSW(MSD(sfub_dma_addr));
6912         mcp->mb[8] = LSW(MSD(sfub_dma_addr));
6913         mcp->mb[9] = sfub_len;
6914         mcp->out_mb =
6915             MBX_9|MBX_8|MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
6916         mcp->in_mb = MBX_2|MBX_1|MBX_0;
6917         mcp->tov = MBX_TOV_SECONDS;
6918         mcp->flags = 0;
6919         rval = qla2x00_mailbox_command(vha, mcp);
6920
6921         if (rval != QLA_SUCCESS) {
6922                 ql_dbg(ql_dbg_mbx, vha, 0xffff, "%s(%ld): failed rval 0x%x, %x %x %x",
6923                         __func__, vha->host_no, rval, mcp->mb[0], mcp->mb[1],
6924                         mcp->mb[2]);
6925         }
6926
6927         return rval;
6928 }
6929
6930 int qla2xxx_write_remote_register(scsi_qla_host_t *vha, uint32_t addr,
6931     uint32_t data)
6932 {
6933         int rval;
6934         mbx_cmd_t mc;
6935         mbx_cmd_t *mcp = &mc;
6936
6937         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10e8,
6938             "Entered %s.\n", __func__);
6939
6940         mcp->mb[0] = MBC_WRITE_REMOTE_REG;
6941         mcp->mb[1] = LSW(addr);
6942         mcp->mb[2] = MSW(addr);
6943         mcp->mb[3] = LSW(data);
6944         mcp->mb[4] = MSW(data);
6945         mcp->out_mb = MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
6946         mcp->in_mb = MBX_1|MBX_0;
6947         mcp->tov = MBX_TOV_SECONDS;
6948         mcp->flags = 0;
6949         rval = qla2x00_mailbox_command(vha, mcp);
6950
6951         if (rval != QLA_SUCCESS) {
6952                 ql_dbg(ql_dbg_mbx, vha, 0x10e9,
6953                     "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
6954         } else {
6955                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10ea,
6956                     "Done %s.\n", __func__);
6957         }
6958
6959         return rval;
6960 }
6961
6962 int qla2xxx_read_remote_register(scsi_qla_host_t *vha, uint32_t addr,
6963     uint32_t *data)
6964 {
6965         int rval;
6966         mbx_cmd_t mc;
6967         mbx_cmd_t *mcp = &mc;
6968
6969         ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10e8,
6970             "Entered %s.\n", __func__);
6971
6972         mcp->mb[0] = MBC_READ_REMOTE_REG;
6973         mcp->mb[1] = LSW(addr);
6974         mcp->mb[2] = MSW(addr);
6975         mcp->out_mb = MBX_2|MBX_1|MBX_0;
6976         mcp->in_mb = MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
6977         mcp->tov = MBX_TOV_SECONDS;
6978         mcp->flags = 0;
6979         rval = qla2x00_mailbox_command(vha, mcp);
6980
6981         *data = (uint32_t)((((uint32_t)mcp->mb[4]) << 16) | mcp->mb[3]);
6982
6983         if (rval != QLA_SUCCESS) {
6984                 ql_dbg(ql_dbg_mbx, vha, 0x10e9,
6985                     "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
6986         } else {
6987                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10ea,
6988                     "Done %s.\n", __func__);
6989         }
6990
6991         return rval;
6992 }
6993
6994 int
6995 ql26xx_led_config(scsi_qla_host_t *vha, uint16_t options, uint16_t *led)
6996 {
6997         struct qla_hw_data *ha = vha->hw;
6998         mbx_cmd_t mc;
6999         mbx_cmd_t *mcp = &mc;
7000         int rval;
7001
7002         if (!IS_QLA2031(ha) && !IS_QLA27XX(ha) && !IS_QLA28XX(ha))
7003                 return QLA_FUNCTION_FAILED;
7004
7005         ql_dbg(ql_dbg_mbx, vha, 0x7070, "Entered %s (options=%x).\n",
7006             __func__, options);
7007
7008         mcp->mb[0] = MBC_SET_GET_FC_LED_CONFIG;
7009         mcp->mb[1] = options;
7010         mcp->out_mb = MBX_1|MBX_0;
7011         mcp->in_mb = MBX_1|MBX_0;
7012         if (options & BIT_0) {
7013                 if (options & BIT_1) {
7014                         mcp->mb[2] = led[2];
7015                         mcp->out_mb |= MBX_2;
7016                 }
7017                 if (options & BIT_2) {
7018                         mcp->mb[3] = led[0];
7019                         mcp->out_mb |= MBX_3;
7020                 }
7021                 if (options & BIT_3) {
7022                         mcp->mb[4] = led[1];
7023                         mcp->out_mb |= MBX_4;
7024                 }
7025         } else {
7026                 mcp->in_mb |= MBX_4|MBX_3|MBX_2;
7027         }
7028         mcp->tov = MBX_TOV_SECONDS;
7029         mcp->flags = 0;
7030         rval = qla2x00_mailbox_command(vha, mcp);
7031         if (rval) {
7032                 ql_dbg(ql_dbg_mbx, vha, 0x7071, "Failed %s %x (mb=%x,%x)\n",
7033                     __func__, rval, mcp->mb[0], mcp->mb[1]);
7034                 return rval;
7035         }
7036
7037         if (options & BIT_0) {
7038                 ha->beacon_blink_led = 0;
7039                 ql_dbg(ql_dbg_mbx, vha, 0x7072, "Done %s\n", __func__);
7040         } else {
7041                 led[2] = mcp->mb[2];
7042                 led[0] = mcp->mb[3];
7043                 led[1] = mcp->mb[4];
7044                 ql_dbg(ql_dbg_mbx, vha, 0x7073, "Done %s (led=%x,%x,%x)\n",
7045                     __func__, led[0], led[1], led[2]);
7046         }
7047
7048         return rval;
7049 }
7050
7051 /**
7052  * qla_no_op_mb(): This MB is used to check if FW is still alive and
7053  * able to generate an interrupt. Otherwise, a timeout will trigger
7054  * FW dump + reset
7055  * @vha: host adapter pointer
7056  * Return: None
7057  */
7058 void qla_no_op_mb(struct scsi_qla_host *vha)
7059 {
7060         mbx_cmd_t mc;
7061         mbx_cmd_t *mcp = &mc;
7062         int rval;
7063
7064         memset(&mc, 0, sizeof(mc));
7065         mcp->mb[0] = 0; // noop cmd= 0
7066         mcp->out_mb = MBX_0;
7067         mcp->in_mb = MBX_0;
7068         mcp->tov = 5;
7069         mcp->flags = 0;
7070         rval = qla2x00_mailbox_command(vha, mcp);
7071
7072         if (rval) {
7073                 ql_dbg(ql_dbg_async, vha, 0x7071,
7074                         "Failed %s %x\n", __func__, rval);
7075         }
7076 }
7077
7078 int qla_mailbox_passthru(scsi_qla_host_t *vha,
7079                          uint16_t *mbx_in, uint16_t *mbx_out)
7080 {
7081         mbx_cmd_t mc;
7082         mbx_cmd_t *mcp = &mc;
7083         int rval = -EINVAL;
7084
7085         memset(&mc, 0, sizeof(mc));
7086         /* Receiving all 32 register's contents */
7087         memcpy(&mcp->mb, (char *)mbx_in, (32 * sizeof(uint16_t)));
7088
7089         mcp->out_mb = 0xFFFFFFFF;
7090         mcp->in_mb = 0xFFFFFFFF;
7091
7092         mcp->tov = MBX_TOV_SECONDS;
7093         mcp->flags = 0;
7094         mcp->bufp = NULL;
7095
7096         rval = qla2x00_mailbox_command(vha, mcp);
7097
7098         if (rval != QLA_SUCCESS) {
7099                 ql_dbg(ql_dbg_mbx, vha, 0xf0a2,
7100                         "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
7101         } else {
7102                 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0xf0a3, "Done %s.\n",
7103                        __func__);
7104                 /* passing all 32 register's contents */
7105                 memcpy(mbx_out, &mcp->mb, 32 * sizeof(uint16_t));
7106         }
7107
7108         return rval;
7109 }