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