/* need to have host registered before triggering any interrupt */
        list_add_tail(&HOSTDATA(shpnt)->host_list, &aha152x_host_list);
 
+       shpnt->no_highmem = true;
        shpnt->io_port   = setup->io_port;
        shpnt->n_io_port = IO_RANGE;
        shpnt->irq       = setup->irq;
        return 0;
 }
 
-static int aha152x_adjust_queue(struct scsi_device *device)
-{
-       blk_queue_bounce_limit(device->request_queue, BLK_BOUNCE_HIGH);
-       return 0;
-}
-
 static const struct scsi_host_template aha152x_driver_template = {
        .module                         = THIS_MODULE,
        .name                           = AHA152X_REVID,
        .this_id                        = 7,
        .sg_tablesize                   = SG_ALL,
        .dma_boundary                   = PAGE_SIZE - 1,
-       .slave_alloc                    = aha152x_adjust_queue,
        .cmd_size                       = sizeof(struct aha152x_cmd_priv),
 };
 
 
        return -ENODEV;
 }
 
-/*
- * imm cannot deal with highmem, so this causes all IO pages for this host
- * to reside in low memory (hence mapped)
- */
-static int imm_adjust_queue(struct scsi_device *device)
-{
-       blk_queue_bounce_limit(device->request_queue, BLK_BOUNCE_HIGH);
-       return 0;
-}
-
 static const struct scsi_host_template imm_template = {
        .module                 = THIS_MODULE,
        .proc_name              = "imm",
        .this_id                = 7,
        .sg_tablesize           = SG_ALL,
        .can_queue              = 1,
-       .slave_alloc            = imm_adjust_queue,
        .cmd_size               = sizeof(struct scsi_pointer),
 };
 
        host = scsi_host_alloc(&imm_template, sizeof(imm_struct *));
        if (!host)
                goto out1;
+       host->no_highmem = true;
        host->io_port = pb->base;
        host->n_io_port = ports;
        host->dma_channel = -1;
 
        return -ENODEV;
 }
 
-static int ppa_adjust_queue(struct scsi_device *device)
-{
-       blk_queue_bounce_limit(device->request_queue, BLK_BOUNCE_HIGH);
-       return 0;
-}
-
 static const struct scsi_host_template ppa_template = {
        .module                 = THIS_MODULE,
        .proc_name              = "ppa",
        .this_id                = -1,
        .sg_tablesize           = SG_ALL,
        .can_queue              = 1,
-       .slave_alloc            = ppa_adjust_queue,
        .cmd_size               = sizeof(struct scsi_pointer),
 };
 
        host = scsi_host_alloc(&ppa_template, sizeof(ppa_struct *));
        if (!host)
                goto out1;
+       host->no_highmem = true;
        host->io_port = pb->base;
        host->n_io_port = ports;
        host->dma_channel = -1;
 
         */
        lim->dma_alignment = max(4, dma_get_cache_alignment()) - 1;
 
+       if (shost->no_highmem)
+               lim->bounce = BLK_BOUNCE_HIGH;
+
        dma_set_seg_boundary(dev, shost->dma_boundary);
        dma_set_max_seg_size(dev, shost->max_segment_size);
 }
 
 #include <scsi/scsi_eh.h>
 
 #include "usb.h"
-#include <linux/usb/hcd.h>
 #include "scsiglue.h"
 #include "debug.h"
 #include "transport.h"
                min_t(size_t, queue_max_hw_sectors(sdev->request_queue),
                      dma_max_mapping_size(dev) >> SECTOR_SHIFT));
 
-       /*
-        * Some USB host controllers can't do DMA; they have to use PIO.
-        * For such controllers we need to make sure the block layer sets
-        * up bounce buffers in addressable memory.
-        */
-       if (!hcd_uses_dma(bus_to_hcd(us->pusb_dev->bus)) ||
-                       (bus_to_hcd(us->pusb_dev->bus)->localmem_pool != NULL))
-               blk_queue_bounce_limit(sdev->request_queue, BLK_BOUNCE_HIGH);
-
        /*
         * We can't put these settings in slave_alloc() because that gets
         * called before the device type is known.  Consequently these
 
 #include <scsi/scsi_device.h>
 
 #include "usb.h"
+#include <linux/usb/hcd.h>
 #include "scsiglue.h"
 #include "transport.h"
 #include "protocol.h"
        if (result)
                goto BadDevice;
 
+       /*
+        * Some USB host controllers can't do DMA; they have to use PIO.
+        * For such controllers we need to make sure the block layer sets
+        * up bounce buffers in addressable memory.
+        */
+       if (!hcd_uses_dma(bus_to_hcd(us->pusb_dev->bus)) ||
+           bus_to_hcd(us->pusb_dev->bus)->localmem_pool)
+               host->no_highmem = true;
+
        /* Get the unusual_devs entries and the descriptors */
        result = get_device_info(us, id, unusual_dev);
        if (result)
 
        /* The transport requires the LUN bits NOT to be stored in CDB[1] */
        unsigned no_scsi2_lun_in_cdb:1;
 
+       unsigned no_highmem:1;
+
        /*
         * Optional work queue to be utilized by the transport
         */