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