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