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