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

   1 /*
   2  * QLogic ISP2x00 SCSI-FCP
   3  * Written by Erik H. Moe, ehm@cris.com
   4  * Copyright 1995, Erik H. Moe
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License as published by the
   8  * Free Software Foundation; either version 2, or (at your option) any
   9  * later version.
  10  *
  11  * This program is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  */
  16
  17 /* Renamed and updated to 1.3.x by Michael Griffith <grif@cs.ucr.edu> */
  18
  19 /* This is a version of the isp1020 driver which was modified by
  20  * Chris Loveland <cwl@iol.unh.edu> to support the isp2100 and isp2200
  21  *
  22  * Big endian support and dynamic DMA mapping added
  23  * by Jakub Jelinek <jakub@redhat.com>.
  24  *
  25  * Conversion to final pci64 DMA interfaces
  26  * by David S. Miller <davem@redhat.com>.
  27  */
  28
  29 /*
  30  * $Date: 1995/09/22 02:23:15 $
  31  * $Revision: 0.5 $
  32  *
  33  * $Log: isp1020.c,v $
  34  * Revision 0.5  1995/09/22  02:23:15  root
  35  * do auto request sense
  36  *
  37  * Revision 0.4  1995/08/07  04:44:33  root
  38  * supply firmware with driver.
  39  * numerous bug fixes/general cleanup of code.
  40  *
  41  * Revision 0.3  1995/07/16  16:15:39  root
  42  * added reset/abort code.
  43  *
  44  * Revision 0.2  1995/06/29  03:14:19  root
  45  * fixed biosparam.
  46  * added queue protocol.
  47  *
  48  * Revision 0.1  1995/06/25  01:55:45  root
  49  * Initial release.
  50  *
  51  */
  52
  53 #include <linux/blkdev.h>
  54 #include <linux/kernel.h>
  55 #include <linux/string.h>
  56 #include <linux/ioport.h>
  57 #include <linux/sched.h>
  58 #include <linux/types.h>
  59 #include <linux/pci.h>
  60 #include <linux/delay.h>
  61 #include <linux/unistd.h>
  62 #include <linux/spinlock.h>
  63 #include <linux/interrupt.h>
  64 #include <linux/jiffies.h>
  65 #include <asm/io.h>
  66 #include <asm/irq.h>
  67 #include "scsi.h"
  68 #include <scsi/scsi_host.h>
  69
  70 #define pci64_dma_hi32(a) ((u32) (0xffffffff & (((u64)(a))>>32)))
  71 #define pci64_dma_lo32(a) ((u32) (0xffffffff & (((u64)(a)))))
  72 #define pci64_dma_build(hi,lo) \
  73         ((dma_addr_t)(((u64)(lo))|(((u64)(hi))<<32)))
  74
  75 /*
  76  * With the qlogic interface, every queue slot can hold a SCSI
  77  * command with up to 2 scatter/gather entries.  If we need more
  78  * than 2 entries, continuation entries can be used that hold
  79  * another 5 entries each.  Unlike for other drivers, this means
  80  * that the maximum number of scatter/gather entries we can
  81  * support at any given time is a function of the number of queue
  82  * slots available.  That is, host->can_queue and host->sg_tablesize
  83  * are dynamic and _not_ independent.  This all works fine because
  84  * requests are queued serially and the scatter/gather limit is
  85  * determined for each queue request anew.
  86  */
  87
  88 #define DATASEGS_PER_COMMAND 2
  89 #define DATASEGS_PER_CONT 5
  90
  91 #define QLOGICFC_REQ_QUEUE_LEN 255     /* must be power of two - 1 */
  92 #define QLOGICFC_MAX_SG(ql)     (DATASEGS_PER_COMMAND + (((ql) > 0) ? DATASEGS_PER_CONT*((ql) - 1) : 0))
  93 #define QLOGICFC_CMD_PER_LUN    8
  94
  95 /* Configuration section **************************************************** */
  96
  97 /* Set the following macro to 1 to reload the ISP2x00's firmware.  This is
  98    version 1.17.30 of the isp2100's firmware and version 2.00.40 of the
  99    isp2200's firmware.
 100 */
 101
 102 #define USE_NVRAM_DEFAULTS      1
 103
 104 #define ISP2x00_PORTDB          1
 105
 106 /* Set the following to 1 to include fabric support, fabric support is
 107  * currently not as well tested as the other aspects of the driver */
 108
 109 #define ISP2x00_FABRIC          1
 110
 111 /*  Macros used for debugging */
 112 #define DEBUG_ISP2x00           0
 113 #define DEBUG_ISP2x00_INT       0
 114 #define DEBUG_ISP2x00_INTR      0
 115 #define DEBUG_ISP2x00_SETUP     0
 116 #define DEBUG_ISP2x00_FABRIC    0
 117 #define TRACE_ISP               0
 118
 119
 120 #define DEFAULT_LOOP_COUNT      1000000000
 121
 122 #define ISP_TIMEOUT (2*HZ)
 123 /* End Configuration section ************************************************ */
 124
 125 #include <linux/module.h>
 126
 127 #if TRACE_ISP
 128
 129 #define TRACE_BUF_LEN   (32*1024)
 130
 131 struct {
 132         u_long next;
 133         struct {
 134                 u_long time;
 135                 u_int index;
 136                 u_int addr;
 137                 u_char *name;
 138         } buf[TRACE_BUF_LEN];
 139 } trace;
 140
 141 #define TRACE(w, i, a)                                          \
 142 {                                                               \
 143         unsigned long flags;                                    \
 144                                                                 \
 145         save_flags(flags);                                      \
 146         cli();                                                  \
 147         trace.buf[trace.next].name  = (w);                      \
 148         trace.buf[trace.next].time  = jiffies;                  \
 149         trace.buf[trace.next].index = (i);                      \
 150         trace.buf[trace.next].addr  = (long) (a);               \
 151         trace.next = (trace.next + 1) & (TRACE_BUF_LEN - 1);    \
 152         restore_flags(flags);                                   \
 153 }
 154
 155 #else
 156 #define TRACE(w, i, a)
 157 #endif
 158
 159 #if DEBUG_ISP2x00_FABRIC
 160 #define DEBUG_FABRIC(x) x
 161 #else
 162 #define DEBUG_FABRIC(x)
 163 #endif                          /* DEBUG_ISP2x00_FABRIC */
 164
 165
 166 #if DEBUG_ISP2x00
 167 #define ENTER(x)        printk("isp2x00 : entering %s()\n", x);
 168 #define LEAVE(x)        printk("isp2x00 : leaving %s()\n", x);
 169 #define DEBUG(x)        x
 170 #else
 171 #define ENTER(x)
 172 #define LEAVE(x)
 173 #define DEBUG(x)
 174 #endif                          /* DEBUG_ISP2x00 */
 175
 176 #if DEBUG_ISP2x00_INTR
 177 #define ENTER_INTR(x)   printk("isp2x00 : entering %s()\n", x);
 178 #define LEAVE_INTR(x)   printk("isp2x00 : leaving %s()\n", x);
 179 #define DEBUG_INTR(x)   x
 180 #else
 181 #define ENTER_INTR(x)
 182 #define LEAVE_INTR(x)
 183 #define DEBUG_INTR(x)
 184 #endif                          /* DEBUG ISP2x00_INTR */
 185
 186
 187 #define ISP2100_REV_ID1        1
 188 #define ISP2100_REV_ID3        3
 189 #define ISP2200_REV_ID5        5
 190
 191 /* host configuration and control registers */
 192 #define HOST_HCCR       0xc0    /* host command and control */
 193
 194 /* pci bus interface registers */
 195 #define FLASH_BIOS_ADDR 0x00
 196 #define FLASH_BIOS_DATA 0x02
 197 #define ISP_CTRL_STATUS 0x06    /* configuration register #1 */
 198 #define PCI_INTER_CTL   0x08    /* pci interrupt control */
 199 #define PCI_INTER_STS   0x0a    /* pci interrupt status */
 200 #define PCI_SEMAPHORE   0x0c    /* pci semaphore */
 201 #define PCI_NVRAM       0x0e    /* pci nvram interface */
 202
 203 /* mailbox registers */
 204 #define MBOX0           0x10    /* mailbox 0 */
 205 #define MBOX1           0x12    /* mailbox 1 */
 206 #define MBOX2           0x14    /* mailbox 2 */
 207 #define MBOX3           0x16    /* mailbox 3 */
 208 #define MBOX4           0x18    /* mailbox 4 */
 209 #define MBOX5           0x1a    /* mailbox 5 */
 210 #define MBOX6           0x1c    /* mailbox 6 */
 211 #define MBOX7           0x1e    /* mailbox 7 */
 212
 213 /* mailbox command complete status codes */
 214 #define MBOX_COMMAND_COMPLETE           0x4000
 215 #define INVALID_COMMAND                 0x4001
 216 #define HOST_INTERFACE_ERROR            0x4002
 217 #define TEST_FAILED                     0x4003
 218 #define COMMAND_ERROR                   0x4005
 219 #define COMMAND_PARAM_ERROR             0x4006
 220 #define PORT_ID_USED                    0x4007
 221 #define LOOP_ID_USED                    0x4008
 222 #define ALL_IDS_USED                    0x4009
 223
 224 /* async event status codes */
 225 #define RESET_DETECTED                  0x8001
 226 #define SYSTEM_ERROR                    0x8002
 227 #define REQUEST_TRANSFER_ERROR          0x8003
 228 #define RESPONSE_TRANSFER_ERROR         0x8004
 229 #define REQUEST_QUEUE_WAKEUP            0x8005
 230 #define LIP_OCCURRED                     0x8010
 231 #define LOOP_UP                         0x8011
 232 #define LOOP_DOWN                       0x8012
 233 #define LIP_RECEIVED                    0x8013
 234 #define PORT_DB_CHANGED                 0x8014
 235 #define CHANGE_NOTIFICATION             0x8015
 236 #define SCSI_COMMAND_COMPLETE           0x8020
 237 #define POINT_TO_POINT_UP               0x8030
 238 #define CONNECTION_MODE                 0x8036
 239
 240 struct Entry_header {
 241         u_char entry_type;
 242         u_char entry_cnt;
 243         u_char sys_def_1;
 244         u_char flags;
 245 };
 246
 247 /* entry header type commands */
 248 #define ENTRY_COMMAND           0x19
 249 #define ENTRY_CONTINUATION      0x0a
 250
 251 #define ENTRY_STATUS            0x03
 252 #define ENTRY_MARKER            0x04
 253
 254
 255 /* entry header flag definitions */
 256 #define EFLAG_BUSY              2
 257 #define EFLAG_BAD_HEADER        4
 258 #define EFLAG_BAD_PAYLOAD       8
 259
 260 struct dataseg {
 261         u_int d_base;
 262         u_int d_base_hi;
 263         u_int d_count;
 264 };
 265
 266 struct Command_Entry {
 267         struct Entry_header hdr;
 268         u_int handle;
 269         u_char target_lun;
 270         u_char target_id;
 271         u_short expanded_lun;
 272         u_short control_flags;
 273         u_short rsvd2;
 274         u_short time_out;
 275         u_short segment_cnt;
 276         u_char cdb[16];
 277         u_int total_byte_cnt;
 278         struct dataseg dataseg[DATASEGS_PER_COMMAND];
 279 };
 280
 281 /* command entry control flag definitions */
 282 #define CFLAG_NODISC            0x01
 283 #define CFLAG_HEAD_TAG          0x02
 284 #define CFLAG_ORDERED_TAG       0x04
 285 #define CFLAG_SIMPLE_TAG        0x08
 286 #define CFLAG_TAR_RTN           0x10
 287 #define CFLAG_READ              0x20
 288 #define CFLAG_WRITE             0x40
 289
 290 struct Continuation_Entry {
 291         struct Entry_header hdr;
 292         struct dataseg dataseg[DATASEGS_PER_CONT];
 293 };
 294
 295 struct Marker_Entry {
 296         struct Entry_header hdr;
 297         u_int reserved;
 298         u_char target_lun;
 299         u_char target_id;
 300         u_char modifier;
 301         u_char expanded_lun;
 302         u_char rsvds[52];
 303 };
 304
 305 /* marker entry modifier definitions */
 306 #define SYNC_DEVICE     0
 307 #define SYNC_TARGET     1
 308 #define SYNC_ALL        2
 309
 310 struct Status_Entry {
 311         struct Entry_header hdr;
 312         u_int handle;
 313         u_short scsi_status;
 314         u_short completion_status;
 315         u_short state_flags;
 316         u_short status_flags;
 317         u_short res_info_len;
 318         u_short req_sense_len;
 319         u_int residual;
 320         u_char res_info[8];
 321         u_char req_sense_data[32];
 322 };
 323
 324 /* status entry completion status definitions */
 325 #define CS_COMPLETE                     0x0000
 326 #define CS_DMA_ERROR                    0x0002
 327 #define CS_RESET_OCCURRED               0x0004
 328 #define CS_ABORTED                      0x0005
 329 #define CS_TIMEOUT                      0x0006
 330 #define CS_DATA_OVERRUN                 0x0007
 331 #define CS_DATA_UNDERRUN                0x0015
 332 #define CS_QUEUE_FULL                   0x001c
 333 #define CS_PORT_UNAVAILABLE             0x0028
 334 #define CS_PORT_LOGGED_OUT              0x0029
 335 #define CS_PORT_CONFIG_CHANGED          0x002a
 336
 337 /* status entry state flag definitions */
 338 #define SF_SENT_CDB                     0x0400
 339 #define SF_TRANSFERRED_DATA             0x0800
 340 #define SF_GOT_STATUS                   0x1000
 341
 342 /* status entry status flag definitions */
 343 #define STF_BUS_RESET                   0x0008
 344 #define STF_DEVICE_RESET                0x0010
 345 #define STF_ABORTED                     0x0020
 346 #define STF_TIMEOUT                     0x0040
 347
 348 /* interrupt control commands */
 349 #define ISP_EN_INT                      0x8000
 350 #define ISP_EN_RISC                     0x0008
 351
 352 /* host control commands */
 353 #define HCCR_NOP                        0x0000
 354 #define HCCR_RESET                      0x1000
 355 #define HCCR_PAUSE                      0x2000
 356 #define HCCR_RELEASE                    0x3000
 357 #define HCCR_SINGLE_STEP                0x4000
 358 #define HCCR_SET_HOST_INTR              0x5000
 359 #define HCCR_CLEAR_HOST_INTR            0x6000
 360 #define HCCR_CLEAR_RISC_INTR            0x7000
 361 #define HCCR_BP_ENABLE                  0x8000
 362 #define HCCR_BIOS_DISABLE               0x9000
 363 #define HCCR_TEST_MODE                  0xf000
 364
 365 #define RISC_BUSY                       0x0004
 366
 367 /* mailbox commands */
 368 #define MBOX_NO_OP                      0x0000
 369 #define MBOX_LOAD_RAM                   0x0001
 370 #define MBOX_EXEC_FIRMWARE              0x0002
 371 #define MBOX_DUMP_RAM                   0x0003
 372 #define MBOX_WRITE_RAM_WORD             0x0004
 373 #define MBOX_READ_RAM_WORD              0x0005
 374 #define MBOX_MAILBOX_REG_TEST           0x0006
 375 #define MBOX_VERIFY_CHECKSUM            0x0007
 376 #define MBOX_ABOUT_FIRMWARE             0x0008
 377 #define MBOX_LOAD_RISC_RAM              0x0009
 378 #define MBOX_DUMP_RISC_RAM              0x000a
 379 #define MBOX_CHECK_FIRMWARE             0x000e
 380 #define MBOX_INIT_REQ_QUEUE             0x0010
 381 #define MBOX_INIT_RES_QUEUE             0x0011
 382 #define MBOX_EXECUTE_IOCB               0x0012
 383 #define MBOX_WAKE_UP                    0x0013
 384 #define MBOX_STOP_FIRMWARE              0x0014
 385 #define MBOX_ABORT_IOCB                 0x0015
 386 #define MBOX_ABORT_DEVICE               0x0016
 387 #define MBOX_ABORT_TARGET               0x0017
 388 #define MBOX_BUS_RESET                  0x0018
 389 #define MBOX_STOP_QUEUE                 0x0019
 390 #define MBOX_START_QUEUE                0x001a
 391 #define MBOX_SINGLE_STEP_QUEUE          0x001b
 392 #define MBOX_ABORT_QUEUE                0x001c
 393 #define MBOX_GET_DEV_QUEUE_STATUS       0x001d
 394 #define MBOX_GET_FIRMWARE_STATUS        0x001f
 395 #define MBOX_GET_INIT_SCSI_ID           0x0020
 396 #define MBOX_GET_RETRY_COUNT            0x0022
 397 #define MBOX_GET_TARGET_PARAMS          0x0028
 398 #define MBOX_GET_DEV_QUEUE_PARAMS       0x0029
 399 #define MBOX_SET_RETRY_COUNT            0x0032
 400 #define MBOX_SET_TARGET_PARAMS          0x0038
 401 #define MBOX_SET_DEV_QUEUE_PARAMS       0x0039
 402 #define MBOX_EXECUTE_IOCB64             0x0054
 403 #define MBOX_INIT_FIRMWARE              0x0060
 404 #define MBOX_GET_INIT_CB                0x0061
 405 #define MBOX_INIT_LIP                   0x0062
 406 #define MBOX_GET_POS_MAP                0x0063
 407 #define MBOX_GET_PORT_DB                0x0064
 408 #define MBOX_CLEAR_ACA                  0x0065
 409 #define MBOX_TARGET_RESET               0x0066
 410 #define MBOX_CLEAR_TASK_SET             0x0067
 411 #define MBOX_ABORT_TASK_SET             0x0068
 412 #define MBOX_GET_FIRMWARE_STATE         0x0069
 413 #define MBOX_GET_PORT_NAME              0x006a
 414 #define MBOX_SEND_SNS                   0x006e
 415 #define MBOX_PORT_LOGIN                 0x006f
 416 #define MBOX_SEND_CHANGE_REQUEST        0x0070
 417 #define MBOX_PORT_LOGOUT                0x0071
 418
 419 /*
 420  *      Firmware if needed (note this is a hack, it belongs in a separate
 421  *      module.
 422  */
 423
 424 #ifdef CONFIG_SCSI_QLOGIC_FC_FIRMWARE
 425 #include "qlogicfc_asm.c"
 426 #else
 427 static unsigned short risc_code_addr01 = 0x1000 ;
 428 #endif
 429
 430 /* Each element in mbox_param is an 8 bit bitmap where each bit indicates
 431    if that mbox should be copied as input.  For example 0x2 would mean
 432    only copy mbox1. */
 433
 434 static const u_char mbox_param[] =
 435 {
 436         0x01,                   /* MBOX_NO_OP */
 437         0x1f,                   /* MBOX_LOAD_RAM */
 438         0x03,                   /* MBOX_EXEC_FIRMWARE */
 439         0x1f,                   /* MBOX_DUMP_RAM */
 440         0x07,                   /* MBOX_WRITE_RAM_WORD */
 441         0x03,                   /* MBOX_READ_RAM_WORD */
 442         0xff,                   /* MBOX_MAILBOX_REG_TEST */
 443         0x03,                   /* MBOX_VERIFY_CHECKSUM */
 444         0x01,                   /* MBOX_ABOUT_FIRMWARE */
 445         0xff,                   /* MBOX_LOAD_RISC_RAM */
 446         0xff,                   /* MBOX_DUMP_RISC_RAM */
 447         0x00,                   /* 0x000b */
 448         0x00,                   /* 0x000c */
 449         0x00,                   /* 0x000d */
 450         0x01,                   /* MBOX_CHECK_FIRMWARE */
 451         0x00,                   /* 0x000f */
 452         0x1f,                   /* MBOX_INIT_REQ_QUEUE */
 453         0x2f,                   /* MBOX_INIT_RES_QUEUE */
 454         0x0f,                   /* MBOX_EXECUTE_IOCB */
 455         0x03,                   /* MBOX_WAKE_UP */
 456         0x01,                   /* MBOX_STOP_FIRMWARE */
 457         0x0f,                   /* MBOX_ABORT_IOCB */
 458         0x03,                   /* MBOX_ABORT_DEVICE */
 459         0x07,                   /* MBOX_ABORT_TARGET */
 460         0x03,                   /* MBOX_BUS_RESET */
 461         0x03,                   /* MBOX_STOP_QUEUE */
 462         0x03,                   /* MBOX_START_QUEUE */
 463         0x03,                   /* MBOX_SINGLE_STEP_QUEUE */
 464         0x03,                   /* MBOX_ABORT_QUEUE */
 465         0x03,                   /* MBOX_GET_DEV_QUEUE_STATUS */
 466         0x00,                   /* 0x001e */
 467         0x01,                   /* MBOX_GET_FIRMWARE_STATUS */
 468         0x01,                   /* MBOX_GET_INIT_SCSI_ID */
 469         0x00,                   /* 0x0021 */
 470         0x01,                   /* MBOX_GET_RETRY_COUNT */
 471         0x00,                   /* 0x0023 */
 472         0x00,                   /* 0x0024 */
 473         0x00,                   /* 0x0025 */
 474         0x00,                   /* 0x0026 */
 475         0x00,                   /* 0x0027 */
 476         0x03,                   /* MBOX_GET_TARGET_PARAMS */
 477         0x03,                   /* MBOX_GET_DEV_QUEUE_PARAMS */
 478         0x00,                   /* 0x002a */
 479         0x00,                   /* 0x002b */
 480         0x00,                   /* 0x002c */
 481         0x00,                   /* 0x002d */
 482         0x00,                   /* 0x002e */
 483         0x00,                   /* 0x002f */
 484         0x00,                   /* 0x0030 */
 485         0x00,                   /* 0x0031 */
 486         0x07,                   /* MBOX_SET_RETRY_COUNT */
 487         0x00,                   /* 0x0033 */
 488         0x00,                   /* 0x0034 */
 489         0x00,                   /* 0x0035 */
 490         0x00,                   /* 0x0036 */
 491         0x00,                   /* 0x0037 */
 492         0x0f,                   /* MBOX_SET_TARGET_PARAMS */
 493         0x0f,                   /* MBOX_SET_DEV_QUEUE_PARAMS */
 494         0x00,                   /* 0x003a */
 495         0x00,                   /* 0x003b */
 496         0x00,                   /* 0x003c */
 497         0x00,                   /* 0x003d */
 498         0x00,                   /* 0x003e */
 499         0x00,                   /* 0x003f */
 500         0x00,                   /* 0x0040 */
 501         0x00,                   /* 0x0041 */
 502         0x00,                   /* 0x0042 */
 503         0x00,                   /* 0x0043 */
 504         0x00,                   /* 0x0044 */
 505         0x00,                   /* 0x0045 */
 506         0x00,                   /* 0x0046 */
 507         0x00,                   /* 0x0047 */
 508         0x00,                   /* 0x0048 */
 509         0x00,                   /* 0x0049 */
 510         0x00,                   /* 0x004a */
 511         0x00,                   /* 0x004b */
 512         0x00,                   /* 0x004c */
 513         0x00,                   /* 0x004d */
 514         0x00,                   /* 0x004e */
 515         0x00,                   /* 0x004f */
 516         0x00,                   /* 0x0050 */
 517         0x00,                   /* 0x0051 */
 518         0x00,                   /* 0x0052 */
 519         0x00,                   /* 0x0053 */
 520         0xcf,                   /* MBOX_EXECUTE_IOCB64 */
 521         0x00,                   /* 0x0055 */
 522         0x00,                   /* 0x0056 */
 523         0x00,                   /* 0x0057 */
 524         0x00,                   /* 0x0058 */
 525         0x00,                   /* 0x0059 */
 526         0x00,                   /* 0x005a */
 527         0x00,                   /* 0x005b */
 528         0x00,                   /* 0x005c */
 529         0x00,                   /* 0x005d */
 530         0x00,                   /* 0x005e */
 531         0x00,                   /* 0x005f */
 532         0xff,                   /* MBOX_INIT_FIRMWARE */
 533         0xcd,                   /* MBOX_GET_INIT_CB */
 534         0x01,                   /* MBOX_INIT_LIP */
 535         0xcd,                   /* MBOX_GET_POS_MAP */
 536         0xcf,                   /* MBOX_GET_PORT_DB */
 537         0x03,                   /* MBOX_CLEAR_ACA */
 538         0x03,                   /* MBOX_TARGET_RESET */
 539         0x03,                   /* MBOX_CLEAR_TASK_SET */
 540         0x03,                   /* MBOX_ABORT_TASK_SET */
 541         0x01,                   /* MBOX_GET_FIRMWARE_STATE */
 542         0x03,                   /* MBOX_GET_PORT_NAME */
 543         0x00,                   /* 0x006b */
 544         0x00,                   /* 0x006c */
 545         0x00,                   /* 0x006d */
 546         0xcf,                   /* MBOX_SEND_SNS */
 547         0x0f,                   /* MBOX_PORT_LOGIN */
 548         0x03,                   /* MBOX_SEND_CHANGE_REQUEST */
 549         0x03,                   /* MBOX_PORT_LOGOUT */
 550 };
 551
 552 #define MAX_MBOX_COMMAND        (sizeof(mbox_param)/sizeof(u_short))
 553
 554
 555 struct id_name_map {
 556         u64 wwn;
 557         u_char loop_id;
 558 };
 559
 560 struct sns_cb {
 561         u_short len;
 562         u_short res1;
 563         u_int response_low;
 564         u_int response_high;
 565         u_short sub_len;
 566         u_short res2;
 567         u_char data[44];
 568 };
 569
 570 /* address of instance of this struct is passed to adapter to initialize things
 571  */
 572 struct init_cb {
 573         u_char version;
 574         u_char reseverd1[1];
 575         u_short firm_opts;
 576         u_short max_frame_len;
 577         u_short max_iocb;
 578         u_short exec_throttle;
 579         u_char retry_cnt;
 580         u_char retry_delay;
 581         u_short node_name[4];
 582         u_short hard_addr;
 583         u_char reserved2[10];
 584         u_short req_queue_out;
 585         u_short res_queue_in;
 586         u_short req_queue_len;
 587         u_short res_queue_len;
 588         u_int req_queue_addr_lo;
 589         u_int req_queue_addr_high;
 590         u_int res_queue_addr_lo;
 591         u_int res_queue_addr_high;
 592         /* the rest of this structure only applies to the isp2200 */
 593         u_short lun_enables;
 594         u_char cmd_resource_cnt;
 595         u_char notify_resource_cnt;
 596         u_short timeout;
 597         u_short reserved3;
 598         u_short add_firm_opts;
 599         u_char res_accum_timer;
 600         u_char irq_delay_timer;
 601         u_short special_options;
 602         u_short reserved4[13];
 603 };
 604
 605 /*
 606  * The result queue can be quite a bit smaller since continuation entries
 607  * do not show up there:
 608  */
 609 #define RES_QUEUE_LEN           ((QLOGICFC_REQ_QUEUE_LEN + 1) / 8 - 1)
 610 #define QUEUE_ENTRY_LEN         64
 611
 612 #if ISP2x00_FABRIC
 613 #define QLOGICFC_MAX_ID    0xff
 614 #else
 615 #define QLOGICFC_MAX_ID    0x7d
 616 #endif
 617
 618 #define QLOGICFC_MAX_LUN        128
 619 #define QLOGICFC_MAX_LOOP_ID    0x7d
 620
 621 /* the following connection options only apply to the 2200.  i have only
 622  * had success with LOOP_ONLY and P2P_ONLY.
 623  */
 624
 625 #define LOOP_ONLY              0
 626 #define P2P_ONLY               1
 627 #define LOOP_PREFERED          2
 628 #define P2P_PREFERED           3
 629
 630 #define CONNECTION_PREFERENCE  LOOP_ONLY
 631
 632 /* adapter_state values */
 633 #define AS_FIRMWARE_DEAD      -1
 634 #define AS_LOOP_DOWN           0
 635 #define AS_LOOP_GOOD           1
 636 #define AS_REDO_FABRIC_PORTDB  2
 637 #define AS_REDO_LOOP_PORTDB    4
 638
 639 #define RES_SIZE        ((RES_QUEUE_LEN + 1)*QUEUE_ENTRY_LEN)
 640 #define REQ_SIZE        ((QLOGICFC_REQ_QUEUE_LEN + 1)*QUEUE_ENTRY_LEN)
 641
 642 struct isp2x00_hostdata {
 643         u_char revision;
 644         struct pci_dev *pci_dev;
 645         /* result and request queues (shared with isp2x00): */
 646         u_int req_in_ptr;       /* index of next request slot */
 647         u_int res_out_ptr;      /* index of next result slot */
 648
 649         /* this is here so the queues are nicely aligned */
 650         long send_marker;       /* do we need to send a marker? */
 651
 652         char * res;
 653         char * req;
 654         struct init_cb control_block;
 655         int adapter_state;
 656         unsigned long int tag_ages[QLOGICFC_MAX_ID + 1];
 657         Scsi_Cmnd *handle_ptrs[QLOGICFC_REQ_QUEUE_LEN + 1];
 658         unsigned long handle_serials[QLOGICFC_REQ_QUEUE_LEN + 1];
 659         struct id_name_map port_db[QLOGICFC_MAX_ID + 1];
 660         u_char mbox_done;
 661         u64 wwn;
 662         u_int port_id;
 663         u_char queued;
 664         u_char host_id;
 665         struct timer_list explore_timer;
 666         struct id_name_map tempmap[QLOGICFC_MAX_ID + 1];
 667 };
 668
 669
 670 /* queue length's _must_ be power of two: */
 671 #define QUEUE_DEPTH(in, out, ql)        ((in - out) & (ql))
 672 #define REQ_QUEUE_DEPTH(in, out)        QUEUE_DEPTH(in, out,                 \
 673                                                     QLOGICFC_REQ_QUEUE_LEN)
 674 #define RES_QUEUE_DEPTH(in, out)        QUEUE_DEPTH(in, out, RES_QUEUE_LEN)
 675
 676 static void isp2x00_enable_irqs(struct Scsi_Host *);
 677 static void isp2x00_disable_irqs(struct Scsi_Host *);
 678 static int isp2x00_init(struct Scsi_Host *);
 679 static int isp2x00_reset_hardware(struct Scsi_Host *);
 680 static int isp2x00_mbox_command(struct Scsi_Host *, u_short[]);
 681 static int isp2x00_return_status(Scsi_Cmnd *, struct Status_Entry *);
 682 static void isp2x00_intr_handler(int, void *, struct pt_regs *);
 683 static irqreturn_t do_isp2x00_intr_handler(int, void *, struct pt_regs *);
 684 static int isp2x00_make_portdb(struct Scsi_Host *);
 685
 686 #if ISP2x00_FABRIC
 687 static int isp2x00_init_fabric(struct Scsi_Host *, struct id_name_map *, int);
 688 #endif
 689
 690 #if USE_NVRAM_DEFAULTS
 691 static int isp2x00_get_nvram_defaults(struct Scsi_Host *, struct init_cb *);
 692 static u_short isp2x00_read_nvram_word(struct Scsi_Host *, u_short);
 693 #endif
 694
 695 #if DEBUG_ISP2x00
 696 static void isp2x00_print_scsi_cmd(Scsi_Cmnd *);
 697 #endif
 698
 699 #if DEBUG_ISP2x00_INTR
 700 static void isp2x00_print_status_entry(struct Status_Entry *);
 701 #endif
 702
 703 static inline void isp2x00_enable_irqs(struct Scsi_Host *host)
 704 {
 705         outw(ISP_EN_INT | ISP_EN_RISC, host->io_port + PCI_INTER_CTL);
 706 }
 707
 708
 709 static inline void isp2x00_disable_irqs(struct Scsi_Host *host)
 710 {
 711         outw(0x0, host->io_port + PCI_INTER_CTL);
 712 }
 713
 714
 715 static int isp2x00_detect(struct scsi_host_template * tmpt)
 716 {
 717         int hosts = 0;
 718         unsigned long wait_time;
 719         struct Scsi_Host *host = NULL;
 720         struct isp2x00_hostdata *hostdata;
 721         struct pci_dev *pdev;
 722         unsigned short device_ids[2];
 723         dma_addr_t busaddr;
 724         int i;
 725
 726
 727         ENTER("isp2x00_detect");
 728
 729         device_ids[0] = PCI_DEVICE_ID_QLOGIC_ISP2100;
 730         device_ids[1] = PCI_DEVICE_ID_QLOGIC_ISP2200;
 731
 732         tmpt->proc_name = "isp2x00";
 733
 734         for (i=0; i<2; i++){
 735                 pdev = NULL;
 736                 while ((pdev = pci_find_device(PCI_VENDOR_ID_QLOGIC, device_ids[i], pdev))) {
 737                         if (pci_enable_device(pdev))
 738                                 continue;
 739
 740                         /* Try to configure DMA attributes. */
 741                         if (pci_set_dma_mask(pdev, 0xffffffffffffffffULL) &&
 742                             pci_set_dma_mask(pdev, 0xffffffffULL))
 743                                         continue;
 744
 745                         host = scsi_register(tmpt, sizeof(struct isp2x00_hostdata));
 746                         if (!host) {
 747                                 printk("qlogicfc%d : could not register host.\n", hosts);
 748                                 continue;
 749                         }
 750                         host->max_id = QLOGICFC_MAX_ID + 1;
 751                         host->max_lun = QLOGICFC_MAX_LUN;
 752                         hostdata = (struct isp2x00_hostdata *) host->hostdata;
 753
 754                         memset(hostdata, 0, sizeof(struct isp2x00_hostdata));
 755                         hostdata->pci_dev = pdev;
 756                         hostdata->res = pci_alloc_consistent(pdev, RES_SIZE + REQ_SIZE, &busaddr);
 757
 758                         if (!hostdata->res){
 759                                 printk("qlogicfc%d : could not allocate memory for request and response queue.\n", hosts);
 760                                 scsi_unregister(host);
 761                                 continue;
 762                         }
 763                         hostdata->req = hostdata->res + (RES_QUEUE_LEN + 1)*QUEUE_ENTRY_LEN;
 764                         hostdata->queued = 0;
 765                         /* set up the control block */
 766                         hostdata->control_block.version = 0x1;
 767                         hostdata->control_block.firm_opts = cpu_to_le16(0x800e);
 768                         hostdata->control_block.max_frame_len = cpu_to_le16(2048);
 769                         hostdata->control_block.max_iocb = cpu_to_le16(QLOGICFC_REQ_QUEUE_LEN);
 770                         hostdata->control_block.exec_throttle = cpu_to_le16(QLOGICFC_CMD_PER_LUN);
 771                         hostdata->control_block.retry_delay = 5;
 772                         hostdata->control_block.retry_cnt = 1;
 773                         hostdata->control_block.node_name[0] = cpu_to_le16(0x0020);
 774                         hostdata->control_block.node_name[1] = cpu_to_le16(0xE000);
 775                         hostdata->control_block.node_name[2] = cpu_to_le16(0x008B);
 776                         hostdata->control_block.node_name[3] = cpu_to_le16(0x0000);
 777                         hostdata->control_block.hard_addr = cpu_to_le16(0x0003);
 778                         hostdata->control_block.req_queue_len = cpu_to_le16(QLOGICFC_REQ_QUEUE_LEN + 1);
 779                         hostdata->control_block.res_queue_len = cpu_to_le16(RES_QUEUE_LEN + 1);
 780                         hostdata->control_block.res_queue_addr_lo = cpu_to_le32(pci64_dma_lo32(busaddr));
 781                         hostdata->control_block.res_queue_addr_high = cpu_to_le32(pci64_dma_hi32(busaddr));
 782                         hostdata->control_block.req_queue_addr_lo = cpu_to_le32(pci64_dma_lo32(busaddr + RES_SIZE));
 783                         hostdata->control_block.req_queue_addr_high = cpu_to_le32(pci64_dma_hi32(busaddr + RES_SIZE));
 784
 785
 786                         hostdata->control_block.add_firm_opts |= cpu_to_le16(CONNECTION_PREFERENCE<<4);
 787                         hostdata->adapter_state = AS_LOOP_DOWN;
 788                         hostdata->explore_timer.data = 1;
 789                         hostdata->host_id = hosts;
 790
 791                         if (isp2x00_init(host) || isp2x00_reset_hardware(host)) {
 792                                 pci_free_consistent (pdev, RES_SIZE + REQ_SIZE, hostdata->res, busaddr);
 793                                 scsi_unregister(host);
 794                                 continue;
 795                         }
 796                         host->this_id = 0;
 797
 798                         if (request_irq(host->irq, do_isp2x00_intr_handler, SA_INTERRUPT | SA_SHIRQ, "qlogicfc", host)) {
 799                                 printk("qlogicfc%d : interrupt %d already in use\n",
 800                                        hostdata->host_id, host->irq);
 801                                 pci_free_consistent (pdev, RES_SIZE + REQ_SIZE, hostdata->res, busaddr);
 802                                 scsi_unregister(host);
 803                                 continue;
 804                         }
 805                         if (!request_region(host->io_port, 0xff, "qlogicfc")) {
 806                                 printk("qlogicfc%d : i/o region 0x%lx-0x%lx already "
 807                                        "in use\n",
 808                                        hostdata->host_id, host->io_port, host->io_port + 0xff);
 809                                 free_irq(host->irq, host);
 810                                 pci_free_consistent (pdev, RES_SIZE + REQ_SIZE, hostdata->res, busaddr);
 811                                 scsi_unregister(host);
 812                                 continue;
 813                         }
 814
 815                         outw(0x0, host->io_port + PCI_SEMAPHORE);
 816                         outw(HCCR_CLEAR_RISC_INTR, host->io_port + HOST_HCCR);
 817                         isp2x00_enable_irqs(host);
 818                         /* wait for the loop to come up */
 819                         for (wait_time = jiffies + 10 * HZ; time_before(jiffies, wait_time) && hostdata->adapter_state == AS_LOOP_DOWN;) {
 820                                 barrier();
 821                                 cpu_relax();
 822                         }
 823                         if (hostdata->adapter_state == AS_LOOP_DOWN) {
 824                                 printk("qlogicfc%d : link is not up\n", hostdata->host_id);
 825                         }
 826                         hosts++;
 827                         hostdata->explore_timer.data = 0;
 828                 }
 829         }
 830
 831
 832         /* this busy loop should not be needed but the isp2x00 seems to need
 833            some time before recognizing it is attached to a fabric */
 834
 835 #if ISP2x00_FABRIC
 836         if (hosts) {
 837                 for (wait_time = jiffies + 5 * HZ; time_before(jiffies, wait_time);) {
 838                         barrier();
 839                         cpu_relax();
 840                 }
 841         }
 842 #endif
 843
 844         LEAVE("isp2x00_detect");
 845
 846         return hosts;
 847 }
 848
 849
 850 static int isp2x00_make_portdb(struct Scsi_Host *host)
 851 {
 852
 853         short param[8];
 854         int i, j;
 855         struct isp2x00_hostdata *hostdata;
 856
 857         isp2x00_disable_irqs(host);
 858
 859         hostdata = (struct isp2x00_hostdata *) host->hostdata;
 860         memset(hostdata->tempmap, 0, sizeof(hostdata->tempmap));
 861
 862 #if ISP2x00_FABRIC
 863         for (i = 0x81; i < QLOGICFC_MAX_ID; i++) {
 864                 param[0] = MBOX_PORT_LOGOUT;
 865                 param[1] = i << 8;
 866                 param[2] = 0;
 867                 param[3] = 0;
 868
 869                 isp2x00_mbox_command(host, param);
 870
 871                 if (param[0] != MBOX_COMMAND_COMPLETE) {
 872
 873                         DEBUG_FABRIC(printk("qlogicfc%d : logout failed %x  %x\n", hostdata->host_id, i, param[0]));
 874                 }
 875         }
 876 #endif
 877
 878
 879         param[0] = MBOX_GET_INIT_SCSI_ID;
 880
 881         isp2x00_mbox_command(host, param);
 882
 883         if (param[0] == MBOX_COMMAND_COMPLETE) {
 884                 hostdata->port_id = ((u_int) param[3]) << 16;
 885                 hostdata->port_id |= param[2];
 886                 hostdata->tempmap[0].loop_id = param[1];
 887                 hostdata->tempmap[0].wwn = hostdata->wwn;
 888         }
 889         else {
 890                 printk("qlogicfc%d : error getting scsi id.\n", hostdata->host_id);
 891         }
 892
 893         for (i = 0; i <=QLOGICFC_MAX_ID; i++)
 894                 hostdata->tempmap[i].loop_id = hostdata->tempmap[0].loop_id;
 895
 896         for (i = 0, j = 1; i <= QLOGICFC_MAX_LOOP_ID; i++) {
 897                 param[0] = MBOX_GET_PORT_NAME;
 898                 param[1] = (i << 8) & 0xff00;
 899
 900                 isp2x00_mbox_command(host, param);
 901
 902                 if (param[0] == MBOX_COMMAND_COMPLETE) {
 903                         hostdata->tempmap[j].loop_id = i;
 904                         hostdata->tempmap[j].wwn = ((u64) (param[2] & 0xff)) << 56;
 905                         hostdata->tempmap[j].wwn |= ((u64) ((param[2] >> 8) & 0xff)) << 48;
 906                         hostdata->tempmap[j].wwn |= ((u64) (param[3] & 0xff)) << 40;
 907                         hostdata->tempmap[j].wwn |= ((u64) ((param[3] >> 8) & 0xff)) << 32;
 908                         hostdata->tempmap[j].wwn |= ((u64) (param[6] & 0xff)) << 24;
 909                         hostdata->tempmap[j].wwn |= ((u64) ((param[6] >> 8) & 0xff)) << 16;
 910                         hostdata->tempmap[j].wwn |= ((u64) (param[7] & 0xff)) << 8;
 911                         hostdata->tempmap[j].wwn |= ((u64) ((param[7] >> 8) & 0xff));
 912
 913                         j++;
 914
 915                 }
 916         }
 917
 918
 919 #if ISP2x00_FABRIC
 920         isp2x00_init_fabric(host, hostdata->tempmap, j);
 921 #endif
 922
 923         for (i = 0; i <= QLOGICFC_MAX_ID; i++) {
 924                 if (hostdata->tempmap[i].wwn != hostdata->port_db[i].wwn) {
 925                         for (j = 0; j <= QLOGICFC_MAX_ID; j++) {
 926                                 if (hostdata->tempmap[j].wwn == hostdata->port_db[i].wwn) {
 927                                         hostdata->port_db[i].loop_id = hostdata->tempmap[j].loop_id;
 928                                         break;
 929                                 }
 930                         }
 931                         if (j == QLOGICFC_MAX_ID + 1)
 932                                 hostdata->port_db[i].loop_id = hostdata->tempmap[0].loop_id;
 933
 934                         for (j = 0; j <= QLOGICFC_MAX_ID; j++) {
 935                                 if (hostdata->port_db[j].wwn == hostdata->tempmap[i].wwn || !hostdata->port_db[j].wwn) {
 936                                         break;
 937                                 }
 938                         }
 939                         if (j == QLOGICFC_MAX_ID + 1)
 940                                 printk("qlogicfc%d : Too many scsi devices, no more room in port map.\n", hostdata->host_id);
 941                         if (!hostdata->port_db[j].wwn) {
 942                                 hostdata->port_db[j].loop_id = hostdata->tempmap[i].loop_id;
 943                                 hostdata->port_db[j].wwn = hostdata->tempmap[i].wwn;
 944                         }
 945                 } else
 946                         hostdata->port_db[i].loop_id = hostdata->tempmap[i].loop_id;
 947
 948         }
 949
 950         isp2x00_enable_irqs(host);
 951
 952         return 0;
 953 }
 954
 955
 956 #if ISP2x00_FABRIC
 957
 958 #define FABRIC_PORT          0x7e
 959 #define FABRIC_CONTROLLER    0x7f
 960 #define FABRIC_SNS           0x80
 961
 962 int isp2x00_init_fabric(struct Scsi_Host *host, struct id_name_map *port_db, int cur_scsi_id)
 963 {
 964
 965         u_short param[8];
 966         u64 wwn;
 967         int done = 0;
 968         u_short loop_id = 0x81;
 969         u_short scsi_id = cur_scsi_id;
 970         u_int port_id;
 971         struct sns_cb *req;
 972         u_char *sns_response;
 973         dma_addr_t busaddr;
 974         struct isp2x00_hostdata *hostdata;
 975
 976         hostdata = (struct isp2x00_hostdata *) host->hostdata;
 977
 978         DEBUG_FABRIC(printk("qlogicfc%d : Checking for a fabric.\n", hostdata->host_id));
 979         param[0] = MBOX_GET_PORT_NAME;
 980         param[1] = (u16)FABRIC_PORT << 8;
 981
 982         isp2x00_mbox_command(host, param);
 983
 984         if (param[0] != MBOX_COMMAND_COMPLETE) {
 985                 DEBUG_FABRIC(printk("qlogicfc%d : fabric check result %x\n", hostdata->host_id, param[0]));
 986                 return 0;
 987         }
 988         printk("qlogicfc%d : Fabric found.\n", hostdata->host_id);
 989
 990         req = (struct sns_cb *)pci_alloc_consistent(hostdata->pci_dev, sizeof(*req) + 608, &busaddr);
 991
 992         if (!req){
 993                 printk("qlogicfc%d : Could not allocate DMA resources for fabric initialization\n", hostdata->host_id);
 994                 return 0;
 995         }
 996         sns_response = (u_char *)(req + 1);
 997
 998         if (hostdata->adapter_state & AS_REDO_LOOP_PORTDB){
 999                 memset(req, 0, sizeof(*req));
1000
1001                 req->len = cpu_to_le16(8);
1002                 req->response_low = cpu_to_le32(pci64_dma_lo32(busaddr + sizeof(*req)));
1003                 req->response_high = cpu_to_le32(pci64_dma_hi32(busaddr + sizeof(*req)));
1004                 req->sub_len = cpu_to_le16(22);
1005                 req->data[0] = 0x17;
1006                 req->data[1] = 0x02;
1007                 req->data[8] = (u_char) (hostdata->port_id & 0xff);
1008                 req->data[9] = (u_char) (hostdata->port_id >> 8 & 0xff);
1009                 req->data[10] = (u_char) (hostdata->port_id >> 16 & 0xff);
1010                 req->data[13] = 0x01;
1011                 param[0] = MBOX_SEND_SNS;
1012                 param[1] = 30;
1013                 param[2] = pci64_dma_lo32(busaddr) >> 16;
1014                 param[3] = pci64_dma_lo32(busaddr);
1015                 param[6] = pci64_dma_hi32(busaddr) >> 16;
1016                 param[7] = pci64_dma_hi32(busaddr);
1017
1018                 isp2x00_mbox_command(host, param);
1019
1020                 if (param[0] != MBOX_COMMAND_COMPLETE)
1021                         printk("qlogicfc%d : error sending RFC-4\n", hostdata->host_id);
1022         }
1023
1024         port_id = hostdata->port_id;
1025         while (!done) {
1026                 memset(req, 0, sizeof(*req));
1027
1028                 req->len = cpu_to_le16(304);
1029                 req->response_low = cpu_to_le32(pci64_dma_lo32(busaddr + sizeof(*req)));
1030                 req->response_high = cpu_to_le32(pci64_dma_hi32(busaddr + sizeof(*req)));
1031                 req->sub_len = cpu_to_le16(6);
1032                 req->data[0] = 0x00;
1033                 req->data[1] = 0x01;
1034                 req->data[8] = (u_char) (port_id & 0xff);
1035                 req->data[9] = (u_char) (port_id >> 8 & 0xff);
1036                 req->data[10] = (u_char) (port_id >> 16 & 0xff);
1037
1038                 param[0] = MBOX_SEND_SNS;
1039                 param[1] = 14;
1040                 param[2] = pci64_dma_lo32(busaddr) >> 16;
1041                 param[3] = pci64_dma_lo32(busaddr);
1042                 param[6] = pci64_dma_hi32(busaddr) >> 16;
1043                 param[7] = pci64_dma_hi32(busaddr);
1044
1045                 isp2x00_mbox_command(host, param);
1046
1047                 if (param[0] == MBOX_COMMAND_COMPLETE) {
1048                         DEBUG_FABRIC(printk("qlogicfc%d : found node %02x%02x%02x%02x%02x%02x%02x%02x ", hostdata->host_id, sns_response[20], sns_response[21], sns_response[22], sns_response[23], sns_response[24], sns_response[25], sns_response[26], sns_response[27]));
1049                         DEBUG_FABRIC(printk("  port id: %02x%02x%02x\n", sns_response[17], sns_response[18], sns_response[19]));
1050                         port_id = ((u_int) sns_response[17]) << 16;
1051                         port_id |= ((u_int) sns_response[18]) << 8;
1052                         port_id |= ((u_int) sns_response[19]);
1053                         wwn = ((u64) sns_response[20]) << 56;
1054                         wwn |= ((u64) sns_response[21]) << 48;
1055                         wwn |= ((u64) sns_response[22]) << 40;
1056                         wwn |= ((u64) sns_response[23]) << 32;
1057                         wwn |= ((u64) sns_response[24]) << 24;
1058                         wwn |= ((u64) sns_response[25]) << 16;
1059                         wwn |= ((u64) sns_response[26]) << 8;
1060                         wwn |= ((u64) sns_response[27]);
1061                         if (hostdata->port_id >> 8 != port_id >> 8) {
1062                                 DEBUG_FABRIC(printk("qlogicfc%d : adding a fabric port: %x\n", hostdata->host_id, port_id));
1063                                 param[0] = MBOX_PORT_LOGIN;
1064                                 param[1] = loop_id << 8;
1065                                 param[2] = (u_short) (port_id >> 16);
1066                                 param[3] = (u_short) (port_id);
1067
1068                                 isp2x00_mbox_command(host, param);
1069
1070                                 if (param[0] == MBOX_COMMAND_COMPLETE) {
1071                                         port_db[scsi_id].wwn = wwn;
1072                                         port_db[scsi_id].loop_id = loop_id;
1073                                         loop_id++;
1074                                         scsi_id++;
1075                                 } else {
1076                                         printk("qlogicfc%d : Error performing port login %x\n", hostdata->host_id, param[0]);
1077                                         DEBUG_FABRIC(printk("qlogicfc%d : loop_id: %x\n", hostdata->host_id, loop_id));
1078                                         param[0] = MBOX_PORT_LOGOUT;
1079                                         param[1] = loop_id << 8;
1080                                         param[2] = 0;
1081                                         param[3] = 0;
1082
1083                                         isp2x00_mbox_command(host, param);
1084
1085                                 }
1086
1087                         }
1088                         if (hostdata->port_id == port_id)
1089                                 done = 1;
1090                 } else {
1091                         printk("qlogicfc%d : Get All Next failed %x.\n", hostdata->host_id, param[0]);
1092                         pci_free_consistent(hostdata->pci_dev, sizeof(*req) + 608, req, busaddr);
1093                         return 0;
1094                 }
1095         }
1096
1097         pci_free_consistent(hostdata->pci_dev, sizeof(*req) + 608, req, busaddr);
1098         return 1;
1099 }
1100
1101 #endif                          /* ISP2x00_FABRIC */
1102
1103
1104 static int isp2x00_release(struct Scsi_Host *host)
1105 {
1106         struct isp2x00_hostdata *hostdata;
1107         dma_addr_t busaddr;
1108
1109         ENTER("isp2x00_release");
1110
1111         hostdata = (struct isp2x00_hostdata *) host->hostdata;
1112
1113         outw(0x0, host->io_port + PCI_INTER_CTL);
1114         free_irq(host->irq, host);
1115
1116         release_region(host->io_port, 0xff);
1117
1118         busaddr = pci64_dma_build(le32_to_cpu(hostdata->control_block.res_queue_addr_high),
1119                                   le32_to_cpu(hostdata->control_block.res_queue_addr_lo));
1120         pci_free_consistent(hostdata->pci_dev, RES_SIZE + REQ_SIZE, hostdata->res, busaddr);
1121
1122         LEAVE("isp2x00_release");
1123
1124         return 0;
1125 }
1126
1127
1128 static const char *isp2x00_info(struct Scsi_Host *host)
1129 {
1130         static char buf[80];
1131         struct isp2x00_hostdata *hostdata;
1132         ENTER("isp2x00_info");
1133
1134         hostdata = (struct isp2x00_hostdata *) host->hostdata;
1135         sprintf(buf,
1136                 "QLogic ISP%04x SCSI on PCI bus %02x device %02x irq %d base 0x%lx",
1137                 hostdata->pci_dev->device, hostdata->pci_dev->bus->number, hostdata->pci_dev->devfn, host->irq,
1138                 host->io_port);
1139
1140
1141         LEAVE("isp2x00_info");
1142
1143         return buf;
1144 }
1145
1146
1147 /*
1148  * The middle SCSI layer ensures that queuecommand never gets invoked
1149  * concurrently with itself or the interrupt handler (though the
1150  * interrupt handler may call this routine as part of
1151  * request-completion handling).
1152  */
1153 static int isp2x00_queuecommand(Scsi_Cmnd * Cmnd, void (*done) (Scsi_Cmnd *))
1154 {
1155         int i, sg_count, n, num_free;
1156         u_int in_ptr, out_ptr;
1157         struct dataseg *ds;
1158         struct scatterlist *sg;
1159         struct Command_Entry *cmd;
1160         struct Continuation_Entry *cont;
1161         struct Scsi_Host *host;
1162         struct isp2x00_hostdata *hostdata;
1163
1164         ENTER("isp2x00_queuecommand");
1165
1166         host = Cmnd->device->host;
1167         hostdata = (struct isp2x00_hostdata *) host->hostdata;
1168         Cmnd->scsi_done = done;
1169
1170         DEBUG(isp2x00_print_scsi_cmd(Cmnd));
1171
1172         if (hostdata->adapter_state & AS_REDO_FABRIC_PORTDB || hostdata->adapter_state & AS_REDO_LOOP_PORTDB) {
1173                 isp2x00_make_portdb(host);
1174                 hostdata->adapter_state = AS_LOOP_GOOD;
1175                 printk("qlogicfc%d : Port Database\n", hostdata->host_id);
1176                 for (i = 0; hostdata->port_db[i].wwn != 0; i++) {
1177                         printk("wwn: %08x%08x  scsi_id: %x  loop_id: ", (u_int) (hostdata->port_db[i].wwn >> 32), (u_int) hostdata->port_db[i].wwn, i);
1178                         if (hostdata->port_db[i].loop_id != hostdata->port_db[0].loop_id || i == 0)
1179                                 printk("%x", hostdata->port_db[i].loop_id);
1180                         else
1181                                 printk("Not Available");
1182                         printk("\n");
1183                 }
1184         }
1185         if (hostdata->adapter_state == AS_FIRMWARE_DEAD) {
1186                 printk("qlogicfc%d : The firmware is dead, just return.\n", hostdata->host_id);
1187                 host->max_id = 0;
1188                 return 0;
1189         }
1190
1191         out_ptr = inw(host->io_port + MBOX4);
1192         in_ptr = hostdata->req_in_ptr;
1193
1194         DEBUG(printk("qlogicfc%d : request queue depth %d\n", hostdata->host_id,
1195                      REQ_QUEUE_DEPTH(in_ptr, out_ptr)));
1196
1197         cmd = (struct Command_Entry *) &hostdata->req[in_ptr*QUEUE_ENTRY_LEN];
1198         in_ptr = (in_ptr + 1) & QLOGICFC_REQ_QUEUE_LEN;
1199         if (in_ptr == out_ptr) {
1200                 DEBUG(printk("qlogicfc%d : request queue overflow\n", hostdata->host_id));
1201                 return 1;
1202         }
1203         if (hostdata->send_marker) {
1204                 struct Marker_Entry *marker;
1205
1206                 TRACE("queue marker", in_ptr, 0);
1207
1208                 DEBUG(printk("qlogicfc%d : adding marker entry\n", hostdata->host_id));
1209                 marker = (struct Marker_Entry *) cmd;
1210                 memset(marker, 0, sizeof(struct Marker_Entry));
1211
1212                 marker->hdr.entry_type = ENTRY_MARKER;
1213                 marker->hdr.entry_cnt = 1;
1214                 marker->modifier = SYNC_ALL;
1215
1216                 hostdata->send_marker = 0;
1217
1218                 if (((in_ptr + 1) & QLOGICFC_REQ_QUEUE_LEN) == out_ptr) {
1219                         outw(in_ptr, host->io_port + MBOX4);
1220                         hostdata->req_in_ptr = in_ptr;
1221                         DEBUG(printk("qlogicfc%d : request queue overflow\n", hostdata->host_id));
1222                         return 1;
1223                 }
1224                 cmd = (struct Command_Entry *) &hostdata->req[in_ptr*QUEUE_ENTRY_LEN];
1225                 in_ptr = (in_ptr + 1) & QLOGICFC_REQ_QUEUE_LEN;
1226         }
1227         TRACE("queue command", in_ptr, Cmnd);
1228
1229         memset(cmd, 0, sizeof(struct Command_Entry));
1230
1231         /* find a free handle mapping slot */
1232         for (i = in_ptr; i != (in_ptr - 1) && hostdata->handle_ptrs[i]; i = ((i + 1) % (QLOGICFC_REQ_QUEUE_LEN + 1)));
1233
1234         if (!hostdata->handle_ptrs[i]) {
1235                 cmd->handle = cpu_to_le32(i);
1236                 hostdata->handle_ptrs[i] = Cmnd;
1237                 hostdata->handle_serials[i] = Cmnd->serial_number;
1238         } else {
1239                 printk("qlogicfc%d : no handle slots, this should not happen.\n", hostdata->host_id);
1240                 printk("hostdata->queued is %x, in_ptr: %x\n", hostdata->queued, in_ptr);
1241                 for (i = 0; i <= QLOGICFC_REQ_QUEUE_LEN; i++){
1242                         if (!hostdata->handle_ptrs[i]){
1243                                 printk("slot %d has %p\n", i, hostdata->handle_ptrs[i]);
1244                         }
1245                 }
1246                 return 1;
1247         }
1248
1249         cmd->hdr.entry_type = ENTRY_COMMAND;
1250         cmd->hdr.entry_cnt = 1;
1251         cmd->target_lun = Cmnd->device->lun;
1252         cmd->expanded_lun = cpu_to_le16(Cmnd->device->lun);
1253 #if ISP2x00_PORTDB
1254         cmd->target_id = hostdata->port_db[Cmnd->device->id].loop_id;
1255 #else
1256         cmd->target_id = Cmnd->target;
1257 #endif
1258         cmd->total_byte_cnt = cpu_to_le32(Cmnd->request_bufflen);
1259         cmd->time_out = 0;
1260         memcpy(cmd->cdb, Cmnd->cmnd, Cmnd->cmd_len);
1261
1262         if (Cmnd->use_sg) {
1263                 sg = (struct scatterlist *) Cmnd->request_buffer;
1264                 sg_count = pci_map_sg(hostdata->pci_dev, sg, Cmnd->use_sg, Cmnd->sc_data_direction);
1265                 cmd->segment_cnt = cpu_to_le16(sg_count);
1266                 ds = cmd->dataseg;
1267                 /* fill in first two sg entries: */
1268                 n = sg_count;
1269                 if (n > DATASEGS_PER_COMMAND)
1270                         n = DATASEGS_PER_COMMAND;
1271
1272                 for (i = 0; i < n; i++) {
1273                         ds[i].d_base = cpu_to_le32(pci64_dma_lo32(sg_dma_address(sg)));
1274                         ds[i].d_base_hi = cpu_to_le32(pci64_dma_hi32(sg_dma_address(sg)));
1275                         ds[i].d_count = cpu_to_le32(sg_dma_len(sg));
1276                         ++sg;
1277                 }
1278                 sg_count -= DATASEGS_PER_COMMAND;
1279
1280                 while (sg_count > 0) {
1281                         ++cmd->hdr.entry_cnt;
1282                         cont = (struct Continuation_Entry *)
1283                             &hostdata->req[in_ptr*QUEUE_ENTRY_LEN];
1284                         memset(cont, 0, sizeof(struct Continuation_Entry));
1285                         in_ptr = (in_ptr + 1) & QLOGICFC_REQ_QUEUE_LEN;
1286                         if (in_ptr == out_ptr) {
1287                                 DEBUG(printk("qlogicfc%d : unexpected request queue overflow\n", hostdata->host_id));
1288                                 return 1;
1289                         }
1290                         TRACE("queue continuation", in_ptr, 0);
1291                         cont->hdr.entry_type = ENTRY_CONTINUATION;
1292                         ds = cont->dataseg;
1293                         n = sg_count;
1294                         if (n > DATASEGS_PER_CONT)
1295                                 n = DATASEGS_PER_CONT;
1296                         for (i = 0; i < n; ++i) {
1297                                 ds[i].d_base = cpu_to_le32(pci64_dma_lo32(sg_dma_address(sg)));
1298                                 ds[i].d_base_hi = cpu_to_le32(pci64_dma_hi32(sg_dma_address(sg)));
1299                                 ds[i].d_count = cpu_to_le32(sg_dma_len(sg));
1300                                 ++sg;
1301                         }
1302                         sg_count -= n;
1303                 }
1304         } else if (Cmnd->request_bufflen && Cmnd->sc_data_direction != PCI_DMA_NONE) {
1305                 struct page *page = virt_to_page(Cmnd->request_buffer);
1306                 unsigned long offset = offset_in_page(Cmnd->request_buffer);
1307                 dma_addr_t busaddr = pci_map_page(hostdata->pci_dev,
1308                                                   page, offset,
1309                                                   Cmnd->request_bufflen,
1310                                                   Cmnd->sc_data_direction);
1311                 Cmnd->SCp.dma_handle = busaddr;
1312
1313                 cmd->dataseg[0].d_base = cpu_to_le32(pci64_dma_lo32(busaddr));
1314                 cmd->dataseg[0].d_base_hi = cpu_to_le32(pci64_dma_hi32(busaddr));
1315                 cmd->dataseg[0].d_count = cpu_to_le32(Cmnd->request_bufflen);
1316                 cmd->segment_cnt = cpu_to_le16(1);
1317         } else {
1318                 cmd->dataseg[0].d_base = 0;
1319                 cmd->dataseg[0].d_base_hi = 0;
1320                 cmd->segment_cnt = cpu_to_le16(1); /* Shouldn't this be 0? */
1321         }
1322
1323         if (Cmnd->sc_data_direction == DMA_TO_DEVICE)
1324                 cmd->control_flags = cpu_to_le16(CFLAG_WRITE);
1325         else
1326                 cmd->control_flags = cpu_to_le16(CFLAG_READ);
1327
1328         if (Cmnd->device->tagged_supported) {
1329                 if (time_after(jiffies, hostdata->tag_ages[Cmnd->device->id] + (2 * ISP_TIMEOUT))) {
1330                         cmd->control_flags |= cpu_to_le16(CFLAG_ORDERED_TAG);
1331                         hostdata->tag_ages[Cmnd->device->id] = jiffies;
1332                 } else
1333                         switch (Cmnd->tag) {
1334                         case HEAD_OF_QUEUE_TAG:
1335                                 cmd->control_flags |= cpu_to_le16(CFLAG_HEAD_TAG);
1336                                 break;
1337                         case ORDERED_QUEUE_TAG:
1338                                 cmd->control_flags |= cpu_to_le16(CFLAG_ORDERED_TAG);
1339                                 break;
1340                         default:
1341                                 cmd->control_flags |= cpu_to_le16(CFLAG_SIMPLE_TAG);
1342                                 break;
1343                 }
1344         }
1345         /*
1346          * TEST_UNIT_READY commands from scsi_scan will fail due to "overlapped
1347          * commands attempted" unless we setup at least a simple queue (midlayer
1348          * will embelish this once it can do an INQUIRY command to the device)
1349          */
1350         else
1351                 cmd->control_flags |= cpu_to_le16(CFLAG_SIMPLE_TAG);
1352         outw(in_ptr, host->io_port + MBOX4);
1353         hostdata->req_in_ptr = in_ptr;
1354
1355         hostdata->queued++;
1356
1357         num_free = QLOGICFC_REQ_QUEUE_LEN - REQ_QUEUE_DEPTH(in_ptr, out_ptr);
1358         num_free = (num_free > 2) ? num_free - 2 : 0;
1359        host->can_queue = host->host_busy + num_free;
1360         if (host->can_queue > QLOGICFC_REQ_QUEUE_LEN)
1361                 host->can_queue = QLOGICFC_REQ_QUEUE_LEN;
1362         host->sg_tablesize = QLOGICFC_MAX_SG(num_free);
1363
1364         LEAVE("isp2x00_queuecommand");
1365
1366         return 0;
1367 }
1368
1369
1370 /* we have received an event, such as a lip or an RSCN, which may mean that
1371  * our port database is incorrect so the port database must be recreated.
1372  */
1373 static void redo_port_db(unsigned long arg)
1374 {
1375
1376         struct Scsi_Host * host = (struct Scsi_Host *) arg;
1377         struct isp2x00_hostdata * hostdata;
1378         unsigned long flags;
1379         int i;
1380
1381         hostdata = (struct isp2x00_hostdata *) host->hostdata;
1382         hostdata->explore_timer.data = 0;
1383         del_timer(&hostdata->explore_timer);
1384
1385         spin_lock_irqsave(host->host_lock, flags);
1386
1387         if (hostdata->adapter_state & AS_REDO_FABRIC_PORTDB || hostdata->adapter_state & AS_REDO_LOOP_PORTDB) {
1388                 isp2x00_make_portdb(host);
1389                 printk("qlogicfc%d : Port Database\n", hostdata->host_id);
1390                 for (i = 0; hostdata->port_db[i].wwn != 0; i++) {
1391                         printk("wwn: %08x%08x  scsi_id: %x  loop_id: ", (u_int) (hostdata->port_db[i].wwn >> 32), (u_int) hostdata->port_db[i].wwn, i);
1392                         if (hostdata->port_db[i].loop_id != hostdata->port_db[0].loop_id || i == 0)
1393                                 printk("%x", hostdata->port_db[i].loop_id);
1394                         else
1395                                 printk("Not Available");
1396                         printk("\n");
1397                 }
1398
1399                 for (i = 0; i < QLOGICFC_REQ_QUEUE_LEN; i++){
1400                         if (hostdata->handle_ptrs[i] && (hostdata->port_db[hostdata->handle_ptrs[i]->device->id].loop_id > QLOGICFC_MAX_LOOP_ID || hostdata->adapter_state & AS_REDO_LOOP_PORTDB)){
1401                                 if (hostdata->port_db[hostdata->handle_ptrs[i]->device->id].loop_id != hostdata->port_db[0].loop_id){
1402                                         Scsi_Cmnd *Cmnd = hostdata->handle_ptrs[i];
1403
1404                                          if (Cmnd->use_sg)
1405                                                  pci_unmap_sg(hostdata->pci_dev,
1406                                                               (struct scatterlist *)Cmnd->buffer,
1407                                                               Cmnd->use_sg,
1408                                                               Cmnd->sc_data_direction);
1409                                          else if (Cmnd->request_bufflen &&
1410                                                   Cmnd->sc_data_direction != PCI_DMA_NONE) {
1411                                                  pci_unmap_page(hostdata->pci_dev,
1412                                                                 Cmnd->SCp.dma_handle,
1413                                                                 Cmnd->request_bufflen,
1414                                                                 Cmnd->sc_data_direction);
1415                                          }
1416
1417                                          hostdata->handle_ptrs[i]->result = DID_SOFT_ERROR << 16;
1418
1419                                          if (hostdata->handle_ptrs[i]->scsi_done){
1420                                            (*hostdata->handle_ptrs[i]->scsi_done) (hostdata->handle_ptrs[i]);
1421                                          }
1422                                          else printk("qlogicfc%d : done is null?\n", hostdata->host_id);
1423                                          hostdata->handle_ptrs[i] = NULL;
1424                                          hostdata->handle_serials[i] = 0;
1425                                 }
1426                         }
1427                 }
1428
1429                 hostdata->adapter_state = AS_LOOP_GOOD;
1430         }
1431
1432         spin_unlock_irqrestore(host->host_lock, flags);
1433
1434 }
1435
1436 #define ASYNC_EVENT_INTERRUPT   0x01
1437
1438 irqreturn_t do_isp2x00_intr_handler(int irq, void *dev_id, struct pt_regs *regs)
1439 {
1440         struct Scsi_Host *host = dev_id;
1441         unsigned long flags;
1442
1443         spin_lock_irqsave(host->host_lock, flags);
1444         isp2x00_intr_handler(irq, dev_id, regs);
1445         spin_unlock_irqrestore(host->host_lock, flags);
1446
1447         return IRQ_HANDLED;
1448 }
1449
1450 void isp2x00_intr_handler(int irq, void *dev_id, struct pt_regs *regs)
1451 {
1452         Scsi_Cmnd *Cmnd;
1453         struct Status_Entry *sts;
1454         struct Scsi_Host *host = dev_id;
1455         struct isp2x00_hostdata *hostdata;
1456         u_int in_ptr, out_ptr, handle, num_free;
1457         u_short status;
1458
1459         ENTER_INTR("isp2x00_intr_handler");
1460
1461         hostdata = (struct isp2x00_hostdata *) host->hostdata;
1462
1463         DEBUG_INTR(printk("qlogicfc%d : interrupt on line %d\n", hostdata->host_id, irq));
1464
1465         if (!(inw(host->io_port + PCI_INTER_STS) & 0x08)) {
1466                 /* spurious interrupts can happen legally */
1467                 DEBUG_INTR(printk("qlogicfc%d : got spurious interrupt\n", hostdata->host_id));
1468                 return;
1469         }
1470         in_ptr = inw(host->io_port + MBOX5);
1471         out_ptr = hostdata->res_out_ptr;
1472
1473         if ((inw(host->io_port + PCI_SEMAPHORE) & ASYNC_EVENT_INTERRUPT)) {
1474                 status = inw(host->io_port + MBOX0);
1475
1476                 DEBUG_INTR(printk("qlogicfc%d : mbox completion status: %x\n",
1477                                   hostdata->host_id, status));
1478
1479                 switch (status) {
1480                 case LOOP_UP:
1481                 case POINT_TO_POINT_UP:
1482                         printk("qlogicfc%d : Link is Up\n", hostdata->host_id);
1483                         hostdata->adapter_state = AS_REDO_FABRIC_PORTDB | AS_REDO_LOOP_PORTDB;
1484                         break;
1485                 case LOOP_DOWN:
1486                         printk("qlogicfc%d : Link is Down\n", hostdata->host_id);
1487                         hostdata->adapter_state = AS_LOOP_DOWN;
1488                         break;
1489                 case CONNECTION_MODE:
1490                         printk("received CONNECTION_MODE irq %x\n", inw(host->io_port + MBOX1));
1491                         break;
1492                 case CHANGE_NOTIFICATION:
1493                         printk("qlogicfc%d : RSCN Received\n", hostdata->host_id);
1494                         if (hostdata->adapter_state == AS_LOOP_GOOD)
1495                                 hostdata->adapter_state = AS_REDO_FABRIC_PORTDB;
1496                         break;
1497                 case LIP_OCCURRED:
1498                 case LIP_RECEIVED:
1499                         printk("qlogicfc%d : Loop Reinitialized\n", hostdata->host_id);
1500                         if (hostdata->adapter_state == AS_LOOP_GOOD)
1501                                 hostdata->adapter_state = AS_REDO_LOOP_PORTDB;
1502                         break;
1503                 case SYSTEM_ERROR:
1504                         printk("qlogicfc%d : The firmware just choked.\n", hostdata->host_id);
1505                         hostdata->adapter_state = AS_FIRMWARE_DEAD;
1506                         break;
1507                 case SCSI_COMMAND_COMPLETE:
1508                         handle = inw(host->io_port + MBOX1) | (inw(host->io_port + MBOX2) << 16);
1509                         Cmnd = hostdata->handle_ptrs[handle];
1510                         hostdata->handle_ptrs[handle] = NULL;
1511                         hostdata->handle_serials[handle] = 0;
1512                         hostdata->queued--;
1513                         if (Cmnd != NULL) {
1514                                 if (Cmnd->use_sg)
1515                                         pci_unmap_sg(hostdata->pci_dev,
1516                                                      (struct scatterlist *)Cmnd->buffer,
1517                                                      Cmnd->use_sg,
1518                                                      Cmnd->sc_data_direction);
1519                                 else if (Cmnd->request_bufflen &&
1520                                          Cmnd->sc_data_direction != PCI_DMA_NONE)
1521                                         pci_unmap_page(hostdata->pci_dev,
1522                                                        Cmnd->SCp.dma_handle,
1523                                                        Cmnd->request_bufflen,
1524                                                        Cmnd->sc_data_direction);
1525                                 Cmnd->result = 0x0;
1526                                 (*Cmnd->scsi_done) (Cmnd);
1527                         } else
1528                                 printk("qlogicfc%d.c : got a null value out of handle_ptrs, this sucks\n", hostdata->host_id);
1529                         break;
1530                 case MBOX_COMMAND_COMPLETE:
1531                 case INVALID_COMMAND:
1532                 case HOST_INTERFACE_ERROR:
1533                 case TEST_FAILED:
1534                 case COMMAND_ERROR:
1535                 case COMMAND_PARAM_ERROR:
1536                 case PORT_ID_USED:
1537                 case LOOP_ID_USED:
1538                 case ALL_IDS_USED:
1539                         hostdata->mbox_done = 1;
1540                         outw(HCCR_CLEAR_RISC_INTR, host->io_port + HOST_HCCR);
1541                         return;
1542                 default:
1543                         printk("qlogicfc%d : got an unknown status? %x\n", hostdata->host_id, status);
1544                 }
1545                 if ((hostdata->adapter_state & AS_REDO_LOOP_PORTDB || hostdata->adapter_state & AS_REDO_FABRIC_PORTDB) && hostdata->explore_timer.data == 0){
1546                         hostdata->explore_timer.function = redo_port_db;
1547                         hostdata->explore_timer.data = (unsigned long)host;
1548                         hostdata->explore_timer.expires = jiffies + (HZ/4);
1549                         init_timer(&hostdata->explore_timer);
1550                         add_timer(&hostdata->explore_timer);
1551                 }
1552                 outw(0x0, host->io_port + PCI_SEMAPHORE);
1553         } else {
1554                 DEBUG_INTR(printk("qlogicfc%d : response queue update\n", hostdata->host_id));
1555                 DEBUG_INTR(printk("qlogicfc%d : response queue depth %d\n", hostdata->host_id, RES_QUEUE_DEPTH(in_ptr, out_ptr)));
1556
1557                 while (out_ptr != in_ptr) {
1558                         unsigned le_hand;
1559                         sts = (struct Status_Entry *) &hostdata->res[out_ptr*QUEUE_ENTRY_LEN];
1560                         out_ptr = (out_ptr + 1) & RES_QUEUE_LEN;
1561
1562                         TRACE("done", out_ptr, Cmnd);
1563                         DEBUG_INTR(isp2x00_print_status_entry(sts));
1564                         le_hand = le32_to_cpu(sts->handle);
1565                         if (sts->hdr.entry_type == ENTRY_STATUS && (Cmnd = hostdata->handle_ptrs[le_hand])) {
1566                                 Cmnd->result = isp2x00_return_status(Cmnd, sts);
1567                                 hostdata->queued--;
1568
1569                                 if (Cmnd->use_sg)
1570                                         pci_unmap_sg(hostdata->pci_dev,
1571                                                      (struct scatterlist *)Cmnd->buffer, Cmnd->use_sg,
1572                                                      Cmnd->sc_data_direction);
1573                                 else if (Cmnd->request_bufflen && Cmnd->sc_data_direction != PCI_DMA_NONE)
1574                                         pci_unmap_page(hostdata->pci_dev,
1575                                                        Cmnd->SCp.dma_handle,
1576                                                        Cmnd->request_bufflen,
1577                                                        Cmnd->sc_data_direction);
1578
1579                                 /*
1580                                  * if any of the following are true we do not
1581                                  * call scsi_done.  if the status is CS_ABORTED
1582                                  * we don't have to call done because the upper
1583                                  * level should already know its aborted.
1584                                  */
1585                                 if (hostdata->handle_serials[le_hand] != Cmnd->serial_number
1586                                     || le16_to_cpu(sts->completion_status) == CS_ABORTED){
1587                                         hostdata->handle_serials[le_hand] = 0;
1588                                         hostdata->handle_ptrs[le_hand] = NULL;
1589                                         outw(out_ptr, host->io_port + MBOX5);
1590                                         continue;
1591                                 }
1592                                 /*
1593                                  * if we get back an error indicating the port
1594                                  * is not there or if the link is down and
1595                                  * this is a device that used to be there
1596                                  * allow the command to timeout.
1597                                  * the device may well be back in a couple of
1598                                  * seconds.
1599                                  */
1600                                 if ((hostdata->adapter_state == AS_LOOP_DOWN || sts->completion_status == cpu_to_le16(CS_PORT_UNAVAILABLE) || sts->completion_status == cpu_to_le16(CS_PORT_LOGGED_OUT) || sts->completion_status == cpu_to_le16(CS_PORT_CONFIG_CHANGED)) && hostdata->port_db[Cmnd->device->id].wwn){
1601                                         outw(out_ptr, host->io_port + MBOX5);
1602                                         continue;
1603                                 }
1604                         } else {
1605                                 outw(out_ptr, host->io_port + MBOX5);
1606                                 continue;
1607                         }
1608
1609                         hostdata->handle_ptrs[le_hand] = NULL;
1610
1611                         if (sts->completion_status == cpu_to_le16(CS_RESET_OCCURRED)
1612                             || (sts->status_flags & cpu_to_le16(STF_BUS_RESET)))
1613                                 hostdata->send_marker = 1;
1614
1615                         if (le16_to_cpu(sts->scsi_status) & 0x0200)
1616                                 memcpy(Cmnd->sense_buffer, sts->req_sense_data,
1617                                        sizeof(Cmnd->sense_buffer));
1618
1619                         outw(out_ptr, host->io_port + MBOX5);
1620
1621                         if (Cmnd->scsi_done != NULL) {
1622                                 (*Cmnd->scsi_done) (Cmnd);
1623                         } else
1624                                 printk("qlogicfc%d : Ouch, scsi done is NULL\n", hostdata->host_id);
1625                 }
1626                 hostdata->res_out_ptr = out_ptr;
1627         }
1628
1629
1630         out_ptr = inw(host->io_port + MBOX4);
1631         in_ptr = hostdata->req_in_ptr;
1632
1633         num_free = QLOGICFC_REQ_QUEUE_LEN - REQ_QUEUE_DEPTH(in_ptr, out_ptr);
1634         num_free = (num_free > 2) ? num_free - 2 : 0;
1635        host->can_queue = host->host_busy + num_free;
1636         if (host->can_queue > QLOGICFC_REQ_QUEUE_LEN)
1637                 host->can_queue = QLOGICFC_REQ_QUEUE_LEN;
1638         host->sg_tablesize = QLOGICFC_MAX_SG(num_free);
1639
1640         outw(HCCR_CLEAR_RISC_INTR, host->io_port + HOST_HCCR);
1641         LEAVE_INTR("isp2x00_intr_handler");
1642 }
1643
1644
1645 static int isp2x00_return_status(Scsi_Cmnd *Cmnd, struct Status_Entry *sts)
1646 {
1647         int host_status = DID_ERROR;
1648 #if DEBUG_ISP2x00_INTR
1649         static char *reason[] =
1650         {
1651                 "DID_OK",
1652                 "DID_NO_CONNECT",
1653                 "DID_BUS_BUSY",
1654                 "DID_TIME_OUT",
1655                 "DID_BAD_TARGET",
1656                 "DID_ABORT",
1657                 "DID_PARITY",
1658                 "DID_ERROR",
1659                 "DID_RESET",
1660                 "DID_BAD_INTR"
1661         };
1662 #endif                          /* DEBUG_ISP2x00_INTR */
1663
1664         ENTER("isp2x00_return_status");
1665
1666         DEBUG(printk("qlogicfc : completion status = 0x%04x\n",
1667                      le16_to_cpu(sts->completion_status)));
1668
1669         switch (le16_to_cpu(sts->completion_status)) {
1670         case CS_COMPLETE:
1671                 host_status = DID_OK;
1672                 break;
1673         case CS_DMA_ERROR:
1674                 host_status = DID_ERROR;
1675                 break;
1676         case CS_RESET_OCCURRED:
1677                 host_status = DID_RESET;
1678                 break;
1679         case CS_ABORTED:
1680                 host_status = DID_ABORT;
1681                 break;
1682         case CS_TIMEOUT:
1683                 host_status = DID_TIME_OUT;
1684                 break;
1685         case CS_DATA_OVERRUN:
1686                 host_status = DID_ERROR;
1687                 break;
1688         case CS_DATA_UNDERRUN:
1689                 if (Cmnd->underflow <= (Cmnd->request_bufflen - le32_to_cpu(sts->residual)))
1690                         host_status = DID_OK;
1691                 else
1692                         host_status = DID_ERROR;
1693                 break;
1694         case CS_PORT_UNAVAILABLE:
1695         case CS_PORT_LOGGED_OUT:
1696         case CS_PORT_CONFIG_CHANGED:
1697                 host_status = DID_BAD_TARGET;
1698                 break;
1699         case CS_QUEUE_FULL:
1700                 host_status = DID_ERROR;
1701                 break;
1702         default:
1703                 printk("qlogicfc : unknown completion status 0x%04x\n",
1704                        le16_to_cpu(sts->completion_status));
1705                 host_status = DID_ERROR;
1706                 break;
1707         }
1708
1709         DEBUG_INTR(printk("qlogicfc : host status (%s) scsi status %x\n",
1710                           reason[host_status], le16_to_cpu(sts->scsi_status)));
1711
1712         LEAVE("isp2x00_return_status");
1713
1714         return (le16_to_cpu(sts->scsi_status) & STATUS_MASK) | (host_status << 16);
1715 }
1716
1717
1718 static int isp2x00_abort(Scsi_Cmnd * Cmnd)
1719 {
1720         u_short param[8];
1721         int i;
1722         struct Scsi_Host *host;
1723         struct isp2x00_hostdata *hostdata;
1724         int return_status = SUCCESS;
1725
1726         ENTER("isp2x00_abort");
1727
1728         host = Cmnd->device->host;
1729         hostdata = (struct isp2x00_hostdata *) host->hostdata;
1730
1731         for (i = 0; i < QLOGICFC_REQ_QUEUE_LEN; i++)
1732                 if (hostdata->handle_ptrs[i] == Cmnd)
1733                         break;
1734
1735         if (i == QLOGICFC_REQ_QUEUE_LEN){
1736                 return SUCCESS;
1737         }
1738
1739         isp2x00_disable_irqs(host);
1740
1741         param[0] = MBOX_ABORT_IOCB;
1742 #if ISP2x00_PORTDB
1743         param[1] = (((u_short) hostdata->port_db[Cmnd->device->id].loop_id) << 8) | Cmnd->device->lun;
1744 #else
1745         param[1] = (((u_short) Cmnd->target) << 8) | Cmnd->lun;
1746 #endif
1747         param[2] = i & 0xffff;
1748         param[3] = i >> 16;
1749
1750         isp2x00_mbox_command(host, param);
1751
1752         if (param[0] != MBOX_COMMAND_COMPLETE) {
1753                 printk("qlogicfc%d : scsi abort failure: %x\n", hostdata->host_id, param[0]);
1754                 if (param[0] == 0x4005)
1755                         Cmnd->result = DID_ERROR << 16;
1756                 if (param[0] == 0x4006)
1757                         Cmnd->result = DID_BAD_TARGET << 16;
1758                 return_status = FAILED;
1759         }
1760
1761         if (return_status != SUCCESS){
1762                 param[0] = MBOX_GET_FIRMWARE_STATE;
1763                 isp2x00_mbox_command(host, param);
1764                 printk("qlogicfc%d : abort failed\n", hostdata->host_id);
1765                 printk("qlogicfc%d : firmware status is %x %x\n", hostdata->host_id, param[0], param[1]);
1766         }
1767
1768         isp2x00_enable_irqs(host);
1769
1770         LEAVE("isp2x00_abort");
1771
1772         return return_status;
1773 }
1774
1775
1776 static int isp2x00_biosparam(struct scsi_device *sdev, struct block_device *n,
1777                 sector_t capacity, int ip[])
1778 {
1779         int size = capacity;
1780
1781         ENTER("isp2x00_biosparam");
1782
1783         ip[0] = 64;
1784         ip[1] = 32;
1785         ip[2] = size >> 11;
1786         if (ip[2] > 1024) {
1787                 ip[0] = 255;
1788                 ip[1] = 63;
1789                 ip[2] = size / (ip[0] * ip[1]);
1790         }
1791         LEAVE("isp2x00_biosparam");
1792
1793         return 0;
1794 }
1795
1796 static int isp2x00_reset_hardware(struct Scsi_Host *host)
1797 {
1798         u_short param[8];
1799         struct isp2x00_hostdata *hostdata;
1800         int loop_count;
1801         dma_addr_t busaddr;
1802
1803         ENTER("isp2x00_reset_hardware");
1804
1805         hostdata = (struct isp2x00_hostdata *) host->hostdata;
1806
1807         /*
1808          *      This cannot be right - PCI writes are posted
1809          *      (apparently this is hardware design flaw not software ?)
1810          */
1811
1812         outw(0x01, host->io_port + ISP_CTRL_STATUS);
1813         udelay(100);
1814         outw(HCCR_RESET, host->io_port + HOST_HCCR);
1815         udelay(100);
1816         outw(HCCR_RELEASE, host->io_port + HOST_HCCR);
1817         outw(HCCR_BIOS_DISABLE, host->io_port + HOST_HCCR);
1818
1819         loop_count = DEFAULT_LOOP_COUNT;
1820         while (--loop_count && inw(host->io_port + HOST_HCCR) == RISC_BUSY) {
1821                 barrier();
1822                 cpu_relax();
1823         }
1824         if (!loop_count)
1825                 printk("qlogicfc%d : reset_hardware loop timeout\n", hostdata->host_id);
1826
1827
1828
1829 #if DEBUG_ISP2x00
1830         printk("qlogicfc%d : mbox 0 0x%04x \n", hostdata->host_id,  inw(host->io_port + MBOX0));
1831         printk("qlogicfc%d : mbox 1 0x%04x \n", hostdata->host_id,  inw(host->io_port + MBOX1));
1832         printk("qlogicfc%d : mbox 2 0x%04x \n", hostdata->host_id,  inw(host->io_port + MBOX2));
1833         printk("qlogicfc%d : mbox 3 0x%04x \n", hostdata->host_id,  inw(host->io_port + MBOX3));
1834         printk("qlogicfc%d : mbox 4 0x%04x \n", hostdata->host_id,  inw(host->io_port + MBOX4));
1835         printk("qlogicfc%d : mbox 5 0x%04x \n", hostdata->host_id,  inw(host->io_port + MBOX5));
1836         printk("qlogicfc%d : mbox 6 0x%04x \n", hostdata->host_id,  inw(host->io_port + MBOX6));
1837         printk("qlogicfc%d : mbox 7 0x%04x \n", hostdata->host_id,  inw(host->io_port + MBOX7));
1838 #endif                          /* DEBUG_ISP2x00 */
1839
1840         DEBUG(printk("qlogicfc%d : verifying checksum\n", hostdata->host_id));
1841
1842 #if defined(CONFIG_SCSI_QLOGIC_FC_FIRMWARE)
1843         {
1844                 int i;
1845                 unsigned short * risc_code = NULL;
1846                 unsigned short risc_code_len = 0;
1847                 if (hostdata->pci_dev->device == PCI_DEVICE_ID_QLOGIC_ISP2100){
1848                         risc_code = risc_code2100;
1849                         risc_code_len = risc_code_length2100;
1850                 }
1851                 else if (hostdata->pci_dev->device == PCI_DEVICE_ID_QLOGIC_ISP2200){
1852                         risc_code = risc_code2200;
1853                         risc_code_len = risc_code_length2200;
1854                 }
1855
1856                 for (i = 0; i < risc_code_len; i++) {
1857                         param[0] = MBOX_WRITE_RAM_WORD;
1858                         param[1] = risc_code_addr01 + i;
1859                         param[2] = risc_code[i];
1860
1861                         isp2x00_mbox_command(host, param);
1862
1863                         if (param[0] != MBOX_COMMAND_COMPLETE) {
1864                                 printk("qlogicfc%d : firmware load failure\n", hostdata->host_id);
1865                                 return 1;
1866                         }
1867                 }
1868         }
1869 #endif                          /* RELOAD_FIRMWARE */
1870
1871         param[0] = MBOX_VERIFY_CHECKSUM;
1872         param[1] = risc_code_addr01;
1873
1874         isp2x00_mbox_command(host, param);
1875
1876         if (param[0] != MBOX_COMMAND_COMPLETE) {
1877                 printk("qlogicfc%d : ram checksum failure\n", hostdata->host_id);
1878                 return 1;
1879         }
1880         DEBUG(printk("qlogicfc%d : executing firmware\n", hostdata->host_id));
1881
1882         param[0] = MBOX_EXEC_FIRMWARE;
1883         param[1] = risc_code_addr01;
1884
1885         isp2x00_mbox_command(host, param);
1886
1887         param[0] = MBOX_ABOUT_FIRMWARE;
1888
1889         isp2x00_mbox_command(host, param);
1890
1891         if (param[0] != MBOX_COMMAND_COMPLETE) {
1892                 printk("qlogicfc%d : about firmware failure\n", hostdata->host_id);
1893                 return 1;
1894         }
1895         DEBUG(printk("qlogicfc%d : firmware major revision %d\n", hostdata->host_id,  param[1]));
1896         DEBUG(printk("qlogicfc%d : firmware minor revision %d\n", hostdata->host_id,  param[2]));
1897
1898 #ifdef USE_NVRAM_DEFAULTS
1899
1900         if (isp2x00_get_nvram_defaults(host, &hostdata->control_block) != 0) {
1901                 printk("qlogicfc%d : Could not read from NVRAM\n", hostdata->host_id);
1902         }
1903 #endif
1904
1905         hostdata->wwn = (u64) (cpu_to_le16(hostdata->control_block.node_name[0])) << 56;
1906         hostdata->wwn |= (u64) (cpu_to_le16(hostdata->control_block.node_name[0]) & 0xff00) << 48;
1907         hostdata->wwn |= (u64) (cpu_to_le16(hostdata->control_block.node_name[1]) & 0xff00) << 24;
1908         hostdata->wwn |= (u64) (cpu_to_le16(hostdata->control_block.node_name[1]) & 0x00ff) << 48;
1909         hostdata->wwn |= (u64) (cpu_to_le16(hostdata->control_block.node_name[2]) & 0x00ff) << 24;
1910         hostdata->wwn |= (u64) (cpu_to_le16(hostdata->control_block.node_name[2]) & 0xff00) << 8;
1911         hostdata->wwn |= (u64) (cpu_to_le16(hostdata->control_block.node_name[3]) & 0x00ff) << 8;
1912         hostdata->wwn |= (u64) (cpu_to_le16(hostdata->control_block.node_name[3]) & 0xff00) >> 8;
1913
1914         /* FIXME: If the DMA transfer goes one way only, this should use
1915          *        PCI_DMA_TODEVICE and below as well.
1916          */
1917         busaddr = pci_map_page(hostdata->pci_dev,
1918                                virt_to_page(&hostdata->control_block),
1919                                offset_in_page(&hostdata->control_block),
1920                                sizeof(hostdata->control_block),
1921                                PCI_DMA_BIDIRECTIONAL);
1922
1923         param[0] = MBOX_INIT_FIRMWARE;
1924         param[2] = (u_short) (pci64_dma_lo32(busaddr) >> 16);
1925         param[3] = (u_short) (pci64_dma_lo32(busaddr) & 0xffff);
1926         param[4] = 0;
1927         param[5] = 0;
1928         param[6] = (u_short) (pci64_dma_hi32(busaddr) >> 16);
1929         param[7] = (u_short) (pci64_dma_hi32(busaddr) & 0xffff);
1930         isp2x00_mbox_command(host, param);
1931         if (param[0] != MBOX_COMMAND_COMPLETE) {
1932                 printk("qlogicfc%d.c: Ouch 0x%04x\n", hostdata->host_id,  param[0]);
1933                 pci_unmap_page(hostdata->pci_dev, busaddr,
1934                                sizeof(hostdata->control_block),
1935                                PCI_DMA_BIDIRECTIONAL);
1936                 return 1;
1937         }
1938         param[0] = MBOX_GET_FIRMWARE_STATE;
1939         isp2x00_mbox_command(host, param);
1940         if (param[0] != MBOX_COMMAND_COMPLETE) {
1941                 printk("qlogicfc%d.c: 0x%04x\n", hostdata->host_id,  param[0]);
1942                 pci_unmap_page(hostdata->pci_dev, busaddr,
1943                                sizeof(hostdata->control_block),
1944                                PCI_DMA_BIDIRECTIONAL);
1945                 return 1;
1946         }
1947
1948         pci_unmap_page(hostdata->pci_dev, busaddr,
1949                        sizeof(hostdata->control_block),
1950                        PCI_DMA_BIDIRECTIONAL);
1951         LEAVE("isp2x00_reset_hardware");
1952
1953         return 0;
1954 }
1955
1956 #ifdef USE_NVRAM_DEFAULTS
1957
1958 static int isp2x00_get_nvram_defaults(struct Scsi_Host *host, struct init_cb *control_block)
1959 {
1960
1961         u_short value;
1962         if (isp2x00_read_nvram_word(host, 0) != 0x5349)
1963                 return 1;
1964
1965         value = isp2x00_read_nvram_word(host, 8);
1966         control_block->node_name[0] = cpu_to_le16(isp2x00_read_nvram_word(host, 9));
1967         control_block->node_name[1] = cpu_to_le16(isp2x00_read_nvram_word(host, 10));
1968         control_block->node_name[2] = cpu_to_le16(isp2x00_read_nvram_word(host, 11));
1969         control_block->node_name[3] = cpu_to_le16(isp2x00_read_nvram_word(host, 12));
1970         control_block->hard_addr = cpu_to_le16(isp2x00_read_nvram_word(host, 13));
1971
1972         return 0;
1973
1974 }
1975
1976 #endif
1977
1978 static int isp2x00_init(struct Scsi_Host *sh)
1979 {
1980         u_long io_base;
1981         struct isp2x00_hostdata *hostdata;
1982         u_char revision;
1983         u_int irq;
1984         u_short command;
1985         struct pci_dev *pdev;
1986
1987
1988         ENTER("isp2x00_init");
1989
1990         hostdata = (struct isp2x00_hostdata *) sh->hostdata;
1991         pdev = hostdata->pci_dev;
1992
1993         if (pci_read_config_word(pdev, PCI_COMMAND, &command)
1994           || pci_read_config_byte(pdev, PCI_CLASS_REVISION, &revision)) {
1995                 printk("qlogicfc%d : error reading PCI configuration\n", hostdata->host_id);
1996                 return 1;
1997         }
1998         io_base = pci_resource_start(pdev, 0);
1999         irq = pdev->irq;
2000
2001
2002         if (pdev->vendor != PCI_VENDOR_ID_QLOGIC) {
2003                 printk("qlogicfc%d : 0x%04x is not QLogic vendor ID\n", hostdata->host_id,
2004                        pdev->vendor);
2005                 return 1;
2006         }
2007         if (pdev->device != PCI_DEVICE_ID_QLOGIC_ISP2100 && pdev->device != PCI_DEVICE_ID_QLOGIC_ISP2200) {
2008                 printk("qlogicfc%d : 0x%04x does not match ISP2100 or ISP2200 device id\n", hostdata->host_id,
2009                        pdev->device);
2010                 return 1;
2011         }
2012         if (!(command & PCI_COMMAND_IO) ||
2013             !(pdev->resource[0].flags & IORESOURCE_IO)) {
2014                 printk("qlogicfc%d : i/o mapping is disabled\n", hostdata->host_id);
2015                 return 1;
2016         }
2017
2018         pci_set_master(pdev);
2019         if (revision != ISP2100_REV_ID1 && revision != ISP2100_REV_ID3 && revision != ISP2200_REV_ID5)
2020                 printk("qlogicfc%d : new isp2x00 revision ID (%d)\n", hostdata->host_id,  revision);
2021
2022
2023         hostdata->revision = revision;
2024
2025         sh->irq = irq;
2026         sh->io_port = io_base;
2027
2028         LEAVE("isp2x00_init");
2029
2030         return 0;
2031 }
2032
2033 #if USE_NVRAM_DEFAULTS
2034
2035 #define NVRAM_DELAY() udelay(10)        /* 10 microsecond delay */
2036
2037
2038 u_short isp2x00_read_nvram_word(struct Scsi_Host * host, u_short byte)
2039 {
2040         int i;
2041         u_short value, output, input;
2042
2043         outw(0x2, host->io_port + PCI_NVRAM);
2044         NVRAM_DELAY();
2045         outw(0x3, host->io_port + PCI_NVRAM);
2046         NVRAM_DELAY();
2047
2048         byte &= 0xff;
2049         byte |= 0x0600;
2050         for (i = 10; i >= 0; i--) {
2051                 output = ((byte >> i) & 0x1) ? 0x4 : 0x0;
2052                 outw(output | 0x2, host->io_port + PCI_NVRAM);
2053                 NVRAM_DELAY();
2054                 outw(output | 0x3, host->io_port + PCI_NVRAM);
2055                 NVRAM_DELAY();
2056                 outw(output | 0x2, host->io_port + PCI_NVRAM);
2057                 NVRAM_DELAY();
2058         }
2059
2060         for (i = 0xf, value = 0; i >= 0; i--) {
2061                 value <<= 1;
2062                 outw(0x3, host->io_port + PCI_NVRAM);
2063                 NVRAM_DELAY();
2064                 input = inw(host->io_port + PCI_NVRAM);
2065                 NVRAM_DELAY();
2066                 outw(0x2, host->io_port + PCI_NVRAM);
2067                 NVRAM_DELAY();
2068                 if (input & 0x8)
2069                         value |= 1;
2070         }
2071
2072         outw(0x0, host->io_port + PCI_NVRAM);
2073         NVRAM_DELAY();
2074
2075         return value;
2076 }
2077
2078
2079 #endif                          /* USE_NVRAM_DEFAULTS */
2080
2081
2082
2083 /*
2084  * currently, this is only called during initialization or abort/reset,
2085  * at which times interrupts are disabled, so polling is OK, I guess...
2086  */
2087 static int isp2x00_mbox_command(struct Scsi_Host *host, u_short param[])
2088 {
2089         int loop_count;
2090         struct isp2x00_hostdata *hostdata = (struct isp2x00_hostdata *) host->hostdata;
2091
2092         if (mbox_param[param[0]] == 0 || hostdata->adapter_state == AS_FIRMWARE_DEAD)
2093                 return 1;
2094
2095         loop_count = DEFAULT_LOOP_COUNT;
2096         while (--loop_count && inw(host->io_port + HOST_HCCR) & 0x0080) {
2097                 barrier();
2098                 cpu_relax();
2099         }
2100         if (!loop_count) {
2101                 printk("qlogicfc%d : mbox_command loop timeout #1\n", hostdata->host_id);
2102                 param[0] = 0x4006;
2103                 hostdata->adapter_state = AS_FIRMWARE_DEAD;
2104                 return 1;
2105         }
2106         hostdata->mbox_done = 0;
2107
2108         if (mbox_param[param[0]] == 0)
2109                 printk("qlogicfc%d : invalid mbox command\n", hostdata->host_id);
2110
2111         if (mbox_param[param[0]] & 0x80)
2112                 outw(param[7], host->io_port + MBOX7);
2113         if (mbox_param[param[0]] & 0x40)
2114                 outw(param[6], host->io_port + MBOX6);
2115         if (mbox_param[param[0]] & 0x20)
2116                 outw(param[5], host->io_port + MBOX5);
2117         if (mbox_param[param[0]] & 0x10)
2118                 outw(param[4], host->io_port + MBOX4);
2119         if (mbox_param[param[0]] & 0x08)
2120                 outw(param[3], host->io_port + MBOX3);
2121         if (mbox_param[param[0]] & 0x04)
2122                 outw(param[2], host->io_port + MBOX2);
2123         if (mbox_param[param[0]] & 0x02)
2124                 outw(param[1], host->io_port + MBOX1);
2125         if (mbox_param[param[0]] & 0x01)
2126                 outw(param[0], host->io_port + MBOX0);
2127
2128
2129         outw(HCCR_SET_HOST_INTR, host->io_port + HOST_HCCR);
2130
2131         while (1) {
2132                 loop_count = DEFAULT_LOOP_COUNT;
2133                 while (--loop_count && !(inw(host->io_port + PCI_INTER_STS) & 0x08)) {
2134                         barrier();
2135                         cpu_relax();
2136                 }
2137
2138                 if (!loop_count) {
2139                         hostdata->adapter_state = AS_FIRMWARE_DEAD;
2140                         printk("qlogicfc%d : mbox_command loop timeout #2\n", hostdata->host_id);
2141                         break;
2142                 }
2143                 isp2x00_intr_handler(host->irq, host, NULL);
2144
2145                 if (hostdata->mbox_done == 1)
2146                         break;
2147
2148         }
2149
2150         loop_count = DEFAULT_LOOP_COUNT;
2151         while (--loop_count && inw(host->io_port + MBOX0) == 0x04) {
2152                 barrier();
2153                 cpu_relax();
2154         }
2155         if (!loop_count)
2156                 printk("qlogicfc%d : mbox_command loop timeout #3\n", hostdata->host_id);
2157
2158         param[7] = inw(host->io_port + MBOX7);
2159         param[6] = inw(host->io_port + MBOX6);
2160         param[5] = inw(host->io_port + MBOX5);
2161         param[4] = inw(host->io_port + MBOX4);
2162         param[3] = inw(host->io_port + MBOX3);
2163         param[2] = inw(host->io_port + MBOX2);
2164         param[1] = inw(host->io_port + MBOX1);
2165         param[0] = inw(host->io_port + MBOX0);
2166
2167
2168         outw(0x0, host->io_port + PCI_SEMAPHORE);
2169
2170         if (inw(host->io_port + HOST_HCCR) & 0x0080) {
2171                 hostdata->adapter_state = AS_FIRMWARE_DEAD;
2172                 printk("qlogicfc%d : mbox op is still pending\n", hostdata->host_id);
2173         }
2174         return 0;
2175 }
2176
2177 #if DEBUG_ISP2x00_INTR
2178
2179 void isp2x00_print_status_entry(struct Status_Entry *status)
2180 {
2181         printk("qlogicfc : entry count = 0x%02x, type = 0x%02x, flags = 0x%02x\n",
2182         status->hdr.entry_cnt, status->hdr.entry_type, status->hdr.flags);
2183         printk("qlogicfc : scsi status = 0x%04x, completion status = 0x%04x\n",
2184                le16_to_cpu(status->scsi_status), le16_to_cpu(status->completion_status));
2185         printk("qlogicfc : state flags = 0x%04x, status flags = 0x%04x\n",
2186                le16_to_cpu(status->state_flags), le16_to_cpu(status->status_flags));
2187         printk("qlogicfc : response info length = 0x%04x, request sense length = 0x%04x\n",
2188                le16_to_cpu(status->res_info_len), le16_to_cpu(status->req_sense_len));
2189         printk("qlogicfc : residual transfer length = 0x%08x, response = 0x%02x\n", le32_to_cpu(status->residual), status->res_info[3]);
2190
2191 }
2192
2193 #endif                         /* DEBUG_ISP2x00_INTR */
2194
2195
2196 #if DEBUG_ISP2x00
2197
2198 void isp2x00_print_scsi_cmd(Scsi_Cmnd * cmd)
2199 {
2200         int i;
2201
2202         printk("qlogicfc : target = 0x%02x, lun = 0x%02x, cmd_len = 0x%02x\n",
2203                cmd->target, cmd->lun, cmd->cmd_len);
2204         printk("qlogicfc : command = ");
2205         for (i = 0; i < cmd->cmd_len; i++)
2206                 printk("0x%02x ", cmd->cmnd[i]);
2207         printk("\n");
2208 }
2209
2210 #endif                          /* DEBUG_ISP2x00 */
2211
2212 MODULE_LICENSE("GPL");
2213
2214 static struct scsi_host_template driver_template = {
2215         .detect                 = isp2x00_detect,
2216         .release                = isp2x00_release,
2217         .info                   = isp2x00_info,
2218         .queuecommand           = isp2x00_queuecommand,
2219         .eh_abort_handler       = isp2x00_abort,
2220         .bios_param             = isp2x00_biosparam,
2221         .can_queue              = QLOGICFC_REQ_QUEUE_LEN,
2222         .this_id                = -1,
2223         .sg_tablesize           = QLOGICFC_MAX_SG(QLOGICFC_REQ_QUEUE_LEN),
2224         .cmd_per_lun            = QLOGICFC_CMD_PER_LUN,
2225         .use_clustering         = ENABLE_CLUSTERING,
2226 };
2227 #include "scsi_module.c"