1 /* 2 * Adaptec AAC series RAID controller driver 3 * (c) Copyright 2001 Red Hat Inc. 4 * 5 * based on the old aacraid driver that is.. 6 * Adaptec aacraid device driver for Linux. 7 * 8 * Copyright (c) 2000-2010 Adaptec, Inc. 9 * 2010 PMC-Sierra, Inc. (aacraid@pmc-sierra.com) 10 * 11 * This program is free software; you can redistribute it and/or modify 12 * it under the terms of the GNU General Public License as published by 13 * the Free Software Foundation; either version 2, or (at your option) 14 * any later version. 15 * 16 * This program is distributed in the hope that it will be useful, 17 * but WITHOUT ANY WARRANTY; without even the implied warranty of 18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 19 * GNU General Public License for more details. 20 * 21 * You should have received a copy of the GNU General Public License 22 * along with this program; see the file COPYING. If not, write to 23 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. 24 * 25 * Module Name: 26 * linit.c 27 * 28 * Abstract: Linux Driver entry module for Adaptec RAID Array Controller 29 */ 30 31 32 #include <linux/compat.h> 33 #include <linux/blkdev.h> 34 #include <linux/completion.h> 35 #include <linux/init.h> 36 #include <linux/interrupt.h> 37 #include <linux/kernel.h> 38 #include <linux/module.h> 39 #include <linux/moduleparam.h> 40 #include <linux/pci.h> 41 #include <linux/aer.h> 42 #include <linux/pci-aspm.h> 43 #include <linux/slab.h> 44 #include <linux/mutex.h> 45 #include <linux/spinlock.h> 46 #include <linux/syscalls.h> 47 #include <linux/delay.h> 48 #include <linux/kthread.h> 49 50 #include <scsi/scsi.h> 51 #include <scsi/scsi_cmnd.h> 52 #include <scsi/scsi_device.h> 53 #include <scsi/scsi_host.h> 54 #include <scsi/scsi_tcq.h> 55 #include <scsi/scsicam.h> 56 #include <scsi/scsi_eh.h> 57 58 #include "aacraid.h" 59 60 #define AAC_DRIVER_VERSION "1.2-1" 61 #ifndef AAC_DRIVER_BRANCH 62 #define AAC_DRIVER_BRANCH "" 63 #endif 64 #define AAC_DRIVERNAME "aacraid" 65 66 #ifdef AAC_DRIVER_BUILD 67 #define _str(x) #x 68 #define str(x) _str(x) 69 #define AAC_DRIVER_FULL_VERSION AAC_DRIVER_VERSION "[" str(AAC_DRIVER_BUILD) "]" AAC_DRIVER_BRANCH 70 #else 71 #define AAC_DRIVER_FULL_VERSION AAC_DRIVER_VERSION AAC_DRIVER_BRANCH 72 #endif 73 74 MODULE_AUTHOR("Red Hat Inc and Adaptec"); 75 MODULE_DESCRIPTION("Dell PERC2, 2/Si, 3/Si, 3/Di, " 76 "Adaptec Advanced Raid Products, " 77 "HP NetRAID-4M, IBM ServeRAID & ICP SCSI driver"); 78 MODULE_LICENSE("GPL"); 79 MODULE_VERSION(AAC_DRIVER_FULL_VERSION); 80 81 static DEFINE_MUTEX(aac_mutex); 82 static LIST_HEAD(aac_devices); 83 static int aac_cfg_major = AAC_CHARDEV_UNREGISTERED; 84 char aac_driver_version[] = AAC_DRIVER_FULL_VERSION; 85 86 /* 87 * Because of the way Linux names scsi devices, the order in this table has 88 * become important. Check for on-board Raid first, add-in cards second. 89 * 90 * Note: The last field is used to index into aac_drivers below. 91 */ 92 static const struct pci_device_id aac_pci_tbl[] = { 93 { 0x1028, 0x0001, 0x1028, 0x0001, 0, 0, 0 }, /* PERC 2/Si (Iguana/PERC2Si) */ 94 { 0x1028, 0x0002, 0x1028, 0x0002, 0, 0, 1 }, /* PERC 3/Di (Opal/PERC3Di) */ 95 { 0x1028, 0x0003, 0x1028, 0x0003, 0, 0, 2 }, /* PERC 3/Si (SlimFast/PERC3Si */ 96 { 0x1028, 0x0004, 0x1028, 0x00d0, 0, 0, 3 }, /* PERC 3/Di (Iguana FlipChip/PERC3DiF */ 97 { 0x1028, 0x0002, 0x1028, 0x00d1, 0, 0, 4 }, /* PERC 3/Di (Viper/PERC3DiV) */ 98 { 0x1028, 0x0002, 0x1028, 0x00d9, 0, 0, 5 }, /* PERC 3/Di (Lexus/PERC3DiL) */ 99 { 0x1028, 0x000a, 0x1028, 0x0106, 0, 0, 6 }, /* PERC 3/Di (Jaguar/PERC3DiJ) */ 100 { 0x1028, 0x000a, 0x1028, 0x011b, 0, 0, 7 }, /* PERC 3/Di (Dagger/PERC3DiD) */ 101 { 0x1028, 0x000a, 0x1028, 0x0121, 0, 0, 8 }, /* PERC 3/Di (Boxster/PERC3DiB) */ 102 { 0x9005, 0x0283, 0x9005, 0x0283, 0, 0, 9 }, /* catapult */ 103 { 0x9005, 0x0284, 0x9005, 0x0284, 0, 0, 10 }, /* tomcat */ 104 { 0x9005, 0x0285, 0x9005, 0x0286, 0, 0, 11 }, /* Adaptec 2120S (Crusader) */ 105 { 0x9005, 0x0285, 0x9005, 0x0285, 0, 0, 12 }, /* Adaptec 2200S (Vulcan) */ 106 { 0x9005, 0x0285, 0x9005, 0x0287, 0, 0, 13 }, /* Adaptec 2200S (Vulcan-2m) */ 107 { 0x9005, 0x0285, 0x17aa, 0x0286, 0, 0, 14 }, /* Legend S220 (Legend Crusader) */ 108 { 0x9005, 0x0285, 0x17aa, 0x0287, 0, 0, 15 }, /* Legend S230 (Legend Vulcan) */ 109 110 { 0x9005, 0x0285, 0x9005, 0x0288, 0, 0, 16 }, /* Adaptec 3230S (Harrier) */ 111 { 0x9005, 0x0285, 0x9005, 0x0289, 0, 0, 17 }, /* Adaptec 3240S (Tornado) */ 112 { 0x9005, 0x0285, 0x9005, 0x028a, 0, 0, 18 }, /* ASR-2020ZCR SCSI PCI-X ZCR (Skyhawk) */ 113 { 0x9005, 0x0285, 0x9005, 0x028b, 0, 0, 19 }, /* ASR-2025ZCR SCSI SO-DIMM PCI-X ZCR (Terminator) */ 114 { 0x9005, 0x0286, 0x9005, 0x028c, 0, 0, 20 }, /* ASR-2230S + ASR-2230SLP PCI-X (Lancer) */ 115 { 0x9005, 0x0286, 0x9005, 0x028d, 0, 0, 21 }, /* ASR-2130S (Lancer) */ 116 { 0x9005, 0x0286, 0x9005, 0x029b, 0, 0, 22 }, /* AAR-2820SA (Intruder) */ 117 { 0x9005, 0x0286, 0x9005, 0x029c, 0, 0, 23 }, /* AAR-2620SA (Intruder) */ 118 { 0x9005, 0x0286, 0x9005, 0x029d, 0, 0, 24 }, /* AAR-2420SA (Intruder) */ 119 { 0x9005, 0x0286, 0x9005, 0x029e, 0, 0, 25 }, /* ICP9024RO (Lancer) */ 120 { 0x9005, 0x0286, 0x9005, 0x029f, 0, 0, 26 }, /* ICP9014RO (Lancer) */ 121 { 0x9005, 0x0286, 0x9005, 0x02a0, 0, 0, 27 }, /* ICP9047MA (Lancer) */ 122 { 0x9005, 0x0286, 0x9005, 0x02a1, 0, 0, 28 }, /* ICP9087MA (Lancer) */ 123 { 0x9005, 0x0286, 0x9005, 0x02a3, 0, 0, 29 }, /* ICP5445AU (Hurricane44) */ 124 { 0x9005, 0x0285, 0x9005, 0x02a4, 0, 0, 30 }, /* ICP9085LI (Marauder-X) */ 125 { 0x9005, 0x0285, 0x9005, 0x02a5, 0, 0, 31 }, /* ICP5085BR (Marauder-E) */ 126 { 0x9005, 0x0286, 0x9005, 0x02a6, 0, 0, 32 }, /* ICP9067MA (Intruder-6) */ 127 { 0x9005, 0x0287, 0x9005, 0x0800, 0, 0, 33 }, /* Themisto Jupiter Platform */ 128 { 0x9005, 0x0200, 0x9005, 0x0200, 0, 0, 33 }, /* Themisto Jupiter Platform */ 129 { 0x9005, 0x0286, 0x9005, 0x0800, 0, 0, 34 }, /* Callisto Jupiter Platform */ 130 { 0x9005, 0x0285, 0x9005, 0x028e, 0, 0, 35 }, /* ASR-2020SA SATA PCI-X ZCR (Skyhawk) */ 131 { 0x9005, 0x0285, 0x9005, 0x028f, 0, 0, 36 }, /* ASR-2025SA SATA SO-DIMM PCI-X ZCR (Terminator) */ 132 { 0x9005, 0x0285, 0x9005, 0x0290, 0, 0, 37 }, /* AAR-2410SA PCI SATA 4ch (Jaguar II) */ 133 { 0x9005, 0x0285, 0x1028, 0x0291, 0, 0, 38 }, /* CERC SATA RAID 2 PCI SATA 6ch (DellCorsair) */ 134 { 0x9005, 0x0285, 0x9005, 0x0292, 0, 0, 39 }, /* AAR-2810SA PCI SATA 8ch (Corsair-8) */ 135 { 0x9005, 0x0285, 0x9005, 0x0293, 0, 0, 40 }, /* AAR-21610SA PCI SATA 16ch (Corsair-16) */ 136 { 0x9005, 0x0285, 0x9005, 0x0294, 0, 0, 41 }, /* ESD SO-DIMM PCI-X SATA ZCR (Prowler) */ 137 { 0x9005, 0x0285, 0x103C, 0x3227, 0, 0, 42 }, /* AAR-2610SA PCI SATA 6ch */ 138 { 0x9005, 0x0285, 0x9005, 0x0296, 0, 0, 43 }, /* ASR-2240S (SabreExpress) */ 139 { 0x9005, 0x0285, 0x9005, 0x0297, 0, 0, 44 }, /* ASR-4005 */ 140 { 0x9005, 0x0285, 0x1014, 0x02F2, 0, 0, 45 }, /* IBM 8i (AvonPark) */ 141 { 0x9005, 0x0285, 0x1014, 0x0312, 0, 0, 45 }, /* IBM 8i (AvonPark Lite) */ 142 { 0x9005, 0x0286, 0x1014, 0x9580, 0, 0, 46 }, /* IBM 8k/8k-l8 (Aurora) */ 143 { 0x9005, 0x0286, 0x1014, 0x9540, 0, 0, 47 }, /* IBM 8k/8k-l4 (Aurora Lite) */ 144 { 0x9005, 0x0285, 0x9005, 0x0298, 0, 0, 48 }, /* ASR-4000 (BlackBird) */ 145 { 0x9005, 0x0285, 0x9005, 0x0299, 0, 0, 49 }, /* ASR-4800SAS (Marauder-X) */ 146 { 0x9005, 0x0285, 0x9005, 0x029a, 0, 0, 50 }, /* ASR-4805SAS (Marauder-E) */ 147 { 0x9005, 0x0286, 0x9005, 0x02a2, 0, 0, 51 }, /* ASR-3800 (Hurricane44) */ 148 149 { 0x9005, 0x0285, 0x1028, 0x0287, 0, 0, 52 }, /* Perc 320/DC*/ 150 { 0x1011, 0x0046, 0x9005, 0x0365, 0, 0, 53 }, /* Adaptec 5400S (Mustang)*/ 151 { 0x1011, 0x0046, 0x9005, 0x0364, 0, 0, 54 }, /* Adaptec 5400S (Mustang)*/ 152 { 0x1011, 0x0046, 0x9005, 0x1364, 0, 0, 55 }, /* Dell PERC2/QC */ 153 { 0x1011, 0x0046, 0x103c, 0x10c2, 0, 0, 56 }, /* HP NetRAID-4M */ 154 155 { 0x9005, 0x0285, 0x1028, PCI_ANY_ID, 0, 0, 57 }, /* Dell Catchall */ 156 { 0x9005, 0x0285, 0x17aa, PCI_ANY_ID, 0, 0, 58 }, /* Legend Catchall */ 157 { 0x9005, 0x0285, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 59 }, /* Adaptec Catch All */ 158 { 0x9005, 0x0286, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 60 }, /* Adaptec Rocket Catch All */ 159 { 0x9005, 0x0288, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 61 }, /* Adaptec NEMER/ARK Catch All */ 160 { 0x9005, 0x028b, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 62 }, /* Adaptec PMC Series 6 (Tupelo) */ 161 { 0x9005, 0x028c, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 63 }, /* Adaptec PMC Series 7 (Denali) */ 162 { 0x9005, 0x028d, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 64 }, /* Adaptec PMC Series 8 */ 163 { 0x9005, 0x028f, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 65 }, /* Adaptec PMC Series 9 */ 164 { 0,} 165 }; 166 MODULE_DEVICE_TABLE(pci, aac_pci_tbl); 167 168 /* 169 * dmb - For now we add the number of channels to this structure. 170 * In the future we should add a fib that reports the number of channels 171 * for the card. At that time we can remove the channels from here 172 */ 173 static struct aac_driver_ident aac_drivers[] = { 174 { aac_rx_init, "percraid", "DELL ", "PERCRAID ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG | AAC_QUIRK_SCSI_32 }, /* PERC 2/Si (Iguana/PERC2Si) */ 175 { aac_rx_init, "percraid", "DELL ", "PERCRAID ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG | AAC_QUIRK_SCSI_32 }, /* PERC 3/Di (Opal/PERC3Di) */ 176 { aac_rx_init, "percraid", "DELL ", "PERCRAID ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG | AAC_QUIRK_SCSI_32 }, /* PERC 3/Si (SlimFast/PERC3Si */ 177 { aac_rx_init, "percraid", "DELL ", "PERCRAID ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG | AAC_QUIRK_SCSI_32 }, /* PERC 3/Di (Iguana FlipChip/PERC3DiF */ 178 { aac_rx_init, "percraid", "DELL ", "PERCRAID ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG | AAC_QUIRK_SCSI_32 }, /* PERC 3/Di (Viper/PERC3DiV) */ 179 { aac_rx_init, "percraid", "DELL ", "PERCRAID ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG | AAC_QUIRK_SCSI_32 }, /* PERC 3/Di (Lexus/PERC3DiL) */ 180 { aac_rx_init, "percraid", "DELL ", "PERCRAID ", 1, AAC_QUIRK_31BIT | AAC_QUIRK_34SG | AAC_QUIRK_SCSI_32 }, /* PERC 3/Di (Jaguar/PERC3DiJ) */ 181 { aac_rx_init, "percraid", "DELL ", "PERCRAID ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG | AAC_QUIRK_SCSI_32 }, /* PERC 3/Di (Dagger/PERC3DiD) */ 182 { aac_rx_init, "percraid", "DELL ", "PERCRAID ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG | AAC_QUIRK_SCSI_32 }, /* PERC 3/Di (Boxster/PERC3DiB) */ 183 { aac_rx_init, "aacraid", "ADAPTEC ", "catapult ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG | AAC_QUIRK_SCSI_32 }, /* catapult */ 184 { aac_rx_init, "aacraid", "ADAPTEC ", "tomcat ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG | AAC_QUIRK_SCSI_32 }, /* tomcat */ 185 { aac_rx_init, "aacraid", "ADAPTEC ", "Adaptec 2120S ", 1, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* Adaptec 2120S (Crusader) */ 186 { aac_rx_init, "aacraid", "ADAPTEC ", "Adaptec 2200S ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* Adaptec 2200S (Vulcan) */ 187 { aac_rx_init, "aacraid", "ADAPTEC ", "Adaptec 2200S ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG | AAC_QUIRK_SCSI_32 }, /* Adaptec 2200S (Vulcan-2m) */ 188 { aac_rx_init, "aacraid", "Legend ", "Legend S220 ", 1, AAC_QUIRK_31BIT | AAC_QUIRK_34SG | AAC_QUIRK_SCSI_32 }, /* Legend S220 (Legend Crusader) */ 189 { aac_rx_init, "aacraid", "Legend ", "Legend S230 ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG | AAC_QUIRK_SCSI_32 }, /* Legend S230 (Legend Vulcan) */ 190 191 { aac_rx_init, "aacraid", "ADAPTEC ", "Adaptec 3230S ", 2 }, /* Adaptec 3230S (Harrier) */ 192 { aac_rx_init, "aacraid", "ADAPTEC ", "Adaptec 3240S ", 2 }, /* Adaptec 3240S (Tornado) */ 193 { aac_rx_init, "aacraid", "ADAPTEC ", "ASR-2020ZCR ", 2 }, /* ASR-2020ZCR SCSI PCI-X ZCR (Skyhawk) */ 194 { aac_rx_init, "aacraid", "ADAPTEC ", "ASR-2025ZCR ", 2 }, /* ASR-2025ZCR SCSI SO-DIMM PCI-X ZCR (Terminator) */ 195 { aac_rkt_init, "aacraid", "ADAPTEC ", "ASR-2230S PCI-X ", 2 }, /* ASR-2230S + ASR-2230SLP PCI-X (Lancer) */ 196 { aac_rkt_init, "aacraid", "ADAPTEC ", "ASR-2130S PCI-X ", 1 }, /* ASR-2130S (Lancer) */ 197 { aac_rkt_init, "aacraid", "ADAPTEC ", "AAR-2820SA ", 1 }, /* AAR-2820SA (Intruder) */ 198 { aac_rkt_init, "aacraid", "ADAPTEC ", "AAR-2620SA ", 1 }, /* AAR-2620SA (Intruder) */ 199 { aac_rkt_init, "aacraid", "ADAPTEC ", "AAR-2420SA ", 1 }, /* AAR-2420SA (Intruder) */ 200 { aac_rkt_init, "aacraid", "ICP ", "ICP9024RO ", 2 }, /* ICP9024RO (Lancer) */ 201 { aac_rkt_init, "aacraid", "ICP ", "ICP9014RO ", 1 }, /* ICP9014RO (Lancer) */ 202 { aac_rkt_init, "aacraid", "ICP ", "ICP9047MA ", 1 }, /* ICP9047MA (Lancer) */ 203 { aac_rkt_init, "aacraid", "ICP ", "ICP9087MA ", 1 }, /* ICP9087MA (Lancer) */ 204 { aac_rkt_init, "aacraid", "ICP ", "ICP5445AU ", 1 }, /* ICP5445AU (Hurricane44) */ 205 { aac_rx_init, "aacraid", "ICP ", "ICP9085LI ", 1 }, /* ICP9085LI (Marauder-X) */ 206 { aac_rx_init, "aacraid", "ICP ", "ICP5085BR ", 1 }, /* ICP5085BR (Marauder-E) */ 207 { aac_rkt_init, "aacraid", "ICP ", "ICP9067MA ", 1 }, /* ICP9067MA (Intruder-6) */ 208 { NULL , "aacraid", "ADAPTEC ", "Themisto ", 0, AAC_QUIRK_SLAVE }, /* Jupiter Platform */ 209 { aac_rkt_init, "aacraid", "ADAPTEC ", "Callisto ", 2, AAC_QUIRK_MASTER }, /* Jupiter Platform */ 210 { aac_rx_init, "aacraid", "ADAPTEC ", "ASR-2020SA ", 1 }, /* ASR-2020SA SATA PCI-X ZCR (Skyhawk) */ 211 { aac_rx_init, "aacraid", "ADAPTEC ", "ASR-2025SA ", 1 }, /* ASR-2025SA SATA SO-DIMM PCI-X ZCR (Terminator) */ 212 { aac_rx_init, "aacraid", "ADAPTEC ", "AAR-2410SA SATA ", 1, AAC_QUIRK_17SG }, /* AAR-2410SA PCI SATA 4ch (Jaguar II) */ 213 { aac_rx_init, "aacraid", "DELL ", "CERC SR2 ", 1, AAC_QUIRK_17SG }, /* CERC SATA RAID 2 PCI SATA 6ch (DellCorsair) */ 214 { aac_rx_init, "aacraid", "ADAPTEC ", "AAR-2810SA SATA ", 1, AAC_QUIRK_17SG }, /* AAR-2810SA PCI SATA 8ch (Corsair-8) */ 215 { aac_rx_init, "aacraid", "ADAPTEC ", "AAR-21610SA SATA", 1, AAC_QUIRK_17SG }, /* AAR-21610SA PCI SATA 16ch (Corsair-16) */ 216 { aac_rx_init, "aacraid", "ADAPTEC ", "ASR-2026ZCR ", 1 }, /* ESD SO-DIMM PCI-X SATA ZCR (Prowler) */ 217 { aac_rx_init, "aacraid", "ADAPTEC ", "AAR-2610SA ", 1 }, /* SATA 6Ch (Bearcat) */ 218 { aac_rx_init, "aacraid", "ADAPTEC ", "ASR-2240S ", 1 }, /* ASR-2240S (SabreExpress) */ 219 { aac_rx_init, "aacraid", "ADAPTEC ", "ASR-4005 ", 1 }, /* ASR-4005 */ 220 { aac_rx_init, "ServeRAID","IBM ", "ServeRAID 8i ", 1 }, /* IBM 8i (AvonPark) */ 221 { aac_rkt_init, "ServeRAID","IBM ", "ServeRAID 8k-l8 ", 1 }, /* IBM 8k/8k-l8 (Aurora) */ 222 { aac_rkt_init, "ServeRAID","IBM ", "ServeRAID 8k-l4 ", 1 }, /* IBM 8k/8k-l4 (Aurora Lite) */ 223 { aac_rx_init, "aacraid", "ADAPTEC ", "ASR-4000 ", 1 }, /* ASR-4000 (BlackBird & AvonPark) */ 224 { aac_rx_init, "aacraid", "ADAPTEC ", "ASR-4800SAS ", 1 }, /* ASR-4800SAS (Marauder-X) */ 225 { aac_rx_init, "aacraid", "ADAPTEC ", "ASR-4805SAS ", 1 }, /* ASR-4805SAS (Marauder-E) */ 226 { aac_rkt_init, "aacraid", "ADAPTEC ", "ASR-3800 ", 1 }, /* ASR-3800 (Hurricane44) */ 227 228 { aac_rx_init, "percraid", "DELL ", "PERC 320/DC ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* Perc 320/DC*/ 229 { aac_sa_init, "aacraid", "ADAPTEC ", "Adaptec 5400S ", 4, AAC_QUIRK_34SG }, /* Adaptec 5400S (Mustang)*/ 230 { aac_sa_init, "aacraid", "ADAPTEC ", "AAC-364 ", 4, AAC_QUIRK_34SG }, /* Adaptec 5400S (Mustang)*/ 231 { aac_sa_init, "percraid", "DELL ", "PERCRAID ", 4, AAC_QUIRK_34SG }, /* Dell PERC2/QC */ 232 { aac_sa_init, "hpnraid", "HP ", "NetRAID ", 4, AAC_QUIRK_34SG }, /* HP NetRAID-4M */ 233 234 { aac_rx_init, "aacraid", "DELL ", "RAID ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG | AAC_QUIRK_SCSI_32 }, /* Dell Catchall */ 235 { aac_rx_init, "aacraid", "Legend ", "RAID ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG | AAC_QUIRK_SCSI_32 }, /* Legend Catchall */ 236 { aac_rx_init, "aacraid", "ADAPTEC ", "RAID ", 2 }, /* Adaptec Catch All */ 237 { aac_rkt_init, "aacraid", "ADAPTEC ", "RAID ", 2 }, /* Adaptec Rocket Catch All */ 238 { aac_nark_init, "aacraid", "ADAPTEC ", "RAID ", 2 }, /* Adaptec NEMER/ARK Catch All */ 239 { aac_src_init, "aacraid", "ADAPTEC ", "RAID ", 2 }, /* Adaptec PMC Series 6 (Tupelo) */ 240 { aac_srcv_init, "aacraid", "ADAPTEC ", "RAID ", 2 }, /* Adaptec PMC Series 7 (Denali) */ 241 { aac_srcv_init, "aacraid", "ADAPTEC ", "RAID ", 2 }, /* Adaptec PMC Series 8 */ 242 { aac_srcv_init, "aacraid", "ADAPTEC ", "RAID ", 2 } /* Adaptec PMC Series 9 */ 243 }; 244 245 /** 246 * aac_queuecommand - queue a SCSI command 247 * @cmd: SCSI command to queue 248 * @done: Function to call on command completion 249 * 250 * Queues a command for execution by the associated Host Adapter. 251 * 252 * TODO: unify with aac_scsi_cmd(). 253 */ 254 255 static int aac_queuecommand(struct Scsi_Host *shost, 256 struct scsi_cmnd *cmd) 257 { 258 int r = 0; 259 cmd->SCp.phase = AAC_OWNER_LOWLEVEL; 260 r = (aac_scsi_cmd(cmd) ? FAILED : 0); 261 return r; 262 } 263 264 /** 265 * aac_info - Returns the host adapter name 266 * @shost: Scsi host to report on 267 * 268 * Returns a static string describing the device in question 269 */ 270 271 static const char *aac_info(struct Scsi_Host *shost) 272 { 273 struct aac_dev *dev = (struct aac_dev *)shost->hostdata; 274 return aac_drivers[dev->cardtype].name; 275 } 276 277 /** 278 * aac_get_driver_ident 279 * @devtype: index into lookup table 280 * 281 * Returns a pointer to the entry in the driver lookup table. 282 */ 283 284 struct aac_driver_ident* aac_get_driver_ident(int devtype) 285 { 286 return &aac_drivers[devtype]; 287 } 288 289 /** 290 * aac_biosparm - return BIOS parameters for disk 291 * @sdev: The scsi device corresponding to the disk 292 * @bdev: the block device corresponding to the disk 293 * @capacity: the sector capacity of the disk 294 * @geom: geometry block to fill in 295 * 296 * Return the Heads/Sectors/Cylinders BIOS Disk Parameters for Disk. 297 * The default disk geometry is 64 heads, 32 sectors, and the appropriate 298 * number of cylinders so as not to exceed drive capacity. In order for 299 * disks equal to or larger than 1 GB to be addressable by the BIOS 300 * without exceeding the BIOS limitation of 1024 cylinders, Extended 301 * Translation should be enabled. With Extended Translation enabled, 302 * drives between 1 GB inclusive and 2 GB exclusive are given a disk 303 * geometry of 128 heads and 32 sectors, and drives above 2 GB inclusive 304 * are given a disk geometry of 255 heads and 63 sectors. However, if 305 * the BIOS detects that the Extended Translation setting does not match 306 * the geometry in the partition table, then the translation inferred 307 * from the partition table will be used by the BIOS, and a warning may 308 * be displayed. 309 */ 310 311 static int aac_biosparm(struct scsi_device *sdev, struct block_device *bdev, 312 sector_t capacity, int *geom) 313 { 314 struct diskparm *param = (struct diskparm *)geom; 315 unsigned char *buf; 316 317 dprintk((KERN_DEBUG "aac_biosparm.\n")); 318 319 /* 320 * Assuming extended translation is enabled - #REVISIT# 321 */ 322 if (capacity >= 2 * 1024 * 1024) { /* 1 GB in 512 byte sectors */ 323 if(capacity >= 4 * 1024 * 1024) { /* 2 GB in 512 byte sectors */ 324 param->heads = 255; 325 param->sectors = 63; 326 } else { 327 param->heads = 128; 328 param->sectors = 32; 329 } 330 } else { 331 param->heads = 64; 332 param->sectors = 32; 333 } 334 335 param->cylinders = cap_to_cyls(capacity, param->heads * param->sectors); 336 337 /* 338 * Read the first 1024 bytes from the disk device, if the boot 339 * sector partition table is valid, search for a partition table 340 * entry whose end_head matches one of the standard geometry 341 * translations ( 64/32, 128/32, 255/63 ). 342 */ 343 buf = scsi_bios_ptable(bdev); 344 if (!buf) 345 return 0; 346 if(*(__le16 *)(buf + 0x40) == cpu_to_le16(0xaa55)) { 347 struct partition *first = (struct partition * )buf; 348 struct partition *entry = first; 349 int saved_cylinders = param->cylinders; 350 int num; 351 unsigned char end_head, end_sec; 352 353 for(num = 0; num < 4; num++) { 354 end_head = entry->end_head; 355 end_sec = entry->end_sector & 0x3f; 356 357 if(end_head == 63) { 358 param->heads = 64; 359 param->sectors = 32; 360 break; 361 } else if(end_head == 127) { 362 param->heads = 128; 363 param->sectors = 32; 364 break; 365 } else if(end_head == 254) { 366 param->heads = 255; 367 param->sectors = 63; 368 break; 369 } 370 entry++; 371 } 372 373 if (num == 4) { 374 end_head = first->end_head; 375 end_sec = first->end_sector & 0x3f; 376 } 377 378 param->cylinders = cap_to_cyls(capacity, param->heads * param->sectors); 379 if (num < 4 && end_sec == param->sectors) { 380 if (param->cylinders != saved_cylinders) 381 dprintk((KERN_DEBUG "Adopting geometry: heads=%d, sectors=%d from partition table %d.\n", 382 param->heads, param->sectors, num)); 383 } else if (end_head > 0 || end_sec > 0) { 384 dprintk((KERN_DEBUG "Strange geometry: heads=%d, sectors=%d in partition table %d.\n", 385 end_head + 1, end_sec, num)); 386 dprintk((KERN_DEBUG "Using geometry: heads=%d, sectors=%d.\n", 387 param->heads, param->sectors)); 388 } 389 } 390 kfree(buf); 391 return 0; 392 } 393 394 /** 395 * aac_slave_configure - compute queue depths 396 * @sdev: SCSI device we are considering 397 * 398 * Selects queue depths for each target device based on the host adapter's 399 * total capacity and the queue depth supported by the target device. 400 * A queue depth of one automatically disables tagged queueing. 401 */ 402 403 static int aac_slave_configure(struct scsi_device *sdev) 404 { 405 struct aac_dev *aac = (struct aac_dev *)sdev->host->hostdata; 406 if (aac->jbod && (sdev->type == TYPE_DISK)) 407 sdev->removable = 1; 408 if ((sdev->type == TYPE_DISK) && 409 (sdev_channel(sdev) != CONTAINER_CHANNEL) && 410 (!aac->jbod || sdev->inq_periph_qual) && 411 (!aac->raid_scsi_mode || (sdev_channel(sdev) != 2))) { 412 if (expose_physicals == 0) 413 return -ENXIO; 414 if (expose_physicals < 0) 415 sdev->no_uld_attach = 1; 416 } 417 if (sdev->tagged_supported && (sdev->type == TYPE_DISK) && 418 (!aac->raid_scsi_mode || (sdev_channel(sdev) != 2)) && 419 !sdev->no_uld_attach) { 420 struct scsi_device * dev; 421 struct Scsi_Host *host = sdev->host; 422 unsigned num_lsu = 0; 423 unsigned num_one = 0; 424 unsigned depth; 425 unsigned cid; 426 427 /* 428 * Firmware has an individual device recovery time typically 429 * of 35 seconds, give us a margin. 430 */ 431 if (sdev->request_queue->rq_timeout < (45 * HZ)) 432 blk_queue_rq_timeout(sdev->request_queue, 45*HZ); 433 for (cid = 0; cid < aac->maximum_num_containers; ++cid) 434 if (aac->fsa_dev[cid].valid) 435 ++num_lsu; 436 __shost_for_each_device(dev, host) { 437 if (dev->tagged_supported && (dev->type == TYPE_DISK) && 438 (!aac->raid_scsi_mode || 439 (sdev_channel(sdev) != 2)) && 440 !dev->no_uld_attach) { 441 if ((sdev_channel(dev) != CONTAINER_CHANNEL) 442 || !aac->fsa_dev[sdev_id(dev)].valid) 443 ++num_lsu; 444 } else 445 ++num_one; 446 } 447 if (num_lsu == 0) 448 ++num_lsu; 449 depth = (host->can_queue - num_one) / num_lsu; 450 if (depth > 256) 451 depth = 256; 452 else if (depth < 2) 453 depth = 2; 454 scsi_change_queue_depth(sdev, depth); 455 } else 456 scsi_change_queue_depth(sdev, 1); 457 458 sdev->tagged_supported = 1; 459 460 return 0; 461 } 462 463 /** 464 * aac_change_queue_depth - alter queue depths 465 * @sdev: SCSI device we are considering 466 * @depth: desired queue depth 467 * 468 * Alters queue depths for target device based on the host adapter's 469 * total capacity and the queue depth supported by the target device. 470 */ 471 472 static int aac_change_queue_depth(struct scsi_device *sdev, int depth) 473 { 474 if (sdev->tagged_supported && (sdev->type == TYPE_DISK) && 475 (sdev_channel(sdev) == CONTAINER_CHANNEL)) { 476 struct scsi_device * dev; 477 struct Scsi_Host *host = sdev->host; 478 unsigned num = 0; 479 480 __shost_for_each_device(dev, host) { 481 if (dev->tagged_supported && (dev->type == TYPE_DISK) && 482 (sdev_channel(dev) == CONTAINER_CHANNEL)) 483 ++num; 484 ++num; 485 } 486 if (num >= host->can_queue) 487 num = host->can_queue - 1; 488 if (depth > (host->can_queue - num)) 489 depth = host->can_queue - num; 490 if (depth > 256) 491 depth = 256; 492 else if (depth < 2) 493 depth = 2; 494 return scsi_change_queue_depth(sdev, depth); 495 } 496 497 return scsi_change_queue_depth(sdev, 1); 498 } 499 500 static ssize_t aac_show_raid_level(struct device *dev, struct device_attribute *attr, char *buf) 501 { 502 struct scsi_device *sdev = to_scsi_device(dev); 503 struct aac_dev *aac = (struct aac_dev *)(sdev->host->hostdata); 504 if (sdev_channel(sdev) != CONTAINER_CHANNEL) 505 return snprintf(buf, PAGE_SIZE, sdev->no_uld_attach 506 ? "Hidden\n" : 507 ((aac->jbod && (sdev->type == TYPE_DISK)) ? "JBOD\n" : "")); 508 return snprintf(buf, PAGE_SIZE, "%s\n", 509 get_container_type(aac->fsa_dev[sdev_id(sdev)].type)); 510 } 511 512 static struct device_attribute aac_raid_level_attr = { 513 .attr = { 514 .name = "level", 515 .mode = S_IRUGO, 516 }, 517 .show = aac_show_raid_level 518 }; 519 520 static struct device_attribute *aac_dev_attrs[] = { 521 &aac_raid_level_attr, 522 NULL, 523 }; 524 525 static int aac_ioctl(struct scsi_device *sdev, int cmd, void __user * arg) 526 { 527 struct aac_dev *dev = (struct aac_dev *)sdev->host->hostdata; 528 if (!capable(CAP_SYS_RAWIO)) 529 return -EPERM; 530 return aac_do_ioctl(dev, cmd, arg); 531 } 532 533 static int aac_eh_abort(struct scsi_cmnd* cmd) 534 { 535 struct scsi_device * dev = cmd->device; 536 struct Scsi_Host * host = dev->host; 537 struct aac_dev * aac = (struct aac_dev *)host->hostdata; 538 int count; 539 int ret = FAILED; 540 541 printk(KERN_ERR "%s: Host adapter abort request (%d,%d,%d,%llu)\n", 542 AAC_DRIVERNAME, 543 host->host_no, sdev_channel(dev), sdev_id(dev), dev->lun); 544 switch (cmd->cmnd[0]) { 545 case SERVICE_ACTION_IN_16: 546 if (!(aac->raw_io_interface) || 547 !(aac->raw_io_64) || 548 ((cmd->cmnd[1] & 0x1f) != SAI_READ_CAPACITY_16)) 549 break; 550 case INQUIRY: 551 case READ_CAPACITY: 552 /* Mark associated FIB to not complete, eh handler does this */ 553 for (count = 0; count < (host->can_queue + AAC_NUM_MGT_FIB); ++count) { 554 struct fib * fib = &aac->fibs[count]; 555 if (fib->hw_fib_va->header.XferState && 556 (fib->flags & FIB_CONTEXT_FLAG) && 557 (fib->callback_data == cmd)) { 558 fib->flags |= FIB_CONTEXT_FLAG_TIMED_OUT; 559 cmd->SCp.phase = AAC_OWNER_ERROR_HANDLER; 560 ret = SUCCESS; 561 } 562 } 563 break; 564 case TEST_UNIT_READY: 565 /* Mark associated FIB to not complete, eh handler does this */ 566 for (count = 0; count < (host->can_queue + AAC_NUM_MGT_FIB); ++count) { 567 struct scsi_cmnd * command; 568 struct fib * fib = &aac->fibs[count]; 569 if ((fib->hw_fib_va->header.XferState & cpu_to_le32(Async | NoResponseExpected)) && 570 (fib->flags & FIB_CONTEXT_FLAG) && 571 ((command = fib->callback_data)) && 572 (command->device == cmd->device)) { 573 fib->flags |= FIB_CONTEXT_FLAG_TIMED_OUT; 574 command->SCp.phase = AAC_OWNER_ERROR_HANDLER; 575 if (command == cmd) 576 ret = SUCCESS; 577 } 578 } 579 } 580 return ret; 581 } 582 583 /* 584 * aac_eh_reset - Reset command handling 585 * @scsi_cmd: SCSI command block causing the reset 586 * 587 */ 588 static int aac_eh_reset(struct scsi_cmnd* cmd) 589 { 590 struct scsi_device * dev = cmd->device; 591 struct Scsi_Host * host = dev->host; 592 struct scsi_cmnd * command; 593 int count; 594 struct aac_dev * aac = (struct aac_dev *)host->hostdata; 595 unsigned long flags; 596 597 /* Mark the associated FIB to not complete, eh handler does this */ 598 for (count = 0; count < (host->can_queue + AAC_NUM_MGT_FIB); ++count) { 599 struct fib * fib = &aac->fibs[count]; 600 if (fib->hw_fib_va->header.XferState && 601 (fib->flags & FIB_CONTEXT_FLAG) && 602 (fib->callback_data == cmd)) { 603 fib->flags |= FIB_CONTEXT_FLAG_TIMED_OUT; 604 cmd->SCp.phase = AAC_OWNER_ERROR_HANDLER; 605 } 606 } 607 printk(KERN_ERR "%s: Host adapter reset request. SCSI hang ?\n", 608 AAC_DRIVERNAME); 609 610 if ((count = aac_check_health(aac))) 611 return count; 612 /* 613 * Wait for all commands to complete to this specific 614 * target (block maximum 60 seconds). 615 */ 616 for (count = 60; count; --count) { 617 int active = aac->in_reset; 618 619 if (active == 0) 620 __shost_for_each_device(dev, host) { 621 spin_lock_irqsave(&dev->list_lock, flags); 622 list_for_each_entry(command, &dev->cmd_list, list) { 623 if ((command != cmd) && 624 (command->SCp.phase == AAC_OWNER_FIRMWARE)) { 625 active++; 626 break; 627 } 628 } 629 spin_unlock_irqrestore(&dev->list_lock, flags); 630 if (active) 631 break; 632 633 } 634 /* 635 * We can exit If all the commands are complete 636 */ 637 if (active == 0) 638 return SUCCESS; 639 ssleep(1); 640 } 641 printk(KERN_ERR "%s: SCSI bus appears hung\n", AAC_DRIVERNAME); 642 /* 643 * This adapter needs a blind reset, only do so for Adapters that 644 * support a register, instead of a commanded, reset. 645 */ 646 if (((aac->supplement_adapter_info.SupportedOptions2 & 647 AAC_OPTION_MU_RESET) || 648 (aac->supplement_adapter_info.SupportedOptions2 & 649 AAC_OPTION_DOORBELL_RESET)) && 650 aac_check_reset && 651 ((aac_check_reset != 1) || 652 !(aac->supplement_adapter_info.SupportedOptions2 & 653 AAC_OPTION_IGNORE_RESET))) 654 aac_reset_adapter(aac, 2); /* Bypass wait for command quiesce */ 655 return SUCCESS; /* Cause an immediate retry of the command with a ten second delay after successful tur */ 656 } 657 658 /** 659 * aac_cfg_open - open a configuration file 660 * @inode: inode being opened 661 * @file: file handle attached 662 * 663 * Called when the configuration device is opened. Does the needed 664 * set up on the handle and then returns 665 * 666 * Bugs: This needs extending to check a given adapter is present 667 * so we can support hot plugging, and to ref count adapters. 668 */ 669 670 static int aac_cfg_open(struct inode *inode, struct file *file) 671 { 672 struct aac_dev *aac; 673 unsigned minor_number = iminor(inode); 674 int err = -ENODEV; 675 676 mutex_lock(&aac_mutex); /* BKL pushdown: nothing else protects this list */ 677 list_for_each_entry(aac, &aac_devices, entry) { 678 if (aac->id == minor_number) { 679 file->private_data = aac; 680 err = 0; 681 break; 682 } 683 } 684 mutex_unlock(&aac_mutex); 685 686 return err; 687 } 688 689 /** 690 * aac_cfg_ioctl - AAC configuration request 691 * @inode: inode of device 692 * @file: file handle 693 * @cmd: ioctl command code 694 * @arg: argument 695 * 696 * Handles a configuration ioctl. Currently this involves wrapping it 697 * up and feeding it into the nasty windowsalike glue layer. 698 * 699 * Bugs: Needs locking against parallel ioctls lower down 700 * Bugs: Needs to handle hot plugging 701 */ 702 703 static long aac_cfg_ioctl(struct file *file, 704 unsigned int cmd, unsigned long arg) 705 { 706 struct aac_dev *aac = (struct aac_dev *)file->private_data; 707 708 if (!capable(CAP_SYS_RAWIO)) 709 return -EPERM; 710 711 return aac_do_ioctl(aac, cmd, (void __user *)arg); 712 } 713 714 #ifdef CONFIG_COMPAT 715 static long aac_compat_do_ioctl(struct aac_dev *dev, unsigned cmd, unsigned long arg) 716 { 717 long ret; 718 switch (cmd) { 719 case FSACTL_MINIPORT_REV_CHECK: 720 case FSACTL_SENDFIB: 721 case FSACTL_OPEN_GET_ADAPTER_FIB: 722 case FSACTL_CLOSE_GET_ADAPTER_FIB: 723 case FSACTL_SEND_RAW_SRB: 724 case FSACTL_GET_PCI_INFO: 725 case FSACTL_QUERY_DISK: 726 case FSACTL_DELETE_DISK: 727 case FSACTL_FORCE_DELETE_DISK: 728 case FSACTL_GET_CONTAINERS: 729 case FSACTL_SEND_LARGE_FIB: 730 ret = aac_do_ioctl(dev, cmd, (void __user *)arg); 731 break; 732 733 case FSACTL_GET_NEXT_ADAPTER_FIB: { 734 struct fib_ioctl __user *f; 735 736 f = compat_alloc_user_space(sizeof(*f)); 737 ret = 0; 738 if (clear_user(f, sizeof(*f))) 739 ret = -EFAULT; 740 if (copy_in_user(f, (void __user *)arg, sizeof(struct fib_ioctl) - sizeof(u32))) 741 ret = -EFAULT; 742 if (!ret) 743 ret = aac_do_ioctl(dev, cmd, f); 744 break; 745 } 746 747 default: 748 ret = -ENOIOCTLCMD; 749 break; 750 } 751 return ret; 752 } 753 754 static int aac_compat_ioctl(struct scsi_device *sdev, int cmd, void __user *arg) 755 { 756 struct aac_dev *dev = (struct aac_dev *)sdev->host->hostdata; 757 if (!capable(CAP_SYS_RAWIO)) 758 return -EPERM; 759 return aac_compat_do_ioctl(dev, cmd, (unsigned long)arg); 760 } 761 762 static long aac_compat_cfg_ioctl(struct file *file, unsigned cmd, unsigned long arg) 763 { 764 if (!capable(CAP_SYS_RAWIO)) 765 return -EPERM; 766 return aac_compat_do_ioctl(file->private_data, cmd, arg); 767 } 768 #endif 769 770 static ssize_t aac_show_model(struct device *device, 771 struct device_attribute *attr, char *buf) 772 { 773 struct aac_dev *dev = (struct aac_dev*)class_to_shost(device)->hostdata; 774 int len; 775 776 if (dev->supplement_adapter_info.AdapterTypeText[0]) { 777 char * cp = dev->supplement_adapter_info.AdapterTypeText; 778 while (*cp && *cp != ' ') 779 ++cp; 780 while (*cp == ' ') 781 ++cp; 782 len = snprintf(buf, PAGE_SIZE, "%s\n", cp); 783 } else 784 len = snprintf(buf, PAGE_SIZE, "%s\n", 785 aac_drivers[dev->cardtype].model); 786 return len; 787 } 788 789 static ssize_t aac_show_vendor(struct device *device, 790 struct device_attribute *attr, char *buf) 791 { 792 struct aac_dev *dev = (struct aac_dev*)class_to_shost(device)->hostdata; 793 int len; 794 795 if (dev->supplement_adapter_info.AdapterTypeText[0]) { 796 char * cp = dev->supplement_adapter_info.AdapterTypeText; 797 while (*cp && *cp != ' ') 798 ++cp; 799 len = snprintf(buf, PAGE_SIZE, "%.*s\n", 800 (int)(cp - (char *)dev->supplement_adapter_info.AdapterTypeText), 801 dev->supplement_adapter_info.AdapterTypeText); 802 } else 803 len = snprintf(buf, PAGE_SIZE, "%s\n", 804 aac_drivers[dev->cardtype].vname); 805 return len; 806 } 807 808 static ssize_t aac_show_flags(struct device *cdev, 809 struct device_attribute *attr, char *buf) 810 { 811 int len = 0; 812 struct aac_dev *dev = (struct aac_dev*)class_to_shost(cdev)->hostdata; 813 814 if (nblank(dprintk(x))) 815 len = snprintf(buf, PAGE_SIZE, "dprintk\n"); 816 #ifdef AAC_DETAILED_STATUS_INFO 817 len += snprintf(buf + len, PAGE_SIZE - len, 818 "AAC_DETAILED_STATUS_INFO\n"); 819 #endif 820 if (dev->raw_io_interface && dev->raw_io_64) 821 len += snprintf(buf + len, PAGE_SIZE - len, 822 "SAI_READ_CAPACITY_16\n"); 823 if (dev->jbod) 824 len += snprintf(buf + len, PAGE_SIZE - len, "SUPPORTED_JBOD\n"); 825 if (dev->supplement_adapter_info.SupportedOptions2 & 826 AAC_OPTION_POWER_MANAGEMENT) 827 len += snprintf(buf + len, PAGE_SIZE - len, 828 "SUPPORTED_POWER_MANAGEMENT\n"); 829 if (dev->msi) 830 len += snprintf(buf + len, PAGE_SIZE - len, "PCI_HAS_MSI\n"); 831 return len; 832 } 833 834 static ssize_t aac_show_kernel_version(struct device *device, 835 struct device_attribute *attr, 836 char *buf) 837 { 838 struct aac_dev *dev = (struct aac_dev*)class_to_shost(device)->hostdata; 839 int len, tmp; 840 841 tmp = le32_to_cpu(dev->adapter_info.kernelrev); 842 len = snprintf(buf, PAGE_SIZE, "%d.%d-%d[%d]\n", 843 tmp >> 24, (tmp >> 16) & 0xff, tmp & 0xff, 844 le32_to_cpu(dev->adapter_info.kernelbuild)); 845 return len; 846 } 847 848 static ssize_t aac_show_monitor_version(struct device *device, 849 struct device_attribute *attr, 850 char *buf) 851 { 852 struct aac_dev *dev = (struct aac_dev*)class_to_shost(device)->hostdata; 853 int len, tmp; 854 855 tmp = le32_to_cpu(dev->adapter_info.monitorrev); 856 len = snprintf(buf, PAGE_SIZE, "%d.%d-%d[%d]\n", 857 tmp >> 24, (tmp >> 16) & 0xff, tmp & 0xff, 858 le32_to_cpu(dev->adapter_info.monitorbuild)); 859 return len; 860 } 861 862 static ssize_t aac_show_bios_version(struct device *device, 863 struct device_attribute *attr, 864 char *buf) 865 { 866 struct aac_dev *dev = (struct aac_dev*)class_to_shost(device)->hostdata; 867 int len, tmp; 868 869 tmp = le32_to_cpu(dev->adapter_info.biosrev); 870 len = snprintf(buf, PAGE_SIZE, "%d.%d-%d[%d]\n", 871 tmp >> 24, (tmp >> 16) & 0xff, tmp & 0xff, 872 le32_to_cpu(dev->adapter_info.biosbuild)); 873 return len; 874 } 875 876 static ssize_t aac_show_serial_number(struct device *device, 877 struct device_attribute *attr, char *buf) 878 { 879 struct aac_dev *dev = (struct aac_dev*)class_to_shost(device)->hostdata; 880 int len = 0; 881 882 if (le32_to_cpu(dev->adapter_info.serial[0]) != 0xBAD0) 883 len = snprintf(buf, 16, "%06X\n", 884 le32_to_cpu(dev->adapter_info.serial[0])); 885 if (len && 886 !memcmp(&dev->supplement_adapter_info.MfgPcbaSerialNo[ 887 sizeof(dev->supplement_adapter_info.MfgPcbaSerialNo)-len], 888 buf, len-1)) 889 len = snprintf(buf, 16, "%.*s\n", 890 (int)sizeof(dev->supplement_adapter_info.MfgPcbaSerialNo), 891 dev->supplement_adapter_info.MfgPcbaSerialNo); 892 893 return min(len, 16); 894 } 895 896 static ssize_t aac_show_max_channel(struct device *device, 897 struct device_attribute *attr, char *buf) 898 { 899 return snprintf(buf, PAGE_SIZE, "%d\n", 900 class_to_shost(device)->max_channel); 901 } 902 903 static ssize_t aac_show_max_id(struct device *device, 904 struct device_attribute *attr, char *buf) 905 { 906 return snprintf(buf, PAGE_SIZE, "%d\n", 907 class_to_shost(device)->max_id); 908 } 909 910 static ssize_t aac_store_reset_adapter(struct device *device, 911 struct device_attribute *attr, 912 const char *buf, size_t count) 913 { 914 int retval = -EACCES; 915 916 if (!capable(CAP_SYS_ADMIN)) 917 return retval; 918 retval = aac_reset_adapter((struct aac_dev*)class_to_shost(device)->hostdata, buf[0] == '!'); 919 if (retval >= 0) 920 retval = count; 921 return retval; 922 } 923 924 static ssize_t aac_show_reset_adapter(struct device *device, 925 struct device_attribute *attr, 926 char *buf) 927 { 928 struct aac_dev *dev = (struct aac_dev*)class_to_shost(device)->hostdata; 929 int len, tmp; 930 931 tmp = aac_adapter_check_health(dev); 932 if ((tmp == 0) && dev->in_reset) 933 tmp = -EBUSY; 934 len = snprintf(buf, PAGE_SIZE, "0x%x\n", tmp); 935 return len; 936 } 937 938 static struct device_attribute aac_model = { 939 .attr = { 940 .name = "model", 941 .mode = S_IRUGO, 942 }, 943 .show = aac_show_model, 944 }; 945 static struct device_attribute aac_vendor = { 946 .attr = { 947 .name = "vendor", 948 .mode = S_IRUGO, 949 }, 950 .show = aac_show_vendor, 951 }; 952 static struct device_attribute aac_flags = { 953 .attr = { 954 .name = "flags", 955 .mode = S_IRUGO, 956 }, 957 .show = aac_show_flags, 958 }; 959 static struct device_attribute aac_kernel_version = { 960 .attr = { 961 .name = "hba_kernel_version", 962 .mode = S_IRUGO, 963 }, 964 .show = aac_show_kernel_version, 965 }; 966 static struct device_attribute aac_monitor_version = { 967 .attr = { 968 .name = "hba_monitor_version", 969 .mode = S_IRUGO, 970 }, 971 .show = aac_show_monitor_version, 972 }; 973 static struct device_attribute aac_bios_version = { 974 .attr = { 975 .name = "hba_bios_version", 976 .mode = S_IRUGO, 977 }, 978 .show = aac_show_bios_version, 979 }; 980 static struct device_attribute aac_serial_number = { 981 .attr = { 982 .name = "serial_number", 983 .mode = S_IRUGO, 984 }, 985 .show = aac_show_serial_number, 986 }; 987 static struct device_attribute aac_max_channel = { 988 .attr = { 989 .name = "max_channel", 990 .mode = S_IRUGO, 991 }, 992 .show = aac_show_max_channel, 993 }; 994 static struct device_attribute aac_max_id = { 995 .attr = { 996 .name = "max_id", 997 .mode = S_IRUGO, 998 }, 999 .show = aac_show_max_id, 1000 }; 1001 static struct device_attribute aac_reset = { 1002 .attr = { 1003 .name = "reset_host", 1004 .mode = S_IWUSR|S_IRUGO, 1005 }, 1006 .store = aac_store_reset_adapter, 1007 .show = aac_show_reset_adapter, 1008 }; 1009 1010 static struct device_attribute *aac_attrs[] = { 1011 &aac_model, 1012 &aac_vendor, 1013 &aac_flags, 1014 &aac_kernel_version, 1015 &aac_monitor_version, 1016 &aac_bios_version, 1017 &aac_serial_number, 1018 &aac_max_channel, 1019 &aac_max_id, 1020 &aac_reset, 1021 NULL 1022 }; 1023 1024 ssize_t aac_get_serial_number(struct device *device, char *buf) 1025 { 1026 return aac_show_serial_number(device, &aac_serial_number, buf); 1027 } 1028 1029 static const struct file_operations aac_cfg_fops = { 1030 .owner = THIS_MODULE, 1031 .unlocked_ioctl = aac_cfg_ioctl, 1032 #ifdef CONFIG_COMPAT 1033 .compat_ioctl = aac_compat_cfg_ioctl, 1034 #endif 1035 .open = aac_cfg_open, 1036 .llseek = noop_llseek, 1037 }; 1038 1039 static struct scsi_host_template aac_driver_template = { 1040 .module = THIS_MODULE, 1041 .name = "AAC", 1042 .proc_name = AAC_DRIVERNAME, 1043 .info = aac_info, 1044 .ioctl = aac_ioctl, 1045 #ifdef CONFIG_COMPAT 1046 .compat_ioctl = aac_compat_ioctl, 1047 #endif 1048 .queuecommand = aac_queuecommand, 1049 .bios_param = aac_biosparm, 1050 .shost_attrs = aac_attrs, 1051 .slave_configure = aac_slave_configure, 1052 .change_queue_depth = aac_change_queue_depth, 1053 .sdev_attrs = aac_dev_attrs, 1054 .eh_abort_handler = aac_eh_abort, 1055 .eh_host_reset_handler = aac_eh_reset, 1056 .can_queue = AAC_NUM_IO_FIB, 1057 .this_id = MAXIMUM_NUM_CONTAINERS, 1058 .sg_tablesize = 16, 1059 .max_sectors = 128, 1060 #if (AAC_NUM_IO_FIB > 256) 1061 .cmd_per_lun = 256, 1062 #else 1063 .cmd_per_lun = AAC_NUM_IO_FIB, 1064 #endif 1065 .use_clustering = ENABLE_CLUSTERING, 1066 .emulated = 1, 1067 .no_write_same = 1, 1068 }; 1069 1070 static void __aac_shutdown(struct aac_dev * aac) 1071 { 1072 int i; 1073 int cpu; 1074 1075 aac_send_shutdown(aac); 1076 1077 if (aac->aif_thread) { 1078 int i; 1079 /* Clear out events first */ 1080 for (i = 0; i < (aac->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB); i++) { 1081 struct fib *fib = &aac->fibs[i]; 1082 if (!(fib->hw_fib_va->header.XferState & cpu_to_le32(NoResponseExpected | Async)) && 1083 (fib->hw_fib_va->header.XferState & cpu_to_le32(ResponseExpected))) 1084 up(&fib->event_wait); 1085 } 1086 kthread_stop(aac->thread); 1087 } 1088 aac_adapter_disable_int(aac); 1089 cpu = cpumask_first(cpu_online_mask); 1090 if (aac->pdev->device == PMC_DEVICE_S6 || 1091 aac->pdev->device == PMC_DEVICE_S7 || 1092 aac->pdev->device == PMC_DEVICE_S8 || 1093 aac->pdev->device == PMC_DEVICE_S9) { 1094 if (aac->max_msix > 1) { 1095 for (i = 0; i < aac->max_msix; i++) { 1096 if (irq_set_affinity_hint( 1097 aac->msixentry[i].vector, 1098 NULL)) { 1099 printk(KERN_ERR "%s%d: Failed to reset IRQ affinity for cpu %d\n", 1100 aac->name, 1101 aac->id, 1102 cpu); 1103 } 1104 cpu = cpumask_next(cpu, 1105 cpu_online_mask); 1106 free_irq(aac->msixentry[i].vector, 1107 &(aac->aac_msix[i])); 1108 } 1109 } else { 1110 free_irq(aac->pdev->irq, 1111 &(aac->aac_msix[0])); 1112 } 1113 } else { 1114 free_irq(aac->pdev->irq, aac); 1115 } 1116 if (aac->msi) 1117 pci_disable_msi(aac->pdev); 1118 else if (aac->max_msix > 1) 1119 pci_disable_msix(aac->pdev); 1120 } 1121 static void aac_init_char(void) 1122 { 1123 aac_cfg_major = register_chrdev(0, "aac", &aac_cfg_fops); 1124 if (aac_cfg_major < 0) { 1125 pr_err("aacraid: unable to register \"aac\" device.\n"); 1126 } 1127 } 1128 1129 static int aac_probe_one(struct pci_dev *pdev, const struct pci_device_id *id) 1130 { 1131 unsigned index = id->driver_data; 1132 struct Scsi_Host *shost; 1133 struct aac_dev *aac; 1134 struct list_head *insert = &aac_devices; 1135 int error = -ENODEV; 1136 int unique_id = 0; 1137 u64 dmamask; 1138 extern int aac_sync_mode; 1139 1140 /* 1141 * Only series 7 needs freset. 1142 */ 1143 if (pdev->device == PMC_DEVICE_S7) 1144 pdev->needs_freset = 1; 1145 1146 list_for_each_entry(aac, &aac_devices, entry) { 1147 if (aac->id > unique_id) 1148 break; 1149 insert = &aac->entry; 1150 unique_id++; 1151 } 1152 1153 pci_disable_link_state(pdev, PCIE_LINK_STATE_L0S | PCIE_LINK_STATE_L1 | 1154 PCIE_LINK_STATE_CLKPM); 1155 1156 error = pci_enable_device(pdev); 1157 if (error) 1158 goto out; 1159 error = -ENODEV; 1160 1161 /* 1162 * If the quirk31 bit is set, the adapter needs adapter 1163 * to driver communication memory to be allocated below 2gig 1164 */ 1165 if (aac_drivers[index].quirks & AAC_QUIRK_31BIT) 1166 dmamask = DMA_BIT_MASK(31); 1167 else 1168 dmamask = DMA_BIT_MASK(32); 1169 1170 if (pci_set_dma_mask(pdev, dmamask) || 1171 pci_set_consistent_dma_mask(pdev, dmamask)) 1172 goto out_disable_pdev; 1173 1174 pci_set_master(pdev); 1175 1176 shost = scsi_host_alloc(&aac_driver_template, sizeof(struct aac_dev)); 1177 if (!shost) 1178 goto out_disable_pdev; 1179 1180 shost->irq = pdev->irq; 1181 shost->unique_id = unique_id; 1182 shost->max_cmd_len = 16; 1183 shost->use_cmd_list = 1; 1184 1185 if (aac_cfg_major == AAC_CHARDEV_NEEDS_REINIT) 1186 aac_init_char(); 1187 1188 aac = (struct aac_dev *)shost->hostdata; 1189 aac->base_start = pci_resource_start(pdev, 0); 1190 aac->scsi_host_ptr = shost; 1191 aac->pdev = pdev; 1192 aac->name = aac_driver_template.name; 1193 aac->id = shost->unique_id; 1194 aac->cardtype = index; 1195 INIT_LIST_HEAD(&aac->entry); 1196 1197 aac->fibs = kzalloc(sizeof(struct fib) * (shost->can_queue + AAC_NUM_MGT_FIB), GFP_KERNEL); 1198 if (!aac->fibs) 1199 goto out_free_host; 1200 spin_lock_init(&aac->fib_lock); 1201 1202 mutex_init(&aac->ioctl_mutex); 1203 /* 1204 * Map in the registers from the adapter. 1205 */ 1206 aac->base_size = AAC_MIN_FOOTPRINT_SIZE; 1207 if ((*aac_drivers[index].init)(aac)) 1208 goto out_unmap; 1209 1210 if (aac->sync_mode) { 1211 if (aac_sync_mode) 1212 printk(KERN_INFO "%s%d: Sync. mode enforced " 1213 "by driver parameter. This will cause " 1214 "a significant performance decrease!\n", 1215 aac->name, 1216 aac->id); 1217 else 1218 printk(KERN_INFO "%s%d: Async. mode not supported " 1219 "by current driver, sync. mode enforced." 1220 "\nPlease update driver to get full performance.\n", 1221 aac->name, 1222 aac->id); 1223 } 1224 1225 /* 1226 * Start any kernel threads needed 1227 */ 1228 aac->thread = kthread_run(aac_command_thread, aac, AAC_DRIVERNAME); 1229 if (IS_ERR(aac->thread)) { 1230 printk(KERN_ERR "aacraid: Unable to create command thread.\n"); 1231 error = PTR_ERR(aac->thread); 1232 aac->thread = NULL; 1233 goto out_deinit; 1234 } 1235 1236 /* 1237 * If we had set a smaller DMA mask earlier, set it to 4gig 1238 * now since the adapter can dma data to at least a 4gig 1239 * address space. 1240 */ 1241 if (aac_drivers[index].quirks & AAC_QUIRK_31BIT) 1242 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) 1243 goto out_deinit; 1244 1245 aac->maximum_num_channels = aac_drivers[index].channels; 1246 error = aac_get_adapter_info(aac); 1247 if (error < 0) 1248 goto out_deinit; 1249 1250 /* 1251 * Lets override negotiations and drop the maximum SG limit to 34 1252 */ 1253 if ((aac_drivers[index].quirks & AAC_QUIRK_34SG) && 1254 (shost->sg_tablesize > 34)) { 1255 shost->sg_tablesize = 34; 1256 shost->max_sectors = (shost->sg_tablesize * 8) + 112; 1257 } 1258 1259 if ((aac_drivers[index].quirks & AAC_QUIRK_17SG) && 1260 (shost->sg_tablesize > 17)) { 1261 shost->sg_tablesize = 17; 1262 shost->max_sectors = (shost->sg_tablesize * 8) + 112; 1263 } 1264 1265 error = pci_set_dma_max_seg_size(pdev, 1266 (aac->adapter_info.options & AAC_OPT_NEW_COMM) ? 1267 (shost->max_sectors << 9) : 65536); 1268 if (error) 1269 goto out_deinit; 1270 1271 /* 1272 * Firmware printf works only with older firmware. 1273 */ 1274 if (aac_drivers[index].quirks & AAC_QUIRK_34SG) 1275 aac->printf_enabled = 1; 1276 else 1277 aac->printf_enabled = 0; 1278 1279 /* 1280 * max channel will be the physical channels plus 1 virtual channel 1281 * all containers are on the virtual channel 0 (CONTAINER_CHANNEL) 1282 * physical channels are address by their actual physical number+1 1283 */ 1284 if (aac->nondasd_support || expose_physicals || aac->jbod) 1285 shost->max_channel = aac->maximum_num_channels; 1286 else 1287 shost->max_channel = 0; 1288 1289 aac_get_config_status(aac, 0); 1290 aac_get_containers(aac); 1291 list_add(&aac->entry, insert); 1292 1293 shost->max_id = aac->maximum_num_containers; 1294 if (shost->max_id < aac->maximum_num_physicals) 1295 shost->max_id = aac->maximum_num_physicals; 1296 if (shost->max_id < MAXIMUM_NUM_CONTAINERS) 1297 shost->max_id = MAXIMUM_NUM_CONTAINERS; 1298 else 1299 shost->this_id = shost->max_id; 1300 1301 /* 1302 * dmb - we may need to move the setting of these parms somewhere else once 1303 * we get a fib that can report the actual numbers 1304 */ 1305 shost->max_lun = AAC_MAX_LUN; 1306 1307 pci_set_drvdata(pdev, shost); 1308 1309 error = scsi_add_host(shost, &pdev->dev); 1310 if (error) 1311 goto out_deinit; 1312 scsi_scan_host(shost); 1313 1314 pci_enable_pcie_error_reporting(pdev); 1315 pci_save_state(pdev); 1316 1317 return 0; 1318 1319 out_deinit: 1320 __aac_shutdown(aac); 1321 out_unmap: 1322 aac_fib_map_free(aac); 1323 if (aac->comm_addr) 1324 pci_free_consistent(aac->pdev, aac->comm_size, aac->comm_addr, 1325 aac->comm_phys); 1326 kfree(aac->queues); 1327 aac_adapter_ioremap(aac, 0); 1328 kfree(aac->fibs); 1329 kfree(aac->fsa_dev); 1330 out_free_host: 1331 scsi_host_put(shost); 1332 out_disable_pdev: 1333 pci_disable_device(pdev); 1334 out: 1335 return error; 1336 } 1337 1338 static void aac_release_resources(struct aac_dev *aac) 1339 { 1340 int i; 1341 1342 aac_adapter_disable_int(aac); 1343 if (aac->pdev->device == PMC_DEVICE_S6 || 1344 aac->pdev->device == PMC_DEVICE_S7 || 1345 aac->pdev->device == PMC_DEVICE_S8 || 1346 aac->pdev->device == PMC_DEVICE_S9) { 1347 if (aac->max_msix > 1) { 1348 for (i = 0; i < aac->max_msix; i++) 1349 free_irq(aac->msixentry[i].vector, 1350 &(aac->aac_msix[i])); 1351 } else { 1352 free_irq(aac->pdev->irq, &(aac->aac_msix[0])); 1353 } 1354 } else { 1355 free_irq(aac->pdev->irq, aac); 1356 } 1357 if (aac->msi) 1358 pci_disable_msi(aac->pdev); 1359 else if (aac->max_msix > 1) 1360 pci_disable_msix(aac->pdev); 1361 1362 } 1363 1364 static int aac_acquire_resources(struct aac_dev *dev) 1365 { 1366 int i, j; 1367 int instance = dev->id; 1368 const char *name = dev->name; 1369 unsigned long status; 1370 /* 1371 * First clear out all interrupts. Then enable the one's that we 1372 * can handle. 1373 */ 1374 while (!((status = src_readl(dev, MUnit.OMR)) & KERNEL_UP_AND_RUNNING) 1375 || status == 0xffffffff) 1376 msleep(20); 1377 1378 aac_adapter_disable_int(dev); 1379 aac_adapter_enable_int(dev); 1380 1381 1382 if ((dev->pdev->device == PMC_DEVICE_S7 || 1383 dev->pdev->device == PMC_DEVICE_S8 || 1384 dev->pdev->device == PMC_DEVICE_S9)) 1385 aac_define_int_mode(dev); 1386 1387 if (dev->msi_enabled) 1388 aac_src_access_devreg(dev, AAC_ENABLE_MSIX); 1389 1390 if (!dev->sync_mode && dev->msi_enabled && dev->max_msix > 1) { 1391 for (i = 0; i < dev->max_msix; i++) { 1392 dev->aac_msix[i].vector_no = i; 1393 dev->aac_msix[i].dev = dev; 1394 1395 if (request_irq(dev->msixentry[i].vector, 1396 dev->a_ops.adapter_intr, 1397 0, "aacraid", &(dev->aac_msix[i]))) { 1398 printk(KERN_ERR "%s%d: Failed to register IRQ for vector %d.\n", 1399 name, instance, i); 1400 for (j = 0 ; j < i ; j++) 1401 free_irq(dev->msixentry[j].vector, 1402 &(dev->aac_msix[j])); 1403 pci_disable_msix(dev->pdev); 1404 goto error_iounmap; 1405 } 1406 } 1407 } else { 1408 dev->aac_msix[0].vector_no = 0; 1409 dev->aac_msix[0].dev = dev; 1410 1411 if (request_irq(dev->pdev->irq, dev->a_ops.adapter_intr, 1412 IRQF_SHARED, "aacraid", 1413 &(dev->aac_msix[0])) < 0) { 1414 if (dev->msi) 1415 pci_disable_msi(dev->pdev); 1416 printk(KERN_ERR "%s%d: Interrupt unavailable.\n", 1417 name, instance); 1418 goto error_iounmap; 1419 } 1420 } 1421 1422 aac_adapter_enable_int(dev); 1423 1424 /*max msix may change after EEH 1425 * Re-assign vectors to fibs 1426 */ 1427 aac_fib_vector_assign(dev); 1428 1429 if (!dev->sync_mode) { 1430 /* After EEH recovery or suspend resume, max_msix count 1431 * may change, therfore updating in init as well. 1432 */ 1433 aac_adapter_start(dev); 1434 dev->init->Sa_MSIXVectors = cpu_to_le32(dev->max_msix); 1435 } 1436 return 0; 1437 1438 error_iounmap: 1439 return -1; 1440 1441 } 1442 1443 #if (defined(CONFIG_PM)) 1444 static int aac_suspend(struct pci_dev *pdev, pm_message_t state) 1445 { 1446 1447 struct Scsi_Host *shost = pci_get_drvdata(pdev); 1448 struct aac_dev *aac = (struct aac_dev *)shost->hostdata; 1449 1450 scsi_block_requests(shost); 1451 aac_send_shutdown(aac); 1452 1453 aac_release_resources(aac); 1454 1455 pci_set_drvdata(pdev, shost); 1456 pci_save_state(pdev); 1457 pci_disable_device(pdev); 1458 pci_set_power_state(pdev, pci_choose_state(pdev, state)); 1459 1460 return 0; 1461 } 1462 1463 static int aac_resume(struct pci_dev *pdev) 1464 { 1465 struct Scsi_Host *shost = pci_get_drvdata(pdev); 1466 struct aac_dev *aac = (struct aac_dev *)shost->hostdata; 1467 int r; 1468 1469 pci_set_power_state(pdev, PCI_D0); 1470 pci_enable_wake(pdev, PCI_D0, 0); 1471 pci_restore_state(pdev); 1472 r = pci_enable_device(pdev); 1473 1474 if (r) 1475 goto fail_device; 1476 1477 pci_set_master(pdev); 1478 if (aac_acquire_resources(aac)) 1479 goto fail_device; 1480 /* 1481 * reset this flag to unblock ioctl() as it was set at 1482 * aac_send_shutdown() to block ioctls from upperlayer 1483 */ 1484 aac->adapter_shutdown = 0; 1485 scsi_unblock_requests(shost); 1486 1487 return 0; 1488 1489 fail_device: 1490 printk(KERN_INFO "%s%d: resume failed.\n", aac->name, aac->id); 1491 scsi_host_put(shost); 1492 pci_disable_device(pdev); 1493 return -ENODEV; 1494 } 1495 #endif 1496 1497 static void aac_shutdown(struct pci_dev *dev) 1498 { 1499 struct Scsi_Host *shost = pci_get_drvdata(dev); 1500 scsi_block_requests(shost); 1501 __aac_shutdown((struct aac_dev *)shost->hostdata); 1502 } 1503 1504 static void aac_remove_one(struct pci_dev *pdev) 1505 { 1506 struct Scsi_Host *shost = pci_get_drvdata(pdev); 1507 struct aac_dev *aac = (struct aac_dev *)shost->hostdata; 1508 1509 scsi_remove_host(shost); 1510 1511 __aac_shutdown(aac); 1512 aac_fib_map_free(aac); 1513 pci_free_consistent(aac->pdev, aac->comm_size, aac->comm_addr, 1514 aac->comm_phys); 1515 kfree(aac->queues); 1516 1517 aac_adapter_ioremap(aac, 0); 1518 1519 kfree(aac->fibs); 1520 kfree(aac->fsa_dev); 1521 1522 list_del(&aac->entry); 1523 scsi_host_put(shost); 1524 pci_disable_device(pdev); 1525 if (list_empty(&aac_devices)) { 1526 unregister_chrdev(aac_cfg_major, "aac"); 1527 aac_cfg_major = AAC_CHARDEV_NEEDS_REINIT; 1528 } 1529 } 1530 1531 static void aac_flush_ios(struct aac_dev *aac) 1532 { 1533 int i; 1534 struct scsi_cmnd *cmd; 1535 1536 for (i = 0; i < aac->scsi_host_ptr->can_queue; i++) { 1537 cmd = (struct scsi_cmnd *)aac->fibs[i].callback_data; 1538 if (cmd && (cmd->SCp.phase == AAC_OWNER_FIRMWARE)) { 1539 scsi_dma_unmap(cmd); 1540 1541 if (aac->handle_pci_error) 1542 cmd->result = DID_NO_CONNECT << 16; 1543 else 1544 cmd->result = DID_RESET << 16; 1545 1546 cmd->scsi_done(cmd); 1547 } 1548 } 1549 } 1550 1551 static pci_ers_result_t aac_pci_error_detected(struct pci_dev *pdev, 1552 enum pci_channel_state error) 1553 { 1554 struct Scsi_Host *shost = pci_get_drvdata(pdev); 1555 struct aac_dev *aac = shost_priv(shost); 1556 1557 dev_err(&pdev->dev, "aacraid: PCI error detected %x\n", error); 1558 1559 switch (error) { 1560 case pci_channel_io_normal: 1561 return PCI_ERS_RESULT_CAN_RECOVER; 1562 case pci_channel_io_frozen: 1563 aac->handle_pci_error = 1; 1564 1565 scsi_block_requests(aac->scsi_host_ptr); 1566 aac_flush_ios(aac); 1567 aac_release_resources(aac); 1568 1569 pci_disable_pcie_error_reporting(pdev); 1570 aac_adapter_ioremap(aac, 0); 1571 1572 return PCI_ERS_RESULT_NEED_RESET; 1573 case pci_channel_io_perm_failure: 1574 aac->handle_pci_error = 1; 1575 1576 aac_flush_ios(aac); 1577 return PCI_ERS_RESULT_DISCONNECT; 1578 } 1579 1580 return PCI_ERS_RESULT_NEED_RESET; 1581 } 1582 1583 static pci_ers_result_t aac_pci_mmio_enabled(struct pci_dev *pdev) 1584 { 1585 dev_err(&pdev->dev, "aacraid: PCI error - mmio enabled\n"); 1586 return PCI_ERS_RESULT_NEED_RESET; 1587 } 1588 1589 static pci_ers_result_t aac_pci_slot_reset(struct pci_dev *pdev) 1590 { 1591 dev_err(&pdev->dev, "aacraid: PCI error - slot reset\n"); 1592 pci_restore_state(pdev); 1593 if (pci_enable_device(pdev)) { 1594 dev_warn(&pdev->dev, 1595 "aacraid: failed to enable slave\n"); 1596 goto fail_device; 1597 } 1598 1599 pci_set_master(pdev); 1600 1601 if (pci_enable_device_mem(pdev)) { 1602 dev_err(&pdev->dev, "pci_enable_device_mem failed\n"); 1603 goto fail_device; 1604 } 1605 1606 return PCI_ERS_RESULT_RECOVERED; 1607 1608 fail_device: 1609 dev_err(&pdev->dev, "aacraid: PCI error - slot reset failed\n"); 1610 return PCI_ERS_RESULT_DISCONNECT; 1611 } 1612 1613 1614 static void aac_pci_resume(struct pci_dev *pdev) 1615 { 1616 struct Scsi_Host *shost = pci_get_drvdata(pdev); 1617 struct scsi_device *sdev = NULL; 1618 struct aac_dev *aac = (struct aac_dev *)shost_priv(shost); 1619 1620 pci_cleanup_aer_uncorrect_error_status(pdev); 1621 1622 if (aac_adapter_ioremap(aac, aac->base_size)) { 1623 1624 dev_err(&pdev->dev, "aacraid: ioremap failed\n"); 1625 /* remap failed, go back ... */ 1626 aac->comm_interface = AAC_COMM_PRODUCER; 1627 if (aac_adapter_ioremap(aac, AAC_MIN_FOOTPRINT_SIZE)) { 1628 dev_warn(&pdev->dev, 1629 "aacraid: unable to map adapter.\n"); 1630 1631 return; 1632 } 1633 } 1634 1635 msleep(10000); 1636 1637 aac_acquire_resources(aac); 1638 1639 /* 1640 * reset this flag to unblock ioctl() as it was set 1641 * at aac_send_shutdown() to block ioctls from upperlayer 1642 */ 1643 aac->adapter_shutdown = 0; 1644 aac->handle_pci_error = 0; 1645 1646 shost_for_each_device(sdev, shost) 1647 if (sdev->sdev_state == SDEV_OFFLINE) 1648 sdev->sdev_state = SDEV_RUNNING; 1649 scsi_unblock_requests(aac->scsi_host_ptr); 1650 scsi_scan_host(aac->scsi_host_ptr); 1651 pci_save_state(pdev); 1652 1653 dev_err(&pdev->dev, "aacraid: PCI error - resume\n"); 1654 } 1655 1656 static struct pci_error_handlers aac_pci_err_handler = { 1657 .error_detected = aac_pci_error_detected, 1658 .mmio_enabled = aac_pci_mmio_enabled, 1659 .slot_reset = aac_pci_slot_reset, 1660 .resume = aac_pci_resume, 1661 }; 1662 1663 static struct pci_driver aac_pci_driver = { 1664 .name = AAC_DRIVERNAME, 1665 .id_table = aac_pci_tbl, 1666 .probe = aac_probe_one, 1667 .remove = aac_remove_one, 1668 #if (defined(CONFIG_PM)) 1669 .suspend = aac_suspend, 1670 .resume = aac_resume, 1671 #endif 1672 .shutdown = aac_shutdown, 1673 .err_handler = &aac_pci_err_handler, 1674 }; 1675 1676 static int __init aac_init(void) 1677 { 1678 int error; 1679 1680 printk(KERN_INFO "Adaptec %s driver %s\n", 1681 AAC_DRIVERNAME, aac_driver_version); 1682 1683 error = pci_register_driver(&aac_pci_driver); 1684 if (error < 0) 1685 return error; 1686 1687 aac_init_char(); 1688 1689 1690 return 0; 1691 } 1692 1693 static void __exit aac_exit(void) 1694 { 1695 if (aac_cfg_major > -1) 1696 unregister_chrdev(aac_cfg_major, "aac"); 1697 pci_unregister_driver(&aac_pci_driver); 1698 } 1699 1700 module_init(aac_init); 1701 module_exit(aac_exit); 1702