projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[SCSI] add global timeout to the scsi mid-layer
[deliverable/linux.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
c7f47602
MH		 30#define AAC_DRIVER_VERSION "1.1-4"
31#ifndef AAC_DRIVER_BRANCH
32#define AAC_DRIVER_BRANCH ""
33#endif
34#define AAC_DRIVER_BUILD_DATE __DATE__ " " __TIME__
1da177e4
LT		 35#define AAC_DRIVERNAME "aacraid"
36
37#include <linux/compat.h>
38#include <linux/blkdev.h>
39#include <linux/completion.h>
40#include <linux/init.h>
41#include <linux/interrupt.h>
42#include <linux/kernel.h>
43#include <linux/module.h>
44#include <linux/moduleparam.h>
45#include <linux/pci.h>
46#include <linux/slab.h>
47#include <linux/spinlock.h>
48#include <linux/syscalls.h>
49#include <linux/ioctl32.h>
50#include <linux/delay.h>
51#include <linux/smp_lock.h>
52#include <asm/semaphore.h>
53
54#include <scsi/scsi.h>
55#include <scsi/scsi_cmnd.h>
56#include <scsi/scsi_device.h>
57#include <scsi/scsi_host.h>
58#include <scsi/scsi_tcq.h>
59#include <scsi/scsicam.h>
60#include <scsi/scsi_eh.h>
61
62#include "aacraid.h"
63
c7f47602
MH		 64#ifdef AAC_DRIVER_BUILD
65#define _str(x) #x
66#define str(x) _str(x)
67#define AAC_DRIVER_FULL_VERSION AAC_DRIVER_VERSION "[" str(AAC_DRIVER_BUILD) "]" AAC_DRIVER_BRANCH
68#else
69#define AAC_DRIVER_FULL_VERSION AAC_DRIVER_VERSION AAC_DRIVER_BRANCH " " AAC_DRIVER_BUILD_DATE
70#endif
1da177e4
LT		 71
72MODULE_AUTHOR("Red Hat Inc and Adaptec");
73MODULE_DESCRIPTION("Dell PERC2, 2/Si, 3/Si, 3/Di, "
74 "Adaptec Advanced Raid Products, "
75 "and HP NetRAID-4M SCSI driver");
76MODULE_LICENSE("GPL");
c7f47602 77MODULE_VERSION(AAC_DRIVER_FULL_VERSION);
1da177e4
LT		 78
79static LIST_HEAD(aac_devices);
80static int aac_cfg_major = -1;
c7f47602 81char aac_driver_version[] = AAC_DRIVER_FULL_VERSION;
1da177e4
LT		 82
83/*
84 * Because of the way Linux names scsi devices, the order in this table has
85 * become important. Check for on-board Raid first, add-in cards second.
86 *
87 * Note: The last field is used to index into aac_drivers below.
88 */
89static struct pci_device_id aac_pci_tbl[] = {
90 { 0x1028, 0x0001, 0x1028, 0x0001, 0, 0, 0 }, /* PERC 2/Si (Iguana/PERC2Si) */
91 { 0x1028, 0x0002, 0x1028, 0x0002, 0, 0, 1 }, /* PERC 3/Di (Opal/PERC3Di) */
92 { 0x1028, 0x0003, 0x1028, 0x0003, 0, 0, 2 }, /* PERC 3/Si (SlimFast/PERC3Si */
93 { 0x1028, 0x0004, 0x1028, 0x00d0, 0, 0, 3 }, /* PERC 3/Di (Iguana FlipChip/PERC3DiF */
94 { 0x1028, 0x0002, 0x1028, 0x00d1, 0, 0, 4 }, /* PERC 3/Di (Viper/PERC3DiV) */
95 { 0x1028, 0x0002, 0x1028, 0x00d9, 0, 0, 5 }, /* PERC 3/Di (Lexus/PERC3DiL) */
96 { 0x1028, 0x000a, 0x1028, 0x0106, 0, 0, 6 }, /* PERC 3/Di (Jaguar/PERC3DiJ) */
97 { 0x1028, 0x000a, 0x1028, 0x011b, 0, 0, 7 }, /* PERC 3/Di (Dagger/PERC3DiD) */
98 { 0x1028, 0x000a, 0x1028, 0x0121, 0, 0, 8 }, /* PERC 3/Di (Boxster/PERC3DiB) */
99 { 0x9005, 0x0283, 0x9005, 0x0283, 0, 0, 9 }, /* catapult */
100 { 0x9005, 0x0284, 0x9005, 0x0284, 0, 0, 10 }, /* tomcat */
101 { 0x9005, 0x0285, 0x9005, 0x0286, 0, 0, 11 }, /* Adaptec 2120S (Crusader) */
102 { 0x9005, 0x0285, 0x9005, 0x0285, 0, 0, 12 }, /* Adaptec 2200S (Vulcan) */
103 { 0x9005, 0x0285, 0x9005, 0x0287, 0, 0, 13 }, /* Adaptec 2200S (Vulcan-2m) */
104 { 0x9005, 0x0285, 0x17aa, 0x0286, 0, 0, 14 }, /* Legend S220 (Legend Crusader) */
105 { 0x9005, 0x0285, 0x17aa, 0x0287, 0, 0, 15 }, /* Legend S230 (Legend Vulcan) */
106
107 { 0x9005, 0x0285, 0x9005, 0x0288, 0, 0, 16 }, /* Adaptec 3230S (Harrier) */
108 { 0x9005, 0x0285, 0x9005, 0x0289, 0, 0, 17 }, /* Adaptec 3240S (Tornado) */
109 { 0x9005, 0x0285, 0x9005, 0x028a, 0, 0, 18 }, /* ASR-2020ZCR SCSI PCI-X ZCR (Skyhawk) */
110 { 0x9005, 0x0285, 0x9005, 0x028b, 0, 0, 19 }, /* ASR-2025ZCR SCSI SO-DIMM PCI-X ZCR (Terminator) */
111 { 0x9005, 0x0286, 0x9005, 0x028c, 0, 0, 20 }, /* ASR-2230S + ASR-2230SLP PCI-X (Lancer) */
112 { 0x9005, 0x0286, 0x9005, 0x028d, 0, 0, 21 }, /* ASR-2130S (Lancer) */
113 { 0x9005, 0x0286, 0x9005, 0x029b, 0, 0, 22 }, /* AAR-2820SA (Intruder) */
114 { 0x9005, 0x0286, 0x9005, 0x029c, 0, 0, 23 }, /* AAR-2620SA (Intruder) */
115 { 0x9005, 0x0286, 0x9005, 0x029d, 0, 0, 24 }, /* AAR-2420SA (Intruder) */
84971738
MH		 116 { 0x9005, 0x0286, 0x9005, 0x029e, 0, 0, 25 }, /* ICP9024R0 (Lancer) */
117 { 0x9005, 0x0286, 0x9005, 0x029f, 0, 0, 26 }, /* ICP9014R0 (Lancer) */
118 { 0x9005, 0x0286, 0x9005, 0x02a0, 0, 0, 27 }, /* ICP9047MA (Lancer) */
119 { 0x9005, 0x0286, 0x9005, 0x02a1, 0, 0, 28 }, /* ICP9087MA (Lancer) */
120 { 0x9005, 0x0286, 0x9005, 0x02a3, 0, 0, 29 }, /* ICP5085AU (Hurricane) */
121 { 0x9005, 0x0285, 0x9005, 0x02a4, 0, 0, 30 }, /* ICP9085LI (Marauder-X) */
122 { 0x9005, 0x0285, 0x9005, 0x02a5, 0, 0, 31 }, /* ICP5085BR (Marauder-E) */
123 { 0x9005, 0x0287, 0x9005, 0x0800, 0, 0, 32 }, /* Themisto Jupiter Platform */
124 { 0x9005, 0x0200, 0x9005, 0x0200, 0, 0, 32 }, /* Themisto Jupiter Platform */
125 { 0x9005, 0x0286, 0x9005, 0x0800, 0, 0, 33 }, /* Callisto Jupiter Platform */
126 { 0x9005, 0x0285, 0x9005, 0x028e, 0, 0, 34 }, /* ASR-2020SA SATA PCI-X ZCR (Skyhawk) */
127 { 0x9005, 0x0285, 0x9005, 0x028f, 0, 0, 35 }, /* ASR-2025SA SATA SO-DIMM PCI-X ZCR (Terminator) */
128 { 0x9005, 0x0285, 0x9005, 0x0290, 0, 0, 36 }, /* AAR-2410SA PCI SATA 4ch (Jaguar II) */
129 { 0x9005, 0x0285, 0x1028, 0x0291, 0, 0, 37 }, /* CERC SATA RAID 2 PCI SATA 6ch (DellCorsair) */
130 { 0x9005, 0x0285, 0x9005, 0x0292, 0, 0, 38 }, /* AAR-2810SA PCI SATA 8ch (Corsair-8) */
131 { 0x9005, 0x0285, 0x9005, 0x0293, 0, 0, 39 }, /* AAR-21610SA PCI SATA 16ch (Corsair-16) */
132 { 0x9005, 0x0285, 0x9005, 0x0294, 0, 0, 40 }, /* ESD SO-DIMM PCI-X SATA ZCR (Prowler) */
133 { 0x9005, 0x0285, 0x103C, 0x3227, 0, 0, 41 }, /* AAR-2610SA PCI SATA 6ch */
134 { 0x9005, 0x0285, 0x9005, 0x0296, 0, 0, 42 }, /* ASR-2240S (SabreExpress) */
135 { 0x9005, 0x0285, 0x9005, 0x0297, 0, 0, 43 }, /* ASR-4005SAS */
136 { 0x9005, 0x0285, 0x1014, 0x02F2, 0, 0, 44 }, /* IBM 8i (AvonPark) */
137 { 0x9005, 0x0285, 0x1014, 0x0312, 0, 0, 44 }, /* IBM 8i (AvonPark Lite) */
138 { 0x9005, 0x0285, 0x9005, 0x0298, 0, 0, 45 }, /* ASR-4000SAS (BlackBird) */
139 { 0x9005, 0x0285, 0x9005, 0x0299, 0, 0, 46 }, /* ASR-4800SAS (Marauder-X) */
140 { 0x9005, 0x0285, 0x9005, 0x029a, 0, 0, 47 }, /* ASR-4805SAS (Marauder-E) */
141 { 0x9005, 0x0286, 0x9005, 0x02a2, 0, 0, 48 }, /* ASR-4810SAS (Hurricane */
142
143 { 0x9005, 0x0285, 0x1028, 0x0287, 0, 0, 49 }, /* Perc 320/DC*/
144 { 0x1011, 0x0046, 0x9005, 0x0365, 0, 0, 50 }, /* Adaptec 5400S (Mustang)*/
145 { 0x1011, 0x0046, 0x9005, 0x0364, 0, 0, 51 }, /* Adaptec 5400S (Mustang)*/
146 { 0x1011, 0x0046, 0x9005, 0x1364, 0, 0, 52 }, /* Dell PERC2/QC */
147 { 0x1011, 0x0046, 0x103c, 0x10c2, 0, 0, 53 }, /* HP NetRAID-4M */
148
149 { 0x9005, 0x0285, 0x1028, PCI_ANY_ID, 0, 0, 54 }, /* Dell Catchall */
150 { 0x9005, 0x0285, 0x17aa, PCI_ANY_ID, 0, 0, 55 }, /* Legend Catchall */
151 { 0x9005, 0x0285, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 56 }, /* Adaptec Catch All */
152 { 0x9005, 0x0286, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 57 }, /* Adaptec Rocket Catch All */
1da177e4
LT		 153 { 0,}
154};
155MODULE_DEVICE_TABLE(pci, aac_pci_tbl);
156
157/*
158 * dmb - For now we add the number of channels to this structure.
159 * In the future we should add a fib that reports the number of channels
160 * for the card. At that time we can remove the channels from here
161 */
162static struct aac_driver_ident aac_drivers[] = {
163 { aac_rx_init, "percraid", "DELL ", "PERCRAID ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* PERC 2/Si (Iguana/PERC2Si) */
164 { aac_rx_init, "percraid", "DELL ", "PERCRAID ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* PERC 3/Di (Opal/PERC3Di) */
165 { aac_rx_init, "percraid", "DELL ", "PERCRAID ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* PERC 3/Si (SlimFast/PERC3Si */
166 { aac_rx_init, "percraid", "DELL ", "PERCRAID ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* PERC 3/Di (Iguana FlipChip/PERC3DiF */
167 { aac_rx_init, "percraid", "DELL ", "PERCRAID ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* PERC 3/Di (Viper/PERC3DiV) */
168 { aac_rx_init, "percraid", "DELL ", "PERCRAID ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* PERC 3/Di (Lexus/PERC3DiL) */
169 { aac_rx_init, "percraid", "DELL ", "PERCRAID ", 1, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* PERC 3/Di (Jaguar/PERC3DiJ) */
170 { aac_rx_init, "percraid", "DELL ", "PERCRAID ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* PERC 3/Di (Dagger/PERC3DiD) */
171 { aac_rx_init, "percraid", "DELL ", "PERCRAID ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* PERC 3/Di (Boxster/PERC3DiB) */
172 { aac_rx_init, "aacraid", "ADAPTEC ", "catapult ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* catapult */
173 { aac_rx_init, "aacraid", "ADAPTEC ", "tomcat ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* tomcat */
174 { aac_rx_init, "aacraid", "ADAPTEC ", "Adaptec 2120S ", 1, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* Adaptec 2120S (Crusader) */
175 { aac_rx_init, "aacraid", "ADAPTEC ", "Adaptec 2200S ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* Adaptec 2200S (Vulcan) */
176 { aac_rx_init, "aacraid", "ADAPTEC ", "Adaptec 2200S ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* Adaptec 2200S (Vulcan-2m) */
177 { aac_rx_init, "aacraid", "Legend ", "Legend S220 ", 1, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* Legend S220 (Legend Crusader) */
178 { aac_rx_init, "aacraid", "Legend ", "Legend S230 ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* Legend S230 (Legend Vulcan) */
179
180 { aac_rx_init, "aacraid", "ADAPTEC ", "Adaptec 3230S ", 2 }, /* Adaptec 3230S (Harrier) */
181 { aac_rx_init, "aacraid", "ADAPTEC ", "Adaptec 3240S ", 2 }, /* Adaptec 3240S (Tornado) */
182 { aac_rx_init, "aacraid", "ADAPTEC ", "ASR-2020ZCR ", 2 }, /* ASR-2020ZCR SCSI PCI-X ZCR (Skyhawk) */
183 { aac_rx_init, "aacraid", "ADAPTEC ", "ASR-2025ZCR ", 2 }, /* ASR-2025ZCR SCSI SO-DIMM PCI-X ZCR (Terminator) */
184 { aac_rkt_init, "aacraid", "ADAPTEC ", "ASR-2230S PCI-X ", 2 }, /* ASR-2230S + ASR-2230SLP PCI-X (Lancer) */
185 { aac_rkt_init, "aacraid", "ADAPTEC ", "ASR-2130S PCI-X ", 1 }, /* ASR-2130S (Lancer) */
186 { aac_rkt_init, "aacraid", "ADAPTEC ", "AAR-2820SA ", 1 }, /* AAR-2820SA (Intruder) */
187 { aac_rkt_init, "aacraid", "ADAPTEC ", "AAR-2620SA ", 1 }, /* AAR-2620SA (Intruder) */
188 { aac_rkt_init, "aacraid", "ADAPTEC ", "AAR-2420SA ", 1 }, /* AAR-2420SA (Intruder) */
84971738
MH		 189 { aac_rkt_init, "aacraid", "ICP ", "ICP9024R0 ", 2 }, /* ICP9024R0 (Lancer) */
190 { aac_rkt_init, "aacraid", "ICP ", "ICP9014R0 ", 1 }, /* ICP9014R0 (Lancer) */
191 { aac_rkt_init, "aacraid", "ICP ", "ICP9047MA ", 1 }, /* ICP9047MA (Lancer) */
192 { aac_rkt_init, "aacraid", "ICP ", "ICP9087MA ", 1 }, /* ICP9087MA (Lancer) */
193 { aac_rkt_init, "aacraid", "ICP ", "ICP5085AU ", 1 }, /* ICP5085AU (Hurricane) */
194 { aac_rkt_init, "aacraid", "ICP ", "ICP9085LI ", 1 }, /* ICP9085LI (Marauder-X) */
195 { aac_rkt_init, "aacraid", "ICP ", "ICP5085BR ", 1 }, /* ICP5085BR (Marauder-E) */
196 { NULL , "aacraid", "ADAPTEC ", "Themisto ", 0, AAC_QUIRK_SLAVE }, /* Jupiter Platform */
1da177e4
LT		 197 { aac_rkt_init, "aacraid", "ADAPTEC ", "Callisto ", 2, AAC_QUIRK_MASTER }, /* Jupiter Platform */
198 { aac_rx_init, "aacraid", "ADAPTEC ", "ASR-2020SA ", 1 }, /* ASR-2020SA SATA PCI-X ZCR (Skyhawk) */
199 { aac_rx_init, "aacraid", "ADAPTEC ", "ASR-2025SA ", 1 }, /* ASR-2025SA SATA SO-DIMM PCI-X ZCR (Terminator) */
200 { aac_rx_init, "aacraid", "ADAPTEC ", "AAR-2410SA SATA ", 1 }, /* AAR-2410SA PCI SATA 4ch (Jaguar II) */
201 { aac_rx_init, "aacraid", "DELL ", "CERC SR2 ", 1 }, /* CERC SATA RAID 2 PCI SATA 6ch (DellCorsair) */
202 { aac_rx_init, "aacraid", "ADAPTEC ", "AAR-2810SA SATA ", 1 }, /* AAR-2810SA PCI SATA 8ch (Corsair-8) */
203 { aac_rx_init, "aacraid", "ADAPTEC ", "AAR-21610SA SATA", 1 }, /* AAR-21610SA PCI SATA 16ch (Corsair-16) */
204 { aac_rx_init, "aacraid", "ADAPTEC ", "ASR-2026ZCR ", 1 }, /* ESD SO-DIMM PCI-X SATA ZCR (Prowler) */
205 { aac_rx_init, "aacraid", "ADAPTEC ", "AAR-2610SA ", 1 }, /* SATA 6Ch (Bearcat) */
206 { aac_rx_init, "aacraid", "ADAPTEC ", "ASR-2240S ", 1 }, /* ASR-2240S (SabreExpress) */
207 { aac_rx_init, "aacraid", "ADAPTEC ", "ASR-4005SAS ", 1 }, /* ASR-4005SAS */
84971738 208 { aac_rx_init, "ServeRAID","IBM ", "ServeRAID 8i ", 1 }, /* IBM 8i (AvonPark) */
1da177e4
LT		 209 { aac_rx_init, "aacraid", "ADAPTEC ", "ASR-4000SAS ", 1 }, /* ASR-4000SAS (BlackBird & AvonPark) */
210 { aac_rx_init, "aacraid", "ADAPTEC ", "ASR-4800SAS ", 1 }, /* ASR-4800SAS (Marauder-X) */
211 { aac_rx_init, "aacraid", "ADAPTEC ", "ASR-4805SAS ", 1 }, /* ASR-4805SAS (Marauder-E) */
84971738 212 { aac_rx_init, "aacraid", "ADAPTEC ", "ASR-4810SAS ", 1 }, /* ASR-4810SAS (Hurricane) */
1da177e4
LT		 213
214 { aac_rx_init, "percraid", "DELL ", "PERC 320/DC ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* Perc 320/DC*/
215 { aac_sa_init, "aacraid", "ADAPTEC ", "Adaptec 5400S ", 4, AAC_QUIRK_34SG }, /* Adaptec 5400S (Mustang)*/
216 { aac_sa_init, "aacraid", "ADAPTEC ", "AAC-364 ", 4, AAC_QUIRK_34SG }, /* Adaptec 5400S (Mustang)*/
217 { aac_sa_init, "percraid", "DELL ", "PERCRAID ", 4, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* Dell PERC2/QC */
218 { aac_sa_init, "hpnraid", "HP ", "NetRAID ", 4, AAC_QUIRK_34SG }, /* HP NetRAID-4M */
219
220 { aac_rx_init, "aacraid", "DELL ", "RAID ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* Dell Catchall */
221 { aac_rx_init, "aacraid", "Legend ", "RAID ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* Legend Catchall */
222 { aac_rx_init, "aacraid", "ADAPTEC ", "RAID ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* Adaptec Catch All */
223 { aac_rkt_init, "aacraid", "ADAPTEC ", "RAID ", 2 } /* Adaptec Rocket Catch All */
224};
225
226/**
227 * aac_queuecommand - queue a SCSI command
228 * @cmd: SCSI command to queue
229 * @done: Function to call on command completion
230 *
231 * Queues a command for execution by the associated Host Adapter.
232 *
233 * TODO: unify with aac_scsi_cmd().
234 */
235
236static int aac_queuecommand(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
237{
238 cmd->scsi_done = done;
239 return (aac_scsi_cmd(cmd) ? FAILED : 0);
240}
241
242/**
243 * aac_info - Returns the host adapter name
244 * @shost: Scsi host to report on
245 *
246 * Returns a static string describing the device in question
247 */
248
4833869e 249static const char *aac_info(struct Scsi_Host *shost)
1da177e4
LT		 250{
251 struct aac_dev *dev = (struct aac_dev *)shost->hostdata;
252 return aac_drivers[dev->cardtype].name;
253}
254
255/**
256 * aac_get_driver_ident
257 * @devtype: index into lookup table
258 *
259 * Returns a pointer to the entry in the driver lookup table.
260 */
261
262struct aac_driver_ident* aac_get_driver_ident(int devtype)
263{
264 return &aac_drivers[devtype];
265}
266
267/**
268 * aac_biosparm - return BIOS parameters for disk
269 * @sdev: The scsi device corresponding to the disk
270 * @bdev: the block device corresponding to the disk
271 * @capacity: the sector capacity of the disk
272 * @geom: geometry block to fill in
273 *
274 * Return the Heads/Sectors/Cylinders BIOS Disk Parameters for Disk.
275 * The default disk geometry is 64 heads, 32 sectors, and the appropriate
276 * number of cylinders so as not to exceed drive capacity. In order for
277 * disks equal to or larger than 1 GB to be addressable by the BIOS
278 * without exceeding the BIOS limitation of 1024 cylinders, Extended
279 * Translation should be enabled. With Extended Translation enabled,
280 * drives between 1 GB inclusive and 2 GB exclusive are given a disk
281 * geometry of 128 heads and 32 sectors, and drives above 2 GB inclusive
282 * are given a disk geometry of 255 heads and 63 sectors. However, if
283 * the BIOS detects that the Extended Translation setting does not match
284 * the geometry in the partition table, then the translation inferred
285 * from the partition table will be used by the BIOS, and a warning may
286 * be displayed.
287 */
288
289static int aac_biosparm(struct scsi_device *sdev, struct block_device *bdev,
290 sector_t capacity, int *geom)
291{
292 struct diskparm *param = (struct diskparm *)geom;
293 unsigned char *buf;
294
295 dprintk((KERN_DEBUG "aac_biosparm.\n"));
296
297 /*
298 * Assuming extended translation is enabled - #REVISIT#
299 */
300 if (capacity >= 2 * 1024 * 1024) { /* 1 GB in 512 byte sectors */
301 if(capacity >= 4 * 1024 * 1024) { /* 2 GB in 512 byte sectors */
302 param->heads = 255;
303 param->sectors = 63;
304 } else {
305 param->heads = 128;
306 param->sectors = 32;
307 }
308 } else {
309 param->heads = 64;
310 param->sectors = 32;
311 }
312
313 param->cylinders = cap_to_cyls(capacity, param->heads * param->sectors);
314
315 /*
316 * Read the first 1024 bytes from the disk device, if the boot
317 * sector partition table is valid, search for a partition table
318 * entry whose end_head matches one of the standard geometry
319 * translations ( 64/32, 128/32, 255/63 ).
320 */
321 buf = scsi_bios_ptable(bdev);
56b58712 322 if(*(__le16 *)(buf + 0x40) == cpu_to_le16(0xaa55)) {
1da177e4
LT		 323 struct partition *first = (struct partition * )buf;
324 struct partition *entry = first;
325 int saved_cylinders = param->cylinders;
326 int num;
327 unsigned char end_head, end_sec;
328
329 for(num = 0; num < 4; num++) {
330 end_head = entry->end_head;
331 end_sec = entry->end_sector & 0x3f;
332
333 if(end_head == 63) {
334 param->heads = 64;
335 param->sectors = 32;
336 break;
337 } else if(end_head == 127) {
338 param->heads = 128;
339 param->sectors = 32;
340 break;
341 } else if(end_head == 254) {
342 param->heads = 255;
343 param->sectors = 63;
344 break;
345 }
346 entry++;
347 }
348
349 if (num == 4) {
350 end_head = first->end_head;
351 end_sec = first->end_sector & 0x3f;
352 }
353
354 param->cylinders = cap_to_cyls(capacity, param->heads * param->sectors);
355 if (num < 4 && end_sec == param->sectors) {
356 if (param->cylinders != saved_cylinders)
357 dprintk((KERN_DEBUG "Adopting geometry: heads=%d, sectors=%d from partition table %d.\n",
358 param->heads, param->sectors, num));
359 } else if (end_head > 0 || end_sec > 0) {
360 dprintk((KERN_DEBUG "Strange geometry: heads=%d, sectors=%d in partition table %d.\n",
361 end_head + 1, end_sec, num));
362 dprintk((KERN_DEBUG "Using geometry: heads=%d, sectors=%d.\n",
363 param->heads, param->sectors));
364 }
365 }
366 kfree(buf);
367 return 0;
368}
369
370/**
371 * aac_slave_configure - compute queue depths
372 * @sdev: SCSI device we are considering
373 *
374 * Selects queue depths for each target device based on the host adapter's
375 * total capacity and the queue depth supported by the target device.
376 * A queue depth of one automatically disables tagged queueing.
377 */
378
379static int aac_slave_configure(struct scsi_device *sdev)
380{
7c00ffa3
MH		 381 struct Scsi_Host *host = sdev->host;
382
1da177e4
LT		 383 if (sdev->tagged_supported)
384 scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, 128);
385 else
386 scsi_adjust_queue_depth(sdev, 0, 1);
7c00ffa3
MH		 387
388 if (host->max_sectors < AAC_MAX_32BIT_SGBCOUNT)
389 blk_queue_max_segment_size(sdev->request_queue, 65536);
390
1da177e4
LT		 391 return 0;
392}
393
394static int aac_ioctl(struct scsi_device *sdev, int cmd, void __user * arg)
395{
396 struct aac_dev *dev = (struct aac_dev *)sdev->host->hostdata;
397 return aac_do_ioctl(dev, cmd, arg);
398}
399
1da177e4
LT		 400/*
401 * aac_eh_reset - Reset command handling
402 * @scsi_cmd: SCSI command block causing the reset
403 *
404 */
405static int aac_eh_reset(struct scsi_cmnd* cmd)
406{
407 struct scsi_device * dev = cmd->device;
408 struct Scsi_Host * host = dev->host;
409 struct scsi_cmnd * command;
410 int count;
411 struct aac_dev * aac;
412 unsigned long flags;
413
414 printk(KERN_ERR "%s: Host adapter reset request. SCSI hang ?\n",
415 AAC_DRIVERNAME);
416
417
df0ae249
JG		 418 spin_lock_irq(host->host_lock);
419
1da177e4
LT		 420 aac = (struct aac_dev *)host->hostdata;
421 if (aac_adapter_check_health(aac)) {
422 printk(KERN_ERR "%s: Host adapter appears dead\n",
423 AAC_DRIVERNAME);
df0ae249 424 spin_unlock_irq(host->host_lock);
1da177e4
LT		 425 return -ENODEV;
426 }
427 /*
428 * Wait for all commands to complete to this specific
429 * target (block maximum 60 seconds).
430 */
431 for (count = 60; count; --count) {
432 int active = 0;
433 __shost_for_each_device(dev, host) {
434 spin_lock_irqsave(&dev->list_lock, flags);
435 list_for_each_entry(command, &dev->cmd_list, list) {
436 if (command->serial_number) {
437 active++;
438 break;
439 }
440 }
441 spin_unlock_irqrestore(&dev->list_lock, flags);
442 if (active)
443 break;
444
445 }
446 /*
447 * We can exit If all the commands are complete
448 */
449 if (active == 0)
450 return SUCCESS;
451 spin_unlock_irq(host->host_lock);
452 ssleep(1);
453 spin_lock_irq(host->host_lock);
454 }
df0ae249 455 spin_unlock_irq(host->host_lock);
1da177e4
LT		 456 printk(KERN_ERR "%s: SCSI bus appears hung\n", AAC_DRIVERNAME);
457 return -ETIMEDOUT;
458}
459
460/**
461 * aac_cfg_open - open a configuration file
462 * @inode: inode being opened
463 * @file: file handle attached
464 *
465 * Called when the configuration device is opened. Does the needed
466 * set up on the handle and then returns
467 *
468 * Bugs: This needs extending to check a given adapter is present
469 * so we can support hot plugging, and to ref count adapters.
470 */
471
472static int aac_cfg_open(struct inode *inode, struct file *file)
473{
474 struct aac_dev *aac;
7c00ffa3 475 unsigned minor_number = iminor(inode);
1da177e4
LT		 476 int err = -ENODEV;
477
478 list_for_each_entry(aac, &aac_devices, entry) {
7c00ffa3 479 if (aac->id == minor_number) {
1da177e4
LT		 480 file->private_data = aac;
481 err = 0;
482 break;
483 }
484 }
485
036d6184 486 return err;
1da177e4
LT		 487}
488
489/**
490 * aac_cfg_ioctl - AAC configuration request
491 * @inode: inode of device
492 * @file: file handle
493 * @cmd: ioctl command code
494 * @arg: argument
495 *
496 * Handles a configuration ioctl. Currently this involves wrapping it
497 * up and feeding it into the nasty windowsalike glue layer.
498 *
499 * Bugs: Needs locking against parallel ioctls lower down
500 * Bugs: Needs to handle hot plugging
501 */
502
503static int aac_cfg_ioctl(struct inode *inode, struct file *file,
504 unsigned int cmd, unsigned long arg)
505{
506 return aac_do_ioctl(file->private_data, cmd, (void __user *)arg);
507}
508
509#ifdef CONFIG_COMPAT
510static long aac_compat_do_ioctl(struct aac_dev *dev, unsigned cmd, unsigned long arg)
511{
512 long ret;
513 lock_kernel();
514 switch (cmd) {
515 case FSACTL_MINIPORT_REV_CHECK:
516 case FSACTL_SENDFIB:
517 case FSACTL_OPEN_GET_ADAPTER_FIB:
518 case FSACTL_CLOSE_GET_ADAPTER_FIB:
519 case FSACTL_SEND_RAW_SRB:
520 case FSACTL_GET_PCI_INFO:
521 case FSACTL_QUERY_DISK:
522 case FSACTL_DELETE_DISK:
523 case FSACTL_FORCE_DELETE_DISK:
524 case FSACTL_GET_CONTAINERS:
7c00ffa3 525 case FSACTL_SEND_LARGE_FIB:
1da177e4
LT		 526 ret = aac_do_ioctl(dev, cmd, (void __user *)arg);
527 break;
528
529 case FSACTL_GET_NEXT_ADAPTER_FIB: {
530 struct fib_ioctl __user *f;
531
532 f = compat_alloc_user_space(sizeof(*f));
533 ret = 0;
534 if (clear_user(f, sizeof(*f) != sizeof(*f)))
535 ret = -EFAULT;
536 if (copy_in_user(f, (void __user *)arg, sizeof(struct fib_ioctl) - sizeof(u32)))
537 ret = -EFAULT;
538 if (!ret)
539 ret = aac_do_ioctl(dev, cmd, (void __user *)arg);
540 break;
541 }
542
543 default:
544 ret = -ENOIOCTLCMD;
545 break;
546 }
547 unlock_kernel();
548 return ret;
549}
550
551static int aac_compat_ioctl(struct scsi_device *sdev, int cmd, void __user *arg)
552{
553 struct aac_dev *dev = (struct aac_dev *)sdev->host->hostdata;
554 return aac_compat_do_ioctl(dev, cmd, (unsigned long)arg);
555}
556
557static long aac_compat_cfg_ioctl(struct file *file, unsigned cmd, unsigned long arg)
558{
559 return aac_compat_do_ioctl((struct aac_dev *)file->private_data, cmd, arg);
560}
561#endif
562
0bb14afe
MH		 563static ssize_t aac_show_model(struct class_device *class_dev,
564 char *buf)
565{
566 struct aac_dev *dev = (struct aac_dev*)class_to_shost(class_dev)->hostdata;
567 int len;
568
569 len = snprintf(buf, PAGE_SIZE, "%s\n",
570 aac_drivers[dev->cardtype].model);
571 return len;
572}
573
574static ssize_t aac_show_vendor(struct class_device *class_dev,
575 char *buf)
576{
577 struct aac_dev *dev = (struct aac_dev*)class_to_shost(class_dev)->hostdata;
578 int len;
579
580 len = snprintf(buf, PAGE_SIZE, "%s\n",
581 aac_drivers[dev->cardtype].vname);
582 return len;
583}
584
585static ssize_t aac_show_kernel_version(struct class_device *class_dev,
586 char *buf)
587{
588 struct aac_dev *dev = (struct aac_dev*)class_to_shost(class_dev)->hostdata;
589 int len, tmp;
590
591 tmp = le32_to_cpu(dev->adapter_info.kernelrev);
592 len = snprintf(buf, PAGE_SIZE, "%d.%d-%d[%d]\n",
593 tmp >> 24, (tmp >> 16) & 0xff, tmp & 0xff,
594 le32_to_cpu(dev->adapter_info.kernelbuild));
595 return len;
596}
597
598static ssize_t aac_show_monitor_version(struct class_device *class_dev,
599 char *buf)
600{
601 struct aac_dev *dev = (struct aac_dev*)class_to_shost(class_dev)->hostdata;
602 int len, tmp;
603
604 tmp = le32_to_cpu(dev->adapter_info.monitorrev);
605 len = snprintf(buf, PAGE_SIZE, "%d.%d-%d[%d]\n",
606 tmp >> 24, (tmp >> 16) & 0xff, tmp & 0xff,
607 le32_to_cpu(dev->adapter_info.monitorbuild));
608 return len;
609}
610
611static ssize_t aac_show_bios_version(struct class_device *class_dev,
612 char *buf)
613{
614 struct aac_dev *dev = (struct aac_dev*)class_to_shost(class_dev)->hostdata;
615 int len, tmp;
616
617 tmp = le32_to_cpu(dev->adapter_info.biosrev);
618 len = snprintf(buf, PAGE_SIZE, "%d.%d-%d[%d]\n",
619 tmp >> 24, (tmp >> 16) & 0xff, tmp & 0xff,
620 le32_to_cpu(dev->adapter_info.biosbuild));
621 return len;
622}
623
624static ssize_t aac_show_serial_number(struct class_device *class_dev,
625 char *buf)
626{
627 struct aac_dev *dev = (struct aac_dev*)class_to_shost(class_dev)->hostdata;
628 int len = 0;
629
630 if (le32_to_cpu(dev->adapter_info.serial[0]) != 0xBAD0)
631 len = snprintf(buf, PAGE_SIZE, "%x\n",
632 le32_to_cpu(dev->adapter_info.serial[0]));
633 return len;
634}
635
636
637static struct class_device_attribute aac_model = {
638 .attr = {
639 .name = "model",
640 .mode = S_IRUGO,
641 },
642 .show = aac_show_model,
643};
644static struct class_device_attribute aac_vendor = {
645 .attr = {
646 .name = "vendor",
647 .mode = S_IRUGO,
648 },
649 .show = aac_show_vendor,
650};
651static struct class_device_attribute aac_kernel_version = {
652 .attr = {
653 .name = "hba_kernel_version",
654 .mode = S_IRUGO,
655 },
656 .show = aac_show_kernel_version,
657};
658static struct class_device_attribute aac_monitor_version = {
659 .attr = {
660 .name = "hba_monitor_version",
661 .mode = S_IRUGO,
662 },
663 .show = aac_show_monitor_version,
664};
665static struct class_device_attribute aac_bios_version = {
666 .attr = {
667 .name = "hba_bios_version",
668 .mode = S_IRUGO,
669 },
670 .show = aac_show_bios_version,
671};
672static struct class_device_attribute aac_serial_number = {
673 .attr = {
674 .name = "serial_number",
675 .mode = S_IRUGO,
676 },
677 .show = aac_show_serial_number,
678};
679
680static struct class_device_attribute *aac_attrs[] = {
681 &aac_model,
682 &aac_vendor,
683 &aac_kernel_version,
684 &aac_monitor_version,
685 &aac_bios_version,
686 &aac_serial_number,
687 NULL
688};
689
690
1da177e4
LT		 691static struct file_operations aac_cfg_fops = {
692 .owner = THIS_MODULE,
693 .ioctl = aac_cfg_ioctl,
694#ifdef CONFIG_COMPAT
695 .compat_ioctl = aac_compat_cfg_ioctl,
696#endif
697 .open = aac_cfg_open,
698};
699
700static struct scsi_host_template aac_driver_template = {
701 .module = THIS_MODULE,
702 .name = "AAC",
7c00ffa3 703 .proc_name = AAC_DRIVERNAME,
1da177e4
LT		 704 .info = aac_info,
705 .ioctl = aac_ioctl,
706#ifdef CONFIG_COMPAT
707 .compat_ioctl = aac_compat_ioctl,
708#endif
709 .queuecommand = aac_queuecommand,
710 .bios_param = aac_biosparm,
0bb14afe 711 .shost_attrs = aac_attrs,
1da177e4 712 .slave_configure = aac_slave_configure,
1da177e4
LT		 713 .eh_host_reset_handler = aac_eh_reset,
714 .can_queue = AAC_NUM_IO_FIB,
84971738 715 .this_id = MAXIMUM_NUM_CONTAINERS,
1da177e4
LT		 716 .sg_tablesize = 16,
717 .max_sectors = 128,
718#if (AAC_NUM_IO_FIB > 256)
719 .cmd_per_lun = 256,
720#else
721 .cmd_per_lun = AAC_NUM_IO_FIB,
722#endif
723 .use_clustering = ENABLE_CLUSTERING,
724};
725
726
727static int __devinit aac_probe_one(struct pci_dev *pdev,
728 const struct pci_device_id *id)
729{
730 unsigned index = id->driver_data;
731 struct Scsi_Host *shost;
732 struct aac_dev *aac;
733 struct list_head *insert = &aac_devices;
734 int error = -ENODEV;
735 int unique_id = 0;
736
737 list_for_each_entry(aac, &aac_devices, entry) {
738 if (aac->id > unique_id)
739 break;
740 insert = &aac->entry;
741 unique_id++;
742 }
743
744 if (pci_enable_device(pdev))
745 goto out;
746
747 if (pci_set_dma_mask(pdev, 0xFFFFFFFFULL) ||
748 pci_set_consistent_dma_mask(pdev, 0xFFFFFFFFULL))
749 goto out;
750 /*
751 * If the quirk31 bit is set, the adapter needs adapter
752 * to driver communication memory to be allocated below 2gig
753 */
754 if (aac_drivers[index].quirks & AAC_QUIRK_31BIT)
755 if (pci_set_dma_mask(pdev, 0x7FFFFFFFULL) ||
756 pci_set_consistent_dma_mask(pdev, 0x7FFFFFFFULL))
757 goto out;
758
759 pci_set_master(pdev);
760
761 shost = scsi_host_alloc(&aac_driver_template, sizeof(struct aac_dev));
762 if (!shost)
763 goto out_disable_pdev;
764
765 shost->irq = pdev->irq;
766 shost->base = pci_resource_start(pdev, 0);
767 shost->unique_id = unique_id;
768
769 aac = (struct aac_dev *)shost->hostdata;
770 aac->scsi_host_ptr = shost;
771 aac->pdev = pdev;
772 aac->name = aac_driver_template.name;
773 aac->id = shost->unique_id;
774 aac->cardtype = index;
775 INIT_LIST_HEAD(&aac->entry);
776
7c00ffa3 777 aac->fibs = kmalloc(sizeof(struct fib) * (shost->can_queue + AAC_NUM_MGT_FIB), GFP_KERNEL);
1da177e4
LT		 778 if (!aac->fibs)
779 goto out_free_host;
780 spin_lock_init(&aac->fib_lock);
781
782 if ((*aac_drivers[index].init)(aac))
783 goto out_free_fibs;
784
785 /*
786 * If we had set a smaller DMA mask earlier, set it to 4gig
787 * now since the adapter can dma data to at least a 4gig
788 * address space.
789 */
790 if (aac_drivers[index].quirks & AAC_QUIRK_31BIT)
791 if (pci_set_dma_mask(pdev, 0xFFFFFFFFULL))
792 goto out_free_fibs;
793
84971738 794 aac->maximum_num_channels = aac_drivers[index].channels;
1da177e4
LT		 795 aac_get_adapter_info(aac);
796
797 /*
7c00ffa3
MH		 798 * Lets override negotiations and drop the maximum SG limit to 34
799 */
800 if ((aac_drivers[index].quirks & AAC_QUIRK_34SG) &&
801 (aac->scsi_host_ptr->sg_tablesize > 34)) {
802 aac->scsi_host_ptr->sg_tablesize = 34;
803 aac->scsi_host_ptr->max_sectors
804 = (aac->scsi_host_ptr->sg_tablesize * 8) + 112;
805 }
806
807 /*
808 * Firware printf works only with older firmware.
809 */
810 if (aac_drivers[index].quirks & AAC_QUIRK_34SG)
811 aac->printf_enabled = 1;
812 else
813 aac->printf_enabled = 0;
814
815 /*
1da177e4
LT		 816 * max channel will be the physical channels plus 1 virtual channel
817 * all containers are on the virtual channel 0
818 * physical channels are address by their actual physical number+1
819 */
820 if (aac->nondasd_support == 1)
84971738 821 shost->max_channel = aac->maximum_num_channels + 1;
1da177e4
LT		 822 else
823 shost->max_channel = 1;
824
825 aac_get_config_status(aac);
826 aac_get_containers(aac);
827 list_add(&aac->entry, insert);
828
829 shost->max_id = aac->maximum_num_containers;
84971738
MH		 830 if (shost->max_id < aac->maximum_num_physicals)
831 shost->max_id = aac->maximum_num_physicals;
1da177e4
LT		 832 if (shost->max_id < MAXIMUM_NUM_CONTAINERS)
833 shost->max_id = MAXIMUM_NUM_CONTAINERS;
834 else
835 shost->this_id = shost->max_id;
836
837 /*
838 * dmb - we may need to move the setting of these parms somewhere else once
839 * we get a fib that can report the actual numbers
840 */
841 shost->max_lun = AAC_MAX_LUN;
842
843 pci_set_drvdata(pdev, shost);
844
845 error = scsi_add_host(shost, &pdev->dev);
846 if (error)
847 goto out_deinit;
848 scsi_scan_host(shost);
849
850 return 0;
851
bd1aac80 852 out_deinit:
1da177e4
LT		 853 kill_proc(aac->thread_pid, SIGKILL, 0);
854 wait_for_completion(&aac->aif_completion);
855
856 aac_send_shutdown(aac);
bd1aac80 857 aac_adapter_disable_int(aac);
1da177e4
LT		 858 fib_map_free(aac);
859 pci_free_consistent(aac->pdev, aac->comm_size, aac->comm_addr, aac->comm_phys);
860 kfree(aac->queues);
861 free_irq(pdev->irq, aac);
862 iounmap(aac->regs.sa);
863 out_free_fibs:
864 kfree(aac->fibs);
865 kfree(aac->fsa_dev);
866 out_free_host:
867 scsi_host_put(shost);
868 out_disable_pdev:
869 pci_disable_device(pdev);
870 out:
871 return error;
872}
873
bd1aac80
MH		 874static void aac_shutdown(struct pci_dev *dev)
875{
876 struct Scsi_Host *shost = pci_get_drvdata(dev);
877 struct aac_dev *aac = (struct aac_dev *)shost->hostdata;
878 aac_send_shutdown(aac);
879}
880
1da177e4
LT		 881static void __devexit aac_remove_one(struct pci_dev *pdev)
882{
883 struct Scsi_Host *shost = pci_get_drvdata(pdev);
884 struct aac_dev *aac = (struct aac_dev *)shost->hostdata;
885
886 scsi_remove_host(shost);
887
888 kill_proc(aac->thread_pid, SIGKILL, 0);
889 wait_for_completion(&aac->aif_completion);
890
891 aac_send_shutdown(aac);
bd1aac80 892 aac_adapter_disable_int(aac);
1da177e4
LT		 893 fib_map_free(aac);
894 pci_free_consistent(aac->pdev, aac->comm_size, aac->comm_addr,
895 aac->comm_phys);
896 kfree(aac->queues);
897
898 free_irq(pdev->irq, aac);
899 iounmap(aac->regs.sa);
900
901 kfree(aac->fibs);
902
903 list_del(&aac->entry);
904 scsi_host_put(shost);
905 pci_disable_device(pdev);
906}
907
908static struct pci_driver aac_pci_driver = {
909 .name = AAC_DRIVERNAME,
910 .id_table = aac_pci_tbl,
911 .probe = aac_probe_one,
912 .remove = __devexit_p(aac_remove_one),
bd1aac80 913 .shutdown = aac_shutdown,
1da177e4
LT		 914};
915
916static int __init aac_init(void)
917{
918 int error;
919
c7f47602
MH		 920 printk(KERN_INFO "Adaptec %s driver (%s)\n",
921 AAC_DRIVERNAME, aac_driver_version);
1da177e4
LT		 922
923 error = pci_module_init(&aac_pci_driver);
924 if (error)
925 return error;
926
927 aac_cfg_major = register_chrdev( 0, "aac", &aac_cfg_fops);
928 if (aac_cfg_major < 0) {
929 printk(KERN_WARNING
930 "aacraid: unable to register \"aac\" device.\n");
931 }
bd1aac80 932
1da177e4
LT		 933 return 0;
934}
935
936static void __exit aac_exit(void)
937{
938 unregister_chrdev(aac_cfg_major, "aac");
939 pci_unregister_driver(&aac_pci_driver);
940}
941
942module_init(aac_init);
943module_exit(aac_exit);
Linux kernel - Deliverables
This page took 0.082514 seconds and 5 git commands to generate.