?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Initial commit
[wrt350n-kernel.git] / drivers / scsi / pcmcia / nsp_cs.c
blob5082ca3c6876035df3818035873a47f1e6d181f9
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 (__FUNCTION__, __LINE__, (type), args)
111 # define nsp_dbg(mask, args...) \
112 nsp_cs_dmessage(__FUNCTION__, __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 #define CS_CHECK(fn, ret) \
1611 do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
1612 /*====================================================================*/
1613 static int nsp_cs_config(struct pcmcia_device *link)
1614 {
1615 int ret;
1616 scsi_info_t *info = link->priv;
1617 tuple_t tuple;
1618 cisparse_t parse;
1619 int last_ret, last_fn;
1620 unsigned char tuple_data[64];
1621 config_info_t conf;
1622 win_req_t req;
1623 memreq_t map;
1624 cistpl_cftable_entry_t dflt = { 0 };
1625 struct Scsi_Host *host;
1626 nsp_hw_data *data = &nsp_data_base;
1627
1628 nsp_dbg(NSP_DEBUG_INIT, "in");
1629
1630 tuple.Attributes = 0;
1631 tuple.TupleData = tuple_data;
1632 tuple.TupleDataMax = sizeof(tuple_data);
1633 tuple.TupleOffset = 0;
1634
1635 /* Look up the current Vcc */
1636 CS_CHECK(GetConfigurationInfo, pcmcia_get_configuration_info(link, &conf));
1637
1638 tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
1639 CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(link, &tuple));
1640 while (1) {
1641 cistpl_cftable_entry_t *cfg = &(parse.cftable_entry);
1642
1643 if (pcmcia_get_tuple_data(link, &tuple) != 0 ||
1644 pcmcia_parse_tuple(link, &tuple, &parse) != 0)
1645 goto next_entry;
1646
1647 if (cfg->flags & CISTPL_CFTABLE_DEFAULT) { dflt = *cfg; }
1648 if (cfg->index == 0) { goto next_entry; }
1649 link->conf.ConfigIndex = cfg->index;
1650
1651 /* Does this card need audio output? */
1652 if (cfg->flags & CISTPL_CFTABLE_AUDIO) {
1653 link->conf.Attributes |= CONF_ENABLE_SPKR;
1654 link->conf.Status = CCSR_AUDIO_ENA;
1655 }
1656
1657 /* Use power settings for Vcc and Vpp if present */
1658 /* Note that the CIS values need to be rescaled */
1659 if (cfg->vcc.present & (1<<CISTPL_POWER_VNOM)) {
1660 if (conf.Vcc != cfg->vcc.param[CISTPL_POWER_VNOM]/10000) {
1661 goto next_entry;
1662 }
1663 } else if (dflt.vcc.present & (1<<CISTPL_POWER_VNOM)) {
1664 if (conf.Vcc != dflt.vcc.param[CISTPL_POWER_VNOM]/10000) {
1665 goto next_entry;
1666 }
1667 }
1668
1669 if (cfg->vpp1.present & (1 << CISTPL_POWER_VNOM)) {
1670 link->conf.Vpp =
1671 cfg->vpp1.param[CISTPL_POWER_VNOM] / 10000;
1672 } else if (dflt.vpp1.present & (1 << CISTPL_POWER_VNOM)) {
1673 link->conf.Vpp =
1674 dflt.vpp1.param[CISTPL_POWER_VNOM] / 10000;
1675 }
1676
1677 /* Do we need to allocate an interrupt? */
1678 if (cfg->irq.IRQInfo1 || dflt.irq.IRQInfo1) {
1679 link->conf.Attributes |= CONF_ENABLE_IRQ;
1680 }
1681
1682 /* IO window settings */
1683 link->io.NumPorts1 = link->io.NumPorts2 = 0;
1684 if ((cfg->io.nwin > 0) || (dflt.io.nwin > 0)) {
1685 cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt.io;
1686 link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
1687 if (!(io->flags & CISTPL_IO_8BIT))
1688 link->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
1689 if (!(io->flags & CISTPL_IO_16BIT))
1690 link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
1691 link->io.IOAddrLines = io->flags & CISTPL_IO_LINES_MASK;
1692 link->io.BasePort1 = io->win[0].base;
1693 link->io.NumPorts1 = io->win[0].len;
1694 if (io->nwin > 1) {
1695 link->io.Attributes2 = link->io.Attributes1;
1696 link->io.BasePort2 = io->win[1].base;
1697 link->io.NumPorts2 = io->win[1].len;
1698 }
1699 /* This reserves IO space but doesn't actually enable it */
1700 if (pcmcia_request_io(link, &link->io) != 0)
1701 goto next_entry;
1702 }
1703
1704 if ((cfg->mem.nwin > 0) || (dflt.mem.nwin > 0)) {
1705 cistpl_mem_t *mem =
1706 (cfg->mem.nwin) ? &cfg->mem : &dflt.mem;
1707 req.Attributes = WIN_DATA_WIDTH_16|WIN_MEMORY_TYPE_CM;
1708 req.Attributes |= WIN_ENABLE;
1709 req.Base = mem->win[0].host_addr;
1710 req.Size = mem->win[0].len;
1711 if (req.Size < 0x1000) {
1712 req.Size = 0x1000;
1713 }
1714 req.AccessSpeed = 0;
1715 if (pcmcia_request_window(&link, &req, &link->win) != 0)
1716 goto next_entry;
1717 map.Page = 0; map.CardOffset = mem->win[0].card_addr;
1718 if (pcmcia_map_mem_page(link->win, &map) != 0)
1719 goto next_entry;
1720
1721 data->MmioAddress = (unsigned long)ioremap_nocache(req.Base, req.Size);
1722 data->MmioLength = req.Size;
1723 }
1724 /* If we got this far, we're cool! */
1725 break;
1726
1727 next_entry:
1728 nsp_dbg(NSP_DEBUG_INIT, "next");
1729 pcmcia_disable_device(link);
1730 CS_CHECK(GetNextTuple, pcmcia_get_next_tuple(link, &tuple));
1731 }
1732
1733 if (link->conf.Attributes & CONF_ENABLE_IRQ) {
1734 CS_CHECK(RequestIRQ, pcmcia_request_irq(link, &link->irq));
1735 }
1736 CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link, &link->conf));
1737
1738 if (free_ports) {
1739 if (link->io.BasePort1) {
1740 release_region(link->io.BasePort1, link->io.NumPorts1);
1741 }
1742 if (link->io.BasePort2) {
1743 release_region(link->io.BasePort2, link->io.NumPorts2);
1744 }
1745 }
1746
1747 /* Set port and IRQ */
1748 data->BaseAddress = link->io.BasePort1;
1749 data->NumAddress = link->io.NumPorts1;
1750 data->IrqNumber = link->irq.AssignedIRQ;
1751
1752 nsp_dbg(NSP_DEBUG_INIT, "I/O[0x%x+0x%x] IRQ %d",
1753 data->BaseAddress, data->NumAddress, data->IrqNumber);
1754
1755 if(nsphw_init(data) == FALSE) {
1756 goto cs_failed;
1757 }
1758
1759 host = nsp_detect(&nsp_driver_template);
1760
1761 if (host == NULL) {
1762 nsp_dbg(NSP_DEBUG_INIT, "detect failed");
1763 goto cs_failed;
1764 }
1765
1766
1767 ret = scsi_add_host (host, NULL);
1768 if (ret)
1769 goto cs_failed;
1770
1771 scsi_scan_host(host);
1772
1773 snprintf(info->node.dev_name, sizeof(info->node.dev_name), "scsi%d", host->host_no);
1774 link->dev_node = &info->node;
1775 info->host = host;
1776
1777 /* Finally, report what we've done */
1778 printk(KERN_INFO "nsp_cs: index 0x%02x: ",
1779 link->conf.ConfigIndex);
1780 if (link->conf.Vpp) {
1781 printk(", Vpp %d.%d", link->conf.Vpp/10, link->conf.Vpp%10);
1782 }
1783 if (link->conf.Attributes & CONF_ENABLE_IRQ) {
1784 printk(", irq %d", link->irq.AssignedIRQ);
1785 }
1786 if (link->io.NumPorts1) {
1787 printk(", io 0x%04x-0x%04x", link->io.BasePort1,
1788 link->io.BasePort1+link->io.NumPorts1-1);
1789 }
1790 if (link->io.NumPorts2)
1791 printk(" & 0x%04x-0x%04x", link->io.BasePort2,
1792 link->io.BasePort2+link->io.NumPorts2-1);
1793 if (link->win)
1794 printk(", mem 0x%06lx-0x%06lx", req.Base,
1795 req.Base+req.Size-1);
1796 printk("\n");
1797
1798 return 0;
1799
1800 cs_failed:
1801 nsp_dbg(NSP_DEBUG_INIT, "config fail");
1802 cs_error(link, last_fn, last_ret);
1803 nsp_cs_release(link);
1804
1805 return -ENODEV;
1806 } /* nsp_cs_config */
1807 #undef CS_CHECK
1808
1809
1810 /*======================================================================
1811 After a card is removed, nsp_cs_release() will unregister the net
1812 device, and release the PCMCIA configuration. If the device is
1813 still open, this will be postponed until it is closed.
1814 ======================================================================*/
1815 static void nsp_cs_release(struct pcmcia_device *link)
1816 {
1817 scsi_info_t *info = link->priv;
1818 nsp_hw_data *data = NULL;
1819
1820 if (info->host == NULL) {
1821 nsp_msg(KERN_DEBUG, "unexpected card release call.");
1822 } else {
1823 data = (nsp_hw_data *)info->host->hostdata;
1824 }
1825
1826 nsp_dbg(NSP_DEBUG_INIT, "link=0x%p", link);
1827
1828 /* Unlink the device chain */
1829 if (info->host != NULL) {
1830 scsi_remove_host(info->host);
1831 }
1832 link->dev_node = NULL;
1833
1834 if (link->win) {
1835 if (data != NULL) {
1836 iounmap((void *)(data->MmioAddress));
1837 }
1838 }
1839 pcmcia_disable_device(link);
1840
1841 if (info->host != NULL) {
1842 scsi_host_put(info->host);
1843 }
1844 } /* nsp_cs_release */
1845
1846 static int nsp_cs_suspend(struct pcmcia_device *link)
1847 {
1848 scsi_info_t *info = link->priv;
1849 nsp_hw_data *data;
1850
1851 nsp_dbg(NSP_DEBUG_INIT, "event: suspend");
1852
1853 if (info->host != NULL) {
1854 nsp_msg(KERN_INFO, "clear SDTR status");
1855
1856 data = (nsp_hw_data *)info->host->hostdata;
1857
1858 nsphw_init_sync(data);
1859 }
1860
1861 info->stop = 1;
1862
1863 return 0;
1864 }
1865
1866 static int nsp_cs_resume(struct pcmcia_device *link)
1867 {
1868 scsi_info_t *info = link->priv;
1869 nsp_hw_data *data;
1870
1871 nsp_dbg(NSP_DEBUG_INIT, "event: resume");
1872
1873 info->stop = 0;
1874
1875 if (info->host != NULL) {
1876 nsp_msg(KERN_INFO, "reset host and bus");
1877
1878 data = (nsp_hw_data *)info->host->hostdata;
1879
1880 nsphw_init (data);
1881 nsp_bus_reset(data);
1882 }
1883
1884 return 0;
1885 }
1886
1887 /*======================================================================*
1888 * module entry point
1889 *====================================================================*/
1890 static struct pcmcia_device_id nsp_cs_ids[] = {
1891 PCMCIA_DEVICE_PROD_ID123("IO DATA", "CBSC16 ", "1", 0x547e66dc, 0x0d63a3fd, 0x51de003a),
1892 PCMCIA_DEVICE_PROD_ID123("KME ", "SCSI-CARD-001", "1", 0x534c02bc, 0x52008408, 0x51de003a),
1893 PCMCIA_DEVICE_PROD_ID123("KME ", "SCSI-CARD-002", "1", 0x534c02bc, 0xcb09d5b2, 0x51de003a),
1894 PCMCIA_DEVICE_PROD_ID123("KME ", "SCSI-CARD-003", "1", 0x534c02bc, 0xbc0ee524, 0x51de003a),
1895 PCMCIA_DEVICE_PROD_ID123("KME ", "SCSI-CARD-004", "1", 0x534c02bc, 0x226a7087, 0x51de003a),
1896 PCMCIA_DEVICE_PROD_ID123("WBT", "NinjaSCSI-3", "R1.0", 0xc7ba805f, 0xfdc7c97d, 0x6973710e),
1897 PCMCIA_DEVICE_PROD_ID123("WORKBIT", "UltraNinja-16", "1", 0x28191418, 0xb70f4b09, 0x51de003a),
1898 PCMCIA_DEVICE_NULL
1899 };
1900 MODULE_DEVICE_TABLE(pcmcia, nsp_cs_ids);
1901
1902 static struct pcmcia_driver nsp_driver = {
1903 .owner = THIS_MODULE,
1904 .drv = {
1905 .name = "nsp_cs",
1906 },
1907 .probe = nsp_cs_probe,
1908 .remove = nsp_cs_detach,
1909 .id_table = nsp_cs_ids,
1910 .suspend = nsp_cs_suspend,
1911 .resume = nsp_cs_resume,
1912 };
1913
1914 static int __init nsp_cs_init(void)
1915 {
1916 nsp_msg(KERN_INFO, "loading...");
1917
1918 return pcmcia_register_driver(&nsp_driver);
1919 }
1920
1921 static void __exit nsp_cs_exit(void)
1922 {
1923 nsp_msg(KERN_INFO, "unloading...");
1924 pcmcia_unregister_driver(&nsp_driver);
1925 }
1926
1927
1928 module_init(nsp_cs_init)
1929 module_exit(nsp_cs_exit)
1930
1931 /* end */
WRT350N Kernel Patches