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