projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[SCSI] zfcp: fix compile error
[linux-2.6-block.git] / drivers / scsi / aacraid / linit.c
CommitLineData
1da177e4
LT		 1/*
2 * Adaptec AAC series RAID controller driver
3 * (c) Copyright 2001 Red Hat Inc. <alan@redhat.com>
4 *
5 * based on the old aacraid driver that is..
6 * Adaptec aacraid device driver for Linux.
7 *
8 * Copyright (c) 2000 Adaptec, Inc. (aacraid@adaptec.com)
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2, or (at your option)
13 * any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; see the file COPYING. If not, write to
22 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
23 *
24 * Module Name:
25 * linit.c
26 *
27 * Abstract: Linux Driver entry module for Adaptec RAID Array Controller
28 */
29
30#define AAC_DRIVER_VERSION "1.1.2-lk2"
31#define AAC_DRIVER_BUILD_DATE __DATE__
32#define AAC_DRIVERNAME "aacraid"
33
34#include <linux/compat.h>
35#include <linux/blkdev.h>
36#include <linux/completion.h>
37#include <linux/init.h>
38#include <linux/interrupt.h>
39#include <linux/kernel.h>
40#include <linux/module.h>
41#include <linux/moduleparam.h>
42#include <linux/pci.h>
43#include <linux/slab.h>
44#include <linux/spinlock.h>
45#include <linux/syscalls.h>
46#include <linux/ioctl32.h>
47#include <linux/delay.h>
48#include <linux/smp_lock.h>
49#include <asm/semaphore.h>
50
51#include <scsi/scsi.h>
52#include <scsi/scsi_cmnd.h>
53#include <scsi/scsi_device.h>
54#include <scsi/scsi_host.h>
55#include <scsi/scsi_tcq.h>
56#include <scsi/scsicam.h>
57#include <scsi/scsi_eh.h>
58
59#include "aacraid.h"
60
61
62MODULE_AUTHOR("Red Hat Inc and Adaptec");
63MODULE_DESCRIPTION("Dell PERC2, 2/Si, 3/Si, 3/Di, "
64 "Adaptec Advanced Raid Products, "
65 "and HP NetRAID-4M SCSI driver");
66MODULE_LICENSE("GPL");
67MODULE_VERSION(AAC_DRIVER_VERSION);
68
69static LIST_HEAD(aac_devices);
70static int aac_cfg_major = -1;
71
72/*
73 * Because of the way Linux names scsi devices, the order in this table has
74 * become important. Check for on-board Raid first, add-in cards second.
75 *
76 * Note: The last field is used to index into aac_drivers below.
77 */
78static struct pci_device_id aac_pci_tbl[] = {
79 { 0x1028, 0x0001, 0x1028, 0x0001, 0, 0, 0 }, /* PERC 2/Si (Iguana/PERC2Si) */
80 { 0x1028, 0x0002, 0x1028, 0x0002, 0, 0, 1 }, /* PERC 3/Di (Opal/PERC3Di) */
81 { 0x1028, 0x0003, 0x1028, 0x0003, 0, 0, 2 }, /* PERC 3/Si (SlimFast/PERC3Si */
82 { 0x1028, 0x0004, 0x1028, 0x00d0, 0, 0, 3 }, /* PERC 3/Di (Iguana FlipChip/PERC3DiF */
83 { 0x1028, 0x0002, 0x1028, 0x00d1, 0, 0, 4 }, /* PERC 3/Di (Viper/PERC3DiV) */
84 { 0x1028, 0x0002, 0x1028, 0x00d9, 0, 0, 5 }, /* PERC 3/Di (Lexus/PERC3DiL) */
85 { 0x1028, 0x000a, 0x1028, 0x0106, 0, 0, 6 }, /* PERC 3/Di (Jaguar/PERC3DiJ) */
86 { 0x1028, 0x000a, 0x1028, 0x011b, 0, 0, 7 }, /* PERC 3/Di (Dagger/PERC3DiD) */
87 { 0x1028, 0x000a, 0x1028, 0x0121, 0, 0, 8 }, /* PERC 3/Di (Boxster/PERC3DiB) */
88 { 0x9005, 0x0283, 0x9005, 0x0283, 0, 0, 9 }, /* catapult */
89 { 0x9005, 0x0284, 0x9005, 0x0284, 0, 0, 10 }, /* tomcat */
90 { 0x9005, 0x0285, 0x9005, 0x0286, 0, 0, 11 }, /* Adaptec 2120S (Crusader) */
91 { 0x9005, 0x0285, 0x9005, 0x0285, 0, 0, 12 }, /* Adaptec 2200S (Vulcan) */
92 { 0x9005, 0x0285, 0x9005, 0x0287, 0, 0, 13 }, /* Adaptec 2200S (Vulcan-2m) */
93 { 0x9005, 0x0285, 0x17aa, 0x0286, 0, 0, 14 }, /* Legend S220 (Legend Crusader) */
94 { 0x9005, 0x0285, 0x17aa, 0x0287, 0, 0, 15 }, /* Legend S230 (Legend Vulcan) */
95
96 { 0x9005, 0x0285, 0x9005, 0x0288, 0, 0, 16 }, /* Adaptec 3230S (Harrier) */
97 { 0x9005, 0x0285, 0x9005, 0x0289, 0, 0, 17 }, /* Adaptec 3240S (Tornado) */
98 { 0x9005, 0x0285, 0x9005, 0x028a, 0, 0, 18 }, /* ASR-2020ZCR SCSI PCI-X ZCR (Skyhawk) */
99 { 0x9005, 0x0285, 0x9005, 0x028b, 0, 0, 19 }, /* ASR-2025ZCR SCSI SO-DIMM PCI-X ZCR (Terminator) */
100 { 0x9005, 0x0286, 0x9005, 0x028c, 0, 0, 20 }, /* ASR-2230S + ASR-2230SLP PCI-X (Lancer) */
101 { 0x9005, 0x0286, 0x9005, 0x028d, 0, 0, 21 }, /* ASR-2130S (Lancer) */
102 { 0x9005, 0x0286, 0x9005, 0x029b, 0, 0, 22 }, /* AAR-2820SA (Intruder) */
103 { 0x9005, 0x0286, 0x9005, 0x029c, 0, 0, 23 }, /* AAR-2620SA (Intruder) */
104 { 0x9005, 0x0286, 0x9005, 0x029d, 0, 0, 24 }, /* AAR-2420SA (Intruder) */
105 { 0x9005, 0x0286, 0x9005, 0x0800, 0, 0, 25 }, /* Callisto Jupiter Platform */
106 { 0x9005, 0x0285, 0x9005, 0x028e, 0, 0, 26 }, /* ASR-2020SA SATA PCI-X ZCR (Skyhawk) */
107 { 0x9005, 0x0285, 0x9005, 0x028f, 0, 0, 27 }, /* ASR-2025SA SATA SO-DIMM PCI-X ZCR (Terminator) */
108 { 0x9005, 0x0285, 0x9005, 0x0290, 0, 0, 28 }, /* AAR-2410SA PCI SATA 4ch (Jaguar II) */
109 { 0x9005, 0x0285, 0x1028, 0x0291, 0, 0, 29 }, /* CERC SATA RAID 2 PCI SATA 6ch (DellCorsair) */
110 { 0x9005, 0x0285, 0x9005, 0x0292, 0, 0, 30 }, /* AAR-2810SA PCI SATA 8ch (Corsair-8) */
111 { 0x9005, 0x0285, 0x9005, 0x0293, 0, 0, 31 }, /* AAR-21610SA PCI SATA 16ch (Corsair-16) */
112 { 0x9005, 0x0285, 0x9005, 0x0294, 0, 0, 32 }, /* ESD SO-DIMM PCI-X SATA ZCR (Prowler) */
113 { 0x9005, 0x0285, 0x103C, 0x3227, 0, 0, 33 }, /* AAR-2610SA PCI SATA 6ch */
114 { 0x9005, 0x0285, 0x9005, 0x0296, 0, 0, 34 }, /* ASR-2240S (SabreExpress) */
115 { 0x9005, 0x0285, 0x9005, 0x0297, 0, 0, 35 }, /* ASR-4005SAS */
116 { 0x9005, 0x0285, 0x1014, 0x02F2, 0, 0, 36 }, /* IBM 8i (AvonPark) */
117 { 0x9005, 0x0285, 0x9005, 0x0298, 0, 0, 37 }, /* ASR-4000SAS (BlackBird) */
118 { 0x9005, 0x0285, 0x9005, 0x0299, 0, 0, 38 }, /* ASR-4800SAS (Marauder-X) */
119 { 0x9005, 0x0285, 0x9005, 0x029A, 0, 0, 39 }, /* ASR-4805SAS (Marauder-E) */
120
121 { 0x9005, 0x0285, 0x1028, 0x0287, 0, 0, 40 }, /* Perc 320/DC*/
122 { 0x1011, 0x0046, 0x9005, 0x0365, 0, 0, 41 }, /* Adaptec 5400S (Mustang)*/
123 { 0x1011, 0x0046, 0x9005, 0x0364, 0, 0, 42 }, /* Adaptec 5400S (Mustang)*/
124 { 0x1011, 0x0046, 0x9005, 0x1364, 0, 0, 43 }, /* Dell PERC2/QC */
125 { 0x1011, 0x0046, 0x103c, 0x10c2, 0, 0, 44 }, /* HP NetRAID-4M */
126
127 { 0x9005, 0x0285, 0x1028, PCI_ANY_ID, 0, 0, 45 }, /* Dell Catchall */
128 { 0x9005, 0x0285, 0x17aa, PCI_ANY_ID, 0, 0, 46 }, /* Legend Catchall */
129 { 0x9005, 0x0285, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 47 }, /* Adaptec Catch All */
130 { 0x9005, 0x0286, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 48 }, /* Adaptec Rocket Catch All */
131 { 0,}
132};
133MODULE_DEVICE_TABLE(pci, aac_pci_tbl);
134
135/*
136 * dmb - For now we add the number of channels to this structure.
137 * In the future we should add a fib that reports the number of channels
138 * for the card. At that time we can remove the channels from here
139 */
140static struct aac_driver_ident aac_drivers[] = {
141 { aac_rx_init, "percraid", "DELL ", "PERCRAID ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* PERC 2/Si (Iguana/PERC2Si) */
142 { aac_rx_init, "percraid", "DELL ", "PERCRAID ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* PERC 3/Di (Opal/PERC3Di) */
143 { aac_rx_init, "percraid", "DELL ", "PERCRAID ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* PERC 3/Si (SlimFast/PERC3Si */
144 { aac_rx_init, "percraid", "DELL ", "PERCRAID ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* PERC 3/Di (Iguana FlipChip/PERC3DiF */
145 { aac_rx_init, "percraid", "DELL ", "PERCRAID ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* PERC 3/Di (Viper/PERC3DiV) */
146 { aac_rx_init, "percraid", "DELL ", "PERCRAID ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* PERC 3/Di (Lexus/PERC3DiL) */
147 { aac_rx_init, "percraid", "DELL ", "PERCRAID ", 1, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* PERC 3/Di (Jaguar/PERC3DiJ) */
148 { aac_rx_init, "percraid", "DELL ", "PERCRAID ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* PERC 3/Di (Dagger/PERC3DiD) */
149 { aac_rx_init, "percraid", "DELL ", "PERCRAID ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* PERC 3/Di (Boxster/PERC3DiB) */
150 { aac_rx_init, "aacraid", "ADAPTEC ", "catapult ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* catapult */
151 { aac_rx_init, "aacraid", "ADAPTEC ", "tomcat ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* tomcat */
152 { aac_rx_init, "aacraid", "ADAPTEC ", "Adaptec 2120S ", 1, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* Adaptec 2120S (Crusader) */
153 { aac_rx_init, "aacraid", "ADAPTEC ", "Adaptec 2200S ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* Adaptec 2200S (Vulcan) */
154 { aac_rx_init, "aacraid", "ADAPTEC ", "Adaptec 2200S ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* Adaptec 2200S (Vulcan-2m) */
155 { aac_rx_init, "aacraid", "Legend ", "Legend S220 ", 1, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* Legend S220 (Legend Crusader) */
156 { aac_rx_init, "aacraid", "Legend ", "Legend S230 ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* Legend S230 (Legend Vulcan) */
157
158 { aac_rx_init, "aacraid", "ADAPTEC ", "Adaptec 3230S ", 2 }, /* Adaptec 3230S (Harrier) */
159 { aac_rx_init, "aacraid", "ADAPTEC ", "Adaptec 3240S ", 2 }, /* Adaptec 3240S (Tornado) */
160 { aac_rx_init, "aacraid", "ADAPTEC ", "ASR-2020ZCR ", 2 }, /* ASR-2020ZCR SCSI PCI-X ZCR (Skyhawk) */
161 { aac_rx_init, "aacraid", "ADAPTEC ", "ASR-2025ZCR ", 2 }, /* ASR-2025ZCR SCSI SO-DIMM PCI-X ZCR (Terminator) */
162 { aac_rkt_init, "aacraid", "ADAPTEC ", "ASR-2230S PCI-X ", 2 }, /* ASR-2230S + ASR-2230SLP PCI-X (Lancer) */
163 { aac_rkt_init, "aacraid", "ADAPTEC ", "ASR-2130S PCI-X ", 1 }, /* ASR-2130S (Lancer) */
164 { aac_rkt_init, "aacraid", "ADAPTEC ", "AAR-2820SA ", 1 }, /* AAR-2820SA (Intruder) */
165 { aac_rkt_init, "aacraid", "ADAPTEC ", "AAR-2620SA ", 1 }, /* AAR-2620SA (Intruder) */
166 { aac_rkt_init, "aacraid", "ADAPTEC ", "AAR-2420SA ", 1 }, /* AAR-2420SA (Intruder) */
167 { aac_rkt_init, "aacraid", "ADAPTEC ", "Callisto ", 2, AAC_QUIRK_MASTER }, /* Jupiter Platform */
168 { aac_rx_init, "aacraid", "ADAPTEC ", "ASR-2020SA ", 1 }, /* ASR-2020SA SATA PCI-X ZCR (Skyhawk) */
169 { aac_rx_init, "aacraid", "ADAPTEC ", "ASR-2025SA ", 1 }, /* ASR-2025SA SATA SO-DIMM PCI-X ZCR (Terminator) */
170 { aac_rx_init, "aacraid", "ADAPTEC ", "AAR-2410SA SATA ", 1 }, /* AAR-2410SA PCI SATA 4ch (Jaguar II) */
171 { aac_rx_init, "aacraid", "DELL ", "CERC SR2 ", 1 }, /* CERC SATA RAID 2 PCI SATA 6ch (DellCorsair) */
172 { aac_rx_init, "aacraid", "ADAPTEC ", "AAR-2810SA SATA ", 1 }, /* AAR-2810SA PCI SATA 8ch (Corsair-8) */
173 { aac_rx_init, "aacraid", "ADAPTEC ", "AAR-21610SA SATA", 1 }, /* AAR-21610SA PCI SATA 16ch (Corsair-16) */
174 { aac_rx_init, "aacraid", "ADAPTEC ", "ASR-2026ZCR ", 1 }, /* ESD SO-DIMM PCI-X SATA ZCR (Prowler) */
175 { aac_rx_init, "aacraid", "ADAPTEC ", "AAR-2610SA ", 1 }, /* SATA 6Ch (Bearcat) */
176 { aac_rx_init, "aacraid", "ADAPTEC ", "ASR-2240S ", 1 }, /* ASR-2240S (SabreExpress) */
177 { aac_rx_init, "aacraid", "ADAPTEC ", "ASR-4005SAS ", 1 }, /* ASR-4005SAS */
178 { aac_rx_init, "aacraid", "IBM ", "ServeRAID 8i ", 1 }, /* IBM 8i (AvonPark) */
179 { aac_rx_init, "aacraid", "ADAPTEC ", "ASR-4000SAS ", 1 }, /* ASR-4000SAS (BlackBird & AvonPark) */
180 { aac_rx_init, "aacraid", "ADAPTEC ", "ASR-4800SAS ", 1 }, /* ASR-4800SAS (Marauder-X) */
181 { aac_rx_init, "aacraid", "ADAPTEC ", "ASR-4805SAS ", 1 }, /* ASR-4805SAS (Marauder-E) */
182
183 { aac_rx_init, "percraid", "DELL ", "PERC 320/DC ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* Perc 320/DC*/
184 { aac_sa_init, "aacraid", "ADAPTEC ", "Adaptec 5400S ", 4, AAC_QUIRK_34SG }, /* Adaptec 5400S (Mustang)*/
185 { aac_sa_init, "aacraid", "ADAPTEC ", "AAC-364 ", 4, AAC_QUIRK_34SG }, /* Adaptec 5400S (Mustang)*/
186 { aac_sa_init, "percraid", "DELL ", "PERCRAID ", 4, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* Dell PERC2/QC */
187 { aac_sa_init, "hpnraid", "HP ", "NetRAID ", 4, AAC_QUIRK_34SG }, /* HP NetRAID-4M */
188
189 { aac_rx_init, "aacraid", "DELL ", "RAID ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* Dell Catchall */
190 { aac_rx_init, "aacraid", "Legend ", "RAID ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* Legend Catchall */
191 { aac_rx_init, "aacraid", "ADAPTEC ", "RAID ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* Adaptec Catch All */
192 { aac_rkt_init, "aacraid", "ADAPTEC ", "RAID ", 2 } /* Adaptec Rocket Catch All */
193};
194
195/**
196 * aac_queuecommand - queue a SCSI command
197 * @cmd: SCSI command to queue
198 * @done: Function to call on command completion
199 *
200 * Queues a command for execution by the associated Host Adapter.
201 *
202 * TODO: unify with aac_scsi_cmd().
203 */
204
205static int aac_queuecommand(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
206{
207 cmd->scsi_done = done;
208 return (aac_scsi_cmd(cmd) ? FAILED : 0);
209}
210
211/**
212 * aac_info - Returns the host adapter name
213 * @shost: Scsi host to report on
214 *
215 * Returns a static string describing the device in question
216 */
217
218const char *aac_info(struct Scsi_Host *shost)
219{
220 struct aac_dev *dev = (struct aac_dev *)shost->hostdata;
221 return aac_drivers[dev->cardtype].name;
222}
223
224/**
225 * aac_get_driver_ident
226 * @devtype: index into lookup table
227 *
228 * Returns a pointer to the entry in the driver lookup table.
229 */
230
231struct aac_driver_ident* aac_get_driver_ident(int devtype)
232{
233 return &aac_drivers[devtype];
234}
235
236/**
237 * aac_biosparm - return BIOS parameters for disk
238 * @sdev: The scsi device corresponding to the disk
239 * @bdev: the block device corresponding to the disk
240 * @capacity: the sector capacity of the disk
241 * @geom: geometry block to fill in
242 *
243 * Return the Heads/Sectors/Cylinders BIOS Disk Parameters for Disk.
244 * The default disk geometry is 64 heads, 32 sectors, and the appropriate
245 * number of cylinders so as not to exceed drive capacity. In order for
246 * disks equal to or larger than 1 GB to be addressable by the BIOS
247 * without exceeding the BIOS limitation of 1024 cylinders, Extended
248 * Translation should be enabled. With Extended Translation enabled,
249 * drives between 1 GB inclusive and 2 GB exclusive are given a disk
250 * geometry of 128 heads and 32 sectors, and drives above 2 GB inclusive
251 * are given a disk geometry of 255 heads and 63 sectors. However, if
252 * the BIOS detects that the Extended Translation setting does not match
253 * the geometry in the partition table, then the translation inferred
254 * from the partition table will be used by the BIOS, and a warning may
255 * be displayed.
256 */
257
258static int aac_biosparm(struct scsi_device *sdev, struct block_device *bdev,
259 sector_t capacity, int *geom)
260{
261 struct diskparm *param = (struct diskparm *)geom;
262 unsigned char *buf;
263
264 dprintk((KERN_DEBUG "aac_biosparm.\n"));
265
266 /*
267 * Assuming extended translation is enabled - #REVISIT#
268 */
269 if (capacity >= 2 * 1024 * 1024) { /* 1 GB in 512 byte sectors */
270 if(capacity >= 4 * 1024 * 1024) { /* 2 GB in 512 byte sectors */
271 param->heads = 255;
272 param->sectors = 63;
273 } else {
274 param->heads = 128;
275 param->sectors = 32;
276 }
277 } else {
278 param->heads = 64;
279 param->sectors = 32;
280 }
281
282 param->cylinders = cap_to_cyls(capacity, param->heads * param->sectors);
283
284 /*
285 * Read the first 1024 bytes from the disk device, if the boot
286 * sector partition table is valid, search for a partition table
287 * entry whose end_head matches one of the standard geometry
288 * translations ( 64/32, 128/32, 255/63 ).
289 */
290 buf = scsi_bios_ptable(bdev);
291 if(*(unsigned short *)(buf + 0x40) == cpu_to_le16(0xaa55)) {
292 struct partition *first = (struct partition * )buf;
293 struct partition *entry = first;
294 int saved_cylinders = param->cylinders;
295 int num;
296 unsigned char end_head, end_sec;
297
298 for(num = 0; num < 4; num++) {
299 end_head = entry->end_head;
300 end_sec = entry->end_sector & 0x3f;
301
302 if(end_head == 63) {
303 param->heads = 64;
304 param->sectors = 32;
305 break;
306 } else if(end_head == 127) {
307 param->heads = 128;
308 param->sectors = 32;
309 break;
310 } else if(end_head == 254) {
311 param->heads = 255;
312 param->sectors = 63;
313 break;
314 }
315 entry++;
316 }
317
318 if (num == 4) {
319 end_head = first->end_head;
320 end_sec = first->end_sector & 0x3f;
321 }
322
323 param->cylinders = cap_to_cyls(capacity, param->heads * param->sectors);
324 if (num < 4 && end_sec == param->sectors) {
325 if (param->cylinders != saved_cylinders)
326 dprintk((KERN_DEBUG "Adopting geometry: heads=%d, sectors=%d from partition table %d.\n",
327 param->heads, param->sectors, num));
328 } else if (end_head > 0 || end_sec > 0) {
329 dprintk((KERN_DEBUG "Strange geometry: heads=%d, sectors=%d in partition table %d.\n",
330 end_head + 1, end_sec, num));
331 dprintk((KERN_DEBUG "Using geometry: heads=%d, sectors=%d.\n",
332 param->heads, param->sectors));
333 }
334 }
335 kfree(buf);
336 return 0;
337}
338
339/**
340 * aac_slave_configure - compute queue depths
341 * @sdev: SCSI device we are considering
342 *
343 * Selects queue depths for each target device based on the host adapter's
344 * total capacity and the queue depth supported by the target device.
345 * A queue depth of one automatically disables tagged queueing.
346 */
347
348static int aac_slave_configure(struct scsi_device *sdev)
349{
350 if (sdev->tagged_supported)
351 scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, 128);
352 else
353 scsi_adjust_queue_depth(sdev, 0, 1);
354 return 0;
355}
356
357static int aac_ioctl(struct scsi_device *sdev, int cmd, void __user * arg)
358{
359 struct aac_dev *dev = (struct aac_dev *)sdev->host->hostdata;
360 return aac_do_ioctl(dev, cmd, arg);
361}
362
363/*
364 * XXX: does aac really need no error handling??
365 */
366static int aac_eh_abort(struct scsi_cmnd *cmd)
367{
368 return FAILED;
369}
370
371/*
372 * aac_eh_reset - Reset command handling
373 * @scsi_cmd: SCSI command block causing the reset
374 *
375 */
376static int aac_eh_reset(struct scsi_cmnd* cmd)
377{
378 struct scsi_device * dev = cmd->device;
379 struct Scsi_Host * host = dev->host;
380 struct scsi_cmnd * command;
381 int count;
382 struct aac_dev * aac;
383 unsigned long flags;
384
385 printk(KERN_ERR "%s: Host adapter reset request. SCSI hang ?\n",
386 AAC_DRIVERNAME);
387
388
389 aac = (struct aac_dev *)host->hostdata;
390 if (aac_adapter_check_health(aac)) {
391 printk(KERN_ERR "%s: Host adapter appears dead\n",
392 AAC_DRIVERNAME);
393 return -ENODEV;
394 }
395 /*
396 * Wait for all commands to complete to this specific
397 * target (block maximum 60 seconds).
398 */
399 for (count = 60; count; --count) {
400 int active = 0;
401 __shost_for_each_device(dev, host) {
402 spin_lock_irqsave(&dev->list_lock, flags);
403 list_for_each_entry(command, &dev->cmd_list, list) {
404 if (command->serial_number) {
405 active++;
406 break;
407 }
408 }
409 spin_unlock_irqrestore(&dev->list_lock, flags);
410 if (active)
411 break;
412
413 }
414 /*
415 * We can exit If all the commands are complete
416 */
417 if (active == 0)
418 return SUCCESS;
419 spin_unlock_irq(host->host_lock);
420 ssleep(1);
421 spin_lock_irq(host->host_lock);
422 }
423 printk(KERN_ERR "%s: SCSI bus appears hung\n", AAC_DRIVERNAME);
424 return -ETIMEDOUT;
425}
426
427/**
428 * aac_cfg_open - open a configuration file
429 * @inode: inode being opened
430 * @file: file handle attached
431 *
432 * Called when the configuration device is opened. Does the needed
433 * set up on the handle and then returns
434 *
435 * Bugs: This needs extending to check a given adapter is present
436 * so we can support hot plugging, and to ref count adapters.
437 */
438
439static int aac_cfg_open(struct inode *inode, struct file *file)
440{
441 struct aac_dev *aac;
442 unsigned minor = iminor(inode);
443 int err = -ENODEV;
444
445 list_for_each_entry(aac, &aac_devices, entry) {
446 if (aac->id == minor) {
447 file->private_data = aac;
448 err = 0;
449 break;
450 }
451 }
452
453 return 0;
454}
455
456/**
457 * aac_cfg_ioctl - AAC configuration request
458 * @inode: inode of device
459 * @file: file handle
460 * @cmd: ioctl command code
461 * @arg: argument
462 *
463 * Handles a configuration ioctl. Currently this involves wrapping it
464 * up and feeding it into the nasty windowsalike glue layer.
465 *
466 * Bugs: Needs locking against parallel ioctls lower down
467 * Bugs: Needs to handle hot plugging
468 */
469
470static int aac_cfg_ioctl(struct inode *inode, struct file *file,
471 unsigned int cmd, unsigned long arg)
472{
473 return aac_do_ioctl(file->private_data, cmd, (void __user *)arg);
474}
475
476#ifdef CONFIG_COMPAT
477static long aac_compat_do_ioctl(struct aac_dev *dev, unsigned cmd, unsigned long arg)
478{
479 long ret;
480 lock_kernel();
481 switch (cmd) {
482 case FSACTL_MINIPORT_REV_CHECK:
483 case FSACTL_SENDFIB:
484 case FSACTL_OPEN_GET_ADAPTER_FIB:
485 case FSACTL_CLOSE_GET_ADAPTER_FIB:
486 case FSACTL_SEND_RAW_SRB:
487 case FSACTL_GET_PCI_INFO:
488 case FSACTL_QUERY_DISK:
489 case FSACTL_DELETE_DISK:
490 case FSACTL_FORCE_DELETE_DISK:
491 case FSACTL_GET_CONTAINERS:
492 ret = aac_do_ioctl(dev, cmd, (void __user *)arg);
493 break;
494
495 case FSACTL_GET_NEXT_ADAPTER_FIB: {
496 struct fib_ioctl __user *f;
497
498 f = compat_alloc_user_space(sizeof(*f));
499 ret = 0;
500 if (clear_user(f, sizeof(*f) != sizeof(*f)))
501 ret = -EFAULT;
502 if (copy_in_user(f, (void __user *)arg, sizeof(struct fib_ioctl) - sizeof(u32)))
503 ret = -EFAULT;
504 if (!ret)
505 ret = aac_do_ioctl(dev, cmd, (void __user *)arg);
506 break;
507 }
508
509 default:
510 ret = -ENOIOCTLCMD;
511 break;
512 }
513 unlock_kernel();
514 return ret;
515}
516
517static int aac_compat_ioctl(struct scsi_device *sdev, int cmd, void __user *arg)
518{
519 struct aac_dev *dev = (struct aac_dev *)sdev->host->hostdata;
520 return aac_compat_do_ioctl(dev, cmd, (unsigned long)arg);
521}
522
523static long aac_compat_cfg_ioctl(struct file *file, unsigned cmd, unsigned long arg)
524{
525 return aac_compat_do_ioctl((struct aac_dev *)file->private_data, cmd, arg);
526}
527#endif
528
529static struct file_operations aac_cfg_fops = {
530 .owner = THIS_MODULE,
531 .ioctl = aac_cfg_ioctl,
532#ifdef CONFIG_COMPAT
533 .compat_ioctl = aac_compat_cfg_ioctl,
534#endif
535 .open = aac_cfg_open,
536};
537
538static struct scsi_host_template aac_driver_template = {
539 .module = THIS_MODULE,
540 .name = "AAC",
541 .proc_name = "aacraid",
542 .info = aac_info,
543 .ioctl = aac_ioctl,
544#ifdef CONFIG_COMPAT
545 .compat_ioctl = aac_compat_ioctl,
546#endif
547 .queuecommand = aac_queuecommand,
548 .bios_param = aac_biosparm,
549 .slave_configure = aac_slave_configure,
550 .eh_abort_handler = aac_eh_abort,
551 .eh_host_reset_handler = aac_eh_reset,
552 .can_queue = AAC_NUM_IO_FIB,
553 .this_id = 16,
554 .sg_tablesize = 16,
555 .max_sectors = 128,
556#if (AAC_NUM_IO_FIB > 256)
557 .cmd_per_lun = 256,
558#else
559 .cmd_per_lun = AAC_NUM_IO_FIB,
560#endif
561 .use_clustering = ENABLE_CLUSTERING,
562};
563
564
565static int __devinit aac_probe_one(struct pci_dev *pdev,
566 const struct pci_device_id *id)
567{
568 unsigned index = id->driver_data;
569 struct Scsi_Host *shost;
570 struct aac_dev *aac;
571 struct list_head *insert = &aac_devices;
572 int error = -ENODEV;
573 int unique_id = 0;
574
575 list_for_each_entry(aac, &aac_devices, entry) {
576 if (aac->id > unique_id)
577 break;
578 insert = &aac->entry;
579 unique_id++;
580 }
581
582 if (pci_enable_device(pdev))
583 goto out;
584
585 if (pci_set_dma_mask(pdev, 0xFFFFFFFFULL) ||
586 pci_set_consistent_dma_mask(pdev, 0xFFFFFFFFULL))
587 goto out;
588 /*
589 * If the quirk31 bit is set, the adapter needs adapter
590 * to driver communication memory to be allocated below 2gig
591 */
592 if (aac_drivers[index].quirks & AAC_QUIRK_31BIT)
593 if (pci_set_dma_mask(pdev, 0x7FFFFFFFULL) ||
594 pci_set_consistent_dma_mask(pdev, 0x7FFFFFFFULL))
595 goto out;
596
597 pci_set_master(pdev);
598
599 shost = scsi_host_alloc(&aac_driver_template, sizeof(struct aac_dev));
600 if (!shost)
601 goto out_disable_pdev;
602
603 shost->irq = pdev->irq;
604 shost->base = pci_resource_start(pdev, 0);
605 shost->unique_id = unique_id;
606
607 aac = (struct aac_dev *)shost->hostdata;
608 aac->scsi_host_ptr = shost;
609 aac->pdev = pdev;
610 aac->name = aac_driver_template.name;
611 aac->id = shost->unique_id;
612 aac->cardtype = index;
613 INIT_LIST_HEAD(&aac->entry);
614
615 aac->fibs = kmalloc(sizeof(struct fib) * AAC_NUM_FIB, GFP_KERNEL);
616 if (!aac->fibs)
617 goto out_free_host;
618 spin_lock_init(&aac->fib_lock);
619
620 if ((*aac_drivers[index].init)(aac))
621 goto out_free_fibs;
622
623 /*
624 * If we had set a smaller DMA mask earlier, set it to 4gig
625 * now since the adapter can dma data to at least a 4gig
626 * address space.
627 */
628 if (aac_drivers[index].quirks & AAC_QUIRK_31BIT)
629 if (pci_set_dma_mask(pdev, 0xFFFFFFFFULL))
630 goto out_free_fibs;
631
632 aac_get_adapter_info(aac);
633
634 /*
635 * max channel will be the physical channels plus 1 virtual channel
636 * all containers are on the virtual channel 0
637 * physical channels are address by their actual physical number+1
638 */
639 if (aac->nondasd_support == 1)
640 shost->max_channel = aac_drivers[index].channels+1;
641 else
642 shost->max_channel = 1;
643
644 aac_get_config_status(aac);
645 aac_get_containers(aac);
646 list_add(&aac->entry, insert);
647
648 shost->max_id = aac->maximum_num_containers;
649 if (shost->max_id < MAXIMUM_NUM_CONTAINERS)
650 shost->max_id = MAXIMUM_NUM_CONTAINERS;
651 else
652 shost->this_id = shost->max_id;
653
654 /*
655 * dmb - we may need to move the setting of these parms somewhere else once
656 * we get a fib that can report the actual numbers
657 */
658 shost->max_lun = AAC_MAX_LUN;
659
660 pci_set_drvdata(pdev, shost);
661
662 error = scsi_add_host(shost, &pdev->dev);
663 if (error)
664 goto out_deinit;
665 scsi_scan_host(shost);
666
667 return 0;
668
669out_deinit:
670 kill_proc(aac->thread_pid, SIGKILL, 0);
671 wait_for_completion(&aac->aif_completion);
672
673 aac_send_shutdown(aac);
674 fib_map_free(aac);
675 pci_free_consistent(aac->pdev, aac->comm_size, aac->comm_addr, aac->comm_phys);
676 kfree(aac->queues);
677 free_irq(pdev->irq, aac);
678 iounmap(aac->regs.sa);
679 out_free_fibs:
680 kfree(aac->fibs);
681 kfree(aac->fsa_dev);
682 out_free_host:
683 scsi_host_put(shost);
684 out_disable_pdev:
685 pci_disable_device(pdev);
686 out:
687 return error;
688}
689
690static void __devexit aac_remove_one(struct pci_dev *pdev)
691{
692 struct Scsi_Host *shost = pci_get_drvdata(pdev);
693 struct aac_dev *aac = (struct aac_dev *)shost->hostdata;
694
695 scsi_remove_host(shost);
696
697 kill_proc(aac->thread_pid, SIGKILL, 0);
698 wait_for_completion(&aac->aif_completion);
699
700 aac_send_shutdown(aac);
701 fib_map_free(aac);
702 pci_free_consistent(aac->pdev, aac->comm_size, aac->comm_addr,
703 aac->comm_phys);
704 kfree(aac->queues);
705
706 free_irq(pdev->irq, aac);
707 iounmap(aac->regs.sa);
708
709 kfree(aac->fibs);
710
711 list_del(&aac->entry);
712 scsi_host_put(shost);
713 pci_disable_device(pdev);
714}
715
716static struct pci_driver aac_pci_driver = {
717 .name = AAC_DRIVERNAME,
718 .id_table = aac_pci_tbl,
719 .probe = aac_probe_one,
720 .remove = __devexit_p(aac_remove_one),
721};
722
723static int __init aac_init(void)
724{
725 int error;
726
727 printk(KERN_INFO "Red Hat/Adaptec aacraid driver (%s %s)\n",
728 AAC_DRIVER_VERSION, AAC_DRIVER_BUILD_DATE);
729
730 error = pci_module_init(&aac_pci_driver);
731 if (error)
732 return error;
733
734 aac_cfg_major = register_chrdev( 0, "aac", &aac_cfg_fops);
735 if (aac_cfg_major < 0) {
736 printk(KERN_WARNING
737 "aacraid: unable to register \"aac\" device.\n");
738 }
739 return 0;
740}
741
742static void __exit aac_exit(void)
743{
744 unregister_chrdev(aac_cfg_major, "aac");
745 pci_unregister_driver(&aac_pci_driver);
746}
747
748module_init(aac_init);
749module_exit(aac_exit);
Linux 6.x block layer and io_uring tree(s)