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