unchecked_isa_dma - 1=>only use bottom 16 MB of ram (ISA DMA addressing
                    restriction), 0=>can use full 32 bit (or better) DMA
                    address space
-    use_clustering - 1=>SCSI commands in mid level's queue can be merged,
-                     0=>disallow SCSI command merging
     no_async_abort - 1=>Asynchronous aborts are not supported
                      0=>Timed-out commands will be aborted asynchronously
     hostt        - pointer to driver's struct scsi_host_template from which
 
        .sg_tablesize           = SG_ALL,
        .max_sectors            = 1024,
        .cmd_per_lun            = SIMSCSI_REQ_QUEUE_LEN,
-       .use_clustering         = DISABLE_CLUSTERING,
+       .dma_boundary           = PAGE_SIZE - 1,
 };
 
 static int __init
 
        .this_id                = 7,
        .sg_tablesize           = SG_ALL,
        .cmd_per_lun            = CMD_PER_LUN,
-       .use_clustering         = DISABLE_CLUSTERING
+       .dma_boundary           = PAGE_SIZE - 1,
 };
 
 static int a2091_probe(struct zorro_dev *z, const struct zorro_device_id *ent)
 
                   shost->sg_tablesize, shost->cmd_per_lun);
 
        seq_printf(m,
-                  " unchecked_isa_dma %d, use_clustering %d\n",
-                  shost->unchecked_isa_dma, shost->use_clustering);
+                  " unchecked_isa_dma %d\n",
+                  shost->unchecked_isa_dma);
 
        seq_printf(m,
                   " flags 0x%x, last_reset 0x%lx, jiffies 0x%lx, asc_n_io_port 0x%x\n",
 
        .can_queue                      = 1,
        .this_id                        = 7,
        .sg_tablesize                   = SG_ALL,
-       .use_clustering                 = DISABLE_CLUSTERING,
+       .dma_boundary                   = PAGE_SIZE - 1,
        .slave_alloc                    = aha152x_adjust_queue,
 };
 
 
        .this_id                = 7,
        .sg_tablesize           = SG_ALL,
        .cmd_per_lun            = 2,
-       .use_clustering         = DISABLE_CLUSTERING,
+       .dma_boundary           = PAGE_SIZE - 1,
        .proc_name              = "acornscsi",
 };
 
 
        .can_queue                      = 0,
        .this_id                        = 7,
        .sg_tablesize                   = SG_ALL,
-       .use_clustering                 = DISABLE_CLUSTERING,
+       .dma_boundary                   = PAGE_SIZE - 1,
        .proc_name                      = "arxescsi",
 };
 
 
        .this_id                = 7,
        .sg_tablesize           = SG_ALL,
        .cmd_per_lun            = 2,
-       .use_clustering         = DISABLE_CLUSTERING,
        .proc_name              = "CumanaSCSI-1",
        .cmd_size               = NCR5380_CMD_SIZE,
        .max_sectors            = 128,
+       .dma_boundary           = PAGE_SIZE - 1,
 };
 
 static int cumanascsi1_probe(struct expansion_card *ec,
 
        .this_id                = 7,
        .sg_tablesize           = SG_ALL,
        .cmd_per_lun            = 2,
-       .use_clustering         = DISABLE_CLUSTERING,
+       .dma_boundary           = PAGE_SIZE - 1,
        .proc_name              = "oakscsi",
        .cmd_size               = NCR5380_CMD_SIZE,
        .max_sectors            = 128,
 
        .eh_host_reset_handler  = atari_scsi_host_reset,
        .this_id                = 7,
        .cmd_per_lun            = 2,
-       .use_clustering         = DISABLE_CLUSTERING,
+       .dma_boundary           = PAGE_SIZE - 1,
        .cmd_size               = NCR5380_CMD_SIZE,
 };
 
 
        .eh_device_reset_handler = iscsi_eh_device_reset,
        .eh_target_reset_handler = iscsi_eh_recover_target,
        .target_alloc   = iscsi_target_alloc,
-       .use_clustering = DISABLE_CLUSTERING,
+       .dma_boundary   = PAGE_SIZE - 1,
        .this_id        = -1,
        .track_queue_depth = 1,
 };
 
        .eh_device_reset_handler = iscsi_eh_device_reset,
        .eh_target_reset_handler = iscsi_eh_recover_target,
        .target_alloc   = iscsi_target_alloc,
-       .use_clustering = DISABLE_CLUSTERING,
+       .dma_boundary   = PAGE_SIZE - 1,
        .this_id        = -1,
        .track_queue_depth = 1,
 };
 
        .cmd_per_lun            = DC395x_MAX_CMD_PER_LUN,
        .eh_abort_handler       = dc395x_eh_abort,
        .eh_bus_reset_handler   = dc395x_eh_bus_reset,
-       .use_clustering         = DISABLE_CLUSTERING,
+       .dma_boundary           = PAGE_SIZE - 1,
 };
 
 
 
        .this_id                = 7,
        .sg_tablesize           = SG_ALL,
        .cmd_per_lun            = 2,
-       .use_clustering         = DISABLE_CLUSTERING,
+       .dma_boundary           = PAGE_SIZE - 1,
        .cmd_size               = NCR5380_CMD_SIZE,
 };
 
 
        .this_id                = 7,
        .sg_tablesize           = SG_ALL,
        .cmd_per_lun            = 2,
-       .use_clustering         = DISABLE_CLUSTERING,
+       .dma_boundary           = PAGE_SIZE - 1,
        .cmd_size               = NCR5380_CMD_SIZE,
        .max_sectors            = 128,
 };
 
        .this_id                = 7,
        .sg_tablesize           = SG_ALL,
        .cmd_per_lun            = CMD_PER_LUN,
-       .use_clustering         = DISABLE_CLUSTERING
+       .dma_boundary           = PAGE_SIZE - 1,
 };
 
 static int check_wd33c93(struct gvp11_scsiregs *regs)
 
        shost->sg_prot_tablesize = sht->sg_prot_tablesize;
        shost->cmd_per_lun = sht->cmd_per_lun;
        shost->unchecked_isa_dma = sht->unchecked_isa_dma;
-       shost->use_clustering = sht->use_clustering;
        shost->no_write_same = sht->no_write_same;
 
        if (shost_eh_deadline == -1 || !sht->eh_host_reset_handler)
 
        sh->sg_tablesize = sh->hostt->sg_tablesize;
        sh->can_queue = sh->hostt->can_queue;
        sh->cmd_per_lun = sh->hostt->cmd_per_lun;
-       sh->use_clustering = sh->hostt->use_clustering;
        sh->max_sectors = 128;
 
        sh->max_id = ha->ntargets;
 
        .eh_abort_handler       = iscsi_eh_abort,
        .eh_device_reset_handler= iscsi_eh_device_reset,
        .eh_target_reset_handler = iscsi_eh_recover_target,
-       .use_clustering         = DISABLE_CLUSTERING,
+       .dma_boundary           = PAGE_SIZE - 1,
        .slave_alloc            = iscsi_sw_tcp_slave_alloc,
        .slave_configure        = iscsi_sw_tcp_slave_configure,
        .target_alloc           = iscsi_target_alloc,
 
                goto fail;
 
        host->max_id = 8;
-       host->use_clustering = DISABLE_CLUSTERING;
+       host->dma_boundary = PAGE_SIZE - 1;
        esp = shost_priv(host);
 
        esp->host = host;
 
        .this_id                = 7,
        .sg_tablesize           = 1,
        .cmd_per_lun            = 2,
-       .use_clustering         = DISABLE_CLUSTERING,
+       .dma_boundary           = PAGE_SIZE - 1,
        .cmd_size               = NCR5380_CMD_SIZE,
        .max_sectors            = 128,
 };
 
        .eh_timed_out = mvumi_timed_out,
        .eh_host_reset_handler = mvumi_host_reset,
        .bios_param = mvumi_bios_param,
-       .use_clustering = DISABLE_CLUSTERING,
+       .dma_boundary = PAGE_SIZE - 1,
        .this_id = -1,
 };
 
 
        .shost_attrs            = myrb_shost_attrs,
        .sdev_attrs             = myrb_sdev_attrs,
        .this_id                = -1,
-       .use_clustering         = DISABLE_CLUSTERING,
+       .dma_boundary           = PAGE_SIZE - 1,
 };
 
 /**
 
        .shost_attrs            = myrs_shost_attrs,
        .sdev_attrs             = myrs_sdev_attrs,
        .this_id                = -1,
-       .use_clustering         = DISABLE_CLUSTERING,
+       .dma_boundary           = PAGE_SIZE - 1,
 };
 
 static struct myrs_hba *myrs_alloc_host(struct pci_dev *pdev,
 
        .sg_tablesize                   = NSP32_SG_SIZE,
        .max_sectors                    = 128,
        .this_id                        = NSP32_HOST_SCSIID,
-       .use_clustering                 = DISABLE_CLUSTERING,
+       .dma_boundary                   = PAGE_SIZE - 1,
        .eh_abort_handler               = nsp32_eh_abort,
        .eh_host_reset_handler          = nsp32_eh_host_reset,
 /*     .highmem_io                     = 1, */
 
        .can_queue               = 1,
        .this_id                 = NSP_INITIATOR_ID,
        .sg_tablesize            = SG_ALL,
-       .use_clustering          = DISABLE_CLUSTERING,
+       .dma_boundary            = PAGE_SIZE - 1,
 };
 
 static nsp_hw_data nsp_data_base; /* attach <-> detect glue */
 
        .can_queue              = 1,
        .this_id                = -1,
        .sg_tablesize           = SG_ALL,
-       .use_clustering         = DISABLE_CLUSTERING,
+       .dma_boundary           = PAGE_SIZE - 1,
 };
 
 /*====================================================================*/
 
        .can_queue              = 1,
        .this_id                = -1,
        .sg_tablesize           = SG_ALL,
-       .use_clustering         = DISABLE_CLUSTERING,
+       .dma_boundary           = PAGE_SIZE - 1,
 };
 
 static __init int qlogicfas_init(void)
 
 
        sdebug_driver_template.can_queue = sdebug_max_queue;
        if (!sdebug_clustering)
-               sdebug_driver_template.use_clustering = DISABLE_CLUSTERING;
+               sdebug_driver_template.dma_boundary = PAGE_SIZE - 1;
+
        hpnt = scsi_host_alloc(&sdebug_driver_template, sizeof(sdbg_host));
        if (NULL == hpnt) {
                pr_err("scsi_host_alloc failed\n");
 
        blk_queue_max_segment_size(q,
                min(shost->max_segment_size, dma_get_max_seg_size(dev)));
 
-       if (shost->use_clustering == DISABLE_CLUSTERING)
-               q->limits.cluster = 0;
-
        /*
         * Set a reasonable default alignment:  The larger of 32-byte (dword),
         * which is a common minimum for HBAs, and the minimum DMA alignment,
 
        .this_id                = 7,
        .sg_tablesize           = SG_ALL,
        .cmd_per_lun            = 8,
-       .use_clustering         = DISABLE_CLUSTERING,
+       .dma_boundary           = PAGE_SIZE - 1,
 };
 
 static int sgiwd93_probe(struct platform_device *pdev)
 
        .eh_abort_handler               = stex_abort,
        .eh_host_reset_handler          = stex_reset,
        .this_id                        = -1,
-       .use_clustering                 = DISABLE_CLUSTERING,
+       .dma_boundary                   = PAGE_SIZE - 1,
 };
 
 static struct pci_device_id stex_pci_tbl[] = {
 
        .this_id                = 7,
        .sg_tablesize           = SG_NONE,
        .cmd_per_lun            = 2,
-       .use_clustering         = DISABLE_CLUSTERING,
+       .dma_boundary           = PAGE_SIZE - 1,
        .cmd_size               = NCR5380_CMD_SIZE,
 };
 
 
        .max_host_blocked       = 1,
        .track_queue_depth      = 1,
        .sdev_groups            = ufshcd_driver_groups,
-       .use_clustering         = DISABLE_CLUSTERING,
+       .dma_boundary           = PAGE_SIZE - 1,
 };
 
 static int ufshcd_config_vreg_load(struct device *dev, struct ufs_vreg *vreg,
 
        .sg_tablesize           = 256,
        .cmd_per_lun            = 1024,
        .max_sectors            = 0xFFFF,
-       .use_clustering         = DISABLE_CLUSTERING,
+       .dma_boundary           = PAGE_SIZE - 1,
        .slave_alloc            = tcm_loop_slave_alloc,
        .module                 = THIS_MODULE,
        .track_queue_depth      = 1,
 
        .this_id = -1,
        .sg_tablesize = SG_NONE,
        .skip_settle_delay = 1,
-       .use_clustering = DISABLE_CLUSTERING,
+       .dma_boundary = PAGE_SIZE - 1,
 };
 
 #define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
 
 #define MODE_INITIATOR 0x01
 #define MODE_TARGET 0x02
 
-#define DISABLE_CLUSTERING (-1)
-
 struct scsi_host_template {
        struct module *module;
        const char *name;
         */
        unsigned unchecked_isa_dma:1;
 
-       /*
-        * True if this host adapter can make good use of clustering.
-        * I originally thought that if the tablesize was large that it
-        * was a waste of CPU cycles to prepare a cluster list, but
-        * it works out that the Buslogic is faster if you use a smaller
-        * number of segments (i.e. use clustering).  I guess it is
-        * inefficient.
-        */
-       unsigned use_clustering:1;
-
        /*
         * True for emulated SCSI host adapters (e.g. ATAPI).
         */
        
        unsigned active_mode:2;
        unsigned unchecked_isa_dma:1;
-       unsigned use_clustering:1;
 
        /*
         * Host has requested that no further requests come through for the