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

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