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