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