aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/scsi
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/scsi')
-rw-r--r--drivers/scsi/Kconfig83
-rw-r--r--drivers/scsi/Makefile2
-rw-r--r--drivers/scsi/aha1542.c66
-rw-r--r--drivers/scsi/fd_mcs.c1354
-rw-r--r--drivers/scsi/ibmmca.c2379
-rw-r--r--drivers/scsi/sim710.c124
6 files changed, 5 insertions, 4003 deletions
diff --git a/drivers/scsi/Kconfig b/drivers/scsi/Kconfig
index bea04e5d3b5..e9559782d3e 100644
--- a/drivers/scsi/Kconfig
+++ b/drivers/scsi/Kconfig
@@ -808,19 +808,6 @@ config SCSI_FUTURE_DOMAIN
808 To compile this driver as a module, choose M here: the 808 To compile this driver as a module, choose M here: the
809 module will be called fdomain. 809 module will be called fdomain.
810 810
811config SCSI_FD_MCS
812 tristate "Future Domain MCS-600/700 SCSI support"
813 depends on MCA_LEGACY && SCSI
814 ---help---
815 This is support for Future Domain MCS 600/700 MCA SCSI adapters.
816 Some PS/2 computers are equipped with IBM Fast SCSI Adapter/A which
817 is identical to the MCS 700 and hence also supported by this driver.
818 This driver also supports the Reply SB16/SCSI card (the SCSI part).
819 It supports multiple adapters in the same system.
820
821 To compile this driver as a module, choose M here: the
822 module will be called fd_mcs.
823
824config SCSI_GDTH 811config SCSI_GDTH
825 tristate "Intel/ICP (former GDT SCSI Disk Array) RAID Controller support" 812 tristate "Intel/ICP (former GDT SCSI Disk Array) RAID Controller support"
826 depends on (ISA || EISA || PCI) && SCSI && ISA_DMA_API 813 depends on (ISA || EISA || PCI) && SCSI && ISA_DMA_API
@@ -890,76 +877,6 @@ config SCSI_GENERIC_NCR53C400
890 not detect your card. See the file 877 not detect your card. See the file
891 <file:Documentation/scsi/g_NCR5380.txt> for details. 878 <file:Documentation/scsi/g_NCR5380.txt> for details.
892 879
893config SCSI_IBMMCA
894 tristate "IBMMCA SCSI support"
895 depends on MCA && SCSI
896 ---help---
897 This is support for the IBM SCSI adapter found in many of the PS/2
898 series computers. These machines have an MCA bus, so you need to
899 answer Y to "MCA support" as well and read
900 <file:Documentation/mca.txt>.
901
902 If the adapter isn't found during boot (a common problem for models
903 56, 57, 76, and 77) you'll need to use the 'ibmmcascsi=<pun>' kernel
904 option, where <pun> is the id of the SCSI subsystem (usually 7, but
905 if that doesn't work check your reference diskette). Owners of
906 model 95 with a LED-matrix-display can in addition activate some
907 activity info like under OS/2, but more informative, by setting
908 'ibmmcascsi=display' as an additional kernel parameter. Try "man
909 bootparam" or see the documentation of your boot loader about how to
910 pass options to the kernel.
911
912 To compile this driver as a module, choose M here: the
913 module will be called ibmmca.
914
915config IBMMCA_SCSI_ORDER_STANDARD
916 bool "Standard SCSI-order"
917 depends on SCSI_IBMMCA
918 ---help---
919 In the PC-world and in most modern SCSI-BIOS-setups, SCSI-hard disks
920 are assigned to the drive letters, starting with the lowest SCSI-id
921 (physical number -- pun) to be drive C:, as seen from DOS and
922 similar operating systems. When looking into papers describing the
923 ANSI-SCSI-standard, this assignment of drives appears to be wrong.
924 The SCSI-standard follows a hardware-hierarchy which says that id 7
925 has the highest priority and id 0 the lowest. Therefore, the host
926 adapters are still today everywhere placed as SCSI-id 7 by default.
927 In the SCSI-standard, the drive letters express the priority of the
928 disk. C: should be the hard disk, or a partition on it, with the
929 highest priority. This must therefore be the disk with the highest
930 SCSI-id (e.g. 6) and not the one with the lowest! IBM-BIOS kept the
931 original definition of the SCSI-standard as also industrial- and
932 process-control-machines, like VME-CPUs running under realtime-OSes
933 (e.g. LynxOS, OS9) do.
934
935 If you like to run Linux on your MCA-machine with the same
936 assignment of hard disks as seen from e.g. DOS or OS/2 on your
937 machine, which is in addition conformant to the SCSI-standard, you
938 must say Y here. This is also necessary for MCA-Linux users who want
939 to keep downward compatibility to older releases of the
940 IBM-MCA-SCSI-driver (older than driver-release 2.00 and older than
941 June 1997).
942
943 If you like to have the lowest SCSI-id assigned as drive C:, as
944 modern SCSI-BIOSes do, which does not conform to the standard, but
945 is widespread and common in the PC-world of today, you must say N
946 here. If unsure, say Y.
947
948config IBMMCA_SCSI_DEV_RESET
949 bool "Reset SCSI-devices at boottime"
950 depends on SCSI_IBMMCA
951 ---help---
952 By default, SCSI-devices are reset when the machine is powered on.
953 However, some devices exist, like special-control-devices,
954 SCSI-CNC-machines, SCSI-printer or scanners of older type, that do
955 not reset when switched on. If you say Y here, each device connected
956 to your SCSI-bus will be issued a reset-command after it has been
957 probed, while the kernel is booting. This may cause problems with
958 more modern devices, like hard disks, which do not appreciate these
959 reset commands, and can cause your system to hang. So say Y only if
960 you know that one of your older devices needs it; N is the safe
961 answer.
962
963config SCSI_IPS 880config SCSI_IPS
964 tristate "IBM ServeRAID support" 881 tristate "IBM ServeRAID support"
965 depends on PCI && SCSI 882 depends on PCI && SCSI
diff --git a/drivers/scsi/Makefile b/drivers/scsi/Makefile
index 8deedeaf560..1a3368b0861 100644
--- a/drivers/scsi/Makefile
+++ b/drivers/scsi/Makefile
@@ -75,7 +75,6 @@ obj-$(CONFIG_SCSI_AIC94XX) += aic94xx/
75obj-$(CONFIG_SCSI_PM8001) += pm8001/ 75obj-$(CONFIG_SCSI_PM8001) += pm8001/
76obj-$(CONFIG_SCSI_ISCI) += isci/ 76obj-$(CONFIG_SCSI_ISCI) += isci/
77obj-$(CONFIG_SCSI_IPS) += ips.o 77obj-$(CONFIG_SCSI_IPS) += ips.o
78obj-$(CONFIG_SCSI_FD_MCS) += fd_mcs.o
79obj-$(CONFIG_SCSI_FUTURE_DOMAIN)+= fdomain.o 78obj-$(CONFIG_SCSI_FUTURE_DOMAIN)+= fdomain.o
80obj-$(CONFIG_SCSI_IN2000) += in2000.o 79obj-$(CONFIG_SCSI_IN2000) += in2000.o
81obj-$(CONFIG_SCSI_GENERIC_NCR5380) += g_NCR5380.o 80obj-$(CONFIG_SCSI_GENERIC_NCR5380) += g_NCR5380.o
@@ -100,7 +99,6 @@ obj-$(CONFIG_SCSI_SYM53C8XX_2) += sym53c8xx_2/
100obj-$(CONFIG_SCSI_ZALON) += zalon7xx.o 99obj-$(CONFIG_SCSI_ZALON) += zalon7xx.o
101obj-$(CONFIG_SCSI_EATA_PIO) += eata_pio.o 100obj-$(CONFIG_SCSI_EATA_PIO) += eata_pio.o
102obj-$(CONFIG_SCSI_7000FASST) += wd7000.o 101obj-$(CONFIG_SCSI_7000FASST) += wd7000.o
103obj-$(CONFIG_SCSI_IBMMCA) += ibmmca.o
104obj-$(CONFIG_SCSI_EATA) += eata.o 102obj-$(CONFIG_SCSI_EATA) += eata.o
105obj-$(CONFIG_SCSI_DC395x) += dc395x.o 103obj-$(CONFIG_SCSI_DC395x) += dc395x.o
106obj-$(CONFIG_SCSI_DC390T) += tmscsim.o 104obj-$(CONFIG_SCSI_DC390T) += tmscsim.o
diff --git a/drivers/scsi/aha1542.c b/drivers/scsi/aha1542.c
index ede91f37800..f79c8f9e33a 100644
--- a/drivers/scsi/aha1542.c
+++ b/drivers/scsi/aha1542.c
@@ -22,7 +22,7 @@
22 * Added module command-line options 22 * Added module command-line options
23 * 19-Jul-99 23 * 19-Jul-99
24 * Modified by Adam Fritzler 24 * Modified by Adam Fritzler
25 * Added proper detection of the AHA-1640 (MCA version of AHA-1540) 25 * Added proper detection of the AHA-1640 (MCA, now deleted)
26 */ 26 */
27 27
28#include <linux/module.h> 28#include <linux/module.h>
@@ -37,8 +37,6 @@
37#include <linux/spinlock.h> 37#include <linux/spinlock.h>
38#include <linux/isapnp.h> 38#include <linux/isapnp.h>
39#include <linux/blkdev.h> 39#include <linux/blkdev.h>
40#include <linux/mca.h>
41#include <linux/mca-legacy.h>
42#include <linux/slab.h> 40#include <linux/slab.h>
43 41
44#include <asm/dma.h> 42#include <asm/dma.h>
@@ -71,7 +69,7 @@
71#define MAXBOARDS 4 /* Increase this and the sizes of the 69#define MAXBOARDS 4 /* Increase this and the sizes of the
72 arrays below, if you need more.. */ 70 arrays below, if you need more.. */
73 71
74/* Boards 3,4 slots are reserved for ISAPnP/MCA scans */ 72/* Boards 3,4 slots are reserved for ISAPnP scans */
75 73
76static unsigned int bases[MAXBOARDS] __initdata = {0x330, 0x334, 0, 0}; 74static unsigned int bases[MAXBOARDS] __initdata = {0x330, 0x334, 0, 0};
77 75
@@ -1009,66 +1007,6 @@ static int __init aha1542_detect(struct scsi_host_template * tpnt)
1009#endif 1007#endif
1010 1008
1011 /* 1009 /*
1012 * Find MicroChannel cards (AHA1640)
1013 */
1014#ifdef CONFIG_MCA_LEGACY
1015 if(MCA_bus) {
1016 int slot = 0;
1017 int pos = 0;
1018
1019 for (indx = 0; (slot != MCA_NOTFOUND) && (indx < ARRAY_SIZE(bases)); indx++) {
1020
1021 if (bases[indx])
1022 continue;
1023
1024 /* Detect only AHA-1640 cards -- MCA ID 0F1F */
1025 slot = mca_find_unused_adapter(0x0f1f, slot);
1026 if (slot == MCA_NOTFOUND)
1027 break;
1028
1029 /* Found one */
1030 pos = mca_read_stored_pos(slot, 3);
1031
1032 /* Decode address */
1033 if (pos & 0x80) {
1034 if (pos & 0x02) {
1035 if (pos & 0x01)
1036 bases[indx] = 0x334;
1037 else
1038 bases[indx] = 0x234;
1039 } else {
1040 if (pos & 0x01)
1041 bases[indx] = 0x134;
1042 }
1043 } else {
1044 if (pos & 0x02) {
1045 if (pos & 0x01)
1046 bases[indx] = 0x330;
1047 else
1048 bases[indx] = 0x230;
1049 } else {
1050 if (pos & 0x01)
1051 bases[indx] = 0x130;
1052 }
1053 }
1054
1055 /* No need to decode IRQ and Arb level -- those are
1056 * read off the card later.
1057 */
1058 printk(KERN_INFO "Found an AHA-1640 in MCA slot %d, I/O 0x%04x\n", slot, bases[indx]);
1059
1060 mca_set_adapter_name(slot, "Adapter AHA-1640");
1061 mca_set_adapter_procfn(slot, NULL, NULL);
1062 mca_mark_as_used(slot);
1063
1064 /* Go on */
1065 slot++;
1066 }
1067
1068 }
1069#endif
1070
1071 /*
1072 * Hunt for ISA Plug'n'Pray Adaptecs (AHA1535) 1010 * Hunt for ISA Plug'n'Pray Adaptecs (AHA1535)
1073 */ 1011 */
1074 1012
diff --git a/drivers/scsi/fd_mcs.c b/drivers/scsi/fd_mcs.c
deleted file mode 100644
index 53bfcaa86f0..00000000000
--- a/drivers/scsi/fd_mcs.c
+++ /dev/null
@@ -1,1354 +0,0 @@
1/* fd_mcs.c -- Future Domain MCS 600/700 (or IBM OEM) driver
2 *
3 * FutureDomain MCS-600/700 v0.2 03/11/1998 by ZP Gu (zpg@castle.net)
4 *
5 * This driver is cloned from fdomain.* to specifically support
6 * the Future Domain MCS 600/700 MCA SCSI adapters. Some PS/2s
7 * also equipped with IBM Fast SCSI Adapter/A which is an OEM
8 * of MCS 700.
9 *
10 * This driver also supports Reply SB16/SCSI card (the SCSI part).
11 *
12 * What makes this driver different is that this driver is MCA only
13 * and it supports multiple adapters in the same system, IRQ
14 * sharing, some driver statistics, and maps highest SCSI id to sda.
15 * All cards are auto-detected.
16 *
17 * Assumptions: TMC-1800/18C50/18C30, BIOS >= 3.4
18 *
19 * LILO command-line options:
20 * fd_mcs=<FIFO_COUNT>[,<FIFO_SIZE>]
21 *
22 * ********************************************************
23 * Please see Copyrights/Comments in fdomain.* for credits.
24 * Following is from fdomain.c for acknowledgement:
25 *
26 * Created: Sun May 3 18:53:19 1992 by faith@cs.unc.edu
27 * Revised: Wed Oct 2 11:10:55 1996 by r.faith@ieee.org
28 * Author: Rickard E. Faith, faith@cs.unc.edu
29 * Copyright 1992, 1993, 1994, 1995, 1996 Rickard E. Faith
30 *
31 * $Id: fdomain.c,v 5.45 1996/10/02 15:13:06 root Exp $
32
33 * This program is free software; you can redistribute it and/or modify it
34 * under the terms of the GNU General Public License as published by the
35 * Free Software Foundation; either version 2, or (at your option) any
36 * later version.
37
38 * This program is distributed in the hope that it will be useful, but
39 * WITHOUT ANY WARRANTY; without even the implied warranty of
40 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
41 * General Public License for more details.
42
43 * You should have received a copy of the GNU General Public License along
44 * with this program; if not, write to the Free Software Foundation, Inc.,
45 * 675 Mass Ave, Cambridge, MA 02139, USA.
46
47 **************************************************************************
48
49 NOTES ON USER DEFINABLE OPTIONS:
50
51 DEBUG: This turns on the printing of various debug information.
52
53 ENABLE_PARITY: This turns on SCSI parity checking. With the current
54 driver, all attached devices must support SCSI parity. If none of your
55 devices support parity, then you can probably get the driver to work by
56 turning this option off. I have no way of testing this, however, and it
57 would appear that no one ever uses this option.
58
59 FIFO_COUNT: The host adapter has an 8K cache (host adapters based on the
60 18C30 chip have a 2k cache). When this many 512 byte blocks are filled by
61 the SCSI device, an interrupt will be raised. Therefore, this could be as
62 low as 0, or as high as 16. Note, however, that values which are too high
63 or too low seem to prevent any interrupts from occurring, and thereby lock
64 up the machine. I have found that 2 is a good number, but throughput may
65 be increased by changing this value to values which are close to 2.
66 Please let me know if you try any different values.
67 [*****Now a runtime option*****]
68
69 RESELECTION: This is no longer an option, since I gave up trying to
70 implement it in version 4.x of this driver. It did not improve
71 performance at all and made the driver unstable (because I never found one
72 of the two race conditions which were introduced by the multiple
73 outstanding command code). The instability seems a very high price to pay
74 just so that you don't have to wait for the tape to rewind. If you want
75 this feature implemented, send me patches. I'll be happy to send a copy
76 of my (broken) driver to anyone who would like to see a copy.
77
78 **************************************************************************/
79
80#include <linux/module.h>
81#include <linux/init.h>
82#include <linux/interrupt.h>
83#include <linux/blkdev.h>
84#include <linux/errno.h>
85#include <linux/string.h>
86#include <linux/ioport.h>
87#include <linux/proc_fs.h>
88#include <linux/delay.h>
89#include <linux/mca.h>
90#include <linux/spinlock.h>
91#include <linux/slab.h>
92#include <scsi/scsicam.h>
93#include <linux/mca-legacy.h>
94
95#include <asm/io.h>
96
97#include "scsi.h"
98#include <scsi/scsi_host.h>
99
100#define DRIVER_VERSION "v0.2 by ZP Gu<zpg@castle.net>"
101
102/* START OF USER DEFINABLE OPTIONS */
103
104#define DEBUG 0 /* Enable debugging output */
105#define ENABLE_PARITY 1 /* Enable SCSI Parity */
106
107/* END OF USER DEFINABLE OPTIONS */
108
109#if DEBUG
110#define EVERY_ACCESS 0 /* Write a line on every scsi access */
111#define ERRORS_ONLY 1 /* Only write a line if there is an error */
112#define DEBUG_MESSAGES 1 /* Debug MESSAGE IN phase */
113#define DEBUG_ABORT 1 /* Debug abort() routine */
114#define DEBUG_RESET 1 /* Debug reset() routine */
115#define DEBUG_RACE 1 /* Debug interrupt-driven race condition */
116#else
117#define EVERY_ACCESS 0 /* LEAVE THESE ALONE--CHANGE THE ONES ABOVE */
118#define ERRORS_ONLY 0
119#define DEBUG_MESSAGES 0
120#define DEBUG_ABORT 0
121#define DEBUG_RESET 0
122#define DEBUG_RACE 0
123#endif
124
125/* Errors are reported on the line, so we don't need to report them again */
126#if EVERY_ACCESS
127#undef ERRORS_ONLY
128#define ERRORS_ONLY 0
129#endif
130
131#if ENABLE_PARITY
132#define PARITY_MASK 0x08
133#else
134#define PARITY_MASK 0x00
135#endif
136
137enum chip_type {
138 unknown = 0x00,
139 tmc1800 = 0x01,
140 tmc18c50 = 0x02,
141 tmc18c30 = 0x03,
142};
143
144enum {
145 in_arbitration = 0x02,
146 in_selection = 0x04,
147 in_other = 0x08,
148 disconnect = 0x10,
149 aborted = 0x20,
150 sent_ident = 0x40,
151};
152
153enum in_port_type {
154 Read_SCSI_Data = 0,
155 SCSI_Status = 1,
156 TMC_Status = 2,
157 FIFO_Status = 3, /* tmc18c50/tmc18c30 only */
158 Interrupt_Cond = 4, /* tmc18c50/tmc18c30 only */
159 LSB_ID_Code = 5,
160 MSB_ID_Code = 6,
161 Read_Loopback = 7,
162 SCSI_Data_NoACK = 8,
163 Interrupt_Status = 9,
164 Configuration1 = 10,
165 Configuration2 = 11, /* tmc18c50/tmc18c30 only */
166 Read_FIFO = 12,
167 FIFO_Data_Count = 14
168};
169
170enum out_port_type {
171 Write_SCSI_Data = 0,
172 SCSI_Cntl = 1,
173 Interrupt_Cntl = 2,
174 SCSI_Mode_Cntl = 3,
175 TMC_Cntl = 4,
176 Memory_Cntl = 5, /* tmc18c50/tmc18c30 only */
177 Write_Loopback = 7,
178 IO_Control = 11, /* tmc18c30 only */
179 Write_FIFO = 12
180};
181
182struct fd_hostdata {
183 unsigned long _bios_base;
184 int _bios_major;
185 int _bios_minor;
186 volatile int _in_command;
187 Scsi_Cmnd *_current_SC;
188 enum chip_type _chip;
189 int _adapter_mask;
190 int _fifo_count; /* Number of 512 byte blocks before INTR */
191
192 char _adapter_name[64];
193#if DEBUG_RACE
194 volatile int _in_interrupt_flag;
195#endif
196
197 int _SCSI_Mode_Cntl_port;
198 int _FIFO_Data_Count_port;
199 int _Interrupt_Cntl_port;
200 int _Interrupt_Status_port;
201 int _Interrupt_Cond_port;
202 int _Read_FIFO_port;
203 int _Read_SCSI_Data_port;
204 int _SCSI_Cntl_port;
205 int _SCSI_Data_NoACK_port;
206 int _SCSI_Status_port;
207 int _TMC_Cntl_port;
208 int _TMC_Status_port;
209 int _Write_FIFO_port;
210 int _Write_SCSI_Data_port;
211
212 int _FIFO_Size; /* = 0x2000; 8k FIFO for
213 pre-tmc18c30 chips */
214 /* simple stats */
215 int _Bytes_Read;
216 int _Bytes_Written;
217 int _INTR_Processed;
218};
219
220#define FD_MAX_HOSTS 3 /* enough? */
221
222#define HOSTDATA(shpnt) ((struct fd_hostdata *) shpnt->hostdata)
223#define bios_base (HOSTDATA(shpnt)->_bios_base)
224#define bios_major (HOSTDATA(shpnt)->_bios_major)
225#define bios_minor (HOSTDATA(shpnt)->_bios_minor)
226#define in_command (HOSTDATA(shpnt)->_in_command)
227#define current_SC (HOSTDATA(shpnt)->_current_SC)
228#define chip (HOSTDATA(shpnt)->_chip)
229#define adapter_mask (HOSTDATA(shpnt)->_adapter_mask)
230#define FIFO_COUNT (HOSTDATA(shpnt)->_fifo_count)
231#define adapter_name (HOSTDATA(shpnt)->_adapter_name)
232#if DEBUG_RACE
233#define in_interrupt_flag (HOSTDATA(shpnt)->_in_interrupt_flag)
234#endif
235#define SCSI_Mode_Cntl_port (HOSTDATA(shpnt)->_SCSI_Mode_Cntl_port)
236#define FIFO_Data_Count_port (HOSTDATA(shpnt)->_FIFO_Data_Count_port)
237#define Interrupt_Cntl_port (HOSTDATA(shpnt)->_Interrupt_Cntl_port)
238#define Interrupt_Status_port (HOSTDATA(shpnt)->_Interrupt_Status_port)
239#define Interrupt_Cond_port (HOSTDATA(shpnt)->_Interrupt_Cond_port)
240#define Read_FIFO_port (HOSTDATA(shpnt)->_Read_FIFO_port)
241#define Read_SCSI_Data_port (HOSTDATA(shpnt)->_Read_SCSI_Data_port)
242#define SCSI_Cntl_port (HOSTDATA(shpnt)->_SCSI_Cntl_port)
243#define SCSI_Data_NoACK_port (HOSTDATA(shpnt)->_SCSI_Data_NoACK_port)
244#define SCSI_Status_port (HOSTDATA(shpnt)->_SCSI_Status_port)
245#define TMC_Cntl_port (HOSTDATA(shpnt)->_TMC_Cntl_port)
246#define TMC_Status_port (HOSTDATA(shpnt)->_TMC_Status_port)
247#define Write_FIFO_port (HOSTDATA(shpnt)->_Write_FIFO_port)
248#define Write_SCSI_Data_port (HOSTDATA(shpnt)->_Write_SCSI_Data_port)
249#define FIFO_Size (HOSTDATA(shpnt)->_FIFO_Size)
250#define Bytes_Read (HOSTDATA(shpnt)->_Bytes_Read)
251#define Bytes_Written (HOSTDATA(shpnt)->_Bytes_Written)
252#define INTR_Processed (HOSTDATA(shpnt)->_INTR_Processed)
253
254struct fd_mcs_adapters_struct {
255 char *name;
256 int id;
257 enum chip_type fd_chip;
258 int fifo_size;
259 int fifo_count;
260};
261
262#define REPLY_ID 0x5137
263
264static struct fd_mcs_adapters_struct fd_mcs_adapters[] = {
265 {"Future Domain SCSI Adapter MCS-700(18C50)",
266 0x60e9,
267 tmc18c50,
268 0x2000,
269 4},
270 {"Future Domain SCSI Adapter MCS-600/700(TMC-1800)",
271 0x6127,
272 tmc1800,
273 0x2000,
274 4},
275 {"Reply Sound Blaster/SCSI Adapter",
276 REPLY_ID,
277 tmc18c30,
278 0x800,
279 2},
280};
281
282#define FD_BRDS ARRAY_SIZE(fd_mcs_adapters)
283
284static irqreturn_t fd_mcs_intr(int irq, void *dev_id);
285
286static unsigned long addresses[] = { 0xc8000, 0xca000, 0xce000, 0xde000 };
287static unsigned short ports[] = { 0x140, 0x150, 0x160, 0x170 };
288static unsigned short interrupts[] = { 3, 5, 10, 11, 12, 14, 15, 0 };
289
290/* host information */
291static int found = 0;
292static struct Scsi_Host *hosts[FD_MAX_HOSTS + 1] = { NULL };
293
294static int user_fifo_count = 0;
295static int user_fifo_size = 0;
296
297#ifndef MODULE
298static int __init fd_mcs_setup(char *str)
299{
300 static int done_setup = 0;
301 int ints[3];
302
303 get_options(str, 3, ints);
304 if (done_setup++ || ints[0] < 1 || ints[0] > 2 || ints[1] < 1 || ints[1] > 16) {
305 printk("fd_mcs: usage: fd_mcs=FIFO_COUNT, FIFO_SIZE\n");
306 return 0;
307 }
308
309 user_fifo_count = ints[0] >= 1 ? ints[1] : 0;
310 user_fifo_size = ints[0] >= 2 ? ints[2] : 0;
311 return 1;
312}
313
314__setup("fd_mcs=", fd_mcs_setup);
315#endif /* !MODULE */
316
317static void print_banner(struct Scsi_Host *shpnt)
318{
319 printk("scsi%d <fd_mcs>: ", shpnt->host_no);
320
321 if (bios_base) {
322 printk("BIOS at 0x%lX", bios_base);
323 } else {
324 printk("No BIOS");
325 }
326
327 printk(", HostID %d, %s Chip, IRQ %d, IO 0x%lX\n", shpnt->this_id, chip == tmc18c50 ? "TMC-18C50" : (chip == tmc18c30 ? "TMC-18C30" : (chip == tmc1800 ? "TMC-1800" : "Unknown")), shpnt->irq, shpnt->io_port);
328}
329
330
331static void do_pause(unsigned amount)
332{ /* Pause for amount*10 milliseconds */
333 do {
334 mdelay(10);
335 } while (--amount);
336}
337
338static void fd_mcs_make_bus_idle(struct Scsi_Host *shpnt)
339{
340 outb(0, SCSI_Cntl_port);
341 outb(0, SCSI_Mode_Cntl_port);
342 if (chip == tmc18c50 || chip == tmc18c30)
343 outb(0x21 | PARITY_MASK, TMC_Cntl_port); /* Clear forced intr. */
344 else
345 outb(0x01 | PARITY_MASK, TMC_Cntl_port);
346}
347
348static int fd_mcs_detect(struct scsi_host_template * tpnt)
349{
350 int loop;
351 struct Scsi_Host *shpnt;
352
353 /* get id, port, bios, irq */
354 int slot;
355 u_char pos2, pos3, pos4;
356 int id, port, irq;
357 unsigned long bios;
358
359 /* if not MCA machine, return */
360 if (!MCA_bus)
361 return 0;
362
363 /* changeable? */
364 id = 7;
365
366 for (loop = 0; loop < FD_BRDS; loop++) {
367 slot = 0;
368 while (MCA_NOTFOUND != (slot = mca_find_adapter(fd_mcs_adapters[loop].id, slot))) {
369
370 /* if we get this far, an adapter has been detected and is
371 enabled */
372
373 printk(KERN_INFO "scsi <fd_mcs>: %s at slot %d\n", fd_mcs_adapters[loop].name, slot + 1);
374
375 pos2 = mca_read_stored_pos(slot, 2);
376 pos3 = mca_read_stored_pos(slot, 3);
377 pos4 = mca_read_stored_pos(slot, 4);
378
379 /* ready for next probe */
380 slot++;
381
382 if (fd_mcs_adapters[loop].id == REPLY_ID) { /* reply card */
383 static int reply_irq[] = { 10, 11, 14, 15 };
384
385 bios = 0; /* no bios */
386
387 if (pos2 & 0x2)
388 port = ports[pos4 & 0x3];
389 else
390 continue;
391
392 /* can't really disable it, same as irq=10 */
393 irq = reply_irq[((pos4 >> 2) & 0x1) + 2 * ((pos4 >> 4) & 0x1)];
394 } else {
395 bios = addresses[pos2 >> 6];
396 port = ports[(pos2 >> 4) & 0x03];
397 irq = interrupts[(pos2 >> 1) & 0x07];
398 }
399
400 if (irq) {
401 /* claim the slot */
402 mca_set_adapter_name(slot - 1, fd_mcs_adapters[loop].name);
403
404 /* check irq/region */
405 if (request_irq(irq, fd_mcs_intr, IRQF_SHARED, "fd_mcs", hosts)) {
406 printk(KERN_ERR "fd_mcs: interrupt is not available, skipping...\n");
407 continue;
408 }
409
410 /* request I/O region */
411 if (request_region(port, 0x10, "fd_mcs")) {
412 printk(KERN_ERR "fd_mcs: I/O region is already in use, skipping...\n");
413 continue;
414 }
415 /* register */
416 if (!(shpnt = scsi_register(tpnt, sizeof(struct fd_hostdata)))) {
417 printk(KERN_ERR "fd_mcs: scsi_register() failed\n");
418 release_region(port, 0x10);
419 free_irq(irq, hosts);
420 continue;
421 }
422
423
424 /* save name */
425 strcpy(adapter_name, fd_mcs_adapters[loop].name);
426
427 /* chip/fifo */
428 chip = fd_mcs_adapters[loop].fd_chip;
429 /* use boot time value if available */
430 FIFO_COUNT = user_fifo_count ? user_fifo_count : fd_mcs_adapters[loop].fifo_count;
431 FIFO_Size = user_fifo_size ? user_fifo_size : fd_mcs_adapters[loop].fifo_size;
432
433/* FIXME: Do we need to keep this bit of code inside NOT_USED around at all? */
434#ifdef NOT_USED
435 /* *************************************************** */
436 /* Try to toggle 32-bit mode. This only
437 works on an 18c30 chip. (User reports
438 say this works, so we should switch to
439 it in the near future.) */
440 outb(0x80, port + IO_Control);
441 if ((inb(port + Configuration2) & 0x80) == 0x80) {
442 outb(0x00, port + IO_Control);
443 if ((inb(port + Configuration2) & 0x80) == 0x00) {
444 chip = tmc18c30;
445 FIFO_Size = 0x800; /* 2k FIFO */
446
447 printk("FIRST: chip=%s, fifo_size=0x%x\n", (chip == tmc18c30) ? "tmc18c30" : "tmc18c50", FIFO_Size);
448 }
449 }
450
451 /* That should have worked, but appears to
452 have problems. Let's assume it is an
453 18c30 if the RAM is disabled. */
454
455 if (inb(port + Configuration2) & 0x02) {
456 chip = tmc18c30;
457 FIFO_Size = 0x800; /* 2k FIFO */
458
459 printk("SECOND: chip=%s, fifo_size=0x%x\n", (chip == tmc18c30) ? "tmc18c30" : "tmc18c50", FIFO_Size);
460 }
461 /* *************************************************** */
462#endif
463
464 /* IBM/ANSI scsi scan ordering */
465 /* Stick this back in when the scsi.c changes are there */
466 shpnt->reverse_ordering = 1;
467
468
469 /* saving info */
470 hosts[found++] = shpnt;
471
472 shpnt->this_id = id;
473 shpnt->irq = irq;
474 shpnt->io_port = port;
475 shpnt->n_io_port = 0x10;
476
477 /* save */
478 bios_base = bios;
479 adapter_mask = (1 << id);
480
481 /* save more */
482 SCSI_Mode_Cntl_port = port + SCSI_Mode_Cntl;
483 FIFO_Data_Count_port = port + FIFO_Data_Count;
484 Interrupt_Cntl_port = port + Interrupt_Cntl;
485 Interrupt_Status_port = port + Interrupt_Status;
486 Interrupt_Cond_port = port + Interrupt_Cond;
487 Read_FIFO_port = port + Read_FIFO;
488 Read_SCSI_Data_port = port + Read_SCSI_Data;
489 SCSI_Cntl_port = port + SCSI_Cntl;
490 SCSI_Data_NoACK_port = port + SCSI_Data_NoACK;
491 SCSI_Status_port = port + SCSI_Status;
492 TMC_Cntl_port = port + TMC_Cntl;
493 TMC_Status_port = port + TMC_Status;
494 Write_FIFO_port = port + Write_FIFO;
495 Write_SCSI_Data_port = port + Write_SCSI_Data;
496
497 Bytes_Read = 0;
498 Bytes_Written = 0;
499 INTR_Processed = 0;
500
501 /* say something */
502 print_banner(shpnt);
503
504 /* reset */
505 outb(1, SCSI_Cntl_port);
506 do_pause(2);
507 outb(0, SCSI_Cntl_port);
508 do_pause(115);
509 outb(0, SCSI_Mode_Cntl_port);
510 outb(PARITY_MASK, TMC_Cntl_port);
511 /* done reset */
512 }
513 }
514
515 if (found == FD_MAX_HOSTS) {
516 printk("fd_mcs: detecting reached max=%d host adapters.\n", FD_MAX_HOSTS);
517 break;
518 }
519 }
520
521 return found;
522}
523
524static const char *fd_mcs_info(struct Scsi_Host *shpnt)
525{
526 return adapter_name;
527}
528
529static int TOTAL_INTR = 0;
530
531/*
532 * inout : decides on the direction of the dataflow and the meaning of the
533 * variables
534 * buffer: If inout==FALSE data is being written to it else read from it
535 * *start: If inout==FALSE start of the valid data in the buffer
536 * offset: If inout==FALSE offset from the beginning of the imaginary file
537 * from which we start writing into the buffer
538 * length: If inout==FALSE max number of bytes to be written into the buffer
539 * else number of bytes in the buffer
540 */
541static int fd_mcs_proc_info(struct Scsi_Host *shpnt, char *buffer, char **start, off_t offset, int length, int inout)
542{
543 int len = 0;
544
545 if (inout)
546 return (-ENOSYS);
547
548 *start = buffer + offset;
549
550 len += sprintf(buffer + len, "Future Domain MCS-600/700 Driver %s\n", DRIVER_VERSION);
551 len += sprintf(buffer + len, "HOST #%d: %s\n", shpnt->host_no, adapter_name);
552 len += sprintf(buffer + len, "FIFO Size=0x%x, FIFO Count=%d\n", FIFO_Size, FIFO_COUNT);
553 len += sprintf(buffer + len, "DriverCalls=%d, Interrupts=%d, BytesRead=%d, BytesWrite=%d\n\n", TOTAL_INTR, INTR_Processed, Bytes_Read, Bytes_Written);
554
555 if ((len -= offset) <= 0)
556 return 0;
557 if (len > length)
558 len = length;
559 return len;
560}
561
562static int fd_mcs_select(struct Scsi_Host *shpnt, int target)
563{
564 int status;
565 unsigned long timeout;
566
567 outb(0x82, SCSI_Cntl_port); /* Bus Enable + Select */
568 outb(adapter_mask | (1 << target), SCSI_Data_NoACK_port);
569
570 /* Stop arbitration and enable parity */
571 outb(PARITY_MASK, TMC_Cntl_port);
572
573 timeout = 350; /* 350mS -- because of timeouts
574 (was 250mS) */
575
576 do {
577 status = inb(SCSI_Status_port); /* Read adapter status */
578 if (status & 1) { /* Busy asserted */
579 /* Enable SCSI Bus (on error, should make bus idle with 0) */
580 outb(0x80, SCSI_Cntl_port);
581 return 0;
582 }
583 udelay(1000); /* wait one msec */
584 } while (--timeout);
585
586 /* Make bus idle */
587 fd_mcs_make_bus_idle(shpnt);
588#if EVERY_ACCESS
589 if (!target)
590 printk("Selection failed\n");
591#endif
592#if ERRORS_ONLY
593 if (!target) {
594 static int flag = 0;
595
596 if (!flag) /* Skip first failure for all chips. */
597 ++flag;
598 else
599 printk("fd_mcs: Selection failed\n");
600 }
601#endif
602 return 1;
603}
604
605static void my_done(struct Scsi_Host *shpnt, int error)
606{
607 if (in_command) {
608 in_command = 0;
609 outb(0x00, Interrupt_Cntl_port);
610 fd_mcs_make_bus_idle(shpnt);
611 current_SC->result = error;
612 current_SC->scsi_done(current_SC);
613 } else {
614 panic("fd_mcs: my_done() called outside of command\n");
615 }
616#if DEBUG_RACE
617 in_interrupt_flag = 0;
618#endif
619}
620
621/* only my_done needs to be protected */
622static irqreturn_t fd_mcs_intr(int irq, void *dev_id)
623{
624 unsigned long flags;
625 int status;
626 int done = 0;
627 unsigned data_count, tmp_count;
628
629 int i = 0;
630 struct Scsi_Host *shpnt;
631
632 TOTAL_INTR++;
633
634 /* search for one adapter-response on shared interrupt */
635 while ((shpnt = hosts[i++])) {
636 if ((inb(TMC_Status_port)) & 1)
637 break;
638 }
639
640 /* return if some other device on this IRQ caused the interrupt */
641 if (!shpnt) {
642 return IRQ_NONE;
643 }
644
645 INTR_Processed++;
646
647 outb(0x00, Interrupt_Cntl_port);
648
649 /* Abort calls my_done, so we do nothing here. */
650 if (current_SC->SCp.phase & aborted) {
651#if DEBUG_ABORT
652 printk("Interrupt after abort, ignoring\n");
653#endif
654 /* return IRQ_HANDLED; */
655 }
656#if DEBUG_RACE
657 ++in_interrupt_flag;
658#endif
659
660 if (current_SC->SCp.phase & in_arbitration) {
661 status = inb(TMC_Status_port); /* Read adapter status */
662 if (!(status & 0x02)) {
663#if EVERY_ACCESS
664 printk(" AFAIL ");
665#endif
666 spin_lock_irqsave(shpnt->host_lock, flags);
667 my_done(shpnt, DID_BUS_BUSY << 16);
668 spin_unlock_irqrestore(shpnt->host_lock, flags);
669 return IRQ_HANDLED;
670 }
671 current_SC->SCp.phase = in_selection;
672
673 outb(0x40 | FIFO_COUNT, Interrupt_Cntl_port);
674
675 outb(0x82, SCSI_Cntl_port); /* Bus Enable + Select */
676 outb(adapter_mask | (1 << scmd_id(current_SC)), SCSI_Data_NoACK_port);
677
678 /* Stop arbitration and enable parity */
679 outb(0x10 | PARITY_MASK, TMC_Cntl_port);
680#if DEBUG_RACE
681 in_interrupt_flag = 0;
682#endif
683 return IRQ_HANDLED;
684 } else if (current_SC->SCp.phase & in_selection) {
685 status = inb(SCSI_Status_port);
686 if (!(status & 0x01)) {
687 /* Try again, for slow devices */
688 if (fd_mcs_select(shpnt, scmd_id(current_SC))) {
689#if EVERY_ACCESS
690 printk(" SFAIL ");
691#endif
692 spin_lock_irqsave(shpnt->host_lock, flags);
693 my_done(shpnt, DID_NO_CONNECT << 16);
694 spin_unlock_irqrestore(shpnt->host_lock, flags);
695 return IRQ_HANDLED;
696 } else {
697#if EVERY_ACCESS
698 printk(" AltSel ");
699#endif
700 /* Stop arbitration and enable parity */
701 outb(0x10 | PARITY_MASK, TMC_Cntl_port);
702 }
703 }
704 current_SC->SCp.phase = in_other;
705 outb(0x90 | FIFO_COUNT, Interrupt_Cntl_port);
706 outb(0x80, SCSI_Cntl_port);
707#if DEBUG_RACE
708 in_interrupt_flag = 0;
709#endif
710 return IRQ_HANDLED;
711 }
712
713 /* current_SC->SCp.phase == in_other: this is the body of the routine */
714
715 status = inb(SCSI_Status_port);
716
717 if (status & 0x10) { /* REQ */
718
719 switch (status & 0x0e) {
720
721 case 0x08: /* COMMAND OUT */
722 outb(current_SC->cmnd[current_SC->SCp.sent_command++], Write_SCSI_Data_port);
723#if EVERY_ACCESS
724 printk("CMD = %x,", current_SC->cmnd[current_SC->SCp.sent_command - 1]);
725#endif
726 break;
727 case 0x00: /* DATA OUT -- tmc18c50/tmc18c30 only */
728 if (chip != tmc1800 && !current_SC->SCp.have_data_in) {
729 current_SC->SCp.have_data_in = -1;
730 outb(0xd0 | PARITY_MASK, TMC_Cntl_port);
731 }
732 break;
733 case 0x04: /* DATA IN -- tmc18c50/tmc18c30 only */
734 if (chip != tmc1800 && !current_SC->SCp.have_data_in) {
735 current_SC->SCp.have_data_in = 1;
736 outb(0x90 | PARITY_MASK, TMC_Cntl_port);
737 }
738 break;
739 case 0x0c: /* STATUS IN */
740 current_SC->SCp.Status = inb(Read_SCSI_Data_port);
741#if EVERY_ACCESS
742 printk("Status = %x, ", current_SC->SCp.Status);
743#endif
744#if ERRORS_ONLY
745 if (current_SC->SCp.Status && current_SC->SCp.Status != 2 && current_SC->SCp.Status != 8) {
746 printk("ERROR fd_mcs: target = %d, command = %x, status = %x\n", current_SC->device->id, current_SC->cmnd[0], current_SC->SCp.Status);
747 }
748#endif
749 break;
750 case 0x0a: /* MESSAGE OUT */
751 outb(MESSAGE_REJECT, Write_SCSI_Data_port); /* Reject */
752 break;
753 case 0x0e: /* MESSAGE IN */
754 current_SC->SCp.Message = inb(Read_SCSI_Data_port);
755#if EVERY_ACCESS
756 printk("Message = %x, ", current_SC->SCp.Message);
757#endif
758 if (!current_SC->SCp.Message)
759 ++done;
760#if DEBUG_MESSAGES || EVERY_ACCESS
761 if (current_SC->SCp.Message) {
762 printk("fd_mcs: message = %x\n", current_SC->SCp.Message);
763 }
764#endif
765 break;
766 }
767 }
768
769 if (chip == tmc1800 && !current_SC->SCp.have_data_in && (current_SC->SCp.sent_command >= current_SC->cmd_len)) {
770 /* We have to get the FIFO direction
771 correct, so I've made a table based
772 on the SCSI Standard of which commands
773 appear to require a DATA OUT phase.
774 */
775 /*
776 p. 94: Command for all device types
777 CHANGE DEFINITION 40 DATA OUT
778 COMPARE 39 DATA OUT
779 COPY 18 DATA OUT
780 COPY AND VERIFY 3a DATA OUT
781 INQUIRY 12
782 LOG SELECT 4c DATA OUT
783 LOG SENSE 4d
784 MODE SELECT (6) 15 DATA OUT
785 MODE SELECT (10) 55 DATA OUT
786 MODE SENSE (6) 1a
787 MODE SENSE (10) 5a
788 READ BUFFER 3c
789 RECEIVE DIAGNOSTIC RESULTS 1c
790 REQUEST SENSE 03
791 SEND DIAGNOSTIC 1d DATA OUT
792 TEST UNIT READY 00
793 WRITE BUFFER 3b DATA OUT
794
795 p.178: Commands for direct-access devices (not listed on p. 94)
796 FORMAT UNIT 04 DATA OUT
797 LOCK-UNLOCK CACHE 36
798 PRE-FETCH 34
799 PREVENT-ALLOW MEDIUM REMOVAL 1e
800 READ (6)/RECEIVE 08
801 READ (10) 3c
802 READ CAPACITY 25
803 READ DEFECT DATA (10) 37
804 READ LONG 3e
805 REASSIGN BLOCKS 07 DATA OUT
806 RELEASE 17
807 RESERVE 16 DATA OUT
808 REZERO UNIT/REWIND 01
809 SEARCH DATA EQUAL (10) 31 DATA OUT
810 SEARCH DATA HIGH (10) 30 DATA OUT
811 SEARCH DATA LOW (10) 32 DATA OUT
812 SEEK (6) 0b
813 SEEK (10) 2b
814 SET LIMITS (10) 33
815 START STOP UNIT 1b
816 SYNCHRONIZE CACHE 35
817 VERIFY (10) 2f
818 WRITE (6)/PRINT/SEND 0a DATA OUT
819 WRITE (10)/SEND 2a DATA OUT
820 WRITE AND VERIFY (10) 2e DATA OUT
821 WRITE LONG 3f DATA OUT
822 WRITE SAME 41 DATA OUT ?
823
824 p. 261: Commands for sequential-access devices (not previously listed)
825 ERASE 19
826 LOAD UNLOAD 1b
827 LOCATE 2b
828 READ BLOCK LIMITS 05
829 READ POSITION 34
830 READ REVERSE 0f
831 RECOVER BUFFERED DATA 14
832 SPACE 11
833 WRITE FILEMARKS 10 ?
834
835 p. 298: Commands for printer devices (not previously listed)
836 ****** NOT SUPPORTED BY THIS DRIVER, since 0b is SEEK (6) *****
837 SLEW AND PRINT 0b DATA OUT -- same as seek
838 STOP PRINT 1b
839 SYNCHRONIZE BUFFER 10
840
841 p. 315: Commands for processor devices (not previously listed)
842
843 p. 321: Commands for write-once devices (not previously listed)
844 MEDIUM SCAN 38
845 READ (12) a8
846 SEARCH DATA EQUAL (12) b1 DATA OUT
847 SEARCH DATA HIGH (12) b0 DATA OUT
848 SEARCH DATA LOW (12) b2 DATA OUT
849 SET LIMITS (12) b3
850 VERIFY (12) af
851 WRITE (12) aa DATA OUT
852 WRITE AND VERIFY (12) ae DATA OUT
853
854 p. 332: Commands for CD-ROM devices (not previously listed)
855 PAUSE/RESUME 4b
856 PLAY AUDIO (10) 45
857 PLAY AUDIO (12) a5
858 PLAY AUDIO MSF 47
859 PLAY TRACK RELATIVE (10) 49
860 PLAY TRACK RELATIVE (12) a9
861 READ HEADER 44
862 READ SUB-CHANNEL 42
863 READ TOC 43
864
865 p. 370: Commands for scanner devices (not previously listed)
866 GET DATA BUFFER STATUS 34
867 GET WINDOW 25
868 OBJECT POSITION 31
869 SCAN 1b
870 SET WINDOW 24 DATA OUT
871
872 p. 391: Commands for optical memory devices (not listed)
873 ERASE (10) 2c
874 ERASE (12) ac
875 MEDIUM SCAN 38 DATA OUT
876 READ DEFECT DATA (12) b7
877 READ GENERATION 29
878 READ UPDATED BLOCK 2d
879 UPDATE BLOCK 3d DATA OUT
880
881 p. 419: Commands for medium changer devices (not listed)
882 EXCHANGE MEDIUM 46
883 INITIALIZE ELEMENT STATUS 07
884 MOVE MEDIUM a5
885 POSITION TO ELEMENT 2b
886 READ ELEMENT STATUS b8
887 REQUEST VOL. ELEMENT ADDRESS b5
888 SEND VOLUME TAG b6 DATA OUT
889
890 p. 454: Commands for communications devices (not listed previously)
891 GET MESSAGE (6) 08
892 GET MESSAGE (10) 28
893 GET MESSAGE (12) a8
894 */
895
896 switch (current_SC->cmnd[0]) {
897 case CHANGE_DEFINITION:
898 case COMPARE:
899 case COPY:
900 case COPY_VERIFY:
901 case LOG_SELECT:
902 case MODE_SELECT:
903 case MODE_SELECT_10:
904 case SEND_DIAGNOSTIC:
905 case WRITE_BUFFER:
906
907 case FORMAT_UNIT:
908 case REASSIGN_BLOCKS:
909 case RESERVE:
910 case SEARCH_EQUAL:
911 case SEARCH_HIGH:
912 case SEARCH_LOW:
913 case WRITE_6:
914 case WRITE_10:
915 case WRITE_VERIFY:
916 case 0x3f:
917 case 0x41:
918
919 case 0xb1:
920 case 0xb0:
921 case 0xb2:
922 case 0xaa:
923 case 0xae:
924
925 case 0x24:
926
927 case 0x38:
928 case 0x3d:
929
930 case 0xb6:
931
932 case 0xea: /* alternate number for WRITE LONG */
933
934 current_SC->SCp.have_data_in = -1;
935 outb(0xd0 | PARITY_MASK, TMC_Cntl_port);
936 break;
937
938 case 0x00:
939 default:
940
941 current_SC->SCp.have_data_in = 1;
942 outb(0x90 | PARITY_MASK, TMC_Cntl_port);
943 break;
944 }
945 }
946
947 if (current_SC->SCp.have_data_in == -1) { /* DATA OUT */
948 while ((data_count = FIFO_Size - inw(FIFO_Data_Count_port)) > 512) {
949#if EVERY_ACCESS
950 printk("DC=%d, ", data_count);
951#endif
952 if (data_count > current_SC->SCp.this_residual)
953 data_count = current_SC->SCp.this_residual;
954 if (data_count > 0) {
955#if EVERY_ACCESS
956 printk("%d OUT, ", data_count);
957#endif
958 if (data_count == 1) {
959 Bytes_Written++;
960
961 outb(*current_SC->SCp.ptr++, Write_FIFO_port);
962 --current_SC->SCp.this_residual;
963 } else {
964 data_count >>= 1;
965 tmp_count = data_count << 1;
966 outsw(Write_FIFO_port, current_SC->SCp.ptr, data_count);
967 current_SC->SCp.ptr += tmp_count;
968 Bytes_Written += tmp_count;
969 current_SC->SCp.this_residual -= tmp_count;
970 }
971 }
972 if (!current_SC->SCp.this_residual) {
973 if (current_SC->SCp.buffers_residual) {
974 --current_SC->SCp.buffers_residual;
975 ++current_SC->SCp.buffer;
976 current_SC->SCp.ptr = sg_virt(current_SC->SCp.buffer);
977 current_SC->SCp.this_residual = current_SC->SCp.buffer->length;
978 } else
979 break;
980 }
981 }
982 } else if (current_SC->SCp.have_data_in == 1) { /* DATA IN */
983 while ((data_count = inw(FIFO_Data_Count_port)) > 0) {
984#if EVERY_ACCESS
985 printk("DC=%d, ", data_count);
986#endif
987 if (data_count > current_SC->SCp.this_residual)
988 data_count = current_SC->SCp.this_residual;
989 if (data_count) {
990#if EVERY_ACCESS
991 printk("%d IN, ", data_count);
992#endif
993 if (data_count == 1) {
994 Bytes_Read++;
995 *current_SC->SCp.ptr++ = inb(Read_FIFO_port);
996 --current_SC->SCp.this_residual;
997 } else {
998 data_count >>= 1; /* Number of words */
999 tmp_count = data_count << 1;
1000 insw(Read_FIFO_port, current_SC->SCp.ptr, data_count);
1001 current_SC->SCp.ptr += tmp_count;
1002 Bytes_Read += tmp_count;
1003 current_SC->SCp.this_residual -= tmp_count;
1004 }
1005 }
1006 if (!current_SC->SCp.this_residual && current_SC->SCp.buffers_residual) {
1007 --current_SC->SCp.buffers_residual;
1008 ++current_SC->SCp.buffer;
1009 current_SC->SCp.ptr = sg_virt(current_SC->SCp.buffer);
1010 current_SC->SCp.this_residual = current_SC->SCp.buffer->length;
1011 }
1012 }
1013 }
1014
1015 if (done) {
1016#if EVERY_ACCESS
1017 printk(" ** IN DONE %d ** ", current_SC->SCp.have_data_in);
1018#endif
1019
1020#if EVERY_ACCESS
1021 printk("BEFORE MY_DONE. . .");
1022#endif
1023 spin_lock_irqsave(shpnt->host_lock, flags);
1024 my_done(shpnt, (current_SC->SCp.Status & 0xff)
1025 | ((current_SC->SCp.Message & 0xff) << 8) | (DID_OK << 16));
1026 spin_unlock_irqrestore(shpnt->host_lock, flags);
1027#if EVERY_ACCESS
1028 printk("RETURNING.\n");
1029#endif
1030
1031 } else {
1032 if (current_SC->SCp.phase & disconnect) {
1033 outb(0xd0 | FIFO_COUNT, Interrupt_Cntl_port);
1034 outb(0x00, SCSI_Cntl_port);
1035 } else {
1036 outb(0x90 | FIFO_COUNT, Interrupt_Cntl_port);
1037 }
1038 }
1039#if DEBUG_RACE
1040 in_interrupt_flag = 0;
1041#endif
1042 return IRQ_HANDLED;
1043}
1044
1045static int fd_mcs_release(struct Scsi_Host *shpnt)
1046{
1047 int i, this_host, irq_usage;
1048
1049 release_region(shpnt->io_port, shpnt->n_io_port);
1050
1051 this_host = -1;
1052 irq_usage = 0;
1053 for (i = 0; i < found; i++) {
1054 if (shpnt == hosts[i])
1055 this_host = i;
1056 if (shpnt->irq == hosts[i]->irq)
1057 irq_usage++;
1058 }
1059
1060 /* only for the last one */
1061 if (1 == irq_usage)
1062 free_irq(shpnt->irq, hosts);
1063
1064 found--;
1065
1066 for (i = this_host; i < found; i++)
1067 hosts[i] = hosts[i + 1];
1068
1069 hosts[found] = NULL;
1070
1071 return 0;
1072}
1073
1074static int fd_mcs_queue_lck(Scsi_Cmnd * SCpnt, void (*done) (Scsi_Cmnd *))
1075{
1076 struct Scsi_Host *shpnt = SCpnt->device->host;
1077
1078 if (in_command) {
1079 panic("fd_mcs: fd_mcs_queue() NOT REENTRANT!\n");
1080 }
1081#if EVERY_ACCESS
1082 printk("queue: target = %d cmnd = 0x%02x pieces = %d size = %u\n",
1083 SCpnt->target, *(unsigned char *) SCpnt->cmnd,
1084 scsi_sg_count(SCpnt), scsi_bufflen(SCpnt));
1085#endif
1086
1087 fd_mcs_make_bus_idle(shpnt);
1088
1089 SCpnt->scsi_done = done; /* Save this for the done function */
1090 current_SC = SCpnt;
1091
1092 /* Initialize static data */
1093
1094 if (scsi_bufflen(current_SC)) {
1095 current_SC->SCp.buffer = scsi_sglist(current_SC);
1096 current_SC->SCp.ptr = sg_virt(current_SC->SCp.buffer);
1097 current_SC->SCp.this_residual = current_SC->SCp.buffer->length;
1098 current_SC->SCp.buffers_residual = scsi_sg_count(current_SC) - 1;
1099 } else {
1100 current_SC->SCp.ptr = NULL;
1101 current_SC->SCp.this_residual = 0;
1102 current_SC->SCp.buffer = NULL;
1103 current_SC->SCp.buffers_residual = 0;
1104 }
1105
1106
1107 current_SC->SCp.Status = 0;
1108 current_SC->SCp.Message = 0;
1109 current_SC->SCp.have_data_in = 0;
1110 current_SC->SCp.sent_command = 0;
1111 current_SC->SCp.phase = in_arbitration;
1112
1113 /* Start arbitration */
1114 outb(0x00, Interrupt_Cntl_port);
1115 outb(0x00, SCSI_Cntl_port); /* Disable data drivers */
1116 outb(adapter_mask, SCSI_Data_NoACK_port); /* Set our id bit */
1117 in_command = 1;
1118 outb(0x20, Interrupt_Cntl_port);
1119 outb(0x14 | PARITY_MASK, TMC_Cntl_port); /* Start arbitration */
1120
1121 return 0;
1122}
1123
1124static DEF_SCSI_QCMD(fd_mcs_queue)
1125
1126#if DEBUG_ABORT || DEBUG_RESET
1127static void fd_mcs_print_info(Scsi_Cmnd * SCpnt)
1128{
1129 unsigned int imr;
1130 unsigned int irr;
1131 unsigned int isr;
1132 struct Scsi_Host *shpnt = SCpnt->host;
1133
1134 if (!SCpnt || !SCpnt->host) {
1135 printk("fd_mcs: cannot provide detailed information\n");
1136 }
1137
1138 printk("%s\n", fd_mcs_info(SCpnt->host));
1139 print_banner(SCpnt->host);
1140 switch (SCpnt->SCp.phase) {
1141 case in_arbitration:
1142 printk("arbitration ");
1143 break;
1144 case in_selection:
1145 printk("selection ");
1146 break;
1147 case in_other:
1148 printk("other ");
1149 break;
1150 default:
1151 printk("unknown ");
1152 break;
1153 }
1154
1155 printk("(%d), target = %d cmnd = 0x%02x pieces = %d size = %u\n",
1156 SCpnt->SCp.phase, SCpnt->device->id, *(unsigned char *) SCpnt->cmnd,
1157 scsi_sg_count(SCpnt), scsi_bufflen(SCpnt));
1158 printk("sent_command = %d, have_data_in = %d, timeout = %d\n", SCpnt->SCp.sent_command, SCpnt->SCp.have_data_in, SCpnt->timeout);
1159#if DEBUG_RACE
1160 printk("in_interrupt_flag = %d\n", in_interrupt_flag);
1161#endif
1162
1163 imr = (inb(0x0a1) << 8) + inb(0x21);
1164 outb(0x0a, 0xa0);
1165 irr = inb(0xa0) << 8;
1166 outb(0x0a, 0x20);
1167 irr += inb(0x20);
1168 outb(0x0b, 0xa0);
1169 isr = inb(0xa0) << 8;
1170 outb(0x0b, 0x20);
1171 isr += inb(0x20);
1172
1173 /* Print out interesting information */
1174 printk("IMR = 0x%04x", imr);
1175 if (imr & (1 << shpnt->irq))
1176 printk(" (masked)");
1177 printk(", IRR = 0x%04x, ISR = 0x%04x\n", irr, isr);
1178
1179 printk("SCSI Status = 0x%02x\n", inb(SCSI_Status_port));
1180 printk("TMC Status = 0x%02x", inb(TMC_Status_port));
1181 if (inb(TMC_Status_port) & 1)
1182 printk(" (interrupt)");
1183 printk("\n");
1184 printk("Interrupt Status = 0x%02x", inb(Interrupt_Status_port));
1185 if (inb(Interrupt_Status_port) & 0x08)
1186 printk(" (enabled)");
1187 printk("\n");
1188 if (chip == tmc18c50 || chip == tmc18c30) {
1189 printk("FIFO Status = 0x%02x\n", inb(shpnt->io_port + FIFO_Status));
1190 printk("Int. Condition = 0x%02x\n", inb(shpnt->io_port + Interrupt_Cond));
1191 }
1192 printk("Configuration 1 = 0x%02x\n", inb(shpnt->io_port + Configuration1));
1193 if (chip == tmc18c50 || chip == tmc18c30)
1194 printk("Configuration 2 = 0x%02x\n", inb(shpnt->io_port + Configuration2));
1195}
1196#endif
1197
1198static int fd_mcs_abort(Scsi_Cmnd * SCpnt)
1199{
1200 struct Scsi_Host *shpnt = SCpnt->device->host;
1201
1202 unsigned long flags;
1203#if EVERY_ACCESS || ERRORS_ONLY || DEBUG_ABORT
1204 printk("fd_mcs: abort ");
1205#endif
1206
1207 spin_lock_irqsave(shpnt->host_lock, flags);
1208 if (!in_command) {
1209#if EVERY_ACCESS || ERRORS_ONLY
1210 printk(" (not in command)\n");
1211#endif
1212 spin_unlock_irqrestore(shpnt->host_lock, flags);
1213 return FAILED;
1214 } else
1215 printk("\n");
1216
1217#if DEBUG_ABORT
1218 fd_mcs_print_info(SCpnt);
1219#endif
1220
1221 fd_mcs_make_bus_idle(shpnt);
1222
1223 current_SC->SCp.phase |= aborted;
1224
1225 current_SC->result = DID_ABORT << 16;
1226
1227 /* Aborts are not done well. . . */
1228 my_done(shpnt, DID_ABORT << 16);
1229
1230 spin_unlock_irqrestore(shpnt->host_lock, flags);
1231 return SUCCESS;
1232}
1233
1234static int fd_mcs_bus_reset(Scsi_Cmnd * SCpnt) {
1235 struct Scsi_Host *shpnt = SCpnt->device->host;
1236 unsigned long flags;
1237
1238#if DEBUG_RESET
1239 static int called_once = 0;
1240#endif
1241
1242#if ERRORS_ONLY
1243 if (SCpnt)
1244 printk("fd_mcs: SCSI Bus Reset\n");
1245#endif
1246
1247#if DEBUG_RESET
1248 if (called_once)
1249 fd_mcs_print_info(current_SC);
1250 called_once = 1;
1251#endif
1252
1253 spin_lock_irqsave(shpnt->host_lock, flags);
1254
1255 outb(1, SCSI_Cntl_port);
1256 do_pause(2);
1257 outb(0, SCSI_Cntl_port);
1258 do_pause(115);
1259 outb(0, SCSI_Mode_Cntl_port);
1260 outb(PARITY_MASK, TMC_Cntl_port);
1261
1262 spin_unlock_irqrestore(shpnt->host_lock, flags);
1263
1264 /* Unless this is the very first call (i.e., SCPnt == NULL), everything
1265 is probably hosed at this point. We will, however, try to keep
1266 things going by informing the high-level code that we need help. */
1267 return SUCCESS;
1268}
1269
1270#include <scsi/scsi_ioctl.h>
1271
1272static int fd_mcs_biosparam(struct scsi_device * disk, struct block_device *bdev,
1273 sector_t capacity, int *info_array)
1274{
1275 unsigned char *p = scsi_bios_ptable(bdev);
1276 int size = capacity;
1277
1278 /* BIOS >= 3.4 for MCA cards */
1279 /* This algorithm was provided by Future Domain (much thanks!). */
1280
1281 if (p && p[65] == 0xaa && p[64] == 0x55 /* Partition table valid */
1282 && p[4]) { /* Partition type */
1283 /* The partition table layout is as follows:
1284
1285 Start: 0x1b3h
1286 Offset: 0 = partition status
1287 1 = starting head
1288 2 = starting sector and cylinder (word, encoded)
1289 4 = partition type
1290 5 = ending head
1291 6 = ending sector and cylinder (word, encoded)
1292 8 = starting absolute sector (double word)
1293 c = number of sectors (double word)
1294 Signature: 0x1fe = 0x55aa
1295
1296 So, this algorithm assumes:
1297 1) the first partition table is in use,
1298 2) the data in the first entry is correct, and
1299 3) partitions never divide cylinders
1300
1301 Note that (1) may be FALSE for NetBSD (and other BSD flavors),
1302 as well as for Linux. Note also, that Linux doesn't pay any
1303 attention to the fields that are used by this algorithm -- it
1304 only uses the absolute sector data. Recent versions of Linux's
1305 fdisk(1) will fill this data in correctly, and forthcoming
1306 versions will check for consistency.
1307
1308 Checking for a non-zero partition type is not part of the
1309 Future Domain algorithm, but it seemed to be a reasonable thing
1310 to do, especially in the Linux and BSD worlds. */
1311
1312 info_array[0] = p[5] + 1; /* heads */
1313 info_array[1] = p[6] & 0x3f; /* sectors */
1314 } else {
1315 /* Note that this new method guarantees that there will always be
1316 less than 1024 cylinders on a platter. This is good for drives
1317 up to approximately 7.85GB (where 1GB = 1024 * 1024 kB). */
1318 if ((unsigned int) size >= 0x7e0000U)
1319 {
1320 info_array[0] = 0xff; /* heads = 255 */
1321 info_array[1] = 0x3f; /* sectors = 63 */
1322 } else if ((unsigned int) size >= 0x200000U) {
1323 info_array[0] = 0x80; /* heads = 128 */
1324 info_array[1] = 0x3f; /* sectors = 63 */
1325 } else {
1326 info_array[0] = 0x40; /* heads = 64 */
1327 info_array[1] = 0x20; /* sectors = 32 */
1328 }
1329 }
1330 /* For both methods, compute the cylinders */
1331 info_array[2] = (unsigned int) size / (info_array[0] * info_array[1]);
1332 kfree(p);
1333 return 0;
1334}
1335
1336static struct scsi_host_template driver_template = {
1337 .proc_name = "fd_mcs",
1338 .proc_info = fd_mcs_proc_info,
1339 .detect = fd_mcs_detect,
1340 .release = fd_mcs_release,
1341 .info = fd_mcs_info,
1342 .queuecommand = fd_mcs_queue,
1343 .eh_abort_handler = fd_mcs_abort,
1344 .eh_bus_reset_handler = fd_mcs_bus_reset,
1345 .bios_param = fd_mcs_biosparam,
1346 .can_queue = 1,
1347 .this_id = 7,
1348 .sg_tablesize = 64,
1349 .cmd_per_lun = 1,
1350 .use_clustering = DISABLE_CLUSTERING,
1351};
1352#include "scsi_module.c"
1353
1354MODULE_LICENSE("GPL");
diff --git a/drivers/scsi/ibmmca.c b/drivers/scsi/ibmmca.c
deleted file mode 100644
index cd09132d5d7..00000000000
--- a/drivers/scsi/ibmmca.c
+++ /dev/null
@@ -1,2379 +0,0 @@
1/*
2 Low Level Linux Driver for the IBM Microchannel SCSI Subsystem for
3 Linux Kernel >= 2.4.0.
4 Copyright (c) 1995 Strom Systems, Inc. under the terms of the GNU
5 General Public License. Written by Martin Kolinek, December 1995.
6 Further development by: Chris Beauregard, Klaus Kudielka, Michael Lang
7 See the file Documentation/scsi/ibmmca.txt for a detailed description
8 of this driver, the commandline arguments and the history of its
9 development.
10 See the WWW-page: http://www.uni-mainz.de/~langm000/linux.html for latest
11 updates, info and ADF-files for adapters supported by this driver.
12
13 Alan Cox <alan@lxorguk.ukuu.org.uk>
14 Updated for Linux 2.5.45 to use the new error handler, cleaned up the
15 lock macros and did a few unavoidable locking tweaks, plus one locking
16 fix in the irq and completion path.
17
18 */
19
20#include <linux/module.h>
21#include <linux/kernel.h>
22#include <linux/types.h>
23#include <linux/ctype.h>
24#include <linux/string.h>
25#include <linux/interrupt.h>
26#include <linux/ioport.h>
27#include <linux/delay.h>
28#include <linux/blkdev.h>
29#include <linux/proc_fs.h>
30#include <linux/stat.h>
31#include <linux/mca.h>
32#include <linux/spinlock.h>
33#include <linux/init.h>
34
35#include <asm/io.h>
36
37#include "scsi.h"
38#include <scsi/scsi_host.h>
39
40/* Common forward declarations for all Linux-versions: */
41static int ibmmca_queuecommand (struct Scsi_Host *, struct scsi_cmnd *);
42static int ibmmca_abort (Scsi_Cmnd *);
43static int ibmmca_host_reset (Scsi_Cmnd *);
44static int ibmmca_biosparam (struct scsi_device *, struct block_device *, sector_t, int *);
45static int ibmmca_proc_info(struct Scsi_Host *shpnt, char *buffer, char **start, off_t offset, int length, int inout);
46
47
48
49/* current version of this driver-source: */
50#define IBMMCA_SCSI_DRIVER_VERSION "4.0b-ac"
51
52/* driver configuration */
53#define IM_MAX_HOSTS 8 /* maximum number of host adapters */
54#define IM_RESET_DELAY 60 /* seconds allowed for a reset */
55
56/* driver debugging - #undef all for normal operation */
57/* if defined: count interrupts and ignore this special one: */
58#undef IM_DEBUG_TIMEOUT //50
59#define TIMEOUT_PUN 0
60#define TIMEOUT_LUN 0
61/* verbose interrupt: */
62#undef IM_DEBUG_INT
63/* verbose queuecommand: */
64#undef IM_DEBUG_CMD
65/* verbose queucommand for specific SCSI-device type: */
66#undef IM_DEBUG_CMD_SPEC_DEV
67/* verbose device probing */
68#undef IM_DEBUG_PROBE
69
70/* device type that shall be displayed on syslog (only during debugging): */
71#define IM_DEBUG_CMD_DEVICE TYPE_TAPE
72
73/* relative addresses of hardware registers on a subsystem */
74#define IM_CMD_REG(h) ((h)->io_port) /*Command Interface, (4 bytes long) */
75#define IM_ATTN_REG(h) ((h)->io_port+4) /*Attention (1 byte) */
76#define IM_CTR_REG(h) ((h)->io_port+5) /*Basic Control (1 byte) */
77#define IM_INTR_REG(h) ((h)->io_port+6) /*Interrupt Status (1 byte, r/o) */
78#define IM_STAT_REG(h) ((h)->io_port+7) /*Basic Status (1 byte, read only) */
79
80/* basic I/O-port of first adapter */
81#define IM_IO_PORT 0x3540
82/* maximum number of hosts that can be found */
83#define IM_N_IO_PORT 8
84
85/*requests going into the upper nibble of the Attention register */
86/*note: the lower nibble specifies the device(0-14), or subsystem(15) */
87#define IM_IMM_CMD 0x10 /*immediate command */
88#define IM_SCB 0x30 /*Subsystem Control Block command */
89#define IM_LONG_SCB 0x40 /*long Subsystem Control Block command */
90#define IM_EOI 0xe0 /*end-of-interrupt request */
91
92/*values for bits 7,1,0 of Basic Control reg. (bits 6-2 reserved) */
93#define IM_HW_RESET 0x80 /*hardware reset */
94#define IM_ENABLE_DMA 0x02 /*enable subsystem's busmaster DMA */
95#define IM_ENABLE_INTR 0x01 /*enable interrupts to the system */
96
97/*to interpret the upper nibble of Interrupt Status register */
98/*note: the lower nibble specifies the device(0-14), or subsystem(15) */
99#define IM_SCB_CMD_COMPLETED 0x10
100#define IM_SCB_CMD_COMPLETED_WITH_RETRIES 0x50
101#define IM_LOOP_SCATTER_BUFFER_FULL 0x60
102#define IM_ADAPTER_HW_FAILURE 0x70
103#define IM_IMMEDIATE_CMD_COMPLETED 0xa0
104#define IM_CMD_COMPLETED_WITH_FAILURE 0xc0
105#define IM_CMD_ERROR 0xe0
106#define IM_SOFTWARE_SEQUENCING_ERROR 0xf0
107
108/*to interpret bits 3-0 of Basic Status register (bits 7-4 reserved) */
109#define IM_CMD_REG_FULL 0x08
110#define IM_CMD_REG_EMPTY 0x04
111#define IM_INTR_REQUEST 0x02
112#define IM_BUSY 0x01
113
114/*immediate commands (word written into low 2 bytes of command reg) */
115#define IM_RESET_IMM_CMD 0x0400
116#define IM_FEATURE_CTR_IMM_CMD 0x040c
117#define IM_DMA_PACING_IMM_CMD 0x040d
118#define IM_ASSIGN_IMM_CMD 0x040e
119#define IM_ABORT_IMM_CMD 0x040f
120#define IM_FORMAT_PREP_IMM_CMD 0x0417
121
122/*SCB (Subsystem Control Block) structure */
123struct im_scb {
124 unsigned short command; /*command word (read, etc.) */
125 unsigned short enable; /*enable word, modifies cmd */
126 union {
127 unsigned long log_blk_adr; /*block address on SCSI device */
128 unsigned char scsi_cmd_length; /*6,10,12, for other scsi cmd */
129 } u1;
130 unsigned long sys_buf_adr; /*physical system memory adr */
131 unsigned long sys_buf_length; /*size of sys mem buffer */
132 unsigned long tsb_adr; /*Termination Status Block adr */
133 unsigned long scb_chain_adr; /*optional SCB chain address */
134 union {
135 struct {
136 unsigned short count; /*block count, on SCSI device */
137 unsigned short length; /*block length, on SCSI device */
138 } blk;
139 unsigned char scsi_command[12]; /*other scsi command */
140 } u2;
141};
142
143/*structure scatter-gather element (for list of system memory areas) */
144struct im_sge {
145 void *address;
146 unsigned long byte_length;
147};
148
149/*structure returned by a get_pos_info command: */
150struct im_pos_info {
151 unsigned short pos_id; /* adapter id */
152 unsigned char pos_3a; /* pos 3 (if pos 6 = 0) */
153 unsigned char pos_2; /* pos 2 */
154 unsigned char int_level; /* interrupt level IRQ 11 or 14 */
155 unsigned char pos_4a; /* pos 4 (if pos 6 = 0) */
156 unsigned short connector_size; /* MCA connector size: 16 or 32 Bit */
157 unsigned char num_luns; /* number of supported luns per device */
158 unsigned char num_puns; /* number of supported puns */
159 unsigned char pacing_factor; /* pacing factor */
160 unsigned char num_ldns; /* number of ldns available */
161 unsigned char eoi_off; /* time EOI and interrupt inactive */
162 unsigned char max_busy; /* time between reset and busy on */
163 unsigned short cache_stat; /* ldn cachestat. Bit=1 = not cached */
164 unsigned short retry_stat; /* retry status of ldns. Bit=1=disabled */
165 unsigned char pos_4b; /* pos 4 (if pos 6 = 1) */
166 unsigned char pos_3b; /* pos 3 (if pos 6 = 1) */
167 unsigned char pos_6; /* pos 6 */
168 unsigned char pos_5; /* pos 5 */
169 unsigned short max_overlap; /* maximum overlapping requests */
170 unsigned short num_bus; /* number of SCSI-busses */
171};
172
173/*values for SCB command word */
174#define IM_NO_SYNCHRONOUS 0x0040 /*flag for any command */
175#define IM_NO_DISCONNECT 0x0080 /*flag for any command */
176#define IM_READ_DATA_CMD 0x1c01
177#define IM_WRITE_DATA_CMD 0x1c02
178#define IM_READ_VERIFY_CMD 0x1c03
179#define IM_WRITE_VERIFY_CMD 0x1c04
180#define IM_REQUEST_SENSE_CMD 0x1c08
181#define IM_READ_CAPACITY_CMD 0x1c09
182#define IM_DEVICE_INQUIRY_CMD 0x1c0b
183#define IM_READ_LOGICAL_CMD 0x1c2a
184#define IM_OTHER_SCSI_CMD_CMD 0x241f
185
186/* unused, but supported, SCB commands */
187#define IM_GET_COMMAND_COMPLETE_STATUS_CMD 0x1c07 /* command status */
188#define IM_GET_POS_INFO_CMD 0x1c0a /* returns neat stuff */
189#define IM_READ_PREFETCH_CMD 0x1c31 /* caching controller only */
190#define IM_FOMAT_UNIT_CMD 0x1c16 /* format unit */
191#define IM_REASSIGN_BLOCK_CMD 0x1c18 /* in case of error */
192
193/*values to set bits in the enable word of SCB */
194#define IM_READ_CONTROL 0x8000
195#define IM_REPORT_TSB_ONLY_ON_ERROR 0x4000
196#define IM_RETRY_ENABLE 0x2000
197#define IM_POINTER_TO_LIST 0x1000
198#define IM_SUPRESS_EXCEPTION_SHORT 0x0400
199#define IM_BYPASS_BUFFER 0x0200
200#define IM_CHAIN_ON_NO_ERROR 0x0001
201
202/*TSB (Termination Status Block) structure */
203struct im_tsb {
204 unsigned short end_status;
205 unsigned short reserved1;
206 unsigned long residual_byte_count;
207 unsigned long sg_list_element_adr;
208 unsigned short status_length;
209 unsigned char dev_status;
210 unsigned char cmd_status;
211 unsigned char dev_error;
212 unsigned char cmd_error;
213 unsigned short reserved2;
214 unsigned short reserved3;
215 unsigned short low_of_last_scb_adr;
216 unsigned short high_of_last_scb_adr;
217};
218
219/*subsystem uses interrupt request level 14 */
220#define IM_IRQ 14
221/*SCSI-2 F/W may evade to interrupt 11 */
222#define IM_IRQ_FW 11
223
224/* Model 95 has an additional alphanumeric display, which can be used
225 to display SCSI-activities. 8595 models do not have any disk led, which
226 makes this feature quite useful.
227 The regular PS/2 disk led is turned on/off by bits 6,7 of system
228 control port. */
229
230/* LED display-port (actually, last LED on display) */
231#define MOD95_LED_PORT 0x108
232/* system-control-register of PS/2s with diskindicator */
233#define PS2_SYS_CTR 0x92
234/* activity displaying methods */
235#define LED_DISP 1
236#define LED_ADISP 2
237#define LED_ACTIVITY 4
238/* failed intr */
239#define CMD_FAIL 255
240
241/* The SCSI-ID(!) of the accessed SCSI-device is shown on PS/2-95 machines' LED
242 displays. ldn is no longer displayed here, because the ldn mapping is now
243 done dynamically and the ldn <-> pun,lun maps can be looked-up at boottime
244 or during uptime in /proc/scsi/ibmmca/<host_no> in case of trouble,
245 interest, debugging or just for having fun. The left number gives the
246 host-adapter number and the right shows the accessed SCSI-ID. */
247
248/* display_mode is set by the ibmmcascsi= command line arg */
249static int display_mode = 0;
250/* set default adapter timeout */
251static unsigned int adapter_timeout = 45;
252/* for probing on feature-command: */
253static unsigned int global_command_error_excuse = 0;
254/* global setting by command line for adapter_speed */
255static int global_adapter_speed = 0; /* full speed by default */
256
257/* Panel / LED on, do it right for F/W addressin, too. adisplay will
258 * just ignore ids>7, as the panel has only 7 digits available */
259#define PS2_DISK_LED_ON(ad,id) { if (display_mode & LED_DISP) { if (id>9) \
260 outw((ad+48)|((id+55)<<8), MOD95_LED_PORT ); else \
261 outw((ad+48)|((id+48)<<8), MOD95_LED_PORT ); } else \
262 if (display_mode & LED_ADISP) { if (id<7) outb((char)(id+48),MOD95_LED_PORT+1+id); \
263 outb((char)(ad+48), MOD95_LED_PORT); } \
264 if ((display_mode & LED_ACTIVITY)||(!display_mode)) \
265 outb(inb(PS2_SYS_CTR) | 0xc0, PS2_SYS_CTR); }
266
267/* Panel / LED off */
268/* bug fixed, Dec 15, 1997, where | was replaced by & here */
269#define PS2_DISK_LED_OFF() { if (display_mode & LED_DISP) \
270 outw(0x2020, MOD95_LED_PORT ); else if (display_mode & LED_ADISP) { \
271 outl(0x20202020,MOD95_LED_PORT); outl(0x20202020,MOD95_LED_PORT+4); } \
272 if ((display_mode & LED_ACTIVITY)||(!display_mode)) \
273 outb(inb(PS2_SYS_CTR) & 0x3f, PS2_SYS_CTR); }
274
275/* types of different supported hardware that goes to hostdata special */
276#define IBM_SCSI2_FW 0
277#define IBM_7568_WCACHE 1
278#define IBM_EXP_UNIT 2
279#define IBM_SCSI_WCACHE 3
280#define IBM_SCSI 4
281#define IBM_INTEGSCSI 5
282
283/* other special flags for hostdata structure */
284#define FORCED_DETECTION 100
285#define INTEGRATED_SCSI 101
286
287/* List of possible IBM-SCSI-adapters */
288static short ibmmca_id_table[] = {
289 0x8efc,
290 0x8efd,
291 0x8ef8,
292 0x8eff,
293 0x8efe,
294 /* No entry for integrated SCSI, that's part of the register */
295 0
296};
297
298static const char *ibmmca_description[] = {
299 "IBM SCSI-2 F/W Adapter", /* special = 0 */
300 "IBM 7568 Industrial Computer SCSI Adapter w/Cache", /* special = 1 */
301 "IBM Expansion Unit SCSI Controller", /* special = 2 */
302 "IBM SCSI Adapter w/Cache", /* special = 3 */
303 "IBM SCSI Adapter", /* special = 4 */
304 "IBM Integrated SCSI Controller", /* special = 5 */
305};
306
307/* Max number of logical devices (can be up from 0 to 14). 15 is the address
308of the adapter itself. */
309#define MAX_LOG_DEV 15
310
311/*local data for a logical device */
312struct logical_device {
313 struct im_scb scb; /* SCSI-subsystem-control-block structure */
314 struct im_tsb tsb; /* SCSI command complete status block structure */
315 struct im_sge sge[16]; /* scatter gather list structure */
316 unsigned char buf[256]; /* SCSI command return data buffer */
317 Scsi_Cmnd *cmd; /* SCSI-command that is currently in progress */
318 int device_type; /* type of the SCSI-device. See include/scsi/scsi.h
319 for interpretation of the possible values */
320 int block_length; /* blocksize of a particular logical SCSI-device */
321 int cache_flag; /* 1 if this is uncached, 0 if cache is present for ldn */
322 int retry_flag; /* 1 if adapter retry is disabled, 0 if enabled */
323};
324
325/* statistics of the driver during operations (for proc_info) */
326struct Driver_Statistics {
327 /* SCSI statistics on the adapter */
328 int ldn_access[MAX_LOG_DEV + 1]; /* total accesses on a ldn */
329 int ldn_read_access[MAX_LOG_DEV + 1]; /* total read-access on a ldn */
330 int ldn_write_access[MAX_LOG_DEV + 1]; /* total write-access on a ldn */
331 int ldn_inquiry_access[MAX_LOG_DEV + 1]; /* total inquiries on a ldn */
332 int ldn_modeselect_access[MAX_LOG_DEV + 1]; /* total mode selects on ldn */
333 int scbs; /* short SCBs queued */
334 int long_scbs; /* long SCBs queued */
335 int total_accesses; /* total accesses on all ldns */
336 int total_interrupts; /* total interrupts (should be
337 same as total_accesses) */
338 int total_errors; /* command completed with error */
339 /* dynamical assignment statistics */
340 int total_scsi_devices; /* number of physical pun,lun */
341 int dyn_flag; /* flag showing dynamical mode */
342 int dynamical_assignments; /* number of remappings of ldns */
343 int ldn_assignments[MAX_LOG_DEV + 1]; /* number of remappings of each
344 ldn */
345};
346
347/* data structure for each host adapter */
348struct ibmmca_hostdata {
349 /* array of logical devices: */
350 struct logical_device _ld[MAX_LOG_DEV + 1];
351 /* array to convert (pun, lun) into logical device number: */
352 unsigned char _get_ldn[16][8];
353 /*array that contains the information about the physical SCSI-devices
354 attached to this host adapter: */
355 unsigned char _get_scsi[16][8];
356 /* used only when checking logical devices: */
357 int _local_checking_phase_flag;
358 /* report received interrupt: */
359 int _got_interrupt;
360 /* report termination-status of SCSI-command: */
361 int _stat_result;
362 /* reset status (used only when doing reset): */
363 int _reset_status;
364 /* code of the last SCSI command (needed for panic info): */
365 int _last_scsi_command[MAX_LOG_DEV + 1];
366 /* identifier of the last SCSI-command type */
367 int _last_scsi_type[MAX_LOG_DEV + 1];
368 /* last blockcount */
369 int _last_scsi_blockcount[MAX_LOG_DEV + 1];
370 /* last locgical block address */
371 unsigned long _last_scsi_logical_block[MAX_LOG_DEV + 1];
372 /* Counter that points on the next reassignable ldn for dynamical
373 remapping. The default value is 7, that is the first reassignable
374 number in the list at boottime: */
375 int _next_ldn;
376 /* Statistics-structure for this IBM-SCSI-host: */
377 struct Driver_Statistics _IBM_DS;
378 /* This hostadapters pos-registers pos2 until pos6 */
379 unsigned int _pos[8];
380 /* assign a special variable, that contains dedicated info about the
381 adaptertype */
382 int _special;
383 /* connector size on the MCA bus */
384 int _connector_size;
385 /* synchronous SCSI transfer rate bitpattern */
386 int _adapter_speed;
387};
388
389/* macros to access host data structure */
390#define subsystem_pun(h) ((h)->this_id)
391#define subsystem_maxid(h) ((h)->max_id)
392#define ld(h) (((struct ibmmca_hostdata *) (h)->hostdata)->_ld)
393#define get_ldn(h) (((struct ibmmca_hostdata *) (h)->hostdata)->_get_ldn)
394#define get_scsi(h) (((struct ibmmca_hostdata *) (h)->hostdata)->_get_scsi)
395#define local_checking_phase_flag(h) (((struct ibmmca_hostdata *) (h)->hostdata)->_local_checking_phase_flag)
396#define got_interrupt(h) (((struct ibmmca_hostdata *) (h)->hostdata)->_got_interrupt)
397#define stat_result(h) (((struct ibmmca_hostdata *) (h)->hostdata)->_stat_result)
398#define reset_status(h) (((struct ibmmca_hostdata *) (h)->hostdata)->_reset_status)
399#define last_scsi_command(h) (((struct ibmmca_hostdata *) (h)->hostdata)->_last_scsi_command)
400#define last_scsi_type(h) (((struct ibmmca_hostdata *) (h)->hostdata)->_last_scsi_type)
401#define last_scsi_blockcount(h) (((struct ibmmca_hostdata *) (h)->hostdata)->_last_scsi_blockcount)
402#define last_scsi_logical_block(h) (((struct ibmmca_hostdata *) (h)->hostdata)->_last_scsi_logical_block)
403#define last_scsi_type(h) (((struct ibmmca_hostdata *) (h)->hostdata)->_last_scsi_type)
404#define next_ldn(h) (((struct ibmmca_hostdata *) (h)->hostdata)->_next_ldn)
405#define IBM_DS(h) (((struct ibmmca_hostdata *) (h)->hostdata)->_IBM_DS)
406#define special(h) (((struct ibmmca_hostdata *) (h)->hostdata)->_special)
407#define subsystem_connector_size(h) (((struct ibmmca_hostdata *) (h)->hostdata)->_connector_size)
408#define adapter_speed(h) (((struct ibmmca_hostdata *) (h)->hostdata)->_adapter_speed)
409#define pos2(h) (((struct ibmmca_hostdata *) (h)->hostdata)->_pos[2])
410#define pos3(h) (((struct ibmmca_hostdata *) (h)->hostdata)->_pos[3])
411#define pos4(h) (((struct ibmmca_hostdata *) (h)->hostdata)->_pos[4])
412#define pos5(h) (((struct ibmmca_hostdata *) (h)->hostdata)->_pos[5])
413#define pos6(h) (((struct ibmmca_hostdata *) (h)->hostdata)->_pos[6])
414
415/* Define a arbitrary number as subsystem-marker-type. This number is, as
416 described in the ANSI-SCSI-standard, not occupied by other device-types. */
417#define TYPE_IBM_SCSI_ADAPTER 0x2F
418
419/* Define 0xFF for no device type, because this type is not defined within
420 the ANSI-SCSI-standard, therefore, it can be used and should not cause any
421 harm. */
422#define TYPE_NO_DEVICE 0xFF
423
424/* define medium-changer. If this is not defined previously, e.g. Linux
425 2.0.x, define this type here. */
426#ifndef TYPE_MEDIUM_CHANGER
427#define TYPE_MEDIUM_CHANGER 0x08
428#endif
429
430/* define possible operations for the immediate_assign command */
431#define SET_LDN 0
432#define REMOVE_LDN 1
433
434/* ldn which is used to probe the SCSI devices */
435#define PROBE_LDN 0
436
437/* reset status flag contents */
438#define IM_RESET_NOT_IN_PROGRESS 0
439#define IM_RESET_IN_PROGRESS 1
440#define IM_RESET_FINISHED_OK 2
441#define IM_RESET_FINISHED_FAIL 3
442#define IM_RESET_NOT_IN_PROGRESS_NO_INT 4
443#define IM_RESET_FINISHED_OK_NO_INT 5
444
445/* define undefined SCSI-command */
446#define NO_SCSI 0xffff
447
448/*-----------------------------------------------------------------------*/
449
450/* if this is nonzero, ibmmcascsi option has been passed to the kernel */
451static int io_port[IM_MAX_HOSTS] = { 0, 0, 0, 0, 0, 0, 0, 0 };
452static int scsi_id[IM_MAX_HOSTS] = { 7, 7, 7, 7, 7, 7, 7, 7 };
453
454/* fill module-parameters only, when this define is present.
455 (that is kernel version 2.1.x) */
456#if defined(MODULE)
457static char *boot_options = NULL;
458module_param(boot_options, charp, 0);
459module_param_array(io_port, int, NULL, 0);
460module_param_array(scsi_id, int, NULL, 0);
461
462MODULE_LICENSE("GPL");
463#endif
464/*counter of concurrent disk read/writes, to turn on/off disk led */
465static int disk_rw_in_progress = 0;
466
467static unsigned int pos[8]; /* whole pos register-line for diagnosis */
468/* Taking into account the additions, made by ZP Gu.
469 * This selects now the preset value from the configfile and
470 * offers the 'normal' commandline option to be accepted */
471#ifdef CONFIG_IBMMCA_SCSI_ORDER_STANDARD
472static char ibm_ansi_order = 1;
473#else
474static char ibm_ansi_order = 0;
475#endif
476
477static void issue_cmd(struct Scsi_Host *, unsigned long, unsigned char);
478static void internal_done(Scsi_Cmnd * cmd);
479static void check_devices(struct Scsi_Host *, int);
480static int immediate_assign(struct Scsi_Host *, unsigned int, unsigned int, unsigned int, unsigned int);
481static int immediate_feature(struct Scsi_Host *, unsigned int, unsigned int);
482#ifdef CONFIG_IBMMCA_SCSI_DEV_RESET
483static int immediate_reset(struct Scsi_Host *, unsigned int);
484#endif
485static int device_inquiry(struct Scsi_Host *, int);
486static int read_capacity(struct Scsi_Host *, int);
487static int get_pos_info(struct Scsi_Host *);
488static char *ti_p(int);
489static char *ti_l(int);
490static char *ibmrate(unsigned int, int);
491static int probe_display(int);
492static int probe_bus_mode(struct Scsi_Host *);
493static int device_exists(struct Scsi_Host *, int, int *, int *);
494static int option_setup(char *);
495/* local functions needed for proc_info */
496static int ldn_access_load(struct Scsi_Host *, int);
497static int ldn_access_total_read_write(struct Scsi_Host *);
498
499static irqreturn_t interrupt_handler(int irq, void *dev_id)
500{
501 unsigned int intr_reg;
502 unsigned int cmd_result;
503 unsigned int ldn;
504 unsigned long flags;
505 Scsi_Cmnd *cmd;
506 int lastSCSI;
507 struct device *dev = dev_id;
508 struct Scsi_Host *shpnt = dev_get_drvdata(dev);
509
510 spin_lock_irqsave(shpnt->host_lock, flags);
511
512 if(!(inb(IM_STAT_REG(shpnt)) & IM_INTR_REQUEST)) {
513 spin_unlock_irqrestore(shpnt->host_lock, flags);
514 return IRQ_NONE;
515 }
516
517 /* the reset-function already did all the job, even ints got
518 renabled on the subsystem, so just return */
519 if ((reset_status(shpnt) == IM_RESET_NOT_IN_PROGRESS_NO_INT) || (reset_status(shpnt) == IM_RESET_FINISHED_OK_NO_INT)) {
520 reset_status(shpnt) = IM_RESET_NOT_IN_PROGRESS;
521 spin_unlock_irqrestore(shpnt->host_lock, flags);
522 return IRQ_HANDLED;
523 }
524
525 /*must wait for attention reg not busy, then send EOI to subsystem */
526 while (1) {
527 if (!(inb(IM_STAT_REG(shpnt)) & IM_BUSY))
528 break;
529 cpu_relax();
530 }
531
532 /*get command result and logical device */
533 intr_reg = (unsigned char) (inb(IM_INTR_REG(shpnt)));
534 cmd_result = intr_reg & 0xf0;
535 ldn = intr_reg & 0x0f;
536 /* get the last_scsi_command here */
537 lastSCSI = last_scsi_command(shpnt)[ldn];
538 outb(IM_EOI | ldn, IM_ATTN_REG(shpnt));
539
540 /*these should never happen (hw fails, or a local programming bug) */
541 if (!global_command_error_excuse) {
542 switch (cmd_result) {
543 /* Prevent from Ooopsing on error to show the real reason */
544 case IM_ADAPTER_HW_FAILURE:
545 case IM_SOFTWARE_SEQUENCING_ERROR:
546 case IM_CMD_ERROR:
547 printk(KERN_ERR "IBM MCA SCSI: Fatal Subsystem ERROR!\n");
548 printk(KERN_ERR " Last cmd=0x%x, ena=%x, len=", lastSCSI, ld(shpnt)[ldn].scb.enable);
549 if (ld(shpnt)[ldn].cmd)
550 printk("%ld/%ld,", (long) (scsi_bufflen(ld(shpnt)[ldn].cmd)), (long) (ld(shpnt)[ldn].scb.sys_buf_length));
551 else
552 printk("none,");
553 if (ld(shpnt)[ldn].cmd)
554 printk("Blocksize=%d", ld(shpnt)[ldn].scb.u2.blk.length);
555 else
556 printk("Blocksize=none");
557 printk(", host=%p, ldn=0x%x\n", shpnt, ldn);
558 if (ld(shpnt)[ldn].cmd) {
559 printk(KERN_ERR "Blockcount=%d/%d\n", last_scsi_blockcount(shpnt)[ldn], ld(shpnt)[ldn].scb.u2.blk.count);
560 printk(KERN_ERR "Logical block=%lx/%lx\n", last_scsi_logical_block(shpnt)[ldn], ld(shpnt)[ldn].scb.u1.log_blk_adr);
561 }
562 printk(KERN_ERR "Reason given: %s\n", (cmd_result == IM_ADAPTER_HW_FAILURE) ? "HARDWARE FAILURE" : (cmd_result == IM_SOFTWARE_SEQUENCING_ERROR) ? "SOFTWARE SEQUENCING ERROR" : (cmd_result == IM_CMD_ERROR) ? "COMMAND ERROR" : "UNKNOWN");
563 /* if errors appear, enter this section to give detailed info */
564 printk(KERN_ERR "IBM MCA SCSI: Subsystem Error-Status follows:\n");
565 printk(KERN_ERR " Command Type................: %x\n", last_scsi_type(shpnt)[ldn]);
566 printk(KERN_ERR " Attention Register..........: %x\n", inb(IM_ATTN_REG(shpnt)));
567 printk(KERN_ERR " Basic Control Register......: %x\n", inb(IM_CTR_REG(shpnt)));
568 printk(KERN_ERR " Interrupt Status Register...: %x\n", intr_reg);
569 printk(KERN_ERR " Basic Status Register.......: %x\n", inb(IM_STAT_REG(shpnt)));
570 if ((last_scsi_type(shpnt)[ldn] == IM_SCB) || (last_scsi_type(shpnt)[ldn] == IM_LONG_SCB)) {
571 printk(KERN_ERR " SCB-Command.................: %x\n", ld(shpnt)[ldn].scb.command);
572 printk(KERN_ERR " SCB-Enable..................: %x\n", ld(shpnt)[ldn].scb.enable);
573 printk(KERN_ERR " SCB-logical block address...: %lx\n", ld(shpnt)[ldn].scb.u1.log_blk_adr);
574 printk(KERN_ERR " SCB-system buffer address...: %lx\n", ld(shpnt)[ldn].scb.sys_buf_adr);
575 printk(KERN_ERR " SCB-system buffer length....: %lx\n", ld(shpnt)[ldn].scb.sys_buf_length);
576 printk(KERN_ERR " SCB-tsb address.............: %lx\n", ld(shpnt)[ldn].scb.tsb_adr);
577 printk(KERN_ERR " SCB-Chain address...........: %lx\n", ld(shpnt)[ldn].scb.scb_chain_adr);
578 printk(KERN_ERR " SCB-block count.............: %x\n", ld(shpnt)[ldn].scb.u2.blk.count);
579 printk(KERN_ERR " SCB-block length............: %x\n", ld(shpnt)[ldn].scb.u2.blk.length);
580 }
581 printk(KERN_ERR " Send this report to the maintainer.\n");
582 panic("IBM MCA SCSI: Fatal error message from the subsystem (0x%X,0x%X)!\n", lastSCSI, cmd_result);
583 break;
584 }
585 } else {
586 /* The command error handling is made silent, but we tell the
587 * calling function, that there is a reported error from the
588 * adapter. */
589 switch (cmd_result) {
590 case IM_ADAPTER_HW_FAILURE:
591 case IM_SOFTWARE_SEQUENCING_ERROR:
592 case IM_CMD_ERROR:
593 global_command_error_excuse = CMD_FAIL;
594 break;
595 default:
596 global_command_error_excuse = 0;
597 break;
598 }
599 }
600 /* if no panic appeared, increase the interrupt-counter */
601 IBM_DS(shpnt).total_interrupts++;
602 /*only for local checking phase */
603 if (local_checking_phase_flag(shpnt)) {
604 stat_result(shpnt) = cmd_result;
605 got_interrupt(shpnt) = 1;
606 reset_status(shpnt) = IM_RESET_FINISHED_OK;
607 last_scsi_command(shpnt)[ldn] = NO_SCSI;
608 spin_unlock_irqrestore(shpnt->host_lock, flags);
609 return IRQ_HANDLED;
610 }
611 /* handling of commands coming from upper level of scsi driver */
612 if (last_scsi_type(shpnt)[ldn] == IM_IMM_CMD) {
613 /* verify ldn, and may handle rare reset immediate command */
614 if ((reset_status(shpnt) == IM_RESET_IN_PROGRESS) && (last_scsi_command(shpnt)[ldn] == IM_RESET_IMM_CMD)) {
615 if (cmd_result == IM_CMD_COMPLETED_WITH_FAILURE) {
616 disk_rw_in_progress = 0;
617 PS2_DISK_LED_OFF();
618 reset_status(shpnt) = IM_RESET_FINISHED_FAIL;
619 } else {
620 /*reset disk led counter, turn off disk led */
621 disk_rw_in_progress = 0;
622 PS2_DISK_LED_OFF();
623 reset_status(shpnt) = IM_RESET_FINISHED_OK;
624 }
625 stat_result(shpnt) = cmd_result;
626 last_scsi_command(shpnt)[ldn] = NO_SCSI;
627 last_scsi_type(shpnt)[ldn] = 0;
628 spin_unlock_irqrestore(shpnt->host_lock, flags);
629 return IRQ_HANDLED;
630 } else if (last_scsi_command(shpnt)[ldn] == IM_ABORT_IMM_CMD) {
631 /* react on SCSI abort command */
632#ifdef IM_DEBUG_PROBE
633 printk("IBM MCA SCSI: Interrupt from SCSI-abort.\n");
634#endif
635 disk_rw_in_progress = 0;
636 PS2_DISK_LED_OFF();
637 cmd = ld(shpnt)[ldn].cmd;
638 ld(shpnt)[ldn].cmd = NULL;
639 if (cmd_result == IM_CMD_COMPLETED_WITH_FAILURE)
640 cmd->result = DID_NO_CONNECT << 16;
641 else
642 cmd->result = DID_ABORT << 16;
643 stat_result(shpnt) = cmd_result;
644 last_scsi_command(shpnt)[ldn] = NO_SCSI;
645 last_scsi_type(shpnt)[ldn] = 0;
646 if (cmd->scsi_done)
647 (cmd->scsi_done) (cmd); /* should be the internal_done */
648 spin_unlock_irqrestore(shpnt->host_lock, flags);
649 return IRQ_HANDLED;
650 } else {
651 disk_rw_in_progress = 0;
652 PS2_DISK_LED_OFF();
653 reset_status(shpnt) = IM_RESET_FINISHED_OK;
654 stat_result(shpnt) = cmd_result;
655 last_scsi_command(shpnt)[ldn] = NO_SCSI;
656 spin_unlock_irqrestore(shpnt->host_lock, flags);
657 return IRQ_HANDLED;
658 }
659 }
660 last_scsi_command(shpnt)[ldn] = NO_SCSI;
661 last_scsi_type(shpnt)[ldn] = 0;
662 cmd = ld(shpnt)[ldn].cmd;
663 ld(shpnt)[ldn].cmd = NULL;
664#ifdef IM_DEBUG_TIMEOUT
665 if (cmd) {
666 if ((cmd->target == TIMEOUT_PUN) && (cmd->device->lun == TIMEOUT_LUN)) {
667 spin_unlock_irqsave(shpnt->host_lock, flags);
668 printk("IBM MCA SCSI: Ignoring interrupt from pun=%x, lun=%x.\n", cmd->target, cmd->device->lun);
669 return IRQ_HANDLED;
670 }
671 }
672#endif
673 /*if no command structure, just return, else clear cmd */
674 if (!cmd)
675 {
676 spin_unlock_irqrestore(shpnt->host_lock, flags);
677 return IRQ_HANDLED;
678 }
679
680#ifdef IM_DEBUG_INT
681 printk("cmd=%02x ireg=%02x ds=%02x cs=%02x de=%02x ce=%02x\n", cmd->cmnd[0], intr_reg, ld(shpnt)[ldn].tsb.dev_status, ld(shpnt)[ldn].tsb.cmd_status, ld(shpnt)[ldn].tsb.dev_error, ld(shpnt)[ldn].tsb.cmd_error);
682#endif
683 /*if this is end of media read/write, may turn off PS/2 disk led */
684 if ((ld(shpnt)[ldn].device_type != TYPE_NO_LUN) && (ld(shpnt)[ldn].device_type != TYPE_NO_DEVICE)) {
685 /* only access this, if there was a valid device addressed */
686 if (--disk_rw_in_progress == 0)
687 PS2_DISK_LED_OFF();
688 }
689
690 /* IBM describes the status-mask to be 0x1e, but this is not conform
691 * with SCSI-definition, I suppose, the reason for it is that IBM
692 * adapters do not support CMD_TERMINATED, TASK_SET_FULL and
693 * ACA_ACTIVE as returning statusbyte information. (ML) */
694 if (cmd_result == IM_CMD_COMPLETED_WITH_FAILURE) {
695 cmd->result = (unsigned char) (ld(shpnt)[ldn].tsb.dev_status & 0x1e);
696 IBM_DS(shpnt).total_errors++;
697 } else
698 cmd->result = 0;
699 /* write device status into cmd->result, and call done function */
700 if (lastSCSI == NO_SCSI) { /* unexpected interrupt :-( */
701 cmd->result |= DID_BAD_INTR << 16;
702 printk("IBM MCA SCSI: WARNING - Interrupt from non-pending SCSI-command!\n");
703 } else /* things went right :-) */
704 cmd->result |= DID_OK << 16;
705 if (cmd->scsi_done)
706 (cmd->scsi_done) (cmd);
707 spin_unlock_irqrestore(shpnt->host_lock, flags);
708 return IRQ_HANDLED;
709}
710
711static void issue_cmd(struct Scsi_Host *shpnt, unsigned long cmd_reg,
712 unsigned char attn_reg)
713{
714 unsigned long flags;
715 /* must wait for attention reg not busy */
716 while (1) {
717 spin_lock_irqsave(shpnt->host_lock, flags);
718 if (!(inb(IM_STAT_REG(shpnt)) & IM_BUSY))
719 break;
720 spin_unlock_irqrestore(shpnt->host_lock, flags);
721 }
722 /* write registers and enable system interrupts */
723 outl(cmd_reg, IM_CMD_REG(shpnt));
724 outb(attn_reg, IM_ATTN_REG(shpnt));
725 spin_unlock_irqrestore(shpnt->host_lock, flags);
726}
727
728static void internal_done(Scsi_Cmnd * cmd)
729{
730 cmd->SCp.Status++;
731 return;
732}
733
734/* SCSI-SCB-command for device_inquiry */
735static int device_inquiry(struct Scsi_Host *shpnt, int ldn)
736{
737 int retr;
738 struct im_scb *scb;
739 struct im_tsb *tsb;
740 unsigned char *buf;
741
742 scb = &(ld(shpnt)[ldn].scb);
743 tsb = &(ld(shpnt)[ldn].tsb);
744 buf = (unsigned char *) (&(ld(shpnt)[ldn].buf));
745 ld(shpnt)[ldn].tsb.dev_status = 0; /* prepare statusblock */
746 for (retr = 0; retr < 3; retr++) {
747 /* fill scb with inquiry command */
748 scb->command = IM_DEVICE_INQUIRY_CMD | IM_NO_DISCONNECT;
749 scb->enable = IM_REPORT_TSB_ONLY_ON_ERROR | IM_READ_CONTROL | IM_SUPRESS_EXCEPTION_SHORT | IM_RETRY_ENABLE | IM_BYPASS_BUFFER;
750 last_scsi_command(shpnt)[ldn] = IM_DEVICE_INQUIRY_CMD;
751 last_scsi_type(shpnt)[ldn] = IM_SCB;
752 scb->sys_buf_adr = isa_virt_to_bus(buf);
753 scb->sys_buf_length = 255; /* maximum bufferlength gives max info */
754 scb->tsb_adr = isa_virt_to_bus(tsb);
755 /* issue scb to passed ldn, and busy wait for interrupt */
756 got_interrupt(shpnt) = 0;
757 issue_cmd(shpnt, isa_virt_to_bus(scb), IM_SCB | ldn);
758 while (!got_interrupt(shpnt))
759 barrier();
760
761 /*if command successful, break */
762 if ((stat_result(shpnt) == IM_SCB_CMD_COMPLETED) || (stat_result(shpnt) == IM_SCB_CMD_COMPLETED_WITH_RETRIES))
763 return 1;
764 }
765 /*if all three retries failed, return "no device at this ldn" */
766 if (retr >= 3)
767 return 0;
768 else
769 return 1;
770}
771
772static int read_capacity(struct Scsi_Host *shpnt, int ldn)
773{
774 int retr;
775 struct im_scb *scb;
776 struct im_tsb *tsb;
777 unsigned char *buf;
778
779 scb = &(ld(shpnt)[ldn].scb);
780 tsb = &(ld(shpnt)[ldn].tsb);
781 buf = (unsigned char *) (&(ld(shpnt)[ldn].buf));
782 ld(shpnt)[ldn].tsb.dev_status = 0;
783 for (retr = 0; retr < 3; retr++) {
784 /*fill scb with read capacity command */
785 scb->command = IM_READ_CAPACITY_CMD;
786 scb->enable = IM_REPORT_TSB_ONLY_ON_ERROR | IM_READ_CONTROL | IM_RETRY_ENABLE | IM_BYPASS_BUFFER;
787 last_scsi_command(shpnt)[ldn] = IM_READ_CAPACITY_CMD;
788 last_scsi_type(shpnt)[ldn] = IM_SCB;
789 scb->sys_buf_adr = isa_virt_to_bus(buf);
790 scb->sys_buf_length = 8;
791 scb->tsb_adr = isa_virt_to_bus(tsb);
792 /*issue scb to passed ldn, and busy wait for interrupt */
793 got_interrupt(shpnt) = 0;
794 issue_cmd(shpnt, isa_virt_to_bus(scb), IM_SCB | ldn);
795 while (!got_interrupt(shpnt))
796 barrier();
797
798 /*if got capacity, get block length and return one device found */
799 if ((stat_result(shpnt) == IM_SCB_CMD_COMPLETED) || (stat_result(shpnt) == IM_SCB_CMD_COMPLETED_WITH_RETRIES))
800 return 1;
801 }
802 /*if all three retries failed, return "no device at this ldn" */
803 if (retr >= 3)
804 return 0;
805 else
806 return 1;
807}
808
809static int get_pos_info(struct Scsi_Host *shpnt)
810{
811 int retr;
812 struct im_scb *scb;
813 struct im_tsb *tsb;
814 unsigned char *buf;
815
816 scb = &(ld(shpnt)[MAX_LOG_DEV].scb);
817 tsb = &(ld(shpnt)[MAX_LOG_DEV].tsb);
818 buf = (unsigned char *) (&(ld(shpnt)[MAX_LOG_DEV].buf));
819 ld(shpnt)[MAX_LOG_DEV].tsb.dev_status = 0;
820 for (retr = 0; retr < 3; retr++) {
821 /*fill scb with get_pos_info command */
822 scb->command = IM_GET_POS_INFO_CMD;
823 scb->enable = IM_READ_CONTROL | IM_REPORT_TSB_ONLY_ON_ERROR | IM_RETRY_ENABLE | IM_BYPASS_BUFFER;
824 last_scsi_command(shpnt)[MAX_LOG_DEV] = IM_GET_POS_INFO_CMD;
825 last_scsi_type(shpnt)[MAX_LOG_DEV] = IM_SCB;
826 scb->sys_buf_adr = isa_virt_to_bus(buf);
827 if (special(shpnt) == IBM_SCSI2_FW)
828 scb->sys_buf_length = 256; /* get all info from F/W adapter */
829 else
830 scb->sys_buf_length = 18; /* get exactly 18 bytes for other SCSI */
831 scb->tsb_adr = isa_virt_to_bus(tsb);
832 /*issue scb to ldn=15, and busy wait for interrupt */
833 got_interrupt(shpnt) = 0;
834 issue_cmd(shpnt, isa_virt_to_bus(scb), IM_SCB | MAX_LOG_DEV);
835
836 /* FIXME: timeout */
837 while (!got_interrupt(shpnt))
838 barrier();
839
840 /*if got POS-stuff, get block length and return one device found */
841 if ((stat_result(shpnt) == IM_SCB_CMD_COMPLETED) || (stat_result(shpnt) == IM_SCB_CMD_COMPLETED_WITH_RETRIES))
842 return 1;
843 }
844 /* if all three retries failed, return "no device at this ldn" */
845 if (retr >= 3)
846 return 0;
847 else
848 return 1;
849}
850
851/* SCSI-immediate-command for assign. This functions maps/unmaps specific
852 ldn-numbers on SCSI (PUN,LUN). It is needed for presetting of the
853 subsystem and for dynamical remapping od ldns. */
854static int immediate_assign(struct Scsi_Host *shpnt, unsigned int pun,
855 unsigned int lun, unsigned int ldn,
856 unsigned int operation)
857{
858 int retr;
859 unsigned long imm_cmd;
860
861 for (retr = 0; retr < 3; retr++) {
862 /* select mutation level of the SCSI-adapter */
863 switch (special(shpnt)) {
864 case IBM_SCSI2_FW:
865 imm_cmd = (unsigned long) (IM_ASSIGN_IMM_CMD);
866 imm_cmd |= (unsigned long) ((lun & 7) << 24);
867 imm_cmd |= (unsigned long) ((operation & 1) << 23);
868 imm_cmd |= (unsigned long) ((pun & 7) << 20) | ((pun & 8) << 24);
869 imm_cmd |= (unsigned long) ((ldn & 15) << 16);
870 break;
871 default:
872 imm_cmd = inl(IM_CMD_REG(shpnt));
873 imm_cmd &= (unsigned long) (0xF8000000); /* keep reserved bits */
874 imm_cmd |= (unsigned long) (IM_ASSIGN_IMM_CMD);
875 imm_cmd |= (unsigned long) ((lun & 7) << 24);
876 imm_cmd |= (unsigned long) ((operation & 1) << 23);
877 imm_cmd |= (unsigned long) ((pun & 7) << 20);
878 imm_cmd |= (unsigned long) ((ldn & 15) << 16);
879 break;
880 }
881 last_scsi_command(shpnt)[MAX_LOG_DEV] = IM_ASSIGN_IMM_CMD;
882 last_scsi_type(shpnt)[MAX_LOG_DEV] = IM_IMM_CMD;
883 got_interrupt(shpnt) = 0;
884 issue_cmd(shpnt, (unsigned long) (imm_cmd), IM_IMM_CMD | MAX_LOG_DEV);
885 while (!got_interrupt(shpnt))
886 barrier();
887
888 /*if command successful, break */
889 if (stat_result(shpnt) == IM_IMMEDIATE_CMD_COMPLETED)
890 return 1;
891 }
892 if (retr >= 3)
893 return 0;
894 else
895 return 1;
896}
897
898static int immediate_feature(struct Scsi_Host *shpnt, unsigned int speed, unsigned int timeout)
899{
900 int retr;
901 unsigned long imm_cmd;
902
903 for (retr = 0; retr < 3; retr++) {
904 /* select mutation level of the SCSI-adapter */
905 imm_cmd = IM_FEATURE_CTR_IMM_CMD;
906 imm_cmd |= (unsigned long) ((speed & 0x7) << 29);
907 imm_cmd |= (unsigned long) ((timeout & 0x1fff) << 16);
908 last_scsi_command(shpnt)[MAX_LOG_DEV] = IM_FEATURE_CTR_IMM_CMD;
909 last_scsi_type(shpnt)[MAX_LOG_DEV] = IM_IMM_CMD;
910 got_interrupt(shpnt) = 0;
911 /* we need to run into command errors in order to probe for the
912 * right speed! */
913 global_command_error_excuse = 1;
914 issue_cmd(shpnt, (unsigned long) (imm_cmd), IM_IMM_CMD | MAX_LOG_DEV);
915
916 /* FIXME: timeout */
917 while (!got_interrupt(shpnt))
918 barrier();
919 if (global_command_error_excuse == CMD_FAIL) {
920 global_command_error_excuse = 0;
921 return 2;
922 } else
923 global_command_error_excuse = 0;
924 /*if command successful, break */
925 if (stat_result(shpnt) == IM_IMMEDIATE_CMD_COMPLETED)
926 return 1;
927 }
928 if (retr >= 3)
929 return 0;
930 else
931 return 1;
932}
933
934#ifdef CONFIG_IBMMCA_SCSI_DEV_RESET
935static int immediate_reset(struct Scsi_Host *shpnt, unsigned int ldn)
936{
937 int retries;
938 int ticks;
939 unsigned long imm_command;
940
941 for (retries = 0; retries < 3; retries++) {
942 imm_command = inl(IM_CMD_REG(shpnt));
943 imm_command &= (unsigned long) (0xFFFF0000); /* keep reserved bits */
944 imm_command |= (unsigned long) (IM_RESET_IMM_CMD);
945 last_scsi_command(shpnt)[ldn] = IM_RESET_IMM_CMD;
946 last_scsi_type(shpnt)[ldn] = IM_IMM_CMD;
947 got_interrupt(shpnt) = 0;
948 reset_status(shpnt) = IM_RESET_IN_PROGRESS;
949 issue_cmd(shpnt, (unsigned long) (imm_command), IM_IMM_CMD | ldn);
950 ticks = IM_RESET_DELAY * HZ;
951 while (reset_status(shpnt) == IM_RESET_IN_PROGRESS && --ticks) {
952 udelay((1 + 999 / HZ) * 1000);
953 barrier();
954 }
955 /* if reset did not complete, just complain */
956 if (!ticks) {
957 printk(KERN_ERR "IBM MCA SCSI: reset did not complete within %d seconds.\n", IM_RESET_DELAY);
958 reset_status(shpnt) = IM_RESET_FINISHED_OK;
959 /* did not work, finish */
960 return 1;
961 }
962 /*if command successful, break */
963 if (stat_result(shpnt) == IM_IMMEDIATE_CMD_COMPLETED)
964 return 1;
965 }
966 if (retries >= 3)
967 return 0;
968 else
969 return 1;
970}
971#endif
972
973/* type-interpreter for physical device numbers */
974static char *ti_p(int dev)
975{
976 switch (dev) {
977 case TYPE_IBM_SCSI_ADAPTER:
978 return ("A");
979 case TYPE_DISK:
980 return ("D");
981 case TYPE_TAPE:
982 return ("T");
983 case TYPE_PROCESSOR:
984 return ("P");
985 case TYPE_WORM:
986 return ("W");
987 case TYPE_ROM:
988 return ("R");
989 case TYPE_SCANNER:
990 return ("S");
991 case TYPE_MOD:
992 return ("M");
993 case TYPE_MEDIUM_CHANGER:
994 return ("C");
995 case TYPE_NO_LUN:
996 return ("+"); /* show NO_LUN */
997 }
998 return ("-"); /* TYPE_NO_DEVICE and others */
999}
1000
1001/* interpreter for logical device numbers (ldn) */
1002static char *ti_l(int val)
1003{
1004 const char hex[16] = "0123456789abcdef";
1005 static char answer[2];
1006
1007 answer[1] = (char) (0x0);
1008 if (val <= MAX_LOG_DEV)
1009 answer[0] = hex[val];
1010 else
1011 answer[0] = '-';
1012 return (char *) &answer;
1013}
1014
1015/* transfers bitpattern of the feature command to values in MHz */
1016static char *ibmrate(unsigned int speed, int i)
1017{
1018 switch (speed) {
1019 case 0:
1020 return i ? "5.00" : "10.00";
1021 case 1:
1022 return i ? "4.00" : "8.00";
1023 case 2:
1024 return i ? "3.33" : "6.66";
1025 case 3:
1026 return i ? "2.86" : "5.00";
1027 case 4:
1028 return i ? "2.50" : "4.00";
1029 case 5:
1030 return i ? "2.22" : "3.10";
1031 case 6:
1032 return i ? "2.00" : "2.50";
1033 case 7:
1034 return i ? "1.82" : "2.00";
1035 }
1036 return "---";
1037}
1038
1039static int probe_display(int what)
1040{
1041 static int rotator = 0;
1042 const char rotor[] = "|/-\\";
1043
1044 if (!(display_mode & LED_DISP))
1045 return 0;
1046 if (!what) {
1047 outl(0x20202020, MOD95_LED_PORT);
1048 outl(0x20202020, MOD95_LED_PORT + 4);
1049 } else {
1050 outb('S', MOD95_LED_PORT + 7);
1051 outb('C', MOD95_LED_PORT + 6);
1052 outb('S', MOD95_LED_PORT + 5);
1053 outb('I', MOD95_LED_PORT + 4);
1054 outb('i', MOD95_LED_PORT + 3);
1055 outb('n', MOD95_LED_PORT + 2);
1056 outb('i', MOD95_LED_PORT + 1);
1057 outb((char) (rotor[rotator]), MOD95_LED_PORT);
1058 rotator++;
1059 if (rotator > 3)
1060 rotator = 0;
1061 }
1062 return 0;
1063}
1064
1065static int probe_bus_mode(struct Scsi_Host *shpnt)
1066{
1067 struct im_pos_info *info;
1068 int num_bus = 0;
1069 int ldn;
1070
1071 info = (struct im_pos_info *) (&(ld(shpnt)[MAX_LOG_DEV].buf));
1072 if (get_pos_info(shpnt)) {
1073 if (info->connector_size & 0xf000)
1074 subsystem_connector_size(shpnt) = 16;
1075 else
1076 subsystem_connector_size(shpnt) = 32;
1077 num_bus |= (info->pos_4b & 8) >> 3;
1078 for (ldn = 0; ldn <= MAX_LOG_DEV; ldn++) {
1079 if ((special(shpnt) == IBM_SCSI_WCACHE) || (special(shpnt) == IBM_7568_WCACHE)) {
1080 if (!((info->cache_stat >> ldn) & 1))
1081 ld(shpnt)[ldn].cache_flag = 0;
1082 }
1083 if (!((info->retry_stat >> ldn) & 1))
1084 ld(shpnt)[ldn].retry_flag = 0;
1085 }
1086#ifdef IM_DEBUG_PROBE
1087 printk("IBM MCA SCSI: SCSI-Cache bits: ");
1088 for (ldn = 0; ldn <= MAX_LOG_DEV; ldn++) {
1089 printk("%d", ld(shpnt)[ldn].cache_flag);
1090 }
1091 printk("\nIBM MCA SCSI: SCSI-Retry bits: ");
1092 for (ldn = 0; ldn <= MAX_LOG_DEV; ldn++) {
1093 printk("%d", ld(shpnt)[ldn].retry_flag);
1094 }
1095 printk("\n");
1096#endif
1097 }
1098 return num_bus;
1099}
1100
1101/* probing scsi devices */
1102static void check_devices(struct Scsi_Host *shpnt, int adaptertype)
1103{
1104 int id, lun, ldn, ticks;
1105 int count_devices; /* local counter for connected device */
1106 int max_pun;
1107 int num_bus;
1108 int speedrun; /* local adapter_speed check variable */
1109
1110 /* assign default values to certain variables */
1111 ticks = 0;
1112 count_devices = 0;
1113 IBM_DS(shpnt).dyn_flag = 0; /* normally no need for dynamical ldn management */
1114 IBM_DS(shpnt).total_errors = 0; /* set errorcounter to 0 */
1115 next_ldn(shpnt) = 7; /* next ldn to be assigned is 7, because 0-6 is 'hardwired' */
1116
1117 /* initialize the very important driver-informational arrays/structs */
1118 memset(ld(shpnt), 0, sizeof(ld(shpnt)));
1119 for (ldn = 0; ldn <= MAX_LOG_DEV; ldn++) {
1120 last_scsi_command(shpnt)[ldn] = NO_SCSI; /* emptify last SCSI-command storage */
1121 last_scsi_type(shpnt)[ldn] = 0;
1122 ld(shpnt)[ldn].cache_flag = 1;
1123 ld(shpnt)[ldn].retry_flag = 1;
1124 }
1125 memset(get_ldn(shpnt), TYPE_NO_DEVICE, sizeof(get_ldn(shpnt))); /* this is essential ! */
1126 memset(get_scsi(shpnt), TYPE_NO_DEVICE, sizeof(get_scsi(shpnt))); /* this is essential ! */
1127 for (lun = 0; lun < 8; lun++) {
1128 /* mark the adapter at its pun on all luns */
1129 get_scsi(shpnt)[subsystem_pun(shpnt)][lun] = TYPE_IBM_SCSI_ADAPTER;
1130 get_ldn(shpnt)[subsystem_pun(shpnt)][lun] = MAX_LOG_DEV; /* make sure, the subsystem
1131 ldn is active for all
1132 luns. */
1133 }
1134 probe_display(0); /* Supercool display usage during SCSI-probing. */
1135 /* This makes sense, when booting without any */
1136 /* monitor connected on model XX95. */
1137
1138 /* STEP 1: */
1139 adapter_speed(shpnt) = global_adapter_speed;
1140 speedrun = adapter_speed(shpnt);
1141 while (immediate_feature(shpnt, speedrun, adapter_timeout) == 2) {
1142 probe_display(1);
1143 if (speedrun == 7)
1144 panic("IBM MCA SCSI: Cannot set Synchronous-Transfer-Rate!\n");
1145 speedrun++;
1146 if (speedrun > 7)
1147 speedrun = 7;
1148 }
1149 adapter_speed(shpnt) = speedrun;
1150 /* Get detailed information about the current adapter, necessary for
1151 * device operations: */
1152 num_bus = probe_bus_mode(shpnt);
1153
1154 /* num_bus contains only valid data for the F/W adapter! */
1155 if (adaptertype == IBM_SCSI2_FW) { /* F/W SCSI adapter: */
1156 /* F/W adapter PUN-space extension evaluation: */
1157 if (num_bus) {
1158 printk(KERN_INFO "IBM MCA SCSI: Separate bus mode (wide-addressing enabled)\n");
1159 subsystem_maxid(shpnt) = 16;
1160 } else {
1161 printk(KERN_INFO "IBM MCA SCSI: Combined bus mode (wide-addressing disabled)\n");
1162 subsystem_maxid(shpnt) = 8;
1163 }
1164 printk(KERN_INFO "IBM MCA SCSI: Sync.-Rate (F/W: 20, Int.: 10, Ext.: %s) MBytes/s\n", ibmrate(speedrun, adaptertype));
1165 } else /* all other IBM SCSI adapters: */
1166 printk(KERN_INFO "IBM MCA SCSI: Synchronous-SCSI-Transfer-Rate: %s MBytes/s\n", ibmrate(speedrun, adaptertype));
1167
1168 /* assign correct PUN device space */
1169 max_pun = subsystem_maxid(shpnt);
1170
1171#ifdef IM_DEBUG_PROBE
1172 printk("IBM MCA SCSI: Current SCSI-host index: %d\n", shpnt);
1173 printk("IBM MCA SCSI: Removing default logical SCSI-device mapping.");
1174#else
1175 printk(KERN_INFO "IBM MCA SCSI: Dev. Order: %s, Mapping (takes <2min): ", (ibm_ansi_order) ? "ANSI" : "New");
1176#endif
1177 for (ldn = 0; ldn < MAX_LOG_DEV; ldn++) {
1178 probe_display(1);
1179#ifdef IM_DEBUG_PROBE
1180 printk(".");
1181#endif
1182 immediate_assign(shpnt, 0, 0, ldn, REMOVE_LDN); /* remove ldn (wherever) */
1183 }
1184 lun = 0; /* default lun is 0 */
1185#ifndef IM_DEBUG_PROBE
1186 printk("cleared,");
1187#endif
1188 /* STEP 2: */
1189#ifdef IM_DEBUG_PROBE
1190 printk("\nIBM MCA SCSI: Scanning SCSI-devices.");
1191#endif
1192 for (id = 0; id < max_pun; id++)
1193#ifdef CONFIG_SCSI_MULTI_LUN
1194 for (lun = 0; lun < 8; lun++)
1195#endif
1196 {
1197 probe_display(1);
1198#ifdef IM_DEBUG_PROBE
1199 printk(".");
1200#endif
1201 if (id != subsystem_pun(shpnt)) {
1202 /* if pun is not the adapter: */
1203 /* set ldn=0 to pun,lun */
1204 immediate_assign(shpnt, id, lun, PROBE_LDN, SET_LDN);
1205 if (device_inquiry(shpnt, PROBE_LDN)) { /* probe device */
1206 get_scsi(shpnt)[id][lun] = (unsigned char) (ld(shpnt)[PROBE_LDN].buf[0]);
1207 /* entry, even for NO_LUN */
1208 if (ld(shpnt)[PROBE_LDN].buf[0] != TYPE_NO_LUN)
1209 count_devices++; /* a existing device is found */
1210 }
1211 /* remove ldn */
1212 immediate_assign(shpnt, id, lun, PROBE_LDN, REMOVE_LDN);
1213 }
1214 }
1215#ifndef IM_DEBUG_PROBE
1216 printk("scanned,");
1217#endif
1218 /* STEP 3: */
1219#ifdef IM_DEBUG_PROBE
1220 printk("\nIBM MCA SCSI: Mapping SCSI-devices.");
1221#endif
1222 ldn = 0;
1223 lun = 0;
1224#ifdef CONFIG_SCSI_MULTI_LUN
1225 for (lun = 0; lun < 8 && ldn < MAX_LOG_DEV; lun++)
1226#endif
1227 for (id = 0; id < max_pun && ldn < MAX_LOG_DEV; id++) {
1228 probe_display(1);
1229#ifdef IM_DEBUG_PROBE
1230 printk(".");
1231#endif
1232 if (id != subsystem_pun(shpnt)) {
1233 if (get_scsi(shpnt)[id][lun] != TYPE_NO_LUN && get_scsi(shpnt)[id][lun] != TYPE_NO_DEVICE) {
1234 /* Only map if accepted type. Always enter for
1235 lun == 0 to get no gaps into ldn-mapping for ldn<7. */
1236 immediate_assign(shpnt, id, lun, ldn, SET_LDN);
1237 get_ldn(shpnt)[id][lun] = ldn; /* map ldn */
1238 if (device_exists(shpnt, ldn, &ld(shpnt)[ldn].block_length, &ld(shpnt)[ldn].device_type)) {
1239#ifdef CONFIG_IBMMCA_SCSI_DEV_RESET
1240 printk("resetting device at ldn=%x ... ", ldn);
1241 immediate_reset(shpnt, ldn);
1242#endif
1243 ldn++;
1244 } else {
1245 /* device vanished, probably because we don't know how to
1246 * handle it or because it has problems */
1247 if (lun > 0) {
1248 /* remove mapping */
1249 get_ldn(shpnt)[id][lun] = TYPE_NO_DEVICE;
1250 immediate_assign(shpnt, 0, 0, ldn, REMOVE_LDN);
1251 } else
1252 ldn++;
1253 }
1254 } else if (lun == 0) {
1255 /* map lun == 0, even if no device exists */
1256 immediate_assign(shpnt, id, lun, ldn, SET_LDN);
1257 get_ldn(shpnt)[id][lun] = ldn; /* map ldn */
1258 ldn++;
1259 }
1260 }
1261 }
1262 /* STEP 4: */
1263
1264 /* map remaining ldns to non-existing devices */
1265 for (lun = 1; lun < 8 && ldn < MAX_LOG_DEV; lun++)
1266 for (id = 0; id < max_pun && ldn < MAX_LOG_DEV; id++) {
1267 if (get_scsi(shpnt)[id][lun] == TYPE_NO_LUN || get_scsi(shpnt)[id][lun] == TYPE_NO_DEVICE) {
1268 probe_display(1);
1269 /* Map remaining ldns only to NON-existing pun,lun
1270 combinations to make sure an inquiry will fail.
1271 For MULTI_LUN, it is needed to avoid adapter autonome
1272 SCSI-remapping. */
1273 immediate_assign(shpnt, id, lun, ldn, SET_LDN);
1274 get_ldn(shpnt)[id][lun] = ldn;
1275 ldn++;
1276 }
1277 }
1278#ifndef IM_DEBUG_PROBE
1279 printk("mapped.");
1280#endif
1281 printk("\n");
1282#ifdef IM_DEBUG_PROBE
1283 if (ibm_ansi_order)
1284 printk("IBM MCA SCSI: Device order: IBM/ANSI (pun=7 is first).\n");
1285 else
1286 printk("IBM MCA SCSI: Device order: New Industry Standard (pun=0 is first).\n");
1287#endif
1288
1289#ifdef IM_DEBUG_PROBE
1290 /* Show the physical and logical mapping during boot. */
1291 printk("IBM MCA SCSI: Determined SCSI-device-mapping:\n");
1292 printk(" Physical SCSI-Device Map Logical SCSI-Device Map\n");
1293 printk("ID\\LUN 0 1 2 3 4 5 6 7 ID\\LUN 0 1 2 3 4 5 6 7\n");
1294 for (id = 0; id < max_pun; id++) {
1295 printk("%2d ", id);
1296 for (lun = 0; lun < 8; lun++)
1297 printk("%2s ", ti_p(get_scsi(shpnt)[id][lun]));
1298 printk(" %2d ", id);
1299 for (lun = 0; lun < 8; lun++)
1300 printk("%2s ", ti_l(get_ldn(shpnt)[id][lun]));
1301 printk("\n");
1302 }
1303#endif
1304
1305 /* assign total number of found SCSI-devices to the statistics struct */
1306 IBM_DS(shpnt).total_scsi_devices = count_devices;
1307
1308 /* decide for output in /proc-filesystem, if the configuration of
1309 SCSI-devices makes dynamical reassignment of devices necessary */
1310 if (count_devices >= MAX_LOG_DEV)
1311 IBM_DS(shpnt).dyn_flag = 1; /* dynamical assignment is necessary */
1312 else
1313 IBM_DS(shpnt).dyn_flag = 0; /* dynamical assignment is not necessary */
1314
1315 /* If no SCSI-devices are assigned, return 1 in order to cause message. */
1316 if (ldn == 0)
1317 printk("IBM MCA SCSI: Warning: No SCSI-devices found/assigned!\n");
1318
1319 /* reset the counters for statistics on the current adapter */
1320 IBM_DS(shpnt).scbs = 0;
1321 IBM_DS(shpnt).long_scbs = 0;
1322 IBM_DS(shpnt).total_accesses = 0;
1323 IBM_DS(shpnt).total_interrupts = 0;
1324 IBM_DS(shpnt).dynamical_assignments = 0;
1325 memset(IBM_DS(shpnt).ldn_access, 0x0, sizeof(IBM_DS(shpnt).ldn_access));
1326 memset(IBM_DS(shpnt).ldn_read_access, 0x0, sizeof(IBM_DS(shpnt).ldn_read_access));
1327 memset(IBM_DS(shpnt).ldn_write_access, 0x0, sizeof(IBM_DS(shpnt).ldn_write_access));
1328 memset(IBM_DS(shpnt).ldn_inquiry_access, 0x0, sizeof(IBM_DS(shpnt).ldn_inquiry_access));
1329 memset(IBM_DS(shpnt).ldn_modeselect_access, 0x0, sizeof(IBM_DS(shpnt).ldn_modeselect_access));
1330 memset(IBM_DS(shpnt).ldn_assignments, 0x0, sizeof(IBM_DS(shpnt).ldn_assignments));
1331 probe_display(0);
1332 return;
1333}
1334
1335static int device_exists(struct Scsi_Host *shpnt, int ldn, int *block_length, int *device_type)
1336{
1337 unsigned char *buf;
1338 /* if no valid device found, return immediately with 0 */
1339 if (!(device_inquiry(shpnt, ldn)))
1340 return 0;
1341 buf = (unsigned char *) (&(ld(shpnt)[ldn].buf));
1342 if (*buf == TYPE_ROM) {
1343 *device_type = TYPE_ROM;
1344 *block_length = 2048; /* (standard blocksize for yellow-/red-book) */
1345 return 1;
1346 }
1347 if (*buf == TYPE_WORM) {
1348 *device_type = TYPE_WORM;
1349 *block_length = 2048;
1350 return 1;
1351 }
1352 if (*buf == TYPE_DISK) {
1353 *device_type = TYPE_DISK;
1354 if (read_capacity(shpnt, ldn)) {
1355 *block_length = *(buf + 7) + (*(buf + 6) << 8) + (*(buf + 5) << 16) + (*(buf + 4) << 24);
1356 return 1;
1357 } else
1358 return 0;
1359 }
1360 if (*buf == TYPE_MOD) {
1361 *device_type = TYPE_MOD;
1362 if (read_capacity(shpnt, ldn)) {
1363 *block_length = *(buf + 7) + (*(buf + 6) << 8) + (*(buf + 5) << 16) + (*(buf + 4) << 24);
1364 return 1;
1365 } else
1366 return 0;
1367 }
1368 if (*buf == TYPE_TAPE) {
1369 *device_type = TYPE_TAPE;
1370 *block_length = 0; /* not in use (setting by mt and mtst in op.) */
1371 return 1;
1372 }
1373 if (*buf == TYPE_PROCESSOR) {
1374 *device_type = TYPE_PROCESSOR;
1375 *block_length = 0; /* they set their stuff on drivers */
1376 return 1;
1377 }
1378 if (*buf == TYPE_SCANNER) {
1379 *device_type = TYPE_SCANNER;
1380 *block_length = 0; /* they set their stuff on drivers */
1381 return 1;
1382 }
1383 if (*buf == TYPE_MEDIUM_CHANGER) {
1384 *device_type = TYPE_MEDIUM_CHANGER;
1385 *block_length = 0; /* One never knows, what to expect on a medium
1386 changer device. */
1387 return 1;
1388 }
1389 return 0;
1390}
1391
1392static void internal_ibmmca_scsi_setup(char *str, int *ints)
1393{
1394 int i, j, io_base, id_base;
1395 char *token;
1396
1397 io_base = 0;
1398 id_base = 0;
1399 if (str) {
1400 j = 0;
1401 while ((token = strsep(&str, ",")) != NULL) {
1402 if (!strcmp(token, "activity"))
1403 display_mode |= LED_ACTIVITY;
1404 if (!strcmp(token, "display"))
1405 display_mode |= LED_DISP;
1406 if (!strcmp(token, "adisplay"))
1407 display_mode |= LED_ADISP;
1408 if (!strcmp(token, "normal"))
1409 ibm_ansi_order = 0;
1410 if (!strcmp(token, "ansi"))
1411 ibm_ansi_order = 1;
1412 if (!strcmp(token, "fast"))
1413 global_adapter_speed = 0;
1414 if (!strcmp(token, "medium"))
1415 global_adapter_speed = 4;
1416 if (!strcmp(token, "slow"))
1417 global_adapter_speed = 7;
1418 if ((*token == '-') || (isdigit(*token))) {
1419 if (!(j % 2) && (io_base < IM_MAX_HOSTS))
1420 io_port[io_base++] = simple_strtoul(token, NULL, 0);
1421 if ((j % 2) && (id_base < IM_MAX_HOSTS))
1422 scsi_id[id_base++] = simple_strtoul(token, NULL, 0);
1423 j++;
1424 }
1425 }
1426 } else if (ints) {
1427 for (i = 0; i < IM_MAX_HOSTS && 2 * i + 2 < ints[0]; i++) {
1428 io_port[i] = ints[2 * i + 2];
1429 scsi_id[i] = ints[2 * i + 2];
1430 }
1431 }
1432 return;
1433}
1434
1435#if 0
1436 FIXME NEED TO MOVE TO SYSFS
1437
1438static int ibmmca_getinfo(char *buf, int slot, void *dev_id)
1439{
1440 struct Scsi_Host *shpnt;
1441 int len, speciale, connectore, k;
1442 unsigned int pos[8];
1443 unsigned long flags;
1444 struct Scsi_Host *dev = dev_id;
1445
1446 spin_lock_irqsave(dev->host_lock, flags);
1447
1448 shpnt = dev; /* assign host-structure to local pointer */
1449 len = 0; /* set filled text-buffer index to 0 */
1450 /* get the _special contents of the hostdata structure */
1451 speciale = ((struct ibmmca_hostdata *) shpnt->hostdata)->_special;
1452 connectore = ((struct ibmmca_hostdata *) shpnt->hostdata)->_connector_size;
1453 for (k = 2; k < 4; k++)
1454 pos[k] = ((struct ibmmca_hostdata *) shpnt->hostdata)->_pos[k];
1455 if (speciale == FORCED_DETECTION) { /* forced detection */
1456 len += sprintf(buf + len,
1457 "Adapter category: forced detected\n" "***************************************\n" "*** Forced detected SCSI Adapter ***\n" "*** No chip-information available ***\n" "***************************************\n");
1458 } else if (speciale == INTEGRATED_SCSI) {
1459 /* if the integrated subsystem has been found automatically: */
1460 len += sprintf(buf + len,
1461 "Adapter category: integrated\n" "Chip revision level: %d\n" "Chip status: %s\n" "8 kByte NVRAM status: %s\n", ((pos[2] & 0xf0) >> 4), (pos[2] & 1) ? "enabled" : "disabled", (pos[2] & 2) ? "locked" : "accessible");
1462 } else if ((speciale >= 0) && (speciale < ARRAY_SIZE(subsys_list))) {
1463 /* if the subsystem is a slot adapter */
1464 len += sprintf(buf + len, "Adapter category: slot-card\n" "ROM Segment Address: ");
1465 if ((pos[2] & 0xf0) == 0xf0)
1466 len += sprintf(buf + len, "off\n");
1467 else
1468 len += sprintf(buf + len, "0x%x\n", ((pos[2] & 0xf0) << 13) + 0xc0000);
1469 len += sprintf(buf + len, "Chip status: %s\n", (pos[2] & 1) ? "enabled" : "disabled");
1470 len += sprintf(buf + len, "Adapter I/O Offset: 0x%x\n", ((pos[2] & 0x0e) << 2));
1471 } else {
1472 len += sprintf(buf + len, "Adapter category: unknown\n");
1473 }
1474 /* common subsystem information to write to the slotn file */
1475 len += sprintf(buf + len, "Subsystem PUN: %d\n", shpnt->this_id);
1476 len += sprintf(buf + len, "I/O base address range: 0x%x-0x%x\n", (unsigned int) (shpnt->io_port), (unsigned int) (shpnt->io_port + 7));
1477 len += sprintf(buf + len, "MCA-slot size: %d bits", connectore);
1478 /* Now make sure, the bufferlength is devidable by 4 to avoid
1479 * paging problems of the buffer. */
1480 while (len % sizeof(int) != (sizeof(int) - 1))
1481 len += sprintf(buf + len, " ");
1482 len += sprintf(buf + len, "\n");
1483
1484 spin_unlock_irqrestore(shpnt->host_lock, flags);
1485
1486 return len;
1487}
1488#endif
1489
1490static struct scsi_host_template ibmmca_driver_template = {
1491 .proc_name = "ibmmca",
1492 .proc_info = ibmmca_proc_info,
1493 .name = "IBM SCSI-Subsystem",
1494 .queuecommand = ibmmca_queuecommand,
1495 .eh_abort_handler = ibmmca_abort,
1496 .eh_host_reset_handler = ibmmca_host_reset,
1497 .bios_param = ibmmca_biosparam,
1498 .can_queue = 16,
1499 .this_id = 7,
1500 .sg_tablesize = 16,
1501 .cmd_per_lun = 1,
1502 .use_clustering = ENABLE_CLUSTERING,
1503};
1504
1505static int ibmmca_probe(struct device *dev)
1506{
1507 struct Scsi_Host *shpnt;
1508 int port, id, i, j, k, irq, enabled, ret = -EINVAL;
1509 struct mca_device *mca_dev = to_mca_device(dev);
1510 const char *description = ibmmca_description[mca_dev->index];
1511
1512 /* First of all, print the version number of the driver. This is
1513 * important to allow better user bugreports in case of already
1514 * having problems with the MCA_bus probing. */
1515 printk(KERN_INFO "IBM MCA SCSI: Version %s\n", IBMMCA_SCSI_DRIVER_VERSION);
1516 /* The POS2-register of all PS/2 model SCSI-subsystems has the following
1517 * interpretation of bits:
1518 * Bit 7 - 4 : Chip Revision ID (Release)
1519 * Bit 3 - 2 : Reserved
1520 * Bit 1 : 8k NVRAM Disabled
1521 * Bit 0 : Chip Enable (EN-Signal)
1522 * The POS3-register is interpreted as follows:
1523 * Bit 7 - 5 : SCSI ID
1524 * Bit 4 : Reserved = 0
1525 * Bit 3 - 0 : Reserved = 0
1526 * (taken from "IBM, PS/2 Hardware Interface Technical Reference, Common
1527 * Interfaces (1991)").
1528 * In short words, this means, that IBM PS/2 machines only support
1529 * 1 single subsystem by default. The slot-adapters must have another
1530 * configuration on pos2. Here, one has to assume the following
1531 * things for POS2-register:
1532 * Bit 7 - 4 : Chip Revision ID (Release)
1533 * Bit 3 - 1 : port offset factor
1534 * Bit 0 : Chip Enable (EN-Signal)
1535 * As I found a patch here, setting the IO-registers to 0x3540 forced,
1536 * as there was a 0x05 in POS2 on a model 56, I assume, that the
1537 * port 0x3540 must be fix for integrated SCSI-controllers.
1538 * Ok, this discovery leads to the following implementation: (M.Lang) */
1539
1540 /* first look for the IBM SCSI integrated subsystem on the motherboard */
1541 for (j = 0; j < 8; j++) /* read the pos-information */
1542 pos[j] = mca_device_read_pos(mca_dev, j);
1543 id = (pos[3] & 0xe0) >> 5; /* this is correct and represents the PUN */
1544 enabled = (pos[2] &0x01);
1545 if (!enabled) {
1546 printk(KERN_WARNING "IBM MCA SCSI: WARNING - Your SCSI-subsystem is disabled!\n");
1547 printk(KERN_WARNING " SCSI-operations may not work.\n");
1548 }
1549
1550 /* pos2 = pos3 = 0xff if there is no integrated SCSI-subsystem present, but
1551 * if we ignore the settings of all surrounding pos registers, it is not
1552 * completely sufficient to only check pos2 and pos3. */
1553 /* Therefore, now the following if statement is used to
1554 * make sure, we see a real integrated onboard SCSI-interface and no
1555 * internal system information, which gets mapped to some pos registers
1556 * on models 95xx. */
1557 if (mca_dev->slot == MCA_INTEGSCSI &&
1558 ((!pos[0] && !pos[1] && pos[2] > 0 &&
1559 pos[3] > 0 && !pos[4] && !pos[5] &&
1560 !pos[6] && !pos[7]) ||
1561 (pos[0] == 0xff && pos[1] == 0xff &&
1562 pos[2] < 0xff && pos[3] < 0xff &&
1563 pos[4] == 0xff && pos[5] == 0xff &&
1564 pos[6] == 0xff && pos[7] == 0xff))) {
1565 irq = IM_IRQ;
1566 port = IM_IO_PORT;
1567 } else {
1568 irq = IM_IRQ;
1569 port = IM_IO_PORT + ((pos[2] &0x0e) << 2);
1570 if ((mca_dev->index == IBM_SCSI2_FW) && (pos[6] != 0)) {
1571 printk(KERN_ERR "IBM MCA SCSI: ERROR - Wrong POS(6)-register setting!\n");
1572 printk(KERN_ERR " Impossible to determine adapter PUN!\n");
1573 printk(KERN_ERR " Guessing adapter PUN = 7.\n");
1574 id = 7;
1575 } else {
1576 id = (pos[3] & 0xe0) >> 5; /* get subsystem PUN */
1577 if (mca_dev->index == IBM_SCSI2_FW) {
1578 id |= (pos[3] & 0x10) >> 1; /* get subsystem PUN high-bit
1579 * for F/W adapters */
1580 }
1581 }
1582 if ((mca_dev->index == IBM_SCSI2_FW) &&
1583 (pos[4] & 0x01) && (pos[6] == 0)) {
1584 /* IRQ11 is used by SCSI-2 F/W Adapter/A */
1585 printk(KERN_DEBUG "IBM MCA SCSI: SCSI-2 F/W adapter needs IRQ 11.\n");
1586 irq = IM_IRQ_FW;
1587 }
1588 }
1589
1590
1591
1592 /* give detailed information on the subsystem. This helps me
1593 * additionally during debugging and analyzing bug-reports. */
1594 printk(KERN_INFO "IBM MCA SCSI: %s found, io=0x%x, scsi id=%d,\n",
1595 description, port, id);
1596 if (mca_dev->slot == MCA_INTEGSCSI)
1597 printk(KERN_INFO " chip rev.=%d, 8K NVRAM=%s, subsystem=%s\n", ((pos[2] & 0xf0) >> 4), (pos[2] & 2) ? "locked" : "accessible", (pos[2] & 1) ? "enabled." : "disabled.");
1598 else {
1599 if ((pos[2] & 0xf0) == 0xf0)
1600 printk(KERN_DEBUG " ROM Addr.=off,");
1601 else
1602 printk(KERN_DEBUG " ROM Addr.=0x%x,", ((pos[2] & 0xf0) << 13) + 0xc0000);
1603
1604 printk(KERN_DEBUG " port-offset=0x%x, subsystem=%s\n", ((pos[2] & 0x0e) << 2), (pos[2] & 1) ? "enabled." : "disabled.");
1605 }
1606
1607 /* check I/O region */
1608 if (!request_region(port, IM_N_IO_PORT, description)) {
1609 printk(KERN_ERR "IBM MCA SCSI: Unable to get I/O region 0x%x-0x%x (%d ports).\n", port, port + IM_N_IO_PORT - 1, IM_N_IO_PORT);
1610 goto out_fail;
1611 }
1612
1613 /* register host */
1614 shpnt = scsi_host_alloc(&ibmmca_driver_template,
1615 sizeof(struct ibmmca_hostdata));
1616 if (!shpnt) {
1617 printk(KERN_ERR "IBM MCA SCSI: Unable to register host.\n");
1618 goto out_release;
1619 }
1620
1621 dev_set_drvdata(dev, shpnt);
1622 if(request_irq(irq, interrupt_handler, IRQF_SHARED, description, dev)) {
1623 printk(KERN_ERR "IBM MCA SCSI: failed to request interrupt %d\n", irq);
1624 goto out_free_host;
1625 }
1626
1627 /* request I/O region */
1628 special(shpnt) = mca_dev->index; /* important assignment or else crash! */
1629 subsystem_connector_size(shpnt) = 0; /* preset slot-size */
1630 shpnt->irq = irq; /* assign necessary stuff for the adapter */
1631 shpnt->io_port = port;
1632 shpnt->n_io_port = IM_N_IO_PORT;
1633 shpnt->this_id = id;
1634 shpnt->max_id = 8; /* 8 PUNs are default */
1635 /* now, the SCSI-subsystem is connected to Linux */
1636
1637#ifdef IM_DEBUG_PROBE
1638 ctrl = (unsigned int) (inb(IM_CTR_REG(found))); /* get control-register status */
1639 printk("IBM MCA SCSI: Control Register contents: %x, status: %x\n", ctrl, inb(IM_STAT_REG(found)));
1640 printk("IBM MCA SCSI: This adapters' POS-registers: ");
1641 for (i = 0; i < 8; i++)
1642 printk("%x ", pos[i]);
1643 printk("\n");
1644#endif
1645 reset_status(shpnt) = IM_RESET_NOT_IN_PROGRESS;
1646
1647 for (i = 0; i < 16; i++) /* reset the tables */
1648 for (j = 0; j < 8; j++)
1649 get_ldn(shpnt)[i][j] = MAX_LOG_DEV;
1650
1651 /* check which logical devices exist */
1652 /* after this line, local interrupting is possible: */
1653 local_checking_phase_flag(shpnt) = 1;
1654 check_devices(shpnt, mca_dev->index); /* call by value, using the global variable hosts */
1655 local_checking_phase_flag(shpnt) = 0;
1656
1657 /* an ibm mca subsystem has been detected */
1658
1659 for (k = 2; k < 7; k++)
1660 ((struct ibmmca_hostdata *) shpnt->hostdata)->_pos[k] = pos[k];
1661 ((struct ibmmca_hostdata *) shpnt->hostdata)->_special = INTEGRATED_SCSI;
1662 mca_device_set_name(mca_dev, description);
1663 /* FIXME: NEED TO REPLUMB TO SYSFS
1664 mca_set_adapter_procfn(MCA_INTEGSCSI, (MCA_ProcFn) ibmmca_getinfo, shpnt);
1665 */
1666 mca_device_set_claim(mca_dev, 1);
1667 if (scsi_add_host(shpnt, dev)) {
1668 dev_printk(KERN_ERR, dev, "IBM MCA SCSI: scsi_add_host failed\n");
1669 goto out_free_host;
1670 }
1671 scsi_scan_host(shpnt);
1672
1673 return 0;
1674 out_free_host:
1675 scsi_host_put(shpnt);
1676 out_release:
1677 release_region(port, IM_N_IO_PORT);
1678 out_fail:
1679 return ret;
1680}
1681
1682static int __devexit ibmmca_remove(struct device *dev)
1683{
1684 struct Scsi_Host *shpnt = dev_get_drvdata(dev);
1685 scsi_remove_host(shpnt);
1686 release_region(shpnt->io_port, shpnt->n_io_port);
1687 free_irq(shpnt->irq, dev);
1688 scsi_host_put(shpnt);
1689 return 0;
1690}
1691
1692/* The following routine is the SCSI command queue for the midlevel driver */
1693static int ibmmca_queuecommand_lck(Scsi_Cmnd * cmd, void (*done) (Scsi_Cmnd *))
1694{
1695 unsigned int ldn;
1696 unsigned int scsi_cmd;
1697 struct im_scb *scb;
1698 struct Scsi_Host *shpnt;
1699 int current_ldn;
1700 int id, lun;
1701 int target;
1702 int max_pun;
1703 int i;
1704 struct scatterlist *sg;
1705
1706 shpnt = cmd->device->host;
1707
1708 max_pun = subsystem_maxid(shpnt);
1709 if (ibm_ansi_order) {
1710 target = max_pun - 1 - cmd->device->id;
1711 if ((target <= subsystem_pun(shpnt)) && (cmd->device->id <= subsystem_pun(shpnt)))
1712 target--;
1713 else if ((target >= subsystem_pun(shpnt)) && (cmd->device->id >= subsystem_pun(shpnt)))
1714 target++;
1715 } else
1716 target = cmd->device->id;
1717
1718 /* if (target,lun) is NO LUN or not existing at all, return error */
1719 if ((get_scsi(shpnt)[target][cmd->device->lun] == TYPE_NO_LUN) || (get_scsi(shpnt)[target][cmd->device->lun] == TYPE_NO_DEVICE)) {
1720 cmd->result = DID_NO_CONNECT << 16;
1721 if (done)
1722 done(cmd);
1723 return 0;
1724 }
1725
1726 /*if (target,lun) unassigned, do further checks... */
1727 ldn = get_ldn(shpnt)[target][cmd->device->lun];
1728 if (ldn >= MAX_LOG_DEV) { /* on invalid ldn do special stuff */
1729 if (ldn > MAX_LOG_DEV) { /* dynamical remapping if ldn unassigned */
1730 current_ldn = next_ldn(shpnt); /* stop-value for one circle */
1731 while (ld(shpnt)[next_ldn(shpnt)].cmd) { /* search for a occupied, but not in */
1732 /* command-processing ldn. */
1733 next_ldn(shpnt)++;
1734 if (next_ldn(shpnt) >= MAX_LOG_DEV)
1735 next_ldn(shpnt) = 7;
1736 if (current_ldn == next_ldn(shpnt)) { /* One circle done ? */
1737 /* no non-processing ldn found */
1738 scmd_printk(KERN_WARNING, cmd,
1739 "IBM MCA SCSI: Cannot assign SCSI-device dynamically!\n"
1740 " On ldn 7-14 SCSI-commands everywhere in progress.\n"
1741 " Reporting DID_NO_CONNECT for device.\n");
1742 cmd->result = DID_NO_CONNECT << 16; /* return no connect */
1743 if (done)
1744 done(cmd);
1745 return 0;
1746 }
1747 }
1748
1749 /* unmap non-processing ldn */
1750 for (id = 0; id < max_pun; id++)
1751 for (lun = 0; lun < 8; lun++) {
1752 if (get_ldn(shpnt)[id][lun] == next_ldn(shpnt)) {
1753 get_ldn(shpnt)[id][lun] = TYPE_NO_DEVICE;
1754 get_scsi(shpnt)[id][lun] = TYPE_NO_DEVICE;
1755 /* unmap entry */
1756 }
1757 }
1758 /* set reduced interrupt_handler-mode for checking */
1759 local_checking_phase_flag(shpnt) = 1;
1760 /* map found ldn to pun,lun */
1761 get_ldn(shpnt)[target][cmd->device->lun] = next_ldn(shpnt);
1762 /* change ldn to the right value, that is now next_ldn */
1763 ldn = next_ldn(shpnt);
1764 /* unassign all ldns (pun,lun,ldn does not matter for remove) */
1765 immediate_assign(shpnt, 0, 0, 0, REMOVE_LDN);
1766 /* set only LDN for remapped device */
1767 immediate_assign(shpnt, target, cmd->device->lun, ldn, SET_LDN);
1768 /* get device information for ld[ldn] */
1769 if (device_exists(shpnt, ldn, &ld(shpnt)[ldn].block_length, &ld(shpnt)[ldn].device_type)) {
1770 ld(shpnt)[ldn].cmd = NULL; /* To prevent panic set 0, because
1771 devices that were not assigned,
1772 should have nothing in progress. */
1773 get_scsi(shpnt)[target][cmd->device->lun] = ld(shpnt)[ldn].device_type;
1774 /* increase assignment counters for statistics in /proc */
1775 IBM_DS(shpnt).dynamical_assignments++;
1776 IBM_DS(shpnt).ldn_assignments[ldn]++;
1777 } else
1778 /* panic here, because a device, found at boottime has
1779 vanished */
1780 panic("IBM MCA SCSI: ldn=0x%x, SCSI-device on (%d,%d) vanished!\n", ldn, target, cmd->device->lun);
1781 /* unassign again all ldns (pun,lun,ldn does not matter for remove) */
1782 immediate_assign(shpnt, 0, 0, 0, REMOVE_LDN);
1783 /* remap all ldns, as written in the pun/lun table */
1784 lun = 0;
1785#ifdef CONFIG_SCSI_MULTI_LUN
1786 for (lun = 0; lun < 8; lun++)
1787#endif
1788 for (id = 0; id < max_pun; id++) {
1789 if (get_ldn(shpnt)[id][lun] <= MAX_LOG_DEV)
1790 immediate_assign(shpnt, id, lun, get_ldn(shpnt)[id][lun], SET_LDN);
1791 }
1792 /* set back to normal interrupt_handling */
1793 local_checking_phase_flag(shpnt) = 0;
1794#ifdef IM_DEBUG_PROBE
1795 /* Information on syslog terminal */
1796 printk("IBM MCA SCSI: ldn=0x%x dynamically reassigned to (%d,%d).\n", ldn, target, cmd->device->lun);
1797#endif
1798 /* increase next_ldn for next dynamical assignment */
1799 next_ldn(shpnt)++;
1800 if (next_ldn(shpnt) >= MAX_LOG_DEV)
1801 next_ldn(shpnt) = 7;
1802 } else { /* wall against Linux accesses to the subsystem adapter */
1803 cmd->result = DID_BAD_TARGET << 16;
1804 if (done)
1805 done(cmd);
1806 return 0;
1807 }
1808 }
1809
1810 /*verify there is no command already in progress for this log dev */
1811 if (ld(shpnt)[ldn].cmd)
1812 panic("IBM MCA SCSI: cmd already in progress for this ldn.\n");
1813
1814 /*save done in cmd, and save cmd for the interrupt handler */
1815 cmd->scsi_done = done;
1816 ld(shpnt)[ldn].cmd = cmd;
1817
1818 /*fill scb information independent of the scsi command */
1819 scb = &(ld(shpnt)[ldn].scb);
1820 ld(shpnt)[ldn].tsb.dev_status = 0;
1821 scb->enable = IM_REPORT_TSB_ONLY_ON_ERROR | IM_RETRY_ENABLE;
1822 scb->tsb_adr = isa_virt_to_bus(&(ld(shpnt)[ldn].tsb));
1823 scsi_cmd = cmd->cmnd[0];
1824
1825 if (scsi_sg_count(cmd)) {
1826 BUG_ON(scsi_sg_count(cmd) > 16);
1827
1828 scsi_for_each_sg(cmd, sg, scsi_sg_count(cmd), i) {
1829 ld(shpnt)[ldn].sge[i].address = (void *) (isa_page_to_bus(sg_page(sg)) + sg->offset);
1830 ld(shpnt)[ldn].sge[i].byte_length = sg->length;
1831 }
1832 scb->enable |= IM_POINTER_TO_LIST;
1833 scb->sys_buf_adr = isa_virt_to_bus(&(ld(shpnt)[ldn].sge[0]));
1834 scb->sys_buf_length = scsi_sg_count(cmd) * sizeof(struct im_sge);
1835 } else {
1836 scb->sys_buf_adr = isa_virt_to_bus(scsi_sglist(cmd));
1837 /* recent Linux midlevel SCSI places 1024 byte for inquiry
1838 * command. Far too much for old PS/2 hardware. */
1839 switch (scsi_cmd) {
1840 /* avoid command errors by setting bufferlengths to
1841 * ANSI-standard. Beware of forcing it to 255,
1842 * this could SEGV the kernel!!! */
1843 case INQUIRY:
1844 case REQUEST_SENSE:
1845 case MODE_SENSE:
1846 case MODE_SELECT:
1847 if (scsi_bufflen(cmd) > 255)
1848 scb->sys_buf_length = 255;
1849 else
1850 scb->sys_buf_length = scsi_bufflen(cmd);
1851 break;
1852 case TEST_UNIT_READY:
1853 scb->sys_buf_length = 0;
1854 break;
1855 default:
1856 scb->sys_buf_length = scsi_bufflen(cmd);
1857 break;
1858 }
1859 }
1860 /*fill scb information dependent on scsi command */
1861
1862#ifdef IM_DEBUG_CMD
1863 printk("issue scsi cmd=%02x to ldn=%d\n", scsi_cmd, ldn);
1864#endif
1865
1866 /* for specific device-type debugging: */
1867#ifdef IM_DEBUG_CMD_SPEC_DEV
1868 if (ld(shpnt)[ldn].device_type == IM_DEBUG_CMD_DEVICE)
1869 printk("(SCSI-device-type=0x%x) issue scsi cmd=%02x to ldn=%d\n", ld(shpnt)[ldn].device_type, scsi_cmd, ldn);
1870#endif
1871
1872 /* for possible panics store current command */
1873 last_scsi_command(shpnt)[ldn] = scsi_cmd;
1874 last_scsi_type(shpnt)[ldn] = IM_SCB;
1875 /* update statistical info */
1876 IBM_DS(shpnt).total_accesses++;
1877 IBM_DS(shpnt).ldn_access[ldn]++;
1878
1879 switch (scsi_cmd) {
1880 case READ_6:
1881 case WRITE_6:
1882 case READ_10:
1883 case WRITE_10:
1884 case READ_12:
1885 case WRITE_12:
1886 /* Distinguish between disk and other devices. Only disks (that are the
1887 most frequently accessed devices) should be supported by the
1888 IBM-SCSI-Subsystem commands. */
1889 switch (ld(shpnt)[ldn].device_type) {
1890 case TYPE_DISK: /* for harddisks enter here ... */
1891 case TYPE_MOD: /* ... try it also for MO-drives (send flames as */
1892 /* you like, if this won't work.) */
1893 if (scsi_cmd == READ_6 || scsi_cmd == READ_10 || scsi_cmd == READ_12) {
1894 /* read command preparations */
1895 scb->enable |= IM_READ_CONTROL;
1896 IBM_DS(shpnt).ldn_read_access[ldn]++; /* increase READ-access on ldn stat. */
1897 scb->command = IM_READ_DATA_CMD | IM_NO_DISCONNECT;
1898 } else { /* write command preparations */
1899 IBM_DS(shpnt).ldn_write_access[ldn]++; /* increase write-count on ldn stat. */
1900 scb->command = IM_WRITE_DATA_CMD | IM_NO_DISCONNECT;
1901 }
1902 if (scsi_cmd == READ_6 || scsi_cmd == WRITE_6) {
1903 scb->u1.log_blk_adr = (((unsigned) cmd->cmnd[3]) << 0) | (((unsigned) cmd->cmnd[2]) << 8) | ((((unsigned) cmd->cmnd[1]) & 0x1f) << 16);
1904 scb->u2.blk.count = (unsigned) cmd->cmnd[4];
1905 } else {
1906 scb->u1.log_blk_adr = (((unsigned) cmd->cmnd[5]) << 0) | (((unsigned) cmd->cmnd[4]) << 8) | (((unsigned) cmd->cmnd[3]) << 16) | (((unsigned) cmd->cmnd[2]) << 24);
1907 scb->u2.blk.count = (((unsigned) cmd->cmnd[8]) << 0) | (((unsigned) cmd->cmnd[7]) << 8);
1908 }
1909 last_scsi_logical_block(shpnt)[ldn] = scb->u1.log_blk_adr;
1910 last_scsi_blockcount(shpnt)[ldn] = scb->u2.blk.count;
1911 scb->u2.blk.length = ld(shpnt)[ldn].block_length;
1912 break;
1913 /* for other devices, enter here. Other types are not known by
1914 Linux! TYPE_NO_LUN is forbidden as valid device. */
1915 case TYPE_ROM:
1916 case TYPE_TAPE:
1917 case TYPE_PROCESSOR:
1918 case TYPE_WORM:
1919 case TYPE_SCANNER:
1920 case TYPE_MEDIUM_CHANGER:
1921 /* If there is a sequential-device, IBM recommends to use
1922 IM_OTHER_SCSI_CMD_CMD instead of subsystem READ/WRITE.
1923 This includes CD-ROM devices, too, due to the partial sequential
1924 read capabilities. */
1925 scb->command = IM_OTHER_SCSI_CMD_CMD;
1926 if (scsi_cmd == READ_6 || scsi_cmd == READ_10 || scsi_cmd == READ_12)
1927 /* enable READ */
1928 scb->enable |= IM_READ_CONTROL;
1929 scb->enable |= IM_BYPASS_BUFFER;
1930 scb->u1.scsi_cmd_length = cmd->cmd_len;
1931 memcpy(scb->u2.scsi_command, cmd->cmnd, cmd->cmd_len);
1932 last_scsi_type(shpnt)[ldn] = IM_LONG_SCB;
1933 /* Read/write on this non-disk devices is also displayworthy,
1934 so flash-up the LED/display. */
1935 break;
1936 }
1937 break;
1938 case INQUIRY:
1939 IBM_DS(shpnt).ldn_inquiry_access[ldn]++;
1940 scb->command = IM_DEVICE_INQUIRY_CMD;
1941 scb->enable |= IM_READ_CONTROL | IM_SUPRESS_EXCEPTION_SHORT | IM_BYPASS_BUFFER;
1942 scb->u1.log_blk_adr = 0;
1943 break;
1944 case TEST_UNIT_READY:
1945 scb->command = IM_OTHER_SCSI_CMD_CMD;
1946 scb->enable |= IM_READ_CONTROL | IM_SUPRESS_EXCEPTION_SHORT | IM_BYPASS_BUFFER;
1947 scb->u1.log_blk_adr = 0;
1948 scb->u1.scsi_cmd_length = 6;
1949 memcpy(scb->u2.scsi_command, cmd->cmnd, 6);
1950 last_scsi_type(shpnt)[ldn] = IM_LONG_SCB;
1951 break;
1952 case READ_CAPACITY:
1953 /* the length of system memory buffer must be exactly 8 bytes */
1954 scb->command = IM_READ_CAPACITY_CMD;
1955 scb->enable |= IM_READ_CONTROL | IM_BYPASS_BUFFER;
1956 if (scb->sys_buf_length > 8)
1957 scb->sys_buf_length = 8;
1958 break;
1959 /* Commands that need read-only-mode (system <- device): */
1960 case REQUEST_SENSE:
1961 scb->command = IM_REQUEST_SENSE_CMD;
1962 scb->enable |= IM_READ_CONTROL | IM_SUPRESS_EXCEPTION_SHORT | IM_BYPASS_BUFFER;
1963 break;
1964 /* Commands that need write-only-mode (system -> device): */
1965 case MODE_SELECT:
1966 case MODE_SELECT_10:
1967 IBM_DS(shpnt).ldn_modeselect_access[ldn]++;
1968 scb->command = IM_OTHER_SCSI_CMD_CMD;
1969 scb->enable |= IM_SUPRESS_EXCEPTION_SHORT | IM_BYPASS_BUFFER; /*Select needs WRITE-enabled */
1970 scb->u1.scsi_cmd_length = cmd->cmd_len;
1971 memcpy(scb->u2.scsi_command, cmd->cmnd, cmd->cmd_len);
1972 last_scsi_type(shpnt)[ldn] = IM_LONG_SCB;
1973 break;
1974 /* For other commands, read-only is useful. Most other commands are
1975 running without an input-data-block. */
1976 default:
1977 scb->command = IM_OTHER_SCSI_CMD_CMD;
1978 scb->enable |= IM_READ_CONTROL | IM_SUPRESS_EXCEPTION_SHORT | IM_BYPASS_BUFFER;
1979 scb->u1.scsi_cmd_length = cmd->cmd_len;
1980 memcpy(scb->u2.scsi_command, cmd->cmnd, cmd->cmd_len);
1981 last_scsi_type(shpnt)[ldn] = IM_LONG_SCB;
1982 break;
1983 }
1984 /*issue scb command, and return */
1985 if (++disk_rw_in_progress == 1)
1986 PS2_DISK_LED_ON(shpnt->host_no, target);
1987
1988 if (last_scsi_type(shpnt)[ldn] == IM_LONG_SCB) {
1989 issue_cmd(shpnt, isa_virt_to_bus(scb), IM_LONG_SCB | ldn);
1990 IBM_DS(shpnt).long_scbs++;
1991 } else {
1992 issue_cmd(shpnt, isa_virt_to_bus(scb), IM_SCB | ldn);
1993 IBM_DS(shpnt).scbs++;
1994 }
1995 return 0;
1996}
1997
1998static DEF_SCSI_QCMD(ibmmca_queuecommand)
1999
2000static int __ibmmca_abort(Scsi_Cmnd * cmd)
2001{
2002 /* Abort does not work, as the adapter never generates an interrupt on
2003 * whatever situation is simulated, even when really pending commands
2004 * are running on the adapters' hardware ! */
2005
2006 struct Scsi_Host *shpnt;
2007 unsigned int ldn;
2008 void (*saved_done) (Scsi_Cmnd *);
2009 int target;
2010 int max_pun;
2011 unsigned long imm_command;
2012
2013#ifdef IM_DEBUG_PROBE
2014 printk("IBM MCA SCSI: Abort subroutine called...\n");
2015#endif
2016
2017 shpnt = cmd->device->host;
2018
2019 max_pun = subsystem_maxid(shpnt);
2020 if (ibm_ansi_order) {
2021 target = max_pun - 1 - cmd->device->id;
2022 if ((target <= subsystem_pun(shpnt)) && (cmd->device->id <= subsystem_pun(shpnt)))
2023 target--;
2024 else if ((target >= subsystem_pun(shpnt)) && (cmd->device->id >= subsystem_pun(shpnt)))
2025 target++;
2026 } else
2027 target = cmd->device->id;
2028
2029 /* get logical device number, and disable system interrupts */
2030 printk(KERN_WARNING "IBM MCA SCSI: Sending abort to device pun=%d, lun=%d.\n", target, cmd->device->lun);
2031 ldn = get_ldn(shpnt)[target][cmd->device->lun];
2032
2033 /*if cmd for this ldn has already finished, no need to abort */
2034 if (!ld(shpnt)[ldn].cmd) {
2035 return SUCCESS;
2036 }
2037
2038 /* Clear ld.cmd, save done function, install internal done,
2039 * send abort immediate command (this enables sys. interrupts),
2040 * and wait until the interrupt arrives.
2041 */
2042 saved_done = cmd->scsi_done;
2043 cmd->scsi_done = internal_done;
2044 cmd->SCp.Status = 0;
2045 last_scsi_command(shpnt)[ldn] = IM_ABORT_IMM_CMD;
2046 last_scsi_type(shpnt)[ldn] = IM_IMM_CMD;
2047 imm_command = inl(IM_CMD_REG(shpnt));
2048 imm_command &= (unsigned long) (0xffff0000); /* mask reserved stuff */
2049 imm_command |= (unsigned long) (IM_ABORT_IMM_CMD);
2050 /* must wait for attention reg not busy */
2051 /* FIXME - timeout, politeness */
2052 while (1) {
2053 if (!(inb(IM_STAT_REG(shpnt)) & IM_BUSY))
2054 break;
2055 }
2056 /* write registers and enable system interrupts */
2057 outl(imm_command, IM_CMD_REG(shpnt));
2058 outb(IM_IMM_CMD | ldn, IM_ATTN_REG(shpnt));
2059#ifdef IM_DEBUG_PROBE
2060 printk("IBM MCA SCSI: Abort queued to adapter...\n");
2061#endif
2062 spin_unlock_irq(shpnt->host_lock);
2063 while (!cmd->SCp.Status)
2064 yield();
2065 spin_lock_irq(shpnt->host_lock);
2066 cmd->scsi_done = saved_done;
2067#ifdef IM_DEBUG_PROBE
2068 printk("IBM MCA SCSI: Abort returned with adapter response...\n");
2069#endif
2070
2071 /*if abort went well, call saved done, then return success or error */
2072 if (cmd->result == (DID_ABORT << 16))
2073 {
2074 cmd->result |= DID_ABORT << 16;
2075 if (cmd->scsi_done)
2076 (cmd->scsi_done) (cmd);
2077 ld(shpnt)[ldn].cmd = NULL;
2078#ifdef IM_DEBUG_PROBE
2079 printk("IBM MCA SCSI: Abort finished with success.\n");
2080#endif
2081 return SUCCESS;
2082 } else {
2083 cmd->result |= DID_NO_CONNECT << 16;
2084 if (cmd->scsi_done)
2085 (cmd->scsi_done) (cmd);
2086 ld(shpnt)[ldn].cmd = NULL;
2087#ifdef IM_DEBUG_PROBE
2088 printk("IBM MCA SCSI: Abort failed.\n");
2089#endif
2090 return FAILED;
2091 }
2092}
2093
2094static int ibmmca_abort(Scsi_Cmnd * cmd)
2095{
2096 struct Scsi_Host *shpnt = cmd->device->host;
2097 int rc;
2098
2099 spin_lock_irq(shpnt->host_lock);
2100 rc = __ibmmca_abort(cmd);
2101 spin_unlock_irq(shpnt->host_lock);
2102
2103 return rc;
2104}
2105
2106static int __ibmmca_host_reset(Scsi_Cmnd * cmd)
2107{
2108 struct Scsi_Host *shpnt;
2109 Scsi_Cmnd *cmd_aid;
2110 int ticks, i;
2111 unsigned long imm_command;
2112
2113 BUG_ON(cmd == NULL);
2114
2115 ticks = IM_RESET_DELAY * HZ;
2116 shpnt = cmd->device->host;
2117
2118 if (local_checking_phase_flag(shpnt)) {
2119 printk(KERN_WARNING "IBM MCA SCSI: unable to reset while checking devices.\n");
2120 return FAILED;
2121 }
2122
2123 /* issue reset immediate command to subsystem, and wait for interrupt */
2124 printk("IBM MCA SCSI: resetting all devices.\n");
2125 reset_status(shpnt) = IM_RESET_IN_PROGRESS;
2126 last_scsi_command(shpnt)[0xf] = IM_RESET_IMM_CMD;
2127 last_scsi_type(shpnt)[0xf] = IM_IMM_CMD;
2128 imm_command = inl(IM_CMD_REG(shpnt));
2129 imm_command &= (unsigned long) (0xffff0000); /* mask reserved stuff */
2130 imm_command |= (unsigned long) (IM_RESET_IMM_CMD);
2131 /* must wait for attention reg not busy */
2132 while (1) {
2133 if (!(inb(IM_STAT_REG(shpnt)) & IM_BUSY))
2134 break;
2135 spin_unlock_irq(shpnt->host_lock);
2136 yield();
2137 spin_lock_irq(shpnt->host_lock);
2138 }
2139 /*write registers and enable system interrupts */
2140 outl(imm_command, IM_CMD_REG(shpnt));
2141 outb(IM_IMM_CMD | 0xf, IM_ATTN_REG(shpnt));
2142 /* wait for interrupt finished or intr_stat register to be set, as the
2143 * interrupt will not be executed, while we are in here! */
2144
2145 /* FIXME: This is really really icky we so want a sleeping version of this ! */
2146 while (reset_status(shpnt) == IM_RESET_IN_PROGRESS && --ticks && ((inb(IM_INTR_REG(shpnt)) & 0x8f) != 0x8f)) {
2147 udelay((1 + 999 / HZ) * 1000);
2148 barrier();
2149 }
2150 /* if reset did not complete, just return an error */
2151 if (!ticks) {
2152 printk(KERN_ERR "IBM MCA SCSI: reset did not complete within %d seconds.\n", IM_RESET_DELAY);
2153 reset_status(shpnt) = IM_RESET_FINISHED_FAIL;
2154 return FAILED;
2155 }
2156
2157 if ((inb(IM_INTR_REG(shpnt)) & 0x8f) == 0x8f) {
2158 /* analysis done by this routine and not by the intr-routine */
2159 if (inb(IM_INTR_REG(shpnt)) == 0xaf)
2160 reset_status(shpnt) = IM_RESET_FINISHED_OK_NO_INT;
2161 else if (inb(IM_INTR_REG(shpnt)) == 0xcf)
2162 reset_status(shpnt) = IM_RESET_FINISHED_FAIL;
2163 else /* failed, 4get it */
2164 reset_status(shpnt) = IM_RESET_NOT_IN_PROGRESS_NO_INT;
2165 outb(IM_EOI | 0xf, IM_ATTN_REG(shpnt));
2166 }
2167
2168 /* if reset failed, just return an error */
2169 if (reset_status(shpnt) == IM_RESET_FINISHED_FAIL) {
2170 printk(KERN_ERR "IBM MCA SCSI: reset failed.\n");
2171 return FAILED;
2172 }
2173
2174 /* so reset finished ok - call outstanding done's, and return success */
2175 printk(KERN_INFO "IBM MCA SCSI: Reset successfully completed.\n");
2176 for (i = 0; i < MAX_LOG_DEV; i++) {
2177 cmd_aid = ld(shpnt)[i].cmd;
2178 if (cmd_aid && cmd_aid->scsi_done) {
2179 ld(shpnt)[i].cmd = NULL;
2180 cmd_aid->result = DID_RESET << 16;
2181 }
2182 }
2183 return SUCCESS;
2184}
2185
2186static int ibmmca_host_reset(Scsi_Cmnd * cmd)
2187{
2188 struct Scsi_Host *shpnt = cmd->device->host;
2189 int rc;
2190
2191 spin_lock_irq(shpnt->host_lock);
2192 rc = __ibmmca_host_reset(cmd);
2193 spin_unlock_irq(shpnt->host_lock);
2194
2195 return rc;
2196}
2197
2198static int ibmmca_biosparam(struct scsi_device *sdev, struct block_device *bdev, sector_t capacity, int *info)
2199{
2200 int size = capacity;
2201 info[0] = 64;
2202 info[1] = 32;
2203 info[2] = size / (info[0] * info[1]);
2204 if (info[2] >= 1024) {
2205 info[0] = 128;
2206 info[1] = 63;
2207 info[2] = size / (info[0] * info[1]);
2208 if (info[2] >= 1024) {
2209 info[0] = 255;
2210 info[1] = 63;
2211 info[2] = size / (info[0] * info[1]);
2212 if (info[2] >= 1024)
2213 info[2] = 1023;
2214 }
2215 }
2216 return 0;
2217}
2218
2219/* calculate percentage of total accesses on a ldn */
2220static int ldn_access_load(struct Scsi_Host *shpnt, int ldn)
2221{
2222 if (IBM_DS(shpnt).total_accesses == 0)
2223 return (0);
2224 if (IBM_DS(shpnt).ldn_access[ldn] == 0)
2225 return (0);
2226 return (IBM_DS(shpnt).ldn_access[ldn] * 100) / IBM_DS(shpnt).total_accesses;
2227}
2228
2229/* calculate total amount of r/w-accesses */
2230static int ldn_access_total_read_write(struct Scsi_Host *shpnt)
2231{
2232 int a;
2233 int i;
2234
2235 a = 0;
2236 for (i = 0; i <= MAX_LOG_DEV; i++)
2237 a += IBM_DS(shpnt).ldn_read_access[i] + IBM_DS(shpnt).ldn_write_access[i];
2238 return (a);
2239}
2240
2241static int ldn_access_total_inquiry(struct Scsi_Host *shpnt)
2242{
2243 int a;
2244 int i;
2245
2246 a = 0;
2247 for (i = 0; i <= MAX_LOG_DEV; i++)
2248 a += IBM_DS(shpnt).ldn_inquiry_access[i];
2249 return (a);
2250}
2251
2252static int ldn_access_total_modeselect(struct Scsi_Host *shpnt)
2253{
2254 int a;
2255 int i;
2256
2257 a = 0;
2258 for (i = 0; i <= MAX_LOG_DEV; i++)
2259 a += IBM_DS(shpnt).ldn_modeselect_access[i];
2260 return (a);
2261}
2262
2263/* routine to display info in the proc-fs-structure (a deluxe feature) */
2264static int ibmmca_proc_info(struct Scsi_Host *shpnt, char *buffer, char **start, off_t offset, int length, int inout)
2265{
2266 int len = 0;
2267 int i, id, lun;
2268 unsigned long flags;
2269 int max_pun;
2270
2271
2272 spin_lock_irqsave(shpnt->host_lock, flags); /* Check it */
2273
2274 max_pun = subsystem_maxid(shpnt);
2275
2276 len += sprintf(buffer + len, "\n IBM-SCSI-Subsystem-Linux-Driver, Version %s\n\n\n", IBMMCA_SCSI_DRIVER_VERSION);
2277 len += sprintf(buffer + len, " SCSI Access-Statistics:\n");
2278 len += sprintf(buffer + len, " Device Scanning Order....: %s\n", (ibm_ansi_order) ? "IBM/ANSI" : "New Industry Standard");
2279#ifdef CONFIG_SCSI_MULTI_LUN
2280 len += sprintf(buffer + len, " Multiple LUN probing.....: Yes\n");
2281#else
2282 len += sprintf(buffer + len, " Multiple LUN probing.....: No\n");
2283#endif
2284 len += sprintf(buffer + len, " This Hostnumber..........: %d\n", shpnt->host_no);
2285 len += sprintf(buffer + len, " Base I/O-Port............: 0x%x\n", (unsigned int) (IM_CMD_REG(shpnt)));
2286 len += sprintf(buffer + len, " (Shared) IRQ.............: %d\n", IM_IRQ);
2287 len += sprintf(buffer + len, " Total Interrupts.........: %d\n", IBM_DS(shpnt).total_interrupts);
2288 len += sprintf(buffer + len, " Total SCSI Accesses......: %d\n", IBM_DS(shpnt).total_accesses);
2289 len += sprintf(buffer + len, " Total short SCBs.........: %d\n", IBM_DS(shpnt).scbs);
2290 len += sprintf(buffer + len, " Total long SCBs..........: %d\n", IBM_DS(shpnt).long_scbs);
2291 len += sprintf(buffer + len, " Total SCSI READ/WRITE..: %d\n", ldn_access_total_read_write(shpnt));
2292 len += sprintf(buffer + len, " Total SCSI Inquiries...: %d\n", ldn_access_total_inquiry(shpnt));
2293 len += sprintf(buffer + len, " Total SCSI Modeselects.: %d\n", ldn_access_total_modeselect(shpnt));
2294 len += sprintf(buffer + len, " Total SCSI other cmds..: %d\n", IBM_DS(shpnt).total_accesses - ldn_access_total_read_write(shpnt)
2295 - ldn_access_total_modeselect(shpnt)
2296 - ldn_access_total_inquiry(shpnt));
2297 len += sprintf(buffer + len, " Total SCSI command fails.: %d\n\n", IBM_DS(shpnt).total_errors);
2298 len += sprintf(buffer + len, " Logical-Device-Number (LDN) Access-Statistics:\n");
2299 len += sprintf(buffer + len, " LDN | Accesses [%%] | READ | WRITE | ASSIGNMENTS\n");
2300 len += sprintf(buffer + len, " -----|--------------|-----------|-----------|--------------\n");
2301 for (i = 0; i <= MAX_LOG_DEV; i++)
2302 len += sprintf(buffer + len, " %2X | %3d | %8d | %8d | %8d\n", i, ldn_access_load(shpnt, i), IBM_DS(shpnt).ldn_read_access[i], IBM_DS(shpnt).ldn_write_access[i], IBM_DS(shpnt).ldn_assignments[i]);
2303 len += sprintf(buffer + len, " -----------------------------------------------------------\n\n");
2304 len += sprintf(buffer + len, " Dynamical-LDN-Assignment-Statistics:\n");
2305 len += sprintf(buffer + len, " Number of physical SCSI-devices..: %d (+ Adapter)\n", IBM_DS(shpnt).total_scsi_devices);
2306 len += sprintf(buffer + len, " Dynamical Assignment necessary...: %s\n", IBM_DS(shpnt).dyn_flag ? "Yes" : "No ");
2307 len += sprintf(buffer + len, " Next LDN to be assigned..........: 0x%x\n", next_ldn(shpnt));
2308 len += sprintf(buffer + len, " Dynamical assignments done yet...: %d\n", IBM_DS(shpnt).dynamical_assignments);
2309 len += sprintf(buffer + len, "\n Current SCSI-Device-Mapping:\n");
2310 len += sprintf(buffer + len, " Physical SCSI-Device Map Logical SCSI-Device Map\n");
2311 len += sprintf(buffer + len, " ID\\LUN 0 1 2 3 4 5 6 7 ID\\LUN 0 1 2 3 4 5 6 7\n");
2312 for (id = 0; id < max_pun; id++) {
2313 len += sprintf(buffer + len, " %2d ", id);
2314 for (lun = 0; lun < 8; lun++)
2315 len += sprintf(buffer + len, "%2s ", ti_p(get_scsi(shpnt)[id][lun]));
2316 len += sprintf(buffer + len, " %2d ", id);
2317 for (lun = 0; lun < 8; lun++)
2318 len += sprintf(buffer + len, "%2s ", ti_l(get_ldn(shpnt)[id][lun]));
2319 len += sprintf(buffer + len, "\n");
2320 }
2321
2322 len += sprintf(buffer + len, "(A = IBM-Subsystem, D = Harddisk, T = Tapedrive, P = Processor, W = WORM,\n");
2323 len += sprintf(buffer + len, " R = CD-ROM, S = Scanner, M = MO-Drive, C = Medium-Changer, + = unprovided LUN,\n");
2324 len += sprintf(buffer + len, " - = nothing found, nothing assigned or unprobed LUN)\n\n");
2325
2326 *start = buffer + offset;
2327 len -= offset;
2328 if (len > length)
2329 len = length;
2330 spin_unlock_irqrestore(shpnt->host_lock, flags);
2331 return len;
2332}
2333
2334static int option_setup(char *str)
2335{
2336 int ints[IM_MAX_HOSTS];
2337 char *cur = str;
2338 int i = 1;
2339
2340 while (cur && isdigit(*cur) && i < IM_MAX_HOSTS) {
2341 ints[i++] = simple_strtoul(cur, NULL, 0);
2342 if ((cur = strchr(cur, ',')) != NULL)
2343 cur++;
2344 }
2345 ints[0] = i - 1;
2346 internal_ibmmca_scsi_setup(cur, ints);
2347 return 1;
2348}
2349
2350__setup("ibmmcascsi=", option_setup);
2351
2352static struct mca_driver ibmmca_driver = {
2353 .id_table = ibmmca_id_table,
2354 .driver = {
2355 .name = "ibmmca",
2356 .bus = &mca_bus_type,
2357 .probe = ibmmca_probe,
2358 .remove = __devexit_p(ibmmca_remove),
2359 },
2360};
2361
2362static int __init ibmmca_init(void)
2363{
2364#ifdef MODULE
2365 /* If the driver is run as module, read from conf.modules or cmd-line */
2366 if (boot_options)
2367 option_setup(boot_options);
2368#endif
2369
2370 return mca_register_driver_integrated(&ibmmca_driver, MCA_INTEGSCSI);
2371}
2372
2373static void __exit ibmmca_exit(void)
2374{
2375 mca_unregister_driver(&ibmmca_driver);
2376}
2377
2378module_init(ibmmca_init);
2379module_exit(ibmmca_exit);
diff --git a/drivers/scsi/sim710.c b/drivers/scsi/sim710.c
index 8ac6ce792b6..a318264a4ba 100644
--- a/drivers/scsi/sim710.c
+++ b/drivers/scsi/sim710.c
@@ -17,7 +17,7 @@
17 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 17 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18 *---------------------------------------------------------------------------- 18 *----------------------------------------------------------------------------
19 * 19 *
20 * MCA card detection code by Trent McNair. 20 * MCA card detection code by Trent McNair. (now deleted)
21 * Fixes to not explicitly nul bss data from Xavier Bestel. 21 * Fixes to not explicitly nul bss data from Xavier Bestel.
22 * Some multiboard fixes from Rolf Eike Beer. 22 * Some multiboard fixes from Rolf Eike Beer.
23 * Auto probing of EISA config space from Trevor Hemsley. 23 * Auto probing of EISA config space from Trevor Hemsley.
@@ -32,7 +32,6 @@
32#include <linux/blkdev.h> 32#include <linux/blkdev.h>
33#include <linux/device.h> 33#include <linux/device.h>
34#include <linux/init.h> 34#include <linux/init.h>
35#include <linux/mca.h>
36#include <linux/eisa.h> 35#include <linux/eisa.h>
37#include <linux/interrupt.h> 36#include <linux/interrupt.h>
38#include <scsi/scsi_host.h> 37#include <scsi/scsi_host.h>
@@ -43,7 +42,7 @@
43#include "53c700.h" 42#include "53c700.h"
44 43
45 44
46/* Must be enough for both EISA and MCA */ 45/* Must be enough for EISA */
47#define MAX_SLOTS 8 46#define MAX_SLOTS 8
48static __u8 __initdata id_array[MAX_SLOTS] = { [0 ... MAX_SLOTS-1] = 7 }; 47static __u8 __initdata id_array[MAX_SLOTS] = { [0 ... MAX_SLOTS-1] = 7 };
49 48
@@ -89,7 +88,7 @@ param_setup(char *str)
89__setup("sim710=", param_setup); 88__setup("sim710=", param_setup);
90 89
91static struct scsi_host_template sim710_driver_template = { 90static struct scsi_host_template sim710_driver_template = {
92 .name = "LSI (Symbios) 710 MCA/EISA", 91 .name = "LSI (Symbios) 710 EISA",
93 .proc_name = "sim710", 92 .proc_name = "sim710",
94 .this_id = 7, 93 .this_id = 7,
95 .module = THIS_MODULE, 94 .module = THIS_MODULE,
@@ -169,114 +168,6 @@ sim710_device_remove(struct device *dev)
169 return 0; 168 return 0;
170} 169}
171 170
172#ifdef CONFIG_MCA
173
174/* CARD ID 01BB and 01BA use the same pos values */
175#define MCA_01BB_IO_PORTS { 0x0000, 0x0000, 0x0800, 0x0C00, 0x1000, 0x1400, \
176 0x1800, 0x1C00, 0x2000, 0x2400, 0x2800, \
177 0x2C00, 0x3000, 0x3400, 0x3800, 0x3C00, \
178 0x4000, 0x4400, 0x4800, 0x4C00, 0x5000 }
179
180#define MCA_01BB_IRQS { 3, 5, 11, 14 }
181
182/* CARD ID 004f */
183#define MCA_004F_IO_PORTS { 0x0000, 0x0200, 0x0300, 0x0400, 0x0500, 0x0600 }
184#define MCA_004F_IRQS { 5, 9, 14 }
185
186static short sim710_mca_id_table[] = { 0x01bb, 0x01ba, 0x004f, 0};
187
188static __init int
189sim710_mca_probe(struct device *dev)
190{
191 struct mca_device *mca_dev = to_mca_device(dev);
192 int slot = mca_dev->slot;
193 int pos[3];
194 unsigned int base;
195 int irq_vector;
196 short id = sim710_mca_id_table[mca_dev->index];
197 static int io_004f_by_pos[] = MCA_004F_IO_PORTS;
198 static int irq_004f_by_pos[] = MCA_004F_IRQS;
199 static int io_01bb_by_pos[] = MCA_01BB_IO_PORTS;
200 static int irq_01bb_by_pos[] = MCA_01BB_IRQS;
201 char *name;
202 int clock;
203
204 pos[0] = mca_device_read_stored_pos(mca_dev, 2);
205 pos[1] = mca_device_read_stored_pos(mca_dev, 3);
206 pos[2] = mca_device_read_stored_pos(mca_dev, 4);
207
208 /*
209 * 01BB & 01BA port base by bits 7,6,5,4,3,2 in pos[2]
210 *
211 * 000000 <disabled> 001010 0x2800
212 * 000001 <invalid> 001011 0x2C00
213 * 000010 0x0800 001100 0x3000
214 * 000011 0x0C00 001101 0x3400
215 * 000100 0x1000 001110 0x3800
216 * 000101 0x1400 001111 0x3C00
217 * 000110 0x1800 010000 0x4000
218 * 000111 0x1C00 010001 0x4400
219 * 001000 0x2000 010010 0x4800
220 * 001001 0x2400 010011 0x4C00
221 * 010100 0x5000
222 *
223 * 00F4 port base by bits 3,2,1 in pos[0]
224 *
225 * 000 <disabled> 001 0x200
226 * 010 0x300 011 0x400
227 * 100 0x500 101 0x600
228 *
229 * 01BB & 01BA IRQ is specified in pos[0] bits 7 and 6:
230 *
231 * 00 3 10 11
232 * 01 5 11 14
233 *
234 * 00F4 IRQ specified by bits 6,5,4 in pos[0]
235 *
236 * 100 5 101 9
237 * 110 14
238 */
239
240 if (id == 0x01bb || id == 0x01ba) {
241 base = io_01bb_by_pos[(pos[2] & 0xFC) >> 2];
242 irq_vector =
243 irq_01bb_by_pos[((pos[0] & 0xC0) >> 6)];
244
245 clock = 50;
246 if (id == 0x01bb)
247 name = "NCR 3360/3430 SCSI SubSystem";
248 else
249 name = "NCR Dual SIOP SCSI Host Adapter Board";
250 } else if ( id == 0x004f ) {
251 base = io_004f_by_pos[((pos[0] & 0x0E) >> 1)];
252 irq_vector =
253 irq_004f_by_pos[((pos[0] & 0x70) >> 4) - 4];
254 clock = 50;
255 name = "NCR 53c710 SCSI Host Adapter Board";
256 } else {
257 return -ENODEV;
258 }
259 mca_device_set_name(mca_dev, name);
260 mca_device_set_claim(mca_dev, 1);
261 base = mca_device_transform_ioport(mca_dev, base);
262 irq_vector = mca_device_transform_irq(mca_dev, irq_vector);
263
264 return sim710_probe_common(dev, base, irq_vector, clock,
265 0, id_array[slot]);
266}
267
268static struct mca_driver sim710_mca_driver = {
269 .id_table = sim710_mca_id_table,
270 .driver = {
271 .name = "sim710",
272 .bus = &mca_bus_type,
273 .probe = sim710_mca_probe,
274 .remove = __devexit_p(sim710_device_remove),
275 },
276};
277
278#endif /* CONFIG_MCA */
279
280#ifdef CONFIG_EISA 171#ifdef CONFIG_EISA
281static struct eisa_device_id sim710_eisa_ids[] = { 172static struct eisa_device_id sim710_eisa_ids[] = {
282 { "CPQ4410" }, 173 { "CPQ4410" },
@@ -344,10 +235,6 @@ static int __init sim710_init(void)
344 param_setup(sim710); 235 param_setup(sim710);
345#endif 236#endif
346 237
347#ifdef CONFIG_MCA
348 err = mca_register_driver(&sim710_mca_driver);
349#endif
350
351#ifdef CONFIG_EISA 238#ifdef CONFIG_EISA
352 err = eisa_driver_register(&sim710_eisa_driver); 239 err = eisa_driver_register(&sim710_eisa_driver);
353#endif 240#endif
@@ -361,11 +248,6 @@ static int __init sim710_init(void)
361 248
362static void __exit sim710_exit(void) 249static void __exit sim710_exit(void)
363{ 250{
364#ifdef CONFIG_MCA
365 if (MCA_bus)
366 mca_unregister_driver(&sim710_mca_driver);
367#endif
368
369#ifdef CONFIG_EISA 251#ifdef CONFIG_EISA
370 eisa_driver_unregister(&sim710_eisa_driver); 252 eisa_driver_unregister(&sim710_eisa_driver);
371#endif 253#endif
generated by cgit v1.2.2 (git 2.25.0) at 2025-01-27 05:59:36 -0500