git.oblomov.eu Git - linux-2.6/blob - drivers/scsi/qla2xxx/qla_isr.c

   1 /*
   2  *                  QLOGIC LINUX SOFTWARE
   3  *
   4  * QLogic ISP2x00 device driver for Linux 2.6.x
   5  * Copyright (C) 2003-2005 QLogic Corporation
   6  * (www.qlogic.com)
   7  *
   8  * This program is free software; you can redistribute it and/or modify it
   9  * under the terms of the GNU General Public License as published by the
  10  * Free Software Foundation; either version 2, or (at your option) any
  11  * later version.
  12  *
  13  * This program is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * General Public License for more details.
  17  *
  18  */
  19 #include "qla_def.h"
  20
  21 static void qla2x00_mbx_completion(scsi_qla_host_t *, uint16_t);
  22 static void qla2x00_async_event(scsi_qla_host_t *, uint16_t *);
  23 static void qla2x00_process_completed_request(struct scsi_qla_host *, uint32_t);
  24 void qla2x00_process_response_queue(struct scsi_qla_host *);
  25 static void qla2x00_status_entry(scsi_qla_host_t *, void *);
  26 static void qla2x00_status_cont_entry(scsi_qla_host_t *, sts_cont_entry_t *);
  27 static void qla2x00_error_entry(scsi_qla_host_t *, sts_entry_t *);
  28 static void qla2x00_ms_entry(scsi_qla_host_t *, ms_iocb_entry_t *);
  29
  30 void qla24xx_process_response_queue(scsi_qla_host_t *);
  31 static void qla24xx_ms_entry(scsi_qla_host_t *, struct ct_entry_24xx *);
  32
  33 /**
  34  * qla2100_intr_handler() - Process interrupts for the ISP2100 and ISP2200.
  35  * @irq:
  36  * @dev_id: SCSI driver HA context
  37  * @regs:
  38  *
  39  * Called by system whenever the host adapter generates an interrupt.
  40  *
  41  * Returns handled flag.
  42  */
  43 irqreturn_t
  44 qla2100_intr_handler(int irq, void *dev_id, struct pt_regs *regs)
  45 {
  46         scsi_qla_host_t *ha;
  47         struct device_reg_2xxx __iomem *reg;
  48         int             status;
  49         unsigned long   flags;
  50         unsigned long   iter;
  51         uint16_t        mb[4];
  52
  53         ha = (scsi_qla_host_t *) dev_id;
  54         if (!ha) {
  55                 printk(KERN_INFO
  56                     "%s(): NULL host pointer\n", __func__);
  57                 return (IRQ_NONE);
  58         }
  59
  60         reg = &ha->iobase->isp;
  61         status = 0;
  62
  63         spin_lock_irqsave(&ha->hardware_lock, flags);
  64         for (iter = 50; iter--; ) {
  65                 if ((RD_REG_WORD(&reg->istatus) & ISR_RISC_INT) == 0)
  66                         break;
  67
  68                 if (RD_REG_WORD(&reg->semaphore) & BIT_0) {
  69                         WRT_REG_WORD(&reg->hccr, HCCR_CLR_RISC_INT);
  70                         RD_REG_WORD(&reg->hccr);
  71
  72                         /* Get mailbox data. */
  73                         mb[0] = RD_MAILBOX_REG(ha, reg, 0);
  74                         if (mb[0] > 0x3fff && mb[0] < 0x8000) {
  75                                 qla2x00_mbx_completion(ha, mb[0]);
  76                                 status |= MBX_INTERRUPT;
  77                         } else if (mb[0] > 0x7fff && mb[0] < 0xc000) {
  78                                 mb[1] = RD_MAILBOX_REG(ha, reg, 1);
  79                                 mb[2] = RD_MAILBOX_REG(ha, reg, 2);
  80                                 mb[3] = RD_MAILBOX_REG(ha, reg, 3);
  81                                 qla2x00_async_event(ha, mb);
  82                         } else {
  83                                 /*EMPTY*/
  84                                 DEBUG2(printk("scsi(%ld): Unrecognized "
  85                                     "interrupt type (%d).\n",
  86                                     ha->host_no, mb[0]));
  87                         }
  88                         /* Release mailbox registers. */
  89                         WRT_REG_WORD(&reg->semaphore, 0);
  90                         RD_REG_WORD(&reg->semaphore);
  91                 } else {
  92                         qla2x00_process_response_queue(ha);
  93
  94                         WRT_REG_WORD(&reg->hccr, HCCR_CLR_RISC_INT);
  95                         RD_REG_WORD(&reg->hccr);
  96                 }
  97         }
  98         spin_unlock_irqrestore(&ha->hardware_lock, flags);
  99
 100         if (test_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags) &&
 101             (status & MBX_INTERRUPT) && ha->flags.mbox_int) {
 102                 spin_lock_irqsave(&ha->mbx_reg_lock, flags);
 103
 104                 set_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
 105                 up(&ha->mbx_intr_sem);
 106
 107                 spin_unlock_irqrestore(&ha->mbx_reg_lock, flags);
 108         }
 109
 110         return (IRQ_HANDLED);
 111 }
 112
 113 /**
 114  * qla2300_intr_handler() - Process interrupts for the ISP23xx and ISP63xx.
 115  * @irq:
 116  * @dev_id: SCSI driver HA context
 117  * @regs:
 118  *
 119  * Called by system whenever the host adapter generates an interrupt.
 120  *
 121  * Returns handled flag.
 122  */
 123 irqreturn_t
 124 qla2300_intr_handler(int irq, void *dev_id, struct pt_regs *regs)
 125 {
 126         scsi_qla_host_t *ha;
 127         struct device_reg_2xxx __iomem *reg;
 128         int             status;
 129         unsigned long   flags;
 130         unsigned long   iter;
 131         uint32_t        stat;
 132         uint16_t        hccr;
 133         uint16_t        mb[4];
 134
 135         ha = (scsi_qla_host_t *) dev_id;
 136         if (!ha) {
 137                 printk(KERN_INFO
 138                     "%s(): NULL host pointer\n", __func__);
 139                 return (IRQ_NONE);
 140         }
 141
 142         reg = &ha->iobase->isp;
 143         status = 0;
 144
 145         spin_lock_irqsave(&ha->hardware_lock, flags);
 146         for (iter = 50; iter--; ) {
 147                 stat = RD_REG_DWORD(&reg->u.isp2300.host_status);
 148                 if (stat & HSR_RISC_PAUSED) {
 149                         hccr = RD_REG_WORD(&reg->hccr);
 150                         if (hccr & (BIT_15 | BIT_13 | BIT_11 | BIT_8))
 151                                 qla_printk(KERN_INFO, ha,
 152                                     "Parity error -- HCCR=%x.\n", hccr);
 153                         else
 154                                 qla_printk(KERN_INFO, ha,
 155                                     "RISC paused -- HCCR=%x.\n", hccr);
 156
 157                         /*
 158                          * Issue a "HARD" reset in order for the RISC
 159                          * interrupt bit to be cleared.  Schedule a big
 160                          * hammmer to get out of the RISC PAUSED state.
 161                          */
 162                         WRT_REG_WORD(&reg->hccr, HCCR_RESET_RISC);
 163                         RD_REG_WORD(&reg->hccr);
 164                         set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
 165                         break;
 166                 } else if ((stat & HSR_RISC_INT) == 0)
 167                         break;
 168
 169                 switch (stat & 0xff) {
 170                 case 0x1:
 171                 case 0x2:
 172                 case 0x10:
 173                 case 0x11:
 174                         qla2x00_mbx_completion(ha, MSW(stat));
 175                         status |= MBX_INTERRUPT;
 176
 177                         /* Release mailbox registers. */
 178                         WRT_REG_WORD(&reg->semaphore, 0);
 179                         break;
 180                 case 0x12:
 181                         mb[0] = MSW(stat);
 182                         mb[1] = RD_MAILBOX_REG(ha, reg, 1);
 183                         mb[2] = RD_MAILBOX_REG(ha, reg, 2);
 184                         mb[3] = RD_MAILBOX_REG(ha, reg, 3);
 185                         qla2x00_async_event(ha, mb);
 186                         break;
 187                 case 0x13:
 188                         qla2x00_process_response_queue(ha);
 189                         break;
 190                 case 0x15:
 191                         mb[0] = MBA_CMPLT_1_16BIT;
 192                         mb[1] = MSW(stat);
 193                         qla2x00_async_event(ha, mb);
 194                         break;
 195                 case 0x16:
 196                         mb[0] = MBA_SCSI_COMPLETION;
 197                         mb[1] = MSW(stat);
 198                         mb[2] = RD_MAILBOX_REG(ha, reg, 2);
 199                         qla2x00_async_event(ha, mb);
 200                         break;
 201                 default:
 202                         DEBUG2(printk("scsi(%ld): Unrecognized interrupt type "
 203                             "(%d).\n",
 204                             ha->host_no, stat & 0xff));
 205                         break;
 206                 }
 207                 WRT_REG_WORD(&reg->hccr, HCCR_CLR_RISC_INT);
 208                 RD_REG_WORD_RELAXED(&reg->hccr);
 209         }
 210         spin_unlock_irqrestore(&ha->hardware_lock, flags);
 211
 212         if (test_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags) &&
 213             (status & MBX_INTERRUPT) && ha->flags.mbox_int) {
 214                 spin_lock_irqsave(&ha->mbx_reg_lock, flags);
 215
 216                 set_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
 217                 up(&ha->mbx_intr_sem);
 218
 219                 spin_unlock_irqrestore(&ha->mbx_reg_lock, flags);
 220         }
 221
 222         return (IRQ_HANDLED);
 223 }
 224
 225 /**
 226  * qla2x00_mbx_completion() - Process mailbox command completions.
 227  * @ha: SCSI driver HA context
 228  * @mb0: Mailbox0 register
 229  */
 230 static void
 231 qla2x00_mbx_completion(scsi_qla_host_t *ha, uint16_t mb0)
 232 {
 233         uint16_t        cnt;
 234         uint16_t __iomem *wptr;
 235         struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
 236
 237         /* Load return mailbox registers. */
 238         ha->flags.mbox_int = 1;
 239         ha->mailbox_out[0] = mb0;
 240         wptr = (uint16_t __iomem *)MAILBOX_REG(ha, reg, 1);
 241
 242         for (cnt = 1; cnt < ha->mbx_count; cnt++) {
 243                 if (IS_QLA2200(ha) && cnt == 8)
 244                         wptr = (uint16_t __iomem *)MAILBOX_REG(ha, reg, 8);
 245                 if (cnt == 4 || cnt == 5)
 246                         ha->mailbox_out[cnt] = qla2x00_debounce_register(wptr);
 247                 else
 248                         ha->mailbox_out[cnt] = RD_REG_WORD(wptr);
 249
 250                 wptr++;
 251         }
 252
 253         if (ha->mcp) {
 254                 DEBUG3(printk("%s(%ld): Got mailbox completion. cmd=%x.\n",
 255                     __func__, ha->host_no, ha->mcp->mb[0]));
 256         } else {
 257                 DEBUG2_3(printk("%s(%ld): MBX pointer ERROR!\n",
 258                     __func__, ha->host_no));
 259         }
 260 }
 261
 262 /**
 263  * qla2x00_async_event() - Process aynchronous events.
 264  * @ha: SCSI driver HA context
 265  * @mb: Mailbox registers (0 - 3)
 266  */
 267 static void
 268 qla2x00_async_event(scsi_qla_host_t *ha, uint16_t *mb)
 269 {
 270 #define LS_UNKNOWN      2
 271         static char     *link_speeds[5] = { "1", "2", "?", "4", "10" };
 272         char            *link_speed;
 273         uint16_t        handle_cnt;
 274         uint16_t        cnt;
 275         uint32_t        handles[5];
 276         struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
 277         uint32_t        rscn_entry, host_pid;
 278         uint8_t         rscn_queue_index;
 279
 280         /* Setup to process RIO completion. */
 281         handle_cnt = 0;
 282         switch (mb[0]) {
 283         case MBA_SCSI_COMPLETION:
 284                 handles[0] = le32_to_cpu((uint32_t)((mb[2] << 16) | mb[1]));
 285                 handle_cnt = 1;
 286                 break;
 287         case MBA_CMPLT_1_16BIT:
 288                 handles[0] = mb[1];
 289                 handle_cnt = 1;
 290                 mb[0] = MBA_SCSI_COMPLETION;
 291                 break;
 292         case MBA_CMPLT_2_16BIT:
 293                 handles[0] = mb[1];
 294                 handles[1] = mb[2];
 295                 handle_cnt = 2;
 296                 mb[0] = MBA_SCSI_COMPLETION;
 297                 break;
 298         case MBA_CMPLT_3_16BIT:
 299                 handles[0] = mb[1];
 300                 handles[1] = mb[2];
 301                 handles[2] = mb[3];
 302                 handle_cnt = 3;
 303                 mb[0] = MBA_SCSI_COMPLETION;
 304                 break;
 305         case MBA_CMPLT_4_16BIT:
 306                 handles[0] = mb[1];
 307                 handles[1] = mb[2];
 308                 handles[2] = mb[3];
 309                 handles[3] = (uint32_t)RD_MAILBOX_REG(ha, reg, 6);
 310                 handle_cnt = 4;
 311                 mb[0] = MBA_SCSI_COMPLETION;
 312                 break;
 313         case MBA_CMPLT_5_16BIT:
 314                 handles[0] = mb[1];
 315                 handles[1] = mb[2];
 316                 handles[2] = mb[3];
 317                 handles[3] = (uint32_t)RD_MAILBOX_REG(ha, reg, 6);
 318                 handles[4] = (uint32_t)RD_MAILBOX_REG(ha, reg, 7);
 319                 handle_cnt = 5;
 320                 mb[0] = MBA_SCSI_COMPLETION;
 321                 break;
 322         case MBA_CMPLT_2_32BIT:
 323                 handles[0] = le32_to_cpu((uint32_t)((mb[2] << 16) | mb[1]));
 324                 handles[1] = le32_to_cpu(
 325                     ((uint32_t)(RD_MAILBOX_REG(ha, reg, 7) << 16)) |
 326                     RD_MAILBOX_REG(ha, reg, 6));
 327                 handle_cnt = 2;
 328                 mb[0] = MBA_SCSI_COMPLETION;
 329                 break;
 330         default:
 331                 break;
 332         }
 333
 334         switch (mb[0]) {
 335         case MBA_SCSI_COMPLETION:       /* Fast Post */
 336                 if (!ha->flags.online)
 337                         break;
 338
 339                 for (cnt = 0; cnt < handle_cnt; cnt++)
 340                         qla2x00_process_completed_request(ha, handles[cnt]);
 341                 break;
 342
 343         case MBA_RESET:                 /* Reset */
 344                 DEBUG2(printk("scsi(%ld): Asynchronous RESET.\n", ha->host_no));
 345
 346                 set_bit(RESET_MARKER_NEEDED, &ha->dpc_flags);
 347                 break;
 348
 349         case MBA_SYSTEM_ERR:            /* System Error */
 350                 mb[1] = RD_MAILBOX_REG(ha, reg, 1);
 351                 mb[2] = RD_MAILBOX_REG(ha, reg, 2);
 352                 mb[3] = RD_MAILBOX_REG(ha, reg, 3);
 353
 354                 qla_printk(KERN_INFO, ha,
 355                     "ISP System Error - mbx1=%xh mbx2=%xh mbx3=%xh.\n",
 356                     mb[1], mb[2], mb[3]);
 357
 358                 ha->isp_ops.fw_dump(ha, 1);
 359
 360                 if (IS_QLA24XX(ha) || IS_QLA25XX(ha)) {
 361                         if (mb[1] == 0 && mb[2] == 0) {
 362                                 qla_printk(KERN_ERR, ha,
 363                                     "Unrecoverable Hardware Error: adapter "
 364                                     "marked OFFLINE!\n");
 365                                 ha->flags.online = 0;
 366                         } else
 367                                 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
 368                 } else if (mb[1] == 0) {
 369                         qla_printk(KERN_INFO, ha,
 370                             "Unrecoverable Hardware Error: adapter marked "
 371                             "OFFLINE!\n");
 372                         ha->flags.online = 0;
 373                 } else
 374                         set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
 375                 break;
 376
 377         case MBA_REQ_TRANSFER_ERR:      /* Request Transfer Error */
 378                 DEBUG2(printk("scsi(%ld): ISP Request Transfer Error.\n",
 379                     ha->host_no));
 380                 qla_printk(KERN_WARNING, ha, "ISP Request Transfer Error.\n");
 381
 382                 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
 383                 break;
 384
 385         case MBA_RSP_TRANSFER_ERR:      /* Response Transfer Error */
 386                 DEBUG2(printk("scsi(%ld): ISP Response Transfer Error.\n",
 387                     ha->host_no));
 388                 qla_printk(KERN_WARNING, ha, "ISP Response Transfer Error.\n");
 389
 390                 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
 391                 break;
 392
 393         case MBA_WAKEUP_THRES:          /* Request Queue Wake-up */
 394                 DEBUG2(printk("scsi(%ld): Asynchronous WAKEUP_THRES.\n",
 395                     ha->host_no));
 396                 break;
 397
 398         case MBA_LIP_OCCURRED:          /* Loop Initialization Procedure */
 399                 DEBUG2(printk("scsi(%ld): LIP occured (%x).\n", ha->host_no,
 400                     mb[1]));
 401                 qla_printk(KERN_INFO, ha, "LIP occured (%x).\n", mb[1]);
 402
 403                 if (atomic_read(&ha->loop_state) != LOOP_DOWN) {
 404                         atomic_set(&ha->loop_state, LOOP_DOWN);
 405                         atomic_set(&ha->loop_down_timer, LOOP_DOWN_TIME);
 406                         qla2x00_mark_all_devices_lost(ha);
 407                 }
 408
 409                 set_bit(REGISTER_FC4_NEEDED, &ha->dpc_flags);
 410
 411                 ha->flags.management_server_logged_in = 0;
 412
 413                 /* Update AEN queue. */
 414                 qla2x00_enqueue_aen(ha, MBA_LIP_OCCURRED, NULL);
 415
 416                 break;
 417
 418         case MBA_LOOP_UP:               /* Loop Up Event */
 419                 ha->link_data_rate = 0;
 420                 if (IS_QLA2100(ha) || IS_QLA2200(ha)) {
 421                         link_speed = link_speeds[0];
 422                 } else {
 423                         link_speed = link_speeds[LS_UNKNOWN];
 424                         if (mb[1] < 5)
 425                                 link_speed = link_speeds[mb[1]];
 426                         ha->link_data_rate = mb[1];
 427                 }
 428
 429                 DEBUG2(printk("scsi(%ld): Asynchronous LOOP UP (%s Gbps).\n",
 430                     ha->host_no, link_speed));
 431                 qla_printk(KERN_INFO, ha, "LOOP UP detected (%s Gbps).\n",
 432                     link_speed);
 433
 434                 ha->flags.management_server_logged_in = 0;
 435
 436                 /* Update AEN queue. */
 437                 qla2x00_enqueue_aen(ha, MBA_LOOP_UP, NULL);
 438                 break;
 439
 440         case MBA_LOOP_DOWN:             /* Loop Down Event */
 441                 DEBUG2(printk("scsi(%ld): Asynchronous LOOP DOWN (%x).\n",
 442                     ha->host_no, mb[1]));
 443                 qla_printk(KERN_INFO, ha, "LOOP DOWN detected (%x).\n", mb[1]);
 444
 445                 if (atomic_read(&ha->loop_state) != LOOP_DOWN) {
 446                         atomic_set(&ha->loop_state, LOOP_DOWN);
 447                         atomic_set(&ha->loop_down_timer, LOOP_DOWN_TIME);
 448                         ha->device_flags |= DFLG_NO_CABLE;
 449                         qla2x00_mark_all_devices_lost(ha);
 450                 }
 451
 452                 ha->flags.management_server_logged_in = 0;
 453                 ha->link_data_rate = 0;
 454
 455                 /* Update AEN queue. */
 456                 qla2x00_enqueue_aen(ha, MBA_LOOP_DOWN, NULL);
 457                 break;
 458
 459         case MBA_LIP_RESET:             /* LIP reset occurred */
 460                 DEBUG2(printk("scsi(%ld): Asynchronous LIP RESET (%x).\n",
 461                     ha->host_no, mb[1]));
 462                 qla_printk(KERN_INFO, ha,
 463                     "LIP reset occured (%x).\n", mb[1]);
 464
 465                 if (atomic_read(&ha->loop_state) != LOOP_DOWN) {
 466                         atomic_set(&ha->loop_state, LOOP_DOWN);
 467                         atomic_set(&ha->loop_down_timer, LOOP_DOWN_TIME);
 468                         qla2x00_mark_all_devices_lost(ha);
 469                 }
 470
 471                 set_bit(RESET_MARKER_NEEDED, &ha->dpc_flags);
 472
 473                 ha->operating_mode = LOOP;
 474                 ha->flags.management_server_logged_in = 0;
 475
 476                 /* Update AEN queue. */
 477                 qla2x00_enqueue_aen(ha, MBA_LIP_RESET, NULL);
 478
 479                 break;
 480
 481         case MBA_POINT_TO_POINT:        /* Point-to-Point */
 482                 if (IS_QLA2100(ha))
 483                         break;
 484
 485                 DEBUG2(printk("scsi(%ld): Asynchronous P2P MODE received.\n",
 486                     ha->host_no));
 487
 488                 /*
 489                  * Until there's a transition from loop down to loop up, treat
 490                  * this as loop down only.
 491                  */
 492                 if (atomic_read(&ha->loop_state) != LOOP_DOWN) {
 493                         atomic_set(&ha->loop_state, LOOP_DOWN);
 494                         if (!atomic_read(&ha->loop_down_timer))
 495                                 atomic_set(&ha->loop_down_timer,
 496                                     LOOP_DOWN_TIME);
 497                         qla2x00_mark_all_devices_lost(ha);
 498                 }
 499
 500                 if (!(test_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags))) {
 501                         set_bit(RESET_MARKER_NEEDED, &ha->dpc_flags);
 502                 }
 503                 set_bit(REGISTER_FC4_NEEDED, &ha->dpc_flags);
 504                 break;
 505
 506         case MBA_CHG_IN_CONNECTION:     /* Change in connection mode */
 507                 if (IS_QLA2100(ha))
 508                         break;
 509
 510                 DEBUG2(printk("scsi(%ld): Asynchronous Change In Connection "
 511                     "received.\n",
 512                     ha->host_no));
 513                 qla_printk(KERN_INFO, ha,
 514                     "Configuration change detected: value=%x.\n", mb[1]);
 515
 516                 if (atomic_read(&ha->loop_state) != LOOP_DOWN) {
 517                         atomic_set(&ha->loop_state, LOOP_DOWN);
 518                         if (!atomic_read(&ha->loop_down_timer))
 519                                 atomic_set(&ha->loop_down_timer,
 520                                     LOOP_DOWN_TIME);
 521                         qla2x00_mark_all_devices_lost(ha);
 522                 }
 523
 524                 set_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags);
 525                 set_bit(LOCAL_LOOP_UPDATE, &ha->dpc_flags);
 526                 break;
 527
 528         case MBA_PORT_UPDATE:           /* Port database update */
 529                 /*
 530                  * If a single remote port just logged into (or logged out of)
 531                  * us, create a new entry in our rscn fcports list and handle
 532                  * the event like an RSCN.
 533                  */
 534                 if (!IS_QLA2100(ha) && !IS_QLA2200(ha) && !IS_QLA6312(ha) &&
 535                     !IS_QLA6322(ha) && !IS_QLA24XX(ha) && !IS_QLA25XX(ha) &&
 536                     ha->flags.init_done && mb[1] != 0xffff &&
 537                     ((ha->operating_mode == P2P && mb[1] != 0) ||
 538                     (ha->operating_mode != P2P && mb[1] !=
 539                         SNS_FIRST_LOOP_ID)) && (mb[2] == 6 || mb[2] == 7)) {
 540                         int rval;
 541                         fc_port_t *rscn_fcport;
 542
 543                         /* Create new fcport for login. */
 544                         rscn_fcport = qla2x00_alloc_rscn_fcport(ha, GFP_ATOMIC);
 545                         if (rscn_fcport) {
 546                                 DEBUG14(printk("scsi(%ld): Port Update -- "
 547                                     "creating RSCN fcport %p for %x/%x/%x.\n",
 548                                     ha->host_no, rscn_fcport, mb[1], mb[2],
 549                                     mb[3]));
 550
 551                                 rscn_fcport->loop_id = mb[1];
 552                                 rscn_fcport->d_id.b24 = INVALID_PORT_ID;
 553                                 atomic_set(&rscn_fcport->state,
 554                                     FCS_DEVICE_LOST);
 555                                 list_add_tail(&rscn_fcport->list,
 556                                     &ha->rscn_fcports);
 557
 558                                 rval = qla2x00_handle_port_rscn(ha, 0,
 559                                     rscn_fcport, 1);
 560                                 if (rval == QLA_SUCCESS)
 561                                         break;
 562                         } else {
 563                                 DEBUG14(printk("scsi(%ld): Port Update -- "
 564                                     "-- unable to allocate RSCN fcport "
 565                                     "login.\n", ha->host_no));
 566                         }
 567                 }
 568
 569                 /*
 570                  * If PORT UPDATE is global (recieved LIP_OCCURED/LIP_RESET
 571                  * event etc. earlier indicating loop is down) then process
 572                  * it.  Otherwise ignore it and Wait for RSCN to come in.
 573                  */
 574                 atomic_set(&ha->loop_down_timer, 0);
 575                 if (atomic_read(&ha->loop_state) != LOOP_DOWN &&
 576                     atomic_read(&ha->loop_state) != LOOP_DEAD) {
 577                         DEBUG2(printk("scsi(%ld): Asynchronous PORT UPDATE "
 578                             "ignored %04x/%04x/%04x.\n", ha->host_no, mb[1],
 579                             mb[2], mb[3]));
 580                         break;
 581                 }
 582
 583                 DEBUG2(printk("scsi(%ld): Asynchronous PORT UPDATE.\n",
 584                     ha->host_no));
 585                 DEBUG(printk(KERN_INFO
 586                     "scsi(%ld): Port database changed %04x %04x %04x.\n",
 587                     ha->host_no, mb[1], mb[2], mb[3]));
 588
 589                 /*
 590                  * Mark all devices as missing so we will login again.
 591                  */
 592                 atomic_set(&ha->loop_state, LOOP_UP);
 593
 594                 qla2x00_mark_all_devices_lost(ha);
 595
 596                 ha->flags.rscn_queue_overflow = 1;
 597
 598                 set_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags);
 599                 set_bit(LOCAL_LOOP_UPDATE, &ha->dpc_flags);
 600
 601                 /* Update AEN queue. */
 602                 qla2x00_enqueue_aen(ha, MBA_PORT_UPDATE, NULL);
 603                 break;
 604
 605         case MBA_RSCN_UPDATE:           /* State Change Registration */
 606                 DEBUG2(printk("scsi(%ld): Asynchronous RSCR UPDATE.\n",
 607                     ha->host_no));
 608                 DEBUG(printk(KERN_INFO
 609                     "scsi(%ld): RSCN database changed -- %04x %04x.\n",
 610                     ha->host_no, mb[1], mb[2]));
 611
 612                 rscn_entry = (mb[1] << 16) | mb[2];
 613                 host_pid = (ha->d_id.b.domain << 16) | (ha->d_id.b.area << 8) |
 614                     ha->d_id.b.al_pa;
 615                 if (rscn_entry == host_pid) {
 616                         DEBUG(printk(KERN_INFO
 617                             "scsi(%ld): Ignoring RSCN update to local host "
 618                             "port ID (%06x)\n",
 619                             ha->host_no, host_pid));
 620                         break;
 621                 }
 622
 623                 rscn_queue_index = ha->rscn_in_ptr + 1;
 624                 if (rscn_queue_index == MAX_RSCN_COUNT)
 625                         rscn_queue_index = 0;
 626                 if (rscn_queue_index != ha->rscn_out_ptr) {
 627                         ha->rscn_queue[ha->rscn_in_ptr] = rscn_entry;
 628                         ha->rscn_in_ptr = rscn_queue_index;
 629                 } else {
 630                         ha->flags.rscn_queue_overflow = 1;
 631                 }
 632
 633                 atomic_set(&ha->loop_state, LOOP_UPDATE);
 634                 atomic_set(&ha->loop_down_timer, 0);
 635                 ha->flags.management_server_logged_in = 0;
 636
 637                 set_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags);
 638                 set_bit(RSCN_UPDATE, &ha->dpc_flags);
 639
 640                 /* Update AEN queue. */
 641                 qla2x00_enqueue_aen(ha, MBA_RSCN_UPDATE, &mb[0]);
 642                 break;
 643
 644         /* case MBA_RIO_RESPONSE: */
 645         case MBA_ZIO_RESPONSE:
 646                 DEBUG2(printk("scsi(%ld): [R|Z]IO update completion.\n",
 647                     ha->host_no));
 648                 DEBUG(printk(KERN_INFO
 649                     "scsi(%ld): [R|Z]IO update completion.\n",
 650                     ha->host_no));
 651
 652                 qla2x00_process_response_queue(ha);
 653                 break;
 654
 655         case MBA_DISCARD_RND_FRAME:
 656                 DEBUG2(printk("scsi(%ld): Discard RND Frame -- %04x %04x "
 657                     "%04x.\n", ha->host_no, mb[1], mb[2], mb[3]));
 658                 break;
 659         }
 660 }
 661
 662 /**
 663  * qla2x00_process_completed_request() - Process a Fast Post response.
 664  * @ha: SCSI driver HA context
 665  * @index: SRB index
 666  */
 667 static void
 668 qla2x00_process_completed_request(struct scsi_qla_host *ha, uint32_t index)
 669 {
 670         srb_t *sp;
 671
 672         /* Validate handle. */
 673         if (index >= MAX_OUTSTANDING_COMMANDS) {
 674                 DEBUG2(printk("scsi(%ld): Invalid SCSI completion handle %d.\n",
 675                     ha->host_no, index));
 676                 qla_printk(KERN_WARNING, ha,
 677                     "Invalid SCSI completion handle %d.\n", index);
 678
 679                 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
 680                 return;
 681         }
 682
 683         sp = ha->outstanding_cmds[index];
 684         if (sp) {
 685                 /* Free outstanding command slot. */
 686                 ha->outstanding_cmds[index] = NULL;
 687
 688                 CMD_COMPL_STATUS(sp->cmd) = 0L;
 689                 CMD_SCSI_STATUS(sp->cmd) = 0L;
 690
 691                 /* Save ISP completion status */
 692                 sp->cmd->result = DID_OK << 16;
 693                 qla2x00_sp_compl(ha, sp);
 694         } else {
 695                 DEBUG2(printk("scsi(%ld): Invalid ISP SCSI completion handle\n",
 696                     ha->host_no));
 697                 qla_printk(KERN_WARNING, ha,
 698                     "Invalid ISP SCSI completion handle\n");
 699
 700                 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
 701         }
 702 }
 703
 704 /**
 705  * qla2x00_process_response_queue() - Process response queue entries.
 706  * @ha: SCSI driver HA context
 707  */
 708 void
 709 qla2x00_process_response_queue(struct scsi_qla_host *ha)
 710 {
 711         struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
 712         sts_entry_t     *pkt;
 713         uint16_t        handle_cnt;
 714         uint16_t        cnt;
 715
 716         if (!ha->flags.online)
 717                 return;
 718
 719         while (ha->response_ring_ptr->signature != RESPONSE_PROCESSED) {
 720                 pkt = (sts_entry_t *)ha->response_ring_ptr;
 721
 722                 ha->rsp_ring_index++;
 723                 if (ha->rsp_ring_index == ha->response_q_length) {
 724                         ha->rsp_ring_index = 0;
 725                         ha->response_ring_ptr = ha->response_ring;
 726                 } else {
 727                         ha->response_ring_ptr++;
 728                 }
 729
 730                 if (pkt->entry_status != 0) {
 731                         DEBUG3(printk(KERN_INFO
 732                             "scsi(%ld): Process error entry.\n", ha->host_no));
 733
 734                         qla2x00_error_entry(ha, pkt);
 735                         ((response_t *)pkt)->signature = RESPONSE_PROCESSED;
 736                         wmb();
 737                         continue;
 738                 }
 739
 740                 switch (pkt->entry_type) {
 741                 case STATUS_TYPE:
 742                         qla2x00_status_entry(ha, pkt);
 743                         break;
 744                 case STATUS_TYPE_21:
 745                         handle_cnt = ((sts21_entry_t *)pkt)->handle_count;
 746                         for (cnt = 0; cnt < handle_cnt; cnt++) {
 747                                 qla2x00_process_completed_request(ha,
 748                                     ((sts21_entry_t *)pkt)->handle[cnt]);
 749                         }
 750                         break;
 751                 case STATUS_TYPE_22:
 752                         handle_cnt = ((sts22_entry_t *)pkt)->handle_count;
 753                         for (cnt = 0; cnt < handle_cnt; cnt++) {
 754                                 qla2x00_process_completed_request(ha,
 755                                     ((sts22_entry_t *)pkt)->handle[cnt]);
 756                         }
 757                         break;
 758                 case STATUS_CONT_TYPE:
 759                         qla2x00_status_cont_entry(ha, (sts_cont_entry_t *)pkt);
 760                         break;
 761                 case MS_IOCB_TYPE:
 762                         qla2x00_ms_entry(ha, (ms_iocb_entry_t *)pkt);
 763                         break;
 764                 case MBX_IOCB_TYPE:
 765                         if (!IS_QLA2100(ha) && !IS_QLA2200(ha) &&
 766                             !IS_QLA6312(ha) && !IS_QLA6322(ha)) {
 767                                 if (pkt->sys_define == SOURCE_ASYNC_IOCB) {
 768                                         qla2x00_process_iodesc(ha,
 769                                             (struct mbx_entry *)pkt);
 770                                 } else {
 771                                         /* MBX IOCB Type Not Supported. */
 772                                         DEBUG4(printk(KERN_WARNING
 773                                             "scsi(%ld): Received unknown MBX "
 774                                             "IOCB response pkt type=%x "
 775                                             "source=%x entry status=%x.\n",
 776                                             ha->host_no, pkt->entry_type,
 777                                             pkt->sys_define,
 778                                             pkt->entry_status));
 779                                 }
 780                                 break;
 781                         }
 782                         /* Fallthrough. */
 783                 default:
 784                         /* Type Not Supported. */
 785                         DEBUG4(printk(KERN_WARNING
 786                             "scsi(%ld): Received unknown response pkt type %x "
 787                             "entry status=%x.\n",
 788                             ha->host_no, pkt->entry_type, pkt->entry_status));
 789                         break;
 790                 }
 791                 ((response_t *)pkt)->signature = RESPONSE_PROCESSED;
 792                 wmb();
 793         }
 794
 795         /* Adjust ring index */
 796         WRT_REG_WORD(ISP_RSP_Q_OUT(ha, reg), ha->rsp_ring_index);
 797 }
 798
 799 /**
 800  * qla2x00_status_entry() - Process a Status IOCB entry.
 801  * @ha: SCSI driver HA context
 802  * @pkt: Entry pointer
 803  */
 804 static void
 805 qla2x00_status_entry(scsi_qla_host_t *ha, void *pkt)
 806 {
 807         srb_t           *sp;
 808         fc_port_t       *fcport;
 809         struct scsi_cmnd *cp;
 810         sts_entry_t *sts;
 811         struct sts_entry_24xx *sts24;
 812         uint16_t        comp_status;
 813         uint16_t        scsi_status;
 814         uint8_t         lscsi_status;
 815         int32_t         resid;
 816         uint32_t        sense_len, rsp_info_len, resid_len;
 817         uint8_t         *rsp_info, *sense_data;
 818
 819         sts = (sts_entry_t *) pkt;
 820         sts24 = (struct sts_entry_24xx *) pkt;
 821         if (IS_QLA24XX(ha) || IS_QLA25XX(ha)) {
 822                 comp_status = le16_to_cpu(sts24->comp_status);
 823                 scsi_status = le16_to_cpu(sts24->scsi_status) & SS_MASK;
 824         } else {
 825                 comp_status = le16_to_cpu(sts->comp_status);
 826                 scsi_status = le16_to_cpu(sts->scsi_status) & SS_MASK;
 827         }
 828
 829         /* Fast path completion. */
 830         if (comp_status == CS_COMPLETE && scsi_status == 0) {
 831                 qla2x00_process_completed_request(ha, sts->handle);
 832
 833                 return;
 834         }
 835
 836         /* Validate handle. */
 837         if (sts->handle < MAX_OUTSTANDING_COMMANDS) {
 838                 sp = ha->outstanding_cmds[sts->handle];
 839                 ha->outstanding_cmds[sts->handle] = NULL;
 840         } else
 841                 sp = NULL;
 842
 843         if (sp == NULL) {
 844                 DEBUG2(printk("scsi(%ld): Status Entry invalid handle.\n",
 845                     ha->host_no));
 846                 qla_printk(KERN_WARNING, ha, "Status Entry invalid handle.\n");
 847
 848                 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
 849                 if (ha->dpc_wait && !ha->dpc_active)
 850                         up(ha->dpc_wait);
 851
 852                 return;
 853         }
 854         cp = sp->cmd;
 855         if (cp == NULL) {
 856                 DEBUG2(printk("scsi(%ld): Command already returned back to OS "
 857                     "pkt->handle=%d sp=%p sp->state:%d\n",
 858                     ha->host_no, sts->handle, sp, sp->state));
 859                 qla_printk(KERN_WARNING, ha,
 860                     "Command is NULL: already returned to OS (sp=%p)\n", sp);
 861
 862                 return;
 863         }
 864
 865         lscsi_status = scsi_status & STATUS_MASK;
 866         CMD_ENTRY_STATUS(cp) = sts->entry_status;
 867         CMD_COMPL_STATUS(cp) = comp_status;
 868         CMD_SCSI_STATUS(cp) = scsi_status;
 869
 870         fcport = sp->fcport;
 871
 872         sense_len = rsp_info_len = resid_len = 0;
 873         if (IS_QLA24XX(ha) || IS_QLA25XX(ha)) {
 874                 sense_len = le32_to_cpu(sts24->sense_len);
 875                 rsp_info_len = le32_to_cpu(sts24->rsp_data_len);
 876                 resid_len = le32_to_cpu(sts24->rsp_residual_count);
 877                 rsp_info = sts24->data;
 878                 sense_data = sts24->data;
 879                 host_to_fcp_swap(sts24->data, sizeof(sts24->data));
 880         } else {
 881                 sense_len = le16_to_cpu(sts->req_sense_length);
 882                 rsp_info_len = le16_to_cpu(sts->rsp_info_len);
 883                 resid_len = le32_to_cpu(sts->residual_length);
 884                 rsp_info = sts->rsp_info;
 885                 sense_data = sts->req_sense_data;
 886         }
 887
 888         /* Check for any FCP transport errors. */
 889         if (scsi_status & SS_RESPONSE_INFO_LEN_VALID) {
 890                 /* Sense data lies beyond any FCP RESPONSE data. */
 891                 if (IS_QLA24XX(ha) || IS_QLA25XX(ha))
 892                         sense_data += rsp_info_len;
 893                 if (rsp_info_len > 3 && rsp_info[3]) {
 894                         DEBUG2(printk("scsi(%ld:%d:%d:%d) FCP I/O protocol "
 895                             "failure (%x/%02x%02x%02x%02x%02x%02x%02x%02x)..."
 896                             "retrying command\n", ha->host_no,
 897                             cp->device->channel, cp->device->id,
 898                             cp->device->lun, rsp_info_len, rsp_info[0],
 899                             rsp_info[1], rsp_info[2], rsp_info[3], rsp_info[4],
 900                             rsp_info[5], rsp_info[6], rsp_info[7]));
 901
 902                         cp->result = DID_BUS_BUSY << 16;
 903                         qla2x00_sp_compl(ha, sp);
 904                         return;
 905                 }
 906         }
 907
 908         /*
 909          * Based on Host and scsi status generate status code for Linux
 910          */
 911         switch (comp_status) {
 912         case CS_COMPLETE:
 913                 if (scsi_status == 0) {
 914                         cp->result = DID_OK << 16;
 915                         break;
 916                 }
 917                 if (scsi_status & (SS_RESIDUAL_UNDER | SS_RESIDUAL_OVER)) {
 918                         resid = resid_len;
 919                         cp->resid = resid;
 920                         CMD_RESID_LEN(cp) = resid;
 921                 }
 922                 cp->result = DID_OK << 16 | lscsi_status;
 923
 924                 if (lscsi_status != SS_CHECK_CONDITION)
 925                         break;
 926
 927                 /* Copy Sense Data into sense buffer. */
 928                 memset(cp->sense_buffer, 0, sizeof(cp->sense_buffer));
 929
 930                 if (!(scsi_status & SS_SENSE_LEN_VALID))
 931                         break;
 932
 933                 if (sense_len >= sizeof(cp->sense_buffer))
 934                         sense_len = sizeof(cp->sense_buffer);
 935
 936                 CMD_ACTUAL_SNSLEN(cp) = sense_len;
 937                 sp->request_sense_length = sense_len;
 938                 sp->request_sense_ptr = cp->sense_buffer;
 939
 940                 if (sp->request_sense_length > 32)
 941                         sense_len = 32;
 942
 943                 memcpy(cp->sense_buffer, sense_data, sense_len);
 944
 945                 sp->request_sense_ptr += sense_len;
 946                 sp->request_sense_length -= sense_len;
 947                 if (sp->request_sense_length != 0)
 948                         ha->status_srb = sp;
 949
 950                 DEBUG5(printk("%s(): Check condition Sense data, "
 951                     "scsi(%ld:%d:%d:%d) cmd=%p pid=%ld\n", __func__,
 952                     ha->host_no, cp->device->channel, cp->device->id,
 953                     cp->device->lun, cp, cp->serial_number));
 954                 if (sense_len)
 955                         DEBUG5(qla2x00_dump_buffer(cp->sense_buffer,
 956                             CMD_ACTUAL_SNSLEN(cp)));
 957                 break;
 958
 959         case CS_DATA_UNDERRUN:
 960                 DEBUG2(printk(KERN_INFO
 961                     "scsi(%ld:%d:%d) UNDERRUN status detected 0x%x-0x%x.\n",
 962                     ha->host_no, cp->device->id, cp->device->lun, comp_status,
 963                     scsi_status));
 964
 965                 resid = resid_len;
 966                 if (scsi_status & SS_RESIDUAL_UNDER) {
 967                         cp->resid = resid;
 968                         CMD_RESID_LEN(cp) = resid;
 969                 }
 970
 971                 /*
 972                  * Check to see if SCSI Status is non zero. If so report SCSI
 973                  * Status.
 974                  */
 975                 if (lscsi_status != 0) {
 976                         cp->result = DID_OK << 16 | lscsi_status;
 977
 978                         if (lscsi_status != SS_CHECK_CONDITION)
 979                                 break;
 980
 981                         /* Copy Sense Data into sense buffer */
 982                         memset(cp->sense_buffer, 0, sizeof(cp->sense_buffer));
 983
 984                         if (!(scsi_status & SS_SENSE_LEN_VALID))
 985                                 break;
 986
 987                         if (sense_len >= sizeof(cp->sense_buffer))
 988                                 sense_len = sizeof(cp->sense_buffer);
 989
 990                         CMD_ACTUAL_SNSLEN(cp) = sense_len;
 991                         sp->request_sense_length = sense_len;
 992                         sp->request_sense_ptr = cp->sense_buffer;
 993
 994                         if (sp->request_sense_length > 32)
 995                                 sense_len = 32;
 996
 997                         memcpy(cp->sense_buffer, sense_data, sense_len);
 998
 999                         sp->request_sense_ptr += sense_len;
1000                         sp->request_sense_length -= sense_len;
1001                         if (sp->request_sense_length != 0)
1002                                 ha->status_srb = sp;
1003
1004                         DEBUG5(printk("%s(): Check condition Sense data, "
1005                             "scsi(%ld:%d:%d:%d) cmd=%p pid=%ld\n",
1006                             __func__, ha->host_no, cp->device->channel,
1007                             cp->device->id, cp->device->lun, cp,
1008                             cp->serial_number));
1009
1010                         if (sense_len)
1011                                 DEBUG5(qla2x00_dump_buffer(cp->sense_buffer,
1012                                     CMD_ACTUAL_SNSLEN(cp)));
1013                 } else {
1014                         /*
1015                          * If RISC reports underrun and target does not report
1016                          * it then we must have a lost frame, so tell upper
1017                          * layer to retry it by reporting a bus busy.
1018                          */
1019                         if (!(scsi_status & SS_RESIDUAL_UNDER)) {
1020                                 DEBUG2(printk("scsi(%ld:%d:%d:%d) Dropped "
1021                                     "frame(s) detected (%x of %x bytes)..."
1022                                     "retrying command.\n", ha->host_no,
1023                                     cp->device->channel, cp->device->id,
1024                                     cp->device->lun, resid,
1025                                     cp->request_bufflen));
1026
1027                                 cp->result = DID_BUS_BUSY << 16;
1028                                 break;
1029                         }
1030
1031                         /* Handle mid-layer underflow */
1032                         if ((unsigned)(cp->request_bufflen - resid) <
1033                             cp->underflow) {
1034                                 qla_printk(KERN_INFO, ha,
1035                                     "scsi(%ld:%d:%d:%d): Mid-layer underflow "
1036                                     "detected (%x of %x bytes)...returning "
1037                                     "error status.\n", ha->host_no,
1038                                     cp->device->channel, cp->device->id,
1039                                     cp->device->lun, resid,
1040                                     cp->request_bufflen);
1041
1042                                 cp->result = DID_ERROR << 16;
1043                                 break;
1044                         }
1045
1046                         /* Everybody online, looking good... */
1047                         cp->result = DID_OK << 16;
1048                 }
1049                 break;
1050
1051         case CS_DATA_OVERRUN:
1052                 DEBUG2(printk(KERN_INFO
1053                     "scsi(%ld:%d:%d): OVERRUN status detected 0x%x-0x%x\n",
1054                     ha->host_no, cp->device->id, cp->device->lun, comp_status,
1055                     scsi_status));
1056                 DEBUG2(printk(KERN_INFO
1057                     "CDB: 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x\n",
1058                     cp->cmnd[0], cp->cmnd[1], cp->cmnd[2], cp->cmnd[3],
1059                     cp->cmnd[4], cp->cmnd[5]));
1060                 DEBUG2(printk(KERN_INFO
1061                     "PID=0x%lx req=0x%x xtra=0x%x -- returning DID_ERROR "
1062                     "status!\n",
1063                     cp->serial_number, cp->request_bufflen, resid_len));
1064
1065                 cp->result = DID_ERROR << 16;
1066                 break;
1067
1068         case CS_PORT_LOGGED_OUT:
1069         case CS_PORT_CONFIG_CHG:
1070         case CS_PORT_BUSY:
1071         case CS_INCOMPLETE:
1072         case CS_PORT_UNAVAILABLE:
1073                 /*
1074                  * If the port is in Target Down state, return all IOs for this
1075                  * Target with DID_NO_CONNECT ELSE Queue the IOs in the
1076                  * retry_queue.
1077                  */
1078                 DEBUG2(printk("scsi(%ld:%d:%d): status_entry: Port Down "
1079                     "pid=%ld, compl status=0x%x, port state=0x%x\n",
1080                     ha->host_no, cp->device->id, cp->device->lun,
1081                     cp->serial_number, comp_status,
1082                     atomic_read(&fcport->state)));
1083
1084                 cp->result = DID_BUS_BUSY << 16;
1085                 if (atomic_read(&fcport->state) == FCS_ONLINE) {
1086                         qla2x00_mark_device_lost(ha, fcport, 1);
1087                 }
1088                 break;
1089
1090         case CS_RESET:
1091                 DEBUG2(printk(KERN_INFO
1092                     "scsi(%ld): RESET status detected 0x%x-0x%x.\n",
1093                     ha->host_no, comp_status, scsi_status));
1094
1095                 cp->result = DID_RESET << 16;
1096                 break;
1097
1098         case CS_ABORTED:
1099                 /*
1100                  * hv2.19.12 - DID_ABORT does not retry the request if we
1101                  * aborted this request then abort otherwise it must be a
1102                  * reset.
1103                  */
1104                 DEBUG2(printk(KERN_INFO
1105                     "scsi(%ld): ABORT status detected 0x%x-0x%x.\n",
1106                     ha->host_no, comp_status, scsi_status));
1107
1108                 cp->result = DID_RESET << 16;
1109                 break;
1110
1111         case CS_TIMEOUT:
1112                 cp->result = DID_BUS_BUSY << 16;
1113
1114                 if (IS_QLA24XX(ha) || IS_QLA25XX(ha)) {
1115                         DEBUG2(printk(KERN_INFO
1116                             "scsi(%ld:%d:%d:%d): TIMEOUT status detected "
1117                             "0x%x-0x%x\n", ha->host_no, cp->device->channel,
1118                             cp->device->id, cp->device->lun, comp_status,
1119                             scsi_status));
1120                         break;
1121                 }
1122                 DEBUG2(printk(KERN_INFO
1123                     "scsi(%ld:%d:%d:%d): TIMEOUT status detected 0x%x-0x%x "
1124                     "sflags=%x.\n", ha->host_no, cp->device->channel,
1125                     cp->device->id, cp->device->lun, comp_status, scsi_status,
1126                     le16_to_cpu(sts->status_flags)));
1127
1128                 /* Check to see if logout occurred. */
1129                 if ((le16_to_cpu(sts->status_flags) & SF_LOGOUT_SENT))
1130                         qla2x00_mark_device_lost(ha, fcport, 1);
1131                 break;
1132
1133         case CS_QUEUE_FULL:
1134                 DEBUG2(printk(KERN_INFO
1135                     "scsi(%ld): QUEUE FULL status detected 0x%x-0x%x.\n",
1136                     ha->host_no, comp_status, scsi_status));
1137
1138                 /* SCSI Mid-Layer handles device queue full */
1139
1140                 cp->result = DID_OK << 16 | lscsi_status;
1141
1142                 break;
1143
1144         default:
1145                 DEBUG3(printk("scsi(%ld): Error detected (unknown status) "
1146                     "0x%x-0x%x.\n", ha->host_no, comp_status, scsi_status));
1147                 qla_printk(KERN_INFO, ha,
1148                     "Unknown status detected 0x%x-0x%x.\n",
1149                     comp_status, scsi_status);
1150
1151                 cp->result = DID_ERROR << 16;
1152                 break;
1153         }
1154
1155         /* Place command on done queue. */
1156         if (ha->status_srb == NULL)
1157                 qla2x00_sp_compl(ha, sp);
1158 }
1159
1160 /**
1161  * qla2x00_status_cont_entry() - Process a Status Continuations entry.
1162  * @ha: SCSI driver HA context
1163  * @pkt: Entry pointer
1164  *
1165  * Extended sense data.
1166  */
1167 static void
1168 qla2x00_status_cont_entry(scsi_qla_host_t *ha, sts_cont_entry_t *pkt)
1169 {
1170         uint8_t         sense_sz = 0;
1171         srb_t           *sp = ha->status_srb;
1172         struct scsi_cmnd *cp;
1173
1174         if (sp != NULL && sp->request_sense_length != 0) {
1175                 cp = sp->cmd;
1176                 if (cp == NULL) {
1177                         DEBUG2(printk("%s(): Cmd already returned back to OS "
1178                             "sp=%p sp->state:%d\n", __func__, sp, sp->state));
1179                         qla_printk(KERN_INFO, ha,
1180                             "cmd is NULL: already returned to OS (sp=%p)\n",
1181                             sp);
1182
1183                         ha->status_srb = NULL;
1184                         return;
1185                 }
1186
1187                 if (sp->request_sense_length > sizeof(pkt->data)) {
1188                         sense_sz = sizeof(pkt->data);
1189                 } else {
1190                         sense_sz = sp->request_sense_length;
1191                 }
1192
1193                 /* Move sense data. */
1194                 if (IS_QLA24XX(ha) || IS_QLA25XX(ha))
1195                         host_to_fcp_swap(pkt->data, sizeof(pkt->data));
1196                 memcpy(sp->request_sense_ptr, pkt->data, sense_sz);
1197                 DEBUG5(qla2x00_dump_buffer(sp->request_sense_ptr, sense_sz));
1198
1199                 sp->request_sense_ptr += sense_sz;
1200                 sp->request_sense_length -= sense_sz;
1201
1202                 /* Place command on done queue. */
1203                 if (sp->request_sense_length == 0) {
1204                         ha->status_srb = NULL;
1205                         qla2x00_sp_compl(ha, sp);
1206                 }
1207         }
1208 }
1209
1210 /**
1211  * qla2x00_error_entry() - Process an error entry.
1212  * @ha: SCSI driver HA context
1213  * @pkt: Entry pointer
1214  */
1215 static void
1216 qla2x00_error_entry(scsi_qla_host_t *ha, sts_entry_t *pkt)
1217 {
1218         srb_t *sp;
1219
1220 #if defined(QL_DEBUG_LEVEL_2)
1221         if (pkt->entry_status & RF_INV_E_ORDER)
1222                 qla_printk(KERN_ERR, ha, "%s: Invalid Entry Order\n", __func__);
1223         else if (pkt->entry_status & RF_INV_E_COUNT)
1224                 qla_printk(KERN_ERR, ha, "%s: Invalid Entry Count\n", __func__);
1225         else if (pkt->entry_status & RF_INV_E_PARAM)
1226                 qla_printk(KERN_ERR, ha,
1227                     "%s: Invalid Entry Parameter\n", __func__);
1228         else if (pkt->entry_status & RF_INV_E_TYPE)
1229                 qla_printk(KERN_ERR, ha, "%s: Invalid Entry Type\n", __func__);
1230         else if (pkt->entry_status & RF_BUSY)
1231                 qla_printk(KERN_ERR, ha, "%s: Busy\n", __func__);
1232         else
1233                 qla_printk(KERN_ERR, ha, "%s: UNKNOWN flag error\n", __func__);
1234 #endif
1235
1236         /* Validate handle. */
1237         if (pkt->handle < MAX_OUTSTANDING_COMMANDS)
1238                 sp = ha->outstanding_cmds[pkt->handle];
1239         else
1240                 sp = NULL;
1241
1242         if (sp) {
1243                 /* Free outstanding command slot. */
1244                 ha->outstanding_cmds[pkt->handle] = NULL;
1245
1246                 /* Bad payload or header */
1247                 if (pkt->entry_status &
1248                     (RF_INV_E_ORDER | RF_INV_E_COUNT |
1249                      RF_INV_E_PARAM | RF_INV_E_TYPE)) {
1250                         sp->cmd->result = DID_ERROR << 16;
1251                 } else if (pkt->entry_status & RF_BUSY) {
1252                         sp->cmd->result = DID_BUS_BUSY << 16;
1253                 } else {
1254                         sp->cmd->result = DID_ERROR << 16;
1255                 }
1256                 qla2x00_sp_compl(ha, sp);
1257
1258         } else if (pkt->entry_type == COMMAND_A64_TYPE || pkt->entry_type ==
1259             COMMAND_TYPE || pkt->entry_type == COMMAND_TYPE_7) {
1260                 DEBUG2(printk("scsi(%ld): Error entry - invalid handle\n",
1261                     ha->host_no));
1262                 qla_printk(KERN_WARNING, ha,
1263                     "Error entry - invalid handle\n");
1264
1265                 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
1266                 if (ha->dpc_wait && !ha->dpc_active)
1267                         up(ha->dpc_wait);
1268         }
1269 }
1270
1271 /**
1272  * qla2x00_ms_entry() - Process a Management Server entry.
1273  * @ha: SCSI driver HA context
1274  * @index: Response queue out pointer
1275  */
1276 static void
1277 qla2x00_ms_entry(scsi_qla_host_t *ha, ms_iocb_entry_t *pkt)
1278 {
1279         srb_t          *sp;
1280
1281         DEBUG3(printk("%s(%ld): pkt=%p pkthandle=%d.\n",
1282             __func__, ha->host_no, pkt, pkt->handle1));
1283
1284         /* Validate handle. */
1285         if (pkt->handle1 < MAX_OUTSTANDING_COMMANDS)
1286                 sp = ha->outstanding_cmds[pkt->handle1];
1287         else
1288                 sp = NULL;
1289
1290         if (sp == NULL) {
1291                 DEBUG2(printk("scsi(%ld): MS entry - invalid handle\n",
1292                     ha->host_no));
1293                 qla_printk(KERN_WARNING, ha, "MS entry - invalid handle\n");
1294
1295                 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
1296                 return;
1297         }
1298
1299         CMD_COMPL_STATUS(sp->cmd) = le16_to_cpu(pkt->status);
1300         CMD_ENTRY_STATUS(sp->cmd) = pkt->entry_status;
1301
1302         /* Free outstanding command slot. */
1303         ha->outstanding_cmds[pkt->handle1] = NULL;
1304
1305         qla2x00_sp_compl(ha, sp);
1306 }
1307
1308
1309 /**
1310  * qla24xx_mbx_completion() - Process mailbox command completions.
1311  * @ha: SCSI driver HA context
1312  * @mb0: Mailbox0 register
1313  */
1314 static void
1315 qla24xx_mbx_completion(scsi_qla_host_t *ha, uint16_t mb0)
1316 {
1317         uint16_t        cnt;
1318         uint16_t __iomem *wptr;
1319         struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
1320
1321         /* Load return mailbox registers. */
1322         ha->flags.mbox_int = 1;
1323         ha->mailbox_out[0] = mb0;
1324         wptr = (uint16_t __iomem *)&reg->mailbox1;
1325
1326         for (cnt = 1; cnt < ha->mbx_count; cnt++) {
1327                 ha->mailbox_out[cnt] = RD_REG_WORD(wptr);
1328                 wptr++;
1329         }
1330
1331         if (ha->mcp) {
1332                 DEBUG3(printk("%s(%ld): Got mailbox completion. cmd=%x.\n",
1333                     __func__, ha->host_no, ha->mcp->mb[0]));
1334         } else {
1335                 DEBUG2_3(printk("%s(%ld): MBX pointer ERROR!\n",
1336                     __func__, ha->host_no));
1337         }
1338 }
1339
1340 /**
1341  * qla24xx_process_response_queue() - Process response queue entries.
1342  * @ha: SCSI driver HA context
1343  */
1344 void
1345 qla24xx_process_response_queue(struct scsi_qla_host *ha)
1346 {
1347         struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
1348         struct sts_entry_24xx *pkt;
1349
1350         if (!ha->flags.online)
1351                 return;
1352
1353         while (ha->response_ring_ptr->signature != RESPONSE_PROCESSED) {
1354                 pkt = (struct sts_entry_24xx *)ha->response_ring_ptr;
1355
1356                 ha->rsp_ring_index++;
1357                 if (ha->rsp_ring_index == ha->response_q_length) {
1358                         ha->rsp_ring_index = 0;
1359                         ha->response_ring_ptr = ha->response_ring;
1360                 } else {
1361                         ha->response_ring_ptr++;
1362                 }
1363
1364                 if (pkt->entry_status != 0) {
1365                         DEBUG3(printk(KERN_INFO
1366                             "scsi(%ld): Process error entry.\n", ha->host_no));
1367
1368                         qla2x00_error_entry(ha, (sts_entry_t *) pkt);
1369                         ((response_t *)pkt)->signature = RESPONSE_PROCESSED;
1370                         wmb();
1371                         continue;
1372                 }
1373
1374                 switch (pkt->entry_type) {
1375                 case STATUS_TYPE:
1376                         qla2x00_status_entry(ha, pkt);
1377                         break;
1378                 case STATUS_CONT_TYPE:
1379                         qla2x00_status_cont_entry(ha, (sts_cont_entry_t *)pkt);
1380                         break;
1381                 case MS_IOCB_TYPE:
1382                         qla24xx_ms_entry(ha, (struct ct_entry_24xx *)pkt);
1383                         break;
1384                 default:
1385                         /* Type Not Supported. */
1386                         DEBUG4(printk(KERN_WARNING
1387                             "scsi(%ld): Received unknown response pkt type %x "
1388                             "entry status=%x.\n",
1389                             ha->host_no, pkt->entry_type, pkt->entry_status));
1390                         break;
1391                 }
1392                 ((response_t *)pkt)->signature = RESPONSE_PROCESSED;
1393                 wmb();
1394         }
1395
1396         /* Adjust ring index */
1397         WRT_REG_DWORD(&reg->rsp_q_out, ha->rsp_ring_index);
1398 }
1399
1400 /**
1401  * qla24xx_intr_handler() - Process interrupts for the ISP23xx and ISP63xx.
1402  * @irq:
1403  * @dev_id: SCSI driver HA context
1404  * @regs:
1405  *
1406  * Called by system whenever the host adapter generates an interrupt.
1407  *
1408  * Returns handled flag.
1409  */
1410 irqreturn_t
1411 qla24xx_intr_handler(int irq, void *dev_id, struct pt_regs *regs)
1412 {
1413         scsi_qla_host_t *ha;
1414         struct device_reg_24xx __iomem *reg;
1415         int             status;
1416         unsigned long   flags;
1417         unsigned long   iter;
1418         uint32_t        stat;
1419         uint32_t        hccr;
1420         uint16_t        mb[4];
1421
1422         ha = (scsi_qla_host_t *) dev_id;
1423         if (!ha) {
1424                 printk(KERN_INFO
1425                     "%s(): NULL host pointer\n", __func__);
1426                 return IRQ_NONE;
1427         }
1428
1429         reg = &ha->iobase->isp24;
1430         status = 0;
1431
1432         spin_lock_irqsave(&ha->hardware_lock, flags);
1433         for (iter = 50; iter--; ) {
1434                 stat = RD_REG_DWORD(&reg->host_status);
1435                 if (stat & HSRX_RISC_PAUSED) {
1436                         hccr = RD_REG_DWORD(&reg->hccr);
1437
1438                         qla_printk(KERN_INFO, ha, "RISC paused -- HCCR=%x, "
1439                             "Dumping firmware!\n", hccr);
1440                         qla24xx_fw_dump(ha, 1);
1441
1442                         set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
1443                         break;
1444                 } else if ((stat & HSRX_RISC_INT) == 0)
1445                         break;
1446
1447                 switch (stat & 0xff) {
1448                 case 0x1:
1449                 case 0x2:
1450                 case 0x10:
1451                 case 0x11:
1452                         qla24xx_mbx_completion(ha, MSW(stat));
1453                         status |= MBX_INTERRUPT;
1454
1455                         break;
1456                 case 0x12:
1457                         mb[0] = MSW(stat);
1458                         mb[1] = RD_REG_WORD(&reg->mailbox1);
1459                         mb[2] = RD_REG_WORD(&reg->mailbox2);
1460                         mb[3] = RD_REG_WORD(&reg->mailbox3);
1461                         qla2x00_async_event(ha, mb);
1462                         break;
1463                 case 0x13:
1464                         qla24xx_process_response_queue(ha);
1465                         break;
1466                 default:
1467                         DEBUG2(printk("scsi(%ld): Unrecognized interrupt type "
1468                             "(%d).\n",
1469                             ha->host_no, stat & 0xff));
1470                         break;
1471                 }
1472                 WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
1473                 RD_REG_DWORD_RELAXED(&reg->hccr);
1474         }
1475         spin_unlock_irqrestore(&ha->hardware_lock, flags);
1476
1477         if (test_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags) &&
1478             (status & MBX_INTERRUPT) && ha->flags.mbox_int) {
1479                 spin_lock_irqsave(&ha->mbx_reg_lock, flags);
1480
1481                 set_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
1482                 up(&ha->mbx_intr_sem);
1483
1484                 spin_unlock_irqrestore(&ha->mbx_reg_lock, flags);
1485         }
1486
1487         return IRQ_HANDLED;
1488 }
1489
1490 /**
1491  * qla24xx_ms_entry() - Process a Management Server entry.
1492  * @ha: SCSI driver HA context
1493  * @index: Response queue out pointer
1494  */
1495 static void
1496 qla24xx_ms_entry(scsi_qla_host_t *ha, struct ct_entry_24xx *pkt)
1497 {
1498         srb_t          *sp;
1499
1500         DEBUG3(printk("%s(%ld): pkt=%p pkthandle=%d.\n",
1501             __func__, ha->host_no, pkt, pkt->handle));
1502
1503         DEBUG9(printk("%s: ct pkt dump:\n", __func__);)
1504         DEBUG9(qla2x00_dump_buffer((void *)pkt, sizeof(struct ct_entry_24xx));)
1505
1506         /* Validate handle. */
1507         if (pkt->handle < MAX_OUTSTANDING_COMMANDS)
1508                 sp = ha->outstanding_cmds[pkt->handle];
1509         else
1510                 sp = NULL;
1511
1512         if (sp == NULL) {
1513                 DEBUG2(printk("scsi(%ld): MS entry - invalid handle\n",
1514                     ha->host_no));
1515                 DEBUG10(printk("scsi(%ld): MS entry - invalid handle\n",
1516                     ha->host_no));
1517                 qla_printk(KERN_WARNING, ha, "MS entry - invalid handle %d\n",
1518                     pkt->handle);
1519
1520                 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
1521                 return;
1522         }
1523
1524         CMD_COMPL_STATUS(sp->cmd) = le16_to_cpu(pkt->comp_status);
1525         CMD_ENTRY_STATUS(sp->cmd) = pkt->entry_status;
1526
1527         /* Free outstanding command slot. */
1528         ha->outstanding_cmds[pkt->handle] = NULL;
1529
1530         qla2x00_sp_compl(ha, sp);
1531 }
1532