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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
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
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480#include <linux/string.h>
481#include <linux/kernel.h>
482#include <linux/ioport.h>
483#include <linux/delay.h>
484#include <linux/proc_fs.h>
485#include <linux/blkdev.h>
486#include <linux/interrupt.h>
487#include <linux/stat.h>
488#include <linux/pci.h>
489#include <linux/init.h>
490#include <linux/ctype.h>
491#include <linux/spinlock.h>
492#include <linux/dma-mapping.h>
493#include <linux/slab.h>
494#include <asm/byteorder.h>
495#include <asm/dma.h>
496#include <asm/io.h>
497#include <asm/irq.h>
498
499#include <scsi/scsi.h>
500#include <scsi/scsi_cmnd.h>
501#include <scsi/scsi_device.h>
502#include <scsi/scsi_host.h>
503#include <scsi/scsi_tcq.h>
504#include <scsi/scsicam.h>
505
506static int eata2x_detect(struct scsi_host_template *);
507static int eata2x_release(struct Scsi_Host *);
508static int eata2x_queuecommand(struct Scsi_Host *, struct scsi_cmnd *);
509static int eata2x_eh_abort(struct scsi_cmnd *);
510static int eata2x_eh_host_reset(struct scsi_cmnd *);
511static int eata2x_bios_param(struct scsi_device *, struct block_device *,
512 sector_t, int *);
513static int eata2x_slave_configure(struct scsi_device *);
514
515static struct scsi_host_template driver_template = {
516 .name = "EATA/DMA 2.0x rev. 8.10.00 ",
517 .detect = eata2x_detect,
518 .release = eata2x_release,
519 .queuecommand = eata2x_queuecommand,
520 .eh_abort_handler = eata2x_eh_abort,
521 .eh_host_reset_handler = eata2x_eh_host_reset,
522 .bios_param = eata2x_bios_param,
523 .slave_configure = eata2x_slave_configure,
524 .this_id = 7,
525 .unchecked_isa_dma = 1,
526 .use_clustering = ENABLE_CLUSTERING,
527};
528
529#if !defined(__BIG_ENDIAN_BITFIELD) && !defined(__LITTLE_ENDIAN_BITFIELD)
530#error "Adjust your <asm/byteorder.h> defines"
531#endif
532
533
534#define ISA 0
535#define ESA 1
536
537#undef FORCE_CONFIG
538
539#undef DEBUG_LINKED_COMMANDS
540#undef DEBUG_DETECT
541#undef DEBUG_PCI_DETECT
542#undef DEBUG_INTERRUPT
543#undef DEBUG_RESET
544#undef DEBUG_GENERATE_ERRORS
545#undef DEBUG_GENERATE_ABORTS
546#undef DEBUG_GEOMETRY
547
548#define MAX_ISA 4
549#define MAX_VESA 0
550#define MAX_EISA 15
551#define MAX_PCI 16
552#define MAX_BOARDS (MAX_ISA + MAX_VESA + MAX_EISA + MAX_PCI)
553#define MAX_CHANNEL 4
554#define MAX_LUN 32
555#define MAX_TARGET 32
556#define MAX_MAILBOXES 64
557#define MAX_SGLIST 64
558#define MAX_LARGE_SGLIST 122
559#define MAX_INTERNAL_RETRIES 64
560#define MAX_CMD_PER_LUN 2
561#define MAX_TAGGED_CMD_PER_LUN (MAX_MAILBOXES - MAX_CMD_PER_LUN)
562
563#define SKIP ULONG_MAX
564#define FREE 0
565#define IN_USE 1
566#define LOCKED 2
567#define IN_RESET 3
568#define IGNORE 4
569#define READY 5
570#define ABORTING 6
571#define NO_DMA 0xff
572#define MAXLOOP 10000
573#define TAG_DISABLED 0
574#define TAG_SIMPLE 1
575#define TAG_ORDERED 2
576
577#define REG_CMD 7
578#define REG_STATUS 7
579#define REG_AUX_STATUS 8
580#define REG_DATA 0
581#define REG_DATA2 1
582#define REG_SEE 6
583#define REG_LOW 2
584#define REG_LM 3
585#define REG_MID 4
586#define REG_MSB 5
587#define REGION_SIZE 9UL
588#define MAX_ISA_ADDR 0x03ff
589#define MIN_EISA_ADDR 0x1c88
590#define MAX_EISA_ADDR 0xfc88
591#define BSY_ASSERTED 0x80
592#define DRQ_ASSERTED 0x08
593#define ABSY_ASSERTED 0x01
594#define IRQ_ASSERTED 0x02
595#define READ_CONFIG_PIO 0xf0
596#define SET_CONFIG_PIO 0xf1
597#define SEND_CP_PIO 0xf2
598#define RECEIVE_SP_PIO 0xf3
599#define TRUNCATE_XFR_PIO 0xf4
600#define RESET_PIO 0xf9
601#define READ_CONFIG_DMA 0xfd
602#define SET_CONFIG_DMA 0xfe
603#define SEND_CP_DMA 0xff
604#define ASOK 0x00
605#define ASST 0x01
606
607#define YESNO(a) ((a) ? 'y' : 'n')
608#define TLDEV(type) ((type) == TYPE_DISK || (type) == TYPE_ROM)
609
610
611#define EATA_SIG_BE 0x45415441
612
613
614#define EATA_2_0A_SIZE 28
615#define EATA_2_0B_SIZE 30
616#define EATA_2_0C_SIZE 34
617
618
619struct eata_info {
620 u_int32_t data_len;
621 u_int32_t sign;
622
623#if defined(__BIG_ENDIAN_BITFIELD)
624 unchar version : 4,
625 : 4;
626 unchar haaval : 1,
627 ata : 1,
628 drqvld : 1,
629 dmasup : 1,
630 morsup : 1,
631 trnxfr : 1,
632 tarsup : 1,
633 ocsena : 1;
634#else
635 unchar : 4,
636 version : 4;
637 unchar ocsena : 1,
638 tarsup : 1,
639 trnxfr : 1,
640 morsup : 1,
641 dmasup : 1,
642 drqvld : 1,
643 ata : 1,
644 haaval : 1;
645#endif
646
647 ushort cp_pad_len;
648 unchar host_addr[4];
649 u_int32_t cp_len;
650 u_int32_t sp_len;
651 ushort queue_size;
652 ushort unused;
653 ushort scatt_size;
654
655#if defined(__BIG_ENDIAN_BITFIELD)
656 unchar drqx : 2,
657 second : 1,
658 irq_tr : 1,
659 irq : 4;
660 unchar sync;
661 unchar : 4,
662 res1 : 1,
663 large_sg : 1,
664 forcaddr : 1,
665 isaena : 1;
666 unchar max_chan : 3,
667 max_id : 5;
668 unchar max_lun;
669 unchar eisa : 1,
670 pci : 1,
671 idquest : 1,
672 m1 : 1,
673 : 4;
674#else
675 unchar irq : 4,
676 irq_tr : 1,
677 second : 1,
678 drqx : 2;
679 unchar sync;
680
681
682 unchar isaena : 1,
683 forcaddr : 1,
684 large_sg : 1,
685 res1 : 1,
686 : 4;
687 unchar max_id : 5,
688 max_chan : 3;
689
690
691 unchar max_lun;
692 unchar
693 : 4,
694 m1 : 1,
695 idquest : 1,
696 pci : 1,
697 eisa : 1;
698#endif
699
700 unchar raidnum;
701 unchar notused;
702
703 ushort ipad[247];
704};
705
706
707struct eata_config {
708 ushort len;
709
710#if defined(__BIG_ENDIAN_BITFIELD)
711 unchar : 4,
712 tarena : 1,
713 mdpena : 1,
714 ocena : 1,
715 edis : 1;
716#else
717 unchar edis : 1,
718 ocena : 1,
719 mdpena : 1,
720 tarena : 1,
721 : 4;
722#endif
723 unchar cpad[511];
724};
725
726
727struct mssp {
728#if defined(__BIG_ENDIAN_BITFIELD)
729 unchar eoc : 1,
730 adapter_status : 7;
731#else
732 unchar adapter_status : 7,
733 eoc : 1;
734#endif
735 unchar target_status;
736 unchar unused[2];
737 u_int32_t inv_res_len;
738 u_int32_t cpp_index;
739 char mess[12];
740};
741
742struct sg_list {
743 unsigned int address;
744 unsigned int num_bytes;
745};
746
747
748struct mscp {
749#if defined(__BIG_ENDIAN_BITFIELD)
750 unchar din : 1,
751 dout : 1,
752 interp : 1,
753 : 1,
754 sg : 1,
755 reqsen :1,
756 init : 1,
757 sreset : 1;
758 unchar sense_len;
759 unchar unused[3];
760 unchar : 7,
761 fwnest : 1;
762 unchar : 5,
763 hbaci : 1,
764 iat : 1,
765 phsunit : 1;
766 unchar channel : 3,
767 target : 5;
768 unchar one : 1,
769 dispri : 1,
770 luntar : 1,
771 lun : 5;
772#else
773 unchar sreset :1,
774 init :1,
775 reqsen :1,
776 sg :1,
777 :1,
778 interp :1,
779 dout :1,
780 din :1;
781 unchar sense_len;
782 unchar unused[3];
783 unchar fwnest : 1,
784 : 7;
785 unchar phsunit : 1,
786 iat : 1,
787 hbaci : 1,
788 : 5;
789 unchar target : 5,
790 channel : 3;
791 unchar lun : 5,
792 luntar : 1,
793 dispri : 1,
794 one : 1;
795#endif
796
797 unchar mess[3];
798 unchar cdb[12];
799 u_int32_t data_len;
800 u_int32_t cpp_index;
801 u_int32_t data_address;
802 u_int32_t sp_dma_addr;
803 u_int32_t sense_addr;
804
805
806 struct scsi_cmnd *SCpnt;
807
808
809
810 dma_addr_t cp_dma_addr;
811 struct sg_list *sglist;
812};
813
814#define CP_TAIL_SIZE (sizeof(struct sglist *) + sizeof(dma_addr_t))
815
816struct hostdata {
817 struct mscp cp[MAX_MAILBOXES];
818 unsigned int cp_stat[MAX_MAILBOXES];
819 unsigned int last_cp_used;
820 unsigned int iocount;
821 int board_number;
822 char board_name[16];
823 int in_reset;
824 int target_to[MAX_TARGET][MAX_CHANNEL];
825 int target_redo[MAX_TARGET][MAX_CHANNEL];
826 unsigned int retries;
827 unsigned long last_retried_pid;
828 unsigned char subversion;
829 unsigned char protocol_rev;
830 unsigned char is_pci;
831 struct pci_dev *pdev;
832 struct mssp *sp_cpu_addr;
833 dma_addr_t sp_dma_addr;
834 struct mssp sp;
835};
836
837static struct Scsi_Host *sh[MAX_BOARDS];
838static const char *driver_name = "EATA";
839static char sha[MAX_BOARDS];
840static DEFINE_SPINLOCK(driver_lock);
841
842
843static unsigned int num_boards = MAX_BOARDS;
844
845static unsigned long io_port[] = {
846
847
848 SKIP, SKIP, SKIP, SKIP, SKIP, SKIP, SKIP, SKIP,
849 SKIP, SKIP,
850
851
852 0x1f0,
853
854
855 SKIP, SKIP, SKIP, SKIP, SKIP, SKIP, SKIP, SKIP,
856 SKIP, SKIP, SKIP, SKIP, SKIP, SKIP, SKIP, SKIP,
857
858
859 0x1c88, 0x2c88, 0x3c88, 0x4c88, 0x5c88, 0x6c88, 0x7c88, 0x8c88,
860 0x9c88, 0xac88, 0xbc88, 0xcc88, 0xdc88, 0xec88, 0xfc88,
861
862
863 0x170, 0x230, 0x330,
864
865
866 0x0
867};
868
869
870#define H2DEV(x) cpu_to_be32(x)
871#define DEV2H(x) be32_to_cpu(x)
872#define H2DEV16(x) cpu_to_be16(x)
873#define DEV2H16(x) be16_to_cpu(x)
874
875
876#define REG2H(x) le16_to_cpu(x)
877
878static irqreturn_t do_interrupt_handler(int, void *);
879static void flush_dev(struct scsi_device *, unsigned long, struct hostdata *,
880 unsigned int);
881static int do_trace = 0;
882static int setup_done = 0;
883static int link_statistics;
884static int ext_tran = 0;
885static int rev_scan = 1;
886
887#if defined(CONFIG_SCSI_EATA_TAGGED_QUEUE)
888static int tag_mode = TAG_SIMPLE;
889#else
890static int tag_mode = TAG_DISABLED;
891#endif
892
893#if defined(CONFIG_SCSI_EATA_LINKED_COMMANDS)
894static int linked_comm = 1;
895#else
896static int linked_comm = 0;
897#endif
898
899#if defined(CONFIG_SCSI_EATA_MAX_TAGS)
900static int max_queue_depth = CONFIG_SCSI_EATA_MAX_TAGS;
901#else
902static int max_queue_depth = MAX_CMD_PER_LUN;
903#endif
904
905#if defined(CONFIG_ISA)
906static int isa_probe = 1;
907#else
908static int isa_probe = 0;
909#endif
910
911#if defined(CONFIG_EISA)
912static int eisa_probe = 1;
913#else
914static int eisa_probe = 0;
915#endif
916
917#if defined(CONFIG_PCI)
918static int pci_probe = 1;
919#else
920static int pci_probe = 0;
921#endif
922
923#define MAX_INT_PARAM 10
924#define MAX_BOOT_OPTIONS_SIZE 256
925static char boot_options[MAX_BOOT_OPTIONS_SIZE];
926
927#if defined(MODULE)
928#include <linux/module.h>
929#include <linux/moduleparam.h>
930
931module_param_string(eata, boot_options, MAX_BOOT_OPTIONS_SIZE, 0);
932MODULE_PARM_DESC(eata, " equivalent to the \"eata=...\" kernel boot option."
933 " Example: modprobe eata \"eata=0x7410,0x230,lc:y,tm:0,mq:4,ep:n\"");
934MODULE_AUTHOR("Dario Ballabio");
935MODULE_LICENSE("GPL");
936MODULE_DESCRIPTION("EATA/DMA SCSI Driver");
937
938#endif
939
940static int eata2x_slave_configure(struct scsi_device *dev)
941{
942 int tqd, utqd;
943 char *tag_suffix, *link_suffix;
944
945 utqd = MAX_CMD_PER_LUN;
946 tqd = max_queue_depth;
947
948 if (TLDEV(dev->type) && dev->tagged_supported) {
949 if (tag_mode == TAG_SIMPLE) {
950 scsi_adjust_queue_depth(dev, MSG_SIMPLE_TAG, tqd);
951 tag_suffix = ", simple tags";
952 } else if (tag_mode == TAG_ORDERED) {
953 scsi_adjust_queue_depth(dev, MSG_ORDERED_TAG, tqd);
954 tag_suffix = ", ordered tags";
955 } else {
956 scsi_adjust_queue_depth(dev, 0, tqd);
957 tag_suffix = ", no tags";
958 }
959 } else if (TLDEV(dev->type) && linked_comm) {
960 scsi_adjust_queue_depth(dev, 0, tqd);
961 tag_suffix = ", untagged";
962 } else {
963 scsi_adjust_queue_depth(dev, 0, utqd);
964 tag_suffix = "";
965 }
966
967 if (TLDEV(dev->type) && linked_comm && dev->queue_depth > 2)
968 link_suffix = ", sorted";
969 else if (TLDEV(dev->type))
970 link_suffix = ", unsorted";
971 else
972 link_suffix = "";
973
974 sdev_printk(KERN_INFO, dev,
975 "cmds/lun %d%s%s.\n",
976 dev->queue_depth, link_suffix, tag_suffix);
977
978 return 0;
979}
980
981static int wait_on_busy(unsigned long iobase, unsigned int loop)
982{
983 while (inb(iobase + REG_AUX_STATUS) & ABSY_ASSERTED) {
984 udelay(1L);
985 if (--loop == 0)
986 return 1;
987 }
988 return 0;
989}
990
991static int do_dma(unsigned long iobase, unsigned long addr, unchar cmd)
992{
993 unsigned char *byaddr;
994 unsigned long devaddr;
995
996 if (wait_on_busy(iobase, (addr ? MAXLOOP * 100 : MAXLOOP)))
997 return 1;
998
999 if (addr) {
1000 devaddr = H2DEV(addr);
1001 byaddr = (unsigned char *)&devaddr;
1002 outb(byaddr[3], iobase + REG_LOW);
1003 outb(byaddr[2], iobase + REG_LM);
1004 outb(byaddr[1], iobase + REG_MID);
1005 outb(byaddr[0], iobase + REG_MSB);
1006 }
1007
1008 outb(cmd, iobase + REG_CMD);
1009 return 0;
1010}
1011
1012static int read_pio(unsigned long iobase, ushort * start, ushort * end)
1013{
1014 unsigned int loop = MAXLOOP;
1015 ushort *p;
1016
1017 for (p = start; p <= end; p++) {
1018 while (!(inb(iobase + REG_STATUS) & DRQ_ASSERTED)) {
1019 udelay(1L);
1020 if (--loop == 0)
1021 return 1;
1022 }
1023 loop = MAXLOOP;
1024 *p = REG2H(inw(iobase));
1025 }
1026
1027 return 0;
1028}
1029
1030static struct pci_dev *get_pci_dev(unsigned long port_base)
1031{
1032#if defined(CONFIG_PCI)
1033 unsigned int addr;
1034 struct pci_dev *dev = NULL;
1035
1036 while ((dev = pci_get_class(PCI_CLASS_STORAGE_SCSI << 8, dev))) {
1037 addr = pci_resource_start(dev, 0);
1038
1039#if defined(DEBUG_PCI_DETECT)
1040 printk("%s: get_pci_dev, bus %d, devfn 0x%x, addr 0x%x.\n",
1041 driver_name, dev->bus->number, dev->devfn, addr);
1042#endif
1043
1044
1045
1046
1047
1048 pci_dev_put(dev);
1049 if (addr + PCI_BASE_ADDRESS_0 == port_base)
1050 return dev;
1051 }
1052#endif
1053 return NULL;
1054}
1055
1056static void enable_pci_ports(void)
1057{
1058#if defined(CONFIG_PCI)
1059 struct pci_dev *dev = NULL;
1060
1061 while ((dev = pci_get_class(PCI_CLASS_STORAGE_SCSI << 8, dev))) {
1062#if defined(DEBUG_PCI_DETECT)
1063 printk("%s: enable_pci_ports, bus %d, devfn 0x%x.\n",
1064 driver_name, dev->bus->number, dev->devfn);
1065#endif
1066
1067 if (pci_enable_device(dev))
1068 printk
1069 ("%s: warning, pci_enable_device failed, bus %d devfn 0x%x.\n",
1070 driver_name, dev->bus->number, dev->devfn);
1071 }
1072
1073#endif
1074}
1075
1076static int port_detect(unsigned long port_base, unsigned int j,
1077 struct scsi_host_template *tpnt)
1078{
1079 unsigned char irq, dma_channel, subversion, i, is_pci = 0;
1080 unsigned char protocol_rev;
1081 struct eata_info info;
1082 char *bus_type, dma_name[16];
1083 struct pci_dev *pdev;
1084
1085 unsigned char dma_channel_table[4] = { 5, 6, 7, 0 };
1086 struct Scsi_Host *shost;
1087 struct hostdata *ha;
1088 char name[16];
1089
1090 sprintf(name, "%s%d", driver_name, j);
1091
1092 if (!request_region(port_base, REGION_SIZE, driver_name)) {
1093#if defined(DEBUG_DETECT)
1094 printk("%s: address 0x%03lx in use, skipping probe.\n", name,
1095 port_base);
1096#endif
1097 goto fail;
1098 }
1099
1100 spin_lock_irq(&driver_lock);
1101
1102 if (do_dma(port_base, 0, READ_CONFIG_PIO)) {
1103#if defined(DEBUG_DETECT)
1104 printk("%s: detect, do_dma failed at 0x%03lx.\n", name,
1105 port_base);
1106#endif
1107 goto freelock;
1108 }
1109
1110
1111 if (read_pio(port_base, (ushort *) & info, (ushort *) & info.ipad[0])) {
1112#if defined(DEBUG_DETECT)
1113 printk("%s: detect, read_pio failed at 0x%03lx.\n", name,
1114 port_base);
1115#endif
1116 goto freelock;
1117 }
1118
1119 info.data_len = DEV2H(info.data_len);
1120 info.sign = DEV2H(info.sign);
1121 info.cp_pad_len = DEV2H16(info.cp_pad_len);
1122 info.cp_len = DEV2H(info.cp_len);
1123 info.sp_len = DEV2H(info.sp_len);
1124 info.scatt_size = DEV2H16(info.scatt_size);
1125 info.queue_size = DEV2H16(info.queue_size);
1126
1127
1128 if (info.sign != EATA_SIG_BE) {
1129#if defined(DEBUG_DETECT)
1130 printk("%s: signature 0x%04x discarded.\n", name, info.sign);
1131#endif
1132 goto freelock;
1133 }
1134
1135 if (info.data_len < EATA_2_0A_SIZE) {
1136 printk
1137 ("%s: config structure size (%d bytes) too short, detaching.\n",
1138 name, info.data_len);
1139 goto freelock;
1140 } else if (info.data_len == EATA_2_0A_SIZE)
1141 protocol_rev = 'A';
1142 else if (info.data_len == EATA_2_0B_SIZE)
1143 protocol_rev = 'B';
1144 else
1145 protocol_rev = 'C';
1146
1147 if (protocol_rev != 'A' && info.forcaddr) {
1148 printk("%s: warning, port address has been forced.\n", name);
1149 bus_type = "PCI";
1150 is_pci = 1;
1151 subversion = ESA;
1152 } else if (port_base > MAX_EISA_ADDR
1153 || (protocol_rev == 'C' && info.pci)) {
1154 bus_type = "PCI";
1155 is_pci = 1;
1156 subversion = ESA;
1157 } else if (port_base >= MIN_EISA_ADDR
1158 || (protocol_rev == 'C' && info.eisa)) {
1159 bus_type = "EISA";
1160 subversion = ESA;
1161 } else if (protocol_rev == 'C' && !info.eisa && !info.pci) {
1162 bus_type = "ISA";
1163 subversion = ISA;
1164 } else if (port_base > MAX_ISA_ADDR) {
1165 bus_type = "PCI";
1166 is_pci = 1;
1167 subversion = ESA;
1168 } else {
1169 bus_type = "ISA";
1170 subversion = ISA;
1171 }
1172
1173 if (!info.haaval || info.ata) {
1174 printk
1175 ("%s: address 0x%03lx, unusable %s board (%d%d), detaching.\n",
1176 name, port_base, bus_type, info.haaval, info.ata);
1177 goto freelock;
1178 }
1179
1180 if (info.drqvld) {
1181 if (subversion == ESA)
1182 printk("%s: warning, weird %s board using DMA.\n", name,
1183 bus_type);
1184
1185 subversion = ISA;
1186 dma_channel = dma_channel_table[3 - info.drqx];
1187 } else {
1188 if (subversion == ISA)
1189 printk("%s: warning, weird %s board not using DMA.\n",
1190 name, bus_type);
1191
1192 subversion = ESA;
1193 dma_channel = NO_DMA;
1194 }
1195
1196 if (!info.dmasup)
1197 printk("%s: warning, DMA protocol support not asserted.\n",
1198 name);
1199
1200 irq = info.irq;
1201
1202 if (subversion == ESA && !info.irq_tr)
1203 printk
1204 ("%s: warning, LEVEL triggering is suggested for IRQ %u.\n",
1205 name, irq);
1206
1207 if (is_pci) {
1208 pdev = get_pci_dev(port_base);
1209 if (!pdev)
1210 printk
1211 ("%s: warning, failed to get pci_dev structure.\n",
1212 name);
1213 } else
1214 pdev = NULL;
1215
1216 if (pdev && (irq != pdev->irq)) {
1217 printk("%s: IRQ %u mapped to IO-APIC IRQ %u.\n", name, irq,
1218 pdev->irq);
1219 irq = pdev->irq;
1220 }
1221
1222
1223 if (request_irq(irq, do_interrupt_handler,
1224 (subversion == ESA) ? IRQF_SHARED : 0,
1225 driver_name, (void *)&sha[j])) {
1226 printk("%s: unable to allocate IRQ %u, detaching.\n", name,
1227 irq);
1228 goto freelock;
1229 }
1230
1231 if (subversion == ISA && request_dma(dma_channel, driver_name)) {
1232 printk("%s: unable to allocate DMA channel %u, detaching.\n",
1233 name, dma_channel);
1234 goto freeirq;
1235 }
1236#if defined(FORCE_CONFIG)
1237 {
1238 struct eata_config *cf;
1239 dma_addr_t cf_dma_addr;
1240
1241 cf = pci_zalloc_consistent(pdev, sizeof(struct eata_config),
1242 &cf_dma_addr);
1243
1244 if (!cf) {
1245 printk
1246 ("%s: config, pci_alloc_consistent failed, detaching.\n",
1247 name);
1248 goto freedma;
1249 }
1250
1251
1252 cf->len = (ushort) H2DEV16((ushort) 510);
1253 cf->ocena = 1;
1254
1255 if (do_dma(port_base, cf_dma_addr, SET_CONFIG_DMA)) {
1256 printk
1257 ("%s: busy timeout sending configuration, detaching.\n",
1258 name);
1259 pci_free_consistent(pdev, sizeof(struct eata_config),
1260 cf, cf_dma_addr);
1261 goto freedma;
1262 }
1263
1264 }
1265#endif
1266
1267 spin_unlock_irq(&driver_lock);
1268 sh[j] = shost = scsi_register(tpnt, sizeof(struct hostdata));
1269 spin_lock_irq(&driver_lock);
1270
1271 if (shost == NULL) {
1272 printk("%s: unable to register host, detaching.\n", name);
1273 goto freedma;
1274 }
1275
1276 shost->io_port = port_base;
1277 shost->unique_id = port_base;
1278 shost->n_io_port = REGION_SIZE;
1279 shost->dma_channel = dma_channel;
1280 shost->irq = irq;
1281 shost->sg_tablesize = (ushort) info.scatt_size;
1282 shost->this_id = (ushort) info.host_addr[3];
1283 shost->can_queue = (ushort) info.queue_size;
1284 shost->cmd_per_lun = MAX_CMD_PER_LUN;
1285
1286 ha = (struct hostdata *)shost->hostdata;
1287
1288 memset(ha, 0, sizeof(struct hostdata));
1289 ha->subversion = subversion;
1290 ha->protocol_rev = protocol_rev;
1291 ha->is_pci = is_pci;
1292 ha->pdev = pdev;
1293 ha->board_number = j;
1294
1295 if (ha->subversion == ESA)
1296 shost->unchecked_isa_dma = 0;
1297 else {
1298 unsigned long flags;
1299 shost->unchecked_isa_dma = 1;
1300
1301 flags = claim_dma_lock();
1302 disable_dma(dma_channel);
1303 clear_dma_ff(dma_channel);
1304 set_dma_mode(dma_channel, DMA_MODE_CASCADE);
1305 enable_dma(dma_channel);
1306 release_dma_lock(flags);
1307
1308 }
1309
1310 strcpy(ha->board_name, name);
1311
1312
1313 if (shost->sg_tablesize > MAX_SGLIST || shost->sg_tablesize < 2) {
1314 printk("%s: detect, wrong n. of SG lists %d, fixed.\n",
1315 ha->board_name, shost->sg_tablesize);
1316 shost->sg_tablesize = MAX_SGLIST;
1317 }
1318
1319
1320 if (shost->can_queue > MAX_MAILBOXES || shost->can_queue < 2) {
1321 printk("%s: detect, wrong n. of mbox %d, fixed.\n",
1322 ha->board_name, shost->can_queue);
1323 shost->can_queue = MAX_MAILBOXES;
1324 }
1325
1326 if (protocol_rev != 'A') {
1327 if (info.max_chan > 0 && info.max_chan < MAX_CHANNEL)
1328 shost->max_channel = info.max_chan;
1329
1330 if (info.max_id > 7 && info.max_id < MAX_TARGET)
1331 shost->max_id = info.max_id + 1;
1332
1333 if (info.large_sg && shost->sg_tablesize == MAX_SGLIST)
1334 shost->sg_tablesize = MAX_LARGE_SGLIST;
1335 }
1336
1337 if (protocol_rev == 'C') {
1338 if (info.max_lun > 7 && info.max_lun < MAX_LUN)
1339 shost->max_lun = info.max_lun + 1;
1340 }
1341
1342 if (dma_channel == NO_DMA)
1343 sprintf(dma_name, "%s", "BMST");
1344 else
1345 sprintf(dma_name, "DMA %u", dma_channel);
1346
1347 spin_unlock_irq(&driver_lock);
1348
1349 for (i = 0; i < shost->can_queue; i++)
1350 ha->cp[i].cp_dma_addr = pci_map_single(ha->pdev,
1351 &ha->cp[i],
1352 sizeof(struct mscp),
1353 PCI_DMA_BIDIRECTIONAL);
1354
1355 for (i = 0; i < shost->can_queue; i++) {
1356 size_t sz = shost->sg_tablesize *sizeof(struct sg_list);
1357 gfp_t gfp_mask = (shost->unchecked_isa_dma ? GFP_DMA : 0) | GFP_ATOMIC;
1358 ha->cp[i].sglist = kmalloc(sz, gfp_mask);
1359 if (!ha->cp[i].sglist) {
1360 printk
1361 ("%s: kmalloc SGlist failed, mbox %d, detaching.\n",
1362 ha->board_name, i);
1363 goto release;
1364 }
1365 }
1366
1367 if (!(ha->sp_cpu_addr = pci_alloc_consistent(ha->pdev,
1368 sizeof(struct mssp),
1369 &ha->sp_dma_addr))) {
1370 printk("%s: pci_alloc_consistent failed, detaching.\n", ha->board_name);
1371 goto release;
1372 }
1373
1374 if (max_queue_depth > MAX_TAGGED_CMD_PER_LUN)
1375 max_queue_depth = MAX_TAGGED_CMD_PER_LUN;
1376
1377 if (max_queue_depth < MAX_CMD_PER_LUN)
1378 max_queue_depth = MAX_CMD_PER_LUN;
1379
1380 if (tag_mode != TAG_DISABLED && tag_mode != TAG_SIMPLE)
1381 tag_mode = TAG_ORDERED;
1382
1383 if (j == 0) {
1384 printk
1385 ("EATA/DMA 2.0x: Copyright (C) 1994-2003 Dario Ballabio.\n");
1386 printk
1387 ("%s config options -> tm:%d, lc:%c, mq:%d, rs:%c, et:%c, "
1388 "ip:%c, ep:%c, pp:%c.\n", driver_name, tag_mode,
1389 YESNO(linked_comm), max_queue_depth, YESNO(rev_scan),
1390 YESNO(ext_tran), YESNO(isa_probe), YESNO(eisa_probe),
1391 YESNO(pci_probe));
1392 }
1393
1394 printk("%s: 2.0%c, %s 0x%03lx, IRQ %u, %s, SG %d, MB %d.\n",
1395 ha->board_name, ha->protocol_rev, bus_type,
1396 (unsigned long)shost->io_port, shost->irq, dma_name,
1397 shost->sg_tablesize, shost->can_queue);
1398
1399 if (shost->max_id > 8 || shost->max_lun > 8)
1400 printk
1401 ("%s: wide SCSI support enabled, max_id %u, max_lun %llu.\n",
1402 ha->board_name, shost->max_id, shost->max_lun);
1403
1404 for (i = 0; i <= shost->max_channel; i++)
1405 printk("%s: SCSI channel %u enabled, host target ID %d.\n",
1406 ha->board_name, i, info.host_addr[3 - i]);
1407
1408#if defined(DEBUG_DETECT)
1409 printk("%s: Vers. 0x%x, ocs %u, tar %u, trnxfr %u, more %u, SYNC 0x%x, "
1410 "sec. %u, infol %d, cpl %d spl %d.\n", name, info.version,
1411 info.ocsena, info.tarsup, info.trnxfr, info.morsup, info.sync,
1412 info.second, info.data_len, info.cp_len, info.sp_len);
1413
1414 if (protocol_rev == 'B' || protocol_rev == 'C')
1415 printk("%s: isaena %u, forcaddr %u, max_id %u, max_chan %u, "
1416 "large_sg %u, res1 %u.\n", name, info.isaena,
1417 info.forcaddr, info.max_id, info.max_chan, info.large_sg,
1418 info.res1);
1419
1420 if (protocol_rev == 'C')
1421 printk("%s: max_lun %u, m1 %u, idquest %u, pci %u, eisa %u, "
1422 "raidnum %u.\n", name, info.max_lun, info.m1,
1423 info.idquest, info.pci, info.eisa, info.raidnum);
1424#endif
1425
1426 if (ha->pdev) {
1427 pci_set_master(ha->pdev);
1428 if (pci_set_dma_mask(ha->pdev, DMA_BIT_MASK(32)))
1429 printk("%s: warning, pci_set_dma_mask failed.\n",
1430 ha->board_name);
1431 }
1432
1433 return 1;
1434
1435 freedma:
1436 if (subversion == ISA)
1437 free_dma(dma_channel);
1438 freeirq:
1439 free_irq(irq, &sha[j]);
1440 freelock:
1441 spin_unlock_irq(&driver_lock);
1442 release_region(port_base, REGION_SIZE);
1443 fail:
1444 return 0;
1445
1446 release:
1447 eata2x_release(shost);
1448 return 0;
1449}
1450
1451static void internal_setup(char *str, int *ints)
1452{
1453 int i, argc = ints[0];
1454 char *cur = str, *pc;
1455
1456 if (argc > 0) {
1457 if (argc > MAX_INT_PARAM)
1458 argc = MAX_INT_PARAM;
1459
1460 for (i = 0; i < argc; i++)
1461 io_port[i] = ints[i + 1];
1462
1463 io_port[i] = 0;
1464 setup_done = 1;
1465 }
1466
1467 while (cur && (pc = strchr(cur, ':'))) {
1468 int val = 0, c = *++pc;
1469
1470 if (c == 'n' || c == 'N')
1471 val = 0;
1472 else if (c == 'y' || c == 'Y')
1473 val = 1;
1474 else
1475 val = (int)simple_strtoul(pc, NULL, 0);
1476
1477 if (!strncmp(cur, "lc:", 3))
1478 linked_comm = val;
1479 else if (!strncmp(cur, "tm:", 3))
1480 tag_mode = val;
1481 else if (!strncmp(cur, "tc:", 3))
1482 tag_mode = val;
1483 else if (!strncmp(cur, "mq:", 3))
1484 max_queue_depth = val;
1485 else if (!strncmp(cur, "ls:", 3))
1486 link_statistics = val;
1487 else if (!strncmp(cur, "et:", 3))
1488 ext_tran = val;
1489 else if (!strncmp(cur, "rs:", 3))
1490 rev_scan = val;
1491 else if (!strncmp(cur, "ip:", 3))
1492 isa_probe = val;
1493 else if (!strncmp(cur, "ep:", 3))
1494 eisa_probe = val;
1495 else if (!strncmp(cur, "pp:", 3))
1496 pci_probe = val;
1497
1498 if ((cur = strchr(cur, ',')))
1499 ++cur;
1500 }
1501
1502 return;
1503}
1504
1505static int option_setup(char *str)
1506{
1507 int ints[MAX_INT_PARAM];
1508 char *cur = str;
1509 int i = 1;
1510
1511 while (cur && isdigit(*cur) && i < MAX_INT_PARAM) {
1512 ints[i++] = simple_strtoul(cur, NULL, 0);
1513
1514 if ((cur = strchr(cur, ',')) != NULL)
1515 cur++;
1516 }
1517
1518 ints[0] = i - 1;
1519 internal_setup(cur, ints);
1520 return 1;
1521}
1522
1523static void add_pci_ports(void)
1524{
1525#if defined(CONFIG_PCI)
1526 unsigned int addr, k;
1527 struct pci_dev *dev = NULL;
1528
1529 for (k = 0; k < MAX_PCI; k++) {
1530
1531 if (!(dev = pci_get_class(PCI_CLASS_STORAGE_SCSI << 8, dev)))
1532 break;
1533
1534 if (pci_enable_device(dev)) {
1535#if defined(DEBUG_PCI_DETECT)
1536 printk
1537 ("%s: detect, bus %d, devfn 0x%x, pci_enable_device failed.\n",
1538 driver_name, dev->bus->number, dev->devfn);
1539#endif
1540
1541 continue;
1542 }
1543
1544 addr = pci_resource_start(dev, 0);
1545
1546#if defined(DEBUG_PCI_DETECT)
1547 printk("%s: detect, seq. %d, bus %d, devfn 0x%x, addr 0x%x.\n",
1548 driver_name, k, dev->bus->number, dev->devfn, addr);
1549#endif
1550
1551
1552 io_port[MAX_INT_PARAM + (rev_scan ? (MAX_PCI - k) : (1 + k))] =
1553 addr + PCI_BASE_ADDRESS_0;
1554 }
1555
1556 pci_dev_put(dev);
1557#endif
1558}
1559
1560static int eata2x_detect(struct scsi_host_template *tpnt)
1561{
1562 unsigned int j = 0, k;
1563
1564 tpnt->proc_name = "eata2x";
1565
1566 if (strlen(boot_options))
1567 option_setup(boot_options);
1568
1569#if defined(MODULE)
1570
1571 if (io_port[0] != SKIP) {
1572 setup_done = 1;
1573 io_port[MAX_INT_PARAM] = 0;
1574 }
1575#endif
1576
1577 for (k = MAX_INT_PARAM; io_port[k]; k++)
1578 if (io_port[k] == SKIP)
1579 continue;
1580 else if (io_port[k] <= MAX_ISA_ADDR) {
1581 if (!isa_probe)
1582 io_port[k] = SKIP;
1583 } else if (io_port[k] >= MIN_EISA_ADDR
1584 && io_port[k] <= MAX_EISA_ADDR) {
1585 if (!eisa_probe)
1586 io_port[k] = SKIP;
1587 }
1588
1589 if (pci_probe) {
1590 if (!setup_done)
1591 add_pci_ports();
1592 else
1593 enable_pci_ports();
1594 }
1595
1596 for (k = 0; io_port[k]; k++) {
1597
1598 if (io_port[k] == SKIP)
1599 continue;
1600
1601 if (j < MAX_BOARDS && port_detect(io_port[k], j, tpnt))
1602 j++;
1603 }
1604
1605 num_boards = j;
1606 return j;
1607}
1608
1609static void map_dma(unsigned int i, struct hostdata *ha)
1610{
1611 unsigned int k, pci_dir;
1612 int count;
1613 struct scatterlist *sg;
1614 struct mscp *cpp;
1615 struct scsi_cmnd *SCpnt;
1616
1617 cpp = &ha->cp[i];
1618 SCpnt = cpp->SCpnt;
1619 pci_dir = SCpnt->sc_data_direction;
1620
1621 if (SCpnt->sense_buffer)
1622 cpp->sense_addr =
1623 H2DEV(pci_map_single(ha->pdev, SCpnt->sense_buffer,
1624 SCSI_SENSE_BUFFERSIZE, PCI_DMA_FROMDEVICE));
1625
1626 cpp->sense_len = SCSI_SENSE_BUFFERSIZE;
1627
1628 if (!scsi_sg_count(SCpnt)) {
1629 cpp->data_len = 0;
1630 return;
1631 }
1632
1633 count = pci_map_sg(ha->pdev, scsi_sglist(SCpnt), scsi_sg_count(SCpnt),
1634 pci_dir);
1635 BUG_ON(!count);
1636
1637 scsi_for_each_sg(SCpnt, sg, count, k) {
1638 cpp->sglist[k].address = H2DEV(sg_dma_address(sg));
1639 cpp->sglist[k].num_bytes = H2DEV(sg_dma_len(sg));
1640 }
1641
1642 cpp->sg = 1;
1643 cpp->data_address = H2DEV(pci_map_single(ha->pdev, cpp->sglist,
1644 scsi_sg_count(SCpnt) *
1645 sizeof(struct sg_list),
1646 pci_dir));
1647 cpp->data_len = H2DEV((scsi_sg_count(SCpnt) * sizeof(struct sg_list)));
1648}
1649
1650static void unmap_dma(unsigned int i, struct hostdata *ha)
1651{
1652 unsigned int pci_dir;
1653 struct mscp *cpp;
1654 struct scsi_cmnd *SCpnt;
1655
1656 cpp = &ha->cp[i];
1657 SCpnt = cpp->SCpnt;
1658 pci_dir = SCpnt->sc_data_direction;
1659
1660 if (DEV2H(cpp->sense_addr))
1661 pci_unmap_single(ha->pdev, DEV2H(cpp->sense_addr),
1662 DEV2H(cpp->sense_len), PCI_DMA_FROMDEVICE);
1663
1664 if (scsi_sg_count(SCpnt))
1665 pci_unmap_sg(ha->pdev, scsi_sglist(SCpnt), scsi_sg_count(SCpnt),
1666 pci_dir);
1667
1668 if (!DEV2H(cpp->data_len))
1669 pci_dir = PCI_DMA_BIDIRECTIONAL;
1670
1671 if (DEV2H(cpp->data_address))
1672 pci_unmap_single(ha->pdev, DEV2H(cpp->data_address),
1673 DEV2H(cpp->data_len), pci_dir);
1674}
1675
1676static void sync_dma(unsigned int i, struct hostdata *ha)
1677{
1678 unsigned int pci_dir;
1679 struct mscp *cpp;
1680 struct scsi_cmnd *SCpnt;
1681
1682 cpp = &ha->cp[i];
1683 SCpnt = cpp->SCpnt;
1684 pci_dir = SCpnt->sc_data_direction;
1685
1686 if (DEV2H(cpp->sense_addr))
1687 pci_dma_sync_single_for_cpu(ha->pdev, DEV2H(cpp->sense_addr),
1688 DEV2H(cpp->sense_len),
1689 PCI_DMA_FROMDEVICE);
1690
1691 if (scsi_sg_count(SCpnt))
1692 pci_dma_sync_sg_for_cpu(ha->pdev, scsi_sglist(SCpnt),
1693 scsi_sg_count(SCpnt), pci_dir);
1694
1695 if (!DEV2H(cpp->data_len))
1696 pci_dir = PCI_DMA_BIDIRECTIONAL;
1697
1698 if (DEV2H(cpp->data_address))
1699 pci_dma_sync_single_for_cpu(ha->pdev,
1700 DEV2H(cpp->data_address),
1701 DEV2H(cpp->data_len), pci_dir);
1702}
1703
1704static void scsi_to_dev_dir(unsigned int i, struct hostdata *ha)
1705{
1706 unsigned int k;
1707
1708 static const unsigned char data_out_cmds[] = {
1709 0x0a, 0x2a, 0x15, 0x55, 0x04, 0x07, 0x18, 0x1d, 0x24, 0x2e,
1710 0x30, 0x31, 0x32, 0x38, 0x39, 0x3a, 0x3b, 0x3d, 0x3f, 0x40,
1711 0x41, 0x4c, 0xaa, 0xae, 0xb0, 0xb1, 0xb2, 0xb6, 0xea, 0x1b, 0x5d
1712 };
1713
1714 static const unsigned char data_none_cmds[] = {
1715 0x01, 0x0b, 0x10, 0x11, 0x13, 0x16, 0x17, 0x19, 0x2b, 0x1e,
1716 0x2c, 0xac, 0x2f, 0xaf, 0x33, 0xb3, 0x35, 0x36, 0x45, 0x47,
1717 0x48, 0x49, 0xa9, 0x4b, 0xa5, 0xa6, 0xb5, 0x00
1718 };
1719
1720 struct mscp *cpp;
1721 struct scsi_cmnd *SCpnt;
1722
1723 cpp = &ha->cp[i];
1724 SCpnt = cpp->SCpnt;
1725
1726 if (SCpnt->sc_data_direction == DMA_FROM_DEVICE) {
1727 cpp->din = 1;
1728 cpp->dout = 0;
1729 return;
1730 } else if (SCpnt->sc_data_direction == DMA_TO_DEVICE) {
1731 cpp->din = 0;
1732 cpp->dout = 1;
1733 return;
1734 } else if (SCpnt->sc_data_direction == DMA_NONE) {
1735 cpp->din = 0;
1736 cpp->dout = 0;
1737 return;
1738 }
1739
1740 if (SCpnt->sc_data_direction != DMA_BIDIRECTIONAL)
1741 panic("%s: qcomm, invalid SCpnt->sc_data_direction.\n",
1742 ha->board_name);
1743
1744 for (k = 0; k < ARRAY_SIZE(data_out_cmds); k++)
1745 if (SCpnt->cmnd[0] == data_out_cmds[k]) {
1746 cpp->dout = 1;
1747 break;
1748 }
1749
1750 if ((cpp->din = !cpp->dout))
1751 for (k = 0; k < ARRAY_SIZE(data_none_cmds); k++)
1752 if (SCpnt->cmnd[0] == data_none_cmds[k]) {
1753 cpp->din = 0;
1754 break;
1755 }
1756
1757}
1758
1759static int eata2x_queuecommand_lck(struct scsi_cmnd *SCpnt,
1760 void (*done) (struct scsi_cmnd *))
1761{
1762 struct Scsi_Host *shost = SCpnt->device->host;
1763 struct hostdata *ha = (struct hostdata *)shost->hostdata;
1764 unsigned int i, k;
1765 struct mscp *cpp;
1766
1767 if (SCpnt->host_scribble)
1768 panic("%s: qcomm, SCpnt %p already active.\n",
1769 ha->board_name, SCpnt);
1770
1771
1772
1773 i = ha->last_cp_used + 1;
1774
1775 for (k = 0; k < shost->can_queue; k++, i++) {
1776 if (i >= shost->can_queue)
1777 i = 0;
1778 if (ha->cp_stat[i] == FREE) {
1779 ha->last_cp_used = i;
1780 break;
1781 }
1782 }
1783
1784 if (k == shost->can_queue) {
1785 printk("%s: qcomm, no free mailbox.\n", ha->board_name);
1786 return 1;
1787 }
1788
1789
1790 cpp = &ha->cp[i];
1791
1792 memset(cpp, 0, sizeof(struct mscp) - CP_TAIL_SIZE);
1793
1794
1795 cpp->sp_dma_addr = H2DEV(ha->sp_dma_addr);
1796
1797 SCpnt->scsi_done = done;
1798 cpp->cpp_index = i;
1799 SCpnt->host_scribble = (unsigned char *)&cpp->cpp_index;
1800
1801 if (do_trace)
1802 scmd_printk(KERN_INFO, SCpnt,
1803 "qcomm, mbox %d.\n", i);
1804
1805 cpp->reqsen = 1;
1806 cpp->dispri = 1;
1807#if 0
1808 if (SCpnt->device->type == TYPE_TAPE)
1809 cpp->hbaci = 1;
1810#endif
1811 cpp->one = 1;
1812 cpp->channel = SCpnt->device->channel;
1813 cpp->target = SCpnt->device->id;
1814 cpp->lun = SCpnt->device->lun;
1815 cpp->SCpnt = SCpnt;
1816 memcpy(cpp->cdb, SCpnt->cmnd, SCpnt->cmd_len);
1817
1818
1819 scsi_to_dev_dir(i, ha);
1820
1821
1822 map_dma(i, ha);
1823
1824 if (linked_comm && SCpnt->device->queue_depth > 2
1825 && TLDEV(SCpnt->device->type)) {
1826 ha->cp_stat[i] = READY;
1827 flush_dev(SCpnt->device, blk_rq_pos(SCpnt->request), ha, 0);
1828 return 0;
1829 }
1830
1831
1832 if (do_dma(shost->io_port, cpp->cp_dma_addr, SEND_CP_DMA)) {
1833 unmap_dma(i, ha);
1834 SCpnt->host_scribble = NULL;
1835 scmd_printk(KERN_INFO, SCpnt, "qcomm, adapter busy.\n");
1836 return 1;
1837 }
1838
1839 ha->cp_stat[i] = IN_USE;
1840 return 0;
1841}
1842
1843static DEF_SCSI_QCMD(eata2x_queuecommand)
1844
1845static int eata2x_eh_abort(struct scsi_cmnd *SCarg)
1846{
1847 struct Scsi_Host *shost = SCarg->device->host;
1848 struct hostdata *ha = (struct hostdata *)shost->hostdata;
1849 unsigned int i;
1850
1851 if (SCarg->host_scribble == NULL) {
1852 scmd_printk(KERN_INFO, SCarg, "abort, cmd inactive.\n");
1853 return SUCCESS;
1854 }
1855
1856 i = *(unsigned int *)SCarg->host_scribble;
1857 scmd_printk(KERN_WARNING, SCarg, "abort, mbox %d.\n", i);
1858
1859 if (i >= shost->can_queue)
1860 panic("%s: abort, invalid SCarg->host_scribble.\n", ha->board_name);
1861
1862 if (wait_on_busy(shost->io_port, MAXLOOP)) {
1863 printk("%s: abort, timeout error.\n", ha->board_name);
1864 return FAILED;
1865 }
1866
1867 if (ha->cp_stat[i] == FREE) {
1868 printk("%s: abort, mbox %d is free.\n", ha->board_name, i);
1869 return SUCCESS;
1870 }
1871
1872 if (ha->cp_stat[i] == IN_USE) {
1873 printk("%s: abort, mbox %d is in use.\n", ha->board_name, i);
1874
1875 if (SCarg != ha->cp[i].SCpnt)
1876 panic("%s: abort, mbox %d, SCarg %p, cp SCpnt %p.\n",
1877 ha->board_name, i, SCarg, ha->cp[i].SCpnt);
1878
1879 if (inb(shost->io_port + REG_AUX_STATUS) & IRQ_ASSERTED)
1880 printk("%s: abort, mbox %d, interrupt pending.\n",
1881 ha->board_name, i);
1882
1883 return FAILED;
1884 }
1885
1886 if (ha->cp_stat[i] == IN_RESET) {
1887 printk("%s: abort, mbox %d is in reset.\n", ha->board_name, i);
1888 return FAILED;
1889 }
1890
1891 if (ha->cp_stat[i] == LOCKED) {
1892 printk("%s: abort, mbox %d is locked.\n", ha->board_name, i);
1893 return SUCCESS;
1894 }
1895
1896 if (ha->cp_stat[i] == READY || ha->cp_stat[i] == ABORTING) {
1897 unmap_dma(i, ha);
1898 SCarg->result = DID_ABORT << 16;
1899 SCarg->host_scribble = NULL;
1900 ha->cp_stat[i] = FREE;
1901 printk("%s, abort, mbox %d ready, DID_ABORT, done.\n",
1902 ha->board_name, i);
1903 SCarg->scsi_done(SCarg);
1904 return SUCCESS;
1905 }
1906
1907 panic("%s: abort, mbox %d, invalid cp_stat.\n", ha->board_name, i);
1908}
1909
1910static int eata2x_eh_host_reset(struct scsi_cmnd *SCarg)
1911{
1912 unsigned int i, time, k, c, limit = 0;
1913 int arg_done = 0;
1914 struct scsi_cmnd *SCpnt;
1915 struct Scsi_Host *shost = SCarg->device->host;
1916 struct hostdata *ha = (struct hostdata *)shost->hostdata;
1917
1918 scmd_printk(KERN_INFO, SCarg, "reset, enter.\n");
1919
1920 spin_lock_irq(shost->host_lock);
1921
1922 if (SCarg->host_scribble == NULL)
1923 printk("%s: reset, inactive.\n", ha->board_name);
1924
1925 if (ha->in_reset) {
1926 printk("%s: reset, exit, already in reset.\n", ha->board_name);
1927 spin_unlock_irq(shost->host_lock);
1928 return FAILED;
1929 }
1930
1931 if (wait_on_busy(shost->io_port, MAXLOOP)) {
1932 printk("%s: reset, exit, timeout error.\n", ha->board_name);
1933 spin_unlock_irq(shost->host_lock);
1934 return FAILED;
1935 }
1936
1937 ha->retries = 0;
1938
1939 for (c = 0; c <= shost->max_channel; c++)
1940 for (k = 0; k < shost->max_id; k++) {
1941 ha->target_redo[k][c] = 1;
1942 ha->target_to[k][c] = 0;
1943 }
1944
1945 for (i = 0; i < shost->can_queue; i++) {
1946
1947 if (ha->cp_stat[i] == FREE)
1948 continue;
1949
1950 if (ha->cp_stat[i] == LOCKED) {
1951 ha->cp_stat[i] = FREE;
1952 printk("%s: reset, locked mbox %d forced free.\n",
1953 ha->board_name, i);
1954 continue;
1955 }
1956
1957 if (!(SCpnt = ha->cp[i].SCpnt))
1958 panic("%s: reset, mbox %d, SCpnt == NULL.\n", ha->board_name, i);
1959
1960 if (ha->cp_stat[i] == READY || ha->cp_stat[i] == ABORTING) {
1961 ha->cp_stat[i] = ABORTING;
1962 printk("%s: reset, mbox %d aborting.\n",
1963 ha->board_name, i);
1964 }
1965
1966 else {
1967 ha->cp_stat[i] = IN_RESET;
1968 printk("%s: reset, mbox %d in reset.\n",
1969 ha->board_name, i);
1970 }
1971
1972 if (SCpnt->host_scribble == NULL)
1973 panic("%s: reset, mbox %d, garbled SCpnt.\n", ha->board_name, i);
1974
1975 if (*(unsigned int *)SCpnt->host_scribble != i)
1976 panic("%s: reset, mbox %d, index mismatch.\n", ha->board_name, i);
1977
1978 if (SCpnt->scsi_done == NULL)
1979 panic("%s: reset, mbox %d, SCpnt->scsi_done == NULL.\n",
1980 ha->board_name, i);
1981
1982 if (SCpnt == SCarg)
1983 arg_done = 1;
1984 }
1985
1986 if (do_dma(shost->io_port, 0, RESET_PIO)) {
1987 printk("%s: reset, cannot reset, timeout error.\n", ha->board_name);
1988 spin_unlock_irq(shost->host_lock);
1989 return FAILED;
1990 }
1991
1992 printk("%s: reset, board reset done, enabling interrupts.\n", ha->board_name);
1993
1994#if defined(DEBUG_RESET)
1995 do_trace = 1;
1996#endif
1997
1998 ha->in_reset = 1;
1999
2000 spin_unlock_irq(shost->host_lock);
2001
2002
2003 time = jiffies;
2004 while ((jiffies - time) < (10 * HZ) && limit++ < 200000)
2005 udelay(100L);
2006
2007 spin_lock_irq(shost->host_lock);
2008
2009 printk("%s: reset, interrupts disabled, loops %d.\n", ha->board_name, limit);
2010
2011 for (i = 0; i < shost->can_queue; i++) {
2012
2013 if (ha->cp_stat[i] == IN_RESET) {
2014 SCpnt = ha->cp[i].SCpnt;
2015 unmap_dma(i, ha);
2016 SCpnt->result = DID_RESET << 16;
2017 SCpnt->host_scribble = NULL;
2018
2019
2020 ha->cp_stat[i] = LOCKED;
2021
2022 printk
2023 ("%s, reset, mbox %d locked, DID_RESET, done.\n",
2024 ha->board_name, i);
2025 }
2026
2027 else if (ha->cp_stat[i] == ABORTING) {
2028 SCpnt = ha->cp[i].SCpnt;
2029 unmap_dma(i, ha);
2030 SCpnt->result = DID_RESET << 16;
2031 SCpnt->host_scribble = NULL;
2032
2033
2034 ha->cp_stat[i] = FREE;
2035
2036 printk
2037 ("%s, reset, mbox %d aborting, DID_RESET, done.\n",
2038 ha->board_name, i);
2039 }
2040
2041 else
2042
2043 continue;
2044
2045 SCpnt->scsi_done(SCpnt);
2046 }
2047
2048 ha->in_reset = 0;
2049 do_trace = 0;
2050
2051 if (arg_done)
2052 printk("%s: reset, exit, done.\n", ha->board_name);
2053 else
2054 printk("%s: reset, exit.\n", ha->board_name);
2055
2056 spin_unlock_irq(shost->host_lock);
2057 return SUCCESS;
2058}
2059
2060int eata2x_bios_param(struct scsi_device *sdev, struct block_device *bdev,
2061 sector_t capacity, int *dkinfo)
2062{
2063 unsigned int size = capacity;
2064
2065 if (ext_tran || (scsicam_bios_param(bdev, capacity, dkinfo) < 0)) {
2066 dkinfo[0] = 255;
2067 dkinfo[1] = 63;
2068 dkinfo[2] = size / (dkinfo[0] * dkinfo[1]);
2069 }
2070#if defined (DEBUG_GEOMETRY)
2071 printk("%s: bios_param, head=%d, sec=%d, cyl=%d.\n", driver_name,
2072 dkinfo[0], dkinfo[1], dkinfo[2]);
2073#endif
2074
2075 return 0;
2076}
2077
2078static void sort(unsigned long sk[], unsigned int da[], unsigned int n,
2079 unsigned int rev)
2080{
2081 unsigned int i, j, k, y;
2082 unsigned long x;
2083
2084 for (i = 0; i < n - 1; i++) {
2085 k = i;
2086
2087 for (j = k + 1; j < n; j++)
2088 if (rev) {
2089 if (sk[j] > sk[k])
2090 k = j;
2091 } else {
2092 if (sk[j] < sk[k])
2093 k = j;
2094 }
2095
2096 if (k != i) {
2097 x = sk[k];
2098 sk[k] = sk[i];
2099 sk[i] = x;
2100 y = da[k];
2101 da[k] = da[i];
2102 da[i] = y;
2103 }
2104 }
2105
2106 return;
2107}
2108
2109static int reorder(struct hostdata *ha, unsigned long cursec,
2110 unsigned int ihdlr, unsigned int il[], unsigned int n_ready)
2111{
2112 struct scsi_cmnd *SCpnt;
2113 struct mscp *cpp;
2114 unsigned int k, n;
2115 unsigned int rev = 0, s = 1, r = 1;
2116 unsigned int input_only = 1, overlap = 0;
2117 unsigned long sl[n_ready], pl[n_ready], ll[n_ready];
2118 unsigned long maxsec = 0, minsec = ULONG_MAX, seek = 0, iseek = 0;
2119 unsigned long ioseek = 0;
2120
2121 static unsigned int flushcount = 0, batchcount = 0, sortcount = 0;
2122 static unsigned int readycount = 0, ovlcount = 0, inputcount = 0;
2123 static unsigned int readysorted = 0, revcount = 0;
2124 static unsigned long seeksorted = 0, seeknosort = 0;
2125
2126 if (link_statistics && !(++flushcount % link_statistics))
2127 printk("fc %d bc %d ic %d oc %d rc %d rs %d sc %d re %d"
2128 " av %ldK as %ldK.\n", flushcount, batchcount,
2129 inputcount, ovlcount, readycount, readysorted, sortcount,
2130 revcount, seeknosort / (readycount + 1),
2131 seeksorted / (readycount + 1));
2132
2133 if (n_ready <= 1)
2134 return 0;
2135
2136 for (n = 0; n < n_ready; n++) {
2137 k = il[n];
2138 cpp = &ha->cp[k];
2139 SCpnt = cpp->SCpnt;
2140
2141 if (!cpp->din)
2142 input_only = 0;
2143
2144 if (blk_rq_pos(SCpnt->request) < minsec)
2145 minsec = blk_rq_pos(SCpnt->request);
2146 if (blk_rq_pos(SCpnt->request) > maxsec)
2147 maxsec = blk_rq_pos(SCpnt->request);
2148
2149 sl[n] = blk_rq_pos(SCpnt->request);
2150 ioseek += blk_rq_sectors(SCpnt->request);
2151
2152 if (!n)
2153 continue;
2154
2155 if (sl[n] < sl[n - 1])
2156 s = 0;
2157 if (sl[n] > sl[n - 1])
2158 r = 0;
2159
2160 if (link_statistics) {
2161 if (sl[n] > sl[n - 1])
2162 seek += sl[n] - sl[n - 1];
2163 else
2164 seek += sl[n - 1] - sl[n];
2165 }
2166
2167 }
2168
2169 if (link_statistics) {
2170 if (cursec > sl[0])
2171 seek += cursec - sl[0];
2172 else
2173 seek += sl[0] - cursec;
2174 }
2175
2176 if (cursec > ((maxsec + minsec) / 2))
2177 rev = 1;
2178
2179 if (ioseek > ((maxsec - minsec) / 2))
2180 rev = 0;
2181
2182 if (!((rev && r) || (!rev && s)))
2183 sort(sl, il, n_ready, rev);
2184
2185 if (!input_only)
2186 for (n = 0; n < n_ready; n++) {
2187 k = il[n];
2188 cpp = &ha->cp[k];
2189 SCpnt = cpp->SCpnt;
2190 ll[n] = blk_rq_sectors(SCpnt->request);
2191 pl[n] = SCpnt->serial_number;
2192
2193 if (!n)
2194 continue;
2195
2196 if ((sl[n] == sl[n - 1])
2197 || (!rev && ((sl[n - 1] + ll[n - 1]) > sl[n]))
2198 || (rev && ((sl[n] + ll[n]) > sl[n - 1])))
2199 overlap = 1;
2200 }
2201
2202 if (overlap)
2203 sort(pl, il, n_ready, 0);
2204
2205 if (link_statistics) {
2206 if (cursec > sl[0])
2207 iseek = cursec - sl[0];
2208 else
2209 iseek = sl[0] - cursec;
2210 batchcount++;
2211 readycount += n_ready;
2212 seeknosort += seek / 1024;
2213 if (input_only)
2214 inputcount++;
2215 if (overlap) {
2216 ovlcount++;
2217 seeksorted += iseek / 1024;
2218 } else
2219 seeksorted += (iseek + maxsec - minsec) / 1024;
2220 if (rev && !r) {
2221 revcount++;
2222 readysorted += n_ready;
2223 }
2224 if (!rev && !s) {
2225 sortcount++;
2226 readysorted += n_ready;
2227 }
2228 }
2229#if defined(DEBUG_LINKED_COMMANDS)
2230 if (link_statistics && (overlap || !(flushcount % link_statistics)))
2231 for (n = 0; n < n_ready; n++) {
2232 k = il[n];
2233 cpp = &ha->cp[k];
2234 SCpnt = cpp->SCpnt;
2235 scmd_printk(KERN_INFO, SCpnt,
2236 "%s mb %d fc %d nr %d sec %ld ns %u"
2237 " cur %ld s:%c r:%c rev:%c in:%c ov:%c xd %d.\n",
2238 (ihdlr ? "ihdlr" : "qcomm"),
2239 k, flushcount,
2240 n_ready, blk_rq_pos(SCpnt->request),
2241 blk_rq_sectors(SCpnt->request), cursec, YESNO(s),
2242 YESNO(r), YESNO(rev), YESNO(input_only),
2243 YESNO(overlap), cpp->din);
2244 }
2245#endif
2246 return overlap;
2247}
2248
2249static void flush_dev(struct scsi_device *dev, unsigned long cursec,
2250 struct hostdata *ha, unsigned int ihdlr)
2251{
2252 struct scsi_cmnd *SCpnt;
2253 struct mscp *cpp;
2254 unsigned int k, n, n_ready = 0, il[MAX_MAILBOXES];
2255
2256 for (k = 0; k < dev->host->can_queue; k++) {
2257
2258 if (ha->cp_stat[k] != READY && ha->cp_stat[k] != IN_USE)
2259 continue;
2260
2261 cpp = &ha->cp[k];
2262 SCpnt = cpp->SCpnt;
2263
2264 if (SCpnt->device != dev)
2265 continue;
2266
2267 if (ha->cp_stat[k] == IN_USE)
2268 return;
2269
2270 il[n_ready++] = k;
2271 }
2272
2273 if (reorder(ha, cursec, ihdlr, il, n_ready))
2274 n_ready = 1;
2275
2276 for (n = 0; n < n_ready; n++) {
2277 k = il[n];
2278 cpp = &ha->cp[k];
2279 SCpnt = cpp->SCpnt;
2280
2281 if (do_dma(dev->host->io_port, cpp->cp_dma_addr, SEND_CP_DMA)) {
2282 scmd_printk(KERN_INFO, SCpnt,
2283 "%s, mbox %d, adapter"
2284 " busy, will abort.\n",
2285 (ihdlr ? "ihdlr" : "qcomm"),
2286 k);
2287 ha->cp_stat[k] = ABORTING;
2288 continue;
2289 }
2290
2291 ha->cp_stat[k] = IN_USE;
2292 }
2293}
2294
2295static irqreturn_t ihdlr(struct Scsi_Host *shost)
2296{
2297 struct scsi_cmnd *SCpnt;
2298 unsigned int i, k, c, status, tstatus, reg;
2299 struct mssp *spp;
2300 struct mscp *cpp;
2301 struct hostdata *ha = (struct hostdata *)shost->hostdata;
2302 int irq = shost->irq;
2303
2304
2305 if (!(inb(shost->io_port + REG_AUX_STATUS) & IRQ_ASSERTED))
2306 goto none;
2307
2308 ha->iocount++;
2309
2310 if (do_trace)
2311 printk("%s: ihdlr, enter, irq %d, count %d.\n", ha->board_name, irq,
2312 ha->iocount);
2313
2314
2315 if (wait_on_busy(shost->io_port, 20 * MAXLOOP)) {
2316 reg = inb(shost->io_port + REG_STATUS);
2317 printk
2318 ("%s: ihdlr, busy timeout error, irq %d, reg 0x%x, count %d.\n",
2319 ha->board_name, irq, reg, ha->iocount);
2320 goto none;
2321 }
2322
2323 spp = &ha->sp;
2324
2325
2326 memcpy(spp, ha->sp_cpu_addr, sizeof(struct mssp));
2327
2328
2329 memset(ha->sp_cpu_addr, 0, sizeof(struct mssp));
2330
2331
2332 reg = inb(shost->io_port + REG_STATUS);
2333
2334#if defined (DEBUG_INTERRUPT)
2335 {
2336 unsigned char *bytesp;
2337 int cnt;
2338 bytesp = (unsigned char *)spp;
2339 if (ha->iocount < 200) {
2340 printk("sp[] =");
2341 for (cnt = 0; cnt < 15; cnt++)
2342 printk(" 0x%x", bytesp[cnt]);
2343 printk("\n");
2344 }
2345 }
2346#endif
2347
2348
2349 if (spp->eoc == 0 && ha->iocount > 1)
2350 printk
2351 ("%s: ihdlr, spp->eoc == 0, irq %d, reg 0x%x, count %d.\n",
2352 ha->board_name, irq, reg, ha->iocount);
2353 if (spp->cpp_index < 0 || spp->cpp_index >= shost->can_queue)
2354 printk
2355 ("%s: ihdlr, bad spp->cpp_index %d, irq %d, reg 0x%x, count %d.\n",
2356 ha->board_name, spp->cpp_index, irq, reg, ha->iocount);
2357 if (spp->eoc == 0 || spp->cpp_index < 0
2358 || spp->cpp_index >= shost->can_queue)
2359 goto handled;
2360
2361
2362 i = spp->cpp_index;
2363
2364 cpp = &(ha->cp[i]);
2365
2366#if defined(DEBUG_GENERATE_ABORTS)
2367 if ((ha->iocount > 500) && ((ha->iocount % 500) < 3))
2368 goto handled;
2369#endif
2370
2371 if (ha->cp_stat[i] == IGNORE) {
2372 ha->cp_stat[i] = FREE;
2373 goto handled;
2374 } else if (ha->cp_stat[i] == LOCKED) {
2375 ha->cp_stat[i] = FREE;
2376 printk("%s: ihdlr, mbox %d unlocked, count %d.\n", ha->board_name, i,
2377 ha->iocount);
2378 goto handled;
2379 } else if (ha->cp_stat[i] == FREE) {
2380 printk("%s: ihdlr, mbox %d is free, count %d.\n", ha->board_name, i,
2381 ha->iocount);
2382 goto handled;
2383 } else if (ha->cp_stat[i] == IN_RESET)
2384 printk("%s: ihdlr, mbox %d is in reset.\n", ha->board_name, i);
2385 else if (ha->cp_stat[i] != IN_USE)
2386 panic("%s: ihdlr, mbox %d, invalid cp_stat: %d.\n",
2387 ha->board_name, i, ha->cp_stat[i]);
2388
2389 ha->cp_stat[i] = FREE;
2390 SCpnt = cpp->SCpnt;
2391
2392 if (SCpnt == NULL)
2393 panic("%s: ihdlr, mbox %d, SCpnt == NULL.\n", ha->board_name, i);
2394
2395 if (SCpnt->host_scribble == NULL)
2396 panic("%s: ihdlr, mbox %d, SCpnt %p garbled.\n", ha->board_name,
2397 i, SCpnt);
2398
2399 if (*(unsigned int *)SCpnt->host_scribble != i)
2400 panic("%s: ihdlr, mbox %d, index mismatch %d.\n",
2401 ha->board_name, i,
2402 *(unsigned int *)SCpnt->host_scribble);
2403
2404 sync_dma(i, ha);
2405
2406 if (linked_comm && SCpnt->device->queue_depth > 2
2407 && TLDEV(SCpnt->device->type))
2408 flush_dev(SCpnt->device, blk_rq_pos(SCpnt->request), ha, 1);
2409
2410 tstatus = status_byte(spp->target_status);
2411
2412#if defined(DEBUG_GENERATE_ERRORS)
2413 if ((ha->iocount > 500) && ((ha->iocount % 200) < 2))
2414 spp->adapter_status = 0x01;
2415#endif
2416
2417 switch (spp->adapter_status) {
2418 case ASOK:
2419
2420
2421 if (tstatus == BUSY && SCpnt->device->type != TYPE_TAPE)
2422 status = DID_ERROR << 16;
2423
2424
2425 else if (tstatus != GOOD && SCpnt->device->type == TYPE_DISK
2426 && ha->target_redo[SCpnt->device->id][SCpnt->
2427 device->
2428 channel])
2429 status = DID_BUS_BUSY << 16;
2430
2431
2432 else if (tstatus == CHECK_CONDITION
2433 && SCpnt->device->type == TYPE_DISK
2434 && (SCpnt->sense_buffer[2] & 0xf) == RECOVERED_ERROR)
2435 status = DID_BUS_BUSY << 16;
2436
2437 else
2438 status = DID_OK << 16;
2439
2440 if (tstatus == GOOD)
2441 ha->target_redo[SCpnt->device->id][SCpnt->device->
2442 channel] = 0;
2443
2444 if (spp->target_status && SCpnt->device->type == TYPE_DISK &&
2445 (!(tstatus == CHECK_CONDITION && ha->iocount <= 1000 &&
2446 (SCpnt->sense_buffer[2] & 0xf) == NOT_READY)))
2447 printk("%s: ihdlr, target %d.%d:%d, "
2448 "target_status 0x%x, sense key 0x%x.\n",
2449 ha->board_name,
2450 SCpnt->device->channel, SCpnt->device->id,
2451 (u8)SCpnt->device->lun,
2452 spp->target_status, SCpnt->sense_buffer[2]);
2453
2454 ha->target_to[SCpnt->device->id][SCpnt->device->channel] = 0;
2455
2456 if (ha->last_retried_pid == SCpnt->serial_number)
2457 ha->retries = 0;
2458
2459 break;
2460 case ASST:
2461 case 0x02:
2462
2463 if (ha->target_to[SCpnt->device->id][SCpnt->device->channel] > 1)
2464 status = DID_ERROR << 16;
2465 else {
2466 status = DID_TIME_OUT << 16;
2467 ha->target_to[SCpnt->device->id][SCpnt->device->
2468 channel]++;
2469 }
2470
2471 break;
2472
2473
2474 case 0x03:
2475 case 0x04:
2476
2477 for (c = 0; c <= shost->max_channel; c++)
2478 for (k = 0; k < shost->max_id; k++)
2479 ha->target_redo[k][c] = 1;
2480
2481 if (SCpnt->device->type != TYPE_TAPE
2482 && ha->retries < MAX_INTERNAL_RETRIES) {
2483
2484#if defined(DID_SOFT_ERROR)
2485 status = DID_SOFT_ERROR << 16;
2486#else
2487 status = DID_BUS_BUSY << 16;
2488#endif
2489
2490 ha->retries++;
2491 ha->last_retried_pid = SCpnt->serial_number;
2492 } else
2493 status = DID_ERROR << 16;
2494
2495 break;
2496 case 0x05:
2497 case 0x06:
2498 case 0x07:
2499 case 0x08:
2500 case 0x09:
2501 case 0x0a:
2502 case 0x0b:
2503 case 0x0c:
2504 default:
2505 status = DID_ERROR << 16;
2506 break;
2507 }
2508
2509 SCpnt->result = status | spp->target_status;
2510
2511#if defined(DEBUG_INTERRUPT)
2512 if (SCpnt->result || do_trace)
2513#else
2514 if ((spp->adapter_status != ASOK && ha->iocount > 1000) ||
2515 (spp->adapter_status != ASOK &&
2516 spp->adapter_status != ASST && ha->iocount <= 1000) ||
2517 do_trace || msg_byte(spp->target_status))
2518#endif
2519 scmd_printk(KERN_INFO, SCpnt, "ihdlr, mbox %2d, err 0x%x:%x,"
2520 " reg 0x%x, count %d.\n",
2521 i, spp->adapter_status, spp->target_status,
2522 reg, ha->iocount);
2523
2524 unmap_dma(i, ha);
2525
2526
2527 SCpnt->host_scribble = NULL;
2528
2529 SCpnt->scsi_done(SCpnt);
2530
2531 if (do_trace)
2532 printk("%s: ihdlr, exit, irq %d, count %d.\n", ha->board_name,
2533 irq, ha->iocount);
2534
2535 handled:
2536 return IRQ_HANDLED;
2537 none:
2538 return IRQ_NONE;
2539}
2540
2541static irqreturn_t do_interrupt_handler(int dummy, void *shap)
2542{
2543 struct Scsi_Host *shost;
2544 unsigned int j;
2545 unsigned long spin_flags;
2546 irqreturn_t ret;
2547
2548
2549 if ((j = (unsigned int)((char *)shap - sha)) >= num_boards)
2550 return IRQ_NONE;
2551 shost = sh[j];
2552
2553 spin_lock_irqsave(shost->host_lock, spin_flags);
2554 ret = ihdlr(shost);
2555 spin_unlock_irqrestore(shost->host_lock, spin_flags);
2556 return ret;
2557}
2558
2559static int eata2x_release(struct Scsi_Host *shost)
2560{
2561 struct hostdata *ha = (struct hostdata *)shost->hostdata;
2562 unsigned int i;
2563
2564 for (i = 0; i < shost->can_queue; i++)
2565 kfree((&ha->cp[i])->sglist);
2566
2567 for (i = 0; i < shost->can_queue; i++)
2568 pci_unmap_single(ha->pdev, ha->cp[i].cp_dma_addr,
2569 sizeof(struct mscp), PCI_DMA_BIDIRECTIONAL);
2570
2571 if (ha->sp_cpu_addr)
2572 pci_free_consistent(ha->pdev, sizeof(struct mssp),
2573 ha->sp_cpu_addr, ha->sp_dma_addr);
2574
2575 free_irq(shost->irq, &sha[ha->board_number]);
2576
2577 if (shost->dma_channel != NO_DMA)
2578 free_dma(shost->dma_channel);
2579
2580 release_region(shost->io_port, shost->n_io_port);
2581 scsi_unregister(shost);
2582 return 0;
2583}
2584
2585#include "scsi_module.c"
2586
2587#ifndef MODULE
2588__setup("eata=", option_setup);
2589#endif
2590