// SPDX-License-Identifier: GPL-2.0-or-later /* * Adaptec AAC series RAID controller driver * (c) Copyright 2001 Red Hat Inc. * * based on the old aacraid driver that is.. * Adaptec aacraid device driver for Linux. * * Copyright (c) 2000-2010 Adaptec, Inc. * 2010-2015 PMC-Sierra, Inc. (aacraid@pmc-sierra.com) * 2016-2017 Microsemi Corp. (aacraid@microsemi.com) * * Module Name: * linit.c * * Abstract: Linux Driver entry module for Adaptec RAID Array Controller #include <linux/compat.h>#include <linux/blkdev.h>#include <linux/completion.h>#include <linux/init.h>#include <linux/interrupt.h>#include <linux/kernel.h>#include <linux/module.h>#include <linux/moduleparam.h>#include <linux/pci.h>#include <linux/slab.h>#include <linux/mutex.h>#include <linux/spinlock.h>#include <linux/syscalls.h>#include <linux/delay.h>#include <linux/kthread.h>#include <linux/msdos_partition.h>#include <scsi/scsi.h>#include <scsi/scsi_cmnd.h>#include <scsi/scsi_device.h>#include <scsi/scsi_host.h>#include <scsi/scsi_tcq.h>#include <scsi/scsicam.h>#include <scsi/scsi_eh.h>#include "aacraid.h" #define AAC_DRIVER_VERSION "1.2.1" #ifndef AAC_DRIVER_BRANCH#define AAC_DRIVER_BRANCH "" #endif #define AAC_DRIVERNAME "aacraid" #ifdef AAC_DRIVER_BUILD#define _str(x) #x #define str(x) _str(x)#define AAC_DRIVER_FULL_VERSION AAC_DRIVER_VERSION "[" str(AAC_DRIVER_BUILD) "]" AAC_DRIVER_BRANCH#else #define AAC_DRIVER_FULL_VERSION AAC_DRIVER_VERSION AAC_DRIVER_BRANCH#endif "Red Hat Inc and Adaptec" );"Dell PERC2, 2/Si, 3/Si, 3/Di, " "Adaptec Advanced Raid Products, " "HP NetRAID-4M, IBM ServeRAID & ICP SCSI driver" );"GPL" );static DEFINE_MUTEX(aac_mutex);static LIST_HEAD(aac_devices);static int aac_cfg_major = AAC_CHARDEV_UNREGISTERED;char aac_driver_version[] = AAC_DRIVER_FULL_VERSION;/* * Because of the way Linux names scsi devices, the order in this table has * become important. Check for on-board Raid first, add-in cards second. * * Note: The last field is used to index into aac_drivers below. static const struct pci_device_id aac_pci_tbl[] = {/* PERC 2/Si (Iguana/PERC2Si) */ /* PERC 3/Di (Opal/PERC3Di) */ /* PERC 3/Si (SlimFast/PERC3Si */ /* PERC 3/Di (Iguana FlipChip/PERC3DiF */ /* PERC 3/Di (Viper/PERC3DiV) */ /* PERC 3/Di (Lexus/PERC3DiL) */ /* PERC 3/Di (Jaguar/PERC3DiJ) */ /* PERC 3/Di (Dagger/PERC3DiD) */ /* PERC 3/Di (Boxster/PERC3DiB) */ /* catapult */ /* tomcat */ /* Adaptec 2120S (Crusader) */ /* Adaptec 2200S (Vulcan) */ /* Adaptec 2200S (Vulcan-2m) */ /* Legend S220 (Legend Crusader) */ /* Legend S230 (Legend Vulcan) */ /* Adaptec 3230S (Harrier) */ /* Adaptec 3240S (Tornado) */ /* ASR-2020ZCR SCSI PCI-X ZCR (Skyhawk) */ /* ASR-2025ZCR SCSI SO-DIMM PCI-X ZCR (Terminator) */ /* ASR-2230S + ASR-2230SLP PCI-X (Lancer) */ /* ASR-2130S (Lancer) */ /* AAR-2820SA (Intruder) */ /* AAR-2620SA (Intruder) */ /* AAR-2420SA (Intruder) */ /* ICP9024RO (Lancer) */ /* ICP9014RO (Lancer) */ /* ICP9047MA (Lancer) */ /* ICP9087MA (Lancer) */ /* ICP5445AU (Hurricane44) */ /* ICP9085LI (Marauder-X) */ /* ICP5085BR (Marauder-E) */ /* ICP9067MA (Intruder-6) */ /* Themisto Jupiter Platform */ /* Themisto Jupiter Platform */ /* Callisto Jupiter Platform */ /* ASR-2020SA SATA PCI-X ZCR (Skyhawk) */ /* ASR-2025SA SATA SO-DIMM PCI-X ZCR (Terminator) */ /* AAR-2410SA PCI SATA 4ch (Jaguar II) */ /* CERC SATA RAID 2 PCI SATA 6ch (DellCorsair) */ /* AAR-2810SA PCI SATA 8ch (Corsair-8) */ /* AAR-21610SA PCI SATA 16ch (Corsair-16) */ /* ESD SO-DIMM PCI-X SATA ZCR (Prowler) */ /* AAR-2610SA PCI SATA 6ch */ /* ASR-2240S (SabreExpress) */ /* ASR-4005 */ /* IBM 8i (AvonPark) */ /* IBM 8i (AvonPark Lite) */ /* IBM 8k/8k-l8 (Aurora) */ /* IBM 8k/8k-l4 (Aurora Lite) */ /* ASR-4000 (BlackBird) */ /* ASR-4800SAS (Marauder-X) */ /* ASR-4805SAS (Marauder-E) */ /* ASR-3800 (Hurricane44) */ /* Perc 320/DC*/ /* Adaptec 5400S (Mustang)*/ /* Adaptec 5400S (Mustang)*/ /* Dell PERC2/QC */ /* HP NetRAID-4M */ /* Dell Catchall */ /* Legend Catchall */ /* Adaptec Catch All */ /* Adaptec Rocket Catch All */ /* Adaptec NEMER/ARK Catch All */ /* Adaptec PMC Series 6 (Tupelo) */ /* Adaptec PMC Series 7 (Denali) */ /* Adaptec PMC Series 8 */ /* * dmb - For now we add the number of channels to this structure. * In the future we should add a fib that reports the number of channels * for the card. At that time we can remove the channels from here static struct aac_driver_ident aac_drivers[] = {"percraid" , "DELL " , "PERCRAID " , 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG | AAC_QUIRK_SCSI_32 }, /* PERC 2/Si (Iguana/PERC2Si) */ "percraid" , "DELL " , "PERCRAID " , 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG | AAC_QUIRK_SCSI_32 }, /* PERC 3/Di (Opal/PERC3Di) */ "percraid" , "DELL " , "PERCRAID " , 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG | AAC_QUIRK_SCSI_32 }, /* PERC 3/Si (SlimFast/PERC3Si */ "percraid" , "DELL " , "PERCRAID " , 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG | AAC_QUIRK_SCSI_32 }, /* PERC 3/Di (Iguana FlipChip/PERC3DiF */ "percraid" , "DELL " , "PERCRAID " , 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG | AAC_QUIRK_SCSI_32 }, /* PERC 3/Di (Viper/PERC3DiV) */ "percraid" , "DELL " , "PERCRAID " , 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG | AAC_QUIRK_SCSI_32 }, /* PERC 3/Di (Lexus/PERC3DiL) */ "percraid" , "DELL " , "PERCRAID " , 1, AAC_QUIRK_31BIT | AAC_QUIRK_34SG | AAC_QUIRK_SCSI_32 }, /* PERC 3/Di (Jaguar/PERC3DiJ) */ "percraid" , "DELL " , "PERCRAID " , 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG | AAC_QUIRK_SCSI_32 }, /* PERC 3/Di (Dagger/PERC3DiD) */ "percraid" , "DELL " , "PERCRAID " , 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG | AAC_QUIRK_SCSI_32 }, /* PERC 3/Di (Boxster/PERC3DiB) */ "aacraid" , "ADAPTEC " , "catapult " , 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG | AAC_QUIRK_SCSI_32 }, /* catapult */ "aacraid" , "ADAPTEC " , "tomcat " , 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG | AAC_QUIRK_SCSI_32 }, /* tomcat */ "aacraid" , "ADAPTEC " , "Adaptec 2120S " , 1, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* Adaptec 2120S (Crusader) */ "aacraid" , "ADAPTEC " , "Adaptec 2200S " , 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* Adaptec 2200S (Vulcan) */ "aacraid" , "ADAPTEC " , "Adaptec 2200S " , 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG | AAC_QUIRK_SCSI_32 }, /* Adaptec 2200S (Vulcan-2m) */ "aacraid" , "Legend " , "Legend S220 " , 1, AAC_QUIRK_31BIT | AAC_QUIRK_34SG | AAC_QUIRK_SCSI_32 }, /* Legend S220 (Legend Crusader) */ "aacraid" , "Legend " , "Legend S230 " , 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG | AAC_QUIRK_SCSI_32 }, /* Legend S230 (Legend Vulcan) */ "aacraid" , "ADAPTEC " , "Adaptec 3230S " , 2 }, /* Adaptec 3230S (Harrier) */ "aacraid" , "ADAPTEC " , "Adaptec 3240S " , 2 }, /* Adaptec 3240S (Tornado) */ "aacraid" , "ADAPTEC " , "ASR-2020ZCR " , 2 }, /* ASR-2020ZCR SCSI PCI-X ZCR (Skyhawk) */ "aacraid" , "ADAPTEC " , "ASR-2025ZCR " , 2 }, /* ASR-2025ZCR SCSI SO-DIMM PCI-X ZCR (Terminator) */ "aacraid" , "ADAPTEC " , "ASR-2230S PCI-X " , 2 }, /* ASR-2230S + ASR-2230SLP PCI-X (Lancer) */ "aacraid" , "ADAPTEC " , "ASR-2130S PCI-X " , 1 }, /* ASR-2130S (Lancer) */ "aacraid" , "ADAPTEC " , "AAR-2820SA " , 1 }, /* AAR-2820SA (Intruder) */ "aacraid" , "ADAPTEC " , "AAR-2620SA " , 1 }, /* AAR-2620SA (Intruder) */ "aacraid" , "ADAPTEC " , "AAR-2420SA " , 1 }, /* AAR-2420SA (Intruder) */ "aacraid" , "ICP " , "ICP9024RO " , 2 }, /* ICP9024RO (Lancer) */ "aacraid" , "ICP " , "ICP9014RO " , 1 }, /* ICP9014RO (Lancer) */ "aacraid" , "ICP " , "ICP9047MA " , 1 }, /* ICP9047MA (Lancer) */ "aacraid" , "ICP " , "ICP9087MA " , 1 }, /* ICP9087MA (Lancer) */ "aacraid" , "ICP " , "ICP5445AU " , 1 }, /* ICP5445AU (Hurricane44) */ "aacraid" , "ICP " , "ICP9085LI " , 1 }, /* ICP9085LI (Marauder-X) */ "aacraid" , "ICP " , "ICP5085BR " , 1 }, /* ICP5085BR (Marauder-E) */ "aacraid" , "ICP " , "ICP9067MA " , 1 }, /* ICP9067MA (Intruder-6) */ "aacraid" , "ADAPTEC " , "Themisto " , 0, AAC_QUIRK_SLAVE }, /* Jupiter Platform */ "aacraid" , "ADAPTEC " , "Callisto " , 2, AAC_QUIRK_MASTER }, /* Jupiter Platform */ "aacraid" , "ADAPTEC " , "ASR-2020SA " , 1 }, /* ASR-2020SA SATA PCI-X ZCR (Skyhawk) */ "aacraid" , "ADAPTEC " , "ASR-2025SA " , 1 }, /* ASR-2025SA SATA SO-DIMM PCI-X ZCR (Terminator) */ "aacraid" , "ADAPTEC " , "AAR-2410SA SATA " , 1, AAC_QUIRK_17SG }, /* AAR-2410SA PCI SATA 4ch (Jaguar II) */ "aacraid" , "DELL " , "CERC SR2 " , 1, AAC_QUIRK_17SG }, /* CERC SATA RAID 2 PCI SATA 6ch (DellCorsair) */ "aacraid" , "ADAPTEC " , "AAR-2810SA SATA " , 1, AAC_QUIRK_17SG }, /* AAR-2810SA PCI SATA 8ch (Corsair-8) */ "aacraid" , "ADAPTEC " , "AAR-21610SA SATA" , 1, AAC_QUIRK_17SG }, /* AAR-21610SA PCI SATA 16ch (Corsair-16) */ "aacraid" , "ADAPTEC " , "ASR-2026ZCR " , 1 }, /* ESD SO-DIMM PCI-X SATA ZCR (Prowler) */ "aacraid" , "ADAPTEC " , "AAR-2610SA " , 1 }, /* SATA 6Ch (Bearcat) */ "aacraid" , "ADAPTEC " , "ASR-2240S " , 1 }, /* ASR-2240S (SabreExpress) */ "aacraid" , "ADAPTEC " , "ASR-4005 " , 1 }, /* ASR-4005 */ "ServeRAID" ,"IBM " , "ServeRAID 8i " , 1 }, /* IBM 8i (AvonPark) */ "ServeRAID" ,"IBM " , "ServeRAID 8k-l8 " , 1 }, /* IBM 8k/8k-l8 (Aurora) */ "ServeRAID" ,"IBM " , "ServeRAID 8k-l4 " , 1 }, /* IBM 8k/8k-l4 (Aurora Lite) */ "aacraid" , "ADAPTEC " , "ASR-4000 " , 1 }, /* ASR-4000 (BlackBird & ;AvonPark) */ "aacraid" , "ADAPTEC " , "ASR-4800SAS " , 1 }, /* ASR-4800SAS (Marauder-X) */ "aacraid" , "ADAPTEC " , "ASR-4805SAS " , 1 }, /* ASR-4805SAS (Marauder-E) */ "aacraid" , "ADAPTEC " , "ASR-3800 " , 1 }, /* ASR-3800 (Hurricane44) */ "percraid" , "DELL " , "PERC 320/DC " , 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* Perc 320/DC*/ "aacraid" , "ADAPTEC " , "Adaptec 5400S " , 4, AAC_QUIRK_34SG }, /* Adaptec 5400S (Mustang)*/ "aacraid" , "ADAPTEC " , "AAC-364 " , 4, AAC_QUIRK_34SG }, /* Adaptec 5400S (Mustang)*/ "percraid" , "DELL " , "PERCRAID " , 4, AAC_QUIRK_34SG }, /* Dell PERC2/QC */ "hpnraid" , "HP " , "NetRAID " , 4, AAC_QUIRK_34SG }, /* HP NetRAID-4M */ "aacraid" , "DELL " , "RAID " , 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG | AAC_QUIRK_SCSI_32 }, /* Dell Catchall */ "aacraid" , "Legend " , "RAID " , 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG | AAC_QUIRK_SCSI_32 }, /* Legend Catchall */ "aacraid" , "ADAPTEC " , "RAID " , 2 }, /* Adaptec Catch All */ "aacraid" , "ADAPTEC " , "RAID " , 2 }, /* Adaptec Rocket Catch All */ "aacraid" , "ADAPTEC " , "RAID " , 2 }, /* Adaptec NEMER/ARK Catch All */ "aacraid" , "ADAPTEC " , "RAID " , 2, AAC_QUIRK_SRC }, /* Adaptec PMC Series 6 (Tupelo) */ "aacraid" , "ADAPTEC " , "RAID " , 2, AAC_QUIRK_SRC }, /* Adaptec PMC Series 7 (Denali) */ "aacraid" , "ADAPTEC " , "RAID " , 2, AAC_QUIRK_SRC }, /* Adaptec PMC Series 8 */ /** * aac_queuecommand - queue a SCSI command * @shost: Scsi host to queue command on * @cmd: SCSI command to queue * * Queues a command for execution by the associated Host Adapter. * * TODO: unify with aac_scsi_cmd(). static int aac_queuecommand(struct Scsi_Host *shost,struct scsi_cmnd *cmd)return aac_scsi_cmd(cmd) ? FAILED : 0;/** * aac_info - Returns the host adapter name * @shost: Scsi host to report on * * Returns a static string describing the device in question static const char *aac_info(struct Scsi_Host *shost)struct aac_dev *dev = (struct aac_dev *)shost->hostdata;return aac_drivers[dev->cardtype].name;/** * aac_get_driver_ident * @devtype: index into lookup table * * Returns a pointer to the entry in the driver lookup table. struct aac_driver_ident* aac_get_driver_ident(int devtype)return &aac_drivers[devtype];/** * aac_biosparm - return BIOS parameters for disk * @sdev: The scsi device corresponding to the disk * @bdev: the block device corresponding to the disk * @capacity: the sector capacity of the disk * @geom: geometry block to fill in * * Return the Heads/Sectors/Cylinders BIOS Disk Parameters for Disk. * The default disk geometry is 64 heads, 32 sectors, and the appropriate * number of cylinders so as not to exceed drive capacity. In order for * disks equal to or larger than 1 GB to be addressable by the BIOS * without exceeding the BIOS limitation of 1024 cylinders, Extended * Translation should be enabled. With Extended Translation enabled, * drives between 1 GB inclusive and 2 GB exclusive are given a disk * geometry of 128 heads and 32 sectors, and drives above 2 GB inclusive * are given a disk geometry of 255 heads and 63 sectors. However, if * the BIOS detects that the Extended Translation setting does not match * the geometry in the partition table, then the translation inferred * from the partition table will be used by the BIOS, and a warning may * be displayed. static int aac_biosparm(struct scsi_device *sdev, struct block_device *bdev,int *geom)struct diskparm *param = (struct diskparm *)geom;unsigned char *buf;"aac_biosparm.\n" ));/* * Assuming extended translation is enabled - #REVISIT# if (capacity >= 2 * 1024 * 1024) { /* 1 GB in 512 byte sectors */ if (capacity >= 4 * 1024 * 1024) { /* 2 GB in 512 byte sectors */ else {else {/* * Read the first 1024 bytes from the disk device, if the boot * sector partition table is valid, search for a partition table * entry whose end_head matches one of the standard geometry * translations ( 64/32, 128/32, 255/63 ). if (!buf)return 0;if (*(__le16 *)(buf + 0x40) == cpu_to_le16(MSDOS_LABEL_MAGIC)) {struct msdos_partition *first = (struct msdos_partition *)buf;struct msdos_partition *entry = first;int saved_cylinders = param->cylinders;int num;unsigned char end_head, end_sec;for (num = 0; num < 4; num++) {if (end_head == 63) {break ;else if (end_head == 127) {break ;else if (end_head == 254) {break ;if (num == 4) {if (num < 4 && end_sec == param->sectors) {if (param->cylinders != saved_cylinders) {"Adopting geometry: heads=%d, sectors=%d from partition table %d.\n" ,else if (end_head > 0 || end_sec > 0) {"Strange geometry: heads=%d, sectors=%d in partition table %d.\n" ,"Using geometry: heads=%d, sectors=%d.\n" ,return 0;/** * aac_sdev_configure - compute queue depths * @sdev: SCSI device we are considering * @lim: Request queue limits * * Selects queue depths for each target device based on the host adapter's * total capacity and the queue depth supported by the target device. * A queue depth of one automatically disables tagged queueing. static int aac_sdev_configure(struct scsi_device *sdev,struct queue_limits *lim)struct aac_dev *aac = (struct aac_dev *)sdev->host->hostdata;int chn, tid;unsigned int depth = 0;unsigned int set_timeout = 0;int timeout = 0;bool set_qd_dev_type = false ;if (chn < AAC_MAX_BUSES && tid < AAC_MAX_TARGETS && aac->sa_firmware) {if (devtype == AAC_DEVTYPE_NATIVE_RAW) {goto common_config;if (devtype == AAC_DEVTYPE_ARC_RAW) {true ;goto common_config;if (aac->jbod && (sdev->type == TYPE_DISK))if (sdev->type == TYPE_DISKif (expose_physicals == 0)return -ENXIO;if (expose_physicals < 0)if (sdev->tagged_supportedstruct scsi_device * dev;struct Scsi_Host *host = sdev->host;unsigned num_lsu = 0;unsigned num_one = 0;unsigned cid;for (cid = 0; cid < aac->maximum_num_containers; ++cid)if (aac->fsa_dev[cid].valid)if (dev->tagged_supportedif ((sdev_channel(dev) != CONTAINER_CHANNEL)else {if (num_lsu == 0)if (sdev_channel(sdev) != NATIVE_CHANNEL)goto common_config;true ;/* * Check if SATA drive if (set_qd_dev_type) {if (strncmp(sdev->vendor, "ATA" , 3) == 0)else /* * Firmware has an individual device recovery time typically * of 35 seconds, give us a margin. Thor devices can take longer in * error recovery, hence different value. if (set_timeout) {if (depth > 256)else if (depth < 1)return 0;/** * aac_change_queue_depth - alter queue depths * @sdev: SCSI device we are considering * @depth: desired queue depth * * Alters queue depths for target device based on the host adapter's * total capacity and the queue depth supported by the target device. static int aac_change_queue_depth(struct scsi_device *sdev, int depth)struct aac_dev *aac = (struct aac_dev *)(sdev->host->hostdata);int chn, tid, is_native_device = 0;if (chn < AAC_MAX_BUSES && tid < AAC_MAX_TARGETS &&if (sdev->tagged_supported && (sdev->type == TYPE_DISK) &&struct scsi_device * dev;struct Scsi_Host *host = sdev->host;unsigned num = 0;if (dev->tagged_supported && (dev->type == TYPE_DISK) &&if (num >= host->can_queue)if (depth > (host->can_queue - num))if (depth > 256)else if (depth < 2)return scsi_change_queue_depth(sdev, depth);else if (is_native_device) {else {return sdev->queue_depth;static ssize_t aac_show_raid_level(struct device *dev, struct device_attribute *attr, char *buf)struct scsi_device *sdev = to_scsi_device(dev);struct aac_dev *aac = (struct aac_dev *)(sdev->host->hostdata);if (sdev_channel(sdev) != CONTAINER_CHANNEL)return snprintf(buf, PAGE_SIZE, sdev->no_uld_attach"Hidden\n" :"JBOD\n" : "" ));return snprintf(buf, PAGE_SIZE, "%s\n" ,static struct device_attribute aac_raid_level_attr = {"level" ,static ssize_t aac_show_unique_id(struct device *dev,struct device_attribute *attr, char *buf)struct scsi_device *sdev = to_scsi_device(dev);struct aac_dev *aac = (struct aac_dev *)(sdev->host->hostdata);unsigned char sn[16];sizeof (sn));if (sdev_channel(sdev) == CONTAINER_CHANNEL)sizeof (sn));return snprintf(buf, 16 * 2 + 2,"%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X\n" ,static struct device_attribute aac_unique_id_attr = {"unique_id" ,static struct attribute *aac_dev_attrs[] = {static int aac_ioctl(struct scsi_device *sdev, unsigned int cmd,void __user *arg)int retval;struct aac_dev *dev = (struct aac_dev *)sdev->host->hostdata;if (!capable(CAP_SYS_RAWIO))return -EPERM;if (retval)return -EBUSY;return aac_do_ioctl(dev, cmd, arg);struct fib_count_data {int mlcnt;int llcnt;int ehcnt;int fwcnt;int krlcnt;static bool fib_count_iter(struct scsi_cmnd *scmnd, void *data)struct fib_count_data *fib_count = data;switch (aac_priv(scmnd)->owner) {case AAC_OWNER_FIRMWARE:break ;case AAC_OWNER_ERROR_HANDLER:break ;case AAC_OWNER_LOWLEVEL:break ;case AAC_OWNER_MIDLEVEL:break ;default :break ;return true ;/* Called during SCSI EH, so we don't need to block requests */ static int get_num_of_incomplete_fibs(struct aac_dev *aac)struct Scsi_Host *shost = aac->scsi_host_ptr;struct device *ctrl_dev;struct fib_count_data fcnt = { };"outstanding cmd: midlevel-%d\n" , fcnt.mlcnt);"outstanding cmd: lowlevel-%d\n" , fcnt.llcnt);"outstanding cmd: error handler-%d\n" , fcnt.ehcnt);"outstanding cmd: firmware-%d\n" , fcnt.fwcnt);"outstanding cmd: kernel-%d\n" , fcnt.krlcnt);return fcnt.mlcnt + fcnt.llcnt + fcnt.ehcnt + fcnt.fwcnt;static int aac_eh_abort(struct scsi_cmnd* cmd)struct aac_cmd_priv *cmd_priv = aac_priv(cmd);struct scsi_device * dev = cmd->device;struct Scsi_Host * host = dev->host;struct aac_dev * aac = (struct aac_dev *)host->hostdata;int count, found;int ret = FAILED;if (aac_adapter_check_health(aac))return ret;if (aac->hba_map[bus][cid].devtype == AAC_DEVTYPE_NATIVE_RAW) {struct fib *fib;struct aac_hba_tm_req *tmf;int status;"%s: Host adapter abort request (%d,%d,%d,%d)\n" ,int )dev->lun);for (count = 0; count < (host->can_queue + AAC_NUM_MGT_FIB); ++count) {if (*(u8 *)fib->hw_fib_va != 0 &&break ;if (!found)return ret;/* start a HBA_TMF_ABORT_TASK TMF request */ if (!fib)return ret;struct aac_hba_tm_req *)fib->hw_fib_va;sizeof (*tmf));sizeof (*tmf);void *) cmd);if (status != -EINPROGRESS) {return ret;/* Wait up to 15 secs for completion */ for (count = 0; count < 15; ++count) {if (cmd_priv->sent_command) {break ;if (ret != SUCCESS)"%s: Host adapter abort request timed out\n" ,else {"%s: Host adapter abort request.\n" "%s: Outstanding commands on (%d,%d,%d,%d):\n" ,int )dev->lun);switch (cmd->cmnd[0]) {case SERVICE_ACTION_IN_16:if (!(aac->raw_io_interface) ||break ;case INQUIRY:case READ_CAPACITY:/* * Mark associated FIB to not complete, * eh handler does this for (count = 0;struct fib *fib = &aac->fibs[count];if (fib->hw_fib_va->header.XferState &&break ;case TEST_UNIT_READY:/* * Mark associated FIB to not complete, * eh handler does this for (count = 0;struct scsi_cmnd *command;struct fib *fib = &aac->fibs[count];if ((fib->hw_fib_va->header.XferState &if (command == cmd)break ;return ret;static u8 aac_eh_tmf_lun_reset_fib(struct aac_hba_map_info *info,struct fib *fib, u64 tmf_lun)struct aac_hba_tm_req *tmf;/* start a HBA_TMF_LUN_RESET TMF request */ struct aac_hba_tm_req *)fib->hw_fib_va;sizeof (*tmf));struct scsi_lun *)tmf->lun);sizeof (*tmf);return HBA_IU_TYPE_SCSI_TM_REQ;static u8 aac_eh_tmf_hard_reset_fib(struct aac_hba_map_info *info,struct fib *fib)struct aac_hba_reset_req *rst;/* already tried, start a hard reset now */ struct aac_hba_reset_req *)fib->hw_fib_va;sizeof (*rst));sizeof (*rst);return HBA_IU_TYPE_SATA_REQ;static void aac_tmf_callback(void *context, struct fib *fibptr)struct aac_hba_resp *err =struct aac_native_hba *)fibptr->hw_fib_va)->resp.err;struct aac_hba_map_info *info = context;int res;switch (err->service_response) {case HBA_RESP_SVCRES_TMF_REJECTED:break ;case HBA_RESP_SVCRES_TMF_LUN_INVALID:break ;case HBA_RESP_SVCRES_TMF_COMPLETE:case HBA_RESP_SVCRES_TMF_SUCCEEDED:break ;default :break ;/* * aac_eh_dev_reset - Device reset command handling * @scsi_cmd: SCSI command block causing the reset * static int aac_eh_dev_reset(struct scsi_cmnd *cmd)struct scsi_device * dev = cmd->device;struct Scsi_Host * host = dev->host;struct aac_dev * aac = (struct aac_dev *)host->hostdata;struct aac_hba_map_info *info;int count;struct fib *fib;int ret = FAILED;int status;if (bus >= AAC_MAX_BUSES || cid >= AAC_MAX_TARGETS)return FAILED;if (!(info->devtype == AAC_DEVTYPE_NATIVE_RAW &&return FAILED;"%s: Host device reset request. SCSI hang ?\n" ,if (!fib)return ret;/* start a HBA_TMF_LUN_RESET TMF request */ void *) info);if (status != -EINPROGRESS) {return ret;/* Wait up to 15 seconds for completion */ for (count = 0; count < 15; ++count) {if (info->reset_state == 0) {break ;return ret;/* * aac_eh_target_reset - Target reset command handling * @scsi_cmd: SCSI command block causing the reset * static int aac_eh_target_reset(struct scsi_cmnd *cmd)struct scsi_device * dev = cmd->device;struct Scsi_Host * host = dev->host;struct aac_dev * aac = (struct aac_dev *)host->hostdata;struct aac_hba_map_info *info;int count;int ret = FAILED;struct fib *fib;int status;if (bus >= AAC_MAX_BUSES || cid >= AAC_MAX_TARGETS)return FAILED;if (!(info->devtype == AAC_DEVTYPE_NATIVE_RAW &&return FAILED;"%s: Host target reset request. SCSI hang ?\n" ,if (!fib)return ret;/* already tried, start a hard reset now */ void *) info);if (status != -EINPROGRESS) {return ret;/* Wait up to 15 seconds for completion */ for (count = 0; count < 15; ++count) {if (info->reset_state <= 0) {break ;return ret;/* * aac_eh_bus_reset - Bus reset command handling * @scsi_cmd: SCSI command block causing the reset * static int aac_eh_bus_reset(struct scsi_cmnd* cmd)struct scsi_device * dev = cmd->device;struct Scsi_Host * host = dev->host;struct aac_dev * aac = (struct aac_dev *)host->hostdata;int count;int status = 0;/* Mark the assoc. FIB to not complete, eh handler does this */ for (count = 0; count < (host->can_queue + AAC_NUM_MGT_FIB); ++count) {struct fib *fib = &aac->fibs[count];if (fib->hw_fib_va->header.XferState &&struct aac_hba_map_info *info;struct scsi_cmnd *)fib->callback_data;if (bus != cmd_bus)continue ;if (bus >= AAC_MAX_BUSES || cid >= AAC_MAX_TARGETS ||"%s: Host bus reset request. SCSI hang ?\n" , AAC_DRIVERNAME);/* * Check the health of the controller if (status)"Adapter health - %d\n" , status);return (count == 0) ? SUCCESS : FAILED;/* * aac_eh_host_reset - Host reset command handling * @scsi_cmd: SCSI command block causing the reset * static int aac_eh_host_reset(struct scsi_cmnd *cmd)struct scsi_device * dev = cmd->device;struct Scsi_Host * host = dev->host;struct aac_dev * aac = (struct aac_dev *)host->hostdata;int ret = FAILED;bool is_mu_reset;bool is_ignore_reset;bool is_doorbell_reset;/* * Check if reset is supported by the firmware /* * This adapter needs a blind reset, only do so for * Adapters that support a register, instead of a commanded, * reset. if ((is_mu_reset || is_doorbell_reset)/* Bypass wait for command quiesce */ if (aac_reset_adapter(aac, 2, IOP_HWSOFT_RESET) == 0)/* * Reset EH state if (ret == SUCCESS) {int bus, cid;struct aac_hba_map_info *info;for (bus = 0; bus < AAC_MAX_BUSES; bus++) {for (cid = 0; cid < AAC_MAX_TARGETS; cid++) {if (info->devtype == AAC_DEVTYPE_NATIVE_RAW)return ret;/** * aac_cfg_open - open a configuration file * @inode: inode being opened * @file: file handle attached * * Called when the configuration device is opened. Does the needed * set up on the handle and then returns * * Bugs: This needs extending to check a given adapter is present * so we can support hot plugging, and to ref count adapters. static int aac_cfg_open(struct inode *inode, struct file *file)struct aac_dev *aac;unsigned minor_number = iminor(inode);int err = -ENODEV;/* BKL pushdown: nothing else protects this list */ if (aac->id == minor_number) {break ;return err;/** * aac_cfg_ioctl - AAC configuration request * @file: file handle * @cmd: ioctl command code * @arg: argument * * Handles a configuration ioctl. Currently this involves wrapping it * up and feeding it into the nasty windowsalike glue layer. * * Bugs: Needs locking against parallel ioctls lower down * Bugs: Needs to handle hot plugging static long aac_cfg_ioctl(struct file *file,unsigned int cmd, unsigned long arg)struct aac_dev *aac = (struct aac_dev *)file->private_data;if (!capable(CAP_SYS_RAWIO))return -EPERM;return aac_do_ioctl(aac, cmd, (void __user *)arg);static ssize_t aac_show_model(struct device *device,struct device_attribute *attr, char *buf)struct aac_dev *dev = (struct aac_dev*)class_to_shost(device)->hostdata;int len;if (dev->supplement_adapter_info.adapter_type_text[0]) {char *cp = dev->supplement_adapter_info.adapter_type_text;while (*cp && *cp != ' ' )while (*cp == ' ' )"%s\n" , cp);else "%s\n" ,return len;static ssize_t aac_show_vendor(struct device *device,struct device_attribute *attr, char *buf)struct aac_dev *dev = (struct aac_dev*)class_to_shost(device)->hostdata;struct aac_supplement_adapter_info *sup_adap_info;int len;if (sup_adap_info->adapter_type_text[0]) {char *cp = sup_adap_info->adapter_type_text;while (*cp && *cp != ' ' )"%.*s\n" ,int )(cp - (char *)sup_adap_info->adapter_type_text),else "%s\n" ,return len;static ssize_t aac_show_flags(struct device *cdev,struct device_attribute *attr, char *buf)int len = 0;struct aac_dev *dev = (struct aac_dev*)class_to_shost(cdev)->hostdata;if (nblank(dprintk(x)))"dprintk\n" );#ifdef AAC_DETAILED_STATUS_INFO"AAC_DETAILED_STATUS_INFO\n" );#endif if (dev->raw_io_interface && dev->raw_io_64)"SAI_READ_CAPACITY_16\n" );if (dev->jbod)"SUPPORTED_JBOD\n" );if (dev->supplement_adapter_info.supported_options2 &"SUPPORTED_POWER_MANAGEMENT\n" );if (dev->msi)"PCI_HAS_MSI\n" );return len;static ssize_t aac_show_kernel_version(struct device *device,struct device_attribute *attr,char *buf)struct aac_dev *dev = (struct aac_dev*)class_to_shost(device)->hostdata;int len, tmp;"%d.%d-%d[%d]\n" ,return len;static ssize_t aac_show_monitor_version(struct device *device,struct device_attribute *attr,char *buf)struct aac_dev *dev = (struct aac_dev*)class_to_shost(device)->hostdata;int len, tmp;"%d.%d-%d[%d]\n" ,return len;static ssize_t aac_show_bios_version(struct device *device,struct device_attribute *attr,char *buf)struct aac_dev *dev = (struct aac_dev*)class_to_shost(device)->hostdata;int len, tmp;"%d.%d-%d[%d]\n" ,return len;static ssize_t aac_show_driver_version(struct device *device,struct device_attribute *attr,char *buf)return snprintf(buf, PAGE_SIZE, "%s\n" , aac_driver_version);static ssize_t aac_show_serial_number(struct device *device,struct device_attribute *attr, char *buf)struct aac_dev *dev = (struct aac_dev*)class_to_shost(device)->hostdata;int len = 0;if (le32_to_cpu(dev->adapter_info.serial[0]) != 0xBAD0)"%06X\n" ,if (len &&sizeof (dev->supplement_adapter_info.mfg_pcba_serial_no)-len],"%.*s\n" ,int )sizeof (dev->supplement_adapter_info.mfg_pcba_serial_no),return min(len, 16);static ssize_t aac_show_max_channel(struct device *device,struct device_attribute *attr, char *buf)return snprintf(buf, PAGE_SIZE, "%d\n" ,static ssize_t aac_show_max_id(struct device *device,struct device_attribute *attr, char *buf)return snprintf(buf, PAGE_SIZE, "%d\n" ,static ssize_t aac_store_reset_adapter(struct device *device,struct device_attribute *attr,const char *buf, size_t count)int retval = -EACCES;if (!capable(CAP_SYS_ADMIN))return retval;'!' , IOP_HWSOFT_RESET);if (retval >= 0)return retval;static ssize_t aac_show_reset_adapter(struct device *device,struct device_attribute *attr,char *buf)struct aac_dev *dev = (struct aac_dev*)class_to_shost(device)->hostdata;int len, tmp;if ((tmp == 0) && dev->in_reset)"0x%x\n" , tmp);return len;static struct device_attribute aac_model = {"model" ,static struct device_attribute aac_vendor = {"vendor" ,static struct device_attribute aac_flags = {"flags" ,static struct device_attribute aac_kernel_version = {"hba_kernel_version" ,static struct device_attribute aac_monitor_version = {"hba_monitor_version" ,static struct device_attribute aac_bios_version = {"hba_bios_version" ,static struct device_attribute aac_lld_version = {"driver_version" ,static struct device_attribute aac_serial_number = {"serial_number" ,static struct device_attribute aac_max_channel = {"max_channel" ,static struct device_attribute aac_max_id = {"max_id" ,static struct device_attribute aac_reset = {"reset_host" ,static struct attribute *aac_host_attrs[] = {struct device *device, char *buf)return aac_show_serial_number(device, &aac_serial_number, buf);static const struct file_operations aac_cfg_fops = {#ifdef CONFIG_COMPAT#endif static const struct scsi_host_template aac_driver_template = {"AAC" ,#ifdef CONFIG_COMPAT#endif #if (AAC_NUM_IO_FIB > 256)#else #endif sizeof (struct aac_cmd_priv),static void __aac_shutdown(struct aac_dev * aac)int i;if (aac->aif_thread) {int i;/* Clear out events first */ for (i = 0; i < (aac->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB); i++) {struct fib *fib = &aac->fibs[i];if (!(fib->hw_fib_va->header.XferState & cpu_to_le32(NoResponseExpected | Async)) &&if (aac_is_src(aac)) {if (aac->max_msix > 1) {for (i = 0; i < aac->max_msix; i++) {else {else {if (aac->msi)else if (aac->max_msix > 1)static void aac_init_char(void )"aac" , &aac_cfg_fops);if (aac_cfg_major < 0) {"aacraid: unable to register \" aac\" device.\n" );void aac_reinit_aif(struct aac_dev *aac, unsigned int index)/* * Firmware may send a AIF messages very early and the Driver may have * ignored as it is not fully ready to process the messages. Send * AIF to firmware so that if there are any unprocessed events they * can be processed now. if (aac_drivers[index].quirks & AAC_QUIRK_SRC)static int aac_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)unsigned index = id->driver_data;struct Scsi_Host *shost;struct aac_dev *aac;struct list_head *insert = &aac_devices;int error;int unique_id = 0;int mask_bits = 0;extern int aac_sync_mode;/* * Only series 7 needs freset. if (pdev->device == PMC_DEVICE_S7)if (aac->id > unique_id)break ;if (error)goto out;if (!(aac_drivers[index].quirks & AAC_QUIRK_SRC)) {if (error) {"PCI 32 BIT dma mask set failed" );goto out_disable_pdev;/* * If the quirk31 bit is set, the adapter needs adapter * to driver communication memory to be allocated below 2gig if (aac_drivers[index].quirks & AAC_QUIRK_31BIT) {else {if (error) {"PCI %d B consistent dma mask set failed\n" goto out_disable_pdev;sizeof (struct aac_dev));if (!shost) {goto out_disable_pdev;if (aac_cfg_major == AAC_CHARDEV_NEEDS_REINIT)struct aac_dev *)shost->hostdata;if (aac_reset_devices || reset_devices)true ;sizeof (struct fib),if (!aac->fibs) {goto out_free_host;/* * Map in the registers from the adapter. if ((*aac_drivers[index].init)(aac)) {goto out_unmap;if (aac->sync_mode) {if (aac_sync_mode)"%s%d: Sync. mode enforced " "by driver parameter. This will cause " "a significant performance decrease!\n" ,else "%s%d: Async. mode not supported " "by current driver, sync. mode enforced." "\nPlease update driver to get full performance.\n" ,/* * Start any kernel threads needed if (IS_ERR(aac->thread)) {"aacraid: Unable to create command thread.\n" );goto out_deinit;if (error < 0)goto out_deinit;/* * Lets override negotiations and drop the maximum SG limit to 34 if ((aac_drivers[index].quirks & AAC_QUIRK_34SG) &&if ((aac_drivers[index].quirks & AAC_QUIRK_17SG) &&if (aac->adapter_info.options & AAC_OPT_NEW_COMM)else /* * Firmware printf works only with older firmware. if (aac_drivers[index].quirks & AAC_QUIRK_34SG)else /* * max channel will be the physical channels plus 1 virtual channel * all containers are on the virtual channel 0 (CONTAINER_CHANNEL) * physical channels are address by their actual physical number+1 if (aac->nondasd_support || expose_physicals || aac->jbod)else if (shost->max_id < aac->maximum_num_physicals)if (shost->max_id < MAXIMUM_NUM_CONTAINERS)else if (!aac->sa_firmware && aac_drivers[index].quirks & AAC_QUIRK_SRC)/* * dmb - we may need to move the setting of these parms somewhere else once * we get a fib that can report the actual numbers if (error)goto out_deinit;return 0;if (aac->comm_addr)return error;static void aac_release_resources(struct aac_dev *aac)static int aac_acquire_resources(struct aac_dev *dev)unsigned long status;/* * First clear out all interrupts. Then enable the one's that we * can handle. while (!((status = src_readl(dev, MUnit.OMR)) & KERNEL_UP_AND_RUNNING)if (aac_is_src(dev))if (dev->msi_enabled)if (aac_acquire_irq(dev))goto error_iounmap;/*max msix may change after EEH * Re-assign vectors to fibs if (!dev->sync_mode) {/* After EEH recovery or suspend resume, max_msix count * may change, therefore updating in init as well. return 0;return -1;static int __maybe_unused aac_suspend(struct device *dev)struct Scsi_Host *shost = dev_get_drvdata(dev);struct aac_dev *aac = (struct aac_dev *)shost->hostdata;return 0;static int __maybe_unused aac_resume(struct device *dev)struct Scsi_Host *shost = dev_get_drvdata(dev);struct aac_dev *aac = (struct aac_dev *)shost->hostdata;if (aac_acquire_resources(aac))goto fail_device;/* * reset this flag to unblock ioctl() as it was set at * aac_send_shutdown() to block ioctls from upperlayer return 0;"%s%d: resume failed.\n" , aac->name, aac->id);return -ENODEV;static void aac_shutdown(struct pci_dev *dev)struct Scsi_Host *shost = pci_get_drvdata(dev);struct aac_dev *)shost->hostdata);static void aac_remove_one(struct pci_dev *pdev)struct Scsi_Host *shost = pci_get_drvdata(pdev);struct aac_dev *aac = (struct aac_dev *)shost->hostdata;if (list_empty(&aac_devices)) {"aac" );static pci_ers_result_t aac_pci_error_detected(struct pci_dev *pdev,struct Scsi_Host *shost = pci_get_drvdata(pdev);struct aac_dev *aac = shost_priv(shost);"aacraid: PCI error detected %x\n" , error);switch (error) {case pci_channel_io_normal:return PCI_ERS_RESULT_CAN_RECOVER;case pci_channel_io_frozen:return PCI_ERS_RESULT_NEED_RESET;case pci_channel_io_perm_failure:return PCI_ERS_RESULT_DISCONNECT;return PCI_ERS_RESULT_NEED_RESET;static pci_ers_result_t aac_pci_mmio_enabled(struct pci_dev *pdev)"aacraid: PCI error - mmio enabled\n" );return PCI_ERS_RESULT_NEED_RESET;static pci_ers_result_t aac_pci_slot_reset(struct pci_dev *pdev)"aacraid: PCI error - slot reset\n" );if (pci_enable_device(pdev)) {"aacraid: failed to enable slave\n" );goto fail_device;if (pci_enable_device_mem(pdev)) {"pci_enable_device_mem failed\n" );goto fail_device;return PCI_ERS_RESULT_RECOVERED;"aacraid: PCI error - slot reset failed\n" );return PCI_ERS_RESULT_DISCONNECT;static void aac_pci_resume(struct pci_dev *pdev)struct Scsi_Host *shost = pci_get_drvdata(pdev);struct aac_dev *aac = (struct aac_dev *)shost_priv(shost);if (aac_adapter_ioremap(aac, aac->base_size)) {"aacraid: ioremap failed\n" );/* remap failed, go back ... */ if (aac_adapter_ioremap(aac, AAC_MIN_FOOTPRINT_SIZE)) {"aacraid: unable to map adapter.\n" );return ;/* * reset this flag to unblock ioctl() as it was set * at aac_send_shutdown() to block ioctls from upperlayer "aacraid: PCI error - resume\n" );static const struct pci_error_handlers aac_pci_err_handler = {static SIMPLE_DEV_PM_OPS(aac_pm_ops, aac_suspend, aac_resume);static struct pci_driver aac_pci_driver = {static int __init aac_init(void )int error;"Adaptec %s driver %s\n" ,if (error < 0)return error;return 0;static void __exit aac_exit(void )if (aac_cfg_major > -1)"aac" );
Messung V0.5 C=94 H=90 G=91
¤ Dauer der Verarbeitung: 0.72 Sekunden
(vorverarbeitet)
¤ *© Formatika GbR, Deutschland
