1 files changed, 182 insertions, 162 deletions

diff --git a/drivers/scsi/hpsa.c b/drivers/scsi/hpsa.c
index b96962c39449..500e20dd56ec 100644
--- a/drivers/scsi/hpsa.c
+++ b/drivers/scsi/hpsa.c
@@ -56,6 +56,7 @@
 /* HPSA_DRIVER_VERSION must be 3 byte values (0-255) separated by '.' */
 #define HPSA_DRIVER_VERSION "2.0.2-1"
 #define DRIVER_NAME "HP HPSA Driver (v " HPSA_DRIVER_VERSION ")"
+#define HPSA "hpsa"
 
 /* How long to wait (in milliseconds) for board to go into simple mode */
 #define MAX_CONFIG_WAIT 30000
@@ -202,30 +203,31 @@ static int check_for_unit_attention(struct ctlr_info *h,
 
         switch (c->err_info->SenseInfo[12]) {
         case STATE_CHANGED:
-                dev_warn(&h->pdev->dev, "hpsa%d: a state change "
+                dev_warn(&h->pdev->dev, HPSA "%d: a state change "
                         "detected, command retried\n", h->ctlr);
                 break;
         case LUN_FAILED:
-                dev_warn(&h->pdev->dev, "hpsa%d: LUN failure "
+                dev_warn(&h->pdev->dev, HPSA "%d: LUN failure "
                         "detected, action required\n", h->ctlr);
                 break;
         case REPORT_LUNS_CHANGED:
-                dev_warn(&h->pdev->dev, "hpsa%d: report LUN data "
+                dev_warn(&h->pdev->dev, HPSA "%d: report LUN data "
                         "changed, action required\n", h->ctlr);
         /*
-         * Note: this REPORT_LUNS_CHANGED condition only occurs on the MSA2012.
+         * Note: this REPORT_LUNS_CHANGED condition only occurs on the external
+         * target (array) devices.
          */
                 break;
         case POWER_OR_RESET:
-                dev_warn(&h->pdev->dev, "hpsa%d: a power on "
+                dev_warn(&h->pdev->dev, HPSA "%d: a power on "
                         "or device reset detected\n", h->ctlr);
                 break;
         case UNIT_ATTENTION_CLEARED:
-                dev_warn(&h->pdev->dev, "hpsa%d: unit attention "
+                dev_warn(&h->pdev->dev, HPSA "%d: unit attention "
                     "cleared by another initiator\n", h->ctlr);
                 break;
         default:
-                dev_warn(&h->pdev->dev, "hpsa%d: unknown "
+                dev_warn(&h->pdev->dev, HPSA "%d: unknown "
                         "unit attention detected\n", h->ctlr);
                 break;
         }
@@ -296,11 +298,23 @@ static u32 unresettable_controller[] = {
         0x40800E11, /* Smart Array 5i */
         0x409C0E11, /* Smart Array 6400 */
         0x409D0E11, /* Smart Array 6400 EM */
+        0x40700E11, /* Smart Array 5300 */
+        0x40820E11, /* Smart Array 532 */
+        0x40830E11, /* Smart Array 5312 */
+        0x409A0E11, /* Smart Array 641 */
+        0x409B0E11, /* Smart Array 642 */
+        0x40910E11, /* Smart Array 6i */
 };
 
 /* List of controllers which cannot even be soft reset */
 static u32 soft_unresettable_controller[] = {
         0x40800E11, /* Smart Array 5i */
+        0x40700E11, /* Smart Array 5300 */
+        0x40820E11, /* Smart Array 532 */
+        0x40830E11, /* Smart Array 5312 */
+        0x409A0E11, /* Smart Array 641 */
+        0x409B0E11, /* Smart Array 642 */
+        0x40910E11, /* Smart Array 6i */
         /* Exclude 640x boards.  These are two pci devices in one slot
          * which share a battery backed cache module.  One controls the
          * cache, the other accesses the cache through the one that controls
@@ -475,8 +489,8 @@ static struct device_attribute *hpsa_shost_attrs[] = {
 
 static struct scsi_host_template hpsa_driver_template = {
         .module                 = THIS_MODULE,
-        .name                   = "hpsa",
-        .proc_name              = "hpsa",
+        .name                   = HPSA,
+        .proc_name              = HPSA,
         .queuecommand           = hpsa_scsi_queue_command,
         .scan_start             = hpsa_scan_start,
         .scan_finished          = hpsa_scan_finished,
@@ -577,21 +591,19 @@ static int hpsa_find_target_lun(struct ctlr_info *h,
         int i, found = 0;
         DECLARE_BITMAP(lun_taken, HPSA_MAX_DEVICES);
 
-        memset(&lun_taken[0], 0, HPSA_MAX_DEVICES >> 3);
+        bitmap_zero(lun_taken, HPSA_MAX_DEVICES);
 
         for (i = 0; i < h->ndevices; i++) {
                 if (h->dev[i]->bus == bus && h->dev[i]->target != -1)
-                        set_bit(h->dev[i]->target, lun_taken);
+                        __set_bit(h->dev[i]->target, lun_taken);
         }
 
-        for (i = 0; i < HPSA_MAX_DEVICES; i++) {
-                if (!test_bit(i, lun_taken)) {
-                        /* *bus = 1; */
-                        *target = i;
-                        *lun = 0;
-                        found = 1;
-                        break;
-                }
+        i = find_first_zero_bit(lun_taken, HPSA_MAX_DEVICES);
+        if (i < HPSA_MAX_DEVICES) {
+                /* *bus = 1; */
+                *target = i;
+                *lun = 0;
+                found = 1;
         }
         return !found;
 }
@@ -675,6 +687,20 @@ lun_assigned:
         return 0;
 }
 
+/* Update an entry in h->dev[] array. */
+static void hpsa_scsi_update_entry(struct ctlr_info *h, int hostno,
+        int entry, struct hpsa_scsi_dev_t *new_entry)
+{
+        /* assumes h->devlock is held */
+        BUG_ON(entry < 0 || entry >= HPSA_MAX_DEVICES);
+
+        /* Raid level changed. */
+        h->dev[entry]->raid_level = new_entry->raid_level;
+        dev_info(&h->pdev->dev, "%s device c%db%dt%dl%d updated.\n",
+                scsi_device_type(new_entry->devtype), hostno, new_entry->bus,
+                new_entry->target, new_entry->lun);
+}
+
 /* Replace an entry from h->dev[] array. */
 static void hpsa_scsi_replace_entry(struct ctlr_info *h, int hostno,
         int entry, struct hpsa_scsi_dev_t *new_entry,
@@ -781,10 +807,25 @@ static inline int device_is_the_same(struct hpsa_scsi_dev_t *dev1,
         return 1;
 }
 
+static inline int device_updated(struct hpsa_scsi_dev_t *dev1,
+        struct hpsa_scsi_dev_t *dev2)
+{
+        /* Device attributes that can change, but don't mean
+         * that the device is a different device, nor that the OS
+         * needs to be told anything about the change.
+         */
+        if (dev1->raid_level != dev2->raid_level)
+                return 1;
+        return 0;
+}
+
 /* Find needle in haystack.  If exact match found, return DEVICE_SAME,
  * and return needle location in *index.  If scsi3addr matches, but not
  * vendor, model, serial num, etc. return DEVICE_CHANGED, and return needle
- * location in *index.  If needle not found, return DEVICE_NOT_FOUND.
+ * location in *index.
+ * In the case of a minor device attribute change, such as RAID level, just
+ * return DEVICE_UPDATED, along with the updated device's location in index.
+ * If needle not found, return DEVICE_NOT_FOUND.
  */
 static int hpsa_scsi_find_entry(struct hpsa_scsi_dev_t *needle,
         struct hpsa_scsi_dev_t *haystack[], int haystack_size,
@@ -794,15 +835,19 @@ static int hpsa_scsi_find_entry(struct hpsa_scsi_dev_t *needle,
 #define DEVICE_NOT_FOUND 0
 #define DEVICE_CHANGED 1
 #define DEVICE_SAME 2
+#define DEVICE_UPDATED 3
         for (i = 0; i < haystack_size; i++) {
                 if (haystack[i] == NULL) /* previously removed. */
                         continue;
                 if (SCSI3ADDR_EQ(needle->scsi3addr, haystack[i]->scsi3addr)) {
                         *index = i;
-                        if (device_is_the_same(needle, haystack[i]))
+                        if (device_is_the_same(needle, haystack[i])) {
+                                if (device_updated(needle, haystack[i]))
+                                        return DEVICE_UPDATED;
                                 return DEVICE_SAME;
-                        else
+                        } else {
                                 return DEVICE_CHANGED;
+                        }
                 }
         }
         *index = -1;
@@ -838,6 +883,8 @@ static void adjust_hpsa_scsi_table(struct ctlr_info *h, int hostno,
          * sd[] and remove them from h->dev[], and for any
          * devices which have changed, remove the old device
          * info and add the new device info.
+         * If minor device attributes change, just update
+         * the existing device structure.
          */
         i = 0;
         nremoved = 0;
@@ -858,6 +905,8 @@ static void adjust_hpsa_scsi_table(struct ctlr_info *h, int hostno,
                          * at the bottom of hpsa_update_scsi_devices()
                          */
                         sd[entry] = NULL;
+                } else if (device_change == DEVICE_UPDATED) {
+                        hpsa_scsi_update_entry(h, hostno, i, sd[entry]);
                 }
                 i++;
         }
@@ -1257,46 +1306,6 @@ static void complete_scsi_command(struct CommandList *cp)
         cmd_free(h, cp);
 }
 
-static int hpsa_scsi_detect(struct ctlr_info *h)
-{
-        struct Scsi_Host *sh;
-        int error;
-
-        sh = scsi_host_alloc(&hpsa_driver_template, sizeof(h));
-        if (sh == NULL)
-                goto fail;
-
-        sh->io_port = 0;
-        sh->n_io_port = 0;
-        sh->this_id = -1;
-        sh->max_channel = 3;
-        sh->max_cmd_len = MAX_COMMAND_SIZE;
-        sh->max_lun = HPSA_MAX_LUN;
-        sh->max_id = HPSA_MAX_LUN;
-        sh->can_queue = h->nr_cmds;
-        sh->cmd_per_lun = h->nr_cmds;
-        sh->sg_tablesize = h->maxsgentries;
-        h->scsi_host = sh;
-        sh->hostdata[0] = (unsigned long) h;
-        sh->irq = h->intr[h->intr_mode];
-        sh->unique_id = sh->irq;
-        error = scsi_add_host(sh, &h->pdev->dev);
-        if (error)
-                goto fail_host_put;
-        scsi_scan_host(sh);
-        return 0;
-
- fail_host_put:
-        dev_err(&h->pdev->dev, "hpsa_scsi_detect: scsi_add_host"
-                " failed for controller %d\n", h->ctlr);
-        scsi_host_put(sh);
-        return error;
- fail:
-        dev_err(&h->pdev->dev, "hpsa_scsi_detect: scsi_host_alloc"
-                " failed for controller %d\n", h->ctlr);
-        return -ENOMEM;
-}
-
 static void hpsa_pci_unmap(struct pci_dev *pdev,
         struct CommandList *c, int sg_used, int data_direction)
 {
@@ -1641,7 +1650,7 @@ bail_out:
         return 1;
 }
 
-static unsigned char *msa2xxx_model[] = {
+static unsigned char *ext_target_model[] = {
         "MSA2012",
         "MSA2024",
         "MSA2312",
@@ -1650,78 +1659,54 @@ static unsigned char *msa2xxx_model[] = {
         NULL,
 };
 
-static int is_msa2xxx(struct ctlr_info *h, struct hpsa_scsi_dev_t *device)
+static int is_ext_target(struct ctlr_info *h, struct hpsa_scsi_dev_t *device)
 {
         int i;
 
-        for (i = 0; msa2xxx_model[i]; i++)
-                if (strncmp(device->model, msa2xxx_model[i],
-                        strlen(msa2xxx_model[i])) == 0)
+        for (i = 0; ext_target_model[i]; i++)
+                if (strncmp(device->model, ext_target_model[i],
+                        strlen(ext_target_model[i])) == 0)
                         return 1;
         return 0;
 }
 
 /* Helper function to assign bus, target, lun mapping of devices.
- * Puts non-msa2xxx logical volumes on bus 0, msa2xxx logical
+ * Puts non-external target logical volumes on bus 0, external target logical
  * volumes on bus 1, physical devices on bus 2. and the hba on bus 3.
  * Logical drive target and lun are assigned at this time, but
  * physical device lun and target assignment are deferred (assigned
  * in hpsa_find_target_lun, called by hpsa_scsi_add_entry.)
  */
 static void figure_bus_target_lun(struct ctlr_info *h,
-        u8 *lunaddrbytes, int *bus, int *target, int *lun,
-        struct hpsa_scsi_dev_t *device)
+        u8 *lunaddrbytes, struct hpsa_scsi_dev_t *device)
 {
-        u32 lunid;
+        u32 lunid = le32_to_cpu(*((__le32 *) lunaddrbytes));
 
-        if (is_logical_dev_addr_mode(lunaddrbytes)) {
-                /* logical device */
-                if (unlikely(is_scsi_rev_5(h))) {
-                        /* p1210m, logical drives lun assignments
-                         * match SCSI REPORT LUNS data.
-                         */
-                        lunid = le32_to_cpu(*((__le32 *) lunaddrbytes));
-                        *bus = 0;
-                        *target = 0;
-                        *lun = (lunid & 0x3fff) + 1;
-                } else {
-                        /* not p1210m... */
-                        lunid = le32_to_cpu(*((__le32 *) lunaddrbytes));
-                        if (is_msa2xxx(h, device)) {
-                                /* msa2xxx way, put logicals on bus 1
-                                 * and match target/lun numbers box
-                                 * reports.
-                                 */
-                                *bus = 1;
-                                *target = (lunid >> 16) & 0x3fff;
-                                *lun = lunid & 0x00ff;
-                        } else {
-                                /* Traditional smart array way. */
-                                *bus = 0;
-                                *lun = 0;
-                                *target = lunid & 0x3fff;
-                        }
-                }
-        } else {
-                /* physical device */
+        if (!is_logical_dev_addr_mode(lunaddrbytes)) {
+                /* physical device, target and lun filled in later */
                 if (is_hba_lunid(lunaddrbytes))
-                        if (unlikely(is_scsi_rev_5(h))) {
-                                *bus = 0; /* put p1210m ctlr at 0,0,0 */
-                                *target = 0;
-                                *lun = 0;
-                                return;
-                        } else
-                                *bus = 3; /* traditional smartarray */
+                        hpsa_set_bus_target_lun(device, 3, 0, lunid & 0x3fff);
                 else
-                        *bus = 2; /* physical disk */
-                *target = -1;
-                *lun = -1; /* we will fill these in later. */
+                        /* defer target, lun assignment for physical devices */
+                        hpsa_set_bus_target_lun(device, 2, -1, -1);
+                return;
+        }
+        /* It's a logical device */
+        if (is_ext_target(h, device)) {
+                /* external target way, put logicals on bus 1
+                 * and match target/lun numbers box
+                 * reports, other smart array, bus 0, target 0, match lunid
+                 */
+                hpsa_set_bus_target_lun(device,
+                        1, (lunid >> 16) & 0x3fff, lunid & 0x00ff);
+                return;
         }
+        hpsa_set_bus_target_lun(device, 0, 0, lunid & 0x3fff);
 }
 
 /*
  * If there is no lun 0 on a target, linux won't find any devices.
- * For the MSA2xxx boxes, we have to manually detect the enclosure
+ * For the external targets (arrays), we have to manually detect the enclosure
  * which is at lun zero, as CCISS_REPORT_PHYSICAL_LUNS doesn't report
  * it for some reason.  *tmpdevice is the target we're adding,
  * this_device is a pointer into the current element of currentsd[]
@@ -1730,46 +1715,46 @@ static void figure_bus_target_lun(struct ctlr_info *h,
  * lun 0 assigned.
  * Returns 1 if an enclosure was added, 0 if not.
  */
-static int add_msa2xxx_enclosure_device(struct ctlr_info *h,
+static int add_ext_target_dev(struct ctlr_info *h,
         struct hpsa_scsi_dev_t *tmpdevice,
         struct hpsa_scsi_dev_t *this_device, u8 *lunaddrbytes,
-        int bus, int target, int lun, unsigned long lunzerobits[],
-        int *nmsa2xxx_enclosures)
+        unsigned long lunzerobits[], int *n_ext_target_devs)
 {
         unsigned char scsi3addr[8];
 
-        if (test_bit(target, lunzerobits))
+        if (test_bit(tmpdevice->target, lunzerobits))
                 return 0; /* There is already a lun 0 on this target. */
 
         if (!is_logical_dev_addr_mode(lunaddrbytes))
                 return 0; /* It's the logical targets that may lack lun 0. */
 
-        if (!is_msa2xxx(h, tmpdevice))
-                return 0; /* It's only the MSA2xxx that have this problem. */
+        if (!is_ext_target(h, tmpdevice))
+                return 0; /* Only external target devices have this problem. */
 
-        if (lun == 0) /* if lun is 0, then obviously we have a lun 0. */
+        if (tmpdevice->lun == 0) /* if lun is 0, then we have a lun 0. */
                 return 0;
 
         memset(scsi3addr, 0, 8);
-        scsi3addr[3] = target;
+        scsi3addr[3] = tmpdevice->target;
         if (is_hba_lunid(scsi3addr))
                 return 0; /* Don't add the RAID controller here. */
 
         if (is_scsi_rev_5(h))
                 return 0; /* p1210m doesn't need to do this. */
 
-        if (*nmsa2xxx_enclosures >= MAX_MSA2XXX_ENCLOSURES) {
-                dev_warn(&h->pdev->dev, "Maximum number of MSA2XXX "
-                        "enclosures exceeded.  Check your hardware "
+        if (*n_ext_target_devs >= MAX_EXT_TARGETS) {
+                dev_warn(&h->pdev->dev, "Maximum number of external "
+                        "target devices exceeded.  Check your hardware "
                         "configuration.");
                 return 0;
         }
 
         if (hpsa_update_device_info(h, scsi3addr, this_device, NULL))
                 return 0;
-        (*nmsa2xxx_enclosures)++;
-        hpsa_set_bus_target_lun(this_device, bus, target, 0);
-        set_bit(target, lunzerobits);
+        (*n_ext_target_devs)++;
+        hpsa_set_bus_target_lun(this_device,
+                                tmpdevice->bus, tmpdevice->target, 0);
+        set_bit(tmpdevice->target, lunzerobits);
         return 1;
 }
 
@@ -1863,10 +1848,9 @@ static void hpsa_update_scsi_devices(struct ctlr_info *h, int hostno)
         struct hpsa_scsi_dev_t **currentsd, *this_device, *tmpdevice;
         int ncurrent = 0;
         int reportlunsize = sizeof(*physdev_list) + HPSA_MAX_PHYS_LUN * 8;
-        int i, nmsa2xxx_enclosures, ndevs_to_allocate;
-        int bus, target, lun;
+        int i, n_ext_target_devs, ndevs_to_allocate;
         int raid_ctlr_position;
-        DECLARE_BITMAP(lunzerobits, HPSA_MAX_TARGETS_PER_CTLR);
+        DECLARE_BITMAP(lunzerobits, MAX_EXT_TARGETS);
 
         currentsd = kzalloc(sizeof(*currentsd) * HPSA_MAX_DEVICES, GFP_KERNEL);
         physdev_list = kzalloc(reportlunsize, GFP_KERNEL);
@@ -1883,11 +1867,11 @@ static void hpsa_update_scsi_devices(struct ctlr_info *h, int hostno)
                         logdev_list, &nlogicals))
                 goto out;
 
-        /* We might see up to 32 MSA2xxx enclosures, actually 8 of them
-         * but each of them 4 times through different paths.  The plus 1
-         * is for the RAID controller.
+        /* We might see up to the maximum number of logical and physical disks
+         * plus external target devices, and a device for the local RAID
+         * controller.
          */
-        ndevs_to_allocate = nphysicals + nlogicals + MAX_MSA2XXX_ENCLOSURES + 1;
+        ndevs_to_allocate = nphysicals + nlogicals + MAX_EXT_TARGETS + 1;
 
         /* Allocate the per device structures */
         for (i = 0; i < ndevs_to_allocate; i++) {
@@ -1913,7 +1897,7 @@ static void hpsa_update_scsi_devices(struct ctlr_info *h, int hostno)
                 raid_ctlr_position = nphysicals + nlogicals;
 
         /* adjust our table of devices */
-        nmsa2xxx_enclosures = 0;
+        n_ext_target_devs = 0;
         for (i = 0; i < nphysicals + nlogicals + 1; i++) {
                 u8 *lunaddrbytes, is_OBDR = 0;
 
@@ -1929,26 +1913,24 @@ static void hpsa_update_scsi_devices(struct ctlr_info *h, int hostno)
                 if (hpsa_update_device_info(h, lunaddrbytes, tmpdevice,
                                                         &is_OBDR))
                         continue; /* skip it if we can't talk to it. */
-                figure_bus_target_lun(h, lunaddrbytes, &bus, &target, &lun,
-                        tmpdevice);
+                figure_bus_target_lun(h, lunaddrbytes, tmpdevice);
                 this_device = currentsd[ncurrent];
 
                 /*
-                 * For the msa2xxx boxes, we have to insert a LUN 0 which
+                 * For external target devices, we have to insert a LUN 0 which
                  * doesn't show up in CCISS_REPORT_PHYSICAL data, but there
                  * is nonetheless an enclosure device there.  We have to
                  * present that otherwise linux won't find anything if
                  * there is no lun 0.
                  */
-                if (add_msa2xxx_enclosure_device(h, tmpdevice, this_device,
-                                lunaddrbytes, bus, target, lun, lunzerobits,
-                                &nmsa2xxx_enclosures)) {
+                if (add_ext_target_dev(h, tmpdevice, this_device,
+                                lunaddrbytes, lunzerobits,
+                                &n_ext_target_devs)) {
                         ncurrent++;
                         this_device = currentsd[ncurrent];
                 }
 
                 *this_device = *tmpdevice;
-                hpsa_set_bus_target_lun(this_device, bus, target, lun);
 
                 switch (this_device->devtype) {
                 case TYPE_ROM:
@@ -2228,13 +2210,42 @@ static void hpsa_unregister_scsi(struct ctlr_info *h)
 
 static int hpsa_register_scsi(struct ctlr_info *h)
 {
-        int rc;
+        struct Scsi_Host *sh;
+        int error;
 
-        rc = hpsa_scsi_detect(h);
-        if (rc != 0)
-                dev_err(&h->pdev->dev, "hpsa_register_scsi: failed"
-                        " hpsa_scsi_detect(), rc is %d\n", rc);
-        return rc;
+        sh = scsi_host_alloc(&hpsa_driver_template, sizeof(h));
+        if (sh == NULL)
+                goto fail;
+
+        sh->io_port = 0;
+        sh->n_io_port = 0;
+        sh->this_id = -1;
+        sh->max_channel = 3;
+        sh->max_cmd_len = MAX_COMMAND_SIZE;
+        sh->max_lun = HPSA_MAX_LUN;
+        sh->max_id = HPSA_MAX_LUN;
+        sh->can_queue = h->nr_cmds;
+        sh->cmd_per_lun = h->nr_cmds;
+        sh->sg_tablesize = h->maxsgentries;
+        h->scsi_host = sh;
+        sh->hostdata[0] = (unsigned long) h;
+        sh->irq = h->intr[h->intr_mode];
+        sh->unique_id = sh->irq;
+        error = scsi_add_host(sh, &h->pdev->dev);
+        if (error)
+                goto fail_host_put;
+        scsi_scan_host(sh);
+        return 0;
+
+ fail_host_put:
+        dev_err(&h->pdev->dev, "%s: scsi_add_host"
+                " failed for controller %d\n", __func__, h->ctlr);
+        scsi_host_put(sh);
+        return error;
+ fail:
+        dev_err(&h->pdev->dev, "%s: scsi_host_alloc"
+                " failed for controller %d\n", __func__, h->ctlr);
+        return -ENOMEM;
 }
 
 static int wait_for_device_to_become_ready(struct ctlr_info *h,
@@ -2700,16 +2711,16 @@ static int hpsa_big_passthru_ioctl(struct ctlr_info *h, void __user *argp)
                 status = -EINVAL;
                 goto cleanup1;
         }
-        if (ioc->buf_size > ioc->malloc_size * MAXSGENTRIES) {
+        if (ioc->buf_size > ioc->malloc_size * SG_ENTRIES_IN_CMD) {
                 status = -EINVAL;
                 goto cleanup1;
         }
-        buff = kzalloc(MAXSGENTRIES * sizeof(char *), GFP_KERNEL);
+        buff = kzalloc(SG_ENTRIES_IN_CMD * sizeof(char *), GFP_KERNEL);
         if (!buff) {
                 status = -ENOMEM;
                 goto cleanup1;
         }
-        buff_size = kmalloc(MAXSGENTRIES * sizeof(int), GFP_KERNEL);
+        buff_size = kmalloc(SG_ENTRIES_IN_CMD * sizeof(int), GFP_KERNEL);
         if (!buff_size) {
                 status = -ENOMEM;
                 goto cleanup1;
@@ -3354,7 +3365,7 @@ static int hpsa_controller_hard_reset(struct pci_dev *pdev,
 static __devinit void init_driver_version(char *driver_version, int len)
 {
         memset(driver_version, 0, len);
-        strncpy(driver_version, "hpsa " HPSA_DRIVER_VERSION, len - 1);
+        strncpy(driver_version, HPSA " " HPSA_DRIVER_VERSION, len - 1);
 }
 
 static __devinit int write_driver_ver_to_cfgtable(
@@ -3935,7 +3946,7 @@ static int __devinit hpsa_pci_init(struct ctlr_info *h)
                 return err;
         }
 
-        err = pci_request_regions(h->pdev, "hpsa");
+        err = pci_request_regions(h->pdev, HPSA);
         if (err) {
                 dev_err(&h->pdev->dev,
                         "cannot obtain PCI resources, aborting\n");
@@ -4253,7 +4264,7 @@ static void start_controller_lockup_detector(struct ctlr_info *h)
                 spin_lock_init(&lockup_detector_lock);
                 hpsa_lockup_detector =
                         kthread_run(detect_controller_lockup_thread,
-                                                NULL, "hpsa");
+                                                NULL, HPSA);
         }
         if (!hpsa_lockup_detector) {
                 dev_warn(&h->pdev->dev,
@@ -4325,7 +4336,7 @@ reinit_after_soft_reset:
         if (rc != 0)
                 goto clean1;
 
-        sprintf(h->devname, "hpsa%d", number_of_controllers);
+        sprintf(h->devname, HPSA "%d", number_of_controllers);
         h->ctlr = number_of_controllers;
         number_of_controllers++;
 
@@ -4482,6 +4493,14 @@ static void hpsa_shutdown(struct pci_dev *pdev)
 #endif                          /* CONFIG_PCI_MSI */
 }
 
+static void __devexit hpsa_free_device_info(struct ctlr_info *h)
+{
+        int i;
+
+        for (i = 0; i < h->ndevices; i++)
+                kfree(h->dev[i]);
+}
+
 static void __devexit hpsa_remove_one(struct pci_dev *pdev)
 {
         struct ctlr_info *h;
@@ -4497,6 +4516,7 @@ static void __devexit hpsa_remove_one(struct pci_dev *pdev)
         iounmap(h->vaddr);
         iounmap(h->transtable);
         iounmap(h->cfgtable);
+        hpsa_free_device_info(h);
         hpsa_free_sg_chain_blocks(h);
         pci_free_consistent(h->pdev,
                 h->nr_cmds * sizeof(struct CommandList),
@@ -4530,7 +4550,7 @@ static int hpsa_resume(__attribute__((unused)) struct pci_dev *pdev)
 }
 
 static struct pci_driver hpsa_pci_driver = {
-        .name = "hpsa",
+        .name = HPSA,
         .probe = hpsa_init_one,
         .remove = __devexit_p(hpsa_remove_one),
         .id_table = hpsa_pci_device_id, /* id_table */
@@ -4592,15 +4612,15 @@ static __devinit void hpsa_enter_performant_mode(struct ctlr_info *h,
          * Each SG entry requires 16 bytes.  The eight registers are programmed
          * with the number of 16-byte blocks a command of that size requires.
          * The smallest command possible requires 5 such 16 byte blocks.
-         * the largest command possible requires MAXSGENTRIES + 4 16-byte
+         * the largest command possible requires SG_ENTRIES_IN_CMD + 4 16-byte
          * blocks.  Note, this only extends to the SG entries contained
          * within the command block, and does not extend to chained blocks
          * of SG elements.   bft[] contains the eight values we write to
          * the registers.  They are not evenly distributed, but have more
          * sizes for small commands, and fewer sizes for larger commands.
          */
-        int bft[8] = {5, 6, 8, 10, 12, 20, 28, MAXSGENTRIES + 4};
-        BUILD_BUG_ON(28 > MAXSGENTRIES + 4);
+        int bft[8] = {5, 6, 8, 10, 12, 20, 28, SG_ENTRIES_IN_CMD + 4};
+        BUILD_BUG_ON(28 > SG_ENTRIES_IN_CMD + 4);
         /*  5 = 1 s/g entry or 4k
          *  6 = 2 s/g entry or 8k
          *  8 = 4 s/g entry or 16k
@@ -4613,8 +4633,9 @@ static __devinit void hpsa_enter_performant_mode(struct ctlr_info *h,
         memset(h->reply_pool, 0, h->reply_pool_size);
         h->reply_pool_head = h->reply_pool;
 
-        bft[7] = h->max_sg_entries + 4;
-        calc_bucket_map(bft, ARRAY_SIZE(bft), 32, h->blockFetchTable);
+        bft[7] = SG_ENTRIES_IN_CMD + 4;
+        calc_bucket_map(bft, ARRAY_SIZE(bft),
+                                SG_ENTRIES_IN_CMD, h->blockFetchTable);
         for (i = 0; i < 8; i++)
                 writel(bft[i], &h->transtable->BlockFetch[i]);
 
@@ -4652,14 +4673,13 @@ static __devinit void hpsa_put_ctlr_into_performant_mode(struct ctlr_info *h)
                 return;
 
         hpsa_get_max_perf_mode_cmds(h);
-        h->max_sg_entries = 32;
         /* Performant mode ring buffer and supporting data structures */
         h->reply_pool_size = h->max_commands * sizeof(u64);
         h->reply_pool = pci_alloc_consistent(h->pdev, h->reply_pool_size,
                                 &(h->reply_pool_dhandle));
 
         /* Need a block fetch table for performant mode */
-        h->blockFetchTable = kmalloc(((h->max_sg_entries+1) *
+        h->blockFetchTable = kmalloc(((SG_ENTRIES_IN_CMD + 1) *
                                 sizeof(u32)), GFP_KERNEL);
 
         if ((h->reply_pool == NULL)