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