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