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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116#include <linux/module.h>
117#include <linux/blkdev.h>
118#include <linux/interrupt.h>
119#include <linux/string.h>
120#include <linux/delay.h>
121#include <linux/proc_fs.h>
122#include <linux/ioport.h>
123#include <linux/stat.h>
124
125#include <asm/io.h>
126#include <asm/system.h>
127
128#include "scsi.h"
129#include <scsi/scsi_host.h>
130
131#define IN2000_VERSION "1.33-2.5"
132#define IN2000_DATE "2002/11/03"
133
134#include "in2000.h"
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184static char *setup_args[] = { "", "", "", "", "", "", "", "", "" };
185
186
187static char *setup_strings;
188
189module_param(setup_strings, charp, 0);
190
191static inline uchar read_3393(struct IN2000_hostdata *hostdata, uchar reg_num)
192{
193 write1_io(reg_num, IO_WD_ADDR);
194 return read1_io(IO_WD_DATA);
195}
196
197
198#define READ_AUX_STAT() read1_io(IO_WD_ASR)
199
200
201static inline void write_3393(struct IN2000_hostdata *hostdata, uchar reg_num, uchar value)
202{
203 write1_io(reg_num, IO_WD_ADDR);
204 write1_io(value, IO_WD_DATA);
205}
206
207
208static inline void write_3393_cmd(struct IN2000_hostdata *hostdata, uchar cmd)
209{
210
211
212 write1_io(WD_COMMAND, IO_WD_ADDR);
213 write1_io(cmd, IO_WD_DATA);
214}
215
216
217static uchar read_1_byte(struct IN2000_hostdata *hostdata)
218{
219 uchar asr, x = 0;
220
221 write_3393(hostdata, WD_CONTROL, CTRL_IDI | CTRL_EDI | CTRL_POLLED);
222 write_3393_cmd(hostdata, WD_CMD_TRANS_INFO | 0x80);
223 do {
224 asr = READ_AUX_STAT();
225 if (asr & ASR_DBR)
226 x = read_3393(hostdata, WD_DATA);
227 } while (!(asr & ASR_INT));
228 return x;
229}
230
231
232static void write_3393_count(struct IN2000_hostdata *hostdata, unsigned long value)
233{
234 write1_io(WD_TRANSFER_COUNT_MSB, IO_WD_ADDR);
235 write1_io((value >> 16), IO_WD_DATA);
236 write1_io((value >> 8), IO_WD_DATA);
237 write1_io(value, IO_WD_DATA);
238}
239
240
241static unsigned long read_3393_count(struct IN2000_hostdata *hostdata)
242{
243 unsigned long value;
244
245 write1_io(WD_TRANSFER_COUNT_MSB, IO_WD_ADDR);
246 value = read1_io(IO_WD_DATA) << 16;
247 value |= read1_io(IO_WD_DATA) << 8;
248 value |= read1_io(IO_WD_DATA);
249 return value;
250}
251
252
253
254
255
256
257
258static int is_dir_out(Scsi_Cmnd * cmd)
259{
260 switch (cmd->cmnd[0]) {
261 case WRITE_6:
262 case WRITE_10:
263 case WRITE_12:
264 case WRITE_LONG:
265 case WRITE_SAME:
266 case WRITE_BUFFER:
267 case WRITE_VERIFY:
268 case WRITE_VERIFY_12:
269 case COMPARE:
270 case COPY:
271 case COPY_VERIFY:
272 case SEARCH_EQUAL:
273 case SEARCH_HIGH:
274 case SEARCH_LOW:
275 case SEARCH_EQUAL_12:
276 case SEARCH_HIGH_12:
277 case SEARCH_LOW_12:
278 case FORMAT_UNIT:
279 case REASSIGN_BLOCKS:
280 case RESERVE:
281 case MODE_SELECT:
282 case MODE_SELECT_10:
283 case LOG_SELECT:
284 case SEND_DIAGNOSTIC:
285 case CHANGE_DEFINITION:
286 case UPDATE_BLOCK:
287 case SET_WINDOW:
288 case MEDIUM_SCAN:
289 case SEND_VOLUME_TAG:
290 case 0xea:
291 return 1;
292 default:
293 return 0;
294 }
295}
296
297
298
299static struct sx_period sx_table[] = {
300 {1, 0x20},
301 {252, 0x20},
302 {376, 0x30},
303 {500, 0x40},
304 {624, 0x50},
305 {752, 0x60},
306 {876, 0x70},
307 {1000, 0x00},
308 {0, 0}
309};
310
311static int round_period(unsigned int period)
312{
313 int x;
314
315 for (x = 1; sx_table[x].period_ns; x++) {
316 if ((period <= sx_table[x - 0].period_ns) && (period > sx_table[x - 1].period_ns)) {
317 return x;
318 }
319 }
320 return 7;
321}
322
323static uchar calc_sync_xfer(unsigned int period, unsigned int offset)
324{
325 uchar result;
326
327 period *= 4;
328 result = sx_table[round_period(period)].reg_value;
329 result |= (offset < OPTIMUM_SX_OFF) ? offset : OPTIMUM_SX_OFF;
330 return result;
331}
332
333
334
335static void in2000_execute(struct Scsi_Host *instance);
336
337static int in2000_queuecommand_lck(Scsi_Cmnd * cmd, void (*done) (Scsi_Cmnd *))
338{
339 struct Scsi_Host *instance;
340 struct IN2000_hostdata *hostdata;
341 Scsi_Cmnd *tmp;
342
343 instance = cmd->device->host;
344 hostdata = (struct IN2000_hostdata *) instance->hostdata;
345
346 DB(DB_QUEUE_COMMAND, scmd_printk(KERN_DEBUG, cmd, "Q-%02x-%ld(", cmd->cmnd[0], cmd->serial_number))
347
348
349
350
351
352
353 cmd->host_scribble = NULL;
354 cmd->scsi_done = done;
355 cmd->result = 0;
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372 if (scsi_bufflen(cmd)) {
373 cmd->SCp.buffer = scsi_sglist(cmd);
374 cmd->SCp.buffers_residual = scsi_sg_count(cmd) - 1;
375 cmd->SCp.ptr = sg_virt(cmd->SCp.buffer);
376 cmd->SCp.this_residual = cmd->SCp.buffer->length;
377 } else {
378 cmd->SCp.buffer = NULL;
379 cmd->SCp.buffers_residual = 0;
380 cmd->SCp.ptr = NULL;
381 cmd->SCp.this_residual = 0;
382 }
383 cmd->SCp.have_data_in = 0;
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404 cmd->SCp.Status = ILLEGAL_STATUS_BYTE;
405
406
407
408
409
410
411
412
413
414
415
416 if (!(hostdata->input_Q) || (cmd->cmnd[0] == REQUEST_SENSE)) {
417 cmd->host_scribble = (uchar *) hostdata->input_Q;
418 hostdata->input_Q = cmd;
419 } else {
420 for (tmp = (Scsi_Cmnd *) hostdata->input_Q; tmp->host_scribble; tmp = (Scsi_Cmnd *) tmp->host_scribble);
421 tmp->host_scribble = (uchar *) cmd;
422 }
423
424
425
426
427
428 in2000_execute(cmd->device->host);
429
430 DB(DB_QUEUE_COMMAND, printk(")Q-%ld ", cmd->serial_number))
431 return 0;
432}
433
434static DEF_SCSI_QCMD(in2000_queuecommand)
435
436
437
438
439
440
441
442
443
444
445
446static void in2000_execute(struct Scsi_Host *instance)
447{
448 struct IN2000_hostdata *hostdata;
449 Scsi_Cmnd *cmd, *prev;
450 int i;
451 unsigned short *sp;
452 unsigned short f;
453 unsigned short flushbuf[16];
454
455
456 hostdata = (struct IN2000_hostdata *) instance->hostdata;
457
458 DB(DB_EXECUTE, printk("EX("))
459
460 if (hostdata->selecting || hostdata->connected) {
461
462 DB(DB_EXECUTE, printk(")EX-0 "))
463
464 return;
465 }
466
467
468
469
470
471
472 cmd = (Scsi_Cmnd *) hostdata->input_Q;
473 prev = NULL;
474 while (cmd) {
475 if (!(hostdata->busy[cmd->device->id] & (1 << cmd->device->lun)))
476 break;
477 prev = cmd;
478 cmd = (Scsi_Cmnd *) cmd->host_scribble;
479 }
480
481
482
483 if (!cmd) {
484
485 DB(DB_EXECUTE, printk(")EX-1 "))
486
487 return;
488 }
489
490
491
492 if (prev)
493 prev->host_scribble = cmd->host_scribble;
494 else
495 hostdata->input_Q = (Scsi_Cmnd *) cmd->host_scribble;
496
497#ifdef PROC_STATISTICS
498 hostdata->cmd_cnt[cmd->device->id]++;
499#endif
500
501
502
503
504
505 if (is_dir_out(cmd))
506 write_3393(hostdata, WD_DESTINATION_ID, cmd->device->id);
507 else
508 write_3393(hostdata, WD_DESTINATION_ID, cmd->device->id | DSTID_DPD);
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533 cmd->SCp.phase = 0;
534 if (hostdata->disconnect == DIS_NEVER)
535 goto no;
536 if (hostdata->disconnect == DIS_ALWAYS)
537 goto yes;
538 if (cmd->device->type == 1)
539 goto yes;
540 if (hostdata->disconnected_Q)
541 goto yes;
542 if (!(hostdata->input_Q))
543 goto no;
544 for (prev = (Scsi_Cmnd *) hostdata->input_Q; prev; prev = (Scsi_Cmnd *) prev->host_scribble) {
545 if ((prev->device->id != cmd->device->id) || (prev->device->lun != cmd->device->lun)) {
546 for (prev = (Scsi_Cmnd *) hostdata->input_Q; prev; prev = (Scsi_Cmnd *) prev->host_scribble)
547 prev->SCp.phase = 1;
548 goto yes;
549 }
550 }
551 goto no;
552
553 yes:
554 cmd->SCp.phase = 1;
555
556#ifdef PROC_STATISTICS
557 hostdata->disc_allowed_cnt[cmd->device->id]++;
558#endif
559
560 no:
561 write_3393(hostdata, WD_SOURCE_ID, ((cmd->SCp.phase) ? SRCID_ER : 0));
562
563 write_3393(hostdata, WD_TARGET_LUN, cmd->device->lun);
564 write_3393(hostdata, WD_SYNCHRONOUS_TRANSFER, hostdata->sync_xfer[cmd->device->id]);
565 hostdata->busy[cmd->device->id] |= (1 << cmd->device->lun);
566
567 if ((hostdata->level2 <= L2_NONE) || (hostdata->sync_stat[cmd->device->id] == SS_UNSET)) {
568
569
570
571
572
573
574
575
576
577 hostdata->selecting = cmd;
578
579
580
581
582
583
584
585
586
587
588
589 if (hostdata->sync_stat[cmd->device->id] == SS_UNSET) {
590 if (hostdata->sync_off & (1 << cmd->device->id))
591 hostdata->sync_stat[cmd->device->id] = SS_SET;
592 else
593 hostdata->sync_stat[cmd->device->id] = SS_FIRST;
594 }
595 hostdata->state = S_SELECTING;
596 write_3393_count(hostdata, 0);
597 write_3393_cmd(hostdata, WD_CMD_SEL_ATN);
598 }
599
600 else {
601
602
603
604
605
606
607
608
609
610 hostdata->connected = cmd;
611 write_3393(hostdata, WD_COMMAND_PHASE, 0);
612
613
614
615
616
617 write1_io(WD_CDB_1, IO_WD_ADDR);
618 for (i = 0; i < cmd->cmd_len; i++)
619 write1_io(cmd->cmnd[i], IO_WD_DATA);
620
621
622
623
624
625
626
627 write_3393(hostdata, WD_OWN_ID, cmd->cmd_len);
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647 if (!(cmd->SCp.phase)) {
648 write_3393_count(hostdata, cmd->SCp.this_residual);
649 write_3393(hostdata, WD_CONTROL, CTRL_IDI | CTRL_EDI | CTRL_BUS);
650 write1_io(0, IO_FIFO_WRITE);
651
652 if (is_dir_out(cmd)) {
653 hostdata->fifo = FI_FIFO_WRITING;
654 if ((i = cmd->SCp.this_residual) > (IN2000_FIFO_SIZE - 16))
655 i = IN2000_FIFO_SIZE - 16;
656 cmd->SCp.have_data_in = i;
657 i >>= 1;
658 sp = (unsigned short *) cmd->SCp.ptr;
659 f = hostdata->io_base + IO_FIFO;
660
661#ifdef FAST_WRITE_IO
662
663 FAST_WRITE2_IO();
664#else
665 while (i--)
666 write2_io(*sp++, IO_FIFO);
667
668#endif
669
670
671
672 if (cmd->SCp.have_data_in <= ((IN2000_FIFO_SIZE - 16) - 32)) {
673 sp = flushbuf;
674 i = 16;
675
676#ifdef FAST_WRITE_IO
677
678 FAST_WRITE2_IO();
679#else
680 while (i--)
681 write2_io(0, IO_FIFO);
682
683#endif
684
685 }
686 }
687
688 else {
689 write1_io(0, IO_FIFO_READ);
690 hostdata->fifo = FI_FIFO_READING;
691 cmd->SCp.have_data_in = 0;
692 }
693
694 } else {
695 write_3393_count(hostdata, 0);
696 }
697 hostdata->state = S_RUNNING_LEVEL2;
698 write_3393_cmd(hostdata, WD_CMD_SEL_ATN_XFER);
699 }
700
701
702
703
704
705
706
707
708 DB(DB_EXECUTE, printk("%s%ld)EX-2 ", (cmd->SCp.phase) ? "d:" : "", cmd->serial_number))
709
710}
711
712
713
714static void transfer_pio(uchar * buf, int cnt, int data_in_dir, struct IN2000_hostdata *hostdata)
715{
716 uchar asr;
717
718 DB(DB_TRANSFER, printk("(%p,%d,%s)", buf, cnt, data_in_dir ? "in" : "out"))
719
720 write_3393(hostdata, WD_CONTROL, CTRL_IDI | CTRL_EDI | CTRL_POLLED);
721 write_3393_count(hostdata, cnt);
722 write_3393_cmd(hostdata, WD_CMD_TRANS_INFO);
723 if (data_in_dir) {
724 do {
725 asr = READ_AUX_STAT();
726 if (asr & ASR_DBR)
727 *buf++ = read_3393(hostdata, WD_DATA);
728 } while (!(asr & ASR_INT));
729 } else {
730 do {
731 asr = READ_AUX_STAT();
732 if (asr & ASR_DBR)
733 write_3393(hostdata, WD_DATA, *buf++);
734 } while (!(asr & ASR_INT));
735 }
736
737
738
739
740
741
742
743
744}
745
746
747
748static void transfer_bytes(Scsi_Cmnd * cmd, int data_in_dir)
749{
750 struct IN2000_hostdata *hostdata;
751 unsigned short *sp;
752 unsigned short f;
753 int i;
754
755 hostdata = (struct IN2000_hostdata *) cmd->device->host->hostdata;
756
757
758
759
760
761
762
763
764
765 if (!cmd->SCp.this_residual && cmd->SCp.buffers_residual) {
766 ++cmd->SCp.buffer;
767 --cmd->SCp.buffers_residual;
768 cmd->SCp.this_residual = cmd->SCp.buffer->length;
769 cmd->SCp.ptr = sg_virt(cmd->SCp.buffer);
770 }
771
772
773
774 write_3393(hostdata, WD_SYNCHRONOUS_TRANSFER, hostdata->sync_xfer[cmd->device->id]);
775 write_3393_count(hostdata, cmd->SCp.this_residual);
776 write_3393(hostdata, WD_CONTROL, CTRL_IDI | CTRL_EDI | CTRL_BUS);
777 write1_io(0, IO_FIFO_WRITE);
778
779
780
781
782
783 if (data_in_dir) {
784 write1_io(0, IO_FIFO_READ);
785 if ((hostdata->level2 >= L2_DATA) || (hostdata->level2 == L2_BASIC && cmd->SCp.phase == 0)) {
786 write_3393(hostdata, WD_COMMAND_PHASE, 0x45);
787 write_3393_cmd(hostdata, WD_CMD_SEL_ATN_XFER);
788 hostdata->state = S_RUNNING_LEVEL2;
789 } else
790 write_3393_cmd(hostdata, WD_CMD_TRANS_INFO);
791 hostdata->fifo = FI_FIFO_READING;
792 cmd->SCp.have_data_in = 0;
793 return;
794 }
795
796
797
798
799
800
801 if ((hostdata->level2 >= L2_DATA) || (hostdata->level2 == L2_BASIC && cmd->SCp.phase == 0)) {
802 write_3393(hostdata, WD_COMMAND_PHASE, 0x45);
803 write_3393_cmd(hostdata, WD_CMD_SEL_ATN_XFER);
804 hostdata->state = S_RUNNING_LEVEL2;
805 } else
806 write_3393_cmd(hostdata, WD_CMD_TRANS_INFO);
807 hostdata->fifo = FI_FIFO_WRITING;
808 sp = (unsigned short *) cmd->SCp.ptr;
809
810 if ((i = cmd->SCp.this_residual) > IN2000_FIFO_SIZE)
811 i = IN2000_FIFO_SIZE;
812 cmd->SCp.have_data_in = i;
813 i >>= 1;
814 f = hostdata->io_base + IO_FIFO;
815
816#ifdef FAST_WRITE_IO
817
818 FAST_WRITE2_IO();
819#else
820 while (i--)
821 write2_io(*sp++, IO_FIFO);
822
823#endif
824
825}
826
827
828
829
830
831
832
833
834static irqreturn_t in2000_intr(int irqnum, void *dev_id)
835{
836 struct Scsi_Host *instance = dev_id;
837 struct IN2000_hostdata *hostdata;
838 Scsi_Cmnd *patch, *cmd;
839 uchar asr, sr, phs, id, lun, *ucp, msg;
840 int i, j;
841 unsigned long length;
842 unsigned short *sp;
843 unsigned short f;
844 unsigned long flags;
845
846 hostdata = (struct IN2000_hostdata *) instance->hostdata;
847
848
849
850 spin_lock_irqsave(instance->host_lock, flags);
851
852#ifdef PROC_STATISTICS
853 hostdata->int_cnt++;
854#endif
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891 write1_io(0, IO_LED_ON);
892 asr = READ_AUX_STAT();
893 if (!(asr & ASR_INT)) {
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914 cmd = (Scsi_Cmnd *) hostdata->connected;
915 CHECK_NULL(cmd, "fifo_int")
916
917 if (hostdata->fifo == FI_FIFO_READING) {
918
919 DB(DB_FIFO, printk("{R:%02x} ", read1_io(IO_FIFO_COUNT)))
920
921 sp = (unsigned short *) (cmd->SCp.ptr + cmd->SCp.have_data_in);
922 i = read1_io(IO_FIFO_COUNT) & 0xfe;
923 i <<= 2;
924 f = hostdata->io_base + IO_FIFO;
925
926#ifdef FAST_READ_IO
927
928 FAST_READ2_IO();
929#else
930 while (i--)
931 *sp++ = read2_io(IO_FIFO);
932
933#endif
934
935 i = sp - (unsigned short *) (cmd->SCp.ptr + cmd->SCp.have_data_in);
936 i <<= 1;
937 cmd->SCp.have_data_in += i;
938 }
939
940 else if (hostdata->fifo == FI_FIFO_WRITING) {
941
942 DB(DB_FIFO, printk("{W:%02x} ", read1_io(IO_FIFO_COUNT)))
943
944
945
946
947
948
949
950
951
952
953
954 if (cmd->SCp.this_residual == cmd->SCp.have_data_in) {
955 i = 16;
956 while (i--)
957 write2_io(0, IO_FIFO);
958 }
959
960
961
962
963
964 else {
965 sp = (unsigned short *) (cmd->SCp.ptr + cmd->SCp.have_data_in);
966 i = cmd->SCp.this_residual - cmd->SCp.have_data_in;
967 j = read1_io(IO_FIFO_COUNT) & 0xfe;
968 j <<= 2;
969 if ((j << 1) > i)
970 j = (i >> 1);
971 while (j--)
972 write2_io(*sp++, IO_FIFO);
973
974 i = sp - (unsigned short *) (cmd->SCp.ptr + cmd->SCp.have_data_in);
975 i <<= 1;
976 cmd->SCp.have_data_in += i;
977 }
978 }
979
980 else {
981 printk("*** Spurious FIFO interrupt ***");
982 }
983
984 write1_io(0, IO_LED_OFF);
985
986
987 spin_unlock_irqrestore(instance->host_lock, flags);
988 return IRQ_HANDLED;
989 }
990
991
992
993
994
995
996 cmd = (Scsi_Cmnd *) hostdata->connected;
997 sr = read_3393(hostdata, WD_SCSI_STATUS);
998 phs = read_3393(hostdata, WD_COMMAND_PHASE);
999
1000 if (!cmd && (sr != CSR_RESEL_AM && sr != CSR_TIMEOUT && sr != CSR_SELECT)) {
1001 printk("\nNR:wd-intr-1\n");
1002 write1_io(0, IO_LED_OFF);
1003
1004
1005 spin_unlock_irqrestore(instance->host_lock, flags);
1006 return IRQ_HANDLED;
1007 }
1008
1009 DB(DB_INTR, printk("{%02x:%02x-", asr, sr))
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023 if (hostdata->fifo == FI_FIFO_READING) {
1024
1025
1026
1027 sp = (unsigned short *) (cmd->SCp.ptr + cmd->SCp.have_data_in);
1028
1029
1030
1031 i = (cmd->SCp.this_residual - read_3393_count(hostdata)) - cmd->SCp.have_data_in;
1032 i >>= 1;
1033 f = hostdata->io_base + IO_FIFO;
1034
1035#ifdef FAST_READ_IO
1036
1037 FAST_READ2_IO();
1038#else
1039 while (i--)
1040 *sp++ = read2_io(IO_FIFO);
1041
1042#endif
1043
1044 hostdata->fifo = FI_FIFO_UNUSED;
1045 length = cmd->SCp.this_residual;
1046 cmd->SCp.this_residual = read_3393_count(hostdata);
1047 cmd->SCp.ptr += (length - cmd->SCp.this_residual);
1048
1049 DB(DB_TRANSFER, printk("(%p,%d)", cmd->SCp.ptr, cmd->SCp.this_residual))
1050
1051 }
1052
1053 else if (hostdata->fifo == FI_FIFO_WRITING) {
1054 hostdata->fifo = FI_FIFO_UNUSED;
1055 length = cmd->SCp.this_residual;
1056 cmd->SCp.this_residual = read_3393_count(hostdata);
1057 cmd->SCp.ptr += (length - cmd->SCp.this_residual);
1058
1059 DB(DB_TRANSFER, printk("(%p,%d)", cmd->SCp.ptr, cmd->SCp.this_residual))
1060
1061 }
1062
1063
1064
1065 switch (sr) {
1066
1067 case CSR_TIMEOUT:
1068 DB(DB_INTR, printk("TIMEOUT"))
1069
1070 if (hostdata->state == S_RUNNING_LEVEL2)
1071 hostdata->connected = NULL;
1072 else {
1073 cmd = (Scsi_Cmnd *) hostdata->selecting;
1074 CHECK_NULL(cmd, "csr_timeout")
1075 hostdata->selecting = NULL;
1076 }
1077
1078 cmd->result = DID_NO_CONNECT << 16;
1079 hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
1080 hostdata->state = S_UNCONNECTED;
1081 cmd->scsi_done(cmd);
1082
1083
1084
1085
1086
1087 in2000_execute(instance);
1088 break;
1089
1090
1091
1092
1093 case CSR_SELECT:
1094 DB(DB_INTR, printk("SELECT"))
1095 hostdata->connected = cmd = (Scsi_Cmnd *) hostdata->selecting;
1096 CHECK_NULL(cmd, "csr_select")
1097 hostdata->selecting = NULL;
1098
1099
1100
1101 hostdata->outgoing_msg[0] = (0x80 | 0x00 | cmd->device->lun);
1102 if (cmd->SCp.phase)
1103 hostdata->outgoing_msg[0] |= 0x40;
1104
1105 if (hostdata->sync_stat[cmd->device->id] == SS_FIRST) {
1106#ifdef SYNC_DEBUG
1107 printk(" sending SDTR ");
1108#endif
1109
1110 hostdata->sync_stat[cmd->device->id] = SS_WAITING;
1111
1112
1113
1114 hostdata->outgoing_msg[1] = EXTENDED_MESSAGE;
1115 hostdata->outgoing_msg[2] = 3;
1116 hostdata->outgoing_msg[3] = EXTENDED_SDTR;
1117 hostdata->outgoing_msg[4] = OPTIMUM_SX_PER / 4;
1118 hostdata->outgoing_msg[5] = OPTIMUM_SX_OFF;
1119 hostdata->outgoing_len = 6;
1120 } else
1121 hostdata->outgoing_len = 1;
1122
1123 hostdata->state = S_CONNECTED;
1124 break;
1125
1126
1127 case CSR_XFER_DONE | PHS_DATA_IN:
1128 case CSR_UNEXP | PHS_DATA_IN:
1129 case CSR_SRV_REQ | PHS_DATA_IN:
1130 DB(DB_INTR, printk("IN-%d.%d", cmd->SCp.this_residual, cmd->SCp.buffers_residual))
1131 transfer_bytes(cmd, DATA_IN_DIR);
1132 if (hostdata->state != S_RUNNING_LEVEL2)
1133 hostdata->state = S_CONNECTED;
1134 break;
1135
1136
1137 case CSR_XFER_DONE | PHS_DATA_OUT:
1138 case CSR_UNEXP | PHS_DATA_OUT:
1139 case CSR_SRV_REQ | PHS_DATA_OUT:
1140 DB(DB_INTR, printk("OUT-%d.%d", cmd->SCp.this_residual, cmd->SCp.buffers_residual))
1141 transfer_bytes(cmd, DATA_OUT_DIR);
1142 if (hostdata->state != S_RUNNING_LEVEL2)
1143 hostdata->state = S_CONNECTED;
1144 break;
1145
1146
1147
1148
1149 case CSR_XFER_DONE | PHS_COMMAND:
1150 case CSR_UNEXP | PHS_COMMAND:
1151 case CSR_SRV_REQ | PHS_COMMAND:
1152 DB(DB_INTR, printk("CMND-%02x,%ld", cmd->cmnd[0], cmd->serial_number))
1153 transfer_pio(cmd->cmnd, cmd->cmd_len, DATA_OUT_DIR, hostdata);
1154 hostdata->state = S_CONNECTED;
1155 break;
1156
1157
1158 case CSR_XFER_DONE | PHS_STATUS:
1159 case CSR_UNEXP | PHS_STATUS:
1160 case CSR_SRV_REQ | PHS_STATUS:
1161 DB(DB_INTR, printk("STATUS="))
1162
1163 cmd->SCp.Status = read_1_byte(hostdata);
1164 DB(DB_INTR, printk("%02x", cmd->SCp.Status))
1165 if (hostdata->level2 >= L2_BASIC) {
1166 sr = read_3393(hostdata, WD_SCSI_STATUS);
1167 hostdata->state = S_RUNNING_LEVEL2;
1168 write_3393(hostdata, WD_COMMAND_PHASE, 0x50);
1169 write_3393_cmd(hostdata, WD_CMD_SEL_ATN_XFER);
1170 } else {
1171 hostdata->state = S_CONNECTED;
1172 }
1173 break;
1174
1175
1176 case CSR_XFER_DONE | PHS_MESS_IN:
1177 case CSR_UNEXP | PHS_MESS_IN:
1178 case CSR_SRV_REQ | PHS_MESS_IN:
1179 DB(DB_INTR, printk("MSG_IN="))
1180
1181 msg = read_1_byte(hostdata);
1182 sr = read_3393(hostdata, WD_SCSI_STATUS);
1183
1184 hostdata->incoming_msg[hostdata->incoming_ptr] = msg;
1185 if (hostdata->incoming_msg[0] == EXTENDED_MESSAGE)
1186 msg = EXTENDED_MESSAGE;
1187 else
1188 hostdata->incoming_ptr = 0;
1189
1190 cmd->SCp.Message = msg;
1191 switch (msg) {
1192
1193 case COMMAND_COMPLETE:
1194 DB(DB_INTR, printk("CCMP-%ld", cmd->serial_number))
1195 write_3393_cmd(hostdata, WD_CMD_NEGATE_ACK);
1196 hostdata->state = S_PRE_CMP_DISC;
1197 break;
1198
1199 case SAVE_POINTERS:
1200 DB(DB_INTR, printk("SDP"))
1201 write_3393_cmd(hostdata, WD_CMD_NEGATE_ACK);
1202 hostdata->state = S_CONNECTED;
1203 break;
1204
1205 case RESTORE_POINTERS:
1206 DB(DB_INTR, printk("RDP"))
1207 if (hostdata->level2 >= L2_BASIC) {
1208 write_3393(hostdata, WD_COMMAND_PHASE, 0x45);
1209 write_3393_cmd(hostdata, WD_CMD_SEL_ATN_XFER);
1210 hostdata->state = S_RUNNING_LEVEL2;
1211 } else {
1212 write_3393_cmd(hostdata, WD_CMD_NEGATE_ACK);
1213 hostdata->state = S_CONNECTED;
1214 }
1215 break;
1216
1217 case DISCONNECT:
1218 DB(DB_INTR, printk("DIS"))
1219 cmd->device->disconnect = 1;
1220 write_3393_cmd(hostdata, WD_CMD_NEGATE_ACK);
1221 hostdata->state = S_PRE_TMP_DISC;
1222 break;
1223
1224 case MESSAGE_REJECT:
1225 DB(DB_INTR, printk("REJ"))
1226#ifdef SYNC_DEBUG
1227 printk("-REJ-");
1228#endif
1229 if (hostdata->sync_stat[cmd->device->id] == SS_WAITING)
1230 hostdata->sync_stat[cmd->device->id] = SS_SET;
1231 write_3393_cmd(hostdata, WD_CMD_NEGATE_ACK);
1232 hostdata->state = S_CONNECTED;
1233 break;
1234
1235 case EXTENDED_MESSAGE:
1236 DB(DB_INTR, printk("EXT"))
1237
1238 ucp = hostdata->incoming_msg;
1239
1240#ifdef SYNC_DEBUG
1241 printk("%02x", ucp[hostdata->incoming_ptr]);
1242#endif
1243
1244
1245 if ((hostdata->incoming_ptr >= 2) && (hostdata->incoming_ptr == (ucp[1] + 1))) {
1246
1247 switch (ucp[2]) {
1248 case EXTENDED_SDTR:
1249 id = calc_sync_xfer(ucp[3], ucp[4]);
1250 if (hostdata->sync_stat[cmd->device->id] != SS_WAITING) {
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261 write_3393_cmd(hostdata, WD_CMD_ASSERT_ATN);
1262 hostdata->outgoing_msg[0] = EXTENDED_MESSAGE;
1263 hostdata->outgoing_msg[1] = 3;
1264 hostdata->outgoing_msg[2] = EXTENDED_SDTR;
1265 hostdata->outgoing_msg[3] = hostdata->default_sx_per / 4;
1266 hostdata->outgoing_msg[4] = 0;
1267 hostdata->outgoing_len = 5;
1268 hostdata->sync_xfer[cmd->device->id] = calc_sync_xfer(hostdata->default_sx_per / 4, 0);
1269 } else {
1270 hostdata->sync_xfer[cmd->device->id] = id;
1271 }
1272#ifdef SYNC_DEBUG
1273 printk("sync_xfer=%02x", hostdata->sync_xfer[cmd->device->id]);
1274#endif
1275 hostdata->sync_stat[cmd->device->id] = SS_SET;
1276 write_3393_cmd(hostdata, WD_CMD_NEGATE_ACK);
1277 hostdata->state = S_CONNECTED;
1278 break;
1279 case EXTENDED_WDTR:
1280 write_3393_cmd(hostdata, WD_CMD_ASSERT_ATN);
1281 printk("sending WDTR ");
1282 hostdata->outgoing_msg[0] = EXTENDED_MESSAGE;
1283 hostdata->outgoing_msg[1] = 2;
1284 hostdata->outgoing_msg[2] = EXTENDED_WDTR;
1285 hostdata->outgoing_msg[3] = 0;
1286 hostdata->outgoing_len = 4;
1287 write_3393_cmd(hostdata, WD_CMD_NEGATE_ACK);
1288 hostdata->state = S_CONNECTED;
1289 break;
1290 default:
1291 write_3393_cmd(hostdata, WD_CMD_ASSERT_ATN);
1292 printk("Rejecting Unknown Extended Message(%02x). ", ucp[2]);
1293 hostdata->outgoing_msg[0] = MESSAGE_REJECT;
1294 hostdata->outgoing_len = 1;
1295 write_3393_cmd(hostdata, WD_CMD_NEGATE_ACK);
1296 hostdata->state = S_CONNECTED;
1297 break;
1298 }
1299 hostdata->incoming_ptr = 0;
1300 }
1301
1302
1303
1304 else {
1305 hostdata->incoming_ptr++;
1306 write_3393_cmd(hostdata, WD_CMD_NEGATE_ACK);
1307 hostdata->state = S_CONNECTED;
1308 }
1309 break;
1310
1311 default:
1312 printk("Rejecting Unknown Message(%02x) ", msg);
1313 write_3393_cmd(hostdata, WD_CMD_ASSERT_ATN);
1314 hostdata->outgoing_msg[0] = MESSAGE_REJECT;
1315 hostdata->outgoing_len = 1;
1316 write_3393_cmd(hostdata, WD_CMD_NEGATE_ACK);
1317 hostdata->state = S_CONNECTED;
1318 }
1319 break;
1320
1321
1322
1323
1324 case CSR_SEL_XFER_DONE:
1325
1326
1327
1328
1329
1330 write_3393(hostdata, WD_SOURCE_ID, SRCID_ER);
1331 if (phs == 0x60) {
1332 DB(DB_INTR, printk("SX-DONE-%ld", cmd->serial_number))
1333 cmd->SCp.Message = COMMAND_COMPLETE;
1334 lun = read_3393(hostdata, WD_TARGET_LUN);
1335 DB(DB_INTR, printk(":%d.%d", cmd->SCp.Status, lun))
1336 hostdata->connected = NULL;
1337 hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
1338 hostdata->state = S_UNCONNECTED;
1339 if (cmd->SCp.Status == ILLEGAL_STATUS_BYTE)
1340 cmd->SCp.Status = lun;
1341 if (cmd->cmnd[0] == REQUEST_SENSE && cmd->SCp.Status != GOOD)
1342 cmd->result = (cmd->result & 0x00ffff) | (DID_ERROR << 16);
1343 else
1344 cmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8);
1345 cmd->scsi_done(cmd);
1346
1347
1348
1349
1350
1351 in2000_execute(instance);
1352 } else {
1353 printk("%02x:%02x:%02x-%ld: Unknown SEL_XFER_DONE phase!!---", asr, sr, phs, cmd->serial_number);
1354 }
1355 break;
1356
1357
1358
1359
1360 case CSR_SDP:
1361 DB(DB_INTR, printk("SDP"))
1362 hostdata->state = S_RUNNING_LEVEL2;
1363 write_3393(hostdata, WD_COMMAND_PHASE, 0x41);
1364 write_3393_cmd(hostdata, WD_CMD_SEL_ATN_XFER);
1365 break;
1366
1367
1368 case CSR_XFER_DONE | PHS_MESS_OUT:
1369 case CSR_UNEXP | PHS_MESS_OUT:
1370 case CSR_SRV_REQ | PHS_MESS_OUT:
1371 DB(DB_INTR, printk("MSG_OUT="))
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385 if (hostdata->outgoing_len == 0) {
1386 hostdata->outgoing_len = 1;
1387 hostdata->outgoing_msg[0] = NOP;
1388 }
1389 transfer_pio(hostdata->outgoing_msg, hostdata->outgoing_len, DATA_OUT_DIR, hostdata);
1390 DB(DB_INTR, printk("%02x", hostdata->outgoing_msg[0]))
1391 hostdata->outgoing_len = 0;
1392 hostdata->state = S_CONNECTED;
1393 break;
1394
1395
1396 case CSR_UNEXP_DISC:
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411 write_3393(hostdata, WD_SOURCE_ID, SRCID_ER);
1412 if (cmd == NULL) {
1413 printk(" - Already disconnected! ");
1414 hostdata->state = S_UNCONNECTED;
1415
1416
1417 spin_unlock_irqrestore(instance->host_lock, flags);
1418 return IRQ_HANDLED;
1419 }
1420 DB(DB_INTR, printk("UNEXP_DISC-%ld", cmd->serial_number))
1421 hostdata->connected = NULL;
1422 hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
1423 hostdata->state = S_UNCONNECTED;
1424 if (cmd->cmnd[0] == REQUEST_SENSE && cmd->SCp.Status != GOOD)
1425 cmd->result = (cmd->result & 0x00ffff) | (DID_ERROR << 16);
1426 else
1427 cmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8);
1428 cmd->scsi_done(cmd);
1429
1430
1431
1432
1433
1434 in2000_execute(instance);
1435 break;
1436
1437
1438 case CSR_DISC:
1439
1440
1441
1442
1443
1444 write_3393(hostdata, WD_SOURCE_ID, SRCID_ER);
1445 DB(DB_INTR, printk("DISC-%ld", cmd->serial_number))
1446 if (cmd == NULL) {
1447 printk(" - Already disconnected! ");
1448 hostdata->state = S_UNCONNECTED;
1449 }
1450 switch (hostdata->state) {
1451 case S_PRE_CMP_DISC:
1452 hostdata->connected = NULL;
1453 hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
1454 hostdata->state = S_UNCONNECTED;
1455 DB(DB_INTR, printk(":%d", cmd->SCp.Status))
1456 if (cmd->cmnd[0] == REQUEST_SENSE && cmd->SCp.Status != GOOD)
1457 cmd->result = (cmd->result & 0x00ffff) | (DID_ERROR << 16);
1458 else
1459 cmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8);
1460 cmd->scsi_done(cmd);
1461 break;
1462 case S_PRE_TMP_DISC:
1463 case S_RUNNING_LEVEL2:
1464 cmd->host_scribble = (uchar *) hostdata->disconnected_Q;
1465 hostdata->disconnected_Q = cmd;
1466 hostdata->connected = NULL;
1467 hostdata->state = S_UNCONNECTED;
1468
1469#ifdef PROC_STATISTICS
1470 hostdata->disc_done_cnt[cmd->device->id]++;
1471#endif
1472
1473 break;
1474 default:
1475 printk("*** Unexpected DISCONNECT interrupt! ***");
1476 hostdata->state = S_UNCONNECTED;
1477 }
1478
1479
1480
1481
1482
1483 in2000_execute(instance);
1484 break;
1485
1486
1487 case CSR_RESEL_AM:
1488 DB(DB_INTR, printk("RESEL"))
1489
1490
1491
1492
1493 if (hostdata->level2 <= L2_NONE) {
1494
1495 if (hostdata->selecting) {
1496 cmd = (Scsi_Cmnd *) hostdata->selecting;
1497 hostdata->selecting = NULL;
1498 hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
1499 cmd->host_scribble = (uchar *) hostdata->input_Q;
1500 hostdata->input_Q = cmd;
1501 }
1502 }
1503
1504 else {
1505
1506 if (cmd) {
1507 if (phs == 0x00) {
1508 hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
1509 cmd->host_scribble = (uchar *) hostdata->input_Q;
1510 hostdata->input_Q = cmd;
1511 } else {
1512 printk("---%02x:%02x:%02x-TROUBLE: Intrusive ReSelect!---", asr, sr, phs);
1513 while (1)
1514 printk("\r");
1515 }
1516 }
1517
1518 }
1519
1520
1521
1522 id = read_3393(hostdata, WD_SOURCE_ID);
1523 id &= SRCID_MASK;
1524
1525
1526
1527
1528
1529
1530 lun = read_3393(hostdata, WD_DATA);
1531 if (hostdata->level2 < L2_RESELECT)
1532 write_3393_cmd(hostdata, WD_CMD_NEGATE_ACK);
1533 lun &= 7;
1534
1535
1536
1537 cmd = (Scsi_Cmnd *) hostdata->disconnected_Q;
1538 patch = NULL;
1539 while (cmd) {
1540 if (id == cmd->device->id && lun == cmd->device->lun)
1541 break;
1542 patch = cmd;
1543 cmd = (Scsi_Cmnd *) cmd->host_scribble;
1544 }
1545
1546
1547
1548 if (!cmd) {
1549 printk("---TROUBLE: target %d.%d not in disconnect queue---", id, lun);
1550 break;
1551 }
1552
1553
1554
1555 if (patch)
1556 patch->host_scribble = cmd->host_scribble;
1557 else
1558 hostdata->disconnected_Q = (Scsi_Cmnd *) cmd->host_scribble;
1559 hostdata->connected = cmd;
1560
1561
1562
1563
1564
1565
1566 if (is_dir_out(cmd))
1567 write_3393(hostdata, WD_DESTINATION_ID, cmd->device->id);
1568 else
1569 write_3393(hostdata, WD_DESTINATION_ID, cmd->device->id | DSTID_DPD);
1570 if (hostdata->level2 >= L2_RESELECT) {
1571 write_3393_count(hostdata, 0);
1572 write_3393(hostdata, WD_COMMAND_PHASE, 0x45);
1573 write_3393_cmd(hostdata, WD_CMD_SEL_ATN_XFER);
1574 hostdata->state = S_RUNNING_LEVEL2;
1575 } else
1576 hostdata->state = S_CONNECTED;
1577
1578 DB(DB_INTR, printk("-%ld", cmd->serial_number))
1579 break;
1580
1581 default:
1582 printk("--UNKNOWN INTERRUPT:%02x:%02x:%02x--", asr, sr, phs);
1583 }
1584
1585 write1_io(0, IO_LED_OFF);
1586
1587 DB(DB_INTR, printk("} "))
1588
1589
1590 spin_unlock_irqrestore(instance->host_lock, flags);
1591 return IRQ_HANDLED;
1592}
1593
1594
1595
1596#define RESET_CARD 0
1597#define RESET_CARD_AND_BUS 1
1598#define B_FLAG 0x80
1599
1600
1601
1602
1603
1604static int reset_hardware(struct Scsi_Host *instance, int type)
1605{
1606 struct IN2000_hostdata *hostdata;
1607 int qt, x;
1608
1609 hostdata = (struct IN2000_hostdata *) instance->hostdata;
1610
1611 write1_io(0, IO_LED_ON);
1612 if (type == RESET_CARD_AND_BUS) {
1613 write1_io(0, IO_CARD_RESET);
1614 x = read1_io(IO_HARDWARE);
1615 }
1616 x = read_3393(hostdata, WD_SCSI_STATUS);
1617 write_3393(hostdata, WD_OWN_ID, instance->this_id | OWNID_EAF | OWNID_RAF | OWNID_FS_8);
1618 write_3393(hostdata, WD_CONTROL, CTRL_IDI | CTRL_EDI | CTRL_POLLED);
1619 write_3393(hostdata, WD_SYNCHRONOUS_TRANSFER, calc_sync_xfer(hostdata->default_sx_per / 4, DEFAULT_SX_OFF));
1620
1621 write1_io(0, IO_FIFO_WRITE);
1622 write1_io(0, IO_FIFO_READ);
1623 write_3393(hostdata, WD_COMMAND, WD_CMD_RESET);
1624
1625 while (!(READ_AUX_STAT() & ASR_INT))
1626 cpu_relax();
1627
1628 x = read_3393(hostdata, WD_SCSI_STATUS);
1629
1630 write_3393(hostdata, WD_QUEUE_TAG, 0xa5);
1631 qt = read_3393(hostdata, WD_QUEUE_TAG);
1632 if (qt == 0xa5) {
1633 x |= B_FLAG;
1634 write_3393(hostdata, WD_QUEUE_TAG, 0);
1635 }
1636 write_3393(hostdata, WD_TIMEOUT_PERIOD, TIMEOUT_PERIOD_VALUE);
1637 write_3393(hostdata, WD_CONTROL, CTRL_IDI | CTRL_EDI | CTRL_POLLED);
1638 write1_io(0, IO_LED_OFF);
1639 return x;
1640}
1641
1642
1643
1644static int in2000_bus_reset(Scsi_Cmnd * cmd)
1645{
1646 struct Scsi_Host *instance;
1647 struct IN2000_hostdata *hostdata;
1648 int x;
1649 unsigned long flags;
1650
1651 instance = cmd->device->host;
1652 hostdata = (struct IN2000_hostdata *) instance->hostdata;
1653
1654 printk(KERN_WARNING "scsi%d: Reset. ", instance->host_no);
1655
1656 spin_lock_irqsave(instance->host_lock, flags);
1657
1658
1659 reset_hardware(instance, RESET_CARD_AND_BUS);
1660 for (x = 0; x < 8; x++) {
1661 hostdata->busy[x] = 0;
1662 hostdata->sync_xfer[x] = calc_sync_xfer(DEFAULT_SX_PER / 4, DEFAULT_SX_OFF);
1663 hostdata->sync_stat[x] = SS_UNSET;
1664 }
1665 hostdata->input_Q = NULL;
1666 hostdata->selecting = NULL;
1667 hostdata->connected = NULL;
1668 hostdata->disconnected_Q = NULL;
1669 hostdata->state = S_UNCONNECTED;
1670 hostdata->fifo = FI_FIFO_UNUSED;
1671 hostdata->incoming_ptr = 0;
1672 hostdata->outgoing_len = 0;
1673
1674 cmd->result = DID_RESET << 16;
1675
1676 spin_unlock_irqrestore(instance->host_lock, flags);
1677 return SUCCESS;
1678}
1679
1680static int __in2000_abort(Scsi_Cmnd * cmd)
1681{
1682 struct Scsi_Host *instance;
1683 struct IN2000_hostdata *hostdata;
1684 Scsi_Cmnd *tmp, *prev;
1685 uchar sr, asr;
1686 unsigned long timeout;
1687
1688 instance = cmd->device->host;
1689 hostdata = (struct IN2000_hostdata *) instance->hostdata;
1690
1691 printk(KERN_DEBUG "scsi%d: Abort-", instance->host_no);
1692 printk("(asr=%02x,count=%ld,resid=%d,buf_resid=%d,have_data=%d,FC=%02x)- ", READ_AUX_STAT(), read_3393_count(hostdata), cmd->SCp.this_residual, cmd->SCp.buffers_residual, cmd->SCp.have_data_in, read1_io(IO_FIFO_COUNT));
1693
1694
1695
1696
1697
1698
1699 tmp = (Scsi_Cmnd *) hostdata->input_Q;
1700 prev = NULL;
1701 while (tmp) {
1702 if (tmp == cmd) {
1703 if (prev)
1704 prev->host_scribble = cmd->host_scribble;
1705 cmd->host_scribble = NULL;
1706 cmd->result = DID_ABORT << 16;
1707 printk(KERN_WARNING "scsi%d: Abort - removing command %ld from input_Q. ", instance->host_no, cmd->serial_number);
1708 cmd->scsi_done(cmd);
1709 return SUCCESS;
1710 }
1711 prev = tmp;
1712 tmp = (Scsi_Cmnd *) tmp->host_scribble;
1713 }
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726 if (hostdata->connected == cmd) {
1727
1728 printk(KERN_WARNING "scsi%d: Aborting connected command %ld - ", instance->host_no, cmd->serial_number);
1729
1730 printk("sending wd33c93 ABORT command - ");
1731 write_3393(hostdata, WD_CONTROL, CTRL_IDI | CTRL_EDI | CTRL_POLLED);
1732 write_3393_cmd(hostdata, WD_CMD_ABORT);
1733
1734
1735
1736 printk("flushing fifo - ");
1737 timeout = 1000000;
1738 do {
1739 asr = READ_AUX_STAT();
1740 if (asr & ASR_DBR)
1741 read_3393(hostdata, WD_DATA);
1742 } while (!(asr & ASR_INT) && timeout-- > 0);
1743 sr = read_3393(hostdata, WD_SCSI_STATUS);
1744 printk("asr=%02x, sr=%02x, %ld bytes un-transferred (timeout=%ld) - ", asr, sr, read_3393_count(hostdata), timeout);
1745
1746
1747
1748
1749
1750
1751
1752 printk("sending wd33c93 DISCONNECT command - ");
1753 write_3393_cmd(hostdata, WD_CMD_DISCONNECT);
1754
1755 timeout = 1000000;
1756 asr = READ_AUX_STAT();
1757 while ((asr & ASR_CIP) && timeout-- > 0)
1758 asr = READ_AUX_STAT();
1759 sr = read_3393(hostdata, WD_SCSI_STATUS);
1760 printk("asr=%02x, sr=%02x.", asr, sr);
1761
1762 hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
1763 hostdata->connected = NULL;
1764 hostdata->state = S_UNCONNECTED;
1765 cmd->result = DID_ABORT << 16;
1766 cmd->scsi_done(cmd);
1767
1768 in2000_execute(instance);
1769
1770 return SUCCESS;
1771 }
1772
1773
1774
1775
1776
1777
1778
1779 for (tmp = (Scsi_Cmnd *) hostdata->disconnected_Q; tmp; tmp = (Scsi_Cmnd *) tmp->host_scribble)
1780 if (cmd == tmp) {
1781 printk(KERN_DEBUG "scsi%d: unable to abort disconnected command.\n", instance->host_no);
1782 return FAILED;
1783 }
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795 in2000_execute(instance);
1796
1797 printk("scsi%d: warning : SCSI command probably completed successfully" " before abortion. ", instance->host_no);
1798 return SUCCESS;
1799}
1800
1801static int in2000_abort(Scsi_Cmnd * cmd)
1802{
1803 int rc;
1804
1805 spin_lock_irq(cmd->device->host->host_lock);
1806 rc = __in2000_abort(cmd);
1807 spin_unlock_irq(cmd->device->host->host_lock);
1808
1809 return rc;
1810}
1811
1812
1813#define MAX_IN2000_HOSTS 3
1814#define MAX_SETUP_ARGS ARRAY_SIZE(setup_args)
1815#define SETUP_BUFFER_SIZE 200
1816static char setup_buffer[SETUP_BUFFER_SIZE];
1817static char setup_used[MAX_SETUP_ARGS];
1818static int done_setup = 0;
1819
1820static void __init in2000_setup(char *str, int *ints)
1821{
1822 int i;
1823 char *p1, *p2;
1824
1825 strlcpy(setup_buffer, str, SETUP_BUFFER_SIZE);
1826 p1 = setup_buffer;
1827 i = 0;
1828 while (*p1 && (i < MAX_SETUP_ARGS)) {
1829 p2 = strchr(p1, ',');
1830 if (p2) {
1831 *p2 = '\0';
1832 if (p1 != p2)
1833 setup_args[i] = p1;
1834 p1 = p2 + 1;
1835 i++;
1836 } else {
1837 setup_args[i] = p1;
1838 break;
1839 }
1840 }
1841 for (i = 0; i < MAX_SETUP_ARGS; i++)
1842 setup_used[i] = 0;
1843 done_setup = 1;
1844}
1845
1846
1847
1848
1849
1850static int __init check_setup_args(char *key, int *val, char *buf)
1851{
1852 int x;
1853 char *cp;
1854
1855 for (x = 0; x < MAX_SETUP_ARGS; x++) {
1856 if (setup_used[x])
1857 continue;
1858 if (!strncmp(setup_args[x], key, strlen(key)))
1859 break;
1860 }
1861 if (x == MAX_SETUP_ARGS)
1862 return 0;
1863 setup_used[x] = 1;
1864 cp = setup_args[x] + strlen(key);
1865 *val = -1;
1866 if (*cp != ':')
1867 return ++x;
1868 cp++;
1869 if ((*cp >= '0') && (*cp <= '9')) {
1870 *val = simple_strtoul(cp, NULL, 0);
1871 }
1872 return ++x;
1873}
1874
1875
1876
1877
1878
1879
1880
1881
1882static u32 bios_tab[] in2000__INITDATA = {
1883 0xc8000,
1884 0xd0000,
1885 0xd8000,
1886 0
1887};
1888
1889static unsigned short base_tab[] in2000__INITDATA = {
1890 0x220,
1891 0x200,
1892 0x110,
1893 0x100,
1894};
1895
1896static int int_tab[] in2000__INITDATA = {
1897 15,
1898 14,
1899 11,
1900 10
1901};
1902
1903static int probe_bios(u32 addr, u32 *s1, uchar *switches)
1904{
1905 void __iomem *p = ioremap(addr, 0x34);
1906 if (!p)
1907 return 0;
1908 *s1 = readl(p + 0x10);
1909 if (*s1 == 0x41564f4e || readl(p + 0x30) == 0x61776c41) {
1910
1911 *switches = ~readb(p + 0x20);
1912 iounmap(p);
1913 return 1;
1914 }
1915 iounmap(p);
1916 return 0;
1917}
1918
1919static int __init in2000_detect(struct scsi_host_template * tpnt)
1920{
1921 struct Scsi_Host *instance;
1922 struct IN2000_hostdata *hostdata;
1923 int detect_count;
1924 int bios;
1925 int x;
1926 unsigned short base;
1927 uchar switches;
1928 uchar hrev;
1929 unsigned long flags;
1930 int val;
1931 char buf[32];
1932
1933
1934
1935
1936
1937
1938
1939
1940
1941
1942
1943
1944
1945 if (!done_setup && setup_strings)
1946 in2000_setup(setup_strings, NULL);
1947
1948 detect_count = 0;
1949 for (bios = 0; bios_tab[bios]; bios++) {
1950 u32 s1 = 0;
1951 if (check_setup_args("ioport", &val, buf)) {
1952 base = val;
1953 switches = ~inb(base + IO_SWITCHES) & 0xff;
1954 printk("Forcing IN2000 detection at IOport 0x%x ", base);
1955 bios = 2;
1956 }
1957
1958
1959
1960
1961
1962 else if (probe_bios(bios_tab[bios], &s1, &switches)) {
1963 printk("Found IN2000 BIOS at 0x%x ", (unsigned int) bios_tab[bios]);
1964
1965
1966
1967 x = switches & (SW_ADDR0 | SW_ADDR1);
1968 base = base_tab[x];
1969
1970
1971
1972 x = ~inb(base + IO_SWITCHES) & 0xff;
1973 if (x != switches) {
1974 printk("Bad IO signature: %02x vs %02x.\n", x, switches);
1975 continue;
1976 }
1977 } else
1978 continue;
1979
1980
1981
1982 if (!(switches & SW_BIT7)) {
1983 printk("There is no IN-2000 SCSI card at IOport 0x%03x!\n", base);
1984 continue;
1985 }
1986
1987
1988
1989
1990
1991
1992 hrev = inb(base + IO_HARDWARE);
1993
1994
1995 if (switches & SW_DISINT) {
1996 printk("The IN-2000 SCSI card at IOport 0x%03x ", base);
1997 printk("is not configured for interrupt operation!\n");
1998 printk("This driver requires an interrupt: cancelling detection.\n");
1999 continue;
2000 }
2001
2002
2003
2004
2005
2006 tpnt->proc_name = "in2000";
2007 instance = scsi_register(tpnt, sizeof(struct IN2000_hostdata));
2008 if (instance == NULL)
2009 continue;
2010 detect_count++;
2011 hostdata = (struct IN2000_hostdata *) instance->hostdata;
2012 instance->io_port = hostdata->io_base = base;
2013 hostdata->dip_switch = switches;
2014 hostdata->hrev = hrev;
2015
2016 write1_io(0, IO_FIFO_WRITE);
2017 write1_io(0, IO_FIFO_READ);
2018 write1_io(0, IO_INTR_MASK);
2019 x = int_tab[(switches & (SW_INT0 | SW_INT1)) >> SW_INT_SHIFT];
2020 if (request_irq(x, in2000_intr, IRQF_DISABLED, "in2000", instance)) {
2021 printk("in2000_detect: Unable to allocate IRQ.\n");
2022 detect_count--;
2023 continue;
2024 }
2025 instance->irq = x;
2026 instance->n_io_port = 13;
2027 request_region(base, 13, "in2000");
2028
2029 for (x = 0; x < 8; x++) {
2030 hostdata->busy[x] = 0;
2031 hostdata->sync_xfer[x] = calc_sync_xfer(DEFAULT_SX_PER / 4, DEFAULT_SX_OFF);
2032 hostdata->sync_stat[x] = SS_UNSET;
2033#ifdef PROC_STATISTICS
2034 hostdata->cmd_cnt[x] = 0;
2035 hostdata->disc_allowed_cnt[x] = 0;
2036 hostdata->disc_done_cnt[x] = 0;
2037#endif
2038 }
2039 hostdata->input_Q = NULL;
2040 hostdata->selecting = NULL;
2041 hostdata->connected = NULL;
2042 hostdata->disconnected_Q = NULL;
2043 hostdata->state = S_UNCONNECTED;
2044 hostdata->fifo = FI_FIFO_UNUSED;
2045 hostdata->level2 = L2_BASIC;
2046 hostdata->disconnect = DIS_ADAPTIVE;
2047 hostdata->args = DEBUG_DEFAULTS;
2048 hostdata->incoming_ptr = 0;
2049 hostdata->outgoing_len = 0;
2050 hostdata->default_sx_per = DEFAULT_SX_PER;
2051
2052
2053
2054 if (s1 == 0x41564f4e && (switches & SW_SYNC_DOS5))
2055 hostdata->sync_off = 0x00;
2056 else
2057 hostdata->sync_off = 0xff;
2058
2059#ifdef PROC_INTERFACE
2060 hostdata->proc = PR_VERSION | PR_INFO | PR_STATISTICS | PR_CONNECTED | PR_INPUTQ | PR_DISCQ | PR_STOP;
2061#ifdef PROC_STATISTICS
2062 hostdata->int_cnt = 0;
2063#endif
2064#endif
2065
2066 if (check_setup_args("nosync", &val, buf))
2067 hostdata->sync_off = val;
2068
2069 if (check_setup_args("period", &val, buf))
2070 hostdata->default_sx_per = sx_table[round_period((unsigned int) val)].period_ns;
2071
2072 if (check_setup_args("disconnect", &val, buf)) {
2073 if ((val >= DIS_NEVER) && (val <= DIS_ALWAYS))
2074 hostdata->disconnect = val;
2075 else
2076 hostdata->disconnect = DIS_ADAPTIVE;
2077 }
2078
2079 if (check_setup_args("noreset", &val, buf))
2080 hostdata->args ^= A_NO_SCSI_RESET;
2081
2082 if (check_setup_args("level2", &val, buf))
2083 hostdata->level2 = val;
2084
2085 if (check_setup_args("debug", &val, buf))
2086 hostdata->args = (val & DB_MASK);
2087
2088#ifdef PROC_INTERFACE
2089 if (check_setup_args("proc", &val, buf))
2090 hostdata->proc = val;
2091#endif
2092
2093
2094
2095
2096 spin_lock_irqsave(instance->host_lock, flags);
2097 x = reset_hardware(instance, (hostdata->args & A_NO_SCSI_RESET) ? RESET_CARD : RESET_CARD_AND_BUS);
2098 spin_unlock_irqrestore(instance->host_lock, flags);
2099
2100 hostdata->microcode = read_3393(hostdata, WD_CDB_1);
2101 if (x & 0x01) {
2102 if (x & B_FLAG)
2103 hostdata->chip = C_WD33C93B;
2104 else
2105 hostdata->chip = C_WD33C93A;
2106 } else
2107 hostdata->chip = C_WD33C93;
2108
2109 printk("dip_switch=%02x irq=%d ioport=%02x floppy=%s sync/DOS5=%s ", (switches & 0x7f), instance->irq, hostdata->io_base, (switches & SW_FLOPPY) ? "Yes" : "No", (switches & SW_SYNC_DOS5) ? "Yes" : "No");
2110 printk("hardware_ver=%02x chip=%s microcode=%02x\n", hrev, (hostdata->chip == C_WD33C93) ? "WD33c93" : (hostdata->chip == C_WD33C93A) ? "WD33c93A" : (hostdata->chip == C_WD33C93B) ? "WD33c93B" : "unknown", hostdata->microcode);
2111#ifdef DEBUGGING_ON
2112 printk("setup_args = ");
2113 for (x = 0; x < MAX_SETUP_ARGS; x++)
2114 printk("%s,", setup_args[x]);
2115 printk("\n");
2116#endif
2117 if (hostdata->sync_off == 0xff)
2118 printk("Sync-transfer DISABLED on all devices: ENABLE from command-line\n");
2119 printk("IN2000 driver version %s - %s\n", IN2000_VERSION, IN2000_DATE);
2120 }
2121
2122 return detect_count;
2123}
2124
2125static int in2000_release(struct Scsi_Host *shost)
2126{
2127 if (shost->irq)
2128 free_irq(shost->irq, shost);
2129 if (shost->io_port && shost->n_io_port)
2130 release_region(shost->io_port, shost->n_io_port);
2131 return 0;
2132}
2133
2134
2135
2136
2137
2138
2139static int in2000_biosparam(struct scsi_device *sdev, struct block_device *bdev, sector_t capacity, int *iinfo)
2140{
2141 int size;
2142
2143 size = capacity;
2144 iinfo[0] = 64;
2145 iinfo[1] = 32;
2146 iinfo[2] = size >> 11;
2147
2148
2149
2150
2151
2152 if (iinfo[2] > 1024) {
2153 iinfo[0] = 64;
2154 iinfo[1] = 63;
2155 iinfo[2] = (unsigned long) capacity / (iinfo[0] * iinfo[1]);
2156 }
2157 if (iinfo[2] > 1024) {
2158 iinfo[0] = 128;
2159 iinfo[1] = 63;
2160 iinfo[2] = (unsigned long) capacity / (iinfo[0] * iinfo[1]);
2161 }
2162 if (iinfo[2] > 1024) {
2163 iinfo[0] = 255;
2164 iinfo[1] = 63;
2165 iinfo[2] = (unsigned long) capacity / (iinfo[0] * iinfo[1]);
2166 }
2167 return 0;
2168}
2169
2170
2171static int in2000_proc_info(struct Scsi_Host *instance, char *buf, char **start, off_t off, int len, int in)
2172{
2173
2174#ifdef PROC_INTERFACE
2175
2176 char *bp;
2177 char tbuf[128];
2178 unsigned long flags;
2179 struct IN2000_hostdata *hd;
2180 Scsi_Cmnd *cmd;
2181 int x, i;
2182 static int stop = 0;
2183
2184 hd = (struct IN2000_hostdata *) instance->hostdata;
2185
2186
2187
2188
2189
2190
2191
2192
2193
2194
2195 if (in) {
2196 buf[len] = '\0';
2197 bp = buf;
2198 if (!strncmp(bp, "debug:", 6)) {
2199 bp += 6;
2200 hd->args = simple_strtoul(bp, NULL, 0) & DB_MASK;
2201 } else if (!strncmp(bp, "disconnect:", 11)) {
2202 bp += 11;
2203 x = simple_strtoul(bp, NULL, 0);
2204 if (x < DIS_NEVER || x > DIS_ALWAYS)
2205 x = DIS_ADAPTIVE;
2206 hd->disconnect = x;
2207 } else if (!strncmp(bp, "period:", 7)) {
2208 bp += 7;
2209 x = simple_strtoul(bp, NULL, 0);
2210 hd->default_sx_per = sx_table[round_period((unsigned int) x)].period_ns;
2211 } else if (!strncmp(bp, "resync:", 7)) {
2212 bp += 7;
2213 x = simple_strtoul(bp, NULL, 0);
2214 for (i = 0; i < 7; i++)
2215 if (x & (1 << i))
2216 hd->sync_stat[i] = SS_UNSET;
2217 } else if (!strncmp(bp, "proc:", 5)) {
2218 bp += 5;
2219 hd->proc = simple_strtoul(bp, NULL, 0);
2220 } else if (!strncmp(bp, "level2:", 7)) {
2221 bp += 7;
2222 hd->level2 = simple_strtoul(bp, NULL, 0);
2223 }
2224 return len;
2225 }
2226
2227 spin_lock_irqsave(instance->host_lock, flags);
2228 bp = buf;
2229 *bp = '\0';
2230 if (hd->proc & PR_VERSION) {
2231 sprintf(tbuf, "\nVersion %s - %s. Compiled %s %s", IN2000_VERSION, IN2000_DATE, __DATE__, __TIME__);
2232 strcat(bp, tbuf);
2233 }
2234 if (hd->proc & PR_INFO) {
2235 sprintf(tbuf, "\ndip_switch=%02x: irq=%d io=%02x floppy=%s sync/DOS5=%s", (hd->dip_switch & 0x7f), instance->irq, hd->io_base, (hd->dip_switch & 0x40) ? "Yes" : "No", (hd->dip_switch & 0x20) ? "Yes" : "No");
2236 strcat(bp, tbuf);
2237 strcat(bp, "\nsync_xfer[] = ");
2238 for (x = 0; x < 7; x++) {
2239 sprintf(tbuf, "\t%02x", hd->sync_xfer[x]);
2240 strcat(bp, tbuf);
2241 }
2242 strcat(bp, "\nsync_stat[] = ");
2243 for (x = 0; x < 7; x++) {
2244 sprintf(tbuf, "\t%02x", hd->sync_stat[x]);
2245 strcat(bp, tbuf);
2246 }
2247 }
2248#ifdef PROC_STATISTICS
2249 if (hd->proc & PR_STATISTICS) {
2250 strcat(bp, "\ncommands issued: ");
2251 for (x = 0; x < 7; x++) {
2252 sprintf(tbuf, "\t%ld", hd->cmd_cnt[x]);
2253 strcat(bp, tbuf);
2254 }
2255 strcat(bp, "\ndisconnects allowed:");
2256 for (x = 0; x < 7; x++) {
2257 sprintf(tbuf, "\t%ld", hd->disc_allowed_cnt[x]);
2258 strcat(bp, tbuf);
2259 }
2260 strcat(bp, "\ndisconnects done: ");
2261 for (x = 0; x < 7; x++) {
2262 sprintf(tbuf, "\t%ld", hd->disc_done_cnt[x]);
2263 strcat(bp, tbuf);
2264 }
2265 sprintf(tbuf, "\ninterrupts: \t%ld", hd->int_cnt);
2266 strcat(bp, tbuf);
2267 }
2268#endif
2269 if (hd->proc & PR_CONNECTED) {
2270 strcat(bp, "\nconnected: ");
2271 if (hd->connected) {
2272 cmd = (Scsi_Cmnd *) hd->connected;
2273 sprintf(tbuf, " %ld-%d:%d(%02x)", cmd->serial_number, cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
2274 strcat(bp, tbuf);
2275 }
2276 }
2277 if (hd->proc & PR_INPUTQ) {
2278 strcat(bp, "\ninput_Q: ");
2279 cmd = (Scsi_Cmnd *) hd->input_Q;
2280 while (cmd) {
2281 sprintf(tbuf, " %ld-%d:%d(%02x)", cmd->serial_number, cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
2282 strcat(bp, tbuf);
2283 cmd = (Scsi_Cmnd *) cmd->host_scribble;
2284 }
2285 }
2286 if (hd->proc & PR_DISCQ) {
2287 strcat(bp, "\ndisconnected_Q:");
2288 cmd = (Scsi_Cmnd *) hd->disconnected_Q;
2289 while (cmd) {
2290 sprintf(tbuf, " %ld-%d:%d(%02x)", cmd->serial_number, cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
2291 strcat(bp, tbuf);
2292 cmd = (Scsi_Cmnd *) cmd->host_scribble;
2293 }
2294 }
2295 if (hd->proc & PR_TEST) {
2296 ;
2297 }
2298 strcat(bp, "\n");
2299 spin_unlock_irqrestore(instance->host_lock, flags);
2300 *start = buf;
2301 if (stop) {
2302 stop = 0;
2303 return 0;
2304 }
2305 if (off > 0x40000)
2306 stop = 1;
2307 if (hd->proc & PR_STOP)
2308 stop = 1;
2309 return strlen(bp);
2310
2311#else
2312
2313 return 0;
2314
2315#endif
2316
2317}
2318
2319MODULE_LICENSE("GPL");
2320
2321
2322static struct scsi_host_template driver_template = {
2323 .proc_name = "in2000",
2324 .proc_info = in2000_proc_info,
2325 .name = "Always IN2000",
2326 .detect = in2000_detect,
2327 .release = in2000_release,
2328 .queuecommand = in2000_queuecommand,
2329 .eh_abort_handler = in2000_abort,
2330 .eh_bus_reset_handler = in2000_bus_reset,
2331 .bios_param = in2000_biosparam,
2332 .can_queue = IN2000_CAN_Q,
2333 .this_id = IN2000_HOST_ID,
2334 .sg_tablesize = IN2000_SG,
2335 .cmd_per_lun = IN2000_CPL,
2336 .use_clustering = DISABLE_CLUSTERING,
2337};
2338#include "scsi_module.c"
2339