/
ultrastor.c
1210 lines (1045 loc) · 36.1 KB
/
ultrastor.c
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
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
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
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
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
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/*
* ultrastor.c Copyright (C) 1992 David B. Gentzel
* Low-level SCSI driver for UltraStor 14F, 24F, and 34F
* by David B. Gentzel, Whitfield Software Services, Carnegie, PA
* (gentzel@nova.enet.dec.com)
* scatter/gather added by Scott Taylor (n217cg@tamuts.tamu.edu)
* 24F and multiple command support by John F. Carr (jfc@athena.mit.edu)
* John's work modified by Caleb Epstein (cae@jpmorgan.com) and
* Eric Youngdale (ericy@cais.com).
* Thanks to UltraStor for providing the necessary documentation
*
* This is an old driver, for the 14F and 34F you should be using the
* u14-34f driver instead.
*/
/*
* TODO:
* 1. Find out why scatter/gather is limited to 16 requests per command.
* This is fixed, at least on the 24F, as of version 1.12 - CAE.
* 2. Look at command linking (mscp.command_link and
* mscp.command_link_id). (Does not work with many disks,
* and no performance increase. ERY).
* 3. Allow multiple adapters.
*/
/*
* NOTES:
* The UltraStor 14F, 24F, and 34F are a family of intelligent, high
* performance SCSI-2 host adapters. They all support command queueing
* and scatter/gather I/O. Some of them can also emulate the standard
* WD1003 interface for use with OS's which don't support SCSI. Here
* is the scoop on the various models:
* 14F - ISA first-party DMA HA with floppy support and WD1003 emulation.
* 14N - ISA HA with floppy support. I think that this is a non-DMA
* HA. Nothing further known.
* 24F - EISA Bus Master HA with floppy support and WD1003 emulation.
* 34F - VL-Bus Bus Master HA with floppy support (no WD1003 emulation).
*
* The 14F, 24F, and 34F are supported by this driver.
*
* Places flagged with a triple question-mark are things which are either
* unfinished, questionable, or wrong.
*/
/* Changes from version 1.11 alpha to 1.12
*
* Increased the size of the scatter-gather list to 33 entries for
* the 24F adapter (it was 16). I don't have the specs for the 14F
* or the 34F, so they may support larger s-g lists as well.
*
* Caleb Epstein <cae@jpmorgan.com>
*/
/* Changes from version 1.9 to 1.11
*
* Patches to bring this driver up to speed with the default kernel
* driver which supports only the 14F and 34F adapters. This version
* should compile cleanly into 0.99.13, 0.99.12 and probably 0.99.11.
*
* Fixes from Eric Youngdale to fix a few possible race conditions and
* several problems with bit testing operations (insufficient
* parentheses).
*
* Removed the ultrastor_abort() and ultrastor_reset() functions
* (enclosed them in #if 0 / #endif). These functions, at least on
* the 24F, cause the SCSI bus to do odd things and generally lead to
* kernel panics and machine hangs. This is like the Adaptec code.
*
* Use check/snarf_region for 14f, 34f to avoid I/O space address conflicts.
*/
/* Changes from version 1.8 to version 1.9
*
* 0.99.11 patches (cae@jpmorgan.com) */
/* Changes from version 1.7 to version 1.8
*
* Better error reporting.
*/
/* Changes from version 1.6 to version 1.7
*
* Removed CSIR command code.
*
* Better race condition avoidance (xchgb function added).
*
* Set ICM and OGM status to zero at probe (24F)
*
* reset sends soft reset to UltraStor adapter
*
* reset adapter if adapter interrupts with an invalid MSCP address
*
* handle aborted command interrupt (24F)
*
*/
/* Changes from version 1.5 to version 1.6:
*
* Read MSCP address from ICM _before_ clearing the interrupt flag.
* This fixes a race condition.
*/
/* Changes from version 1.4 to version 1.5:
*
* Abort now calls done when multiple commands are enabled.
*
* Clear busy when aborted command finishes, not when abort is called.
*
* More debugging messages for aborts.
*/
/* Changes from version 1.3 to version 1.4:
*
* Enable automatic request of sense data on error (requires newer version
* of scsi.c to be useful).
*
* Fix PORT_OVERRIDE for 14F.
*
* Fix abort and reset to work properly (config.aborted wasn't cleared
* after it was tested, so after a command abort no further commands would
* work).
*
* Boot time test to enable SCSI bus reset (defaults to not allowing reset).
*
* Fix test for OGM busy -- the busy bit is in different places on the 24F.
*
* Release ICM slot by clearing first byte on 24F.
*/
#include <linux/module.h>
#include <linux/blkdev.h>
#include <linux/interrupt.h>
#include <linux/stddef.h>
#include <linux/string.h>
#include <linux/kernel.h>
#include <linux/ioport.h>
#include <linux/proc_fs.h>
#include <linux/spinlock.h>
#include <linux/stat.h>
#include <linux/bitops.h>
#include <linux/delay.h>
#include <asm/io.h>
#include <asm/dma.h>
#define ULTRASTOR_PRIVATE /* Get the private stuff from ultrastor.h */
#include "scsi.h"
#include <scsi/scsi_host.h>
#include "ultrastor.h"
#define FALSE 0
#define TRUE 1
#ifndef ULTRASTOR_DEBUG
#define ULTRASTOR_DEBUG (UD_ABORT|UD_CSIR|UD_RESET)
#endif
#define VERSION "1.12"
#define PACKED __attribute__((packed))
#define ALIGNED(x) __attribute__((aligned(x)))
/* The 14F uses an array of 4-byte ints for its scatter/gather list.
The data can be unaligned, but need not be. It's easier to give
the list normal alignment since it doesn't need to fit into a
packed structure. */
typedef struct {
u32 address;
u32 num_bytes;
} ultrastor_sg_list;
/* MailBox SCSI Command Packet. Basic command structure for communicating
with controller. */
struct mscp {
unsigned char opcode: 3; /* type of command */
unsigned char xdir: 2; /* data transfer direction */
unsigned char dcn: 1; /* disable disconnect */
unsigned char ca: 1; /* use cache (if available) */
unsigned char sg: 1; /* scatter/gather operation */
unsigned char target_id: 3; /* target SCSI id */
unsigned char ch_no: 2; /* SCSI channel (always 0 for 14f) */
unsigned char lun: 3; /* logical unit number */
unsigned int transfer_data PACKED; /* transfer data pointer */
unsigned int transfer_data_length PACKED; /* length in bytes */
unsigned int command_link PACKED; /* for linking command chains */
unsigned char scsi_command_link_id; /* identifies command in chain */
unsigned char number_of_sg_list; /* (if sg is set) 8 bytes per list */
unsigned char length_of_sense_byte;
unsigned char length_of_scsi_cdbs; /* 6, 10, or 12 */
unsigned char scsi_cdbs[12]; /* SCSI commands */
unsigned char adapter_status; /* non-zero indicates HA error */
unsigned char target_status; /* non-zero indicates target error */
u32 sense_data PACKED;
/* The following fields are for software only. They are included in
the MSCP structure because they are associated with SCSI requests. */
void (*done) (struct scsi_cmnd *);
struct scsi_cmnd *SCint;
ultrastor_sg_list sglist[ULTRASTOR_24F_MAX_SG]; /* use larger size for 24F */
};
/* Port addresses (relative to the base address) */
#define U14F_PRODUCT_ID(port) ((port) + 0x4)
#define CONFIG(port) ((port) + 0x6)
/* Port addresses relative to the doorbell base address. */
#define LCL_DOORBELL_MASK(port) ((port) + 0x0)
#define LCL_DOORBELL_INTR(port) ((port) + 0x1)
#define SYS_DOORBELL_MASK(port) ((port) + 0x2)
#define SYS_DOORBELL_INTR(port) ((port) + 0x3)
/* Used to store configuration info read from config i/o registers. Most of
this is not used yet, but might as well save it.
This structure also holds port addresses that are not at the same offset
on the 14F and 24F.
This structure holds all data that must be duplicated to support multiple
adapters. */
static struct ultrastor_config
{
unsigned short port_address; /* base address of card */
unsigned short doorbell_address; /* base address of doorbell CSRs */
unsigned short ogm_address; /* base address of OGM */
unsigned short icm_address; /* base address of ICM */
const void *bios_segment;
unsigned char interrupt: 4;
unsigned char dma_channel: 3;
unsigned char bios_drive_number: 1;
unsigned char heads;
unsigned char sectors;
unsigned char ha_scsi_id: 3;
unsigned char subversion: 4;
unsigned char revision;
/* The slot number is used to distinguish the 24F (slot != 0) from
the 14F and 34F (slot == 0). */
unsigned char slot;
#ifdef PRINT_U24F_VERSION
volatile int csir_done;
#endif
/* A pool of MSCP structures for this adapter, and a bitmask of
busy structures. (If ULTRASTOR_14F_MAX_CMDS == 1, a 1 byte
busy flag is used instead.) */
#if ULTRASTOR_MAX_CMDS == 1
unsigned char mscp_busy;
#else
unsigned long mscp_free;
#endif
volatile unsigned char aborted[ULTRASTOR_MAX_CMDS];
struct mscp mscp[ULTRASTOR_MAX_CMDS];
} config = {0};
/* Set this to 1 to reset the SCSI bus on error. */
static int ultrastor_bus_reset;
/* Allowed BIOS base addresses (NULL indicates reserved) */
static const void *const bios_segment_table[8] = {
NULL, (void *)0xC4000, (void *)0xC8000, (void *)0xCC000,
(void *)0xD0000, (void *)0xD4000, (void *)0xD8000, (void *)0xDC000,
};
/* Allowed IRQs for 14f */
static const unsigned char interrupt_table_14f[4] = { 15, 14, 11, 10 };
/* Allowed DMA channels for 14f (0 indicates reserved) */
static const unsigned char dma_channel_table_14f[4] = { 5, 6, 7, 0 };
/* Head/sector mappings allowed by 14f */
static const struct {
unsigned char heads;
unsigned char sectors;
} mapping_table[4] = { { 16, 63 }, { 64, 32 }, { 64, 63 }, { 64, 32 } };
#ifndef PORT_OVERRIDE
/* ??? A probe of address 0x310 screws up NE2000 cards */
static const unsigned short ultrastor_ports_14f[] = {
0x330, 0x340, /*0x310,*/ 0x230, 0x240, 0x210, 0x130, 0x140,
};
#endif
static void ultrastor_interrupt(void *);
static irqreturn_t do_ultrastor_interrupt(int, void *);
static inline void build_sg_list(struct mscp *, struct scsi_cmnd *SCpnt);
/* Always called with host lock held */
static inline int find_and_clear_bit_16(unsigned long *field)
{
int rv;
if (*field == 0)
panic("No free mscp");
asm volatile (
"xorl %0,%0\n\t"
"0: bsfw %1,%w0\n\t"
"btr %0,%1\n\t"
"jnc 0b"
: "=&r" (rv), "+m" (*field) :);
return rv;
}
/* This has been re-implemented with the help of Richard Earnshaw,
<rwe@pegasus.esprit.ec.org> and works with gcc-2.5.8 and gcc-2.6.0.
The instability noted by jfc below appears to be a bug in
gcc-2.5.x when compiling w/o optimization. --Caleb
This asm is fragile: it doesn't work without the casts and it may
not work without optimization. Maybe I should add a swap builtin
to gcc. --jfc */
static inline unsigned char xchgb(unsigned char reg,
volatile unsigned char *mem)
{
__asm__ ("xchgb %0,%1" : "=q" (reg), "=m" (*mem) : "0" (reg));
return reg;
}
#if ULTRASTOR_DEBUG & (UD_COMMAND | UD_ABORT)
/* Always called with the host lock held */
static void log_ultrastor_abort(struct ultrastor_config *config,
int command)
{
static char fmt[80] = "abort %d (%x); MSCP free pool: %x;";
int i;
for (i = 0; i < ULTRASTOR_MAX_CMDS; i++)
{
fmt[20 + i*2] = ' ';
if (! (config->mscp_free & (1 << i)))
fmt[21 + i*2] = '0' + config->mscp[i].target_id;
else
fmt[21 + i*2] = '-';
}
fmt[20 + ULTRASTOR_MAX_CMDS * 2] = '\n';
fmt[21 + ULTRASTOR_MAX_CMDS * 2] = 0;
printk(fmt, command, &config->mscp[command], config->mscp_free);
}
#endif
static int ultrastor_14f_detect(struct scsi_host_template * tpnt)
{
size_t i;
unsigned char in_byte, version_byte = 0;
struct config_1 {
unsigned char bios_segment: 3;
unsigned char removable_disks_as_fixed: 1;
unsigned char interrupt: 2;
unsigned char dma_channel: 2;
} config_1;
struct config_2 {
unsigned char ha_scsi_id: 3;
unsigned char mapping_mode: 2;
unsigned char bios_drive_number: 1;
unsigned char tfr_port: 2;
} config_2;
#if (ULTRASTOR_DEBUG & UD_DETECT)
printk("US14F: detect: called\n");
#endif
/* If a 24F has already been configured, don't look for a 14F. */
if (config.bios_segment)
return FALSE;
#ifdef PORT_OVERRIDE
if(!request_region(PORT_OVERRIDE, 0xc, "ultrastor")) {
printk("Ultrastor I/O space already in use\n");
return FALSE;
};
config.port_address = PORT_OVERRIDE;
#else
for (i = 0; i < ARRAY_SIZE(ultrastor_ports_14f); i++) {
if(!request_region(ultrastor_ports_14f[i], 0x0c, "ultrastor")) continue;
config.port_address = ultrastor_ports_14f[i];
#endif
#if (ULTRASTOR_DEBUG & UD_DETECT)
printk("US14F: detect: testing port address %03X\n", config.port_address);
#endif
in_byte = inb(U14F_PRODUCT_ID(config.port_address));
if (in_byte != US14F_PRODUCT_ID_0) {
#if (ULTRASTOR_DEBUG & UD_DETECT)
# ifdef PORT_OVERRIDE
printk("US14F: detect: wrong product ID 0 - %02X\n", in_byte);
# else
printk("US14F: detect: no adapter at port %03X\n", config.port_address);
# endif
#endif
#ifdef PORT_OVERRIDE
goto out_release_port;
#else
release_region(config.port_address, 0x0c);
continue;
#endif
}
in_byte = inb(U14F_PRODUCT_ID(config.port_address) + 1);
/* Only upper nibble is significant for Product ID 1 */
if ((in_byte & 0xF0) != US14F_PRODUCT_ID_1) {
#if (ULTRASTOR_DEBUG & UD_DETECT)
# ifdef PORT_OVERRIDE
printk("US14F: detect: wrong product ID 1 - %02X\n", in_byte);
# else
printk("US14F: detect: no adapter at port %03X\n", config.port_address);
# endif
#endif
#ifdef PORT_OVERRIDE
goto out_release_port;
#else
release_region(config.port_address, 0x0c);
continue;
#endif
}
version_byte = in_byte;
#ifndef PORT_OVERRIDE
break;
}
if (i == ARRAY_SIZE(ultrastor_ports_14f)) {
# if (ULTRASTOR_DEBUG & UD_DETECT)
printk("US14F: detect: no port address found!\n");
# endif
/* all ports probed already released - we can just go straight out */
return FALSE;
}
#endif
#if (ULTRASTOR_DEBUG & UD_DETECT)
printk("US14F: detect: adapter found at port address %03X\n",
config.port_address);
#endif
/* Set local doorbell mask to disallow bus reset unless
ultrastor_bus_reset is true. */
outb(ultrastor_bus_reset ? 0xc2 : 0x82, LCL_DOORBELL_MASK(config.port_address));
/* All above tests passed, must be the right thing. Get some useful
info. */
/* Register the I/O space that we use */
*(char *)&config_1 = inb(CONFIG(config.port_address + 0));
*(char *)&config_2 = inb(CONFIG(config.port_address + 1));
config.bios_segment = bios_segment_table[config_1.bios_segment];
config.doorbell_address = config.port_address;
config.ogm_address = config.port_address + 0x8;
config.icm_address = config.port_address + 0xC;
config.interrupt = interrupt_table_14f[config_1.interrupt];
config.ha_scsi_id = config_2.ha_scsi_id;
config.heads = mapping_table[config_2.mapping_mode].heads;
config.sectors = mapping_table[config_2.mapping_mode].sectors;
config.bios_drive_number = config_2.bios_drive_number;
config.subversion = (version_byte & 0x0F);
if (config.subversion == U34F)
config.dma_channel = 0;
else
config.dma_channel = dma_channel_table_14f[config_1.dma_channel];
if (!config.bios_segment) {
#if (ULTRASTOR_DEBUG & UD_DETECT)
printk("US14F: detect: not detected.\n");
#endif
goto out_release_port;
}
/* Final consistency check, verify previous info. */
if (config.subversion != U34F)
if (!config.dma_channel || !(config_2.tfr_port & 0x2)) {
#if (ULTRASTOR_DEBUG & UD_DETECT)
printk("US14F: detect: consistency check failed\n");
#endif
goto out_release_port;
}
/* If we were TRULY paranoid, we could issue a host adapter inquiry
command here and verify the data returned. But frankly, I'm
exhausted! */
/* Finally! Now I'm satisfied... */
#if (ULTRASTOR_DEBUG & UD_DETECT)
printk("US14F: detect: detect succeeded\n"
" Port address: %03X\n"
" BIOS segment: %05X\n"
" Interrupt: %u\n"
" DMA channel: %u\n"
" H/A SCSI ID: %u\n"
" Subversion: %u\n",
config.port_address, config.bios_segment, config.interrupt,
config.dma_channel, config.ha_scsi_id, config.subversion);
#endif
tpnt->this_id = config.ha_scsi_id;
tpnt->unchecked_isa_dma = (config.subversion != U34F);
#if ULTRASTOR_MAX_CMDS > 1
config.mscp_free = ~0;
#endif
/*
* Brrr, &config.mscp[0].SCint->host) it is something magical....
* XXX and FIXME
*/
if (request_irq(config.interrupt, do_ultrastor_interrupt, 0, "Ultrastor", &config.mscp[0].SCint->device->host)) {
printk("Unable to allocate IRQ%u for UltraStor controller.\n",
config.interrupt);
goto out_release_port;
}
if (config.dma_channel && request_dma(config.dma_channel,"Ultrastor")) {
printk("Unable to allocate DMA channel %u for UltraStor controller.\n",
config.dma_channel);
free_irq(config.interrupt, NULL);
goto out_release_port;
}
tpnt->sg_tablesize = ULTRASTOR_14F_MAX_SG;
printk("UltraStor driver version" VERSION ". Using %d SG lists.\n",
ULTRASTOR_14F_MAX_SG);
return TRUE;
out_release_port:
release_region(config.port_address, 0x0c);
return FALSE;
}
static int ultrastor_24f_detect(struct scsi_host_template * tpnt)
{
int i;
struct Scsi_Host * shpnt = NULL;
#if (ULTRASTOR_DEBUG & UD_DETECT)
printk("US24F: detect");
#endif
/* probe each EISA slot at slot address C80 */
for (i = 1; i < 15; i++)
{
unsigned char config_1, config_2;
unsigned short addr = (i << 12) | ULTRASTOR_24F_PORT;
if (inb(addr) != US24F_PRODUCT_ID_0 &&
inb(addr+1) != US24F_PRODUCT_ID_1 &&
inb(addr+2) != US24F_PRODUCT_ID_2)
continue;
config.revision = inb(addr+3);
config.slot = i;
if (! (inb(addr+4) & 1))
{
#if (ULTRASTOR_DEBUG & UD_DETECT)
printk("U24F: found disabled card in slot %u\n", i);
#endif
continue;
}
#if (ULTRASTOR_DEBUG & UD_DETECT)
printk("U24F: found card in slot %u\n", i);
#endif
config_1 = inb(addr + 5);
config.bios_segment = bios_segment_table[config_1 & 7];
switch(config_1 >> 4)
{
case 1:
config.interrupt = 15;
break;
case 2:
config.interrupt = 14;
break;
case 4:
config.interrupt = 11;
break;
case 8:
config.interrupt = 10;
break;
default:
printk("U24F: invalid IRQ\n");
return FALSE;
}
/* BIOS addr set */
/* base port set */
config.port_address = addr;
config.doorbell_address = addr + 12;
config.ogm_address = addr + 0x17;
config.icm_address = addr + 0x1C;
config_2 = inb(addr + 7);
config.ha_scsi_id = config_2 & 7;
config.heads = mapping_table[(config_2 >> 3) & 3].heads;
config.sectors = mapping_table[(config_2 >> 3) & 3].sectors;
#if (ULTRASTOR_DEBUG & UD_DETECT)
printk("US24F: detect: detect succeeded\n"
" Port address: %03X\n"
" BIOS segment: %05X\n"
" Interrupt: %u\n"
" H/A SCSI ID: %u\n",
config.port_address, config.bios_segment,
config.interrupt, config.ha_scsi_id);
#endif
tpnt->this_id = config.ha_scsi_id;
tpnt->unchecked_isa_dma = 0;
tpnt->sg_tablesize = ULTRASTOR_24F_MAX_SG;
shpnt = scsi_register(tpnt, 0);
if (!shpnt) {
printk(KERN_WARNING "(ultrastor:) Could not register scsi device. Aborting registration.\n");
free_irq(config.interrupt, do_ultrastor_interrupt);
return FALSE;
}
if (request_irq(config.interrupt, do_ultrastor_interrupt, 0, "Ultrastor", shpnt))
{
printk("Unable to allocate IRQ%u for UltraStor controller.\n",
config.interrupt);
return FALSE;
}
shpnt->irq = config.interrupt;
shpnt->dma_channel = config.dma_channel;
shpnt->io_port = config.port_address;
#if ULTRASTOR_MAX_CMDS > 1
config.mscp_free = ~0;
#endif
/* Mark ICM and OGM free */
outb(0, addr + 0x16);
outb(0, addr + 0x1B);
/* Set local doorbell mask to disallow bus reset unless
ultrastor_bus_reset is true. */
outb(ultrastor_bus_reset ? 0xc2 : 0x82, LCL_DOORBELL_MASK(addr+12));
outb(0x02, SYS_DOORBELL_MASK(addr+12));
printk("UltraStor driver version " VERSION ". Using %d SG lists.\n",
tpnt->sg_tablesize);
return TRUE;
}
return FALSE;
}
static int ultrastor_detect(struct scsi_host_template * tpnt)
{
tpnt->proc_name = "ultrastor";
return ultrastor_14f_detect(tpnt) || ultrastor_24f_detect(tpnt);
}
static int ultrastor_release(struct Scsi_Host *shost)
{
if (shost->irq)
free_irq(shost->irq, NULL);
if (shost->dma_channel != 0xff)
free_dma(shost->dma_channel);
if (shost->io_port && shost->n_io_port)
release_region(shost->io_port, shost->n_io_port);
scsi_unregister(shost);
return 0;
}
static const char *ultrastor_info(struct Scsi_Host * shpnt)
{
static char buf[64];
if (config.slot)
sprintf(buf, "UltraStor 24F SCSI @ Slot %u IRQ%u",
config.slot, config.interrupt);
else if (config.subversion)
sprintf(buf, "UltraStor 34F SCSI @ Port %03X BIOS %05X IRQ%u",
config.port_address, (int)config.bios_segment,
config.interrupt);
else
sprintf(buf, "UltraStor 14F SCSI @ Port %03X BIOS %05X IRQ%u DMA%u",
config.port_address, (int)config.bios_segment,
config.interrupt, config.dma_channel);
return buf;
}
static inline void build_sg_list(struct mscp *mscp, struct scsi_cmnd *SCpnt)
{
struct scatterlist *sg;
long transfer_length = 0;
int i, max;
max = scsi_sg_count(SCpnt);
scsi_for_each_sg(SCpnt, sg, max, i) {
mscp->sglist[i].address = isa_page_to_bus(sg_page(sg)) + sg->offset;
mscp->sglist[i].num_bytes = sg->length;
transfer_length += sg->length;
}
mscp->number_of_sg_list = max;
mscp->transfer_data = isa_virt_to_bus(mscp->sglist);
/* ??? May not be necessary. Docs are unclear as to whether transfer
length field is ignored or whether it should be set to the total
number of bytes of the transfer. */
mscp->transfer_data_length = transfer_length;
}
static int ultrastor_queuecommand_lck(struct scsi_cmnd *SCpnt,
void (*done) (struct scsi_cmnd *))
{
struct mscp *my_mscp;
#if ULTRASTOR_MAX_CMDS > 1
int mscp_index;
#endif
unsigned int status;
/* Next test is for debugging; "can't happen" */
if ((config.mscp_free & ((1U << ULTRASTOR_MAX_CMDS) - 1)) == 0)
panic("ultrastor_queuecommand: no free MSCP\n");
mscp_index = find_and_clear_bit_16(&config.mscp_free);
/* Has the command been aborted? */
if (xchgb(0xff, &config.aborted[mscp_index]) != 0)
{
status = DID_ABORT << 16;
goto aborted;
}
my_mscp = &config.mscp[mscp_index];
*(unsigned char *)my_mscp = OP_SCSI | (DTD_SCSI << 3);
/* Tape drives don't work properly if the cache is used. The SCSI
READ command for a tape doesn't have a block offset, and the adapter
incorrectly assumes that all reads from the tape read the same
blocks. Results will depend on read buffer size and other disk
activity.
??? Which other device types should never use the cache? */
my_mscp->ca = SCpnt->device->type != TYPE_TAPE;
my_mscp->target_id = SCpnt->device->id;
my_mscp->ch_no = 0;
my_mscp->lun = SCpnt->device->lun;
if (scsi_sg_count(SCpnt)) {
/* Set scatter/gather flag in SCSI command packet */
my_mscp->sg = TRUE;
build_sg_list(my_mscp, SCpnt);
} else {
/* Unset scatter/gather flag in SCSI command packet */
my_mscp->sg = FALSE;
my_mscp->transfer_data = isa_virt_to_bus(scsi_sglist(SCpnt));
my_mscp->transfer_data_length = scsi_bufflen(SCpnt);
}
my_mscp->command_link = 0; /*???*/
my_mscp->scsi_command_link_id = 0; /*???*/
my_mscp->length_of_sense_byte = SCSI_SENSE_BUFFERSIZE;
my_mscp->length_of_scsi_cdbs = SCpnt->cmd_len;
memcpy(my_mscp->scsi_cdbs, SCpnt->cmnd, my_mscp->length_of_scsi_cdbs);
my_mscp->adapter_status = 0;
my_mscp->target_status = 0;
my_mscp->sense_data = isa_virt_to_bus(&SCpnt->sense_buffer);
my_mscp->done = done;
my_mscp->SCint = SCpnt;
SCpnt->host_scribble = (unsigned char *)my_mscp;
/* Find free OGM slot. On 24F, look for OGM status byte == 0.
On 14F and 34F, wait for local interrupt pending flag to clear.
FIXME: now we are using new_eh we should punt here and let the
midlayer sort it out */
retry:
if (config.slot)
while (inb(config.ogm_address - 1) != 0 && config.aborted[mscp_index] == 0xff)
barrier();
/* else??? */
while ((inb(LCL_DOORBELL_INTR(config.doorbell_address)) & (config.slot ? 2 : 1)) && config.aborted[mscp_index] == 0xff)
barrier();
/* To avoid race conditions, keep the code to write to the adapter
atomic. This simplifies the abort code. Right now the
scsi mid layer has the host_lock already held
*/
if (inb(LCL_DOORBELL_INTR(config.doorbell_address)) & (config.slot ? 2 : 1))
goto retry;
status = xchgb(0, &config.aborted[mscp_index]);
if (status != 0xff) {
#if ULTRASTOR_DEBUG & (UD_COMMAND | UD_ABORT)
printk("USx4F: queuecommand: aborted\n");
#if ULTRASTOR_MAX_CMDS > 1
log_ultrastor_abort(&config, mscp_index);
#endif
#endif
status <<= 16;
aborted:
set_bit(mscp_index, &config.mscp_free);
/* If the driver queues commands, call the done proc here. Otherwise
return an error. */
#if ULTRASTOR_MAX_CMDS > 1
SCpnt->result = status;
done(SCpnt);
return 0;
#else
return status;
#endif
}
/* Store pointer in OGM address bytes */
outl(isa_virt_to_bus(my_mscp), config.ogm_address);
/* Issue OGM interrupt */
if (config.slot) {
/* Write OGM command register on 24F */
outb(1, config.ogm_address - 1);
outb(0x2, LCL_DOORBELL_INTR(config.doorbell_address));
} else {
outb(0x1, LCL_DOORBELL_INTR(config.doorbell_address));
}
#if (ULTRASTOR_DEBUG & UD_COMMAND)
printk("USx4F: queuecommand: returning\n");
#endif
return 0;
}
static DEF_SCSI_QCMD(ultrastor_queuecommand)
/* This code must deal with 2 cases:
1. The command has not been written to the OGM. In this case, set
the abort flag and return.
2. The command has been written to the OGM and is stuck somewhere in
the adapter.
2a. On a 24F, ask the adapter to abort the command. It will interrupt
when it does.
2b. Call the command's done procedure.
*/
static int ultrastor_abort(struct scsi_cmnd *SCpnt)
{
#if ULTRASTOR_DEBUG & UD_ABORT
char out[108];
unsigned char icm_status = 0, ogm_status = 0;
unsigned int icm_addr = 0, ogm_addr = 0;
#endif
unsigned int mscp_index;
unsigned char old_aborted;
unsigned long flags;
void (*done)(struct scsi_cmnd *);
struct Scsi_Host *host = SCpnt->device->host;
if(config.slot)
return FAILED; /* Do not attempt an abort for the 24f */
/* Simple consistency checking */
if(!SCpnt->host_scribble)
return FAILED;
mscp_index = ((struct mscp *)SCpnt->host_scribble) - config.mscp;
if (mscp_index >= ULTRASTOR_MAX_CMDS)
panic("Ux4F aborting invalid MSCP");
#if ULTRASTOR_DEBUG & UD_ABORT
if (config.slot)
{
int port0 = (config.slot << 12) | 0xc80;
int i;
unsigned long flags;
spin_lock_irqsave(host->host_lock, flags);
strcpy(out, "OGM %d:%x ICM %d:%x ports: ");
for (i = 0; i < 16; i++)
{
unsigned char p = inb(port0 + i);
out[28 + i * 3] = "0123456789abcdef"[p >> 4];
out[29 + i * 3] = "0123456789abcdef"[p & 15];
out[30 + i * 3] = ' ';
}
out[28 + i * 3] = '\n';
out[29 + i * 3] = 0;
ogm_status = inb(port0 + 22);
ogm_addr = (unsigned int)isa_bus_to_virt(inl(port0 + 23));
icm_status = inb(port0 + 27);
icm_addr = (unsigned int)isa_bus_to_virt(inl(port0 + 28));
spin_unlock_irqrestore(host->host_lock, flags);
}
/* First check to see if an interrupt is pending. I suspect the SiS
chipset loses interrupts. (I also suspect is mangles data, but
one bug at a time... */
if (config.slot ? inb(config.icm_address - 1) == 2 :
(inb(SYS_DOORBELL_INTR(config.doorbell_address)) & 1))
{
printk("Ux4F: abort while completed command pending\n");
spin_lock_irqsave(host->host_lock, flags);
/* FIXME: Ewww... need to think about passing host around properly */
ultrastor_interrupt(NULL);
spin_unlock_irqrestore(host->host_lock, flags);
return SUCCESS;
}
#endif
old_aborted = xchgb(DID_ABORT, &config.aborted[mscp_index]);
/* aborted == 0xff is the signal that queuecommand has not yet sent
the command. It will notice the new abort flag and fail. */
if (old_aborted == 0xff)
return SUCCESS;
/* On 24F, send an abort MSCP request. The adapter will interrupt
and the interrupt handler will call done. */
if (config.slot && inb(config.ogm_address - 1) == 0)
{
unsigned long flags;
spin_lock_irqsave(host->host_lock, flags);
outl(isa_virt_to_bus(&config.mscp[mscp_index]), config.ogm_address);
udelay(8);
outb(0x80, config.ogm_address - 1);
outb(0x2, LCL_DOORBELL_INTR(config.doorbell_address));
#if ULTRASTOR_DEBUG & UD_ABORT
log_ultrastor_abort(&config, mscp_index);
printk(out, ogm_status, ogm_addr, icm_status, icm_addr);
#endif
spin_unlock_irqrestore(host->host_lock, flags);
/* FIXME: add a wait for the abort to complete */
return SUCCESS;
}
#if ULTRASTOR_DEBUG & UD_ABORT
log_ultrastor_abort(&config, mscp_index);
#endif
/* Can't request a graceful abort. Either this is not a 24F or
the OGM is busy. Don't free the command -- the adapter might
still be using it. Setting SCint = 0 causes the interrupt
handler to ignore the command. */
/* FIXME - devices that implement soft resets will still be running
the command after a bus reset. We would probably rather leave
the command in the queue. The upper level code will automatically
leave the command in the active state instead of requeueing it. ERY */
#if ULTRASTOR_DEBUG & UD_ABORT
if (config.mscp[mscp_index].SCint != SCpnt)
printk("abort: command mismatch, %p != %p\n",
config.mscp[mscp_index].SCint, SCpnt);
#endif
if (config.mscp[mscp_index].SCint == NULL)
return FAILED;
if (config.mscp[mscp_index].SCint != SCpnt) panic("Bad abort");
config.mscp[mscp_index].SCint = NULL;
done = config.mscp[mscp_index].done;
config.mscp[mscp_index].done = NULL;
SCpnt->result = DID_ABORT << 16;
/* Take the host lock to guard against scsi layer re-entry */
done(SCpnt);
/* Need to set a timeout here in case command never completes. */
return SUCCESS;
}
static int ultrastor_host_reset(struct scsi_cmnd * SCpnt)
{
unsigned long flags;
int i;
struct Scsi_Host *host = SCpnt->device->host;
#if (ULTRASTOR_DEBUG & UD_RESET)
printk("US14F: reset: called\n");
#endif
if(config.slot)
return FAILED;
spin_lock_irqsave(host->host_lock, flags);
/* Reset the adapter and SCSI bus. The SCSI bus reset can be
inhibited by clearing ultrastor_bus_reset before probe. */
outb(0xc0, LCL_DOORBELL_INTR(config.doorbell_address));
if (config.slot)
{
outb(0, config.ogm_address - 1);
outb(0, config.icm_address - 1);
}
#if ULTRASTOR_MAX_CMDS == 1
if (config.mscp_busy && config.mscp->done && config.mscp->SCint)
{
config.mscp->SCint->result = DID_RESET << 16;
config.mscp->done(config.mscp->SCint);
}