linit.c source code [linux/drivers/scsi/aacraid/linit.c]

1	// SPDX-License-Identifier: GPL-2.0-or-later
2	/*
3	* Adaptec AAC series RAID controller driver
4	* (c) Copyright 2001 Red Hat Inc.
5	*
6	* based on the old aacraid driver that is..
7	* Adaptec aacraid device driver for Linux.
8	*
9	* Copyright (c) 2000-2010 Adaptec, Inc.
10	* 2010-2015 PMC-Sierra, Inc. (aacraid@pmc-sierra.com)
11	* 2016-2017 Microsemi Corp. (aacraid@microsemi.com)
12	*
13	* Module Name:
14	* linit.c
15	*
16	* Abstract: Linux Driver entry module for Adaptec RAID Array Controller
17	*/
18
19
20	#include <linux/compat.h>
21	#include <linux/blkdev.h>
22	#include <linux/completion.h>
23	#include <linux/init.h>
24	#include <linux/interrupt.h>
25	#include <linux/kernel.h>
26	#include <linux/module.h>
27	#include <linux/moduleparam.h>
28	#include <linux/pci.h>
29	#include <linux/slab.h>
30	#include <linux/mutex.h>
31	#include <linux/spinlock.h>
32	#include <linux/syscalls.h>
33	#include <linux/delay.h>
34	#include <linux/kthread.h>
35	#include <linux/msdos_partition.h>
36
37	#include <scsi/scsi.h>
38	#include <scsi/scsi_cmnd.h>
39	#include <scsi/scsi_device.h>
40	#include <scsi/scsi_host.h>
41	#include <scsi/scsi_tcq.h>
42	#include <scsi/scsicam.h>
43	#include <scsi/scsi_eh.h>
44
45	#include "aacraid.h"
46
47	#define AAC_DRIVER_VERSION "1.2.1"
48	#ifndef AAC_DRIVER_BRANCH
49	#define AAC_DRIVER_BRANCH ""
50	#endif
51	#define AAC_DRIVERNAME "aacraid"
52
53	#ifdef AAC_DRIVER_BUILD
54	#define _str(x) #x
55	#define str(x) _str(x)
56	#define AAC_DRIVER_FULL_VERSION AAC_DRIVER_VERSION "[" str(AAC_DRIVER_BUILD) "]" AAC_DRIVER_BRANCH
57	#else
58	#define AAC_DRIVER_FULL_VERSION AAC_DRIVER_VERSION AAC_DRIVER_BRANCH
59	#endif
60
61	MODULE_AUTHOR("Red Hat Inc and Adaptec");
62	MODULE_DESCRIPTION("Dell PERC2, 2/Si, 3/Si, 3/Di, "
63	"Adaptec Advanced Raid Products, "
64	"HP NetRAID-4M, IBM ServeRAID & ICP SCSI driver");
65	MODULE_LICENSE("GPL");
66	MODULE_VERSION(AAC_DRIVER_FULL_VERSION);
67
68	static DEFINE_MUTEX(aac_mutex);
69	static LIST_HEAD(aac_devices);
70	static int aac_cfg_major = AAC_CHARDEV_UNREGISTERED;
71	char aac_driver_version[] = AAC_DRIVER_FULL_VERSION;
72
73	/*
74	* Because of the way Linux names scsi devices, the order in this table has
75	* become important. Check for on-board Raid first, add-in cards second.
76	*
77	* Note: The last field is used to index into aac_drivers below.
78	*/
79	static const struct pci_device_id aac_pci_tbl[] = {
80	{ `0x1028`, `0x0001`, `0x1028`, `0x0001`, `0`, `0`, `0` }, / PERC 2/Si (Iguana/PERC2Si) /
81	{ `0x1028`, `0x0002`, `0x1028`, `0x0002`, `0`, `0`, `1` }, / PERC 3/Di (Opal/PERC3Di) /
82	{ `0x1028`, `0x0003`, `0x1028`, `0x0003`, `0`, `0`, `2` }, / PERC 3/Si (SlimFast/PERC3Si /
83	{ `0x1028`, `0x0004`, `0x1028`, `0x00d0`, `0`, `0`, `3` }, / PERC 3/Di (Iguana FlipChip/PERC3DiF /
84	{ `0x1028`, `0x0002`, `0x1028`, `0x00d1`, `0`, `0`, `4` }, / PERC 3/Di (Viper/PERC3DiV) /
85	{ `0x1028`, `0x0002`, `0x1028`, `0x00d9`, `0`, `0`, `5` }, / PERC 3/Di (Lexus/PERC3DiL) /
86	{ `0x1028`, `0x000a`, `0x1028`, `0x0106`, `0`, `0`, `6` }, / PERC 3/Di (Jaguar/PERC3DiJ) /
87	{ `0x1028`, `0x000a`, `0x1028`, `0x011b`, `0`, `0`, `7` }, / PERC 3/Di (Dagger/PERC3DiD) /
88	{ `0x1028`, `0x000a`, `0x1028`, `0x0121`, `0`, `0`, `8` }, / PERC 3/Di (Boxster/PERC3DiB) /
89	{ `0x9005`, `0x0283`, `0x9005`, `0x0283`, `0`, `0`, `9` }, / catapult /
90	{ `0x9005`, `0x0284`, `0x9005`, `0x0284`, `0`, `0`, `10` }, / tomcat /
91	{ `0x9005`, `0x0285`, `0x9005`, `0x0286`, `0`, `0`, `11` }, / Adaptec 2120S (Crusader) /
92	{ `0x9005`, `0x0285`, `0x9005`, `0x0285`, `0`, `0`, `12` }, / Adaptec 2200S (Vulcan) /
93	{ `0x9005`, `0x0285`, `0x9005`, `0x0287`, `0`, `0`, `13` }, / Adaptec 2200S (Vulcan-2m) /
94	{ `0x9005`, `0x0285`, `0x17aa`, `0x0286`, `0`, `0`, `14` }, / Legend S220 (Legend Crusader) /
95	{ `0x9005`, `0x0285`, `0x17aa`, `0x0287`, `0`, `0`, `15` }, / Legend S230 (Legend Vulcan) /
96
97	{ `0x9005`, `0x0285`, `0x9005`, `0x0288`, `0`, `0`, `16` }, / Adaptec 3230S (Harrier) /
98	{ `0x9005`, `0x0285`, `0x9005`, `0x0289`, `0`, `0`, `17` }, / Adaptec 3240S (Tornado) /
99	{ `0x9005`, `0x0285`, `0x9005`, `0x028a`, `0`, `0`, `18` }, / ASR-2020ZCR SCSI PCI-X ZCR (Skyhawk) /
100	{ `0x9005`, `0x0285`, `0x9005`, `0x028b`, `0`, `0`, `19` }, / ASR-2025ZCR SCSI SO-DIMM PCI-X ZCR (Terminator) /
101	{ `0x9005`, `0x0286`, `0x9005`, `0x028c`, `0`, `0`, `20` }, / ASR-2230S + ASR-2230SLP PCI-X (Lancer) /
102	{ `0x9005`, `0x0286`, `0x9005`, `0x028d`, `0`, `0`, `21` }, / ASR-2130S (Lancer) /
103	{ `0x9005`, `0x0286`, `0x9005`, `0x029b`, `0`, `0`, `22` }, / AAR-2820SA (Intruder) /
104	{ `0x9005`, `0x0286`, `0x9005`, `0x029c`, `0`, `0`, `23` }, / AAR-2620SA (Intruder) /
105	{ `0x9005`, `0x0286`, `0x9005`, `0x029d`, `0`, `0`, `24` }, / AAR-2420SA (Intruder) /
106	{ `0x9005`, `0x0286`, `0x9005`, `0x029e`, `0`, `0`, `25` }, / ICP9024RO (Lancer) /
107	{ `0x9005`, `0x0286`, `0x9005`, `0x029f`, `0`, `0`, `26` }, / ICP9014RO (Lancer) /
108	{ `0x9005`, `0x0286`, `0x9005`, `0x02a0`, `0`, `0`, `27` }, / ICP9047MA (Lancer) /
109	{ `0x9005`, `0x0286`, `0x9005`, `0x02a1`, `0`, `0`, `28` }, / ICP9087MA (Lancer) /
110	{ `0x9005`, `0x0286`, `0x9005`, `0x02a3`, `0`, `0`, `29` }, / ICP5445AU (Hurricane44) /
111	{ `0x9005`, `0x0285`, `0x9005`, `0x02a4`, `0`, `0`, `30` }, / ICP9085LI (Marauder-X) /
112	{ `0x9005`, `0x0285`, `0x9005`, `0x02a5`, `0`, `0`, `31` }, / ICP5085BR (Marauder-E) /
113	{ `0x9005`, `0x0286`, `0x9005`, `0x02a6`, `0`, `0`, `32` }, / ICP9067MA (Intruder-6) /
114	{ `0x9005`, `0x0287`, `0x9005`, `0x0800`, `0`, `0`, `33` }, / Themisto Jupiter Platform /
115	{ `0x9005`, `0x0200`, `0x9005`, `0x0200`, `0`, `0`, `33` }, / Themisto Jupiter Platform /
116	{ `0x9005`, `0x0286`, `0x9005`, `0x0800`, `0`, `0`, `34` }, / Callisto Jupiter Platform /
117	{ `0x9005`, `0x0285`, `0x9005`, `0x028e`, `0`, `0`, `35` }, / ASR-2020SA SATA PCI-X ZCR (Skyhawk) /
118	{ `0x9005`, `0x0285`, `0x9005`, `0x028f`, `0`, `0`, `36` }, / ASR-2025SA SATA SO-DIMM PCI-X ZCR (Terminator) /
119	{ `0x9005`, `0x0285`, `0x9005`, `0x0290`, `0`, `0`, `37` }, / AAR-2410SA PCI SATA 4ch (Jaguar II) /
120	{ `0x9005`, `0x0285`, `0x1028`, `0x0291`, `0`, `0`, `38` }, / CERC SATA RAID 2 PCI SATA 6ch (DellCorsair) /
121	{ `0x9005`, `0x0285`, `0x9005`, `0x0292`, `0`, `0`, `39` }, / AAR-2810SA PCI SATA 8ch (Corsair-8) /
122	{ `0x9005`, `0x0285`, `0x9005`, `0x0293`, `0`, `0`, `40` }, / AAR-21610SA PCI SATA 16ch (Corsair-16) /
123	{ `0x9005`, `0x0285`, `0x9005`, `0x0294`, `0`, `0`, `41` }, / ESD SO-DIMM PCI-X SATA ZCR (Prowler) /
124	{ `0x9005`, `0x0285`, `0x103C`, `0x3227`, `0`, `0`, `42` }, / AAR-2610SA PCI SATA 6ch /
125	{ `0x9005`, `0x0285`, `0x9005`, `0x0296`, `0`, `0`, `43` }, / ASR-2240S (SabreExpress) /
126	{ `0x9005`, `0x0285`, `0x9005`, `0x0297`, `0`, `0`, `44` }, / ASR-4005 /
127	{ `0x9005`, `0x0285`, `0x1014`, `0x02F2`, `0`, `0`, `45` }, / IBM 8i (AvonPark) /
128	{ `0x9005`, `0x0285`, `0x1014`, `0x0312`, `0`, `0`, `45` }, / IBM 8i (AvonPark Lite) /
129	{ `0x9005`, `0x0286`, `0x1014`, `0x9580`, `0`, `0`, `46` }, / IBM 8k/8k-l8 (Aurora) /
130	{ `0x9005`, `0x0286`, `0x1014`, `0x9540`, `0`, `0`, `47` }, / IBM 8k/8k-l4 (Aurora Lite) /
131	{ `0x9005`, `0x0285`, `0x9005`, `0x0298`, `0`, `0`, `48` }, / ASR-4000 (BlackBird) /
132	{ `0x9005`, `0x0285`, `0x9005`, `0x0299`, `0`, `0`, `49` }, / ASR-4800SAS (Marauder-X) /
133	{ `0x9005`, `0x0285`, `0x9005`, `0x029a`, `0`, `0`, `50` }, / ASR-4805SAS (Marauder-E) /
134	{ `0x9005`, `0x0286`, `0x9005`, `0x02a2`, `0`, `0`, `51` }, / ASR-3800 (Hurricane44) /
135
136	{ `0x9005`, `0x0285`, `0x1028`, `0x0287`, `0`, `0`, `52` }, / Perc 320/DC/
137	{ `0x1011`, `0x0046`, `0x9005`, `0x0365`, `0`, `0`, `53` }, / Adaptec 5400S (Mustang)/
138	{ `0x1011`, `0x0046`, `0x9005`, `0x0364`, `0`, `0`, `54` }, / Adaptec 5400S (Mustang)/
139	{ `0x1011`, `0x0046`, `0x9005`, `0x1364`, `0`, `0`, `55` }, / Dell PERC2/QC /
140	{ `0x1011`, `0x0046`, `0x103c`, `0x10c2`, `0`, `0`, `56` }, / HP NetRAID-4M /
141
142	{ `0x9005`, `0x0285`, `0x1028`, PCI_ANY_ID, `0`, `0`, `57` }, / Dell Catchall /
143	{ `0x9005`, `0x0285`, `0x17aa`, PCI_ANY_ID, `0`, `0`, `58` }, / Legend Catchall /
144	{ `0x9005`, `0x0285`, PCI_ANY_ID, PCI_ANY_ID, `0`, `0`, `59` }, / Adaptec Catch All /
145	{ `0x9005`, `0x0286`, PCI_ANY_ID, PCI_ANY_ID, `0`, `0`, `60` }, / Adaptec Rocket Catch All /
146	{ `0x9005`, `0x0288`, PCI_ANY_ID, PCI_ANY_ID, `0`, `0`, `61` }, / Adaptec NEMER/ARK Catch All /
147	{ `0x9005`, `0x028b`, PCI_ANY_ID, PCI_ANY_ID, `0`, `0`, `62` }, / Adaptec PMC Series 6 (Tupelo) /
148	{ `0x9005`, `0x028c`, PCI_ANY_ID, PCI_ANY_ID, `0`, `0`, `63` }, / Adaptec PMC Series 7 (Denali) /
149	{ `0x9005`, `0x028d`, PCI_ANY_ID, PCI_ANY_ID, `0`, `0`, `64` }, / Adaptec PMC Series 8 /
150	{ `0`,}
151	};
152	MODULE_DEVICE_TABLE(pci, aac_pci_tbl);
153
154	/*
155	* dmb - For now we add the number of channels to this structure.
156	* In the future we should add a fib that reports the number of channels
157	* for the card. At that time we can remove the channels from here
158	*/
159	static struct aac_driver_ident aac_drivers[] = {
160	{ aac_rx_init, "percraid", "DELL ", "PERCRAID ", `2`, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG \| AAC_QUIRK_SCSI_32 }, / PERC 2/Si (Iguana/PERC2Si) /
161	{ aac_rx_init, "percraid", "DELL ", "PERCRAID ", `2`, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG \| AAC_QUIRK_SCSI_32 }, / PERC 3/Di (Opal/PERC3Di) /
162	{ aac_rx_init, "percraid", "DELL ", "PERCRAID ", `2`, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG \| AAC_QUIRK_SCSI_32 }, / PERC 3/Si (SlimFast/PERC3Si /
163	{ aac_rx_init, "percraid", "DELL ", "PERCRAID ", `2`, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG \| AAC_QUIRK_SCSI_32 }, / PERC 3/Di (Iguana FlipChip/PERC3DiF /
164	{ aac_rx_init, "percraid", "DELL ", "PERCRAID ", `2`, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG \| AAC_QUIRK_SCSI_32 }, / PERC 3/Di (Viper/PERC3DiV) /
165	{ aac_rx_init, "percraid", "DELL ", "PERCRAID ", `2`, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG \| AAC_QUIRK_SCSI_32 }, / PERC 3/Di (Lexus/PERC3DiL) /
166	{ aac_rx_init, "percraid", "DELL ", "PERCRAID ", `1`, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG \| AAC_QUIRK_SCSI_32 }, / PERC 3/Di (Jaguar/PERC3DiJ) /
167	{ aac_rx_init, "percraid", "DELL ", "PERCRAID ", `2`, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG \| AAC_QUIRK_SCSI_32 }, / PERC 3/Di (Dagger/PERC3DiD) /
168	{ aac_rx_init, "percraid", "DELL ", "PERCRAID ", `2`, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG \| AAC_QUIRK_SCSI_32 }, / PERC 3/Di (Boxster/PERC3DiB) /
169	{ aac_rx_init, "aacraid", "ADAPTEC ", "catapult ", `2`, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG \| AAC_QUIRK_SCSI_32 }, / catapult /
170	{ aac_rx_init, "aacraid", "ADAPTEC ", "tomcat ", `2`, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG \| AAC_QUIRK_SCSI_32 }, / tomcat /
171	{ aac_rx_init, "aacraid", "ADAPTEC ", "Adaptec 2120S ", `1`, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG }, / Adaptec 2120S (Crusader) /
172	{ aac_rx_init, "aacraid", "ADAPTEC ", "Adaptec 2200S ", `2`, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG }, / Adaptec 2200S (Vulcan) /
173	{ aac_rx_init, "aacraid", "ADAPTEC ", "Adaptec 2200S ", `2`, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG \| AAC_QUIRK_SCSI_32 }, / Adaptec 2200S (Vulcan-2m) /
174	{ aac_rx_init, "aacraid", "Legend ", "Legend S220 ", `1`, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG \| AAC_QUIRK_SCSI_32 }, / Legend S220 (Legend Crusader) /
175	{ aac_rx_init, "aacraid", "Legend ", "Legend S230 ", `2`, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG \| AAC_QUIRK_SCSI_32 }, / Legend S230 (Legend Vulcan) /
176
177	{ aac_rx_init, "aacraid", "ADAPTEC ", "Adaptec 3230S ", `2` }, / Adaptec 3230S (Harrier) /
178	{ aac_rx_init, "aacraid", "ADAPTEC ", "Adaptec 3240S ", `2` }, / Adaptec 3240S (Tornado) /
179	{ aac_rx_init, "aacraid", "ADAPTEC ", "ASR-2020ZCR ", `2` }, / ASR-2020ZCR SCSI PCI-X ZCR (Skyhawk) /
180	{ aac_rx_init, "aacraid", "ADAPTEC ", "ASR-2025ZCR ", `2` }, / ASR-2025ZCR SCSI SO-DIMM PCI-X ZCR (Terminator) /
181	{ aac_rkt_init, "aacraid", "ADAPTEC ", "ASR-2230S PCI-X ", `2` }, / ASR-2230S + ASR-2230SLP PCI-X (Lancer) /
182	{ aac_rkt_init, "aacraid", "ADAPTEC ", "ASR-2130S PCI-X ", `1` }, / ASR-2130S (Lancer) /
183	{ aac_rkt_init, "aacraid", "ADAPTEC ", "AAR-2820SA ", `1` }, / AAR-2820SA (Intruder) /
184	{ aac_rkt_init, "aacraid", "ADAPTEC ", "AAR-2620SA ", `1` }, / AAR-2620SA (Intruder) /
185	{ aac_rkt_init, "aacraid", "ADAPTEC ", "AAR-2420SA ", `1` }, / AAR-2420SA (Intruder) /
186	{ aac_rkt_init, "aacraid", "ICP ", "ICP9024RO ", `2` }, / ICP9024RO (Lancer) /
187	{ aac_rkt_init, "aacraid", "ICP ", "ICP9014RO ", `1` }, / ICP9014RO (Lancer) /
188	{ aac_rkt_init, "aacraid", "ICP ", "ICP9047MA ", `1` }, / ICP9047MA (Lancer) /
189	{ aac_rkt_init, "aacraid", "ICP ", "ICP9087MA ", `1` }, / ICP9087MA (Lancer) /
190	{ aac_rkt_init, "aacraid", "ICP ", "ICP5445AU ", `1` }, / ICP5445AU (Hurricane44) /
191	{ aac_rx_init, "aacraid", "ICP ", "ICP9085LI ", `1` }, / ICP9085LI (Marauder-X) /
192	{ aac_rx_init, "aacraid", "ICP ", "ICP5085BR ", `1` }, / ICP5085BR (Marauder-E) /
193	{ aac_rkt_init, "aacraid", "ICP ", "ICP9067MA ", `1` }, / ICP9067MA (Intruder-6) /
194	{ NULL , "aacraid", "ADAPTEC ", "Themisto ", `0`, AAC_QUIRK_SLAVE }, / Jupiter Platform /
195	{ aac_rkt_init, "aacraid", "ADAPTEC ", "Callisto ", `2`, AAC_QUIRK_MASTER }, / Jupiter Platform /
196	{ aac_rx_init, "aacraid", "ADAPTEC ", "ASR-2020SA ", `1` }, / ASR-2020SA SATA PCI-X ZCR (Skyhawk) /
197	{ aac_rx_init, "aacraid", "ADAPTEC ", "ASR-2025SA ", `1` }, / ASR-2025SA SATA SO-DIMM PCI-X ZCR (Terminator) /
198	{ aac_rx_init, "aacraid", "ADAPTEC ", "AAR-2410SA SATA ", `1`, AAC_QUIRK_17SG }, / AAR-2410SA PCI SATA 4ch (Jaguar II) /
199	{ aac_rx_init, "aacraid", "DELL ", "CERC SR2 ", `1`, AAC_QUIRK_17SG }, / CERC SATA RAID 2 PCI SATA 6ch (DellCorsair) /
200	{ aac_rx_init, "aacraid", "ADAPTEC ", "AAR-2810SA SATA ", `1`, AAC_QUIRK_17SG }, / AAR-2810SA PCI SATA 8ch (Corsair-8) /
201	{ aac_rx_init, "aacraid", "ADAPTEC ", "AAR-21610SA SATA", `1`, AAC_QUIRK_17SG }, / AAR-21610SA PCI SATA 16ch (Corsair-16) /
202	{ aac_rx_init, "aacraid", "ADAPTEC ", "ASR-2026ZCR ", `1` }, / ESD SO-DIMM PCI-X SATA ZCR (Prowler) /
203	{ aac_rx_init, "aacraid", "ADAPTEC ", "AAR-2610SA ", `1` }, / SATA 6Ch (Bearcat) /
204	{ aac_rx_init, "aacraid", "ADAPTEC ", "ASR-2240S ", `1` }, / ASR-2240S (SabreExpress) /
205	{ aac_rx_init, "aacraid", "ADAPTEC ", "ASR-4005 ", `1` }, / ASR-4005 /
206	{ aac_rx_init, "ServeRAID","IBM ", "ServeRAID 8i ", `1` }, / IBM 8i (AvonPark) /
207	{ aac_rkt_init, "ServeRAID","IBM ", "ServeRAID 8k-l8 ", `1` }, / IBM 8k/8k-l8 (Aurora) /
208	{ aac_rkt_init, "ServeRAID","IBM ", "ServeRAID 8k-l4 ", `1` }, / IBM 8k/8k-l4 (Aurora Lite) /
209	{ aac_rx_init, "aacraid", "ADAPTEC ", "ASR-4000 ", `1` }, / ASR-4000 (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) /
212	{ aac_rkt_init, "aacraid", "ADAPTEC ", "ASR-3800 ", `1` }, / ASR-3800 (Hurricane44) /
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_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 \| AAC_QUIRK_SCSI_32 }, / Dell Catchall /
221	{ aac_rx_init, "aacraid", "Legend ", "RAID ", `2`, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG \| AAC_QUIRK_SCSI_32 }, / Legend Catchall /
222	{ aac_rx_init, "aacraid", "ADAPTEC ", "RAID ", `2` }, / Adaptec Catch All /
223	{ aac_rkt_init, "aacraid", "ADAPTEC ", "RAID ", `2` }, / Adaptec Rocket Catch All /
224	{ aac_nark_init, "aacraid", "ADAPTEC ", "RAID ", `2` }, / Adaptec NEMER/ARK Catch All /
225	{ aac_src_init, "aacraid", "ADAPTEC ", "RAID ", `2`, AAC_QUIRK_SRC }, / Adaptec PMC Series 6 (Tupelo) /
226	{ aac_srcv_init, "aacraid", "ADAPTEC ", "RAID ", `2`, AAC_QUIRK_SRC }, / Adaptec PMC Series 7 (Denali) /
227	{ aac_srcv_init, "aacraid", "ADAPTEC ", "RAID ", `2`, AAC_QUIRK_SRC }, / Adaptec PMC Series 8 /
228	};
229
230	/**
231	* aac_queuecommand - queue a SCSI command
232	* @shost: Scsi host to queue command on
233	* @cmd: SCSI command to queue
234	*
235	* Queues a command for execution by the associated Host Adapter.
236	*
237	* TODO: unify with aac_scsi_cmd().
238	*/
239
240	static int aac_queuecommand(struct Scsi_Host *shost,
241	struct scsi_cmnd *cmd)
242	{
243	aac_priv(cmd)->owner = AAC_OWNER_LOWLEVEL;
244
245	return aac_scsi_cmd(cmd) ? FAILED : `0`;
246	}
247
248	/**
249	* aac_info - Returns the host adapter name
250	* @shost: Scsi host to report on
251	*
252	* Returns a static string describing the device in question
253	*/
254
255	static const char aac_info(struct* Scsi_Host *shost)
256	{
257	struct aac_dev dev = (struct* aac_dev *)shost->hostdata;
258	return aac_drivers[dev->cardtype].name;
259	}
260
261	/**
262	* aac_get_driver_ident
263	* @devtype: index into lookup table
264	*
265	* Returns a pointer to the entry in the driver lookup table.
266	*/
267
268	struct aac_driver_ident* aac_get_driver_ident(int devtype)
269	{
270	return &aac_drivers[devtype];
271	}
272
273	/**
274	* aac_biosparm - return BIOS parameters for disk
275	* @sdev: The scsi device corresponding to the disk
276	* @bdev: the block device corresponding to the disk
277	* @capacity: the sector capacity of the disk
278	* @geom: geometry block to fill in
279	*
280	* Return the Heads/Sectors/Cylinders BIOS Disk Parameters for Disk.
281	* The default disk geometry is 64 heads, 32 sectors, and the appropriate
282	* number of cylinders so as not to exceed drive capacity. In order for
283	* disks equal to or larger than 1 GB to be addressable by the BIOS
284	* without exceeding the BIOS limitation of 1024 cylinders, Extended
285	* Translation should be enabled. With Extended Translation enabled,
286	* drives between 1 GB inclusive and 2 GB exclusive are given a disk
287	* geometry of 128 heads and 32 sectors, and drives above 2 GB inclusive
288	* are given a disk geometry of 255 heads and 63 sectors. However, if
289	* the BIOS detects that the Extended Translation setting does not match
290	* the geometry in the partition table, then the translation inferred
291	* from the partition table will be used by the BIOS, and a warning may
292	* be displayed.
293	*/
294
295	static int aac_biosparm(struct scsi_device sdev, struct* block_device *bdev,
296	sector_t capacity, int *geom)
297	{
298	struct diskparm param = (struct* diskparm *)geom;
299	unsigned char *buf;
300
301	dprintk((KERN_DEBUG "aac_biosparm.\n"));
302
303	/*
304	* Assuming extended translation is enabled - #REVISIT#
305	*/
306	if (capacity >= `2` * `1024` * `1024`) { / 1 GB in 512 byte sectors /
307	if(capacity >= `4` * `1024` * `1024`) { / 2 GB in 512 byte sectors /
308	param->heads = `255`;
309	param->sectors = `63`;
310	} else {
311	param->heads = `128`;
312	param->sectors = `32`;
313	}
314	} else {
315	param->heads = `64`;
316	param->sectors = `32`;
317	}
318
319	param->cylinders = cap_to_cyls(capacity, divisor: param->heads * param->sectors);
320
321	/*
322	* Read the first 1024 bytes from the disk device, if the boot
323	* sector partition table is valid, search for a partition table
324	* entry whose end_head matches one of the standard geometry
325	* translations ( 64/32, 128/32, 255/63 ).
326	*/
327	buf = scsi_bios_ptable(bdev);
328	if (!buf)
329	return `0`;
330	if ((__le16 )(buf + `0x40`) == cpu_to_le16(MSDOS_LABEL_MAGIC)) {
331	struct msdos_partition first = (struct* msdos_partition *)buf;
332	struct msdos_partition *entry = first;
333	int saved_cylinders = param->cylinders;
334	int num;
335	unsigned char end_head, end_sec;
336
337	for(num = `0`; num < `4`; num++) {
338	end_head = entry->end_head;
339	end_sec = entry->end_sector & `0x3f`;
340
341	if(end_head == `63`) {
342	param->heads = `64`;
343	param->sectors = `32`;
344	break;
345	} else if(end_head == `127`) {
346	param->heads = `128`;
347	param->sectors = `32`;
348	break;
349	} else if(end_head == `254`) {
350	param->heads = `255`;
351	param->sectors = `63`;
352	break;
353	}
354	entry++;
355	}
356
357	if (num == `4`) {
358	end_head = first->end_head;
359	end_sec = first->end_sector & `0x3f`;
360	}
361
362	param->cylinders = cap_to_cyls(capacity, divisor: param->heads * param->sectors);
363	if (num < `4` && end_sec == param->sectors) {
364	if (param->cylinders != saved_cylinders) {
365	dprintk((KERN_DEBUG "Adopting geometry: heads=%d, sectors=%d from partition table %d.\n",
366	param->heads, param->sectors, num));
367	}
368	} else if (end_head > `0` \|\| end_sec > `0`) {
369	dprintk((KERN_DEBUG "Strange geometry: heads=%d, sectors=%d in partition table %d.\n",
370	end_head + `1`, end_sec, num));
371	dprintk((KERN_DEBUG "Using geometry: heads=%d, sectors=%d.\n",
372	param->heads, param->sectors));
373	}
374	}
375	kfree(objp: buf);
376	return `0`;
377	}
378
379	/**
380	* aac_slave_configure - compute queue depths
381	* @sdev: SCSI device we are considering
382	*
383	* Selects queue depths for each target device based on the host adapter's
384	* total capacity and the queue depth supported by the target device.
385	* A queue depth of one automatically disables tagged queueing.
386	*/
387
388	static int aac_slave_configure(struct scsi_device *sdev)
389	{
390	struct aac_dev aac = (struct* aac_dev *)sdev->host->hostdata;
391	int chn, tid;
392	unsigned int depth = `0`;
393	unsigned int set_timeout = `0`;
394	int timeout = `0`;
395	bool set_qd_dev_type = false;
396	u8 devtype = `0`;
397
398	chn = aac_logical_to_phys(sdev_channel(sdev));
399	tid = sdev_id(sdev);
400	if (chn < AAC_MAX_BUSES && tid < AAC_MAX_TARGETS && aac->sa_firmware) {
401	devtype = aac->hba_map[chn][tid].devtype;
402
403	if (devtype == AAC_DEVTYPE_NATIVE_RAW) {
404	depth = aac->hba_map[chn][tid].qd_limit;
405	set_timeout = `1`;
406	goto common_config;
407	}
408	if (devtype == AAC_DEVTYPE_ARC_RAW) {
409	set_qd_dev_type = true;
410	set_timeout = `1`;
411	goto common_config;
412	}
413	}
414
415	if (aac->jbod && (sdev->type == TYPE_DISK))
416	sdev->removable = `1`;
417
418	if (sdev->type == TYPE_DISK
419	&& sdev_channel(sdev) != CONTAINER_CHANNEL
420	&& (!aac->jbod \|\| sdev->inq_periph_qual)
421	&& (!aac->raid_scsi_mode \|\| (sdev_channel(sdev) != `2`))) {
422
423	if (expose_physicals == `0`)
424	return -ENXIO;
425
426	if (expose_physicals < `0`)
427	sdev->no_uld_attach = `1`;
428	}
429
430	if (sdev->tagged_supported
431	&& sdev->type == TYPE_DISK
432	&& (!aac->raid_scsi_mode \|\| (sdev_channel(sdev) != `2`))
433	&& !sdev->no_uld_attach) {
434
435	struct scsi_device * dev;
436	struct Scsi_Host *host = sdev->host;
437	unsigned num_lsu = `0`;
438	unsigned num_one = `0`;
439	unsigned cid;
440
441	set_timeout = `1`;
442
443	for (cid = `0`; cid < aac->maximum_num_containers; ++cid)
444	if (aac->fsa_dev[cid].valid)
445	++num_lsu;
446
447	__shost_for_each_device(dev, host) {
448	if (dev->tagged_supported
449	&& dev->type == TYPE_DISK
450	&& (!aac->raid_scsi_mode \|\| (sdev_channel(sdev) != `2`))
451	&& !dev->no_uld_attach) {
452	if ((sdev_channel(sdev: dev) != CONTAINER_CHANNEL)
453	\|\| !aac->fsa_dev[sdev_id(sdev: dev)].valid) {
454	++num_lsu;
455	}
456	} else {
457	++num_one;
458	}
459	}
460
461	if (num_lsu == `0`)
462	++num_lsu;
463
464	depth = (host->can_queue - num_one) / num_lsu;
465
466	if (sdev_channel(sdev) != NATIVE_CHANNEL)
467	goto common_config;
468
469	set_qd_dev_type = true;
470
471	}
472
473	common_config:
474
475	/*
476	* Check if SATA drive
477	*/
478	if (set_qd_dev_type) {
479	if (strncmp(sdev->vendor, "ATA", `3`) == `0`)
480	depth = `32`;
481	else
482	depth = `64`;
483	}
484
485	/*
486	* Firmware has an individual device recovery time typically
487	* of 35 seconds, give us a margin. Thor devices can take longer in
488	* error recovery, hence different value.
489	*/
490	if (set_timeout) {
491	timeout = aac->sa_firmware ? AAC_SA_TIMEOUT : AAC_ARC_TIMEOUT;
492	blk_queue_rq_timeout(sdev->request_queue, timeout * HZ);
493	}
494
495	if (depth > `256`)
496	depth = `256`;
497	else if (depth < `1`)
498	depth = `1`;
499
500	scsi_change_queue_depth(sdev, depth);
501
502	sdev->tagged_supported = `1`;
503
504	return `0`;
505	}
506
507	/**
508	* aac_change_queue_depth - alter queue depths
509	* @sdev: SCSI device we are considering
510	* @depth: desired queue depth
511	*
512	* Alters queue depths for target device based on the host adapter's
513	* total capacity and the queue depth supported by the target device.
514	*/
515
516	static int aac_change_queue_depth(struct scsi_device sdev, int* depth)
517	{
518	struct aac_dev aac = (struct* aac_dev *)(sdev->host->hostdata);
519	int chn, tid, is_native_device = `0`;
520
521	chn = aac_logical_to_phys(sdev_channel(sdev));
522	tid = sdev_id(sdev);
523	if (chn < AAC_MAX_BUSES && tid < AAC_MAX_TARGETS &&
524	aac->hba_map[chn][tid].devtype == AAC_DEVTYPE_NATIVE_RAW)
525	is_native_device = `1`;
526
527	if (sdev->tagged_supported && (sdev->type == TYPE_DISK) &&
528	(sdev_channel(sdev) == CONTAINER_CHANNEL)) {
529	struct scsi_device * dev;
530	struct Scsi_Host *host = sdev->host;
531	unsigned num = `0`;
532
533	__shost_for_each_device(dev, host) {
534	if (dev->tagged_supported && (dev->type == TYPE_DISK) &&
535	(sdev_channel(sdev: dev) == CONTAINER_CHANNEL))
536	++num;
537	++num;
538	}
539	if (num >= host->can_queue)
540	num = host->can_queue - `1`;
541	if (depth > (host->can_queue - num))
542	depth = host->can_queue - num;
543	if (depth > `256`)
544	depth = `256`;
545	else if (depth < `2`)
546	depth = `2`;
547	return scsi_change_queue_depth(sdev, depth);
548	} else if (is_native_device) {
549	scsi_change_queue_depth(sdev, aac->hba_map[chn][tid].qd_limit);
550	} else {
551	scsi_change_queue_depth(sdev, `1`);
552	}
553	return sdev->queue_depth;
554	}
555
556	static ssize_t aac_show_raid_level(struct device dev, struct* device_attribute attr, char* *buf)
557	{
558	struct scsi_device *sdev = to_scsi_device(dev);
559	struct aac_dev aac = (struct* aac_dev *)(sdev->host->hostdata);
560	if (sdev_channel(sdev) != CONTAINER_CHANNEL)
561	return snprintf(buf, PAGE_SIZE, fmt: sdev->no_uld_attach
562	? "Hidden\n" :
563	((aac->jbod && (sdev->type == TYPE_DISK)) ? "JBOD\n" : ""));
564	return snprintf(buf, PAGE_SIZE, fmt: "%s\n",
565	get_container_type(type: aac->fsa_dev[sdev_id(sdev)].type));
566	}
567
568	static struct device_attribute aac_raid_level_attr = {
569	.attr = {
570	.name = "level",
571	.mode = S_IRUGO,
572	},
573	.show = aac_show_raid_level
574	};
575
576	static ssize_t aac_show_unique_id(struct device *dev,
577	struct device_attribute attr, char* *buf)
578	{
579	struct scsi_device *sdev = to_scsi_device(dev);
580	struct aac_dev aac = (struct* aac_dev *)(sdev->host->hostdata);
581	unsigned char sn[`16`];
582
583	memset(sn, `0`, sizeof(sn));
584
585	if (sdev_channel(sdev) == CONTAINER_CHANNEL)
586	memcpy(sn, aac->fsa_dev[sdev_id(sdev)].identifier, sizeof(sn));
587
588	return snprintf(buf, size: `16` * `2` + `2`,
589	fmt: "%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X\n",
590	sn[`0`], sn[`1`], sn[`2`], sn[`3`],
591	sn[`4`], sn[`5`], sn[`6`], sn[`7`],
592	sn[`8`], sn[`9`], sn[`10`], sn[`11`],
593	sn[`12`], sn[`13`], sn[`14`], sn[`15`]);
594	}
595
596	static struct device_attribute aac_unique_id_attr = {
597	.attr = {
598	.name = "unique_id",
599	.mode = `0444`,
600	},
601	.show = aac_show_unique_id
602	};
603
604
605
606	static struct attribute *aac_dev_attrs[] = {
607	&aac_raid_level_attr.attr,
608	&aac_unique_id_attr.attr,
609	NULL,
610	};
611
612	ATTRIBUTE_GROUPS(aac_dev);
613
614	static int aac_ioctl(struct scsi_device sdev, unsigned* int cmd,
615	void __user *arg)
616	{
617	int retval;
618	struct aac_dev dev = (struct* aac_dev *)sdev->host->hostdata;
619	if (!capable(CAP_SYS_RAWIO))
620	return -EPERM;
621	retval = aac_adapter_check_health(dev);
622	if (retval)
623	return -EBUSY;
624	return aac_do_ioctl(dev, cmd, arg);
625	}
626
627	struct fib_count_data {
628	int mlcnt;
629	int llcnt;
630	int ehcnt;
631	int fwcnt;
632	int krlcnt;
633	};
634
635	static bool fib_count_iter(struct scsi_cmnd scmnd, void* *data)
636	{
637	struct fib_count_data *fib_count = data;
638
639	switch (aac_priv(cmd: scmnd)->owner) {
640	case AAC_OWNER_FIRMWARE:
641	fib_count->fwcnt++;
642	break;
643	case AAC_OWNER_ERROR_HANDLER:
644	fib_count->ehcnt++;
645	break;
646	case AAC_OWNER_LOWLEVEL:
647	fib_count->llcnt++;
648	break;
649	case AAC_OWNER_MIDLEVEL:
650	fib_count->mlcnt++;
651	break;
652	default:
653	fib_count->krlcnt++;
654	break;
655	}
656	return true;
657	}
658
659	/ Called during SCSI EH, so we don't need to block requests /
660	static int get_num_of_incomplete_fibs(struct aac_dev *aac)
661	{
662	struct Scsi_Host *shost = aac->scsi_host_ptr;
663	struct device *ctrl_dev;
664	struct fib_count_data fcnt = { };
665
666	scsi_host_busy_iter(shost, fn: fib_count_iter, priv: &fcnt);
667
668	ctrl_dev = &aac->pdev->dev;
669
670	dev_info(ctrl_dev, "outstanding cmd: midlevel-%d\n", fcnt.mlcnt);
671	dev_info(ctrl_dev, "outstanding cmd: lowlevel-%d\n", fcnt.llcnt);
672	dev_info(ctrl_dev, "outstanding cmd: error handler-%d\n", fcnt.ehcnt);
673	dev_info(ctrl_dev, "outstanding cmd: firmware-%d\n", fcnt.fwcnt);
674	dev_info(ctrl_dev, "outstanding cmd: kernel-%d\n", fcnt.krlcnt);
675
676	return fcnt.mlcnt + fcnt.llcnt + fcnt.ehcnt + fcnt.fwcnt;
677	}
678
679	static int aac_eh_abort(struct scsi_cmnd* cmd)
680	{
681	struct aac_cmd_priv *cmd_priv = aac_priv(cmd);
682	struct scsi_device * dev = cmd->device;
683	struct Scsi_Host * host = dev->host;
684	struct aac_dev * aac = (struct aac_dev *)host->hostdata;
685	int count, found;
686	u32 bus, cid;
687	int ret = FAILED;
688
689	if (aac_adapter_check_health(dev: aac))
690	return ret;
691
692	bus = aac_logical_to_phys(scmd_channel(cmd));
693	cid = scmd_id(cmd);
694	if (aac->hba_map[bus][cid].devtype == AAC_DEVTYPE_NATIVE_RAW) {
695	struct fib *fib;
696	struct aac_hba_tm_req *tmf;
697	int status;
698	u64 address;
699
700	pr_err("%s: Host adapter abort request (%d,%d,%d,%d)\n",
701	AAC_DRIVERNAME,
702	host->host_no, sdev_channel(dev), sdev_id(dev), (int)dev->lun);
703
704	found = `0`;
705	for (count = `0`; count < (host->can_queue + AAC_NUM_MGT_FIB); ++count) {
706	fib = &aac->fibs[count];
707	if ((u8 )fib->hw_fib_va != `0` &&
708	(fib->flags & FIB_CONTEXT_FLAG_NATIVE_HBA) &&
709	(fib->callback_data == cmd)) {
710	found = `1`;
711	break;
712	}
713	}
714	if (!found)
715	return ret;
716
717	/ start a HBA_TMF_ABORT_TASK TMF request /
718	fib = aac_fib_alloc(dev: aac);
719	if (!fib)
720	return ret;
721
722	tmf = (struct aac_hba_tm_req *)fib->hw_fib_va;
723	memset(tmf, `0`, sizeof(*tmf));
724	tmf->tmf = HBA_TMF_ABORT_TASK;
725	tmf->it_nexus = aac->hba_map[bus][cid].rmw_nexus;
726	tmf->lun[`1`] = cmd->device->lun;
727
728	address = (u64)fib->hw_error_pa;
729	tmf->error_ptr_hi = cpu_to_le32((u32)(address >> `32`));
730	tmf->error_ptr_lo = cpu_to_le32((u32)(address & `0xffffffff`));
731	tmf->error_length = cpu_to_le32(FW_ERROR_BUFFER_SIZE);
732
733	fib->hbacmd_size = sizeof(*tmf);
734	cmd_priv->sent_command = `0`;
735
736	status = aac_hba_send(command: HBA_IU_TYPE_SCSI_TM_REQ, context: fib,
737	callback: (fib_callback) aac_hba_callback,
738	ctxt: (void *) cmd);
739	if (status != -EINPROGRESS) {
740	aac_fib_complete(context: fib);
741	aac_fib_free(context: fib);
742	return ret;
743	}
744	/ Wait up to 15 secs for completion /
745	for (count = `0`; count < `15`; ++count) {
746	if (cmd_priv->sent_command) {
747	ret = SUCCESS;
748	break;
749	}
750	msleep(msecs: `1000`);
751	}
752
753	if (ret != SUCCESS)
754	pr_err("%s: Host adapter abort request timed out\n",
755	AAC_DRIVERNAME);
756	} else {
757	pr_err(
758	"%s: Host adapter abort request.\n"
759	"%s: Outstanding commands on (%d,%d,%d,%d):\n",
760	AAC_DRIVERNAME, AAC_DRIVERNAME,
761	host->host_no, sdev_channel(dev), sdev_id(dev),
762	(int)dev->lun);
763	switch (cmd->cmnd[`0`]) {
764	case SERVICE_ACTION_IN_16:
765	if (!(aac->raw_io_interface) \|\|
766	!(aac->raw_io_64) \|\|
767	((cmd->cmnd[`1`] & `0x1f`) != SAI_READ_CAPACITY_16))
768	break;
769	fallthrough;
770	case INQUIRY:
771	case READ_CAPACITY:
772	/*
773	* Mark associated FIB to not complete,
774	* eh handler does this
775	*/
776	for (count = `0`;
777	count < (host->can_queue + AAC_NUM_MGT_FIB);
778	++count) {
779	struct fib *fib = &aac->fibs[count];
780
781	if (fib->hw_fib_va->header.XferState &&
782	(fib->flags & FIB_CONTEXT_FLAG) &&
783	(fib->callback_data == cmd)) {
784	fib->flags \|=
785	FIB_CONTEXT_FLAG_TIMED_OUT;
786	cmd_priv->owner =
787	AAC_OWNER_ERROR_HANDLER;
788	ret = SUCCESS;
789	}
790	}
791	break;
792	case TEST_UNIT_READY:
793	/*
794	* Mark associated FIB to not complete,
795	* eh handler does this
796	*/
797	for (count = `0`;
798	count < (host->can_queue + AAC_NUM_MGT_FIB);
799	++count) {
800	struct scsi_cmnd *command;
801	struct fib *fib = &aac->fibs[count];
802
803	command = fib->callback_data;
804
805	if ((fib->hw_fib_va->header.XferState &
806	cpu_to_le32
807	(Async \| NoResponseExpected)) &&
808	(fib->flags & FIB_CONTEXT_FLAG) &&
809	((command)) &&
810	(command->device == cmd->device)) {
811	fib->flags \|=
812	FIB_CONTEXT_FLAG_TIMED_OUT;
813	aac_priv(cmd: command)->owner =
814	AAC_OWNER_ERROR_HANDLER;
815	if (command == cmd)
816	ret = SUCCESS;
817	}
818	}
819	break;
820	}
821	}
822	return ret;
823	}
824
825	static u8 aac_eh_tmf_lun_reset_fib(struct aac_hba_map_info *info,
826	struct fib *fib, u64 tmf_lun)
827	{
828	struct aac_hba_tm_req *tmf;
829	u64 address;
830
831	/ start a HBA_TMF_LUN_RESET TMF request /
832	tmf = (struct aac_hba_tm_req *)fib->hw_fib_va;
833	memset(tmf, `0`, sizeof(*tmf));
834	tmf->tmf = HBA_TMF_LUN_RESET;
835	tmf->it_nexus = info->rmw_nexus;
836	int_to_scsilun(tmf_lun, (struct scsi_lun *)tmf->lun);
837
838	address = (u64)fib->hw_error_pa;
839	tmf->error_ptr_hi = cpu_to_le32
840	((u32)(address >> `32`));
841	tmf->error_ptr_lo = cpu_to_le32
842	((u32)(address & `0xffffffff`));
843	tmf->error_length = cpu_to_le32(FW_ERROR_BUFFER_SIZE);
844	fib->hbacmd_size = sizeof(*tmf);
845
846	return HBA_IU_TYPE_SCSI_TM_REQ;
847	}
848
849	static u8 aac_eh_tmf_hard_reset_fib(struct aac_hba_map_info *info,
850	struct fib *fib)
851	{
852	struct aac_hba_reset_req *rst;
853	u64 address;
854
855	/ already tried, start a hard reset now /
856	rst = (struct aac_hba_reset_req *)fib->hw_fib_va;
857	memset(rst, `0`, sizeof(*rst));
858	rst->it_nexus = info->rmw_nexus;
859
860	address = (u64)fib->hw_error_pa;
861	rst->error_ptr_hi = cpu_to_le32((u32)(address >> `32`));
862	rst->error_ptr_lo = cpu_to_le32((u32)(address & `0xffffffff`));
863	rst->error_length = cpu_to_le32(FW_ERROR_BUFFER_SIZE);
864	fib->hbacmd_size = sizeof(*rst);
865
866	return HBA_IU_TYPE_SATA_REQ;
867	}
868
869	static void aac_tmf_callback(void context, struct* fib *fibptr)
870	{
871	struct aac_hba_resp *err =
872	&((struct aac_native_hba *)fibptr->hw_fib_va)->resp.err;
873	struct aac_hba_map_info *info = context;
874	int res;
875
876	switch (err->service_response) {
877	case HBA_RESP_SVCRES_TMF_REJECTED:
878	res = -`1`;
879	break;
880	case HBA_RESP_SVCRES_TMF_LUN_INVALID:
881	res = `0`;
882	break;
883	case HBA_RESP_SVCRES_TMF_COMPLETE:
884	case HBA_RESP_SVCRES_TMF_SUCCEEDED:
885	res = `0`;
886	break;
887	default:
888	res = -`2`;
889	break;
890	}
891	aac_fib_complete(context: fibptr);
892
893	info->reset_state = res;
894	}
895
896	/*
897	* aac_eh_dev_reset - Device reset command handling
898	* @scsi_cmd: SCSI command block causing the reset
899	*
900	*/
901	static int aac_eh_dev_reset(struct scsi_cmnd *cmd)
902	{
903	struct scsi_device * dev = cmd->device;
904	struct Scsi_Host * host = dev->host;
905	struct aac_dev * aac = (struct aac_dev *)host->hostdata;
906	struct aac_hba_map_info *info;
907	int count;
908	u32 bus, cid;
909	struct fib *fib;
910	int ret = FAILED;
911	int status;
912	u8 command;
913
914	bus = aac_logical_to_phys(scmd_channel(cmd));
915	cid = scmd_id(cmd);
916
917	if (bus >= AAC_MAX_BUSES \|\| cid >= AAC_MAX_TARGETS)
918	return FAILED;
919
920	info = &aac->hba_map[bus][cid];
921
922	if (!(info->devtype == AAC_DEVTYPE_NATIVE_RAW &&
923	!(info->reset_state > `0`)))
924	return FAILED;
925
926	pr_err("%s: Host device reset request. SCSI hang ?\n",
927	AAC_DRIVERNAME);
928
929	fib = aac_fib_alloc(dev: aac);
930	if (!fib)
931	return ret;
932
933	/ start a HBA_TMF_LUN_RESET TMF request /
934	command = aac_eh_tmf_lun_reset_fib(info, fib, tmf_lun: dev->lun);
935
936	info->reset_state = `1`;
937
938	status = aac_hba_send(command, context: fib,
939	callback: (fib_callback) aac_tmf_callback,
940	ctxt: (void *) info);
941	if (status != -EINPROGRESS) {
942	info->reset_state = `0`;
943	aac_fib_complete(context: fib);
944	aac_fib_free(context: fib);
945	return ret;
946	}
947	/ Wait up to 15 seconds for completion /
948	for (count = `0`; count < `15`; ++count) {
949	if (info->reset_state == `0`) {
950	ret = info->reset_state == `0` ? SUCCESS : FAILED;
951	break;
952	}
953	msleep(msecs: `1000`);
954	}
955
956	return ret;
957	}
958
959	/*
960	* aac_eh_target_reset - Target reset command handling
961	* @scsi_cmd: SCSI command block causing the reset
962	*
963	*/
964	static int aac_eh_target_reset(struct scsi_cmnd *cmd)
965	{
966	struct scsi_device * dev = cmd->device;
967	struct Scsi_Host * host = dev->host;
968	struct aac_dev * aac = (struct aac_dev *)host->hostdata;
969	struct aac_hba_map_info *info;
970	int count;
971	u32 bus, cid;
972	int ret = FAILED;
973	struct fib *fib;
974	int status;
975	u8 command;
976
977	bus = aac_logical_to_phys(scmd_channel(cmd));
978	cid = scmd_id(cmd);
979
980	if (bus >= AAC_MAX_BUSES \|\| cid >= AAC_MAX_TARGETS)
981	return FAILED;
982
983	info = &aac->hba_map[bus][cid];
984
985	if (!(info->devtype == AAC_DEVTYPE_NATIVE_RAW &&
986	!(info->reset_state > `0`)))
987	return FAILED;
988
989	pr_err("%s: Host target reset request. SCSI hang ?\n",
990	AAC_DRIVERNAME);
991
992	fib = aac_fib_alloc(dev: aac);
993	if (!fib)
994	return ret;
995
996
997	/ already tried, start a hard reset now /
998	command = aac_eh_tmf_hard_reset_fib(info, fib);
999
1000	info->reset_state = `2`;
1001
1002	status = aac_hba_send(command, context: fib,
1003	callback: (fib_callback) aac_tmf_callback,
1004	ctxt: (void *) info);
1005
1006	if (status != -EINPROGRESS) {
1007	info->reset_state = `0`;
1008	aac_fib_complete(context: fib);
1009	aac_fib_free(context: fib);
1010	return ret;
1011	}
1012
1013	/ Wait up to 15 seconds for completion /
1014	for (count = `0`; count < `15`; ++count) {
1015	if (info->reset_state <= `0`) {
1016	ret = info->reset_state == `0` ? SUCCESS : FAILED;
1017	break;
1018	}
1019	msleep(msecs: `1000`);
1020	}
1021
1022	return ret;
1023	}
1024
1025	/*
1026	* aac_eh_bus_reset - Bus reset command handling
1027	* @scsi_cmd: SCSI command block causing the reset
1028	*
1029	*/
1030	static int aac_eh_bus_reset(struct scsi_cmnd* cmd)
1031	{
1032	struct scsi_device * dev = cmd->device;
1033	struct Scsi_Host * host = dev->host;
1034	struct aac_dev * aac = (struct aac_dev *)host->hostdata;
1035	int count;
1036	u32 cmd_bus;
1037	int status = `0`;
1038
1039
1040	cmd_bus = aac_logical_to_phys(scmd_channel(cmd));
1041	/ Mark the assoc. FIB to not complete, eh handler does this /
1042	for (count = `0`; count < (host->can_queue + AAC_NUM_MGT_FIB); ++count) {
1043	struct fib *fib = &aac->fibs[count];
1044
1045	if (fib->hw_fib_va->header.XferState &&
1046	(fib->flags & FIB_CONTEXT_FLAG) &&
1047	(fib->flags & FIB_CONTEXT_FLAG_SCSI_CMD)) {
1048	struct aac_hba_map_info *info;
1049	u32 bus, cid;
1050
1051	cmd = (struct scsi_cmnd *)fib->callback_data;
1052	bus = aac_logical_to_phys(scmd_channel(cmd));
1053	if (bus != cmd_bus)
1054	continue;
1055	cid = scmd_id(cmd);
1056	info = &aac->hba_map[bus][cid];
1057	if (bus >= AAC_MAX_BUSES \|\| cid >= AAC_MAX_TARGETS \|\|
1058	info->devtype != AAC_DEVTYPE_NATIVE_RAW) {
1059	fib->flags \|= FIB_CONTEXT_FLAG_EH_RESET;
1060	aac_priv(cmd)->owner = AAC_OWNER_ERROR_HANDLER;
1061	}
1062	}
1063	}
1064
1065	pr_err("%s: Host bus reset request. SCSI hang ?\n", AAC_DRIVERNAME);
1066
1067	/*
1068	* Check the health of the controller
1069	*/
1070	status = aac_adapter_check_health(dev: aac);
1071	if (status)
1072	dev_err(&aac->pdev->dev, "Adapter health - %d\n", status);
1073
1074	count = get_num_of_incomplete_fibs(aac);
1075	return (count == `0`) ? SUCCESS : FAILED;
1076	}
1077
1078	/*
1079	* aac_eh_host_reset - Host reset command handling
1080	* @scsi_cmd: SCSI command block causing the reset
1081	*
1082	*/
1083	static int aac_eh_host_reset(struct scsi_cmnd *cmd)
1084	{
1085	struct scsi_device * dev = cmd->device;
1086	struct Scsi_Host * host = dev->host;
1087	struct aac_dev * aac = (struct aac_dev *)host->hostdata;
1088	int ret = FAILED;
1089	__le32 supported_options2 = `0`;
1090	bool is_mu_reset;
1091	bool is_ignore_reset;
1092	bool is_doorbell_reset;
1093
1094	/*
1095	* Check if reset is supported by the firmware
1096	*/
1097	supported_options2 = aac->supplement_adapter_info.supported_options2;
1098	is_mu_reset = supported_options2 & AAC_OPTION_MU_RESET;
1099	is_doorbell_reset = supported_options2 & AAC_OPTION_DOORBELL_RESET;
1100	is_ignore_reset = supported_options2 & AAC_OPTION_IGNORE_RESET;
1101	/*
1102	* This adapter needs a blind reset, only do so for
1103	* Adapters that support a register, instead of a commanded,
1104	* reset.
1105	*/
1106	if ((is_mu_reset \|\| is_doorbell_reset)
1107	&& aac_check_reset
1108	&& (aac_check_reset != -`1` \|\| !is_ignore_reset)) {
1109	/ Bypass wait for command quiesce /
1110	if (aac_reset_adapter(dev: aac, forced: `2`, IOP_HWSOFT_RESET) == `0`)
1111	ret = SUCCESS;
1112	}
1113	/*
1114	* Reset EH state
1115	*/
1116	if (ret == SUCCESS) {
1117	int bus, cid;
1118	struct aac_hba_map_info *info;
1119
1120	for (bus = `0`; bus < AAC_MAX_BUSES; bus++) {
1121	for (cid = `0`; cid < AAC_MAX_TARGETS; cid++) {
1122	info = &aac->hba_map[bus][cid];
1123	if (info->devtype == AAC_DEVTYPE_NATIVE_RAW)
1124	info->reset_state = `0`;
1125	}
1126	}
1127	}
1128	return ret;
1129	}
1130
1131	/**
1132	* aac_cfg_open - open a configuration file
1133	* @inode: inode being opened
1134	* @file: file handle attached
1135	*
1136	* Called when the configuration device is opened. Does the needed
1137	* set up on the handle and then returns
1138	*
1139	* Bugs: This needs extending to check a given adapter is present
1140	* so we can support hot plugging, and to ref count adapters.
1141	*/
1142
1143	static int aac_cfg_open(struct inode inode, struct* file *file)
1144	{
1145	struct aac_dev *aac;
1146	unsigned minor_number = iminor(inode);
1147	int err = -ENODEV;
1148
1149	mutex_lock(&aac_mutex); / BKL pushdown: nothing else protects this list /
1150	list_for_each_entry(aac, &aac_devices, entry) {
1151	if (aac->id == minor_number) {
1152	file->private_data = aac;
1153	err = `0`;
1154	break;
1155	}
1156	}
1157	mutex_unlock(lock: &aac_mutex);
1158
1159	return err;
1160	}
1161
1162	/**
1163	* aac_cfg_ioctl - AAC configuration request
1164	* @file: file handle
1165	* @cmd: ioctl command code
1166	* @arg: argument
1167	*
1168	* Handles a configuration ioctl. Currently this involves wrapping it
1169	* up and feeding it into the nasty windowsalike glue layer.
1170	*
1171	* Bugs: Needs locking against parallel ioctls lower down
1172	* Bugs: Needs to handle hot plugging
1173	*/
1174
1175	static long aac_cfg_ioctl(struct file *file,
1176	unsigned int cmd, unsigned long arg)
1177	{
1178	struct aac_dev aac = (struct* aac_dev *)file->private_data;
1179
1180	if (!capable(CAP_SYS_RAWIO))
1181	return -EPERM;
1182
1183	return aac_do_ioctl(dev: aac, cmd, arg: (void __user *)arg);
1184	}
1185
1186	static ssize_t aac_show_model(struct device *device,
1187	struct device_attribute attr, char* *buf)
1188	{
1189	struct aac_dev dev = (struct* aac_dev*)class_to_shost(device)->hostdata;
1190	int len;
1191
1192	if (dev->supplement_adapter_info.adapter_type_text[`0`]) {
1193	char *cp = dev->supplement_adapter_info.adapter_type_text;
1194	while (cp && cp != `' '`)
1195	++cp;
1196	while (*cp == `' '`)
1197	++cp;
1198	len = snprintf(buf, PAGE_SIZE, fmt: "%s\n", cp);
1199	} else
1200	len = snprintf(buf, PAGE_SIZE, fmt: "%s\n",
1201	aac_drivers[dev->cardtype].model);
1202	return len;
1203	}
1204
1205	static ssize_t aac_show_vendor(struct device *device,
1206	struct device_attribute attr, char* *buf)
1207	{
1208	struct aac_dev dev = (struct* aac_dev*)class_to_shost(device)->hostdata;
1209	struct aac_supplement_adapter_info *sup_adap_info;
1210	int len;
1211
1212	sup_adap_info = &dev->supplement_adapter_info;
1213	if (sup_adap_info->adapter_type_text[`0`]) {
1214	char *cp = sup_adap_info->adapter_type_text;
1215	while (cp && cp != `' '`)
1216	++cp;
1217	len = snprintf(buf, PAGE_SIZE, fmt: "%.*s\n",
1218	(int)(cp - (char *)sup_adap_info->adapter_type_text),
1219	sup_adap_info->adapter_type_text);
1220	} else
1221	len = snprintf(buf, PAGE_SIZE, fmt: "%s\n",
1222	aac_drivers[dev->cardtype].vname);
1223	return len;
1224	}
1225
1226	static ssize_t aac_show_flags(struct device *cdev,
1227	struct device_attribute attr, char* *buf)
1228	{
1229	int len = `0`;
1230	struct aac_dev dev = (struct* aac_dev*)class_to_shost(cdev)->hostdata;
1231
1232	if (nblank(dprintk(x)))
1233	len = snprintf(buf, PAGE_SIZE, fmt: "dprintk\n");
1234	#ifdef AAC_DETAILED_STATUS_INFO
1235	len += scnprintf(buf + len, PAGE_SIZE - len,
1236	"AAC_DETAILED_STATUS_INFO\n");
1237	#endif
1238	if (dev->raw_io_interface && dev->raw_io_64)
1239	len += scnprintf(buf: buf + len, PAGE_SIZE - len,
1240	fmt: "SAI_READ_CAPACITY_16\n");
1241	if (dev->jbod)
1242	len += scnprintf(buf: buf + len, PAGE_SIZE - len,
1243	fmt: "SUPPORTED_JBOD\n");
1244	if (dev->supplement_adapter_info.supported_options2 &
1245	AAC_OPTION_POWER_MANAGEMENT)
1246	len += scnprintf(buf: buf + len, PAGE_SIZE - len,
1247	fmt: "SUPPORTED_POWER_MANAGEMENT\n");
1248	if (dev->msi)
1249	len += scnprintf(buf: buf + len, PAGE_SIZE - len, fmt: "PCI_HAS_MSI\n");
1250	return len;
1251	}
1252
1253	static ssize_t aac_show_kernel_version(struct device *device,
1254	struct device_attribute *attr,
1255	char *buf)
1256	{
1257	struct aac_dev dev = (struct* aac_dev*)class_to_shost(device)->hostdata;
1258	int len, tmp;
1259
1260	tmp = le32_to_cpu(dev->adapter_info.kernelrev);
1261	len = snprintf(buf, PAGE_SIZE, fmt: "%d.%d-%d[%d]\n",
1262	tmp >> `24`, (tmp >> `16`) & `0xff`, tmp & `0xff`,
1263	le32_to_cpu(dev->adapter_info.kernelbuild));
1264	return len;
1265	}
1266
1267	static ssize_t aac_show_monitor_version(struct device *device,
1268	struct device_attribute *attr,
1269	char *buf)
1270	{
1271	struct aac_dev dev = (struct* aac_dev*)class_to_shost(device)->hostdata;
1272	int len, tmp;
1273
1274	tmp = le32_to_cpu(dev->adapter_info.monitorrev);
1275	len = snprintf(buf, PAGE_SIZE, fmt: "%d.%d-%d[%d]\n",
1276	tmp >> `24`, (tmp >> `16`) & `0xff`, tmp & `0xff`,
1277	le32_to_cpu(dev->adapter_info.monitorbuild));
1278	return len;
1279	}
1280
1281	static ssize_t aac_show_bios_version(struct device *device,
1282	struct device_attribute *attr,
1283	char *buf)
1284	{
1285	struct aac_dev dev = (struct* aac_dev*)class_to_shost(device)->hostdata;
1286	int len, tmp;
1287
1288	tmp = le32_to_cpu(dev->adapter_info.biosrev);
1289	len = snprintf(buf, PAGE_SIZE, fmt: "%d.%d-%d[%d]\n",
1290	tmp >> `24`, (tmp >> `16`) & `0xff`, tmp & `0xff`,
1291	le32_to_cpu(dev->adapter_info.biosbuild));
1292	return len;
1293	}
1294
1295	static ssize_t aac_show_driver_version(struct device *device,
1296	struct device_attribute *attr,
1297	char *buf)
1298	{
1299	return snprintf(buf, PAGE_SIZE, fmt: "%s\n", aac_driver_version);
1300	}
1301
1302	static ssize_t aac_show_serial_number(struct device *device,
1303	struct device_attribute attr, char* *buf)
1304	{
1305	struct aac_dev dev = (struct* aac_dev*)class_to_shost(device)->hostdata;
1306	int len = `0`;
1307
1308	if (le32_to_cpu(dev->adapter_info.serial[`0`]) != `0xBAD0`)
1309	len = snprintf(buf, size: `16`, fmt: "%06X\n",
1310	le32_to_cpu(dev->adapter_info.serial[`0`]));
1311	if (len &&
1312	!memcmp(p: &dev->supplement_adapter_info.mfg_pcba_serial_no[
1313	sizeof(dev->supplement_adapter_info.mfg_pcba_serial_no)-len],
1314	q: buf, size: len-`1`))
1315	len = snprintf(buf, size: `16`, fmt: "%.*s\n",
1316	(int)sizeof(dev->supplement_adapter_info.mfg_pcba_serial_no),
1317	dev->supplement_adapter_info.mfg_pcba_serial_no);
1318
1319	return min(len, `16`);
1320	}
1321
1322	static ssize_t aac_show_max_channel(struct device *device,
1323	struct device_attribute attr, char* *buf)
1324	{
1325	return snprintf(buf, PAGE_SIZE, fmt: "%d\n",
1326	class_to_shost(device)->max_channel);
1327	}
1328
1329	static ssize_t aac_show_max_id(struct device *device,
1330	struct device_attribute attr, char* *buf)
1331	{
1332	return snprintf(buf, PAGE_SIZE, fmt: "%d\n",
1333	class_to_shost(device)->max_id);
1334	}
1335
1336	static ssize_t aac_store_reset_adapter(struct device *device,
1337	struct device_attribute *attr,
1338	const char *buf, size_t count)
1339	{
1340	int retval = -EACCES;
1341
1342	if (!capable(CAP_SYS_ADMIN))
1343	return retval;
1344
1345	retval = aac_reset_adapter(dev: shost_priv(class_to_shost(device)),
1346	forced: buf[`0`] == `'!'`, IOP_HWSOFT_RESET);
1347	if (retval >= `0`)
1348	retval = count;
1349
1350	return retval;
1351	}
1352
1353	static ssize_t aac_show_reset_adapter(struct device *device,
1354	struct device_attribute *attr,
1355	char *buf)
1356	{
1357	struct aac_dev dev = (struct* aac_dev*)class_to_shost(device)->hostdata;
1358	int len, tmp;
1359
1360	tmp = aac_adapter_check_health(dev);
1361	if ((tmp == `0`) && dev->in_reset)
1362	tmp = -EBUSY;
1363	len = snprintf(buf, PAGE_SIZE, fmt: "0x%x\n", tmp);
1364	return len;
1365	}
1366
1367	static struct device_attribute aac_model = {
1368	.attr = {
1369	.name = "model",
1370	.mode = S_IRUGO,
1371	},
1372	.show = aac_show_model,
1373	};
1374	static struct device_attribute aac_vendor = {
1375	.attr = {
1376	.name = "vendor",
1377	.mode = S_IRUGO,
1378	},
1379	.show = aac_show_vendor,
1380	};
1381	static struct device_attribute aac_flags = {
1382	.attr = {
1383	.name = "flags",
1384	.mode = S_IRUGO,
1385	},
1386	.show = aac_show_flags,
1387	};
1388	static struct device_attribute aac_kernel_version = {
1389	.attr = {
1390	.name = "hba_kernel_version",
1391	.mode = S_IRUGO,
1392	},
1393	.show = aac_show_kernel_version,
1394	};
1395	static struct device_attribute aac_monitor_version = {
1396	.attr = {
1397	.name = "hba_monitor_version",
1398	.mode = S_IRUGO,
1399	},
1400	.show = aac_show_monitor_version,
1401	};
1402	static struct device_attribute aac_bios_version = {
1403	.attr = {
1404	.name = "hba_bios_version",
1405	.mode = S_IRUGO,
1406	},
1407	.show = aac_show_bios_version,
1408	};
1409	static struct device_attribute aac_lld_version = {
1410	.attr = {
1411	.name = "driver_version",
1412	.mode = `0444`,
1413	},
1414	.show = aac_show_driver_version,
1415	};
1416	static struct device_attribute aac_serial_number = {
1417	.attr = {
1418	.name = "serial_number",
1419	.mode = S_IRUGO,
1420	},
1421	.show = aac_show_serial_number,
1422	};
1423	static struct device_attribute aac_max_channel = {
1424	.attr = {
1425	.name = "max_channel",
1426	.mode = S_IRUGO,
1427	},
1428	.show = aac_show_max_channel,
1429	};
1430	static struct device_attribute aac_max_id = {
1431	.attr = {
1432	.name = "max_id",
1433	.mode = S_IRUGO,
1434	},
1435	.show = aac_show_max_id,
1436	};
1437	static struct device_attribute aac_reset = {
1438	.attr = {
1439	.name = "reset_host",
1440	.mode = S_IWUSR\|S_IRUGO,
1441	},
1442	.store = aac_store_reset_adapter,
1443	.show = aac_show_reset_adapter,
1444	};
1445
1446	static struct attribute *aac_host_attrs[] = {
1447	&aac_model.attr,
1448	&aac_vendor.attr,
1449	&aac_flags.attr,
1450	&aac_kernel_version.attr,
1451	&aac_monitor_version.attr,
1452	&aac_bios_version.attr,
1453	&aac_lld_version.attr,
1454	&aac_serial_number.attr,
1455	&aac_max_channel.attr,
1456	&aac_max_id.attr,
1457	&aac_reset.attr,
1458	NULL
1459	};
1460
1461	ATTRIBUTE_GROUPS(aac_host);
1462
1463	ssize_t aac_get_serial_number(struct device device, char* *buf)
1464	{
1465	return aac_show_serial_number(device, attr: &aac_serial_number, buf);
1466	}
1467
1468	static const struct file_operations aac_cfg_fops = {
1469	.owner = THIS_MODULE,
1470	.unlocked_ioctl = aac_cfg_ioctl,
1471	#ifdef CONFIG_COMPAT
1472	.compat_ioctl = aac_cfg_ioctl,
1473	#endif
1474	.open = aac_cfg_open,
1475	.llseek = noop_llseek,
1476	};
1477
1478	static const struct scsi_host_template aac_driver_template = {
1479	.module = THIS_MODULE,
1480	.name = "AAC",
1481	.proc_name = AAC_DRIVERNAME,
1482	.info = aac_info,
1483	.ioctl = aac_ioctl,
1484	#ifdef CONFIG_COMPAT
1485	.compat_ioctl = aac_ioctl,
1486	#endif
1487	.queuecommand = aac_queuecommand,
1488	.bios_param = aac_biosparm,
1489	.shost_groups = aac_host_groups,
1490	.slave_configure = aac_slave_configure,
1491	.change_queue_depth = aac_change_queue_depth,
1492	.sdev_groups = aac_dev_groups,
1493	.eh_abort_handler = aac_eh_abort,
1494	.eh_device_reset_handler = aac_eh_dev_reset,
1495	.eh_target_reset_handler = aac_eh_target_reset,
1496	.eh_bus_reset_handler = aac_eh_bus_reset,
1497	.eh_host_reset_handler = aac_eh_host_reset,
1498	.can_queue = AAC_NUM_IO_FIB,
1499	.this_id = MAXIMUM_NUM_CONTAINERS,
1500	.sg_tablesize = `16`,
1501	.max_sectors = `128`,
1502	#if (AAC_NUM_IO_FIB > 256)
1503	.cmd_per_lun = `256`,
1504	#else
1505	.cmd_per_lun = AAC_NUM_IO_FIB,
1506	#endif
1507	.emulated = `1`,
1508	.no_write_same = `1`,
1509	.cmd_size = sizeof(struct aac_cmd_priv),
1510	};
1511
1512	static void __aac_shutdown(struct aac_dev * aac)
1513	{
1514	int i;
1515
1516	mutex_lock(&aac->ioctl_mutex);
1517	aac->adapter_shutdown = `1`;
1518	mutex_unlock(lock: &aac->ioctl_mutex);
1519
1520	if (aac->aif_thread) {
1521	int i;
1522	/ Clear out events first /
1523	for (i = `0`; i < (aac->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB); i++) {
1524	struct fib *fib = &aac->fibs[i];
1525	if (!(fib->hw_fib_va->header.XferState & cpu_to_le32(NoResponseExpected \| Async)) &&
1526	(fib->hw_fib_va->header.XferState & cpu_to_le32(ResponseExpected)))
1527	complete(&fib->event_wait);
1528	}
1529	kthread_stop(k: aac->thread);
1530	aac->thread = NULL;
1531	}
1532
1533	aac_send_shutdown(dev: aac);
1534
1535	aac_adapter_disable_int(aac);
1536
1537	if (aac_is_src(dev: aac)) {
1538	if (aac->max_msix > `1`) {
1539	for (i = `0`; i < aac->max_msix; i++) {
1540	free_irq(pci_irq_vector(dev: aac->pdev, nr: i),
1541	&(aac->aac_msix[i]));
1542	}
1543	} else {
1544	free_irq(aac->pdev->irq,
1545	&(aac->aac_msix[`0`]));
1546	}
1547	} else {
1548	free_irq(aac->pdev->irq, aac);
1549	}
1550	if (aac->msi)
1551	pci_disable_msi(dev: aac->pdev);
1552	else if (aac->max_msix > `1`)
1553	pci_disable_msix(dev: aac->pdev);
1554	}
1555	static void aac_init_char(void)
1556	{
1557	aac_cfg_major = register_chrdev(major: `0`, name: "aac", fops: &aac_cfg_fops);
1558	if (aac_cfg_major < `0`) {
1559	pr_err("aacraid: unable to register \"aac\" device.\n");
1560	}
1561	}
1562
1563	void aac_reinit_aif(struct aac_dev aac, unsigned* int index)
1564	{
1565	/*
1566	* Firmware may send a AIF messages very early and the Driver may have
1567	* ignored as it is not fully ready to process the messages. Send
1568	* AIF to firmware so that if there are any unprocessed events they
1569	* can be processed now.
1570	*/
1571	if (aac_drivers[index].quirks & AAC_QUIRK_SRC)
1572	aac_intr_normal(dev: aac, Index: `0`, isAif: `2`, isFastResponse: `0`, NULL);
1573
1574	}
1575
1576	static int aac_probe_one(struct pci_dev pdev, const* struct pci_device_id *id)
1577	{
1578	unsigned index = id->driver_data;
1579	struct Scsi_Host *shost;
1580	struct aac_dev *aac;
1581	struct list_head *insert = &aac_devices;
1582	int error;
1583	int unique_id = `0`;
1584	u64 dmamask;
1585	int mask_bits = `0`;
1586	extern int aac_sync_mode;
1587
1588	/*
1589	* Only series 7 needs freset.
1590	*/
1591	if (pdev->device == PMC_DEVICE_S7)
1592	pdev->needs_freset = `1`;
1593
1594	list_for_each_entry(aac, &aac_devices, entry) {
1595	if (aac->id > unique_id)
1596	break;
1597	insert = &aac->entry;
1598	unique_id++;
1599	}
1600
1601	pci_disable_link_state(pdev, PCIE_LINK_STATE_L0S \| PCIE_LINK_STATE_L1 \|
1602	PCIE_LINK_STATE_CLKPM);
1603
1604	error = pci_enable_device(dev: pdev);
1605	if (error)
1606	goto out;
1607
1608	if (!(aac_drivers[index].quirks & AAC_QUIRK_SRC)) {
1609	error = dma_set_mask(dev: &pdev->dev, DMA_BIT_MASK(`32`));
1610	if (error) {
1611	dev_err(&pdev->dev, "PCI 32 BIT dma mask set failed");
1612	goto out_disable_pdev;
1613	}
1614	}
1615
1616	/*
1617	* If the quirk31 bit is set, the adapter needs adapter
1618	* to driver communication memory to be allocated below 2gig
1619	*/
1620	if (aac_drivers[index].quirks & AAC_QUIRK_31BIT) {
1621	dmamask = DMA_BIT_MASK(`31`);
1622	mask_bits = `31`;
1623	} else {
1624	dmamask = DMA_BIT_MASK(`32`);
1625	mask_bits = `32`;
1626	}
1627
1628	error = dma_set_coherent_mask(dev: &pdev->dev, mask: dmamask);
1629	if (error) {
1630	dev_err(&pdev->dev, "PCI %d B consistent dma mask set failed\n"
1631	, mask_bits);
1632	goto out_disable_pdev;
1633	}
1634
1635	pci_set_master(dev: pdev);
1636
1637	shost = scsi_host_alloc(&aac_driver_template, sizeof(struct aac_dev));
1638	if (!shost) {
1639	error = -ENOMEM;
1640	goto out_disable_pdev;
1641	}
1642
1643	shost->irq = pdev->irq;
1644	shost->unique_id = unique_id;
1645	shost->max_cmd_len = `16`;
1646
1647	if (aac_cfg_major == AAC_CHARDEV_NEEDS_REINIT)
1648	aac_init_char();
1649
1650	aac = (struct aac_dev *)shost->hostdata;
1651	aac->base_start = pci_resource_start(pdev, `0`);
1652	aac->scsi_host_ptr = shost;
1653	aac->pdev = pdev;
1654	aac->name = aac_driver_template.name;
1655	aac->id = shost->unique_id;
1656	aac->cardtype = index;
1657	INIT_LIST_HEAD(list: &aac->entry);
1658
1659	if (aac_reset_devices \|\| reset_devices)
1660	aac->init_reset = true;
1661
1662	aac->fibs = kcalloc(n: shost->can_queue + AAC_NUM_MGT_FIB,
1663	size: sizeof(struct fib),
1664	GFP_KERNEL);
1665	if (!aac->fibs) {
1666	error = -ENOMEM;
1667	goto out_free_host;
1668	}
1669
1670	spin_lock_init(&aac->fib_lock);
1671
1672	mutex_init(&aac->ioctl_mutex);
1673	mutex_init(&aac->scan_mutex);
1674
1675	INIT_DELAYED_WORK(&aac->safw_rescan_work, aac_safw_rescan_worker);
1676	INIT_DELAYED_WORK(&aac->src_reinit_aif_worker,
1677	aac_src_reinit_aif_worker);
1678	/*
1679	* Map in the registers from the adapter.
1680	*/
1681	aac->base_size = AAC_MIN_FOOTPRINT_SIZE;
1682	if ((*aac_drivers[index].init)(aac)) {
1683	error = -ENODEV;
1684	goto out_unmap;
1685	}
1686
1687	if (aac->sync_mode) {
1688	if (aac_sync_mode)
1689	printk(KERN_INFO "%s%d: Sync. mode enforced "
1690	"by driver parameter. This will cause "
1691	"a significant performance decrease!\n",
1692	aac->name,
1693	aac->id);
1694	else
1695	printk(KERN_INFO "%s%d: Async. mode not supported "
1696	"by current driver, sync. mode enforced."
1697	"\nPlease update driver to get full performance.\n",
1698	aac->name,
1699	aac->id);
1700	}
1701
1702	/*
1703	* Start any kernel threads needed
1704	*/
1705	aac->thread = kthread_run(aac_command_thread, aac, AAC_DRIVERNAME);
1706	if (IS_ERR(ptr: aac->thread)) {
1707	printk(KERN_ERR "aacraid: Unable to create command thread.\n");
1708	error = PTR_ERR(ptr: aac->thread);
1709	aac->thread = NULL;
1710	goto out_deinit;
1711	}
1712
1713	aac->maximum_num_channels = aac_drivers[index].channels;
1714	error = aac_get_adapter_info(dev: aac);
1715	if (error < `0`)
1716	goto out_deinit;
1717
1718	/*
1719	* Lets override negotiations and drop the maximum SG limit to 34
1720	*/
1721	if ((aac_drivers[index].quirks & AAC_QUIRK_34SG) &&
1722	(shost->sg_tablesize > `34`)) {
1723	shost->sg_tablesize = `34`;
1724	shost->max_sectors = (shost->sg_tablesize * `8`) + `112`;
1725	}
1726
1727	if ((aac_drivers[index].quirks & AAC_QUIRK_17SG) &&
1728	(shost->sg_tablesize > `17`)) {
1729	shost->sg_tablesize = `17`;
1730	shost->max_sectors = (shost->sg_tablesize * `8`) + `112`;
1731	}
1732
1733	if (aac->adapter_info.options & AAC_OPT_NEW_COMM)
1734	shost->max_segment_size = shost->max_sectors << `9`;
1735	else
1736	shost->max_segment_size = `65536`;
1737
1738	/*
1739	* Firmware printf works only with older firmware.
1740	*/
1741	if (aac_drivers[index].quirks & AAC_QUIRK_34SG)
1742	aac->printf_enabled = `1`;
1743	else
1744	aac->printf_enabled = `0`;
1745
1746	/*
1747	* max channel will be the physical channels plus 1 virtual channel
1748	* all containers are on the virtual channel 0 (CONTAINER_CHANNEL)
1749	* physical channels are address by their actual physical number+1
1750	*/
1751	if (aac->nondasd_support \|\| expose_physicals \|\| aac->jbod)
1752	shost->max_channel = aac->maximum_num_channels;
1753	else
1754	shost->max_channel = `0`;
1755
1756	aac_get_config_status(dev: aac, commit_flag: `0`);
1757	aac_get_containers(dev: aac);
1758	list_add(new: &aac->entry, head: insert);
1759
1760	shost->max_id = aac->maximum_num_containers;
1761	if (shost->max_id < aac->maximum_num_physicals)
1762	shost->max_id = aac->maximum_num_physicals;
1763	if (shost->max_id < MAXIMUM_NUM_CONTAINERS)
1764	shost->max_id = MAXIMUM_NUM_CONTAINERS;
1765	else
1766	shost->this_id = shost->max_id;
1767
1768	if (!aac->sa_firmware && aac_drivers[index].quirks & AAC_QUIRK_SRC)
1769	aac_intr_normal(dev: aac, Index: `0`, isAif: `2`, isFastResponse: `0`, NULL);
1770
1771	/*
1772	* dmb - we may need to move the setting of these parms somewhere else once
1773	* we get a fib that can report the actual numbers
1774	*/
1775	shost->max_lun = AAC_MAX_LUN;
1776
1777	pci_set_drvdata(pdev, data: shost);
1778
1779	error = scsi_add_host(host: shost, dev: &pdev->dev);
1780	if (error)
1781	goto out_deinit;
1782
1783	aac_scan_host(dev: aac);
1784
1785	pci_save_state(dev: pdev);
1786
1787	return `0`;
1788
1789	out_deinit:
1790	__aac_shutdown(aac);
1791	out_unmap:
1792	aac_fib_map_free(dev: aac);
1793	if (aac->comm_addr)
1794	dma_free_coherent(dev: &aac->pdev->dev, size: aac->comm_size,
1795	cpu_addr: aac->comm_addr, dma_handle: aac->comm_phys);
1796	kfree(objp: aac->queues);
1797	aac_adapter_ioremap(aac, `0`);
1798	kfree(objp: aac->fibs);
1799	kfree(objp: aac->fsa_dev);
1800	out_free_host:
1801	scsi_host_put(t: shost);
1802	out_disable_pdev:
1803	pci_disable_device(dev: pdev);
1804	out:
1805	return error;
1806	}
1807
1808	static void aac_release_resources(struct aac_dev *aac)
1809	{
1810	aac_adapter_disable_int(aac);
1811	aac_free_irq(dev: aac);
1812	}
1813
1814	static int aac_acquire_resources(struct aac_dev *dev)
1815	{
1816	unsigned long status;
1817	/*
1818	* First clear out all interrupts. Then enable the one's that we
1819	* can handle.
1820	*/
1821	while (!((status = src_readl(dev, MUnit.OMR)) & KERNEL_UP_AND_RUNNING)
1822	\|\| status == `0xffffffff`)
1823	msleep(msecs: `20`);
1824
1825	aac_adapter_disable_int(dev);
1826	aac_adapter_enable_int(dev);
1827
1828
1829	if (aac_is_src(dev))
1830	aac_define_int_mode(dev);
1831
1832	if (dev->msi_enabled)
1833	aac_src_access_devreg(dev, mode: AAC_ENABLE_MSIX);
1834
1835	if (aac_acquire_irq(dev))
1836	goto error_iounmap;
1837
1838	aac_adapter_enable_int(dev);
1839
1840	/max msix may change after EEH*
1841	* Re-assign vectors to fibs
1842	*/
1843	aac_fib_vector_assign(dev);
1844
1845	if (!dev->sync_mode) {
1846	/ After EEH recovery or suspend resume, max_msix count*
1847	* may change, therefore updating in init as well.
1848	*/
1849	dev->init->r7.no_of_msix_vectors = cpu_to_le32(dev->max_msix);
1850	aac_adapter_start(dev);
1851	}
1852	return `0`;
1853
1854	error_iounmap:
1855	return -`1`;
1856
1857	}
1858
1859	static int __maybe_unused aac_suspend(struct device *dev)
1860	{
1861	struct Scsi_Host *shost = dev_get_drvdata(dev);
1862	struct aac_dev aac = (struct* aac_dev *)shost->hostdata;
1863
1864	scsi_host_block(shost);
1865	aac_cancel_rescan_worker(dev: aac);
1866	aac_send_shutdown(dev: aac);
1867
1868	aac_release_resources(aac);
1869
1870	return `0`;
1871	}
1872
1873	static int __maybe_unused aac_resume(struct device *dev)
1874	{
1875	struct Scsi_Host *shost = dev_get_drvdata(dev);
1876	struct aac_dev aac = (struct* aac_dev *)shost->hostdata;
1877
1878	if (aac_acquire_resources(dev: aac))
1879	goto fail_device;
1880	/*
1881	* reset this flag to unblock ioctl() as it was set at
1882	* aac_send_shutdown() to block ioctls from upperlayer
1883	*/
1884	aac->adapter_shutdown = `0`;
1885	scsi_host_unblock(shost, new_state: SDEV_RUNNING);
1886
1887	return `0`;
1888
1889	fail_device:
1890	printk(KERN_INFO "%s%d: resume failed.\n", aac->name, aac->id);
1891	scsi_host_put(t: shost);
1892	return -ENODEV;
1893	}
1894
1895	static void aac_shutdown(struct pci_dev *dev)
1896	{
1897	struct Scsi_Host *shost = pci_get_drvdata(pdev: dev);
1898
1899	scsi_host_block(shost);
1900	__aac_shutdown(aac: (struct aac_dev *)shost->hostdata);
1901	}
1902
1903	static void aac_remove_one(struct pci_dev *pdev)
1904	{
1905	struct Scsi_Host *shost = pci_get_drvdata(pdev);
1906	struct aac_dev aac = (struct* aac_dev *)shost->hostdata;
1907
1908	aac_cancel_rescan_worker(dev: aac);
1909	scsi_remove_host(shost);
1910
1911	__aac_shutdown(aac);
1912	aac_fib_map_free(dev: aac);
1913	dma_free_coherent(dev: &aac->pdev->dev, size: aac->comm_size, cpu_addr: aac->comm_addr,
1914	dma_handle: aac->comm_phys);
1915	kfree(objp: aac->queues);
1916
1917	aac_adapter_ioremap(aac, `0`);
1918
1919	kfree(objp: aac->fibs);
1920	kfree(objp: aac->fsa_dev);
1921
1922	list_del(entry: &aac->entry);
1923	scsi_host_put(t: shost);
1924	pci_disable_device(dev: pdev);
1925	if (list_empty(head: &aac_devices)) {
1926	unregister_chrdev(major: aac_cfg_major, name: "aac");
1927	aac_cfg_major = AAC_CHARDEV_NEEDS_REINIT;
1928	}
1929	}
1930
1931	static pci_ers_result_t aac_pci_error_detected(struct pci_dev *pdev,
1932	pci_channel_state_t error)
1933	{
1934	struct Scsi_Host *shost = pci_get_drvdata(pdev);
1935	struct aac_dev *aac = shost_priv(shost);
1936
1937	dev_err(&pdev->dev, "aacraid: PCI error detected %x\n", error);
1938
1939	switch (error) {
1940	case pci_channel_io_normal:
1941	return PCI_ERS_RESULT_CAN_RECOVER;
1942	case pci_channel_io_frozen:
1943	aac->handle_pci_error = `1`;
1944
1945	scsi_host_block(shost);
1946	aac_cancel_rescan_worker(dev: aac);
1947	scsi_host_complete_all_commands(shost, status: DID_NO_CONNECT);
1948	aac_release_resources(aac);
1949
1950	aac_adapter_ioremap(aac, `0`);
1951
1952	return PCI_ERS_RESULT_NEED_RESET;
1953	case pci_channel_io_perm_failure:
1954	aac->handle_pci_error = `1`;
1955
1956	scsi_host_complete_all_commands(shost, status: DID_NO_CONNECT);
1957	return PCI_ERS_RESULT_DISCONNECT;
1958	}
1959
1960	return PCI_ERS_RESULT_NEED_RESET;
1961	}
1962
1963	static pci_ers_result_t aac_pci_mmio_enabled(struct pci_dev *pdev)
1964	{
1965	dev_err(&pdev->dev, "aacraid: PCI error - mmio enabled\n");
1966	return PCI_ERS_RESULT_NEED_RESET;
1967	}
1968
1969	static pci_ers_result_t aac_pci_slot_reset(struct pci_dev *pdev)
1970	{
1971	dev_err(&pdev->dev, "aacraid: PCI error - slot reset\n");
1972	pci_restore_state(dev: pdev);
1973	if (pci_enable_device(dev: pdev)) {
1974	dev_warn(&pdev->dev,
1975	"aacraid: failed to enable slave\n");
1976	goto fail_device;
1977	}
1978
1979	pci_set_master(dev: pdev);
1980
1981	if (pci_enable_device_mem(dev: pdev)) {
1982	dev_err(&pdev->dev, "pci_enable_device_mem failed\n");
1983	goto fail_device;
1984	}
1985
1986	return PCI_ERS_RESULT_RECOVERED;
1987
1988	fail_device:
1989	dev_err(&pdev->dev, "aacraid: PCI error - slot reset failed\n");
1990	return PCI_ERS_RESULT_DISCONNECT;
1991	}
1992
1993
1994	static void aac_pci_resume(struct pci_dev *pdev)
1995	{
1996	struct Scsi_Host *shost = pci_get_drvdata(pdev);
1997	struct aac_dev aac = (struct* aac_dev *)shost_priv(shost);
1998
1999	if (aac_adapter_ioremap(aac, aac->base_size)) {
2000
2001	dev_err(&pdev->dev, "aacraid: ioremap failed\n");
2002	/ remap failed, go back ... /
2003	aac->comm_interface = AAC_COMM_PRODUCER;
2004	if (aac_adapter_ioremap(aac, AAC_MIN_FOOTPRINT_SIZE)) {
2005	dev_warn(&pdev->dev,
2006	"aacraid: unable to map adapter.\n");
2007
2008	return;
2009	}
2010	}
2011
2012	msleep(msecs: `10000`);
2013
2014	aac_acquire_resources(dev: aac);
2015
2016	/*
2017	* reset this flag to unblock ioctl() as it was set
2018	* at aac_send_shutdown() to block ioctls from upperlayer
2019	*/
2020	aac->adapter_shutdown = `0`;
2021	aac->handle_pci_error = `0`;
2022
2023	scsi_host_unblock(shost, new_state: SDEV_RUNNING);
2024	aac_scan_host(dev: aac);
2025	pci_save_state(dev: pdev);
2026
2027	dev_err(&pdev->dev, "aacraid: PCI error - resume\n");
2028	}
2029
2030	static struct pci_error_handlers aac_pci_err_handler = {
2031	.error_detected = aac_pci_error_detected,
2032	.mmio_enabled = aac_pci_mmio_enabled,
2033	.slot_reset = aac_pci_slot_reset,
2034	.resume = aac_pci_resume,
2035	};
2036
2037	static SIMPLE_DEV_PM_OPS(aac_pm_ops, aac_suspend, aac_resume);
2038
2039	static struct pci_driver aac_pci_driver = {
2040	.name = AAC_DRIVERNAME,
2041	.id_table = aac_pci_tbl,
2042	.probe = aac_probe_one,
2043	.remove = aac_remove_one,
2044	.driver.pm = &aac_pm_ops,
2045	.shutdown = aac_shutdown,
2046	.err_handler = &aac_pci_err_handler,
2047	};
2048
2049	static int __init aac_init(void)
2050	{
2051	int error;
2052
2053	printk(KERN_INFO "Adaptec %s driver %s\n",
2054	AAC_DRIVERNAME, aac_driver_version);
2055
2056	error = pci_register_driver(&aac_pci_driver);
2057	if (error < `0`)
2058	return error;
2059
2060	aac_init_char();
2061
2062
2063	return `0`;
2064	}
2065
2066	static void __exit aac_exit(void)
2067	{
2068	if (aac_cfg_major > -`1`)
2069	unregister_chrdev(major: aac_cfg_major, name: "aac");
2070	pci_unregister_driver(dev: &aac_pci_driver);
2071	}
2072
2073	module_init(aac_init);
2074	module_exit(aac_exit);
2075

source code of linux/drivers/scsi/aacraid/linit.c