drivers/scsi/pcmcia/nsp_cs.c

   1 /*======================================================================
   2
   3     NinjaSCSI-3 / NinjaSCSI-32Bi PCMCIA SCSI host adapter card driver
   4       By: YOKOTA Hiroshi <yokota@netlab.is.tsukuba.ac.jp>
   5
   6     Ver.2.8   Support 32bit MMIO mode
   7               Support Synchronous Data Transfer Request (SDTR) mode
   8     Ver.2.0   Support 32bit PIO mode
   9     Ver.1.1.2 Fix for scatter list buffer exceeds
  10     Ver.1.1   Support scatter list
  11     Ver.0.1   Initial version
  12
  13     This software may be used and distributed according to the terms of
  14     the GNU General Public License.
  15
  16 ======================================================================*/
  17
  18 /***********************************************************************
  19     This driver is for these PCcards.
  20
  21         I-O DATA PCSC-F  (Workbit NinjaSCSI-3)
  22                         "WBT", "NinjaSCSI-3", "R1.0"
  23         I-O DATA CBSC-II (Workbit NinjaSCSI-32Bi in 16bit mode)
  24                         "IO DATA", "CBSC16       ", "1"
  25
  26 ***********************************************************************/
  27
  28 #include <linux/module.h>
  29 #include <linux/kernel.h>
  30 #include <linux/init.h>
  31 #include <linux/slab.h>
  32 #include <linux/string.h>
  33 #include <linux/timer.h>
  34 #include <linux/ioport.h>
  35 #include <linux/delay.h>
  36 #include <linux/interrupt.h>
  37 #include <linux/major.h>
  38 #include <linux/blkdev.h>
  39 #include <linux/stat.h>
  40
  41 #include <asm/io.h>
  42 #include <asm/irq.h>
  43
  44 #include <scsi/scsi.h>
  45 #include <scsi/scsi_cmnd.h>
  46 #include <scsi/scsi_host.h>
  47 #include <scsi/scsi_ioctl.h>
  48
  49 #include <pcmcia/cistpl.h>
  50 #include <pcmcia/cisreg.h>
  51 #include <pcmcia/ds.h>
  52
  53 #include "nsp_cs.h"
  54
  55 MODULE_AUTHOR("YOKOTA Hiroshi <yokota@netlab.is.tsukuba.ac.jp>");
  56 MODULE_DESCRIPTION("WorkBit NinjaSCSI-3 / NinjaSCSI-32Bi(16bit) PCMCIA SCSI host adapter module");
  57 MODULE_LICENSE("GPL");
  58
  59 #include "nsp_io.h"
  60
  61 /*====================================================================*/
  62 /* Parameters that can be set with 'insmod' */
  63
  64 static int       nsp_burst_mode = BURST_MEM32;
  65 module_param(nsp_burst_mode, int, 0);
  66 MODULE_PARM_DESC(nsp_burst_mode, "Burst transfer mode (0=io8, 1=io32, 2=mem32(default))");
  67
  68 /* Release IO ports after configuration? */
  69 static bool       free_ports = 0;
  70 module_param(free_ports, bool, 0);
  71 MODULE_PARM_DESC(free_ports, "Release IO ports after configuration? (default: 0 (=no))");
  72
  73 static struct scsi_pointer *nsp_priv(struct scsi_cmnd *cmd)
  74 {
  75         return scsi_cmd_priv(cmd);
  76 }
  77
  78 static struct scsi_host_template nsp_driver_template = {
  79         .proc_name               = "nsp_cs",
  80         .show_info               = nsp_show_info,
  81         .name                    = "WorkBit NinjaSCSI-3/32Bi(16bit)",
  82         .info                    = nsp_info,
  83         .queuecommand            = nsp_queuecommand,
  84 /*      .eh_abort_handler        = nsp_eh_abort,*/
  85         .eh_bus_reset_handler    = nsp_eh_bus_reset,
  86         .eh_host_reset_handler   = nsp_eh_host_reset,
  87         .can_queue               = 1,
  88         .this_id                 = NSP_INITIATOR_ID,
  89         .sg_tablesize            = SG_ALL,
  90         .dma_boundary            = PAGE_SIZE - 1,
  91         .cmd_size                = sizeof(struct scsi_pointer),
  92 };
  93
  94 static nsp_hw_data nsp_data_base; /* attach <-> detect glue */
  95
  96
  97
  98 /*
  99  * debug, error print
 100  */
 101 #ifndef NSP_DEBUG
 102 # define NSP_DEBUG_MASK         0x000000
 103 # define nsp_msg(type, args...) nsp_cs_message("", 0, (type), args)
 104 # define nsp_dbg(mask, args...) /* */
 105 #else
 106 # define NSP_DEBUG_MASK         0xffffff
 107 # define nsp_msg(type, args...) \
 108         nsp_cs_message (__func__, __LINE__, (type), args)
 109 # define nsp_dbg(mask, args...) \
 110         nsp_cs_dmessage(__func__, __LINE__, (mask), args)
 111 #endif
 112
 113 #define NSP_DEBUG_QUEUECOMMAND          BIT(0)
 114 #define NSP_DEBUG_REGISTER              BIT(1)
 115 #define NSP_DEBUG_AUTOSCSI              BIT(2)
 116 #define NSP_DEBUG_INTR                  BIT(3)
 117 #define NSP_DEBUG_SGLIST                BIT(4)
 118 #define NSP_DEBUG_BUSFREE               BIT(5)
 119 #define NSP_DEBUG_CDB_CONTENTS          BIT(6)
 120 #define NSP_DEBUG_RESELECTION           BIT(7)
 121 #define NSP_DEBUG_MSGINOCCUR            BIT(8)
 122 #define NSP_DEBUG_EEPROM                BIT(9)
 123 #define NSP_DEBUG_MSGOUTOCCUR           BIT(10)
 124 #define NSP_DEBUG_BUSRESET              BIT(11)
 125 #define NSP_DEBUG_RESTART               BIT(12)
 126 #define NSP_DEBUG_SYNC                  BIT(13)
 127 #define NSP_DEBUG_WAIT                  BIT(14)
 128 #define NSP_DEBUG_TARGETFLAG            BIT(15)
 129 #define NSP_DEBUG_PROC                  BIT(16)
 130 #define NSP_DEBUG_INIT                  BIT(17)
 131 #define NSP_DEBUG_DATA_IO               BIT(18)
 132 #define NSP_SPECIAL_PRINT_REGISTER      BIT(20)
 133
 134 #define NSP_DEBUG_BUF_LEN               150
 135
 136 static inline void nsp_inc_resid(struct scsi_cmnd *SCpnt, int residInc)
 137 {
 138         scsi_set_resid(SCpnt, scsi_get_resid(SCpnt) + residInc);
 139 }
 140
 141 __printf(4, 5)
 142 static void nsp_cs_message(const char *func, int line, char *type, char *fmt, ...)
 143 {
 144         va_list args;
 145         char buf[NSP_DEBUG_BUF_LEN];
 146
 147         va_start(args, fmt);
 148         vsnprintf(buf, sizeof(buf), fmt, args);
 149         va_end(args);
 150
 151 #ifndef NSP_DEBUG
 152         printk("%snsp_cs: %s\n", type, buf);
 153 #else
 154         printk("%snsp_cs: %s (%d): %s\n", type, func, line, buf);
 155 #endif
 156 }
 157
 158 #ifdef NSP_DEBUG
 159 static void nsp_cs_dmessage(const char *func, int line, int mask, char *fmt, ...)
 160 {
 161         va_list args;
 162         char buf[NSP_DEBUG_BUF_LEN];
 163
 164         va_start(args, fmt);
 165         vsnprintf(buf, sizeof(buf), fmt, args);
 166         va_end(args);
 167
 168         if (mask & NSP_DEBUG_MASK) {
 169                 printk("nsp_cs-debug: 0x%x %s (%d): %s\n", mask, func, line, buf);
 170         }
 171 }
 172 #endif
 173
 174 /***********************************************************/
 175
 176 /*====================================================
 177  * Clenaup parameters and call done() functions.
 178  * You must be set SCpnt->result before call this function.
 179  */
 180 static void nsp_scsi_done(struct scsi_cmnd *SCpnt)
 181 {
 182         nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata;
 183
 184         data->CurrentSC = NULL;
 185
 186         scsi_done(SCpnt);
 187 }
 188
 189 static int nsp_queuecommand_lck(struct scsi_cmnd *const SCpnt)
 190 {
 191         struct scsi_pointer *scsi_pointer = nsp_priv(SCpnt);
 192 #ifdef NSP_DEBUG
 193         /*unsigned int host_id = SCpnt->device->host->this_id;*/
 194         /*unsigned int base    = SCpnt->device->host->io_port;*/
 195         unsigned char target = scmd_id(SCpnt);
 196 #endif
 197         nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata;
 198
 199         nsp_dbg(NSP_DEBUG_QUEUECOMMAND,
 200                 "SCpnt=0x%p target=%d lun=%llu sglist=0x%p bufflen=%d sg_count=%d",
 201                 SCpnt, target, SCpnt->device->lun, scsi_sglist(SCpnt),
 202                 scsi_bufflen(SCpnt), scsi_sg_count(SCpnt));
 203         //nsp_dbg(NSP_DEBUG_QUEUECOMMAND, "before CurrentSC=0x%p", data->CurrentSC);
 204
 205         if (data->CurrentSC != NULL) {
 206                 nsp_msg(KERN_DEBUG, "CurrentSC!=NULL this can't be happen");
 207                 SCpnt->result   = DID_BAD_TARGET << 16;
 208                 nsp_scsi_done(SCpnt);
 209                 return 0;
 210         }
 211
 212 #if 0
 213         /* XXX: pcmcia-cs generates SCSI command with "scsi_info" utility.
 214                 This makes kernel crash when suspending... */
 215         if (data->ScsiInfo->stop != 0) {
 216                 nsp_msg(KERN_INFO, "suspending device. reject command.");
 217                 SCpnt->result  = DID_BAD_TARGET << 16;
 218                 nsp_scsi_done(SCpnt);
 219                 return SCSI_MLQUEUE_HOST_BUSY;
 220         }
 221 #endif
 222
 223         show_command(SCpnt);
 224
 225         data->CurrentSC         = SCpnt;
 226
 227         scsi_pointer->Status       = SAM_STAT_CHECK_CONDITION;
 228         scsi_pointer->Message      = 0;
 229         scsi_pointer->have_data_in = IO_UNKNOWN;
 230         scsi_pointer->sent_command = 0;
 231         scsi_pointer->phase        = PH_UNDETERMINED;
 232         scsi_set_resid(SCpnt, scsi_bufflen(SCpnt));
 233
 234         /* setup scratch area
 235            SCp.ptr              : buffer pointer
 236            SCp.this_residual    : buffer length
 237            SCp.buffer           : next buffer
 238            SCp.buffers_residual : left buffers in list
 239            SCp.phase            : current state of the command */
 240         if (scsi_bufflen(SCpnt)) {
 241                 scsi_pointer->buffer           = scsi_sglist(SCpnt);
 242                 scsi_pointer->ptr              = BUFFER_ADDR(SCpnt);
 243                 scsi_pointer->this_residual    = scsi_pointer->buffer->length;
 244                 scsi_pointer->buffers_residual = scsi_sg_count(SCpnt) - 1;
 245         } else {
 246                 scsi_pointer->ptr              = NULL;
 247                 scsi_pointer->this_residual    = 0;
 248                 scsi_pointer->buffer           = NULL;
 249                 scsi_pointer->buffers_residual = 0;
 250         }
 251
 252         if (!nsphw_start_selection(SCpnt)) {
 253                 nsp_dbg(NSP_DEBUG_QUEUECOMMAND, "selection fail");
 254                 SCpnt->result   = DID_BUS_BUSY << 16;
 255                 nsp_scsi_done(SCpnt);
 256                 return 0;
 257         }
 258
 259
 260         //nsp_dbg(NSP_DEBUG_QUEUECOMMAND, "out");
 261 #ifdef NSP_DEBUG
 262         data->CmdId++;
 263 #endif
 264         return 0;
 265 }
 266
 267 static DEF_SCSI_QCMD(nsp_queuecommand)
 268
 269 /*
 270  * setup PIO FIFO transfer mode and enable/disable to data out
 271  */
 272 static void nsp_setup_fifo(nsp_hw_data *data, bool enabled)
 273 {
 274         unsigned int  base = data->BaseAddress;
 275         unsigned char transfer_mode_reg;
 276
 277         //nsp_dbg(NSP_DEBUG_DATA_IO, "enabled=%d", enabled);
 278
 279         if (enabled) {
 280                 transfer_mode_reg = TRANSFER_GO | BRAIND;
 281         } else {
 282                 transfer_mode_reg = 0;
 283         }
 284
 285         transfer_mode_reg |= data->TransferMode;
 286
 287         nsp_index_write(base, TRANSFERMODE, transfer_mode_reg);
 288 }
 289
 290 static void nsphw_init_sync(nsp_hw_data *data)
 291 {
 292         sync_data tmp_sync = { .SyncNegotiation = SYNC_NOT_YET,
 293                                .SyncPeriod      = 0,
 294                                .SyncOffset      = 0
 295         };
 296         int i;
 297
 298         /* setup sync data */
 299         for ( i = 0; i < ARRAY_SIZE(data->Sync); i++ ) {
 300                 data->Sync[i] = tmp_sync;
 301         }
 302 }
 303
 304 /*
 305  * Initialize Ninja hardware
 306  */
 307 static void nsphw_init(nsp_hw_data *data)
 308 {
 309         unsigned int base     = data->BaseAddress;
 310
 311         nsp_dbg(NSP_DEBUG_INIT, "in base=0x%x", base);
 312
 313         data->ScsiClockDiv = CLOCK_40M | FAST_20;
 314         data->CurrentSC    = NULL;
 315         data->FifoCount    = 0;
 316         data->TransferMode = MODE_IO8;
 317
 318         nsphw_init_sync(data);
 319
 320         /* block all interrupts */
 321         nsp_write(base,       IRQCONTROL,   IRQCONTROL_ALLMASK);
 322
 323         /* setup SCSI interface */
 324         nsp_write(base,       IFSELECT,     IF_IFSEL);
 325
 326         nsp_index_write(base, SCSIIRQMODE,  0);
 327
 328         nsp_index_write(base, TRANSFERMODE, MODE_IO8);
 329         nsp_index_write(base, CLOCKDIV,     data->ScsiClockDiv);
 330
 331         nsp_index_write(base, PARITYCTRL,   0);
 332         nsp_index_write(base, POINTERCLR,   POINTER_CLEAR     |
 333                                             ACK_COUNTER_CLEAR |
 334                                             REQ_COUNTER_CLEAR |
 335                                             HOST_COUNTER_CLEAR);
 336
 337         /* setup fifo asic */
 338         nsp_write(base,       IFSELECT,     IF_REGSEL);
 339         nsp_index_write(base, TERMPWRCTRL,  0);
 340         if ((nsp_index_read(base, OTHERCONTROL) & TPWR_SENSE) == 0) {
 341                 nsp_msg(KERN_INFO, "terminator power on");
 342                 nsp_index_write(base, TERMPWRCTRL, POWER_ON);
 343         }
 344
 345         nsp_index_write(base, TIMERCOUNT,   0);
 346         nsp_index_write(base, TIMERCOUNT,   0); /* requires 2 times!! */
 347
 348         nsp_index_write(base, SYNCREG,      0);
 349         nsp_index_write(base, ACKWIDTH,     0);
 350
 351         /* enable interrupts and ack them */
 352         nsp_index_write(base, SCSIIRQMODE,  SCSI_PHASE_CHANGE_EI |
 353                                             RESELECT_EI          |
 354                                             SCSI_RESET_IRQ_EI    );
 355         nsp_write(base,       IRQCONTROL,   IRQCONTROL_ALLCLEAR);
 356
 357         nsp_setup_fifo(data, false);
 358 }
 359
 360 /*
 361  * Start selection phase
 362  */
 363 static bool nsphw_start_selection(struct scsi_cmnd *const SCpnt)
 364 {
 365         struct scsi_pointer *scsi_pointer = nsp_priv(SCpnt);
 366         unsigned int  host_id    = SCpnt->device->host->this_id;
 367         unsigned int  base       = SCpnt->device->host->io_port;
 368         unsigned char target     = scmd_id(SCpnt);
 369         nsp_hw_data  *data = (nsp_hw_data *)SCpnt->device->host->hostdata;
 370         int           time_out;
 371         unsigned char phase, arbit;
 372
 373         //nsp_dbg(NSP_DEBUG_RESELECTION, "in");
 374
 375         phase = nsp_index_read(base, SCSIBUSMON);
 376         if(phase != BUSMON_BUS_FREE) {
 377                 //nsp_dbg(NSP_DEBUG_RESELECTION, "bus busy");
 378                 return false;
 379         }
 380
 381         /* start arbitration */
 382         //nsp_dbg(NSP_DEBUG_RESELECTION, "start arbit");
 383         scsi_pointer->phase = PH_ARBSTART;
 384         nsp_index_write(base, SETARBIT, ARBIT_GO);
 385
 386         time_out = 1000;
 387         do {
 388                 /* XXX: what a stupid chip! */
 389                 arbit = nsp_index_read(base, ARBITSTATUS);
 390                 //nsp_dbg(NSP_DEBUG_RESELECTION, "arbit=%d, wait_count=%d", arbit, wait_count);
 391                 udelay(1); /* hold 1.2us */
 392         } while((arbit & (ARBIT_WIN | ARBIT_FAIL)) == 0 &&
 393                 (time_out-- != 0));
 394
 395         if (!(arbit & ARBIT_WIN)) {
 396                 //nsp_dbg(NSP_DEBUG_RESELECTION, "arbit fail");
 397                 nsp_index_write(base, SETARBIT, ARBIT_FLAG_CLEAR);
 398                 return false;
 399         }
 400
 401         /* assert select line */
 402         //nsp_dbg(NSP_DEBUG_RESELECTION, "assert SEL line");
 403         scsi_pointer->phase = PH_SELSTART;
 404         udelay(3); /* wait 2.4us */
 405         nsp_index_write(base, SCSIDATALATCH, BIT(host_id) | BIT(target));
 406         nsp_index_write(base, SCSIBUSCTRL,   SCSI_SEL | SCSI_BSY                    | SCSI_ATN);
 407         udelay(2); /* wait >1.2us */
 408         nsp_index_write(base, SCSIBUSCTRL,   SCSI_SEL | SCSI_BSY | SCSI_DATAOUT_ENB | SCSI_ATN);
 409         nsp_index_write(base, SETARBIT,      ARBIT_FLAG_CLEAR);
 410         /*udelay(1);*/ /* wait >90ns */
 411         nsp_index_write(base, SCSIBUSCTRL,   SCSI_SEL            | SCSI_DATAOUT_ENB | SCSI_ATN);
 412
 413         /* check selection timeout */
 414         nsp_start_timer(SCpnt, 1000/51);
 415         data->SelectionTimeOut = 1;
 416
 417         return true;
 418 }
 419
 420 struct nsp_sync_table {
 421         unsigned int min_period;
 422         unsigned int max_period;
 423         unsigned int chip_period;
 424         unsigned int ack_width;
 425 };
 426
 427 static struct nsp_sync_table nsp_sync_table_40M[] = {
 428         {0x0c, 0x0c, 0x1, 0},   /* 20MB   50ns*/
 429         {0x19, 0x19, 0x3, 1},   /* 10MB  100ns*/
 430         {0x1a, 0x25, 0x5, 2},   /* 7.5MB 150ns*/
 431         {0x26, 0x32, 0x7, 3},   /* 5MB   200ns*/
 432         {   0,    0,   0, 0},
 433 };
 434
 435 static struct nsp_sync_table nsp_sync_table_20M[] = {
 436         {0x19, 0x19, 0x1, 0},   /* 10MB  100ns*/
 437         {0x1a, 0x25, 0x2, 0},   /* 7.5MB 150ns*/
 438         {0x26, 0x32, 0x3, 1},   /* 5MB   200ns*/
 439         {   0,    0,   0, 0},
 440 };
 441
 442 /*
 443  * setup synchronous data transfer mode
 444  */
 445 static int nsp_analyze_sdtr(struct scsi_cmnd *SCpnt)
 446 {
 447         unsigned char          target = scmd_id(SCpnt);
 448 //      unsigned char          lun    = SCpnt->device->lun;
 449         nsp_hw_data           *data   = (nsp_hw_data *)SCpnt->device->host->hostdata;
 450         sync_data             *sync   = &(data->Sync[target]);
 451         struct nsp_sync_table *sync_table;
 452         unsigned int           period, offset;
 453         int                    i;
 454
 455
 456         nsp_dbg(NSP_DEBUG_SYNC, "in");
 457
 458         period = sync->SyncPeriod;
 459         offset = sync->SyncOffset;
 460
 461         nsp_dbg(NSP_DEBUG_SYNC, "period=0x%x, offset=0x%x", period, offset);
 462
 463         if ((data->ScsiClockDiv & (BIT(0)|BIT(1))) == CLOCK_20M) {
 464                 sync_table = nsp_sync_table_20M;
 465         } else {
 466                 sync_table = nsp_sync_table_40M;
 467         }
 468
 469         for ( i = 0; sync_table->max_period != 0; i++, sync_table++) {
 470                 if ( period >= sync_table->min_period &&
 471                      period <= sync_table->max_period    ) {
 472                         break;
 473                 }
 474         }
 475
 476         if (period != 0 && sync_table->max_period == 0) {
 477                 /*
 478                  * No proper period/offset found
 479                  */
 480                 nsp_dbg(NSP_DEBUG_SYNC, "no proper period/offset");
 481
 482                 sync->SyncPeriod      = 0;
 483                 sync->SyncOffset      = 0;
 484                 sync->SyncRegister    = 0;
 485                 sync->AckWidth        = 0;
 486
 487                 return false;
 488         }
 489
 490         sync->SyncRegister    = (sync_table->chip_period << SYNCREG_PERIOD_SHIFT) |
 491                                 (offset & SYNCREG_OFFSET_MASK);
 492         sync->AckWidth        = sync_table->ack_width;
 493
 494         nsp_dbg(NSP_DEBUG_SYNC, "sync_reg=0x%x, ack_width=0x%x", sync->SyncRegister, sync->AckWidth);
 495
 496         return true;
 497 }
 498
 499
 500 /*
 501  * start ninja hardware timer
 502  */
 503 static void nsp_start_timer(struct scsi_cmnd *SCpnt, int time)
 504 {
 505         unsigned int base = SCpnt->device->host->io_port;
 506         nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata;
 507
 508         //nsp_dbg(NSP_DEBUG_INTR, "in SCpnt=0x%p, time=%d", SCpnt, time);
 509         data->TimerCount = time;
 510         nsp_index_write(base, TIMERCOUNT, time);
 511 }
 512
 513 /*
 514  * wait for bus phase change
 515  */
 516 static int nsp_negate_signal(struct scsi_cmnd *SCpnt, unsigned char mask,
 517                              char *str)
 518 {
 519         unsigned int  base = SCpnt->device->host->io_port;
 520         unsigned char reg;
 521         int           time_out;
 522
 523         //nsp_dbg(NSP_DEBUG_INTR, "in");
 524
 525         time_out = 100;
 526
 527         do {
 528                 reg = nsp_index_read(base, SCSIBUSMON);
 529                 if (reg == 0xff) {
 530                         break;
 531                 }
 532         } while ((--time_out != 0) && (reg & mask) != 0);
 533
 534         if (time_out == 0) {
 535                 nsp_msg(KERN_DEBUG, " %s signal off timeout", str);
 536         }
 537
 538         return 0;
 539 }
 540
 541 /*
 542  * expect Ninja Irq
 543  */
 544 static int nsp_expect_signal(struct scsi_cmnd *SCpnt,
 545                              unsigned char current_phase,
 546                              unsigned char mask)
 547 {
 548         unsigned int  base       = SCpnt->device->host->io_port;
 549         int           time_out;
 550         unsigned char phase, i_src;
 551
 552         //nsp_dbg(NSP_DEBUG_INTR, "current_phase=0x%x, mask=0x%x", current_phase, mask);
 553
 554         time_out = 100;
 555         do {
 556                 phase = nsp_index_read(base, SCSIBUSMON);
 557                 if (phase == 0xff) {
 558                         //nsp_dbg(NSP_DEBUG_INTR, "ret -1");
 559                         return -1;
 560                 }
 561                 i_src = nsp_read(base, IRQSTATUS);
 562                 if (i_src & IRQSTATUS_SCSI) {
 563                         //nsp_dbg(NSP_DEBUG_INTR, "ret 0 found scsi signal");
 564                         return 0;
 565                 }
 566                 if ((phase & mask) != 0 && (phase & BUSMON_PHASE_MASK) == current_phase) {
 567                         //nsp_dbg(NSP_DEBUG_INTR, "ret 1 phase=0x%x", phase);
 568                         return 1;
 569                 }
 570         } while(time_out-- != 0);
 571
 572         //nsp_dbg(NSP_DEBUG_INTR, "timeout");
 573         return -1;
 574 }
 575
 576 /*
 577  * transfer SCSI message
 578  */
 579 static int nsp_xfer(struct scsi_cmnd *const SCpnt, int phase)
 580 {
 581         struct scsi_pointer *scsi_pointer = nsp_priv(SCpnt);
 582         unsigned int  base = SCpnt->device->host->io_port;
 583         nsp_hw_data  *data = (nsp_hw_data *)SCpnt->device->host->hostdata;
 584         char         *buf  = data->MsgBuffer;
 585         int           len  = min(MSGBUF_SIZE, data->MsgLen);
 586         int           ptr;
 587         int           ret;
 588
 589         //nsp_dbg(NSP_DEBUG_DATA_IO, "in");
 590         for (ptr = 0; len > 0; len--, ptr++) {
 591
 592                 ret = nsp_expect_signal(SCpnt, phase, BUSMON_REQ);
 593                 if (ret <= 0) {
 594                         nsp_dbg(NSP_DEBUG_DATA_IO, "xfer quit");
 595                         return 0;
 596                 }
 597
 598                 /* if last byte, negate ATN */
 599                 if (len == 1 && scsi_pointer->phase == PH_MSG_OUT) {
 600                         nsp_index_write(base, SCSIBUSCTRL, AUTODIRECTION | ACKENB);
 601                 }
 602
 603                 /* read & write message */
 604                 if (phase & BUSMON_IO) {
 605                         nsp_dbg(NSP_DEBUG_DATA_IO, "read msg");
 606                         buf[ptr] = nsp_index_read(base, SCSIDATAWITHACK);
 607                 } else {
 608                         nsp_dbg(NSP_DEBUG_DATA_IO, "write msg");
 609                         nsp_index_write(base, SCSIDATAWITHACK, buf[ptr]);
 610                 }
 611                 nsp_negate_signal(SCpnt, BUSMON_ACK, "xfer<ack>");
 612
 613         }
 614         return len;
 615 }
 616
 617 /*
 618  * get extra SCSI data from fifo
 619  */
 620 static int nsp_dataphase_bypass(struct scsi_cmnd *const SCpnt)
 621 {
 622         struct scsi_pointer *scsi_pointer = nsp_priv(SCpnt);
 623         nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata;
 624         unsigned int count;
 625
 626         //nsp_dbg(NSP_DEBUG_DATA_IO, "in");
 627
 628         if (scsi_pointer->have_data_in != IO_IN) {
 629                 return 0;
 630         }
 631
 632         count = nsp_fifo_count(SCpnt);
 633         if (data->FifoCount == count) {
 634                 //nsp_dbg(NSP_DEBUG_DATA_IO, "not use bypass quirk");
 635                 return 0;
 636         }
 637
 638         /*
 639          * XXX: NSP_QUIRK
 640          * data phase skip only occures in case of SCSI_LOW_READ
 641          */
 642         nsp_dbg(NSP_DEBUG_DATA_IO, "use bypass quirk");
 643         scsi_pointer->phase = PH_DATA;
 644         nsp_pio_read(SCpnt);
 645         nsp_setup_fifo(data, false);
 646
 647         return 0;
 648 }
 649
 650 /*
 651  * accept reselection
 652  */
 653 static void nsp_reselected(struct scsi_cmnd *SCpnt)
 654 {
 655         unsigned int  base    = SCpnt->device->host->io_port;
 656         unsigned int  host_id = SCpnt->device->host->this_id;
 657         //nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata;
 658         unsigned char bus_reg;
 659         unsigned char id_reg, tmp;
 660         int target;
 661
 662         nsp_dbg(NSP_DEBUG_RESELECTION, "in");
 663
 664         id_reg = nsp_index_read(base, RESELECTID);
 665         tmp    = id_reg & (~BIT(host_id));
 666         target = 0;
 667         while(tmp != 0) {
 668                 if (tmp & BIT(0)) {
 669                         break;
 670                 }
 671                 tmp >>= 1;
 672                 target++;
 673         }
 674
 675         if (scmd_id(SCpnt) != target) {
 676                 nsp_msg(KERN_ERR, "XXX: reselect ID must be %d in this implementation.", target);
 677         }
 678
 679         nsp_negate_signal(SCpnt, BUSMON_SEL, "reselect<SEL>");
 680
 681         nsp_nexus(SCpnt);
 682         bus_reg = nsp_index_read(base, SCSIBUSCTRL) & ~(SCSI_BSY | SCSI_ATN);
 683         nsp_index_write(base, SCSIBUSCTRL, bus_reg);
 684         nsp_index_write(base, SCSIBUSCTRL, bus_reg | AUTODIRECTION | ACKENB);
 685 }
 686
 687 /*
 688  * count how many data transferd
 689  */
 690 static int nsp_fifo_count(struct scsi_cmnd *SCpnt)
 691 {
 692         unsigned int base = SCpnt->device->host->io_port;
 693         unsigned int count;
 694         unsigned int l, m, h;
 695
 696         nsp_index_write(base, POINTERCLR, POINTER_CLEAR | ACK_COUNTER);
 697
 698         l     = nsp_index_read(base, TRANSFERCOUNT);
 699         m     = nsp_index_read(base, TRANSFERCOUNT);
 700         h     = nsp_index_read(base, TRANSFERCOUNT);
 701         nsp_index_read(base, TRANSFERCOUNT); /* required this! */
 702
 703         count = (h << 16) | (m << 8) | (l << 0);
 704
 705         //nsp_dbg(NSP_DEBUG_DATA_IO, "count=0x%x", count);
 706
 707         return count;
 708 }
 709
 710 /* fifo size */
 711 #define RFIFO_CRIT 64
 712 #define WFIFO_CRIT 64
 713
 714 /*
 715  * read data in DATA IN phase
 716  */
 717 static void nsp_pio_read(struct scsi_cmnd *const SCpnt)
 718 {
 719         struct scsi_pointer *scsi_pointer = nsp_priv(SCpnt);
 720         unsigned int  base      = SCpnt->device->host->io_port;
 721         unsigned long mmio_base = SCpnt->device->host->base;
 722         nsp_hw_data  *data      = (nsp_hw_data *)SCpnt->device->host->hostdata;
 723         long          time_out;
 724         int           ocount, res;
 725         unsigned char stat, fifo_stat;
 726
 727         ocount = data->FifoCount;
 728
 729         nsp_dbg(NSP_DEBUG_DATA_IO, "in SCpnt=0x%p resid=%d ocount=%d ptr=0x%p this_residual=%d buffers=0x%p nbuf=%d",
 730                 SCpnt, scsi_get_resid(SCpnt), ocount, scsi_pointer->ptr,
 731                 scsi_pointer->this_residual, scsi_pointer->buffer,
 732                 scsi_pointer->buffers_residual);
 733
 734         time_out = 1000;
 735
 736         while ((time_out-- != 0) &&
 737                (scsi_pointer->this_residual > 0 ||
 738                 scsi_pointer->buffers_residual > 0)) {
 739
 740                 stat = nsp_index_read(base, SCSIBUSMON);
 741                 stat &= BUSMON_PHASE_MASK;
 742
 743
 744                 res = nsp_fifo_count(SCpnt) - ocount;
 745                 //nsp_dbg(NSP_DEBUG_DATA_IO, "ptr=0x%p this=0x%x ocount=0x%x res=0x%x", scsi_pointer->ptr, scsi_pointer->this_residual, ocount, res);
 746                 if (res == 0) { /* if some data available ? */
 747                         if (stat == BUSPHASE_DATA_IN) { /* phase changed? */
 748                                 //nsp_dbg(NSP_DEBUG_DATA_IO, " wait for data this=%d", scsi_pointer->this_residual);
 749                                 continue;
 750                         } else {
 751                                 nsp_dbg(NSP_DEBUG_DATA_IO, "phase changed stat=0x%x", stat);
 752                                 break;
 753                         }
 754                 }
 755
 756                 fifo_stat = nsp_read(base, FIFOSTATUS);
 757                 if ((fifo_stat & FIFOSTATUS_FULL_EMPTY) == 0 &&
 758                     stat                                == BUSPHASE_DATA_IN) {
 759                         continue;
 760                 }
 761
 762                 res = min(res, scsi_pointer->this_residual);
 763
 764                 switch (data->TransferMode) {
 765                 case MODE_IO32:
 766                         res &= ~(BIT(1)|BIT(0)); /* align 4 */
 767                         nsp_fifo32_read(base, scsi_pointer->ptr, res >> 2);
 768                         break;
 769                 case MODE_IO8:
 770                         nsp_fifo8_read(base, scsi_pointer->ptr, res);
 771                         break;
 772
 773                 case MODE_MEM32:
 774                         res &= ~(BIT(1)|BIT(0)); /* align 4 */
 775                         nsp_mmio_fifo32_read(mmio_base, scsi_pointer->ptr,
 776                                              res >> 2);
 777                         break;
 778
 779                 default:
 780                         nsp_dbg(NSP_DEBUG_DATA_IO, "unknown read mode");
 781                         return;
 782                 }
 783
 784                 nsp_inc_resid(SCpnt, -res);
 785                 scsi_pointer->ptr += res;
 786                 scsi_pointer->this_residual -= res;
 787                 ocount                   += res;
 788                 //nsp_dbg(NSP_DEBUG_DATA_IO, "ptr=0x%p this_residual=0x%x ocount=0x%x", scsi_pointer->ptr, scsi_pointer->this_residual, ocount);
 789
 790                 /* go to next scatter list if available */
 791                 if (scsi_pointer->this_residual == 0 &&
 792                     scsi_pointer->buffers_residual != 0 ) {
 793                         //nsp_dbg(NSP_DEBUG_DATA_IO, "scatterlist next timeout=%d", time_out);
 794                         scsi_pointer->buffers_residual--;
 795                         scsi_pointer->buffer = sg_next(scsi_pointer->buffer);
 796                         scsi_pointer->ptr = BUFFER_ADDR(SCpnt);
 797                         scsi_pointer->this_residual =
 798                                 scsi_pointer->buffer->length;
 799                         time_out = 1000;
 800
 801                         //nsp_dbg(NSP_DEBUG_DATA_IO, "page: 0x%p, off: 0x%x", scsi_pointer->buffer->page, scsi_pointer->buffer->offset);
 802                 }
 803         }
 804
 805         data->FifoCount = ocount;
 806
 807         if (time_out < 0) {
 808                 nsp_msg(KERN_DEBUG, "pio read timeout resid=%d this_residual=%d buffers_residual=%d",
 809                         scsi_get_resid(SCpnt), scsi_pointer->this_residual,
 810                         scsi_pointer->buffers_residual);
 811         }
 812         nsp_dbg(NSP_DEBUG_DATA_IO, "read ocount=0x%x", ocount);
 813         nsp_dbg(NSP_DEBUG_DATA_IO, "r cmd=%d resid=0x%x\n", data->CmdId,
 814                                                         scsi_get_resid(SCpnt));
 815 }
 816
 817 /*
 818  * write data in DATA OUT phase
 819  */
 820 static void nsp_pio_write(struct scsi_cmnd *SCpnt)
 821 {
 822         struct scsi_pointer *scsi_pointer = nsp_priv(SCpnt);
 823         unsigned int  base      = SCpnt->device->host->io_port;
 824         unsigned long mmio_base = SCpnt->device->host->base;
 825         nsp_hw_data  *data      = (nsp_hw_data *)SCpnt->device->host->hostdata;
 826         int           time_out;
 827         int           ocount, res;
 828         unsigned char stat;
 829
 830         ocount   = data->FifoCount;
 831
 832         nsp_dbg(NSP_DEBUG_DATA_IO, "in fifocount=%d ptr=0x%p this_residual=%d buffers=0x%p nbuf=%d resid=0x%x",
 833                 data->FifoCount, scsi_pointer->ptr, scsi_pointer->this_residual,
 834                 scsi_pointer->buffer, scsi_pointer->buffers_residual,
 835                 scsi_get_resid(SCpnt));
 836
 837         time_out = 1000;
 838
 839         while ((time_out-- != 0) &&
 840                (scsi_pointer->this_residual > 0 ||
 841                 scsi_pointer->buffers_residual > 0)) {
 842                 stat = nsp_index_read(base, SCSIBUSMON);
 843                 stat &= BUSMON_PHASE_MASK;
 844
 845                 if (stat != BUSPHASE_DATA_OUT) {
 846                         res = ocount - nsp_fifo_count(SCpnt);
 847
 848                         nsp_dbg(NSP_DEBUG_DATA_IO, "phase changed stat=0x%x, res=%d\n", stat, res);
 849                         /* Put back pointer */
 850                         nsp_inc_resid(SCpnt, res);
 851                         scsi_pointer->ptr -= res;
 852                         scsi_pointer->this_residual += res;
 853                         ocount -= res;
 854
 855                         break;
 856                 }
 857
 858                 res = ocount - nsp_fifo_count(SCpnt);
 859                 if (res > 0) { /* write all data? */
 860                         nsp_dbg(NSP_DEBUG_DATA_IO, "wait for all data out. ocount=0x%x res=%d", ocount, res);
 861                         continue;
 862                 }
 863
 864                 res = min(scsi_pointer->this_residual, WFIFO_CRIT);
 865
 866                 //nsp_dbg(NSP_DEBUG_DATA_IO, "ptr=0x%p this=0x%x res=0x%x", scsi_pointer->ptr, scsi_pointer->this_residual, res);
 867                 switch (data->TransferMode) {
 868                 case MODE_IO32:
 869                         res &= ~(BIT(1)|BIT(0)); /* align 4 */
 870                         nsp_fifo32_write(base, scsi_pointer->ptr, res >> 2);
 871                         break;
 872                 case MODE_IO8:
 873                         nsp_fifo8_write(base, scsi_pointer->ptr, res);
 874                         break;
 875
 876                 case MODE_MEM32:
 877                         res &= ~(BIT(1)|BIT(0)); /* align 4 */
 878                         nsp_mmio_fifo32_write(mmio_base, scsi_pointer->ptr,
 879                                               res >> 2);
 880                         break;
 881
 882                 default:
 883                         nsp_dbg(NSP_DEBUG_DATA_IO, "unknown write mode");
 884                         break;
 885                 }
 886
 887                 nsp_inc_resid(SCpnt, -res);
 888                 scsi_pointer->ptr += res;
 889                 scsi_pointer->this_residual -= res;
 890                 ocount += res;
 891
 892                 /* go to next scatter list if available */
 893                 if (scsi_pointer->this_residual == 0 &&
 894                     scsi_pointer->buffers_residual != 0 ) {
 895                         //nsp_dbg(NSP_DEBUG_DATA_IO, "scatterlist next");
 896                         scsi_pointer->buffers_residual--;
 897                         scsi_pointer->buffer = sg_next(scsi_pointer->buffer);
 898                         scsi_pointer->ptr = BUFFER_ADDR(SCpnt);
 899                         scsi_pointer->this_residual =
 900                                 scsi_pointer->buffer->length;
 901                         time_out = 1000;
 902                 }
 903         }
 904
 905         data->FifoCount = ocount;
 906
 907         if (time_out < 0) {
 908                 nsp_msg(KERN_DEBUG, "pio write timeout resid=0x%x",
 909                                                         scsi_get_resid(SCpnt));
 910         }
 911         nsp_dbg(NSP_DEBUG_DATA_IO, "write ocount=0x%x", ocount);
 912         nsp_dbg(NSP_DEBUG_DATA_IO, "w cmd=%d resid=0x%x\n", data->CmdId,
 913                                                         scsi_get_resid(SCpnt));
 914 }
 915 #undef RFIFO_CRIT
 916 #undef WFIFO_CRIT
 917
 918 /*
 919  * setup synchronous/asynchronous data transfer mode
 920  */
 921 static int nsp_nexus(struct scsi_cmnd *SCpnt)
 922 {
 923         unsigned int   base   = SCpnt->device->host->io_port;
 924         unsigned char  target = scmd_id(SCpnt);
 925 //      unsigned char  lun    = SCpnt->device->lun;
 926         nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata;
 927         sync_data     *sync   = &(data->Sync[target]);
 928
 929         //nsp_dbg(NSP_DEBUG_DATA_IO, "in SCpnt=0x%p", SCpnt);
 930
 931         /* setup synch transfer registers */
 932         nsp_index_write(base, SYNCREG,  sync->SyncRegister);
 933         nsp_index_write(base, ACKWIDTH, sync->AckWidth);
 934
 935         if (scsi_get_resid(SCpnt) % 4 != 0 ||
 936             scsi_get_resid(SCpnt) <= PAGE_SIZE ) {
 937                 data->TransferMode = MODE_IO8;
 938         } else if (nsp_burst_mode == BURST_MEM32) {
 939                 data->TransferMode = MODE_MEM32;
 940         } else if (nsp_burst_mode == BURST_IO32) {
 941                 data->TransferMode = MODE_IO32;
 942         } else {
 943                 data->TransferMode = MODE_IO8;
 944         }
 945
 946         /* setup pdma fifo */
 947         nsp_setup_fifo(data, true);
 948
 949         /* clear ack counter */
 950         data->FifoCount = 0;
 951         nsp_index_write(base, POINTERCLR, POINTER_CLEAR     |
 952                                           ACK_COUNTER_CLEAR |
 953                                           REQ_COUNTER_CLEAR |
 954                                           HOST_COUNTER_CLEAR);
 955
 956         return 0;
 957 }
 958
 959 #include "nsp_message.c"
 960 /*
 961  * interrupt handler
 962  */
 963 static irqreturn_t nspintr(int irq, void *dev_id)
 964 {
 965         unsigned int   base;
 966         unsigned char  irq_status, irq_phase, phase;
 967         struct scsi_cmnd *tmpSC;
 968         struct scsi_pointer *scsi_pointer;
 969         unsigned char  target, lun;
 970         unsigned int  *sync_neg;
 971         int            i, tmp;
 972         nsp_hw_data   *data;
 973
 974
 975         //nsp_dbg(NSP_DEBUG_INTR, "dev_id=0x%p", dev_id);
 976         //nsp_dbg(NSP_DEBUG_INTR, "host=0x%p", ((scsi_info_t *)dev_id)->host);
 977
 978         if (                dev_id        != NULL &&
 979             ((scsi_info_t *)dev_id)->host != NULL  ) {
 980                 scsi_info_t *info = (scsi_info_t *)dev_id;
 981
 982                 data = (nsp_hw_data *)info->host->hostdata;
 983         } else {
 984                 nsp_dbg(NSP_DEBUG_INTR, "host data wrong");
 985                 return IRQ_NONE;
 986         }
 987
 988         //nsp_dbg(NSP_DEBUG_INTR, "&nsp_data_base=0x%p, dev_id=0x%p", &nsp_data_base, dev_id);
 989
 990         base = data->BaseAddress;
 991         //nsp_dbg(NSP_DEBUG_INTR, "base=0x%x", base);
 992
 993         /*
 994          * interrupt check
 995          */
 996         nsp_write(base, IRQCONTROL, IRQCONTROL_IRQDISABLE);
 997         irq_status = nsp_read(base, IRQSTATUS);
 998         //nsp_dbg(NSP_DEBUG_INTR, "irq_status=0x%x", irq_status);
 999         if ((irq_status == 0xff) || ((irq_status & IRQSTATUS_MASK) == 0)) {
1000                 nsp_write(base, IRQCONTROL, 0);
1001                 //nsp_dbg(NSP_DEBUG_INTR, "no irq/shared irq");
1002                 return IRQ_NONE;
1003         }
1004
1005         /* XXX: IMPORTANT
1006          * Do not read an irq_phase register if no scsi phase interrupt.
1007          * Unless, you should lose a scsi phase interrupt.
1008          */
1009         phase = nsp_index_read(base, SCSIBUSMON);
1010         if((irq_status & IRQSTATUS_SCSI) != 0) {
1011                 irq_phase = nsp_index_read(base, IRQPHASESENCE);
1012         } else {
1013                 irq_phase = 0;
1014         }
1015
1016         //nsp_dbg(NSP_DEBUG_INTR, "irq_phase=0x%x", irq_phase);
1017
1018         /*
1019          * timer interrupt handler (scsi vs timer interrupts)
1020          */
1021         //nsp_dbg(NSP_DEBUG_INTR, "timercount=%d", data->TimerCount);
1022         if (data->TimerCount != 0) {
1023                 //nsp_dbg(NSP_DEBUG_INTR, "stop timer");
1024                 nsp_index_write(base, TIMERCOUNT, 0);
1025                 nsp_index_write(base, TIMERCOUNT, 0);
1026                 data->TimerCount = 0;
1027         }
1028
1029         if ((irq_status & IRQSTATUS_MASK) == IRQSTATUS_TIMER &&
1030             data->SelectionTimeOut == 0) {
1031                 //nsp_dbg(NSP_DEBUG_INTR, "timer start");
1032                 nsp_write(base, IRQCONTROL, IRQCONTROL_TIMER_CLEAR);
1033                 return IRQ_HANDLED;
1034         }
1035
1036         nsp_write(base, IRQCONTROL, IRQCONTROL_TIMER_CLEAR | IRQCONTROL_FIFO_CLEAR);
1037
1038         if ((irq_status & IRQSTATUS_SCSI) &&
1039             (irq_phase  & SCSI_RESET_IRQ)) {
1040                 nsp_msg(KERN_ERR, "bus reset (power off?)");
1041
1042                 nsphw_init(data);
1043                 nsp_bus_reset(data);
1044
1045                 if(data->CurrentSC != NULL) {
1046                         tmpSC = data->CurrentSC;
1047                         scsi_pointer = nsp_priv(tmpSC);
1048                         tmpSC->result = (DID_RESET              << 16) |
1049                                 ((scsi_pointer->Message & 0xff) <<  8) |
1050                                 ((scsi_pointer->Status  & 0xff) <<  0);
1051                         nsp_scsi_done(tmpSC);
1052                 }
1053                 return IRQ_HANDLED;
1054         }
1055
1056         if (data->CurrentSC == NULL) {
1057                 nsp_msg(KERN_ERR, "CurrentSC==NULL irq_status=0x%x phase=0x%x irq_phase=0x%x this can't be happen. reset everything", irq_status, phase, irq_phase);
1058                 nsphw_init(data);
1059                 nsp_bus_reset(data);
1060                 return IRQ_HANDLED;
1061         }
1062
1063         tmpSC    = data->CurrentSC;
1064         scsi_pointer = nsp_priv(tmpSC);
1065         target   = tmpSC->device->id;
1066         lun      = tmpSC->device->lun;
1067         sync_neg = &(data->Sync[target].SyncNegotiation);
1068
1069         /*
1070          * parse hardware SCSI irq reasons register
1071          */
1072         if (irq_status & IRQSTATUS_SCSI) {
1073                 if (irq_phase & RESELECT_IRQ) {
1074                         nsp_dbg(NSP_DEBUG_INTR, "reselect");
1075                         nsp_write(base, IRQCONTROL, IRQCONTROL_RESELECT_CLEAR);
1076                         nsp_reselected(tmpSC);
1077                         return IRQ_HANDLED;
1078                 }
1079
1080                 if ((irq_phase & (PHASE_CHANGE_IRQ | LATCHED_BUS_FREE)) == 0) {
1081                         return IRQ_HANDLED;
1082                 }
1083         }
1084
1085         //show_phase(tmpSC);
1086
1087         switch (scsi_pointer->phase) {
1088         case PH_SELSTART:
1089                 // *sync_neg = SYNC_NOT_YET;
1090                 if ((phase & BUSMON_BSY) == 0) {
1091                         //nsp_dbg(NSP_DEBUG_INTR, "selection count=%d", data->SelectionTimeOut);
1092                         if (data->SelectionTimeOut >= NSP_SELTIMEOUT) {
1093                                 nsp_dbg(NSP_DEBUG_INTR, "selection time out");
1094                                 data->SelectionTimeOut = 0;
1095                                 nsp_index_write(base, SCSIBUSCTRL, 0);
1096
1097                                 tmpSC->result   = DID_TIME_OUT << 16;
1098                                 nsp_scsi_done(tmpSC);
1099
1100                                 return IRQ_HANDLED;
1101                         }
1102                         data->SelectionTimeOut += 1;
1103                         nsp_start_timer(tmpSC, 1000/51);
1104                         return IRQ_HANDLED;
1105                 }
1106
1107                 /* attention assert */
1108                 //nsp_dbg(NSP_DEBUG_INTR, "attention assert");
1109                 data->SelectionTimeOut = 0;
1110                 scsi_pointer->phase = PH_SELECTED;
1111                 nsp_index_write(base, SCSIBUSCTRL, SCSI_ATN);
1112                 udelay(1);
1113                 nsp_index_write(base, SCSIBUSCTRL, SCSI_ATN | AUTODIRECTION | ACKENB);
1114                 return IRQ_HANDLED;
1115
1116         case PH_RESELECT:
1117                 //nsp_dbg(NSP_DEBUG_INTR, "phase reselect");
1118                 // *sync_neg = SYNC_NOT_YET;
1119                 if ((phase & BUSMON_PHASE_MASK) != BUSPHASE_MESSAGE_IN) {
1120
1121                         tmpSC->result   = DID_ABORT << 16;
1122                         nsp_scsi_done(tmpSC);
1123                         return IRQ_HANDLED;
1124                 }
1125                 fallthrough;
1126         default:
1127                 if ((irq_status & (IRQSTATUS_SCSI | IRQSTATUS_FIFO)) == 0) {
1128                         return IRQ_HANDLED;
1129                 }
1130                 break;
1131         }
1132
1133         /*
1134          * SCSI sequencer
1135          */
1136         //nsp_dbg(NSP_DEBUG_INTR, "start scsi seq");
1137
1138         /* normal disconnect */
1139         if ((scsi_pointer->phase == PH_MSG_IN ||
1140              scsi_pointer->phase == PH_MSG_OUT) &&
1141             (irq_phase & LATCHED_BUS_FREE) != 0) {
1142                 nsp_dbg(NSP_DEBUG_INTR, "normal disconnect irq_status=0x%x, phase=0x%x, irq_phase=0x%x", irq_status, phase, irq_phase);
1143
1144                 //*sync_neg       = SYNC_NOT_YET;
1145
1146                 /* all command complete and return status */
1147                 if (scsi_pointer->Message == COMMAND_COMPLETE) {
1148                         tmpSC->result = (DID_OK                 << 16) |
1149                                 ((scsi_pointer->Message & 0xff) <<  8) |
1150                                 ((scsi_pointer->Status  & 0xff) <<  0);
1151                         nsp_dbg(NSP_DEBUG_INTR, "command complete result=0x%x", tmpSC->result);
1152                         nsp_scsi_done(tmpSC);
1153
1154                         return IRQ_HANDLED;
1155                 }
1156
1157                 return IRQ_HANDLED;
1158         }
1159
1160
1161         /* check unexpected bus free state */
1162         if (phase == 0) {
1163                 nsp_msg(KERN_DEBUG, "unexpected bus free. irq_status=0x%x, phase=0x%x, irq_phase=0x%x", irq_status, phase, irq_phase);
1164
1165                 *sync_neg       = SYNC_NG;
1166                 tmpSC->result   = DID_ERROR << 16;
1167                 nsp_scsi_done(tmpSC);
1168                 return IRQ_HANDLED;
1169         }
1170
1171         switch (phase & BUSMON_PHASE_MASK) {
1172         case BUSPHASE_COMMAND:
1173                 nsp_dbg(NSP_DEBUG_INTR, "BUSPHASE_COMMAND");
1174                 if ((phase & BUSMON_REQ) == 0) {
1175                         nsp_dbg(NSP_DEBUG_INTR, "REQ == 0");
1176                         return IRQ_HANDLED;
1177                 }
1178
1179                 scsi_pointer->phase = PH_COMMAND;
1180
1181                 nsp_nexus(tmpSC);
1182
1183                 /* write scsi command */
1184                 nsp_dbg(NSP_DEBUG_INTR, "cmd_len=%d", tmpSC->cmd_len);
1185                 nsp_index_write(base, COMMANDCTRL, CLEAR_COMMAND_POINTER);
1186                 for (i = 0; i < tmpSC->cmd_len; i++) {
1187                         nsp_index_write(base, COMMANDDATA, tmpSC->cmnd[i]);
1188                 }
1189                 nsp_index_write(base, COMMANDCTRL, CLEAR_COMMAND_POINTER | AUTO_COMMAND_GO);
1190                 break;
1191
1192         case BUSPHASE_DATA_OUT:
1193                 nsp_dbg(NSP_DEBUG_INTR, "BUSPHASE_DATA_OUT");
1194
1195                 scsi_pointer->phase        = PH_DATA;
1196                 scsi_pointer->have_data_in = IO_OUT;
1197
1198                 nsp_pio_write(tmpSC);
1199
1200                 break;
1201
1202         case BUSPHASE_DATA_IN:
1203                 nsp_dbg(NSP_DEBUG_INTR, "BUSPHASE_DATA_IN");
1204
1205                 scsi_pointer->phase        = PH_DATA;
1206                 scsi_pointer->have_data_in = IO_IN;
1207
1208                 nsp_pio_read(tmpSC);
1209
1210                 break;
1211
1212         case BUSPHASE_STATUS:
1213                 nsp_dataphase_bypass(tmpSC);
1214                 nsp_dbg(NSP_DEBUG_INTR, "BUSPHASE_STATUS");
1215
1216                 scsi_pointer->phase = PH_STATUS;
1217
1218                 scsi_pointer->Status = nsp_index_read(base, SCSIDATAWITHACK);
1219                 nsp_dbg(NSP_DEBUG_INTR, "message=0x%x status=0x%x",
1220                         scsi_pointer->Message, scsi_pointer->Status);
1221
1222                 break;
1223
1224         case BUSPHASE_MESSAGE_OUT:
1225                 nsp_dbg(NSP_DEBUG_INTR, "BUSPHASE_MESSAGE_OUT");
1226                 if ((phase & BUSMON_REQ) == 0) {
1227                         goto timer_out;
1228                 }
1229
1230                 scsi_pointer->phase = PH_MSG_OUT;
1231
1232                 //*sync_neg = SYNC_NOT_YET;
1233
1234                 data->MsgLen = i = 0;
1235                 data->MsgBuffer[i] = IDENTIFY(true, lun); i++;
1236
1237                 if (*sync_neg == SYNC_NOT_YET) {
1238                         data->Sync[target].SyncPeriod = 0;
1239                         data->Sync[target].SyncOffset = 0;
1240
1241                         /**/
1242                         data->MsgBuffer[i] = EXTENDED_MESSAGE; i++;
1243                         data->MsgBuffer[i] = 3;            i++;
1244                         data->MsgBuffer[i] = EXTENDED_SDTR; i++;
1245                         data->MsgBuffer[i] = 0x0c;         i++;
1246                         data->MsgBuffer[i] = 15;           i++;
1247                         /**/
1248                 }
1249                 data->MsgLen = i;
1250
1251                 nsp_analyze_sdtr(tmpSC);
1252                 show_message(data);
1253                 nsp_message_out(tmpSC);
1254                 break;
1255
1256         case BUSPHASE_MESSAGE_IN:
1257                 nsp_dataphase_bypass(tmpSC);
1258                 nsp_dbg(NSP_DEBUG_INTR, "BUSPHASE_MESSAGE_IN");
1259                 if ((phase & BUSMON_REQ) == 0) {
1260                         goto timer_out;
1261                 }
1262
1263                 scsi_pointer->phase = PH_MSG_IN;
1264                 nsp_message_in(tmpSC);
1265
1266                 /**/
1267                 if (*sync_neg == SYNC_NOT_YET) {
1268                         //nsp_dbg(NSP_DEBUG_INTR, "sync target=%d,lun=%d",target,lun);
1269
1270                         if (data->MsgLen       >= 5            &&
1271                             data->MsgBuffer[0] == EXTENDED_MESSAGE &&
1272                             data->MsgBuffer[1] == 3            &&
1273                             data->MsgBuffer[2] == EXTENDED_SDTR ) {
1274                                 data->Sync[target].SyncPeriod = data->MsgBuffer[3];
1275                                 data->Sync[target].SyncOffset = data->MsgBuffer[4];
1276                                 //nsp_dbg(NSP_DEBUG_INTR, "sync ok, %d %d", data->MsgBuffer[3], data->MsgBuffer[4]);
1277                                 *sync_neg = SYNC_OK;
1278                         } else {
1279                                 data->Sync[target].SyncPeriod = 0;
1280                                 data->Sync[target].SyncOffset = 0;
1281                                 *sync_neg = SYNC_NG;
1282                         }
1283                         nsp_analyze_sdtr(tmpSC);
1284                 }
1285                 /**/
1286
1287                 /* search last messeage byte */
1288                 tmp = -1;
1289                 for (i = 0; i < data->MsgLen; i++) {
1290                         tmp = data->MsgBuffer[i];
1291                         if (data->MsgBuffer[i] == EXTENDED_MESSAGE) {
1292                                 i += (1 + data->MsgBuffer[i+1]);
1293                         }
1294                 }
1295                 scsi_pointer->Message = tmp;
1296
1297                 nsp_dbg(NSP_DEBUG_INTR, "message=0x%x len=%d",
1298                         scsi_pointer->Message, data->MsgLen);
1299                 show_message(data);
1300
1301                 break;
1302
1303         case BUSPHASE_SELECT:
1304         default:
1305                 nsp_dbg(NSP_DEBUG_INTR, "BUSPHASE other");
1306
1307                 break;
1308         }
1309
1310         //nsp_dbg(NSP_DEBUG_INTR, "out");
1311         return IRQ_HANDLED;
1312
1313 timer_out:
1314         nsp_start_timer(tmpSC, 1000/102);
1315         return IRQ_HANDLED;
1316 }
1317
1318 #ifdef NSP_DEBUG
1319 #include "nsp_debug.c"
1320 #endif  /* NSP_DEBUG */
1321
1322 /*----------------------------------------------------------------*/
1323 /* look for ninja3 card and init if found                         */
1324 /*----------------------------------------------------------------*/
1325 static struct Scsi_Host *nsp_detect(struct scsi_host_template *sht)
1326 {
1327         struct Scsi_Host *host; /* registered host structure */
1328         nsp_hw_data *data_b = &nsp_data_base, *data;
1329
1330         nsp_dbg(NSP_DEBUG_INIT, "this_id=%d", sht->this_id);
1331         host = scsi_host_alloc(&nsp_driver_template, sizeof(nsp_hw_data));
1332         if (host == NULL) {
1333                 nsp_dbg(NSP_DEBUG_INIT, "host failed");
1334                 return NULL;
1335         }
1336
1337         memcpy(host->hostdata, data_b, sizeof(nsp_hw_data));
1338         data = (nsp_hw_data *)host->hostdata;
1339         data->ScsiInfo->host = host;
1340 #ifdef NSP_DEBUG
1341         data->CmdId = 0;
1342 #endif
1343
1344         nsp_dbg(NSP_DEBUG_INIT, "irq=%d,%d", data_b->IrqNumber, ((nsp_hw_data *)host->hostdata)->IrqNumber);
1345
1346         host->unique_id   = data->BaseAddress;
1347         host->io_port     = data->BaseAddress;
1348         host->n_io_port   = data->NumAddress;
1349         host->irq         = data->IrqNumber;
1350         host->base        = data->MmioAddress;
1351
1352         spin_lock_init(&(data->Lock));
1353
1354         snprintf(data->nspinfo,
1355                  sizeof(data->nspinfo),
1356                  "NinjaSCSI-3/32Bi Driver $Revision: 1.23 $ IO:0x%04lx-0x%04lx MMIO(virt addr):0x%04lx IRQ:%02d",
1357                  host->io_port, host->io_port + host->n_io_port - 1,
1358                  host->base,
1359                  host->irq);
1360         sht->name         = data->nspinfo;
1361
1362         nsp_dbg(NSP_DEBUG_INIT, "end");
1363
1364
1365         return host; /* detect done. */
1366 }
1367
1368 /*----------------------------------------------------------------*/
1369 /* return info string                                             */
1370 /*----------------------------------------------------------------*/
1371 static const char *nsp_info(struct Scsi_Host *shpnt)
1372 {
1373         nsp_hw_data *data = (nsp_hw_data *)shpnt->hostdata;
1374
1375         return data->nspinfo;
1376 }
1377
1378 static int nsp_show_info(struct seq_file *m, struct Scsi_Host *host)
1379 {
1380         int id;
1381         int speed;
1382         unsigned long flags;
1383         nsp_hw_data *data;
1384         int hostno;
1385
1386         hostno = host->host_no;
1387         data = (nsp_hw_data *)host->hostdata;
1388
1389         seq_puts(m, "NinjaSCSI status\n\n"
1390                 "Driver version:        $Revision: 1.23 $\n");
1391         seq_printf(m, "SCSI host No.:         %d\n",          hostno);
1392         seq_printf(m, "IRQ:                   %d\n",          host->irq);
1393         seq_printf(m, "IO:                    0x%lx-0x%lx\n", host->io_port, host->io_port + host->n_io_port - 1);
1394         seq_printf(m, "MMIO(virtual address): 0x%lx-0x%lx\n", host->base, host->base + data->MmioLength - 1);
1395         seq_printf(m, "sg_tablesize:          %d\n",          host->sg_tablesize);
1396
1397         seq_puts(m, "burst transfer mode:   ");
1398         switch (nsp_burst_mode) {
1399         case BURST_IO8:
1400                 seq_puts(m, "io8");
1401                 break;
1402         case BURST_IO32:
1403                 seq_puts(m, "io32");
1404                 break;
1405         case BURST_MEM32:
1406                 seq_puts(m, "mem32");
1407                 break;
1408         default:
1409                 seq_puts(m, "???");
1410                 break;
1411         }
1412         seq_putc(m, '\n');
1413
1414
1415         spin_lock_irqsave(&(data->Lock), flags);
1416         seq_printf(m, "CurrentSC:             0x%p\n\n",      data->CurrentSC);
1417         spin_unlock_irqrestore(&(data->Lock), flags);
1418
1419         seq_puts(m, "SDTR status\n");
1420         for(id = 0; id < ARRAY_SIZE(data->Sync); id++) {
1421
1422                 seq_printf(m, "id %d: ", id);
1423
1424                 if (id == host->this_id) {
1425                         seq_puts(m, "----- NinjaSCSI-3 host adapter\n");
1426                         continue;
1427                 }
1428
1429                 switch(data->Sync[id].SyncNegotiation) {
1430                 case SYNC_OK:
1431                         seq_puts(m, " sync");
1432                         break;
1433                 case SYNC_NG:
1434                         seq_puts(m, "async");
1435                         break;
1436                 case SYNC_NOT_YET:
1437                         seq_puts(m, " none");
1438                         break;
1439                 default:
1440                         seq_puts(m, "?????");
1441                         break;
1442                 }
1443
1444                 if (data->Sync[id].SyncPeriod != 0) {
1445                         speed = 1000000 / (data->Sync[id].SyncPeriod * 4);
1446
1447                         seq_printf(m, " transfer %d.%dMB/s, offset %d",
1448                                 speed / 1000,
1449                                 speed % 1000,
1450                                 data->Sync[id].SyncOffset
1451                                 );
1452                 }
1453                 seq_putc(m, '\n');
1454         }
1455         return 0;
1456 }
1457
1458 /*---------------------------------------------------------------*/
1459 /* error handler                                                 */
1460 /*---------------------------------------------------------------*/
1461
1462 /*
1463 static int nsp_eh_abort(struct scsi_cmnd *SCpnt)
1464 {
1465         nsp_dbg(NSP_DEBUG_BUSRESET, "SCpnt=0x%p", SCpnt);
1466
1467         return nsp_eh_bus_reset(SCpnt);
1468 }*/
1469
1470 static int nsp_bus_reset(nsp_hw_data *data)
1471 {
1472         unsigned int base = data->BaseAddress;
1473         int          i;
1474
1475         nsp_write(base, IRQCONTROL, IRQCONTROL_ALLMASK);
1476
1477         nsp_index_write(base, SCSIBUSCTRL, SCSI_RST);
1478         mdelay(100); /* 100ms */
1479         nsp_index_write(base, SCSIBUSCTRL, 0);
1480         for(i = 0; i < 5; i++) {
1481                 nsp_index_read(base, IRQPHASESENCE); /* dummy read */
1482         }
1483
1484         nsphw_init_sync(data);
1485
1486         nsp_write(base, IRQCONTROL, IRQCONTROL_ALLCLEAR);
1487
1488         return SUCCESS;
1489 }
1490
1491 static int nsp_eh_bus_reset(struct scsi_cmnd *SCpnt)
1492 {
1493         nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata;
1494
1495         nsp_dbg(NSP_DEBUG_BUSRESET, "SCpnt=0x%p", SCpnt);
1496
1497         return nsp_bus_reset(data);
1498 }
1499
1500 static int nsp_eh_host_reset(struct scsi_cmnd *SCpnt)
1501 {
1502         nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata;
1503
1504         nsp_dbg(NSP_DEBUG_BUSRESET, "in");
1505
1506         nsphw_init(data);
1507
1508         return SUCCESS;
1509 }
1510
1511
1512 /**********************************************************************
1513   PCMCIA functions
1514 **********************************************************************/
1515
1516 static int nsp_cs_probe(struct pcmcia_device *link)
1517 {
1518         scsi_info_t  *info;
1519         nsp_hw_data  *data = &nsp_data_base;
1520         int ret;
1521
1522         nsp_dbg(NSP_DEBUG_INIT, "in");
1523
1524         /* Create new SCSI device */
1525         info = kzalloc(sizeof(*info), GFP_KERNEL);
1526         if (info == NULL) { return -ENOMEM; }
1527         info->p_dev = link;
1528         link->priv = info;
1529         data->ScsiInfo = info;
1530
1531         nsp_dbg(NSP_DEBUG_INIT, "info=0x%p", info);
1532
1533         ret = nsp_cs_config(link);
1534
1535         nsp_dbg(NSP_DEBUG_INIT, "link=0x%p", link);
1536         return ret;
1537 } /* nsp_cs_attach */
1538
1539
1540 static void nsp_cs_detach(struct pcmcia_device *link)
1541 {
1542         nsp_dbg(NSP_DEBUG_INIT, "in, link=0x%p", link);
1543
1544         ((scsi_info_t *)link->priv)->stop = 1;
1545         nsp_cs_release(link);
1546
1547         kfree(link->priv);
1548         link->priv = NULL;
1549 } /* nsp_cs_detach */
1550
1551
1552 static int nsp_cs_config_check(struct pcmcia_device *p_dev, void *priv_data)
1553 {
1554         nsp_hw_data             *data = priv_data;
1555
1556         if (p_dev->config_index == 0)
1557                 return -ENODEV;
1558
1559         /* This reserves IO space but doesn't actually enable it */
1560         if (pcmcia_request_io(p_dev) != 0)
1561                 goto next_entry;
1562
1563         if (resource_size(p_dev->resource[2])) {
1564                 p_dev->resource[2]->flags |= (WIN_DATA_WIDTH_16 |
1565                                         WIN_MEMORY_TYPE_CM |
1566                                         WIN_ENABLE);
1567                 if (p_dev->resource[2]->end < 0x1000)
1568                         p_dev->resource[2]->end = 0x1000;
1569                 if (pcmcia_request_window(p_dev, p_dev->resource[2], 0) != 0)
1570                         goto next_entry;
1571                 if (pcmcia_map_mem_page(p_dev, p_dev->resource[2],
1572                                                 p_dev->card_addr) != 0)
1573                         goto next_entry;
1574
1575                 data->MmioAddress = (unsigned long)
1576                         ioremap(p_dev->resource[2]->start,
1577                                         resource_size(p_dev->resource[2]));
1578                 if (!data->MmioAddress)
1579                         goto next_entry;
1580
1581                 data->MmioLength  = resource_size(p_dev->resource[2]);
1582         }
1583         /* If we got this far, we're cool! */
1584         return 0;
1585
1586 next_entry:
1587         nsp_dbg(NSP_DEBUG_INIT, "next");
1588         pcmcia_disable_device(p_dev);
1589         return -ENODEV;
1590 }
1591
1592 static int nsp_cs_config(struct pcmcia_device *link)
1593 {
1594         int               ret;
1595         scsi_info_t      *info   = link->priv;
1596         struct Scsi_Host *host;
1597         nsp_hw_data      *data = &nsp_data_base;
1598
1599         nsp_dbg(NSP_DEBUG_INIT, "in");
1600
1601         link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_CHECK_VCC |
1602                 CONF_AUTO_SET_VPP | CONF_AUTO_AUDIO | CONF_AUTO_SET_IOMEM |
1603                 CONF_AUTO_SET_IO;
1604
1605         ret = pcmcia_loop_config(link, nsp_cs_config_check, data);
1606         if (ret)
1607                 goto cs_failed;
1608
1609         if (pcmcia_request_irq(link, nspintr))
1610                 goto cs_failed;
1611
1612         ret = pcmcia_enable_device(link);
1613         if (ret)
1614                 goto cs_failed;
1615
1616         if (free_ports) {
1617                 if (link->resource[0]) {
1618                         release_region(link->resource[0]->start,
1619                                         resource_size(link->resource[0]));
1620                 }
1621                 if (link->resource[1]) {
1622                         release_region(link->resource[1]->start,
1623                                         resource_size(link->resource[1]));
1624                 }
1625         }
1626
1627         /* Set port and IRQ */
1628         data->BaseAddress = link->resource[0]->start;
1629         data->NumAddress  = resource_size(link->resource[0]);
1630         data->IrqNumber   = link->irq;
1631
1632         nsp_dbg(NSP_DEBUG_INIT, "I/O[0x%x+0x%x] IRQ %d",
1633                 data->BaseAddress, data->NumAddress, data->IrqNumber);
1634
1635         nsphw_init(data);
1636
1637         host = nsp_detect(&nsp_driver_template);
1638
1639         if (host == NULL) {
1640                 nsp_dbg(NSP_DEBUG_INIT, "detect failed");
1641                 goto cs_failed;
1642         }
1643
1644
1645         ret = scsi_add_host (host, NULL);
1646         if (ret)
1647                 goto cs_failed;
1648
1649         scsi_scan_host(host);
1650
1651         info->host = host;
1652
1653         return 0;
1654
1655  cs_failed:
1656         nsp_dbg(NSP_DEBUG_INIT, "config fail");
1657         nsp_cs_release(link);
1658
1659         return -ENODEV;
1660 } /* nsp_cs_config */
1661
1662
1663 static void nsp_cs_release(struct pcmcia_device *link)
1664 {
1665         scsi_info_t *info = link->priv;
1666         nsp_hw_data *data = NULL;
1667
1668         if (info->host == NULL) {
1669                 nsp_msg(KERN_DEBUG, "unexpected card release call.");
1670         } else {
1671                 data = (nsp_hw_data *)info->host->hostdata;
1672         }
1673
1674         nsp_dbg(NSP_DEBUG_INIT, "link=0x%p", link);
1675
1676         /* Unlink the device chain */
1677         if (info->host != NULL) {
1678                 scsi_remove_host(info->host);
1679         }
1680
1681         if (resource_size(link->resource[2])) {
1682                 if (data != NULL) {
1683                         iounmap((void *)(data->MmioAddress));
1684                 }
1685         }
1686         pcmcia_disable_device(link);
1687
1688         if (info->host != NULL) {
1689                 scsi_host_put(info->host);
1690         }
1691 } /* nsp_cs_release */
1692
1693 static int nsp_cs_suspend(struct pcmcia_device *link)
1694 {
1695         scsi_info_t *info = link->priv;
1696         nsp_hw_data *data;
1697
1698         nsp_dbg(NSP_DEBUG_INIT, "event: suspend");
1699
1700         if (info->host != NULL) {
1701                 nsp_msg(KERN_INFO, "clear SDTR status");
1702
1703                 data = (nsp_hw_data *)info->host->hostdata;
1704
1705                 nsphw_init_sync(data);
1706         }
1707
1708         info->stop = 1;
1709
1710         return 0;
1711 }
1712
1713 static int nsp_cs_resume(struct pcmcia_device *link)
1714 {
1715         scsi_info_t *info = link->priv;
1716         nsp_hw_data *data;
1717
1718         nsp_dbg(NSP_DEBUG_INIT, "event: resume");
1719
1720         info->stop = 0;
1721
1722         if (info->host != NULL) {
1723                 nsp_msg(KERN_INFO, "reset host and bus");
1724
1725                 data = (nsp_hw_data *)info->host->hostdata;
1726
1727                 nsphw_init   (data);
1728                 nsp_bus_reset(data);
1729         }
1730
1731         return 0;
1732 }
1733
1734 /*======================================================================*
1735  *      module entry point
1736  *====================================================================*/
1737 static const struct pcmcia_device_id nsp_cs_ids[] = {
1738         PCMCIA_DEVICE_PROD_ID123("IO DATA", "CBSC16       ", "1", 0x547e66dc, 0x0d63a3fd, 0x51de003a),
1739         PCMCIA_DEVICE_PROD_ID123("KME    ", "SCSI-CARD-001", "1", 0x534c02bc, 0x52008408, 0x51de003a),
1740         PCMCIA_DEVICE_PROD_ID123("KME    ", "SCSI-CARD-002", "1", 0x534c02bc, 0xcb09d5b2, 0x51de003a),
1741         PCMCIA_DEVICE_PROD_ID123("KME    ", "SCSI-CARD-003", "1", 0x534c02bc, 0xbc0ee524, 0x51de003a),
1742         PCMCIA_DEVICE_PROD_ID123("KME    ", "SCSI-CARD-004", "1", 0x534c02bc, 0x226a7087, 0x51de003a),
1743         PCMCIA_DEVICE_PROD_ID123("WBT", "NinjaSCSI-3", "R1.0", 0xc7ba805f, 0xfdc7c97d, 0x6973710e),
1744         PCMCIA_DEVICE_PROD_ID123("WORKBIT", "UltraNinja-16", "1", 0x28191418, 0xb70f4b09, 0x51de003a),
1745         PCMCIA_DEVICE_NULL
1746 };
1747 MODULE_DEVICE_TABLE(pcmcia, nsp_cs_ids);
1748
1749 static struct pcmcia_driver nsp_driver = {
1750         .owner          = THIS_MODULE,
1751         .name           = "nsp_cs",
1752         .probe          = nsp_cs_probe,
1753         .remove         = nsp_cs_detach,
1754         .id_table       = nsp_cs_ids,
1755         .suspend        = nsp_cs_suspend,
1756         .resume         = nsp_cs_resume,
1757 };
1758 module_pcmcia_driver(nsp_driver);
1759
1760 /* end */