drivers/scsi/aacraid/linit.c

   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);