drivers/scsi/qla2xxx/qla_isr.c

   1 /*
   2  * QLogic Fibre Channel HBA Driver
   3  * Copyright (c)  2003-2014 QLogic Corporation
   4  *
   5  * See LICENSE.qla2xxx for copyright and licensing details.
   6  */
   7 #include "qla_def.h"
   8 #include "qla_target.h"
   9
  10 #include <linux/delay.h>
  11 #include <linux/slab.h>
  12 #include <linux/cpu.h>
  13 #include <linux/t10-pi.h>
  14 #include <scsi/scsi_tcq.h>
  15 #include <scsi/scsi_bsg_fc.h>
  16 #include <scsi/scsi_eh.h>
  17 #include <scsi/fc/fc_fs.h>
  18 #include <linux/nvme-fc-driver.h>
  19
  20 static void qla2x00_mbx_completion(scsi_qla_host_t *, uint16_t);
  21 static void qla2x00_status_entry(scsi_qla_host_t *, struct rsp_que *, void *);
  22 static void qla2x00_status_cont_entry(struct rsp_que *, sts_cont_entry_t *);
  23 static int qla2x00_error_entry(scsi_qla_host_t *, struct rsp_que *,
  24         sts_entry_t *);
  25
  26 /**
  27  * qla2100_intr_handler() - Process interrupts for the ISP2100 and ISP2200.
  28  * @irq:
  29  * @dev_id: SCSI driver HA context
  30  *
  31  * Called by system whenever the host adapter generates an interrupt.
  32  *
  33  * Returns handled flag.
  34  */
  35 irqreturn_t
  36 qla2100_intr_handler(int irq, void *dev_id)
  37 {
  38         scsi_qla_host_t *vha;
  39         struct qla_hw_data *ha;
  40         struct device_reg_2xxx __iomem *reg;
  41         int             status;
  42         unsigned long   iter;
  43         uint16_t        hccr;
  44         uint16_t        mb[4];
  45         struct rsp_que *rsp;
  46         unsigned long   flags;
  47
  48         rsp = (struct rsp_que *) dev_id;
  49         if (!rsp) {
  50                 ql_log(ql_log_info, NULL, 0x505d,
  51                     "%s: NULL response queue pointer.\n", __func__);
  52                 return (IRQ_NONE);
  53         }
  54
  55         ha = rsp->hw;
  56         reg = &ha->iobase->isp;
  57         status = 0;
  58
  59         spin_lock_irqsave(&ha->hardware_lock, flags);
  60         vha = pci_get_drvdata(ha->pdev);
  61         for (iter = 50; iter--; ) {
  62                 hccr = RD_REG_WORD(&reg->hccr);
  63                 if (qla2x00_check_reg16_for_disconnect(vha, hccr))
  64                         break;
  65                 if (hccr & HCCR_RISC_PAUSE) {
  66                         if (pci_channel_offline(ha->pdev))
  67                                 break;
  68
  69                         /*
  70                          * Issue a "HARD" reset in order for the RISC interrupt
  71                          * bit to be cleared.  Schedule a big hammer to get
  72                          * out of the RISC PAUSED state.
  73                          */
  74                         WRT_REG_WORD(&reg->hccr, HCCR_RESET_RISC);
  75                         RD_REG_WORD(&reg->hccr);
  76
  77                         ha->isp_ops->fw_dump(vha, 1);
  78                         set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
  79                         break;
  80                 } else if ((RD_REG_WORD(&reg->istatus) & ISR_RISC_INT) == 0)
  81                         break;
  82
  83                 if (RD_REG_WORD(&reg->semaphore) & BIT_0) {
  84                         WRT_REG_WORD(&reg->hccr, HCCR_CLR_RISC_INT);
  85                         RD_REG_WORD(&reg->hccr);
  86
  87                         /* Get mailbox data. */
  88                         mb[0] = RD_MAILBOX_REG(ha, reg, 0);
  89                         if (mb[0] > 0x3fff && mb[0] < 0x8000) {
  90                                 qla2x00_mbx_completion(vha, mb[0]);
  91                                 status |= MBX_INTERRUPT;
  92                         } else if (mb[0] > 0x7fff && mb[0] < 0xc000) {
  93                                 mb[1] = RD_MAILBOX_REG(ha, reg, 1);
  94                                 mb[2] = RD_MAILBOX_REG(ha, reg, 2);
  95                                 mb[3] = RD_MAILBOX_REG(ha, reg, 3);
  96                                 qla2x00_async_event(vha, rsp, mb);
  97                         } else {
  98                                 /*EMPTY*/
  99                                 ql_dbg(ql_dbg_async, vha, 0x5025,
 100                                     "Unrecognized interrupt type (%d).\n",
 101                                     mb[0]);
 102                         }
 103                         /* Release mailbox registers. */
 104                         WRT_REG_WORD(&reg->semaphore, 0);
 105                         RD_REG_WORD(&reg->semaphore);
 106                 } else {
 107                         qla2x00_process_response_queue(rsp);
 108
 109                         WRT_REG_WORD(&reg->hccr, HCCR_CLR_RISC_INT);
 110                         RD_REG_WORD(&reg->hccr);
 111                 }
 112         }
 113         qla2x00_handle_mbx_completion(ha, status);
 114         spin_unlock_irqrestore(&ha->hardware_lock, flags);
 115
 116         return (IRQ_HANDLED);
 117 }
 118
 119 bool
 120 qla2x00_check_reg32_for_disconnect(scsi_qla_host_t *vha, uint32_t reg)
 121 {
 122         /* Check for PCI disconnection */
 123         if (reg == 0xffffffff && !pci_channel_offline(vha->hw->pdev)) {
 124                 if (!test_and_set_bit(PFLG_DISCONNECTED, &vha->pci_flags) &&
 125                     !test_bit(PFLG_DRIVER_REMOVING, &vha->pci_flags) &&
 126                     !test_bit(PFLG_DRIVER_PROBING, &vha->pci_flags)) {
 127                         /*
 128                          * Schedule this (only once) on the default system
 129                          * workqueue so that all the adapter workqueues and the
 130                          * DPC thread can be shutdown cleanly.
 131                          */
 132                         schedule_work(&vha->hw->board_disable);
 133                 }
 134                 return true;
 135         } else
 136                 return false;
 137 }
 138
 139 bool
 140 qla2x00_check_reg16_for_disconnect(scsi_qla_host_t *vha, uint16_t reg)
 141 {
 142         return qla2x00_check_reg32_for_disconnect(vha, 0xffff0000 | reg);
 143 }
 144
 145 /**
 146  * qla2300_intr_handler() - Process interrupts for the ISP23xx and ISP63xx.
 147  * @irq:
 148  * @dev_id: SCSI driver HA context
 149  *
 150  * Called by system whenever the host adapter generates an interrupt.
 151  *
 152  * Returns handled flag.
 153  */
 154 irqreturn_t
 155 qla2300_intr_handler(int irq, void *dev_id)
 156 {
 157         scsi_qla_host_t *vha;
 158         struct device_reg_2xxx __iomem *reg;
 159         int             status;
 160         unsigned long   iter;
 161         uint32_t        stat;
 162         uint16_t        hccr;
 163         uint16_t        mb[4];
 164         struct rsp_que *rsp;
 165         struct qla_hw_data *ha;
 166         unsigned long   flags;
 167
 168         rsp = (struct rsp_que *) dev_id;
 169         if (!rsp) {
 170                 ql_log(ql_log_info, NULL, 0x5058,
 171                     "%s: NULL response queue pointer.\n", __func__);
 172                 return (IRQ_NONE);
 173         }
 174
 175         ha = rsp->hw;
 176         reg = &ha->iobase->isp;
 177         status = 0;
 178
 179         spin_lock_irqsave(&ha->hardware_lock, flags);
 180         vha = pci_get_drvdata(ha->pdev);
 181         for (iter = 50; iter--; ) {
 182                 stat = RD_REG_DWORD(&reg->u.isp2300.host_status);
 183                 if (qla2x00_check_reg32_for_disconnect(vha, stat))
 184                         break;
 185                 if (stat & HSR_RISC_PAUSED) {
 186                         if (unlikely(pci_channel_offline(ha->pdev)))
 187                                 break;
 188
 189                         hccr = RD_REG_WORD(&reg->hccr);
 190
 191                         if (hccr & (BIT_15 | BIT_13 | BIT_11 | BIT_8))
 192                                 ql_log(ql_log_warn, vha, 0x5026,
 193                                     "Parity error -- HCCR=%x, Dumping "
 194                                     "firmware.\n", hccr);
 195                         else
 196                                 ql_log(ql_log_warn, vha, 0x5027,
 197                                     "RISC paused -- HCCR=%x, Dumping "
 198                                     "firmware.\n", hccr);
 199
 200                         /*
 201                          * Issue a "HARD" reset in order for the RISC
 202                          * interrupt bit to be cleared.  Schedule a big
 203                          * hammer to get out of the RISC PAUSED state.
 204                          */
 205                         WRT_REG_WORD(&reg->hccr, HCCR_RESET_RISC);
 206                         RD_REG_WORD(&reg->hccr);
 207
 208                         ha->isp_ops->fw_dump(vha, 1);
 209                         set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
 210                         break;
 211                 } else if ((stat & HSR_RISC_INT) == 0)
 212                         break;
 213
 214                 switch (stat & 0xff) {
 215                 case 0x1:
 216                 case 0x2:
 217                 case 0x10:
 218                 case 0x11:
 219                         qla2x00_mbx_completion(vha, MSW(stat));
 220                         status |= MBX_INTERRUPT;
 221
 222                         /* Release mailbox registers. */
 223                         WRT_REG_WORD(&reg->semaphore, 0);
 224                         break;
 225                 case 0x12:
 226                         mb[0] = MSW(stat);
 227                         mb[1] = RD_MAILBOX_REG(ha, reg, 1);
 228                         mb[2] = RD_MAILBOX_REG(ha, reg, 2);
 229                         mb[3] = RD_MAILBOX_REG(ha, reg, 3);
 230                         qla2x00_async_event(vha, rsp, mb);
 231                         break;
 232                 case 0x13:
 233                         qla2x00_process_response_queue(rsp);
 234                         break;
 235                 case 0x15:
 236                         mb[0] = MBA_CMPLT_1_16BIT;
 237                         mb[1] = MSW(stat);
 238                         qla2x00_async_event(vha, rsp, mb);
 239                         break;
 240                 case 0x16:
 241                         mb[0] = MBA_SCSI_COMPLETION;
 242                         mb[1] = MSW(stat);
 243                         mb[2] = RD_MAILBOX_REG(ha, reg, 2);
 244                         qla2x00_async_event(vha, rsp, mb);
 245                         break;
 246                 default:
 247                         ql_dbg(ql_dbg_async, vha, 0x5028,
 248                             "Unrecognized interrupt type (%d).\n", stat & 0xff);
 249                         break;
 250                 }
 251                 WRT_REG_WORD(&reg->hccr, HCCR_CLR_RISC_INT);
 252                 RD_REG_WORD_RELAXED(&reg->hccr);
 253         }
 254         qla2x00_handle_mbx_completion(ha, status);
 255         spin_unlock_irqrestore(&ha->hardware_lock, flags);
 256
 257         return (IRQ_HANDLED);
 258 }
 259
 260 /**
 261  * qla2x00_mbx_completion() - Process mailbox command completions.
 262  * @ha: SCSI driver HA context
 263  * @mb0: Mailbox0 register
 264  */
 265 static void
 266 qla2x00_mbx_completion(scsi_qla_host_t *vha, uint16_t mb0)
 267 {
 268         uint16_t        cnt;
 269         uint32_t        mboxes;
 270         uint16_t __iomem *wptr;
 271         struct qla_hw_data *ha = vha->hw;
 272         struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
 273
 274         /* Read all mbox registers? */
 275         WARN_ON_ONCE(ha->mbx_count > 32);
 276         mboxes = (1ULL << ha->mbx_count) - 1;
 277         if (!ha->mcp)
 278                 ql_dbg(ql_dbg_async, vha, 0x5001, "MBX pointer ERROR.\n");
 279         else
 280                 mboxes = ha->mcp->in_mb;
 281
 282         /* Load return mailbox registers. */
 283         ha->flags.mbox_int = 1;
 284         ha->mailbox_out[0] = mb0;
 285         mboxes >>= 1;
 286         wptr = (uint16_t __iomem *)MAILBOX_REG(ha, reg, 1);
 287
 288         for (cnt = 1; cnt < ha->mbx_count; cnt++) {
 289                 if (IS_QLA2200(ha) && cnt == 8)
 290                         wptr = (uint16_t __iomem *)MAILBOX_REG(ha, reg, 8);
 291                 if ((cnt == 4 || cnt == 5) && (mboxes & BIT_0))
 292                         ha->mailbox_out[cnt] = qla2x00_debounce_register(wptr);
 293                 else if (mboxes & BIT_0)
 294                         ha->mailbox_out[cnt] = RD_REG_WORD(wptr);
 295
 296                 wptr++;
 297                 mboxes >>= 1;
 298         }
 299 }
 300
 301 static void
 302 qla81xx_idc_event(scsi_qla_host_t *vha, uint16_t aen, uint16_t descr)
 303 {
 304         static char *event[] =
 305                 { "Complete", "Request Notification", "Time Extension" };
 306         int rval;
 307         struct device_reg_24xx __iomem *reg24 = &vha->hw->iobase->isp24;
 308         struct device_reg_82xx __iomem *reg82 = &vha->hw->iobase->isp82;
 309         uint16_t __iomem *wptr;
 310         uint16_t cnt, timeout, mb[QLA_IDC_ACK_REGS];
 311
 312         /* Seed data -- mailbox1 -> mailbox7. */
 313         if (IS_QLA81XX(vha->hw) || IS_QLA83XX(vha->hw))
 314                 wptr = (uint16_t __iomem *)&reg24->mailbox1;
 315         else if (IS_QLA8044(vha->hw))
 316                 wptr = (uint16_t __iomem *)&reg82->mailbox_out[1];
 317         else
 318                 return;
 319
 320         for (cnt = 0; cnt < QLA_IDC_ACK_REGS; cnt++, wptr++)
 321                 mb[cnt] = RD_REG_WORD(wptr);
 322
 323         ql_dbg(ql_dbg_async, vha, 0x5021,
 324             "Inter-Driver Communication %s -- "
 325             "%04x %04x %04x %04x %04x %04x %04x.\n",
 326             event[aen & 0xff], mb[0], mb[1], mb[2], mb[3],
 327             mb[4], mb[5], mb[6]);
 328         switch (aen) {
 329         /* Handle IDC Error completion case. */
 330         case MBA_IDC_COMPLETE:
 331                 if (mb[1] >> 15) {
 332                         vha->hw->flags.idc_compl_status = 1;
 333                         if (vha->hw->notify_dcbx_comp && !vha->vp_idx)
 334                                 complete(&vha->hw->dcbx_comp);
 335                 }
 336                 break;
 337
 338         case MBA_IDC_NOTIFY:
 339                 /* Acknowledgement needed? [Notify && non-zero timeout]. */
 340                 timeout = (descr >> 8) & 0xf;
 341                 ql_dbg(ql_dbg_async, vha, 0x5022,
 342                     "%lu Inter-Driver Communication %s -- ACK timeout=%d.\n",
 343                     vha->host_no, event[aen & 0xff], timeout);
 344
 345                 if (!timeout)
 346                         return;
 347                 rval = qla2x00_post_idc_ack_work(vha, mb);
 348                 if (rval != QLA_SUCCESS)
 349                         ql_log(ql_log_warn, vha, 0x5023,
 350                             "IDC failed to post ACK.\n");
 351                 break;
 352         case MBA_IDC_TIME_EXT:
 353                 vha->hw->idc_extend_tmo = descr;
 354                 ql_dbg(ql_dbg_async, vha, 0x5087,
 355                     "%lu Inter-Driver Communication %s -- "
 356                     "Extend timeout by=%d.\n",
 357                     vha->host_no, event[aen & 0xff], vha->hw->idc_extend_tmo);
 358                 break;
 359         }
 360 }
 361
 362 #define LS_UNKNOWN      2
 363 const char *
 364 qla2x00_get_link_speed_str(struct qla_hw_data *ha, uint16_t speed)
 365 {
 366         static const char *const link_speeds[] = {
 367                 "1", "2", "?", "4", "8", "16", "32", "10"
 368         };
 369 #define QLA_LAST_SPEED  7
 370
 371         if (IS_QLA2100(ha) || IS_QLA2200(ha))
 372                 return link_speeds[0];
 373         else if (speed == 0x13)
 374                 return link_speeds[QLA_LAST_SPEED];
 375         else if (speed < QLA_LAST_SPEED)
 376                 return link_speeds[speed];
 377         else
 378                 return link_speeds[LS_UNKNOWN];
 379 }
 380
 381 static void
 382 qla83xx_handle_8200_aen(scsi_qla_host_t *vha, uint16_t *mb)
 383 {
 384         struct qla_hw_data *ha = vha->hw;
 385
 386         /*
 387          * 8200 AEN Interpretation:
 388          * mb[0] = AEN code
 389          * mb[1] = AEN Reason code
 390          * mb[2] = LSW of Peg-Halt Status-1 Register
 391          * mb[6] = MSW of Peg-Halt Status-1 Register
 392          * mb[3] = LSW of Peg-Halt Status-2 register
 393          * mb[7] = MSW of Peg-Halt Status-2 register
 394          * mb[4] = IDC Device-State Register value
 395          * mb[5] = IDC Driver-Presence Register value
 396          */
 397         ql_dbg(ql_dbg_async, vha, 0x506b, "AEN Code: mb[0] = 0x%x AEN reason: "
 398             "mb[1] = 0x%x PH-status1: mb[2] = 0x%x PH-status1: mb[6] = 0x%x.\n",
 399             mb[0], mb[1], mb[2], mb[6]);
 400         ql_dbg(ql_dbg_async, vha, 0x506c, "PH-status2: mb[3] = 0x%x "
 401             "PH-status2: mb[7] = 0x%x Device-State: mb[4] = 0x%x "
 402             "Drv-Presence: mb[5] = 0x%x.\n", mb[3], mb[7], mb[4], mb[5]);
 403
 404         if (mb[1] & (IDC_PEG_HALT_STATUS_CHANGE | IDC_NIC_FW_REPORTED_FAILURE |
 405                                 IDC_HEARTBEAT_FAILURE)) {
 406                 ha->flags.nic_core_hung = 1;
 407                 ql_log(ql_log_warn, vha, 0x5060,
 408                     "83XX: F/W Error Reported: Check if reset required.\n");
 409
 410                 if (mb[1] & IDC_PEG_HALT_STATUS_CHANGE) {
 411                         uint32_t protocol_engine_id, fw_err_code, err_level;
 412
 413                         /*
 414                          * IDC_PEG_HALT_STATUS_CHANGE interpretation:
 415                          *  - PEG-Halt Status-1 Register:
 416                          *      (LSW = mb[2], MSW = mb[6])
 417                          *      Bits 0-7   = protocol-engine ID
 418                          *      Bits 8-28  = f/w error code
 419                          *      Bits 29-31 = Error-level
 420                          *          Error-level 0x1 = Non-Fatal error
 421                          *          Error-level 0x2 = Recoverable Fatal error
 422                          *          Error-level 0x4 = UnRecoverable Fatal error
 423                          *  - PEG-Halt Status-2 Register:
 424                          *      (LSW = mb[3], MSW = mb[7])
 425                          */
 426                         protocol_engine_id = (mb[2] & 0xff);
 427                         fw_err_code = (((mb[2] & 0xff00) >> 8) |
 428                             ((mb[6] & 0x1fff) << 8));
 429                         err_level = ((mb[6] & 0xe000) >> 13);
 430                         ql_log(ql_log_warn, vha, 0x5061, "PegHalt Status-1 "
 431                             "Register: protocol_engine_id=0x%x "
 432                             "fw_err_code=0x%x err_level=0x%x.\n",
 433                             protocol_engine_id, fw_err_code, err_level);
 434                         ql_log(ql_log_warn, vha, 0x5062, "PegHalt Status-2 "
 435                             "Register: 0x%x%x.\n", mb[7], mb[3]);
 436                         if (err_level == ERR_LEVEL_NON_FATAL) {
 437                                 ql_log(ql_log_warn, vha, 0x5063,
 438                                     "Not a fatal error, f/w has recovered itself.\n");
 439                         } else if (err_level == ERR_LEVEL_RECOVERABLE_FATAL) {
 440                                 ql_log(ql_log_fatal, vha, 0x5064,
 441                                     "Recoverable Fatal error: Chip reset "
 442                                     "required.\n");
 443                                 qla83xx_schedule_work(vha,
 444                                     QLA83XX_NIC_CORE_RESET);
 445                         } else if (err_level == ERR_LEVEL_UNRECOVERABLE_FATAL) {
 446                                 ql_log(ql_log_fatal, vha, 0x5065,
 447                                     "Unrecoverable Fatal error: Set FAILED "
 448                                     "state, reboot required.\n");
 449                                 qla83xx_schedule_work(vha,
 450                                     QLA83XX_NIC_CORE_UNRECOVERABLE);
 451                         }
 452                 }
 453
 454                 if (mb[1] & IDC_NIC_FW_REPORTED_FAILURE) {
 455                         uint16_t peg_fw_state, nw_interface_link_up;
 456                         uint16_t nw_interface_signal_detect, sfp_status;
 457                         uint16_t htbt_counter, htbt_monitor_enable;
 458                         uint16_t sfp_additional_info, sfp_multirate;
 459                         uint16_t sfp_tx_fault, link_speed, dcbx_status;
 460
 461                         /*
 462                          * IDC_NIC_FW_REPORTED_FAILURE interpretation:
 463                          *  - PEG-to-FC Status Register:
 464                          *      (LSW = mb[2], MSW = mb[6])
 465                          *      Bits 0-7   = Peg-Firmware state
 466                          *      Bit 8      = N/W Interface Link-up
 467                          *      Bit 9      = N/W Interface signal detected
 468                          *      Bits 10-11 = SFP Status
 469                          *        SFP Status 0x0 = SFP+ transceiver not expected
 470                          *        SFP Status 0x1 = SFP+ transceiver not present
 471                          *        SFP Status 0x2 = SFP+ transceiver invalid
 472                          *        SFP Status 0x3 = SFP+ transceiver present and
 473                          *        valid
 474                          *      Bits 12-14 = Heartbeat Counter
 475                          *      Bit 15     = Heartbeat Monitor Enable
 476                          *      Bits 16-17 = SFP Additional Info
 477                          *        SFP info 0x0 = Unregocnized transceiver for
 478                          *        Ethernet
 479                          *        SFP info 0x1 = SFP+ brand validation failed
 480                          *        SFP info 0x2 = SFP+ speed validation failed
 481                          *        SFP info 0x3 = SFP+ access error
 482                          *      Bit 18     = SFP Multirate
 483                          *      Bit 19     = SFP Tx Fault
 484                          *      Bits 20-22 = Link Speed
 485                          *      Bits 23-27 = Reserved
 486                          *      Bits 28-30 = DCBX Status
 487                          *        DCBX Status 0x0 = DCBX Disabled
 488                          *        DCBX Status 0x1 = DCBX Enabled
 489                          *        DCBX Status 0x2 = DCBX Exchange error
 490                          *      Bit 31     = Reserved
 491                          */
 492                         peg_fw_state = (mb[2] & 0x00ff);
 493                         nw_interface_link_up = ((mb[2] & 0x0100) >> 8);
 494                         nw_interface_signal_detect = ((mb[2] & 0x0200) >> 9);
 495                         sfp_status = ((mb[2] & 0x0c00) >> 10);
 496                         htbt_counter = ((mb[2] & 0x7000) >> 12);
 497                         htbt_monitor_enable = ((mb[2] & 0x8000) >> 15);
 498                         sfp_additional_info = (mb[6] & 0x0003);
 499                         sfp_multirate = ((mb[6] & 0x0004) >> 2);
 500                         sfp_tx_fault = ((mb[6] & 0x0008) >> 3);
 501                         link_speed = ((mb[6] & 0x0070) >> 4);
 502                         dcbx_status = ((mb[6] & 0x7000) >> 12);
 503
 504                         ql_log(ql_log_warn, vha, 0x5066,
 505                             "Peg-to-Fc Status Register:\n"
 506                             "peg_fw_state=0x%x, nw_interface_link_up=0x%x, "
 507                             "nw_interface_signal_detect=0x%x"
 508                             "\nsfp_statis=0x%x.\n ", peg_fw_state,
 509                             nw_interface_link_up, nw_interface_signal_detect,
 510                             sfp_status);
 511                         ql_log(ql_log_warn, vha, 0x5067,
 512                             "htbt_counter=0x%x, htbt_monitor_enable=0x%x, "
 513                             "sfp_additional_info=0x%x, sfp_multirate=0x%x.\n ",
 514                             htbt_counter, htbt_monitor_enable,
 515                             sfp_additional_info, sfp_multirate);
 516                         ql_log(ql_log_warn, vha, 0x5068,
 517                             "sfp_tx_fault=0x%x, link_state=0x%x, "
 518                             "dcbx_status=0x%x.\n", sfp_tx_fault, link_speed,
 519                             dcbx_status);
 520
 521                         qla83xx_schedule_work(vha, QLA83XX_NIC_CORE_RESET);
 522                 }
 523
 524                 if (mb[1] & IDC_HEARTBEAT_FAILURE) {
 525                         ql_log(ql_log_warn, vha, 0x5069,
 526                             "Heartbeat Failure encountered, chip reset "
 527                             "required.\n");
 528
 529                         qla83xx_schedule_work(vha, QLA83XX_NIC_CORE_RESET);
 530                 }
 531         }
 532
 533         if (mb[1] & IDC_DEVICE_STATE_CHANGE) {
 534                 ql_log(ql_log_info, vha, 0x506a,
 535                     "IDC Device-State changed = 0x%x.\n", mb[4]);
 536                 if (ha->flags.nic_core_reset_owner)
 537                         return;
 538                 qla83xx_schedule_work(vha, MBA_IDC_AEN);
 539         }
 540 }
 541
 542 int
 543 qla2x00_is_a_vp_did(scsi_qla_host_t *vha, uint32_t rscn_entry)
 544 {
 545         struct qla_hw_data *ha = vha->hw;
 546         scsi_qla_host_t *vp;
 547         uint32_t vp_did;
 548         unsigned long flags;
 549         int ret = 0;
 550
 551         if (!ha->num_vhosts)
 552                 return ret;
 553
 554         spin_lock_irqsave(&ha->vport_slock, flags);
 555         list_for_each_entry(vp, &ha->vp_list, list) {
 556                 vp_did = vp->d_id.b24;
 557                 if (vp_did == rscn_entry) {
 558                         ret = 1;
 559                         break;
 560                 }
 561         }
 562         spin_unlock_irqrestore(&ha->vport_slock, flags);
 563
 564         return ret;
 565 }
 566
 567 fc_port_t *
 568 qla2x00_find_fcport_by_loopid(scsi_qla_host_t *vha, uint16_t loop_id)
 569 {
 570         fc_port_t *f, *tf;
 571
 572         f = tf = NULL;
 573         list_for_each_entry_safe(f, tf, &vha->vp_fcports, list)
 574                 if (f->loop_id == loop_id)
 575                         return f;
 576         return NULL;
 577 }
 578
 579 fc_port_t *
 580 qla2x00_find_fcport_by_wwpn(scsi_qla_host_t *vha, u8 *wwpn, u8 incl_deleted)
 581 {
 582         fc_port_t *f, *tf;
 583
 584         f = tf = NULL;
 585         list_for_each_entry_safe(f, tf, &vha->vp_fcports, list) {
 586                 if (memcmp(f->port_name, wwpn, WWN_SIZE) == 0) {
 587                         if (incl_deleted)
 588                                 return f;
 589                         else if (f->deleted == 0)
 590                                 return f;
 591                 }
 592         }
 593         return NULL;
 594 }
 595
 596 fc_port_t *
 597 qla2x00_find_fcport_by_nportid(scsi_qla_host_t *vha, port_id_t *id,
 598         u8 incl_deleted)
 599 {
 600         fc_port_t *f, *tf;
 601
 602         f = tf = NULL;
 603         list_for_each_entry_safe(f, tf, &vha->vp_fcports, list) {
 604                 if (f->d_id.b24 == id->b24) {
 605                         if (incl_deleted)
 606                                 return f;
 607                         else if (f->deleted == 0)
 608                                 return f;
 609                 }
 610         }
 611         return NULL;
 612 }
 613
 614 /**
 615  * qla2x00_async_event() - Process aynchronous events.
 616  * @ha: SCSI driver HA context
 617  * @mb: Mailbox registers (0 - 3)
 618  */
 619 void
 620 qla2x00_async_event(scsi_qla_host_t *vha, struct rsp_que *rsp, uint16_t *mb)
 621 {
 622         uint16_t        handle_cnt;
 623         uint16_t        cnt, mbx;
 624         uint32_t        handles[5];
 625         struct qla_hw_data *ha = vha->hw;
 626         struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
 627         struct device_reg_24xx __iomem *reg24 = &ha->iobase->isp24;
 628         struct device_reg_82xx __iomem *reg82 = &ha->iobase->isp82;
 629         uint32_t        rscn_entry, host_pid;
 630         unsigned long   flags;
 631         fc_port_t       *fcport = NULL;
 632
 633         /* Setup to process RIO completion. */
 634         handle_cnt = 0;
 635         if (IS_CNA_CAPABLE(ha))
 636                 goto skip_rio;
 637         switch (mb[0]) {
 638         case MBA_SCSI_COMPLETION:
 639                 handles[0] = le32_to_cpu((uint32_t)((mb[2] << 16) | mb[1]));
 640                 handle_cnt = 1;
 641                 break;
 642         case MBA_CMPLT_1_16BIT:
 643                 handles[0] = mb[1];
 644                 handle_cnt = 1;
 645                 mb[0] = MBA_SCSI_COMPLETION;
 646                 break;
 647         case MBA_CMPLT_2_16BIT:
 648                 handles[0] = mb[1];
 649                 handles[1] = mb[2];
 650                 handle_cnt = 2;
 651                 mb[0] = MBA_SCSI_COMPLETION;
 652                 break;
 653         case MBA_CMPLT_3_16BIT:
 654                 handles[0] = mb[1];
 655                 handles[1] = mb[2];
 656                 handles[2] = mb[3];
 657                 handle_cnt = 3;
 658                 mb[0] = MBA_SCSI_COMPLETION;
 659                 break;
 660         case MBA_CMPLT_4_16BIT:
 661                 handles[0] = mb[1];
 662                 handles[1] = mb[2];
 663                 handles[2] = mb[3];
 664                 handles[3] = (uint32_t)RD_MAILBOX_REG(ha, reg, 6);
 665                 handle_cnt = 4;
 666                 mb[0] = MBA_SCSI_COMPLETION;
 667                 break;
 668         case MBA_CMPLT_5_16BIT:
 669                 handles[0] = mb[1];
 670                 handles[1] = mb[2];
 671                 handles[2] = mb[3];
 672                 handles[3] = (uint32_t)RD_MAILBOX_REG(ha, reg, 6);
 673                 handles[4] = (uint32_t)RD_MAILBOX_REG(ha, reg, 7);
 674                 handle_cnt = 5;
 675                 mb[0] = MBA_SCSI_COMPLETION;
 676                 break;
 677         case MBA_CMPLT_2_32BIT:
 678                 handles[0] = le32_to_cpu((uint32_t)((mb[2] << 16) | mb[1]));
 679                 handles[1] = le32_to_cpu(
 680                     ((uint32_t)(RD_MAILBOX_REG(ha, reg, 7) << 16)) |
 681                     RD_MAILBOX_REG(ha, reg, 6));
 682                 handle_cnt = 2;
 683                 mb[0] = MBA_SCSI_COMPLETION;
 684                 break;
 685         default:
 686                 break;
 687         }
 688 skip_rio:
 689         switch (mb[0]) {
 690         case MBA_SCSI_COMPLETION:       /* Fast Post */
 691                 if (!vha->flags.online)
 692                         break;
 693
 694                 for (cnt = 0; cnt < handle_cnt; cnt++)
 695                         qla2x00_process_completed_request(vha, rsp->req,
 696                                 handles[cnt]);
 697                 break;
 698
 699         case MBA_RESET:                 /* Reset */
 700                 ql_dbg(ql_dbg_async, vha, 0x5002,
 701                     "Asynchronous RESET.\n");
 702
 703                 set_bit(RESET_MARKER_NEEDED, &vha->dpc_flags);
 704                 break;
 705
 706         case MBA_SYSTEM_ERR:            /* System Error */
 707                 mbx = (IS_QLA81XX(ha) || IS_QLA83XX(ha) || IS_QLA27XX(ha)) ?
 708                         RD_REG_WORD(&reg24->mailbox7) : 0;
 709                 ql_log(ql_log_warn, vha, 0x5003,
 710                     "ISP System Error - mbx1=%xh mbx2=%xh mbx3=%xh "
 711                     "mbx7=%xh.\n", mb[1], mb[2], mb[3], mbx);
 712
 713                 ha->isp_ops->fw_dump(vha, 1);
 714                 ha->flags.fw_init_done = 0;
 715                 QLA_FW_STOPPED(ha);
 716
 717                 if (IS_FWI2_CAPABLE(ha)) {
 718                         if (mb[1] == 0 && mb[2] == 0) {
 719                                 ql_log(ql_log_fatal, vha, 0x5004,
 720                                     "Unrecoverable Hardware Error: adapter "
 721                                     "marked OFFLINE!\n");
 722                                 vha->flags.online = 0;
 723                                 vha->device_flags |= DFLG_DEV_FAILED;
 724                         } else {
 725                                 /* Check to see if MPI timeout occurred */
 726                                 if ((mbx & MBX_3) && (ha->port_no == 0))
 727                                         set_bit(MPI_RESET_NEEDED,
 728                                             &vha->dpc_flags);
 729
 730                                 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
 731                         }
 732                 } else if (mb[1] == 0) {
 733                         ql_log(ql_log_fatal, vha, 0x5005,
 734                             "Unrecoverable Hardware Error: adapter marked "
 735                             "OFFLINE!\n");
 736                         vha->flags.online = 0;
 737                         vha->device_flags |= DFLG_DEV_FAILED;
 738                 } else
 739                         set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
 740                 break;
 741
 742         case MBA_REQ_TRANSFER_ERR:      /* Request Transfer Error */
 743                 ql_log(ql_log_warn, vha, 0x5006,
 744                     "ISP Request Transfer Error (%x).\n",  mb[1]);
 745
 746                 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
 747                 break;
 748
 749         case MBA_RSP_TRANSFER_ERR:      /* Response Transfer Error */
 750                 ql_log(ql_log_warn, vha, 0x5007,
 751                     "ISP Response Transfer Error (%x).\n", mb[1]);
 752
 753                 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
 754                 break;
 755
 756         case MBA_WAKEUP_THRES:          /* Request Queue Wake-up */
 757                 ql_dbg(ql_dbg_async, vha, 0x5008,
 758                     "Asynchronous WAKEUP_THRES (%x).\n", mb[1]);
 759                 break;
 760
 761         case MBA_LOOP_INIT_ERR:
 762                 ql_log(ql_log_warn, vha, 0x5090,
 763                     "LOOP INIT ERROR (%x).\n", mb[1]);
 764                 ha->isp_ops->fw_dump(vha, 1);
 765                 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
 766                 break;
 767
 768         case MBA_LIP_OCCURRED:          /* Loop Initialization Procedure */
 769                 ha->flags.lip_ae = 1;
 770                 ha->flags.n2n_ae = 0;
 771
 772                 ql_dbg(ql_dbg_async, vha, 0x5009,
 773                     "LIP occurred (%x).\n", mb[1]);
 774
 775                 if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
 776                         atomic_set(&vha->loop_state, LOOP_DOWN);
 777                         atomic_set(&vha->loop_down_timer, LOOP_DOWN_TIME);
 778                         qla2x00_mark_all_devices_lost(vha, 1);
 779                 }
 780
 781                 if (vha->vp_idx) {
 782                         atomic_set(&vha->vp_state, VP_FAILED);
 783                         fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
 784                 }
 785
 786                 set_bit(REGISTER_FC4_NEEDED, &vha->dpc_flags);
 787                 set_bit(REGISTER_FDMI_NEEDED, &vha->dpc_flags);
 788
 789                 vha->flags.management_server_logged_in = 0;
 790                 qla2x00_post_aen_work(vha, FCH_EVT_LIP, mb[1]);
 791                 break;
 792
 793         case MBA_LOOP_UP:               /* Loop Up Event */
 794                 if (IS_QLA2100(ha) || IS_QLA2200(ha))
 795                         ha->link_data_rate = PORT_SPEED_1GB;
 796                 else
 797                         ha->link_data_rate = mb[1];
 798
 799                 ql_log(ql_log_info, vha, 0x500a,
 800                     "LOOP UP detected (%s Gbps).\n",
 801                     qla2x00_get_link_speed_str(ha, ha->link_data_rate));
 802
 803                 vha->flags.management_server_logged_in = 0;
 804                 qla2x00_post_aen_work(vha, FCH_EVT_LINKUP, ha->link_data_rate);
 805
 806                 if (AUTO_DETECT_SFP_SUPPORT(vha)) {
 807                         set_bit(DETECT_SFP_CHANGE, &vha->dpc_flags);
 808                         qla2xxx_wake_dpc(vha);
 809                 }
 810                 break;
 811
 812         case MBA_LOOP_DOWN:             /* Loop Down Event */
 813                 SAVE_TOPO(ha);
 814                 ha->flags.n2n_ae = 0;
 815                 ha->flags.lip_ae = 0;
 816                 ha->current_topology = 0;
 817
 818                 mbx = (IS_QLA81XX(ha) || IS_QLA8031(ha))
 819                         ? RD_REG_WORD(&reg24->mailbox4) : 0;
 820                 mbx = (IS_P3P_TYPE(ha)) ? RD_REG_WORD(&reg82->mailbox_out[4])
 821                         : mbx;
 822                 ql_log(ql_log_info, vha, 0x500b,
 823                     "LOOP DOWN detected (%x %x %x %x).\n",
 824                     mb[1], mb[2], mb[3], mbx);
 825
 826                 if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
 827                         atomic_set(&vha->loop_state, LOOP_DOWN);
 828                         atomic_set(&vha->loop_down_timer, LOOP_DOWN_TIME);
 829                         /*
 830                          * In case of loop down, restore WWPN from
 831                          * NVRAM in case of FA-WWPN capable ISP
 832                          * Restore for Physical Port only
 833                          */
 834                         if (!vha->vp_idx) {
 835                                 if (ha->flags.fawwpn_enabled) {
 836                                         void *wwpn = ha->init_cb->port_name;
 837                                         memcpy(vha->port_name, wwpn, WWN_SIZE);
 838                                         fc_host_port_name(vha->host) =
 839                                             wwn_to_u64(vha->port_name);
 840                                         ql_dbg(ql_dbg_init + ql_dbg_verbose,
 841                                             vha, 0x00d8, "LOOP DOWN detected,"
 842                                             "restore WWPN %016llx\n",
 843                                             wwn_to_u64(vha->port_name));
 844                                 }
 845
 846                                 clear_bit(VP_CONFIG_OK, &vha->vp_flags);
 847                         }
 848
 849                         vha->device_flags |= DFLG_NO_CABLE;
 850                         qla2x00_mark_all_devices_lost(vha, 1);
 851                 }
 852
 853                 if (vha->vp_idx) {
 854                         atomic_set(&vha->vp_state, VP_FAILED);
 855                         fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
 856                 }
 857
 858                 vha->flags.management_server_logged_in = 0;
 859                 ha->link_data_rate = PORT_SPEED_UNKNOWN;
 860                 qla2x00_post_aen_work(vha, FCH_EVT_LINKDOWN, 0);
 861                 break;
 862
 863         case MBA_LIP_RESET:             /* LIP reset occurred */
 864                 ql_dbg(ql_dbg_async, vha, 0x500c,
 865                     "LIP reset occurred (%x).\n", mb[1]);
 866
 867                 if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
 868                         atomic_set(&vha->loop_state, LOOP_DOWN);
 869                         atomic_set(&vha->loop_down_timer, LOOP_DOWN_TIME);
 870                         qla2x00_mark_all_devices_lost(vha, 1);
 871                 }
 872
 873                 if (vha->vp_idx) {
 874                         atomic_set(&vha->vp_state, VP_FAILED);
 875                         fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
 876                 }
 877
 878                 set_bit(RESET_MARKER_NEEDED, &vha->dpc_flags);
 879
 880                 ha->operating_mode = LOOP;
 881                 vha->flags.management_server_logged_in = 0;
 882                 qla2x00_post_aen_work(vha, FCH_EVT_LIPRESET, mb[1]);
 883                 break;
 884
 885         /* case MBA_DCBX_COMPLETE: */
 886         case MBA_POINT_TO_POINT:        /* Point-to-Point */
 887                 ha->flags.lip_ae = 0;
 888                 ha->flags.n2n_ae = 1;
 889
 890                 if (IS_QLA2100(ha))
 891                         break;
 892
 893                 if (IS_CNA_CAPABLE(ha)) {
 894                         ql_dbg(ql_dbg_async, vha, 0x500d,
 895                             "DCBX Completed -- %04x %04x %04x.\n",
 896                             mb[1], mb[2], mb[3]);
 897                         if (ha->notify_dcbx_comp && !vha->vp_idx)
 898                                 complete(&ha->dcbx_comp);
 899
 900                 } else
 901                         ql_dbg(ql_dbg_async, vha, 0x500e,
 902                             "Asynchronous P2P MODE received.\n");
 903
 904                 /*
 905                  * Until there's a transition from loop down to loop up, treat
 906                  * this as loop down only.
 907                  */
 908                 if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
 909                         atomic_set(&vha->loop_state, LOOP_DOWN);
 910                         if (!atomic_read(&vha->loop_down_timer))
 911                                 atomic_set(&vha->loop_down_timer,
 912                                     LOOP_DOWN_TIME);
 913                         qla2x00_mark_all_devices_lost(vha, 1);
 914                 }
 915
 916                 if (vha->vp_idx) {
 917                         atomic_set(&vha->vp_state, VP_FAILED);
 918                         fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
 919                 }
 920
 921                 if (!(test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags)))
 922                         set_bit(RESET_MARKER_NEEDED, &vha->dpc_flags);
 923
 924                 set_bit(REGISTER_FC4_NEEDED, &vha->dpc_flags);
 925                 set_bit(REGISTER_FDMI_NEEDED, &vha->dpc_flags);
 926
 927                 vha->flags.management_server_logged_in = 0;
 928                 break;
 929
 930         case MBA_CHG_IN_CONNECTION:     /* Change in connection mode */
 931                 if (IS_QLA2100(ha))
 932                         break;
 933
 934                 ql_dbg(ql_dbg_async, vha, 0x500f,
 935                     "Configuration change detected: value=%x.\n", mb[1]);
 936
 937                 if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
 938                         atomic_set(&vha->loop_state, LOOP_DOWN);
 939                         if (!atomic_read(&vha->loop_down_timer))
 940                                 atomic_set(&vha->loop_down_timer,
 941                                     LOOP_DOWN_TIME);
 942                         qla2x00_mark_all_devices_lost(vha, 1);
 943                 }
 944
 945                 if (vha->vp_idx) {
 946                         atomic_set(&vha->vp_state, VP_FAILED);
 947                         fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
 948                 }
 949
 950                 set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
 951                 set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
 952                 break;
 953
 954         case MBA_PORT_UPDATE:           /* Port database update */
 955                 /*
 956                  * Handle only global and vn-port update events
 957                  *
 958                  * Relevant inputs:
 959                  * mb[1] = N_Port handle of changed port
 960                  * OR 0xffff for global event
 961                  * mb[2] = New login state
 962                  * 7 = Port logged out
 963                  * mb[3] = LSB is vp_idx, 0xff = all vps
 964                  *
 965                  * Skip processing if:
 966                  *       Event is global, vp_idx is NOT all vps,
 967                  *           vp_idx does not match
 968                  *       Event is not global, vp_idx does not match
 969                  */
 970                 if (IS_QLA2XXX_MIDTYPE(ha) &&
 971                     ((mb[1] == 0xffff && (mb[3] & 0xff) != 0xff) ||
 972                         (mb[1] != 0xffff)) && vha->vp_idx != (mb[3] & 0xff))
 973                         break;
 974
 975                 if (mb[2] == 0x7) {
 976                         ql_dbg(ql_dbg_async, vha, 0x5010,
 977                             "Port %s %04x %04x %04x.\n",
 978                             mb[1] == 0xffff ? "unavailable" : "logout",
 979                             mb[1], mb[2], mb[3]);
 980
 981                         if (mb[1] == 0xffff)
 982                                 goto global_port_update;
 983
 984                         if (mb[1] == NPH_SNS_LID(ha)) {
 985                                 set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
 986                                 set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
 987                                 break;
 988                         }
 989
 990                         /* use handle_cnt for loop id/nport handle */
 991                         if (IS_FWI2_CAPABLE(ha))
 992                                 handle_cnt = NPH_SNS;
 993                         else
 994                                 handle_cnt = SIMPLE_NAME_SERVER;
 995                         if (mb[1] == handle_cnt) {
 996                                 set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
 997                                 set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
 998                                 break;
 999                         }
1000
1001                         /* Port logout */
1002                         fcport = qla2x00_find_fcport_by_loopid(vha, mb[1]);
1003                         if (!fcport)
1004                                 break;
1005                         if (atomic_read(&fcport->state) != FCS_ONLINE)
1006                                 break;
1007                         ql_dbg(ql_dbg_async, vha, 0x508a,
1008                             "Marking port lost loopid=%04x portid=%06x.\n",
1009                             fcport->loop_id, fcport->d_id.b24);
1010                         if (qla_ini_mode_enabled(vha)) {
1011                                 qla2x00_mark_device_lost(fcport->vha, fcport, 1, 1);
1012                                 fcport->logout_on_delete = 0;
1013                                 qlt_schedule_sess_for_deletion(fcport);
1014                         }
1015                         break;
1016
1017 global_port_update:
1018                         if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
1019                                 atomic_set(&vha->loop_state, LOOP_DOWN);
1020                                 atomic_set(&vha->loop_down_timer,
1021                                     LOOP_DOWN_TIME);
1022                                 vha->device_flags |= DFLG_NO_CABLE;
1023                                 qla2x00_mark_all_devices_lost(vha, 1);
1024                         }
1025
1026                         if (vha->vp_idx) {
1027                                 atomic_set(&vha->vp_state, VP_FAILED);
1028                                 fc_vport_set_state(vha->fc_vport,
1029                                     FC_VPORT_FAILED);
1030                                 qla2x00_mark_all_devices_lost(vha, 1);
1031                         }
1032
1033                         vha->flags.management_server_logged_in = 0;
1034                         ha->link_data_rate = PORT_SPEED_UNKNOWN;
1035                         break;
1036                 }
1037
1038                 /*
1039                  * If PORT UPDATE is global (received LIP_OCCURRED/LIP_RESET
1040                  * event etc. earlier indicating loop is down) then process
1041                  * it.  Otherwise ignore it and Wait for RSCN to come in.
1042                  */
1043                 atomic_set(&vha->loop_down_timer, 0);
1044                 if (atomic_read(&vha->loop_state) != LOOP_DOWN &&
1045                         !ha->flags.n2n_ae  &&
1046                     atomic_read(&vha->loop_state) != LOOP_DEAD) {
1047                         ql_dbg(ql_dbg_async, vha, 0x5011,
1048                             "Asynchronous PORT UPDATE ignored %04x/%04x/%04x.\n",
1049                             mb[1], mb[2], mb[3]);
1050
1051                         qlt_async_event(mb[0], vha, mb);
1052                         break;
1053                 }
1054
1055                 ql_dbg(ql_dbg_async, vha, 0x5012,
1056                     "Port database changed %04x %04x %04x.\n",
1057                     mb[1], mb[2], mb[3]);
1058
1059                 /*
1060                  * Mark all devices as missing so we will login again.
1061                  */
1062                 atomic_set(&vha->loop_state, LOOP_UP);
1063                 vha->scan.scan_retry = 0;
1064
1065                 set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
1066                 set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
1067                 set_bit(VP_CONFIG_OK, &vha->vp_flags);
1068
1069                 qlt_async_event(mb[0], vha, mb);
1070                 break;
1071
1072         case MBA_RSCN_UPDATE:           /* State Change Registration */
1073                 /* Check if the Vport has issued a SCR */
1074                 if (vha->vp_idx && test_bit(VP_SCR_NEEDED, &vha->vp_flags))
1075                         break;
1076                 /* Only handle SCNs for our Vport index. */
1077                 if (ha->flags.npiv_supported && vha->vp_idx != (mb[3] & 0xff))
1078                         break;
1079
1080                 ql_dbg(ql_dbg_async, vha, 0x5013,
1081                     "RSCN database changed -- %04x %04x %04x.\n",
1082                     mb[1], mb[2], mb[3]);
1083
1084                 rscn_entry = ((mb[1] & 0xff) << 16) | mb[2];
1085                 host_pid = (vha->d_id.b.domain << 16) | (vha->d_id.b.area << 8)
1086                                 | vha->d_id.b.al_pa;
1087                 if (rscn_entry == host_pid) {
1088                         ql_dbg(ql_dbg_async, vha, 0x5014,
1089                             "Ignoring RSCN update to local host "
1090                             "port ID (%06x).\n", host_pid);
1091                         break;
1092                 }
1093
1094                 /* Ignore reserved bits from RSCN-payload. */
1095                 rscn_entry = ((mb[1] & 0x3ff) << 16) | mb[2];
1096
1097                 /* Skip RSCNs for virtual ports on the same physical port */
1098                 if (qla2x00_is_a_vp_did(vha, rscn_entry))
1099                         break;
1100
1101                 atomic_set(&vha->loop_down_timer, 0);
1102                 vha->flags.management_server_logged_in = 0;
1103                 {
1104                         struct event_arg ea;
1105
1106                         memset(&ea, 0, sizeof(ea));
1107                         ea.event = FCME_RSCN;
1108                         ea.id.b24 = rscn_entry;
1109                         ea.id.b.rsvd_1 = rscn_entry >> 24;
1110                         qla2x00_fcport_event_handler(vha, &ea);
1111                         qla2x00_post_aen_work(vha, FCH_EVT_RSCN, rscn_entry);
1112                 }
1113                 break;
1114         /* case MBA_RIO_RESPONSE: */
1115         case MBA_ZIO_RESPONSE:
1116                 ql_dbg(ql_dbg_async, vha, 0x5015,
1117                     "[R|Z]IO update completion.\n");
1118
1119                 if (IS_FWI2_CAPABLE(ha))
1120                         qla24xx_process_response_queue(vha, rsp);
1121                 else
1122                         qla2x00_process_response_queue(rsp);
1123                 break;
1124
1125         case MBA_DISCARD_RND_FRAME:
1126                 ql_dbg(ql_dbg_async, vha, 0x5016,
1127                     "Discard RND Frame -- %04x %04x %04x.\n",
1128                     mb[1], mb[2], mb[3]);
1129                 break;
1130
1131         case MBA_TRACE_NOTIFICATION:
1132                 ql_dbg(ql_dbg_async, vha, 0x5017,
1133                     "Trace Notification -- %04x %04x.\n", mb[1], mb[2]);
1134                 break;
1135
1136         case MBA_ISP84XX_ALERT:
1137                 ql_dbg(ql_dbg_async, vha, 0x5018,
1138                     "ISP84XX Alert Notification -- %04x %04x %04x.\n",
1139                     mb[1], mb[2], mb[3]);
1140
1141                 spin_lock_irqsave(&ha->cs84xx->access_lock, flags);
1142                 switch (mb[1]) {
1143                 case A84_PANIC_RECOVERY:
1144                         ql_log(ql_log_info, vha, 0x5019,
1145                             "Alert 84XX: panic recovery %04x %04x.\n",
1146                             mb[2], mb[3]);
1147                         break;
1148                 case A84_OP_LOGIN_COMPLETE:
1149                         ha->cs84xx->op_fw_version = mb[3] << 16 | mb[2];
1150                         ql_log(ql_log_info, vha, 0x501a,
1151                             "Alert 84XX: firmware version %x.\n",
1152                             ha->cs84xx->op_fw_version);
1153                         break;
1154                 case A84_DIAG_LOGIN_COMPLETE:
1155                         ha->cs84xx->diag_fw_version = mb[3] << 16 | mb[2];
1156                         ql_log(ql_log_info, vha, 0x501b,
1157                             "Alert 84XX: diagnostic firmware version %x.\n",
1158                             ha->cs84xx->diag_fw_version);
1159                         break;
1160                 case A84_GOLD_LOGIN_COMPLETE:
1161                         ha->cs84xx->diag_fw_version = mb[3] << 16 | mb[2];
1162                         ha->cs84xx->fw_update = 1;
1163                         ql_log(ql_log_info, vha, 0x501c,
1164                             "Alert 84XX: gold firmware version %x.\n",
1165                             ha->cs84xx->gold_fw_version);
1166                         break;
1167                 default:
1168                         ql_log(ql_log_warn, vha, 0x501d,
1169                             "Alert 84xx: Invalid Alert %04x %04x %04x.\n",
1170                             mb[1], mb[2], mb[3]);
1171                 }
1172                 spin_unlock_irqrestore(&ha->cs84xx->access_lock, flags);
1173                 break;
1174         case MBA_DCBX_START:
1175                 ql_dbg(ql_dbg_async, vha, 0x501e,
1176                     "DCBX Started -- %04x %04x %04x.\n",
1177                     mb[1], mb[2], mb[3]);
1178                 break;
1179         case MBA_DCBX_PARAM_UPDATE:
1180                 ql_dbg(ql_dbg_async, vha, 0x501f,
1181                     "DCBX Parameters Updated -- %04x %04x %04x.\n",
1182                     mb[1], mb[2], mb[3]);
1183                 break;
1184         case MBA_FCF_CONF_ERR:
1185                 ql_dbg(ql_dbg_async, vha, 0x5020,
1186                     "FCF Configuration Error -- %04x %04x %04x.\n",
1187                     mb[1], mb[2], mb[3]);
1188                 break;
1189         case MBA_IDC_NOTIFY:
1190                 if (IS_QLA8031(vha->hw) || IS_QLA8044(ha)) {
1191                         mb[4] = RD_REG_WORD(&reg24->mailbox4);
1192                         if (((mb[2] & 0x7fff) == MBC_PORT_RESET ||
1193                             (mb[2] & 0x7fff) == MBC_SET_PORT_CONFIG) &&
1194                             (mb[4] & INTERNAL_LOOPBACK_MASK) != 0) {
1195                                 set_bit(ISP_QUIESCE_NEEDED, &vha->dpc_flags);
1196                                 /*
1197                                  * Extend loop down timer since port is active.
1198                                  */
1199                                 if (atomic_read(&vha->loop_state) == LOOP_DOWN)
1200                                         atomic_set(&vha->loop_down_timer,
1201                                             LOOP_DOWN_TIME);
1202                                 qla2xxx_wake_dpc(vha);
1203                         }
1204                 }
1205                 /* fall through */
1206         case MBA_IDC_COMPLETE:
1207                 if (ha->notify_lb_portup_comp && !vha->vp_idx)
1208                         complete(&ha->lb_portup_comp);
1209                 /* Fallthru */
1210         case MBA_IDC_TIME_EXT:
1211                 if (IS_QLA81XX(vha->hw) || IS_QLA8031(vha->hw) ||
1212                     IS_QLA8044(ha))
1213                         qla81xx_idc_event(vha, mb[0], mb[1]);
1214                 break;
1215
1216         case MBA_IDC_AEN:
1217                 mb[4] = RD_REG_WORD(&reg24->mailbox4);
1218                 mb[5] = RD_REG_WORD(&reg24->mailbox5);
1219                 mb[6] = RD_REG_WORD(&reg24->mailbox6);
1220                 mb[7] = RD_REG_WORD(&reg24->mailbox7);
1221                 qla83xx_handle_8200_aen(vha, mb);
1222                 break;
1223
1224         case MBA_DPORT_DIAGNOSTICS:
1225                 ql_dbg(ql_dbg_async, vha, 0x5052,
1226                     "D-Port Diagnostics: %04x result=%s\n",
1227                     mb[0],
1228                     mb[1] == 0 ? "start" :
1229                     mb[1] == 1 ? "done (pass)" :
1230                     mb[1] == 2 ? "done (error)" : "other");
1231                 break;
1232
1233         case MBA_TEMPERATURE_ALERT:
1234                 ql_dbg(ql_dbg_async, vha, 0x505e,
1235                     "TEMPERATURE ALERT: %04x %04x %04x\n", mb[1], mb[2], mb[3]);
1236                 if (mb[1] == 0x12)
1237                         schedule_work(&ha->board_disable);
1238                 break;
1239
1240         case MBA_TRANS_INSERT:
1241                 ql_dbg(ql_dbg_async, vha, 0x5091,
1242                     "Transceiver Insertion: %04x\n", mb[1]);
1243                 break;
1244
1245         default:
1246                 ql_dbg(ql_dbg_async, vha, 0x5057,
1247                     "Unknown AEN:%04x %04x %04x %04x\n",
1248                     mb[0], mb[1], mb[2], mb[3]);
1249         }
1250
1251         qlt_async_event(mb[0], vha, mb);
1252
1253         if (!vha->vp_idx && ha->num_vhosts)
1254                 qla2x00_alert_all_vps(rsp, mb);
1255 }
1256
1257 /**
1258  * qla2x00_process_completed_request() - Process a Fast Post response.
1259  * @ha: SCSI driver HA context
1260  * @index: SRB index
1261  */
1262 void
1263 qla2x00_process_completed_request(struct scsi_qla_host *vha,
1264                                   struct req_que *req, uint32_t index)
1265 {
1266         srb_t *sp;
1267         struct qla_hw_data *ha = vha->hw;
1268
1269         /* Validate handle. */
1270         if (index >= req->num_outstanding_cmds) {
1271                 ql_log(ql_log_warn, vha, 0x3014,
1272                     "Invalid SCSI command index (%x).\n", index);
1273
1274                 if (IS_P3P_TYPE(ha))
1275                         set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
1276                 else
1277                         set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
1278                 return;
1279         }
1280
1281         sp = req->outstanding_cmds[index];
1282         if (sp) {
1283                 /* Free outstanding command slot. */
1284                 req->outstanding_cmds[index] = NULL;
1285
1286                 /* Save ISP completion status */
1287                 sp->done(sp, DID_OK << 16);
1288         } else {
1289                 ql_log(ql_log_warn, vha, 0x3016, "Invalid SCSI SRB.\n");
1290
1291                 if (IS_P3P_TYPE(ha))
1292                         set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
1293                 else
1294                         set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
1295         }
1296 }
1297
1298 srb_t *
1299 qla2x00_get_sp_from_handle(scsi_qla_host_t *vha, const char *func,
1300     struct req_que *req, void *iocb)
1301 {
1302         struct qla_hw_data *ha = vha->hw;
1303         sts_entry_t *pkt = iocb;
1304         srb_t *sp = NULL;
1305         uint16_t index;
1306
1307         index = LSW(pkt->handle);
1308         if (index >= req->num_outstanding_cmds) {
1309                 ql_log(ql_log_warn, vha, 0x5031,
1310                            "Invalid command index (%x) type %8ph.\n",
1311                            index, iocb);
1312                 if (IS_P3P_TYPE(ha))
1313                         set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
1314                 else
1315                         set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
1316                 goto done;
1317         }
1318         sp = req->outstanding_cmds[index];
1319         if (!sp) {
1320                 ql_log(ql_log_warn, vha, 0x5032,
1321                     "Invalid completion handle (%x) -- timed-out.\n", index);
1322                 return sp;
1323         }
1324         if (sp->handle != index) {
1325                 ql_log(ql_log_warn, vha, 0x5033,
1326                     "SRB handle (%x) mismatch %x.\n", sp->handle, index);
1327                 return NULL;
1328         }
1329
1330         req->outstanding_cmds[index] = NULL;
1331
1332 done:
1333         return sp;
1334 }
1335
1336 static void
1337 qla2x00_mbx_iocb_entry(scsi_qla_host_t *vha, struct req_que *req,
1338     struct mbx_entry *mbx)
1339 {
1340         const char func[] = "MBX-IOCB";
1341         const char *type;
1342         fc_port_t *fcport;
1343         srb_t *sp;
1344         struct srb_iocb *lio;
1345         uint16_t *data;
1346         uint16_t status;
1347
1348         sp = qla2x00_get_sp_from_handle(vha, func, req, mbx);
1349         if (!sp)
1350                 return;
1351
1352         lio = &sp->u.iocb_cmd;
1353         type = sp->name;
1354         fcport = sp->fcport;
1355         data = lio->u.logio.data;
1356
1357         data[0] = MBS_COMMAND_ERROR;
1358         data[1] = lio->u.logio.flags & SRB_LOGIN_RETRIED ?
1359             QLA_LOGIO_LOGIN_RETRIED : 0;
1360         if (mbx->entry_status) {
1361                 ql_dbg(ql_dbg_async, vha, 0x5043,
1362                     "Async-%s error entry - hdl=%x portid=%02x%02x%02x "
1363                     "entry-status=%x status=%x state-flag=%x "
1364                     "status-flags=%x.\n", type, sp->handle,
1365                     fcport->d_id.b.domain, fcport->d_id.b.area,
1366                     fcport->d_id.b.al_pa, mbx->entry_status,
1367                     le16_to_cpu(mbx->status), le16_to_cpu(mbx->state_flags),
1368                     le16_to_cpu(mbx->status_flags));
1369
1370                 ql_dump_buffer(ql_dbg_async + ql_dbg_buffer, vha, 0x5029,
1371                     (uint8_t *)mbx, sizeof(*mbx));
1372
1373                 goto logio_done;
1374         }
1375
1376         status = le16_to_cpu(mbx->status);
1377         if (status == 0x30 && sp->type == SRB_LOGIN_CMD &&
1378             le16_to_cpu(mbx->mb0) == MBS_COMMAND_COMPLETE)
1379                 status = 0;
1380         if (!status && le16_to_cpu(mbx->mb0) == MBS_COMMAND_COMPLETE) {
1381                 ql_dbg(ql_dbg_async, vha, 0x5045,
1382                     "Async-%s complete - hdl=%x portid=%02x%02x%02x mbx1=%x.\n",
1383                     type, sp->handle, fcport->d_id.b.domain,
1384                     fcport->d_id.b.area, fcport->d_id.b.al_pa,
1385                     le16_to_cpu(mbx->mb1));
1386
1387                 data[0] = MBS_COMMAND_COMPLETE;
1388                 if (sp->type == SRB_LOGIN_CMD) {
1389                         fcport->port_type = FCT_TARGET;
1390                         if (le16_to_cpu(mbx->mb1) & BIT_0)
1391                                 fcport->port_type = FCT_INITIATOR;
1392                         else if (le16_to_cpu(mbx->mb1) & BIT_1)
1393                                 fcport->flags |= FCF_FCP2_DEVICE;
1394                 }
1395                 goto logio_done;
1396         }
1397
1398         data[0] = le16_to_cpu(mbx->mb0);
1399         switch (data[0]) {
1400         case MBS_PORT_ID_USED:
1401                 data[1] = le16_to_cpu(mbx->mb1);
1402                 break;
1403         case MBS_LOOP_ID_USED:
1404                 break;
1405         default:
1406                 data[0] = MBS_COMMAND_ERROR;
1407                 break;
1408         }
1409
1410         ql_log(ql_log_warn, vha, 0x5046,
1411             "Async-%s failed - hdl=%x portid=%02x%02x%02x status=%x "
1412             "mb0=%x mb1=%x mb2=%x mb6=%x mb7=%x.\n", type, sp->handle,
1413             fcport->d_id.b.domain, fcport->d_id.b.area, fcport->d_id.b.al_pa,
1414             status, le16_to_cpu(mbx->mb0), le16_to_cpu(mbx->mb1),
1415             le16_to_cpu(mbx->mb2), le16_to_cpu(mbx->mb6),
1416             le16_to_cpu(mbx->mb7));
1417
1418 logio_done:
1419         sp->done(sp, 0);
1420 }
1421
1422 static void
1423 qla24xx_mbx_iocb_entry(scsi_qla_host_t *vha, struct req_que *req,
1424     struct mbx_24xx_entry *pkt)
1425 {
1426         const char func[] = "MBX-IOCB2";
1427         srb_t *sp;
1428         struct srb_iocb *si;
1429         u16 sz, i;
1430         int res;
1431
1432         sp = qla2x00_get_sp_from_handle(vha, func, req, pkt);
1433         if (!sp)
1434                 return;
1435
1436         si = &sp->u.iocb_cmd;
1437         sz = min(ARRAY_SIZE(pkt->mb), ARRAY_SIZE(sp->u.iocb_cmd.u.mbx.in_mb));
1438
1439         for (i = 0; i < sz; i++)
1440                 si->u.mbx.in_mb[i] = le16_to_cpu(pkt->mb[i]);
1441
1442         res = (si->u.mbx.in_mb[0] & MBS_MASK);
1443
1444         sp->done(sp, res);
1445 }
1446
1447 static void
1448 qla24xxx_nack_iocb_entry(scsi_qla_host_t *vha, struct req_que *req,
1449     struct nack_to_isp *pkt)
1450 {
1451         const char func[] = "nack";
1452         srb_t *sp;
1453         int res = 0;
1454
1455         sp = qla2x00_get_sp_from_handle(vha, func, req, pkt);
1456         if (!sp)
1457                 return;
1458
1459         if (pkt->u.isp2x.status != cpu_to_le16(NOTIFY_ACK_SUCCESS))
1460                 res = QLA_FUNCTION_FAILED;
1461
1462         sp->done(sp, res);
1463 }
1464
1465 static void
1466 qla2x00_ct_entry(scsi_qla_host_t *vha, struct req_que *req,
1467     sts_entry_t *pkt, int iocb_type)
1468 {
1469         const char func[] = "CT_IOCB";
1470         const char *type;
1471         srb_t *sp;
1472         struct bsg_job *bsg_job;
1473         struct fc_bsg_reply *bsg_reply;
1474         uint16_t comp_status;
1475         int res = 0;
1476
1477         sp = qla2x00_get_sp_from_handle(vha, func, req, pkt);
1478         if (!sp)
1479                 return;
1480
1481         switch (sp->type) {
1482         case SRB_CT_CMD:
1483             bsg_job = sp->u.bsg_job;
1484             bsg_reply = bsg_job->reply;
1485
1486             type = "ct pass-through";
1487
1488             comp_status = le16_to_cpu(pkt->comp_status);
1489
1490             /*
1491              * return FC_CTELS_STATUS_OK and leave the decoding of the ELS/CT
1492              * fc payload  to the caller
1493              */
1494             bsg_reply->reply_data.ctels_reply.status = FC_CTELS_STATUS_OK;
1495             bsg_job->reply_len = sizeof(struct fc_bsg_reply);
1496
1497             if (comp_status != CS_COMPLETE) {
1498                     if (comp_status == CS_DATA_UNDERRUN) {
1499                             res = DID_OK << 16;
1500                             bsg_reply->reply_payload_rcv_len =
1501                                 le16_to_cpu(((sts_entry_t *)pkt)->rsp_info_len);
1502
1503                             ql_log(ql_log_warn, vha, 0x5048,
1504                                 "CT pass-through-%s error comp_status=0x%x total_byte=0x%x.\n",
1505                                 type, comp_status,
1506                                 bsg_reply->reply_payload_rcv_len);
1507                     } else {
1508                             ql_log(ql_log_warn, vha, 0x5049,
1509                                 "CT pass-through-%s error comp_status=0x%x.\n",
1510                                 type, comp_status);
1511                             res = DID_ERROR << 16;
1512                             bsg_reply->reply_payload_rcv_len = 0;
1513                     }
1514                     ql_dump_buffer(ql_dbg_async + ql_dbg_buffer, vha, 0x5035,
1515                         (uint8_t *)pkt, sizeof(*pkt));
1516             } else {
1517                     res = DID_OK << 16;
1518                     bsg_reply->reply_payload_rcv_len =
1519                         bsg_job->reply_payload.payload_len;
1520                     bsg_job->reply_len = 0;
1521             }
1522             break;
1523         case SRB_CT_PTHRU_CMD:
1524             /*
1525              * borrowing sts_entry_24xx.comp_status.
1526              * same location as ct_entry_24xx.comp_status
1527              */
1528              res = qla2x00_chk_ms_status(vha, (ms_iocb_entry_t *)pkt,
1529                  (struct ct_sns_rsp *)sp->u.iocb_cmd.u.ctarg.rsp,
1530                  sp->name);
1531              break;
1532         }
1533
1534         sp->done(sp, res);
1535 }
1536
1537 static void
1538 qla24xx_els_ct_entry(scsi_qla_host_t *vha, struct req_que *req,
1539     struct sts_entry_24xx *pkt, int iocb_type)
1540 {
1541         const char func[] = "ELS_CT_IOCB";
1542         const char *type;
1543         srb_t *sp;
1544         struct bsg_job *bsg_job;
1545         struct fc_bsg_reply *bsg_reply;
1546         uint16_t comp_status;
1547         uint32_t fw_status[3];
1548         int res;
1549         struct srb_iocb *els;
1550
1551         sp = qla2x00_get_sp_from_handle(vha, func, req, pkt);
1552         if (!sp)
1553                 return;
1554
1555         type = NULL;
1556         switch (sp->type) {
1557         case SRB_ELS_CMD_RPT:
1558         case SRB_ELS_CMD_HST:
1559                 type = "els";
1560                 break;
1561         case SRB_CT_CMD:
1562                 type = "ct pass-through";
1563                 break;
1564         case SRB_ELS_DCMD:
1565                 type = "Driver ELS logo";
1566                 if (iocb_type != ELS_IOCB_TYPE) {
1567                         ql_dbg(ql_dbg_user, vha, 0x5047,
1568                             "Completing %s: (%p) type=%d.\n",
1569                             type, sp, sp->type);
1570                         sp->done(sp, 0);
1571                         return;
1572                 }
1573                 break;
1574         case SRB_CT_PTHRU_CMD:
1575                 /* borrowing sts_entry_24xx.comp_status.
1576                    same location as ct_entry_24xx.comp_status
1577                  */
1578                 res = qla2x00_chk_ms_status(sp->vha, (ms_iocb_entry_t *)pkt,
1579                         (struct ct_sns_rsp *)sp->u.iocb_cmd.u.ctarg.rsp,
1580                         sp->name);
1581                 sp->done(sp, res);
1582                 return;
1583         default:
1584                 ql_dbg(ql_dbg_user, vha, 0x503e,
1585                     "Unrecognized SRB: (%p) type=%d.\n", sp, sp->type);
1586                 return;
1587         }
1588
1589         comp_status = fw_status[0] = le16_to_cpu(pkt->comp_status);
1590         fw_status[1] = le16_to_cpu(((struct els_sts_entry_24xx*)pkt)->error_subcode_1);
1591         fw_status[2] = le16_to_cpu(((struct els_sts_entry_24xx*)pkt)->error_subcode_2);
1592
1593         if (iocb_type == ELS_IOCB_TYPE) {
1594                 els = &sp->u.iocb_cmd;
1595                 els->u.els_plogi.fw_status[0] = fw_status[0];
1596                 els->u.els_plogi.fw_status[1] = fw_status[1];
1597                 els->u.els_plogi.fw_status[2] = fw_status[2];
1598                 els->u.els_plogi.comp_status = fw_status[0];
1599                 if (comp_status == CS_COMPLETE) {
1600                         res =  DID_OK << 16;
1601                 } else {
1602                         if (comp_status == CS_DATA_UNDERRUN) {
1603                                 res =  DID_OK << 16;
1604                                 els->u.els_plogi.len =
1605                                 le16_to_cpu(((struct els_sts_entry_24xx *)
1606                                         pkt)->total_byte_count);
1607                         } else {
1608                                 els->u.els_plogi.len = 0;
1609                                 res = DID_ERROR << 16;
1610                         }
1611                 }
1612                 ql_log(ql_log_info, vha, 0x503f,
1613                     "ELS IOCB Done -%s error hdl=%x comp_status=0x%x error subcode 1=0x%x error subcode 2=0x%x total_byte=0x%x\n",
1614                     type, sp->handle, comp_status, fw_status[1], fw_status[2],
1615                     le16_to_cpu(((struct els_sts_entry_24xx *)
1616                         pkt)->total_byte_count));
1617                 goto els_ct_done;
1618         }
1619
1620         /* return FC_CTELS_STATUS_OK and leave the decoding of the ELS/CT
1621          * fc payload  to the caller
1622          */
1623         bsg_job = sp->u.bsg_job;
1624         bsg_reply = bsg_job->reply;
1625         bsg_reply->reply_data.ctels_reply.status = FC_CTELS_STATUS_OK;
1626         bsg_job->reply_len = sizeof(struct fc_bsg_reply) + sizeof(fw_status);
1627
1628         if (comp_status != CS_COMPLETE) {
1629                 if (comp_status == CS_DATA_UNDERRUN) {
1630                         res = DID_OK << 16;
1631                         bsg_reply->reply_payload_rcv_len =
1632                             le16_to_cpu(((struct els_sts_entry_24xx *)pkt)->total_byte_count);
1633
1634                         ql_dbg(ql_dbg_user, vha, 0x503f,
1635                             "ELS-CT pass-through-%s error hdl=%x comp_status-status=0x%x "
1636                             "error subcode 1=0x%x error subcode 2=0x%x total_byte = 0x%x.\n",
1637                             type, sp->handle, comp_status, fw_status[1], fw_status[2],
1638                             le16_to_cpu(((struct els_sts_entry_24xx *)
1639                                 pkt)->total_byte_count));
1640                 } else {
1641                         ql_dbg(ql_dbg_user, vha, 0x5040,
1642                             "ELS-CT pass-through-%s error hdl=%x comp_status-status=0x%x "
1643                             "error subcode 1=0x%x error subcode 2=0x%x.\n",
1644                             type, sp->handle, comp_status,
1645                             le16_to_cpu(((struct els_sts_entry_24xx *)
1646                                 pkt)->error_subcode_1),
1647                             le16_to_cpu(((struct els_sts_entry_24xx *)
1648                                     pkt)->error_subcode_2));
1649                         res = DID_ERROR << 16;
1650                         bsg_reply->reply_payload_rcv_len = 0;
1651                 }
1652                 memcpy(bsg_job->reply + sizeof(struct fc_bsg_reply),
1653                        fw_status, sizeof(fw_status));
1654                 ql_dump_buffer(ql_dbg_user + ql_dbg_buffer, vha, 0x5056,
1655                                 (uint8_t *)pkt, sizeof(*pkt));
1656         }
1657         else {
1658                 res =  DID_OK << 16;
1659                 bsg_reply->reply_payload_rcv_len = bsg_job->reply_payload.payload_len;
1660                 bsg_job->reply_len = 0;
1661         }
1662 els_ct_done:
1663
1664         sp->done(sp, res);
1665 }
1666
1667 static void
1668 qla24xx_logio_entry(scsi_qla_host_t *vha, struct req_que *req,
1669     struct logio_entry_24xx *logio)
1670 {
1671         const char func[] = "LOGIO-IOCB";
1672         const char *type;
1673         fc_port_t *fcport;
1674         srb_t *sp;
1675         struct srb_iocb *lio;
1676         uint16_t *data;
1677         uint32_t iop[2];
1678
1679         sp = qla2x00_get_sp_from_handle(vha, func, req, logio);
1680         if (!sp)
1681                 return;
1682
1683         lio = &sp->u.iocb_cmd;
1684         type = sp->name;
1685         fcport = sp->fcport;
1686         data = lio->u.logio.data;
1687
1688         data[0] = MBS_COMMAND_ERROR;
1689         data[1] = lio->u.logio.flags & SRB_LOGIN_RETRIED ?
1690                 QLA_LOGIO_LOGIN_RETRIED : 0;
1691         if (logio->entry_status) {
1692                 ql_log(ql_log_warn, fcport->vha, 0x5034,
1693                     "Async-%s error entry - %8phC hdl=%x"
1694                     "portid=%02x%02x%02x entry-status=%x.\n",
1695                     type, fcport->port_name, sp->handle, fcport->d_id.b.domain,
1696                     fcport->d_id.b.area, fcport->d_id.b.al_pa,
1697                     logio->entry_status);
1698                 ql_dump_buffer(ql_dbg_async + ql_dbg_buffer, vha, 0x504d,
1699                     (uint8_t *)logio, sizeof(*logio));
1700
1701                 goto logio_done;
1702         }
1703
1704         if (le16_to_cpu(logio->comp_status) == CS_COMPLETE) {
1705                 ql_dbg(ql_dbg_async, fcport->vha, 0x5036,
1706                     "Async-%s complete - %8phC hdl=%x portid=%02x%02x%02x "
1707                     "iop0=%x.\n", type, fcport->port_name, sp->handle,
1708                     fcport->d_id.b.domain,
1709                     fcport->d_id.b.area, fcport->d_id.b.al_pa,
1710                     le32_to_cpu(logio->io_parameter[0]));
1711
1712                 vha->hw->exch_starvation = 0;
1713                 data[0] = MBS_COMMAND_COMPLETE;
1714                 if (sp->type != SRB_LOGIN_CMD)
1715                         goto logio_done;
1716
1717                 iop[0] = le32_to_cpu(logio->io_parameter[0]);
1718                 if (iop[0] & BIT_4) {
1719                         fcport->port_type = FCT_TARGET;
1720                         if (iop[0] & BIT_8)
1721                                 fcport->flags |= FCF_FCP2_DEVICE;
1722                 } else if (iop[0] & BIT_5)
1723                         fcport->port_type = FCT_INITIATOR;
1724
1725                 if (iop[0] & BIT_7)
1726                         fcport->flags |= FCF_CONF_COMP_SUPPORTED;
1727
1728                 if (logio->io_parameter[7] || logio->io_parameter[8])
1729                         fcport->supported_classes |= FC_COS_CLASS2;
1730                 if (logio->io_parameter[9] || logio->io_parameter[10])
1731                         fcport->supported_classes |= FC_COS_CLASS3;
1732
1733                 goto logio_done;
1734         }
1735
1736         iop[0] = le32_to_cpu(logio->io_parameter[0]);
1737         iop[1] = le32_to_cpu(logio->io_parameter[1]);
1738         lio->u.logio.iop[0] = iop[0];
1739         lio->u.logio.iop[1] = iop[1];
1740         switch (iop[0]) {
1741         case LSC_SCODE_PORTID_USED:
1742                 data[0] = MBS_PORT_ID_USED;
1743                 data[1] = LSW(iop[1]);
1744                 break;
1745         case LSC_SCODE_NPORT_USED:
1746                 data[0] = MBS_LOOP_ID_USED;
1747                 break;
1748         case LSC_SCODE_CMD_FAILED:
1749                 if (iop[1] == 0x0606) {
1750                         /*
1751                          * PLOGI/PRLI Completed. We must have Recv PLOGI/PRLI,
1752                          * Target side acked.
1753                          */
1754                         data[0] = MBS_COMMAND_COMPLETE;
1755                         goto logio_done;
1756                 }
1757                 data[0] = MBS_COMMAND_ERROR;
1758                 break;
1759         case LSC_SCODE_NOXCB:
1760                 vha->hw->exch_starvation++;
1761                 if (vha->hw->exch_starvation > 5) {
1762                         ql_log(ql_log_warn, vha, 0xd046,
1763                             "Exchange starvation. Resetting RISC\n");
1764
1765                         vha->hw->exch_starvation = 0;
1766
1767                         if (IS_P3P_TYPE(vha->hw))
1768                                 set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
1769                         else
1770                                 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
1771                         qla2xxx_wake_dpc(vha);
1772                 }
1773                 /* fall through */
1774         default:
1775                 data[0] = MBS_COMMAND_ERROR;
1776                 break;
1777         }
1778
1779         ql_dbg(ql_dbg_async, fcport->vha, 0x5037,
1780             "Async-%s failed - %8phC hdl=%x portid=%02x%02x%02x comp=%x "
1781             "iop0=%x iop1=%x.\n", type, fcport->port_name,
1782                 sp->handle, fcport->d_id.b.domain,
1783             fcport->d_id.b.area, fcport->d_id.b.al_pa,
1784             le16_to_cpu(logio->comp_status),
1785             le32_to_cpu(logio->io_parameter[0]),
1786             le32_to_cpu(logio->io_parameter[1]));
1787
1788 logio_done:
1789         sp->done(sp, 0);
1790 }
1791
1792 static void
1793 qla24xx_tm_iocb_entry(scsi_qla_host_t *vha, struct req_que *req, void *tsk)
1794 {
1795         const char func[] = "TMF-IOCB";
1796         const char *type;
1797         fc_port_t *fcport;
1798         srb_t *sp;
1799         struct srb_iocb *iocb;
1800         struct sts_entry_24xx *sts = (struct sts_entry_24xx *)tsk;
1801
1802         sp = qla2x00_get_sp_from_handle(vha, func, req, tsk);
1803         if (!sp)
1804                 return;
1805
1806         iocb = &sp->u.iocb_cmd;
1807         type = sp->name;
1808         fcport = sp->fcport;
1809         iocb->u.tmf.data = QLA_SUCCESS;
1810
1811         if (sts->entry_status) {
1812                 ql_log(ql_log_warn, fcport->vha, 0x5038,
1813                     "Async-%s error - hdl=%x entry-status(%x).\n",
1814                     type, sp->handle, sts->entry_status);
1815                 iocb->u.tmf.data = QLA_FUNCTION_FAILED;
1816         } else if (sts->comp_status != cpu_to_le16(CS_COMPLETE)) {
1817                 ql_log(ql_log_warn, fcport->vha, 0x5039,
1818                     "Async-%s error - hdl=%x completion status(%x).\n",
1819                     type, sp->handle, sts->comp_status);
1820                 iocb->u.tmf.data = QLA_FUNCTION_FAILED;
1821         } else if ((le16_to_cpu(sts->scsi_status) &
1822             SS_RESPONSE_INFO_LEN_VALID)) {
1823                 if (le32_to_cpu(sts->rsp_data_len) < 4) {
1824                         ql_log(ql_log_warn, fcport->vha, 0x503b,
1825                             "Async-%s error - hdl=%x not enough response(%d).\n",
1826                             type, sp->handle, sts->rsp_data_len);
1827                 } else if (sts->data[3]) {
1828                         ql_log(ql_log_warn, fcport->vha, 0x503c,
1829                             "Async-%s error - hdl=%x response(%x).\n",
1830                             type, sp->handle, sts->data[3]);
1831                         iocb->u.tmf.data = QLA_FUNCTION_FAILED;
1832                 }
1833         }
1834
1835         if (iocb->u.tmf.data != QLA_SUCCESS)
1836                 ql_dump_buffer(ql_dbg_async + ql_dbg_buffer, vha, 0x5055,
1837                     (uint8_t *)sts, sizeof(*sts));
1838
1839         sp->done(sp, 0);
1840 }
1841
1842 static void
1843 qla24xx_nvme_iocb_entry(scsi_qla_host_t *vha, struct req_que *req, void *tsk)
1844 {
1845         const char func[] = "NVME-IOCB";
1846         fc_port_t *fcport;
1847         srb_t *sp;
1848         struct srb_iocb *iocb;
1849         struct sts_entry_24xx *sts = (struct sts_entry_24xx *)tsk;
1850         uint16_t        state_flags;
1851         struct nvmefc_fcp_req *fd;
1852         uint16_t        ret = 0;
1853         struct srb_iocb *nvme;
1854
1855         sp = qla2x00_get_sp_from_handle(vha, func, req, tsk);
1856         if (!sp)
1857                 return;
1858
1859         iocb = &sp->u.iocb_cmd;
1860         fcport = sp->fcport;
1861         iocb->u.nvme.comp_status = le16_to_cpu(sts->comp_status);
1862         state_flags  = le16_to_cpu(sts->state_flags);
1863         fd = iocb->u.nvme.desc;
1864         nvme = &sp->u.iocb_cmd;
1865
1866         if (unlikely(nvme->u.nvme.aen_op))
1867                 atomic_dec(&sp->vha->hw->nvme_active_aen_cnt);
1868
1869         /*
1870          * State flags: Bit 6 and 0.
1871          * If 0 is set, we don't care about 6.
1872          * both cases resp was dma'd to host buffer
1873          * if both are 0, that is good path case.
1874          * if six is set and 0 is clear, we need to
1875          * copy resp data from status iocb to resp buffer.
1876          */
1877         if (!(state_flags & (SF_FCP_RSP_DMA | SF_NVME_ERSP))) {
1878                 iocb->u.nvme.rsp_pyld_len = 0;
1879         } else if ((state_flags & SF_FCP_RSP_DMA)) {
1880                 iocb->u.nvme.rsp_pyld_len = le16_to_cpu(sts->nvme_rsp_pyld_len);
1881         } else if (state_flags & SF_NVME_ERSP) {
1882                 uint32_t *inbuf, *outbuf;
1883                 uint16_t iter;
1884
1885                 inbuf = (uint32_t *)&sts->nvme_ersp_data;
1886                 outbuf = (uint32_t *)fd->rspaddr;
1887                 iocb->u.nvme.rsp_pyld_len = le16_to_cpu(sts->nvme_rsp_pyld_len);
1888                 iter = iocb->u.nvme.rsp_pyld_len >> 2;
1889                 for (; iter; iter--)
1890                         *outbuf++ = swab32(*inbuf++);
1891         } else { /* unhandled case */
1892             ql_log(ql_log_warn, fcport->vha, 0x503a,
1893                 "NVME-%s error. Unhandled state_flags of %x\n",
1894                 sp->name, state_flags);
1895         }
1896
1897         fd->transferred_length = fd->payload_length -
1898             le32_to_cpu(sts->residual_len);
1899
1900         /*
1901          * If transport error then Failure (HBA rejects request)
1902          * otherwise transport will handle.
1903          */
1904         if (sts->entry_status) {
1905                 ql_log(ql_log_warn, fcport->vha, 0x5038,
1906                     "NVME-%s error - hdl=%x entry-status(%x).\n",
1907                     sp->name, sp->handle, sts->entry_status);
1908                 ret = QLA_FUNCTION_FAILED;
1909         } else  {
1910                 switch (le16_to_cpu(sts->comp_status)) {
1911                         case CS_COMPLETE:
1912                                 ret = 0;
1913                         break;
1914
1915                         case CS_ABORTED:
1916                         case CS_RESET:
1917                         case CS_PORT_UNAVAILABLE:
1918                         case CS_PORT_LOGGED_OUT:
1919                         case CS_PORT_BUSY:
1920                                 ql_log(ql_log_warn, fcport->vha, 0x5060,
1921                                 "NVME-%s ERR Handling - hdl=%x completion status(%x) resid=%x  ox_id=%x\n",
1922                                 sp->name, sp->handle, sts->comp_status,
1923                                 le32_to_cpu(sts->residual_len), sts->ox_id);
1924                                 fd->transferred_length = fd->payload_length;
1925                                 ret = QLA_ABORTED;
1926                         break;
1927
1928                         default:
1929                                 ql_log(ql_log_warn, fcport->vha, 0x5060,
1930                                 "NVME-%s error - hdl=%x completion status(%x) resid=%x  ox_id=%x\n",
1931                                 sp->name, sp->handle, sts->comp_status,
1932                                 le32_to_cpu(sts->residual_len), sts->ox_id);
1933                                 ret = QLA_FUNCTION_FAILED;
1934                                 break;
1935                 }
1936         }
1937         sp->done(sp, ret);
1938 }
1939
1940 static void qla_ctrlvp_completed(scsi_qla_host_t *vha, struct req_que *req,
1941     struct vp_ctrl_entry_24xx *vce)
1942 {
1943         const char func[] = "CTRLVP-IOCB";
1944         srb_t *sp;
1945         int rval = QLA_SUCCESS;
1946
1947         sp = qla2x00_get_sp_from_handle(vha, func, req, vce);
1948         if (!sp)
1949                 return;
1950
1951         if (vce->entry_status != 0) {
1952                 ql_dbg(ql_dbg_vport, vha, 0x10c4,
1953                     "%s: Failed to complete IOCB -- error status (%x)\n",
1954                     sp->name, vce->entry_status);
1955                 rval = QLA_FUNCTION_FAILED;
1956         } else if (vce->comp_status != cpu_to_le16(CS_COMPLETE)) {
1957                 ql_dbg(ql_dbg_vport, vha, 0x10c5,
1958                     "%s: Failed to complete IOCB -- completion status (%x) vpidx %x\n",
1959                     sp->name, le16_to_cpu(vce->comp_status),
1960                     le16_to_cpu(vce->vp_idx_failed));
1961                 rval = QLA_FUNCTION_FAILED;
1962         } else {
1963                 ql_dbg(ql_dbg_vport, vha, 0x10c6,
1964                     "Done %s.\n", __func__);
1965         }
1966
1967         sp->rc = rval;
1968         sp->done(sp, rval);
1969 }
1970
1971 /**
1972  * qla2x00_process_response_queue() - Process response queue entries.
1973  * @ha: SCSI driver HA context
1974  */
1975 void
1976 qla2x00_process_response_queue(struct rsp_que *rsp)
1977 {
1978         struct scsi_qla_host *vha;
1979         struct qla_hw_data *ha = rsp->hw;
1980         struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
1981         sts_entry_t     *pkt;
1982         uint16_t        handle_cnt;
1983         uint16_t        cnt;
1984
1985         vha = pci_get_drvdata(ha->pdev);
1986
1987         if (!vha->flags.online)
1988                 return;
1989
1990         while (rsp->ring_ptr->signature != RESPONSE_PROCESSED) {
1991                 pkt = (sts_entry_t *)rsp->ring_ptr;
1992
1993                 rsp->ring_index++;
1994                 if (rsp->ring_index == rsp->length) {
1995                         rsp->ring_index = 0;
1996                         rsp->ring_ptr = rsp->ring;
1997                 } else {
1998                         rsp->ring_ptr++;
1999                 }
2000
2001                 if (pkt->entry_status != 0) {
2002                         qla2x00_error_entry(vha, rsp, pkt);
2003                         ((response_t *)pkt)->signature = RESPONSE_PROCESSED;
2004                         wmb();
2005                         continue;
2006                 }
2007
2008                 switch (pkt->entry_type) {
2009                 case STATUS_TYPE:
2010                         qla2x00_status_entry(vha, rsp, pkt);
2011                         break;
2012                 case STATUS_TYPE_21:
2013                         handle_cnt = ((sts21_entry_t *)pkt)->handle_count;
2014                         for (cnt = 0; cnt < handle_cnt; cnt++) {
2015                                 qla2x00_process_completed_request(vha, rsp->req,
2016                                     ((sts21_entry_t *)pkt)->handle[cnt]);
2017                         }
2018                         break;
2019                 case STATUS_TYPE_22:
2020                         handle_cnt = ((sts22_entry_t *)pkt)->handle_count;
2021                         for (cnt = 0; cnt < handle_cnt; cnt++) {
2022                                 qla2x00_process_completed_request(vha, rsp->req,
2023                                     ((sts22_entry_t *)pkt)->handle[cnt]);
2024                         }
2025                         break;
2026                 case STATUS_CONT_TYPE:
2027                         qla2x00_status_cont_entry(rsp, (sts_cont_entry_t *)pkt);
2028                         break;
2029                 case MBX_IOCB_TYPE:
2030                         qla2x00_mbx_iocb_entry(vha, rsp->req,
2031                             (struct mbx_entry *)pkt);
2032                         break;
2033                 case CT_IOCB_TYPE:
2034                         qla2x00_ct_entry(vha, rsp->req, pkt, CT_IOCB_TYPE);
2035                         break;
2036                 default:
2037                         /* Type Not Supported. */
2038                         ql_log(ql_log_warn, vha, 0x504a,
2039                             "Received unknown response pkt type %x "
2040                             "entry status=%x.\n",
2041                             pkt->entry_type, pkt->entry_status);
2042                         break;
2043                 }
2044                 ((response_t *)pkt)->signature = RESPONSE_PROCESSED;
2045                 wmb();
2046         }
2047
2048         /* Adjust ring index */
2049         WRT_REG_WORD(ISP_RSP_Q_OUT(ha, reg), rsp->ring_index);
2050 }
2051
2052 static inline void
2053 qla2x00_handle_sense(srb_t *sp, uint8_t *sense_data, uint32_t par_sense_len,
2054                      uint32_t sense_len, struct rsp_que *rsp, int res)
2055 {
2056         struct scsi_qla_host *vha = sp->vha;
2057         struct scsi_cmnd *cp = GET_CMD_SP(sp);
2058         uint32_t track_sense_len;
2059
2060         if (sense_len >= SCSI_SENSE_BUFFERSIZE)
2061                 sense_len = SCSI_SENSE_BUFFERSIZE;
2062
2063         SET_CMD_SENSE_LEN(sp, sense_len);
2064         SET_CMD_SENSE_PTR(sp, cp->sense_buffer);
2065         track_sense_len = sense_len;
2066
2067         if (sense_len > par_sense_len)
2068                 sense_len = par_sense_len;
2069
2070         memcpy(cp->sense_buffer, sense_data, sense_len);
2071
2072         SET_CMD_SENSE_PTR(sp, cp->sense_buffer + sense_len);
2073         track_sense_len -= sense_len;
2074         SET_CMD_SENSE_LEN(sp, track_sense_len);
2075
2076         if (track_sense_len != 0) {
2077                 rsp->status_srb = sp;
2078                 cp->result = res;
2079         }
2080
2081         if (sense_len) {
2082                 ql_dbg(ql_dbg_io + ql_dbg_buffer, vha, 0x301c,
2083                     "Check condition Sense data, nexus%ld:%d:%llu cmd=%p.\n",
2084                     sp->vha->host_no, cp->device->id, cp->device->lun,
2085                     cp);
2086                 ql_dump_buffer(ql_dbg_io + ql_dbg_buffer, vha, 0x302b,
2087                     cp->sense_buffer, sense_len);
2088         }
2089 }
2090
2091 struct scsi_dif_tuple {
2092         __be16 guard;       /* Checksum */
2093         __be16 app_tag;         /* APPL identifier */
2094         __be32 ref_tag;         /* Target LBA or indirect LBA */
2095 };
2096
2097 /*
2098  * Checks the guard or meta-data for the type of error
2099  * detected by the HBA. In case of errors, we set the
2100  * ASC/ASCQ fields in the sense buffer with ILLEGAL_REQUEST
2101  * to indicate to the kernel that the HBA detected error.
2102  */
2103 static inline int
2104 qla2x00_handle_dif_error(srb_t *sp, struct sts_entry_24xx *sts24)
2105 {
2106         struct scsi_qla_host *vha = sp->vha;
2107         struct scsi_cmnd *cmd = GET_CMD_SP(sp);
2108         uint8_t         *ap = &sts24->data[12];
2109         uint8_t         *ep = &sts24->data[20];
2110         uint32_t        e_ref_tag, a_ref_tag;
2111         uint16_t        e_app_tag, a_app_tag;
2112         uint16_t        e_guard, a_guard;
2113
2114         /*
2115          * swab32 of the "data" field in the beginning of qla2x00_status_entry()
2116          * would make guard field appear at offset 2
2117          */
2118         a_guard   = le16_to_cpu(*(uint16_t *)(ap + 2));
2119         a_app_tag = le16_to_cpu(*(uint16_t *)(ap + 0));
2120         a_ref_tag = le32_to_cpu(*(uint32_t *)(ap + 4));
2121         e_guard   = le16_to_cpu(*(uint16_t *)(ep + 2));
2122         e_app_tag = le16_to_cpu(*(uint16_t *)(ep + 0));
2123         e_ref_tag = le32_to_cpu(*(uint32_t *)(ep + 4));
2124
2125         ql_dbg(ql_dbg_io, vha, 0x3023,
2126             "iocb(s) %p Returned STATUS.\n", sts24);
2127
2128         ql_dbg(ql_dbg_io, vha, 0x3024,
2129             "DIF ERROR in cmd 0x%x lba 0x%llx act ref"
2130             " tag=0x%x, exp ref_tag=0x%x, act app tag=0x%x, exp app"
2131             " tag=0x%x, act guard=0x%x, exp guard=0x%x.\n",
2132             cmd->cmnd[0], (u64)scsi_get_lba(cmd), a_ref_tag, e_ref_tag,
2133             a_app_tag, e_app_tag, a_guard, e_guard);
2134
2135         /*
2136          * Ignore sector if:
2137          * For type     3: ref & app tag is all 'f's
2138          * For type 0,1,2: app tag is all 'f's
2139          */
2140         if ((a_app_tag == T10_PI_APP_ESCAPE) &&
2141             ((scsi_get_prot_type(cmd) != SCSI_PROT_DIF_TYPE3) ||
2142              (a_ref_tag == T10_PI_REF_ESCAPE))) {
2143                 uint32_t blocks_done, resid;
2144                 sector_t lba_s = scsi_get_lba(cmd);
2145
2146                 /* 2TB boundary case covered automatically with this */
2147                 blocks_done = e_ref_tag - (uint32_t)lba_s + 1;
2148
2149                 resid = scsi_bufflen(cmd) - (blocks_done *
2150                     cmd->device->sector_size);
2151
2152                 scsi_set_resid(cmd, resid);
2153                 cmd->result = DID_OK << 16;
2154
2155                 /* Update protection tag */
2156                 if (scsi_prot_sg_count(cmd)) {
2157                         uint32_t i, j = 0, k = 0, num_ent;
2158                         struct scatterlist *sg;
2159                         struct t10_pi_tuple *spt;
2160
2161                         /* Patch the corresponding protection tags */
2162                         scsi_for_each_prot_sg(cmd, sg,
2163                             scsi_prot_sg_count(cmd), i) {
2164                                 num_ent = sg_dma_len(sg) / 8;
2165                                 if (k + num_ent < blocks_done) {
2166                                         k += num_ent;
2167                                         continue;
2168                                 }
2169                                 j = blocks_done - k - 1;
2170                                 k = blocks_done;
2171                                 break;
2172                         }
2173
2174                         if (k != blocks_done) {
2175                                 ql_log(ql_log_warn, vha, 0x302f,
2176                                     "unexpected tag values tag:lba=%x:%llx)\n",
2177                                     e_ref_tag, (unsigned long long)lba_s);
2178                                 return 1;
2179                         }
2180
2181                         spt = page_address(sg_page(sg)) + sg->offset;
2182                         spt += j;
2183
2184                         spt->app_tag = T10_PI_APP_ESCAPE;
2185                         if (scsi_get_prot_type(cmd) == SCSI_PROT_DIF_TYPE3)
2186                                 spt->ref_tag = T10_PI_REF_ESCAPE;
2187                 }
2188
2189                 return 0;
2190         }
2191
2192         /* check guard */
2193         if (e_guard != a_guard) {
2194                 scsi_build_sense_buffer(1, cmd->sense_buffer, ILLEGAL_REQUEST,
2195                     0x10, 0x1);
2196                 set_driver_byte(cmd, DRIVER_SENSE);
2197                 set_host_byte(cmd, DID_ABORT);
2198                 cmd->result |= SAM_STAT_CHECK_CONDITION << 1;
2199                 return 1;
2200         }
2201
2202         /* check ref tag */
2203         if (e_ref_tag != a_ref_tag) {
2204                 scsi_build_sense_buffer(1, cmd->sense_buffer, ILLEGAL_REQUEST,
2205                     0x10, 0x3);
2206                 set_driver_byte(cmd, DRIVER_SENSE);
2207                 set_host_byte(cmd, DID_ABORT);
2208                 cmd->result |= SAM_STAT_CHECK_CONDITION << 1;
2209                 return 1;
2210         }
2211
2212         /* check appl tag */
2213         if (e_app_tag != a_app_tag) {
2214                 scsi_build_sense_buffer(1, cmd->sense_buffer, ILLEGAL_REQUEST,
2215                     0x10, 0x2);
2216                 set_driver_byte(cmd, DRIVER_SENSE);
2217                 set_host_byte(cmd, DID_ABORT);
2218                 cmd->result |= SAM_STAT_CHECK_CONDITION << 1;
2219                 return 1;
2220         }
2221
2222         return 1;
2223 }
2224
2225 static void
2226 qla25xx_process_bidir_status_iocb(scsi_qla_host_t *vha, void *pkt,
2227                                   struct req_que *req, uint32_t index)
2228 {
2229         struct qla_hw_data *ha = vha->hw;
2230         srb_t *sp;
2231         uint16_t        comp_status;
2232         uint16_t        scsi_status;
2233         uint16_t thread_id;
2234         uint32_t rval = EXT_STATUS_OK;
2235         struct bsg_job *bsg_job = NULL;
2236         struct fc_bsg_request *bsg_request;
2237         struct fc_bsg_reply *bsg_reply;
2238         sts_entry_t *sts;
2239         struct sts_entry_24xx *sts24;
2240         sts = (sts_entry_t *) pkt;
2241         sts24 = (struct sts_entry_24xx *) pkt;
2242
2243         /* Validate handle. */
2244         if (index >= req->num_outstanding_cmds) {
2245                 ql_log(ql_log_warn, vha, 0x70af,
2246                     "Invalid SCSI completion handle 0x%x.\n", index);
2247                 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
2248                 return;
2249         }
2250
2251         sp = req->outstanding_cmds[index];
2252         if (!sp) {
2253                 ql_log(ql_log_warn, vha, 0x70b0,
2254                     "Req:%d: Invalid ISP SCSI completion handle(0x%x)\n",
2255                     req->id, index);
2256
2257                 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
2258                 return;
2259         }
2260
2261         /* Free outstanding command slot. */
2262         req->outstanding_cmds[index] = NULL;
2263         bsg_job = sp->u.bsg_job;
2264         bsg_request = bsg_job->request;
2265         bsg_reply = bsg_job->reply;
2266
2267         if (IS_FWI2_CAPABLE(ha)) {
2268                 comp_status = le16_to_cpu(sts24->comp_status);
2269                 scsi_status = le16_to_cpu(sts24->scsi_status) & SS_MASK;
2270         } else {
2271                 comp_status = le16_to_cpu(sts->comp_status);
2272                 scsi_status = le16_to_cpu(sts->scsi_status) & SS_MASK;
2273         }
2274
2275         thread_id = bsg_request->rqst_data.h_vendor.vendor_cmd[1];
2276         switch (comp_status) {
2277         case CS_COMPLETE:
2278                 if (scsi_status == 0) {
2279                         bsg_reply->reply_payload_rcv_len =
2280                                         bsg_job->reply_payload.payload_len;
2281                         vha->qla_stats.input_bytes +=
2282                                 bsg_reply->reply_payload_rcv_len;
2283                         vha->qla_stats.input_requests++;
2284                         rval = EXT_STATUS_OK;
2285                 }
2286                 goto done;
2287
2288         case CS_DATA_OVERRUN:
2289                 ql_dbg(ql_dbg_user, vha, 0x70b1,
2290                     "Command completed with data overrun thread_id=%d\n",
2291                     thread_id);
2292                 rval = EXT_STATUS_DATA_OVERRUN;
2293                 break;
2294
2295         case CS_DATA_UNDERRUN:
2296                 ql_dbg(ql_dbg_user, vha, 0x70b2,
2297                     "Command completed with data underrun thread_id=%d\n",
2298                     thread_id);
2299                 rval = EXT_STATUS_DATA_UNDERRUN;
2300                 break;
2301         case CS_BIDIR_RD_OVERRUN:
2302                 ql_dbg(ql_dbg_user, vha, 0x70b3,
2303                     "Command completed with read data overrun thread_id=%d\n",
2304                     thread_id);
2305                 rval = EXT_STATUS_DATA_OVERRUN;
2306                 break;
2307
2308         case CS_BIDIR_RD_WR_OVERRUN:
2309                 ql_dbg(ql_dbg_user, vha, 0x70b4,
2310                     "Command completed with read and write data overrun "
2311                     "thread_id=%d\n", thread_id);
2312                 rval = EXT_STATUS_DATA_OVERRUN;
2313                 break;
2314
2315         case CS_BIDIR_RD_OVERRUN_WR_UNDERRUN:
2316                 ql_dbg(ql_dbg_user, vha, 0x70b5,
2317                     "Command completed with read data over and write data "
2318                     "underrun thread_id=%d\n", thread_id);
2319                 rval = EXT_STATUS_DATA_OVERRUN;
2320                 break;
2321
2322         case CS_BIDIR_RD_UNDERRUN:
2323                 ql_dbg(ql_dbg_user, vha, 0x70b6,
2324                     "Command completed with read data underrun "
2325                     "thread_id=%d\n", thread_id);
2326                 rval = EXT_STATUS_DATA_UNDERRUN;
2327                 break;
2328
2329         case CS_BIDIR_RD_UNDERRUN_WR_OVERRUN:
2330                 ql_dbg(ql_dbg_user, vha, 0x70b7,
2331                     "Command completed with read data under and write data "
2332                     "overrun thread_id=%d\n", thread_id);
2333                 rval = EXT_STATUS_DATA_UNDERRUN;
2334                 break;
2335
2336         case CS_BIDIR_RD_WR_UNDERRUN:
2337                 ql_dbg(ql_dbg_user, vha, 0x70b8,
2338                     "Command completed with read and write data underrun "
2339                     "thread_id=%d\n", thread_id);
2340                 rval = EXT_STATUS_DATA_UNDERRUN;
2341                 break;
2342
2343         case CS_BIDIR_DMA:
2344                 ql_dbg(ql_dbg_user, vha, 0x70b9,
2345                     "Command completed with data DMA error thread_id=%d\n",
2346                     thread_id);
2347                 rval = EXT_STATUS_DMA_ERR;
2348                 break;
2349
2350         case CS_TIMEOUT:
2351                 ql_dbg(ql_dbg_user, vha, 0x70ba,
2352                     "Command completed with timeout thread_id=%d\n",
2353                     thread_id);
2354                 rval = EXT_STATUS_TIMEOUT;
2355                 break;
2356         default:
2357                 ql_dbg(ql_dbg_user, vha, 0x70bb,
2358                     "Command completed with completion status=0x%x "
2359                     "thread_id=%d\n", comp_status, thread_id);
2360                 rval = EXT_STATUS_ERR;
2361                 break;
2362         }
2363         bsg_reply->reply_payload_rcv_len = 0;
2364
2365 done:
2366         /* Return the vendor specific reply to API */
2367         bsg_reply->reply_data.vendor_reply.vendor_rsp[0] = rval;
2368         bsg_job->reply_len = sizeof(struct fc_bsg_reply);
2369         /* Always return DID_OK, bsg will send the vendor specific response
2370          * in this case only */
2371         sp->done(sp, DID_OK << 6);
2372
2373 }
2374
2375 /**
2376  * qla2x00_status_entry() - Process a Status IOCB entry.
2377  * @ha: SCSI driver HA context
2378  * @pkt: Entry pointer
2379  */
2380 static void
2381 qla2x00_status_entry(scsi_qla_host_t *vha, struct rsp_que *rsp, void *pkt)
2382 {
2383         srb_t           *sp;
2384         fc_port_t       *fcport;
2385         struct scsi_cmnd *cp;
2386         sts_entry_t *sts;
2387         struct sts_entry_24xx *sts24;
2388         uint16_t        comp_status;
2389         uint16_t        scsi_status;
2390         uint16_t        ox_id;
2391         uint8_t         lscsi_status;
2392         int32_t         resid;
2393         uint32_t sense_len, par_sense_len, rsp_info_len, resid_len,
2394             fw_resid_len;
2395         uint8_t         *rsp_info, *sense_data;
2396         struct qla_hw_data *ha = vha->hw;
2397         uint32_t handle;
2398         uint16_t que;
2399         struct req_que *req;
2400         int logit = 1;
2401         int res = 0;
2402         uint16_t state_flags = 0;
2403         uint16_t retry_delay = 0;
2404
2405         sts = (sts_entry_t *) pkt;
2406         sts24 = (struct sts_entry_24xx *) pkt;
2407         if (IS_FWI2_CAPABLE(ha)) {
2408                 comp_status = le16_to_cpu(sts24->comp_status);
2409                 scsi_status = le16_to_cpu(sts24->scsi_status) & SS_MASK;
2410                 state_flags = le16_to_cpu(sts24->state_flags);
2411         } else {
2412                 comp_status = le16_to_cpu(sts->comp_status);
2413                 scsi_status = le16_to_cpu(sts->scsi_status) & SS_MASK;
2414         }
2415         handle = (uint32_t) LSW(sts->handle);
2416         que = MSW(sts->handle);
2417         req = ha->req_q_map[que];
2418
2419         /* Check for invalid queue pointer */
2420         if (req == NULL ||
2421             que >= find_first_zero_bit(ha->req_qid_map, ha->max_req_queues)) {
2422                 ql_dbg(ql_dbg_io, vha, 0x3059,
2423                     "Invalid status handle (0x%x): Bad req pointer. req=%p, "
2424                     "que=%u.\n", sts->handle, req, que);
2425                 return;
2426         }
2427
2428         /* Validate handle. */
2429         if (handle < req->num_outstanding_cmds) {
2430                 sp = req->outstanding_cmds[handle];
2431                 if (!sp) {
2432                         ql_dbg(ql_dbg_io, vha, 0x3075,
2433                             "%s(%ld): Already returned command for status handle (0x%x).\n",
2434                             __func__, vha->host_no, sts->handle);
2435                         return;
2436                 }
2437         } else {
2438                 ql_dbg(ql_dbg_io, vha, 0x3017,
2439                     "Invalid status handle, out of range (0x%x).\n",
2440                     sts->handle);
2441
2442                 if (!test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags)) {
2443                         if (IS_P3P_TYPE(ha))
2444                                 set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
2445                         else
2446                                 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
2447                         qla2xxx_wake_dpc(vha);
2448                 }
2449                 return;
2450         }
2451
2452         if (sp->cmd_type != TYPE_SRB) {
2453                 req->outstanding_cmds[handle] = NULL;
2454                 ql_dbg(ql_dbg_io, vha, 0x3015,
2455                     "Unknown sp->cmd_type %x %p).\n",
2456                     sp->cmd_type, sp);
2457                 return;
2458         }
2459
2460         /* NVME completion. */
2461         if (sp->type == SRB_NVME_CMD) {
2462                 qla24xx_nvme_iocb_entry(vha, req, pkt);
2463                 return;
2464         }
2465
2466         if (unlikely((state_flags & BIT_1) && (sp->type == SRB_BIDI_CMD))) {
2467                 qla25xx_process_bidir_status_iocb(vha, pkt, req, handle);
2468                 return;
2469         }
2470
2471         /* Task Management completion. */
2472         if (sp->type == SRB_TM_CMD) {
2473                 qla24xx_tm_iocb_entry(vha, req, pkt);
2474                 return;
2475         }
2476
2477         /* Fast path completion. */
2478         if (comp_status == CS_COMPLETE && scsi_status == 0) {
2479                 qla2x00_process_completed_request(vha, req, handle);
2480
2481                 return;
2482         }
2483
2484         req->outstanding_cmds[handle] = NULL;
2485         cp = GET_CMD_SP(sp);
2486         if (cp == NULL) {
2487                 ql_dbg(ql_dbg_io, vha, 0x3018,
2488                     "Command already returned (0x%x/%p).\n",
2489                     sts->handle, sp);
2490
2491                 return;
2492         }
2493
2494         lscsi_status = scsi_status & STATUS_MASK;
2495
2496         fcport = sp->fcport;
2497
2498         ox_id = 0;
2499         sense_len = par_sense_len = rsp_info_len = resid_len =
2500             fw_resid_len = 0;
2501         if (IS_FWI2_CAPABLE(ha)) {
2502                 if (scsi_status & SS_SENSE_LEN_VALID)
2503                         sense_len = le32_to_cpu(sts24->sense_len);
2504                 if (scsi_status & SS_RESPONSE_INFO_LEN_VALID)
2505                         rsp_info_len = le32_to_cpu(sts24->rsp_data_len);
2506                 if (scsi_status & (SS_RESIDUAL_UNDER | SS_RESIDUAL_OVER))
2507                         resid_len = le32_to_cpu(sts24->rsp_residual_count);
2508                 if (comp_status == CS_DATA_UNDERRUN)
2509                         fw_resid_len = le32_to_cpu(sts24->residual_len);
2510                 rsp_info = sts24->data;
2511                 sense_data = sts24->data;
2512                 host_to_fcp_swap(sts24->data, sizeof(sts24->data));
2513                 ox_id = le16_to_cpu(sts24->ox_id);
2514                 par_sense_len = sizeof(sts24->data);
2515                 /* Valid values of the retry delay timer are 0x1-0xffef */
2516                 if (sts24->retry_delay > 0 && sts24->retry_delay < 0xfff1)
2517                         retry_delay = sts24->retry_delay;
2518         } else {
2519                 if (scsi_status & SS_SENSE_LEN_VALID)
2520                         sense_len = le16_to_cpu(sts->req_sense_length);
2521                 if (scsi_status & SS_RESPONSE_INFO_LEN_VALID)
2522                         rsp_info_len = le16_to_cpu(sts->rsp_info_len);
2523                 resid_len = le32_to_cpu(sts->residual_length);
2524                 rsp_info = sts->rsp_info;
2525                 sense_data = sts->req_sense_data;
2526                 par_sense_len = sizeof(sts->req_sense_data);
2527         }
2528
2529         /* Check for any FCP transport errors. */
2530         if (scsi_status & SS_RESPONSE_INFO_LEN_VALID) {
2531                 /* Sense data lies beyond any FCP RESPONSE data. */
2532                 if (IS_FWI2_CAPABLE(ha)) {
2533                         sense_data += rsp_info_len;
2534                         par_sense_len -= rsp_info_len;
2535                 }
2536                 if (rsp_info_len > 3 && rsp_info[3]) {
2537                         ql_dbg(ql_dbg_io, fcport->vha, 0x3019,
2538                             "FCP I/O protocol failure (0x%x/0x%x).\n",
2539                             rsp_info_len, rsp_info[3]);
2540
2541                         res = DID_BUS_BUSY << 16;
2542                         goto out;
2543                 }
2544         }
2545
2546         /* Check for overrun. */
2547         if (IS_FWI2_CAPABLE(ha) && comp_status == CS_COMPLETE &&
2548             scsi_status & SS_RESIDUAL_OVER)
2549                 comp_status = CS_DATA_OVERRUN;
2550
2551         /*
2552          * Check retry_delay_timer value if we receive a busy or
2553          * queue full.
2554          */
2555         if (lscsi_status == SAM_STAT_TASK_SET_FULL ||
2556             lscsi_status == SAM_STAT_BUSY)
2557                 qla2x00_set_retry_delay_timestamp(fcport, retry_delay);
2558
2559         /*
2560          * Based on Host and scsi status generate status code for Linux
2561          */
2562         switch (comp_status) {
2563         case CS_COMPLETE:
2564         case CS_QUEUE_FULL:
2565                 if (scsi_status == 0) {
2566                         res = DID_OK << 16;
2567                         break;
2568                 }
2569                 if (scsi_status & (SS_RESIDUAL_UNDER | SS_RESIDUAL_OVER)) {
2570                         resid = resid_len;
2571                         scsi_set_resid(cp, resid);
2572
2573                         if (!lscsi_status &&
2574                             ((unsigned)(scsi_bufflen(cp) - resid) <
2575                              cp->underflow)) {
2576                                 ql_dbg(ql_dbg_io, fcport->vha, 0x301a,
2577                                     "Mid-layer underflow detected (0x%x of 0x%x bytes).\n",
2578                                     resid, scsi_bufflen(cp));
2579
2580                                 res = DID_ERROR << 16;
2581                                 break;
2582                         }
2583                 }
2584                 res = DID_OK << 16 | lscsi_status;
2585
2586                 if (lscsi_status == SAM_STAT_TASK_SET_FULL) {
2587                         ql_dbg(ql_dbg_io, fcport->vha, 0x301b,
2588                             "QUEUE FULL detected.\n");
2589                         break;
2590                 }
2591                 logit = 0;
2592                 if (lscsi_status != SS_CHECK_CONDITION)
2593                         break;
2594
2595                 memset(cp->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
2596                 if (!(scsi_status & SS_SENSE_LEN_VALID))
2597                         break;
2598
2599                 qla2x00_handle_sense(sp, sense_data, par_sense_len, sense_len,
2600                     rsp, res);
2601                 break;
2602
2603         case CS_DATA_UNDERRUN:
2604                 /* Use F/W calculated residual length. */
2605                 resid = IS_FWI2_CAPABLE(ha) ? fw_resid_len : resid_len;
2606                 scsi_set_resid(cp, resid);
2607                 if (scsi_status & SS_RESIDUAL_UNDER) {
2608                         if (IS_FWI2_CAPABLE(ha) && fw_resid_len != resid_len) {
2609                                 ql_dbg(ql_dbg_io, fcport->vha, 0x301d,
2610                                     "Dropped frame(s) detected (0x%x of 0x%x bytes).\n",
2611                                     resid, scsi_bufflen(cp));
2612
2613                                 res = DID_ERROR << 16 | lscsi_status;
2614                                 goto check_scsi_status;
2615                         }
2616
2617                         if (!lscsi_status &&
2618                             ((unsigned)(scsi_bufflen(cp) - resid) <
2619                             cp->underflow)) {
2620                                 ql_dbg(ql_dbg_io, fcport->vha, 0x301e,
2621                                     "Mid-layer underflow detected (0x%x of 0x%x bytes).\n",
2622                                     resid, scsi_bufflen(cp));
2623
2624                                 res = DID_ERROR << 16;
2625                                 break;
2626                         }
2627                 } else if (lscsi_status != SAM_STAT_TASK_SET_FULL &&
2628                             lscsi_status != SAM_STAT_BUSY) {
2629                         /*
2630                          * scsi status of task set and busy are considered to be
2631                          * task not completed.
2632                          */
2633
2634                         ql_dbg(ql_dbg_io, fcport->vha, 0x301f,
2635                             "Dropped frame(s) detected (0x%x of 0x%x bytes).\n",
2636                             resid, scsi_bufflen(cp));
2637
2638                         res = DID_ERROR << 16 | lscsi_status;
2639                         goto check_scsi_status;
2640                 } else {
2641                         ql_dbg(ql_dbg_io, fcport->vha, 0x3030,
2642                             "scsi_status: 0x%x, lscsi_status: 0x%x\n",
2643                             scsi_status, lscsi_status);
2644                 }
2645
2646                 res = DID_OK << 16 | lscsi_status;
2647                 logit = 0;
2648
2649 check_scsi_status:
2650                 /*
2651                  * Check to see if SCSI Status is non zero. If so report SCSI
2652                  * Status.
2653                  */
2654                 if (lscsi_status != 0) {
2655                         if (lscsi_status == SAM_STAT_TASK_SET_FULL) {
2656                                 ql_dbg(ql_dbg_io, fcport->vha, 0x3020,
2657                                     "QUEUE FULL detected.\n");
2658                                 logit = 1;
2659                                 break;
2660                         }
2661                         if (lscsi_status != SS_CHECK_CONDITION)
2662                                 break;
2663
2664                         memset(cp->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
2665                         if (!(scsi_status & SS_SENSE_LEN_VALID))
2666                                 break;
2667
2668                         qla2x00_handle_sense(sp, sense_data, par_sense_len,
2669                             sense_len, rsp, res);
2670                 }
2671                 break;
2672
2673         case CS_PORT_LOGGED_OUT:
2674         case CS_PORT_CONFIG_CHG:
2675         case CS_PORT_BUSY:
2676         case CS_INCOMPLETE:
2677         case CS_PORT_UNAVAILABLE:
2678         case CS_TIMEOUT:
2679         case CS_RESET:
2680
2681                 /*
2682                  * We are going to have the fc class block the rport
2683                  * while we try to recover so instruct the mid layer
2684                  * to requeue until the class decides how to handle this.
2685                  */
2686                 res = DID_TRANSPORT_DISRUPTED << 16;
2687
2688                 if (comp_status == CS_TIMEOUT) {
2689                         if (IS_FWI2_CAPABLE(ha))
2690                                 break;
2691                         else if ((le16_to_cpu(sts->status_flags) &
2692                             SF_LOGOUT_SENT) == 0)
2693                                 break;
2694                 }
2695
2696                 if (atomic_read(&fcport->state) == FCS_ONLINE) {
2697                         ql_dbg(ql_dbg_disc, fcport->vha, 0x3021,
2698                                 "Port to be marked lost on fcport=%02x%02x%02x, current "
2699                                 "port state= %s comp_status %x.\n", fcport->d_id.b.domain,
2700                                 fcport->d_id.b.area, fcport->d_id.b.al_pa,
2701                                 port_state_str[atomic_read(&fcport->state)],
2702                                 comp_status);
2703
2704                         qla2x00_mark_device_lost(fcport->vha, fcport, 1, 1);
2705                         qlt_schedule_sess_for_deletion(fcport);
2706                 }
2707
2708                 break;
2709
2710         case CS_ABORTED:
2711                 res = DID_RESET << 16;
2712                 break;
2713
2714         case CS_DIF_ERROR:
2715                 logit = qla2x00_handle_dif_error(sp, sts24);
2716                 res = cp->result;
2717                 break;
2718
2719         case CS_TRANSPORT:
2720                 res = DID_ERROR << 16;
2721
2722                 if (!IS_PI_SPLIT_DET_CAPABLE(ha))
2723                         break;
2724
2725                 if (state_flags & BIT_4)
2726                         scmd_printk(KERN_WARNING, cp,
2727                             "Unsupported device '%s' found.\n",
2728                             cp->device->vendor);
2729                 break;
2730
2731         default:
2732                 res = DID_ERROR << 16;
2733                 break;
2734         }
2735
2736 out:
2737         if (logit)
2738                 ql_dbg(ql_dbg_io, fcport->vha, 0x3022,
2739                     "FCP command status: 0x%x-0x%x (0x%x) nexus=%ld:%d:%llu "
2740                     "portid=%02x%02x%02x oxid=0x%x cdb=%10phN len=0x%x "
2741                     "rsp_info=0x%x resid=0x%x fw_resid=0x%x sp=%p cp=%p.\n",
2742                     comp_status, scsi_status, res, vha->host_no,
2743                     cp->device->id, cp->device->lun, fcport->d_id.b.domain,
2744                     fcport->d_id.b.area, fcport->d_id.b.al_pa, ox_id,
2745                     cp->cmnd, scsi_bufflen(cp), rsp_info_len,
2746                     resid_len, fw_resid_len, sp, cp);
2747
2748         if (rsp->status_srb == NULL)
2749                 sp->done(sp, res);
2750 }
2751
2752 /**
2753  * qla2x00_status_cont_entry() - Process a Status Continuations entry.
2754  * @ha: SCSI driver HA context
2755  * @pkt: Entry pointer
2756  *
2757  * Extended sense data.
2758  */
2759 static void
2760 qla2x00_status_cont_entry(struct rsp_que *rsp, sts_cont_entry_t *pkt)
2761 {
2762         uint8_t sense_sz = 0;
2763         struct qla_hw_data *ha = rsp->hw;
2764         struct scsi_qla_host *vha = pci_get_drvdata(ha->pdev);
2765         srb_t *sp = rsp->status_srb;
2766         struct scsi_cmnd *cp;
2767         uint32_t sense_len;
2768         uint8_t *sense_ptr;
2769
2770         if (!sp || !GET_CMD_SENSE_LEN(sp))
2771                 return;
2772
2773         sense_len = GET_CMD_SENSE_LEN(sp);
2774         sense_ptr = GET_CMD_SENSE_PTR(sp);
2775
2776         cp = GET_CMD_SP(sp);
2777         if (cp == NULL) {
2778                 ql_log(ql_log_warn, vha, 0x3025,
2779                     "cmd is NULL: already returned to OS (sp=%p).\n", sp);
2780
2781                 rsp->status_srb = NULL;
2782                 return;
2783         }
2784
2785         if (sense_len > sizeof(pkt->data))
2786                 sense_sz = sizeof(pkt->data);
2787         else
2788                 sense_sz = sense_len;
2789
2790         /* Move sense data. */
2791         if (IS_FWI2_CAPABLE(ha))
2792                 host_to_fcp_swap(pkt->data, sizeof(pkt->data));
2793         memcpy(sense_ptr, pkt->data, sense_sz);
2794         ql_dump_buffer(ql_dbg_io + ql_dbg_buffer, vha, 0x302c,
2795                 sense_ptr, sense_sz);
2796
2797         sense_len -= sense_sz;
2798         sense_ptr += sense_sz;
2799
2800         SET_CMD_SENSE_PTR(sp, sense_ptr);
2801         SET_CMD_SENSE_LEN(sp, sense_len);
2802
2803         /* Place command on done queue. */
2804         if (sense_len == 0) {
2805                 rsp->status_srb = NULL;
2806                 sp->done(sp, cp->result);
2807         }
2808 }
2809
2810 /**
2811  * qla2x00_error_entry() - Process an error entry.
2812  * @ha: SCSI driver HA context
2813  * @pkt: Entry pointer
2814  * return : 1=allow further error analysis. 0=no additional error analysis.
2815  */
2816 static int
2817 qla2x00_error_entry(scsi_qla_host_t *vha, struct rsp_que *rsp, sts_entry_t *pkt)
2818 {
2819         srb_t *sp;
2820         struct qla_hw_data *ha = vha->hw;
2821         const char func[] = "ERROR-IOCB";
2822         uint16_t que = MSW(pkt->handle);
2823         struct req_que *req = NULL;
2824         int res = DID_ERROR << 16;
2825
2826         ql_dbg(ql_dbg_async, vha, 0x502a,
2827             "iocb type %xh with error status %xh, handle %xh, rspq id %d\n",
2828             pkt->entry_type, pkt->entry_status, pkt->handle, rsp->id);
2829
2830         if (que >= ha->max_req_queues || !ha->req_q_map[que])
2831                 goto fatal;
2832
2833         req = ha->req_q_map[que];
2834
2835         if (pkt->entry_status & RF_BUSY)
2836                 res = DID_BUS_BUSY << 16;
2837
2838         if ((pkt->handle & ~QLA_TGT_HANDLE_MASK) == QLA_TGT_SKIP_HANDLE)
2839                 return 0;
2840
2841         switch (pkt->entry_type) {
2842         case NOTIFY_ACK_TYPE:
2843         case STATUS_TYPE:
2844         case STATUS_CONT_TYPE:
2845         case LOGINOUT_PORT_IOCB_TYPE:
2846         case CT_IOCB_TYPE:
2847         case ELS_IOCB_TYPE:
2848         case ABORT_IOCB_TYPE:
2849         case MBX_IOCB_TYPE:
2850                 sp = qla2x00_get_sp_from_handle(vha, func, req, pkt);
2851                 if (sp) {
2852                         sp->done(sp, res);
2853                         return 0;
2854                 }
2855                 break;
2856
2857         case ABTS_RESP_24XX:
2858         case CTIO_TYPE7:
2859         case CTIO_CRC2:
2860         default:
2861                 return 1;
2862         }
2863 fatal:
2864         ql_log(ql_log_warn, vha, 0x5030,
2865             "Error entry - invalid handle/queue (%04x).\n", que);
2866         return 0;
2867 }
2868
2869 /**
2870  * qla24xx_mbx_completion() - Process mailbox command completions.
2871  * @ha: SCSI driver HA context
2872  * @mb0: Mailbox0 register
2873  */
2874 static void
2875 qla24xx_mbx_completion(scsi_qla_host_t *vha, uint16_t mb0)
2876 {
2877         uint16_t        cnt;
2878         uint32_t        mboxes;
2879         uint16_t __iomem *wptr;
2880         struct qla_hw_data *ha = vha->hw;
2881         struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
2882
2883         /* Read all mbox registers? */
2884         WARN_ON_ONCE(ha->mbx_count > 32);
2885         mboxes = (1ULL << ha->mbx_count) - 1;
2886         if (!ha->mcp)
2887                 ql_dbg(ql_dbg_async, vha, 0x504e, "MBX pointer ERROR.\n");
2888         else
2889                 mboxes = ha->mcp->in_mb;
2890
2891         /* Load return mailbox registers. */
2892         ha->flags.mbox_int = 1;
2893         ha->mailbox_out[0] = mb0;
2894         mboxes >>= 1;
2895         wptr = (uint16_t __iomem *)&reg->mailbox1;
2896
2897         for (cnt = 1; cnt < ha->mbx_count; cnt++) {
2898                 if (mboxes & BIT_0)
2899                         ha->mailbox_out[cnt] = RD_REG_WORD(wptr);
2900
2901                 mboxes >>= 1;
2902                 wptr++;
2903         }
2904 }
2905
2906 static void
2907 qla24xx_abort_iocb_entry(scsi_qla_host_t *vha, struct req_que *req,
2908         struct abort_entry_24xx *pkt)
2909 {
2910         const char func[] = "ABT_IOCB";
2911         srb_t *sp;
2912         struct srb_iocb *abt;
2913
2914         sp = qla2x00_get_sp_from_handle(vha, func, req, pkt);
2915         if (!sp)
2916                 return;
2917
2918         abt = &sp->u.iocb_cmd;
2919         abt->u.abt.comp_status = le16_to_cpu(pkt->nport_handle);
2920         sp->done(sp, 0);
2921 }
2922
2923 void qla24xx_nvme_ls4_iocb(struct scsi_qla_host *vha,
2924     struct pt_ls4_request *pkt, struct req_que *req)
2925 {
2926         srb_t *sp;
2927         const char func[] = "LS4_IOCB";
2928         uint16_t comp_status;
2929
2930         sp = qla2x00_get_sp_from_handle(vha, func, req, pkt);
2931         if (!sp)
2932                 return;
2933
2934         comp_status = le16_to_cpu(pkt->status);
2935         sp->done(sp, comp_status);
2936 }
2937
2938 /**
2939  * qla24xx_process_response_queue() - Process response queue entries.
2940  * @ha: SCSI driver HA context
2941  */
2942 void qla24xx_process_response_queue(struct scsi_qla_host *vha,
2943         struct rsp_que *rsp)
2944 {
2945         struct sts_entry_24xx *pkt;
2946         struct qla_hw_data *ha = vha->hw;
2947
2948         if (!ha->flags.fw_started)
2949                 return;
2950
2951         if (rsp->qpair->cpuid != smp_processor_id())
2952                 qla_cpu_update(rsp->qpair, smp_processor_id());
2953
2954         while (rsp->ring_ptr->signature != RESPONSE_PROCESSED) {
2955                 pkt = (struct sts_entry_24xx *)rsp->ring_ptr;
2956
2957                 rsp->ring_index++;
2958                 if (rsp->ring_index == rsp->length) {
2959                         rsp->ring_index = 0;
2960                         rsp->ring_ptr = rsp->ring;
2961                 } else {
2962                         rsp->ring_ptr++;
2963                 }
2964
2965                 if (pkt->entry_status != 0) {
2966                         if (qla2x00_error_entry(vha, rsp, (sts_entry_t *) pkt))
2967                                 goto process_err;
2968
2969                         ((response_t *)pkt)->signature = RESPONSE_PROCESSED;
2970                         wmb();
2971                         continue;
2972                 }
2973 process_err:
2974
2975                 switch (pkt->entry_type) {
2976                 case STATUS_TYPE:
2977                         qla2x00_status_entry(vha, rsp, pkt);
2978                         break;
2979                 case STATUS_CONT_TYPE:
2980                         qla2x00_status_cont_entry(rsp, (sts_cont_entry_t *)pkt);
2981                         break;
2982                 case VP_RPT_ID_IOCB_TYPE:
2983                         qla24xx_report_id_acquisition(vha,
2984                             (struct vp_rpt_id_entry_24xx *)pkt);
2985                         break;
2986                 case LOGINOUT_PORT_IOCB_TYPE:
2987                         qla24xx_logio_entry(vha, rsp->req,
2988                             (struct logio_entry_24xx *)pkt);
2989                         break;
2990                 case CT_IOCB_TYPE:
2991                         qla24xx_els_ct_entry(vha, rsp->req, pkt, CT_IOCB_TYPE);
2992                         break;
2993                 case ELS_IOCB_TYPE:
2994                         qla24xx_els_ct_entry(vha, rsp->req, pkt, ELS_IOCB_TYPE);
2995                         break;
2996                 case ABTS_RECV_24XX:
2997                         if (IS_QLA83XX(ha) || IS_QLA27XX(ha)) {
2998                                 /* ensure that the ATIO queue is empty */
2999                                 qlt_handle_abts_recv(vha, rsp,
3000                                     (response_t *)pkt);
3001                                 break;
3002                         } else {
3003                                 qlt_24xx_process_atio_queue(vha, 1);
3004                         }
3005                         /* fall through */
3006                 case ABTS_RESP_24XX:
3007                 case CTIO_TYPE7:
3008                 case CTIO_CRC2:
3009                         qlt_response_pkt_all_vps(vha, rsp, (response_t *)pkt);
3010                         break;
3011                 case PT_LS4_REQUEST:
3012                         qla24xx_nvme_ls4_iocb(vha, (struct pt_ls4_request *)pkt,
3013                             rsp->req);
3014                         break;
3015                 case NOTIFY_ACK_TYPE:
3016                         if (pkt->handle == QLA_TGT_SKIP_HANDLE)
3017                                 qlt_response_pkt_all_vps(vha, rsp,
3018                                     (response_t *)pkt);
3019                         else
3020                                 qla24xxx_nack_iocb_entry(vha, rsp->req,
3021                                         (struct nack_to_isp *)pkt);
3022                         break;
3023                 case MARKER_TYPE:
3024                         /* Do nothing in this case, this check is to prevent it
3025                          * from falling into default case
3026                          */
3027                         break;
3028                 case ABORT_IOCB_TYPE:
3029                         qla24xx_abort_iocb_entry(vha, rsp->req,
3030                             (struct abort_entry_24xx *)pkt);
3031                         break;
3032                 case MBX_IOCB_TYPE:
3033                         qla24xx_mbx_iocb_entry(vha, rsp->req,
3034                             (struct mbx_24xx_entry *)pkt);
3035                         break;
3036                 case VP_CTRL_IOCB_TYPE:
3037                         qla_ctrlvp_completed(vha, rsp->req,
3038                             (struct vp_ctrl_entry_24xx *)pkt);
3039                         break;
3040                 default:
3041                         /* Type Not Supported. */
3042                         ql_dbg(ql_dbg_async, vha, 0x5042,
3043                             "Received unknown response pkt type %x "
3044                             "entry status=%x.\n",
3045                             pkt->entry_type, pkt->entry_status);
3046                         break;
3047                 }
3048                 ((response_t *)pkt)->signature = RESPONSE_PROCESSED;
3049                 wmb();
3050         }
3051
3052         /* Adjust ring index */
3053         if (IS_P3P_TYPE(ha)) {
3054                 struct device_reg_82xx __iomem *reg = &ha->iobase->isp82;
3055                 WRT_REG_DWORD(&reg->rsp_q_out[0], rsp->ring_index);
3056         } else {
3057                 WRT_REG_DWORD(rsp->rsp_q_out, rsp->ring_index);
3058         }
3059 }
3060
3061 static void
3062 qla2xxx_check_risc_status(scsi_qla_host_t *vha)
3063 {
3064         int rval;
3065         uint32_t cnt;
3066         struct qla_hw_data *ha = vha->hw;
3067         struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
3068
3069         if (!IS_QLA25XX(ha) && !IS_QLA81XX(ha) && !IS_QLA83XX(ha) &&
3070             !IS_QLA27XX(ha))
3071                 return;
3072
3073         rval = QLA_SUCCESS;
3074         WRT_REG_DWORD(&reg->iobase_addr, 0x7C00);
3075         RD_REG_DWORD(&reg->iobase_addr);
3076         WRT_REG_DWORD(&reg->iobase_window, 0x0001);
3077         for (cnt = 10000; (RD_REG_DWORD(&reg->iobase_window) & BIT_0) == 0 &&
3078             rval == QLA_SUCCESS; cnt--) {
3079                 if (cnt) {
3080                         WRT_REG_DWORD(&reg->iobase_window, 0x0001);
3081                         udelay(10);
3082                 } else
3083                         rval = QLA_FUNCTION_TIMEOUT;
3084         }
3085         if (rval == QLA_SUCCESS)
3086                 goto next_test;
3087
3088         rval = QLA_SUCCESS;
3089         WRT_REG_DWORD(&reg->iobase_window, 0x0003);
3090         for (cnt = 100; (RD_REG_DWORD(&reg->iobase_window) & BIT_0) == 0 &&
3091             rval == QLA_SUCCESS; cnt--) {
3092                 if (cnt) {
3093                         WRT_REG_DWORD(&reg->iobase_window, 0x0003);
3094                         udelay(10);
3095                 } else
3096                         rval = QLA_FUNCTION_TIMEOUT;
3097         }
3098         if (rval != QLA_SUCCESS)
3099                 goto done;
3100
3101 next_test:
3102         if (RD_REG_DWORD(&reg->iobase_c8) & BIT_3)
3103                 ql_log(ql_log_info, vha, 0x504c,
3104                     "Additional code -- 0x55AA.\n");
3105
3106 done:
3107         WRT_REG_DWORD(&reg->iobase_window, 0x0000);
3108         RD_REG_DWORD(&reg->iobase_window);
3109 }
3110
3111 /**
3112  * qla24xx_intr_handler() - Process interrupts for the ISP23xx and ISP24xx.
3113  * @irq:
3114  * @dev_id: SCSI driver HA context
3115  *
3116  * Called by system whenever the host adapter generates an interrupt.
3117  *
3118  * Returns handled flag.
3119  */
3120 irqreturn_t
3121 qla24xx_intr_handler(int irq, void *dev_id)
3122 {
3123         scsi_qla_host_t *vha;
3124         struct qla_hw_data *ha;
3125         struct device_reg_24xx __iomem *reg;
3126         int             status;
3127         unsigned long   iter;
3128         uint32_t        stat;
3129         uint32_t        hccr;
3130         uint16_t        mb[8];
3131         struct rsp_que *rsp;
3132         unsigned long   flags;
3133
3134         rsp = (struct rsp_que *) dev_id;
3135         if (!rsp) {
3136                 ql_log(ql_log_info, NULL, 0x5059,
3137                     "%s: NULL response queue pointer.\n", __func__);
3138                 return IRQ_NONE;
3139         }
3140
3141         ha = rsp->hw;
3142         reg = &ha->iobase->isp24;
3143         status = 0;
3144
3145         if (unlikely(pci_channel_offline(ha->pdev)))
3146                 return IRQ_HANDLED;
3147
3148         spin_lock_irqsave(&ha->hardware_lock, flags);
3149         vha = pci_get_drvdata(ha->pdev);
3150         for (iter = 50; iter--; ) {
3151                 stat = RD_REG_DWORD(&reg->host_status);
3152                 if (qla2x00_check_reg32_for_disconnect(vha, stat))
3153                         break;
3154                 if (stat & HSRX_RISC_PAUSED) {
3155                         if (unlikely(pci_channel_offline(ha->pdev)))
3156                                 break;
3157
3158                         hccr = RD_REG_DWORD(&reg->hccr);
3159
3160                         ql_log(ql_log_warn, vha, 0x504b,
3161                             "RISC paused -- HCCR=%x, Dumping firmware.\n",
3162                             hccr);
3163
3164                         qla2xxx_check_risc_status(vha);
3165
3166                         ha->isp_ops->fw_dump(vha, 1);
3167                         set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
3168                         break;
3169                 } else if ((stat & HSRX_RISC_INT) == 0)
3170                         break;
3171
3172                 switch (stat & 0xff) {
3173                 case INTR_ROM_MB_SUCCESS:
3174                 case INTR_ROM_MB_FAILED:
3175                 case INTR_MB_SUCCESS:
3176                 case INTR_MB_FAILED:
3177                         qla24xx_mbx_completion(vha, MSW(stat));
3178                         status |= MBX_INTERRUPT;
3179
3180                         break;
3181                 case INTR_ASYNC_EVENT:
3182                         mb[0] = MSW(stat);
3183                         mb[1] = RD_REG_WORD(&reg->mailbox1);
3184                         mb[2] = RD_REG_WORD(&reg->mailbox2);
3185                         mb[3] = RD_REG_WORD(&reg->mailbox3);
3186                         qla2x00_async_event(vha, rsp, mb);
3187                         break;
3188                 case INTR_RSP_QUE_UPDATE:
3189                 case INTR_RSP_QUE_UPDATE_83XX:
3190                         qla24xx_process_response_queue(vha, rsp);
3191                         break;
3192                 case INTR_ATIO_QUE_UPDATE_27XX:
3193                 case INTR_ATIO_QUE_UPDATE:{
3194                         unsigned long flags2;
3195                         spin_lock_irqsave(&ha->tgt.atio_lock, flags2);
3196                         qlt_24xx_process_atio_queue(vha, 1);
3197                         spin_unlock_irqrestore(&ha->tgt.atio_lock, flags2);
3198                         break;
3199                 }
3200                 case INTR_ATIO_RSP_QUE_UPDATE: {
3201                         unsigned long flags2;
3202                         spin_lock_irqsave(&ha->tgt.atio_lock, flags2);
3203                         qlt_24xx_process_atio_queue(vha, 1);
3204                         spin_unlock_irqrestore(&ha->tgt.atio_lock, flags2);
3205
3206                         qla24xx_process_response_queue(vha, rsp);
3207                         break;
3208                 }
3209                 default:
3210                         ql_dbg(ql_dbg_async, vha, 0x504f,
3211                             "Unrecognized interrupt type (%d).\n", stat * 0xff);
3212                         break;
3213                 }
3214                 WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
3215                 RD_REG_DWORD_RELAXED(&reg->hccr);
3216                 if (unlikely(IS_QLA83XX(ha) && (ha->pdev->revision == 1)))
3217                         ndelay(3500);
3218         }
3219         qla2x00_handle_mbx_completion(ha, status);
3220         spin_unlock_irqrestore(&ha->hardware_lock, flags);
3221
3222         return IRQ_HANDLED;
3223 }
3224
3225 static irqreturn_t
3226 qla24xx_msix_rsp_q(int irq, void *dev_id)
3227 {
3228         struct qla_hw_data *ha;
3229         struct rsp_que *rsp;
3230         struct device_reg_24xx __iomem *reg;
3231         struct scsi_qla_host *vha;
3232         unsigned long flags;
3233
3234         rsp = (struct rsp_que *) dev_id;
3235         if (!rsp) {
3236                 ql_log(ql_log_info, NULL, 0x505a,
3237                     "%s: NULL response queue pointer.\n", __func__);
3238                 return IRQ_NONE;
3239         }
3240         ha = rsp->hw;
3241         reg = &ha->iobase->isp24;
3242
3243         spin_lock_irqsave(&ha->hardware_lock, flags);
3244
3245         vha = pci_get_drvdata(ha->pdev);
3246         qla24xx_process_response_queue(vha, rsp);
3247         if (!ha->flags.disable_msix_handshake) {
3248                 WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
3249                 RD_REG_DWORD_RELAXED(&reg->hccr);
3250         }
3251         spin_unlock_irqrestore(&ha->hardware_lock, flags);
3252
3253         return IRQ_HANDLED;
3254 }
3255
3256 static irqreturn_t
3257 qla24xx_msix_default(int irq, void *dev_id)
3258 {
3259         scsi_qla_host_t *vha;
3260         struct qla_hw_data *ha;
3261         struct rsp_que *rsp;
3262         struct device_reg_24xx __iomem *reg;
3263         int             status;
3264         uint32_t        stat;
3265         uint32_t        hccr;
3266         uint16_t        mb[8];
3267         unsigned long flags;
3268
3269         rsp = (struct rsp_que *) dev_id;
3270         if (!rsp) {
3271                 ql_log(ql_log_info, NULL, 0x505c,
3272                     "%s: NULL response queue pointer.\n", __func__);
3273                 return IRQ_NONE;
3274         }
3275         ha = rsp->hw;
3276         reg = &ha->iobase->isp24;
3277         status = 0;
3278
3279         spin_lock_irqsave(&ha->hardware_lock, flags);
3280         vha = pci_get_drvdata(ha->pdev);
3281         do {
3282                 stat = RD_REG_DWORD(&reg->host_status);
3283                 if (qla2x00_check_reg32_for_disconnect(vha, stat))
3284                         break;
3285                 if (stat & HSRX_RISC_PAUSED) {
3286                         if (unlikely(pci_channel_offline(ha->pdev)))
3287                                 break;
3288
3289                         hccr = RD_REG_DWORD(&reg->hccr);
3290
3291                         ql_log(ql_log_info, vha, 0x5050,
3292                             "RISC paused -- HCCR=%x, Dumping firmware.\n",
3293                             hccr);
3294
3295                         qla2xxx_check_risc_status(vha);
3296
3297                         ha->isp_ops->fw_dump(vha, 1);
3298                         set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
3299                         break;
3300                 } else if ((stat & HSRX_RISC_INT) == 0)
3301                         break;
3302
3303                 switch (stat & 0xff) {
3304                 case INTR_ROM_MB_SUCCESS:
3305                 case INTR_ROM_MB_FAILED:
3306                 case INTR_MB_SUCCESS:
3307                 case INTR_MB_FAILED:
3308                         qla24xx_mbx_completion(vha, MSW(stat));
3309                         status |= MBX_INTERRUPT;
3310
3311                         break;
3312                 case INTR_ASYNC_EVENT:
3313                         mb[0] = MSW(stat);
3314                         mb[1] = RD_REG_WORD(&reg->mailbox1);
3315                         mb[2] = RD_REG_WORD(&reg->mailbox2);
3316                         mb[3] = RD_REG_WORD(&reg->mailbox3);
3317                         qla2x00_async_event(vha, rsp, mb);
3318                         break;
3319                 case INTR_RSP_QUE_UPDATE:
3320                 case INTR_RSP_QUE_UPDATE_83XX:
3321                         qla24xx_process_response_queue(vha, rsp);
3322                         break;
3323                 case INTR_ATIO_QUE_UPDATE_27XX:
3324                 case INTR_ATIO_QUE_UPDATE:{
3325                         unsigned long flags2;
3326                         spin_lock_irqsave(&ha->tgt.atio_lock, flags2);
3327                         qlt_24xx_process_atio_queue(vha, 1);
3328                         spin_unlock_irqrestore(&ha->tgt.atio_lock, flags2);
3329                         break;
3330                 }
3331                 case INTR_ATIO_RSP_QUE_UPDATE: {
3332                         unsigned long flags2;
3333                         spin_lock_irqsave(&ha->tgt.atio_lock, flags2);
3334                         qlt_24xx_process_atio_queue(vha, 1);
3335                         spin_unlock_irqrestore(&ha->tgt.atio_lock, flags2);
3336
3337                         qla24xx_process_response_queue(vha, rsp);
3338                         break;
3339                 }
3340                 default:
3341                         ql_dbg(ql_dbg_async, vha, 0x5051,
3342                             "Unrecognized interrupt type (%d).\n", stat & 0xff);
3343                         break;
3344                 }
3345                 WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
3346         } while (0);
3347         qla2x00_handle_mbx_completion(ha, status);
3348         spin_unlock_irqrestore(&ha->hardware_lock, flags);
3349
3350         return IRQ_HANDLED;
3351 }
3352
3353 irqreturn_t
3354 qla2xxx_msix_rsp_q(int irq, void *dev_id)
3355 {
3356         struct qla_hw_data *ha;
3357         struct qla_qpair *qpair;
3358         struct device_reg_24xx __iomem *reg;
3359         unsigned long flags;
3360
3361         qpair = dev_id;
3362         if (!qpair) {
3363                 ql_log(ql_log_info, NULL, 0x505b,
3364                     "%s: NULL response queue pointer.\n", __func__);
3365                 return IRQ_NONE;
3366         }
3367         ha = qpair->hw;
3368
3369         /* Clear the interrupt, if enabled, for this response queue */
3370         if (unlikely(!ha->flags.disable_msix_handshake)) {
3371                 reg = &ha->iobase->isp24;
3372                 spin_lock_irqsave(&ha->hardware_lock, flags);
3373                 WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
3374                 spin_unlock_irqrestore(&ha->hardware_lock, flags);
3375         }
3376
3377         queue_work(ha->wq, &qpair->q_work);
3378
3379         return IRQ_HANDLED;
3380 }
3381
3382 /* Interrupt handling helpers. */
3383
3384 struct qla_init_msix_entry {
3385         const char *name;
3386         irq_handler_t handler;
3387 };
3388
3389 static const struct qla_init_msix_entry msix_entries[] = {
3390         { "default", qla24xx_msix_default },
3391         { "rsp_q", qla24xx_msix_rsp_q },
3392         { "atio_q", qla83xx_msix_atio_q },
3393         { "qpair_multiq", qla2xxx_msix_rsp_q },
3394 };
3395
3396 static const struct qla_init_msix_entry qla82xx_msix_entries[] = {
3397         { "qla2xxx (default)", qla82xx_msix_default },
3398         { "qla2xxx (rsp_q)", qla82xx_msix_rsp_q },
3399 };
3400
3401 static int
3402 qla24xx_enable_msix(struct qla_hw_data *ha, struct rsp_que *rsp)
3403 {
3404         int i, ret;
3405         struct qla_msix_entry *qentry;
3406         scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
3407         int min_vecs = QLA_BASE_VECTORS;
3408         struct irq_affinity desc = {
3409                 .pre_vectors = QLA_BASE_VECTORS,
3410         };
3411
3412         if (QLA_TGT_MODE_ENABLED() && (ql2xenablemsix != 0) &&
3413             IS_ATIO_MSIX_CAPABLE(ha)) {
3414                 desc.pre_vectors++;
3415                 min_vecs++;
3416         }
3417
3418         if (USER_CTRL_IRQ(ha)) {
3419                 /* user wants to control IRQ setting for target mode */
3420                 ret = pci_alloc_irq_vectors(ha->pdev, min_vecs,
3421                     ha->msix_count, PCI_IRQ_MSIX);
3422         } else
3423                 ret = pci_alloc_irq_vectors_affinity(ha->pdev, min_vecs,
3424                     ha->msix_count, PCI_IRQ_MSIX | PCI_IRQ_AFFINITY,
3425                     &desc);
3426
3427         if (ret < 0) {
3428                 ql_log(ql_log_fatal, vha, 0x00c7,
3429                     "MSI-X: Failed to enable support, "
3430                     "giving   up -- %d/%d.\n",
3431                     ha->msix_count, ret);
3432                 goto msix_out;
3433         } else if (ret < ha->msix_count) {
3434                 ql_log(ql_log_warn, vha, 0x00c6,
3435                     "MSI-X: Failed to enable support "
3436                      "with %d vectors, using %d vectors.\n",
3437                     ha->msix_count, ret);
3438                 ha->msix_count = ret;
3439                 /* Recalculate queue values */
3440                 if (ha->mqiobase && (ql2xmqsupport || ql2xnvmeenable)) {
3441                         ha->max_req_queues = ha->msix_count - 1;
3442
3443                         /* ATIOQ needs 1 vector. That's 1 less QPair */
3444                         if (QLA_TGT_MODE_ENABLED())
3445                                 ha->max_req_queues--;
3446
3447                         ha->max_rsp_queues = ha->max_req_queues;
3448
3449                         ha->max_qpairs = ha->max_req_queues - 1;
3450                         ql_dbg_pci(ql_dbg_init, ha->pdev, 0x0190,
3451                             "Adjusted Max no of queues pairs: %d.\n", ha->max_qpairs);
3452                 }
3453         }
3454         ha->msix_entries = kzalloc(sizeof(struct qla_msix_entry) *
3455                                 ha->msix_count, GFP_KERNEL);
3456         if (!ha->msix_entries) {
3457                 ql_log(ql_log_fatal, vha, 0x00c8,
3458                     "Failed to allocate memory for ha->msix_entries.\n");
3459                 ret = -ENOMEM;
3460                 goto msix_out;
3461         }
3462         ha->flags.msix_enabled = 1;
3463
3464         for (i = 0; i < ha->msix_count; i++) {
3465                 qentry = &ha->msix_entries[i];
3466                 qentry->vector = pci_irq_vector(ha->pdev, i);
3467                 qentry->entry = i;
3468                 qentry->have_irq = 0;
3469                 qentry->in_use = 0;
3470                 qentry->handle = NULL;
3471         }
3472
3473         /* Enable MSI-X vectors for the base queue */
3474         for (i = 0; i < QLA_BASE_VECTORS; i++) {
3475                 qentry = &ha->msix_entries[i];
3476                 qentry->handle = rsp;
3477                 rsp->msix = qentry;
3478                 scnprintf(qentry->name, sizeof(qentry->name),
3479                     "qla2xxx%lu_%s", vha->host_no, msix_entries[i].name);
3480                 if (IS_P3P_TYPE(ha))
3481                         ret = request_irq(qentry->vector,
3482                                 qla82xx_msix_entries[i].handler,
3483                                 0, qla82xx_msix_entries[i].name, rsp);
3484                 else
3485                         ret = request_irq(qentry->vector,
3486                                 msix_entries[i].handler,
3487                                 0, qentry->name, rsp);
3488                 if (ret)
3489                         goto msix_register_fail;
3490                 qentry->have_irq = 1;
3491                 qentry->in_use = 1;
3492         }
3493
3494         /*
3495          * If target mode is enable, also request the vector for the ATIO
3496          * queue.
3497          */
3498         if (QLA_TGT_MODE_ENABLED() && (ql2xenablemsix != 0) &&
3499             IS_ATIO_MSIX_CAPABLE(ha)) {
3500                 qentry = &ha->msix_entries[QLA_ATIO_VECTOR];
3501                 rsp->msix = qentry;
3502                 qentry->handle = rsp;
3503                 scnprintf(qentry->name, sizeof(qentry->name),
3504                     "qla2xxx%lu_%s", vha->host_no,
3505                     msix_entries[QLA_ATIO_VECTOR].name);
3506                 qentry->in_use = 1;
3507                 ret = request_irq(qentry->vector,
3508                         msix_entries[QLA_ATIO_VECTOR].handler,
3509                         0, qentry->name, rsp);
3510                 qentry->have_irq = 1;
3511         }
3512
3513 msix_register_fail:
3514         if (ret) {
3515                 ql_log(ql_log_fatal, vha, 0x00cb,
3516                     "MSI-X: unable to register handler -- %x/%d.\n",
3517                     qentry->vector, ret);
3518                 qla2x00_free_irqs(vha);
3519                 ha->mqenable = 0;
3520                 goto msix_out;
3521         }
3522
3523         /* Enable MSI-X vector for response queue update for queue 0 */
3524         if (IS_QLA83XX(ha) || IS_QLA27XX(ha)) {
3525                 if (ha->msixbase && ha->mqiobase &&
3526                     (ha->max_rsp_queues > 1 || ha->max_req_queues > 1 ||
3527                      ql2xmqsupport))
3528                         ha->mqenable = 1;
3529         } else
3530                 if (ha->mqiobase &&
3531                     (ha->max_rsp_queues > 1 || ha->max_req_queues > 1 ||
3532                      ql2xmqsupport))
3533                         ha->mqenable = 1;
3534         ql_dbg(ql_dbg_multiq, vha, 0xc005,
3535             "mqiobase=%p, max_rsp_queues=%d, max_req_queues=%d.\n",
3536             ha->mqiobase, ha->max_rsp_queues, ha->max_req_queues);
3537         ql_dbg(ql_dbg_init, vha, 0x0055,
3538             "mqiobase=%p, max_rsp_queues=%d, max_req_queues=%d.\n",
3539             ha->mqiobase, ha->max_rsp_queues, ha->max_req_queues);
3540
3541 msix_out:
3542         return ret;
3543 }
3544
3545 int
3546 qla2x00_request_irqs(struct qla_hw_data *ha, struct rsp_que *rsp)
3547 {
3548         int ret = QLA_FUNCTION_FAILED;
3549         device_reg_t *reg = ha->iobase;
3550         scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
3551
3552         /* If possible, enable MSI-X. */
3553         if (ql2xenablemsix == 0 || (!IS_QLA2432(ha) && !IS_QLA2532(ha) &&
3554             !IS_QLA8432(ha) && !IS_CNA_CAPABLE(ha) && !IS_QLA2031(ha) &&
3555             !IS_QLAFX00(ha) && !IS_QLA27XX(ha)))
3556                 goto skip_msi;
3557
3558         if (ql2xenablemsix == 2)
3559                 goto skip_msix;
3560
3561         if (ha->pdev->subsystem_vendor == PCI_VENDOR_ID_HP &&
3562                 (ha->pdev->subsystem_device == 0x7040 ||
3563                 ha->pdev->subsystem_device == 0x7041 ||
3564                 ha->pdev->subsystem_device == 0x1705)) {
3565                 ql_log(ql_log_warn, vha, 0x0034,
3566                     "MSI-X: Unsupported ISP 2432 SSVID/SSDID (0x%X,0x%X).\n",
3567                         ha->pdev->subsystem_vendor,
3568                         ha->pdev->subsystem_device);
3569                 goto skip_msi;
3570         }
3571
3572         if (IS_QLA2432(ha) && (ha->pdev->revision < QLA_MSIX_CHIP_REV_24XX)) {
3573                 ql_log(ql_log_warn, vha, 0x0035,
3574                     "MSI-X; Unsupported ISP2432 (0x%X, 0x%X).\n",
3575                     ha->pdev->revision, QLA_MSIX_CHIP_REV_24XX);
3576                 goto skip_msix;
3577         }
3578
3579         ret = qla24xx_enable_msix(ha, rsp);
3580         if (!ret) {
3581                 ql_dbg(ql_dbg_init, vha, 0x0036,
3582                     "MSI-X: Enabled (0x%X, 0x%X).\n",
3583                     ha->chip_revision, ha->fw_attributes);
3584                 goto clear_risc_ints;
3585         }
3586
3587 skip_msix:
3588
3589         ql_log(ql_log_info, vha, 0x0037,
3590             "Falling back-to MSI mode -%d.\n", ret);
3591
3592         if (!IS_QLA24XX(ha) && !IS_QLA2532(ha) && !IS_QLA8432(ha) &&
3593             !IS_QLA8001(ha) && !IS_P3P_TYPE(ha) && !IS_QLAFX00(ha) &&
3594             !IS_QLA27XX(ha))
3595                 goto skip_msi;
3596
3597         ret = pci_alloc_irq_vectors(ha->pdev, 1, 1, PCI_IRQ_MSI);
3598         if (!ret) {
3599                 ql_dbg(ql_dbg_init, vha, 0x0038,
3600                     "MSI: Enabled.\n");
3601                 ha->flags.msi_enabled = 1;
3602         } else
3603                 ql_log(ql_log_warn, vha, 0x0039,
3604                     "Falling back-to INTa mode -- %d.\n", ret);
3605 skip_msi:
3606
3607         /* Skip INTx on ISP82xx. */
3608         if (!ha->flags.msi_enabled && IS_QLA82XX(ha))
3609                 return QLA_FUNCTION_FAILED;
3610
3611         ret = request_irq(ha->pdev->irq, ha->isp_ops->intr_handler,
3612             ha->flags.msi_enabled ? 0 : IRQF_SHARED,
3613             QLA2XXX_DRIVER_NAME, rsp);
3614         if (ret) {
3615                 ql_log(ql_log_warn, vha, 0x003a,
3616                     "Failed to reserve interrupt %d already in use.\n",
3617                     ha->pdev->irq);
3618                 goto fail;
3619         } else if (!ha->flags.msi_enabled) {
3620                 ql_dbg(ql_dbg_init, vha, 0x0125,
3621                     "INTa mode: Enabled.\n");
3622                 ha->flags.mr_intr_valid = 1;
3623         }
3624
3625 clear_risc_ints:
3626         if (IS_FWI2_CAPABLE(ha) || IS_QLAFX00(ha))
3627                 goto fail;
3628
3629         spin_lock_irq(&ha->hardware_lock);
3630         WRT_REG_WORD(&reg->isp.semaphore, 0);
3631         spin_unlock_irq(&ha->hardware_lock);
3632
3633 fail:
3634         return ret;
3635 }
3636
3637 void
3638 qla2x00_free_irqs(scsi_qla_host_t *vha)
3639 {
3640         struct qla_hw_data *ha = vha->hw;
3641         struct rsp_que *rsp;
3642         struct qla_msix_entry *qentry;
3643         int i;
3644
3645         /*
3646          * We need to check that ha->rsp_q_map is valid in case we are called
3647          * from a probe failure context.
3648          */
3649         if (!ha->rsp_q_map || !ha->rsp_q_map[0])
3650                 goto free_irqs;
3651         rsp = ha->rsp_q_map[0];
3652
3653         if (ha->flags.msix_enabled) {
3654                 for (i = 0; i < ha->msix_count; i++) {
3655                         qentry = &ha->msix_entries[i];
3656                         if (qentry->have_irq) {
3657                                 irq_set_affinity_notifier(qentry->vector, NULL);
3658                                 free_irq(pci_irq_vector(ha->pdev, i), qentry->handle);
3659                         }
3660                 }
3661                 kfree(ha->msix_entries);
3662                 ha->msix_entries = NULL;
3663                 ha->flags.msix_enabled = 0;
3664                 ql_dbg(ql_dbg_init, vha, 0x0042,
3665                         "Disabled MSI-X.\n");
3666         } else {
3667                 free_irq(pci_irq_vector(ha->pdev, 0), rsp);
3668         }
3669
3670 free_irqs:
3671         pci_free_irq_vectors(ha->pdev);
3672 }
3673
3674 int qla25xx_request_irq(struct qla_hw_data *ha, struct qla_qpair *qpair,
3675         struct qla_msix_entry *msix, int vector_type)
3676 {
3677         const struct qla_init_msix_entry *intr = &msix_entries[vector_type];
3678         scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
3679         int ret;
3680
3681         scnprintf(msix->name, sizeof(msix->name),
3682             "qla2xxx%lu_qpair%d", vha->host_no, qpair->id);
3683         ret = request_irq(msix->vector, intr->handler, 0, msix->name, qpair);
3684         if (ret) {
3685                 ql_log(ql_log_fatal, vha, 0x00e6,
3686                     "MSI-X: Unable to register handler -- %x/%d.\n",
3687                     msix->vector, ret);
3688                 return ret;
3689         }
3690         msix->have_irq = 1;
3691         msix->handle = qpair;
3692         return ret;
3693 }