Merge branch 'for-2.6.34' of git://git.kernel.dk/linux-2.6-block

* 'for-2.6.34' of git://git.kernel.dk/linux-2.6-block: (38 commits)
  block: don't access jiffies when initialising io_context
  cfq: remove 8 bytes of padding from cfq_rb_root on 64 bit builds
  block: fix for "Consolidate phys_segment and hw_segment limits"
  cfq-iosched: quantum check tweak
  blktrace: perform cleanup after setup error
  blkdev: fix merge_bvec_fn return value checks
  cfq-iosched: requests "in flight" vs "in driver" clarification
  cciss: Fix problem with scatter gather elements in the scsi half of the driver
  cciss: eliminate unnecessary pointer use in cciss scsi code
  cciss: do not use void pointer for scsi hba data
  cciss: factor out scatter gather chain block mapping code
  cciss: fix scatter gather chain block dma direction kludge
  cciss: simplify scatter gather code
  cciss: factor out scatter gather chain block allocation and freeing
  cciss: detect bad alignment of scsi commands at build time
  cciss: clarify command list padding calculation
  cfq-iosched: rethink seeky detection for SSDs
  cfq-iosched: rework seeky detection
  block: remove padding from io_context on 64bit builds
  block: Consolidate phys_segment and hw_segment limits
  ...

54 files changed, 348 insertions, 503 deletions

diff --git a/drivers/ata/libata-scsi.c b/drivers/ata/libata-scsi.c
index d096fbcbc771..bea003a24d27 100644
--- a/drivers/ata/libata-scsi.c
+++ b/drivers/ata/libata-scsi.c
@@ -1097,7 +1097,7 @@ static int ata_scsi_dev_config(struct scsi_device *sdev,
                 dev->flags |= ATA_DFLAG_NO_UNLOAD;
 
         /* configure max sectors */
-        blk_queue_max_sectors(sdev->request_queue, dev->max_sectors);
+        blk_queue_max_hw_sectors(sdev->request_queue, dev->max_sectors);
 
         if (dev->class == ATA_DEV_ATAPI) {
                 struct request_queue *q = sdev->request_queue;
diff --git a/drivers/ata/sata_nv.c b/drivers/ata/sata_nv.c
index 0c82d335c55d..684fe04dbbb7 100644
--- a/drivers/ata/sata_nv.c
+++ b/drivers/ata/sata_nv.c
@@ -772,7 +772,7 @@ static int nv_adma_slave_config(struct scsi_device *sdev)
         }
 
         blk_queue_segment_boundary(sdev->request_queue, segment_boundary);
-        blk_queue_max_hw_segments(sdev->request_queue, sg_tablesize);
+        blk_queue_max_segments(sdev->request_queue, sg_tablesize);
         ata_port_printk(ap, KERN_INFO,
                 "DMA mask 0x%llX, segment boundary 0x%lX, hw segs %hu\n",
                 (unsigned long long)*ap->host->dev->dma_mask,
diff --git a/drivers/block/DAC960.c b/drivers/block/DAC960.c
index ce1fa923c414..459f1bc25a7b 100644
--- a/drivers/block/DAC960.c
+++ b/drivers/block/DAC960.c
@@ -2534,8 +2534,8 @@ static bool DAC960_RegisterBlockDevice(DAC960_Controller_T *Controller)
         blk_queue_bounce_limit(RequestQueue, Controller->BounceBufferLimit);
         RequestQueue->queuedata = Controller;
         blk_queue_max_hw_segments(RequestQueue, Controller->DriverScatterGatherLimit);
-        blk_queue_max_phys_segments(RequestQueue, Controller->DriverScatterGatherLimit);
-        blk_queue_max_sectors(RequestQueue, Controller->MaxBlocksPerCommand);
+        blk_queue_max_segments(RequestQueue, Controller->DriverScatterGatherLimit);
+        blk_queue_max_hw_sectors(RequestQueue, Controller->MaxBlocksPerCommand);
         disk->queue = RequestQueue;
         sprintf(disk->disk_name, "rd/c%dd%d", Controller->ControllerNumber, n);
         disk->major = MajorNumber;
@@ -7134,7 +7134,7 @@ static struct DAC960_privdata DAC960_P_privdata = {
         .MemoryWindowSize =     DAC960_PD_RegisterWindowSize,
 };
 
-static struct pci_device_id DAC960_id_table[] = {
+static const struct pci_device_id DAC960_id_table[] = {
         {
                 .vendor         = PCI_VENDOR_ID_MYLEX,
                 .device         = PCI_DEVICE_ID_MYLEX_DAC960_GEM,
diff --git a/drivers/block/brd.c b/drivers/block/brd.c
index 4f688434daf1..c6ddeacb77fd 100644
--- a/drivers/block/brd.c
+++ b/drivers/block/brd.c
@@ -434,7 +434,7 @@ static struct brd_device *brd_alloc(int i)
                 goto out_free_dev;
         blk_queue_make_request(brd->brd_queue, brd_make_request);
         blk_queue_ordered(brd->brd_queue, QUEUE_ORDERED_TAG, NULL);
-        blk_queue_max_sectors(brd->brd_queue, 1024);
+        blk_queue_max_hw_sectors(brd->brd_queue, 1024);
         blk_queue_bounce_limit(brd->brd_queue, BLK_BOUNCE_ANY);
 
         disk = brd->brd_disk = alloc_disk(1 << part_shift);
diff --git a/drivers/block/cciss.c b/drivers/block/cciss.c
index 9291614ac6b7..9e3af307aae1 100644
--- a/drivers/block/cciss.c
+++ b/drivers/block/cciss.c
@@ -257,6 +257,79 @@ static inline void removeQ(CommandList_struct *c)
         hlist_del_init(&c->list);
 }
 
+static void cciss_free_sg_chain_blocks(SGDescriptor_struct **cmd_sg_list,
+        int nr_cmds)
+{
+        int i;
+
+        if (!cmd_sg_list)
+                return;
+        for (i = 0; i < nr_cmds; i++) {
+                kfree(cmd_sg_list[i]);
+                cmd_sg_list[i] = NULL;
+        }
+        kfree(cmd_sg_list);
+}
+
+static SGDescriptor_struct **cciss_allocate_sg_chain_blocks(
+        ctlr_info_t *h, int chainsize, int nr_cmds)
+{
+        int j;
+        SGDescriptor_struct **cmd_sg_list;
+
+        if (chainsize <= 0)
+                return NULL;
+
+        cmd_sg_list = kmalloc(sizeof(*cmd_sg_list) * nr_cmds, GFP_KERNEL);
+        if (!cmd_sg_list)
+                return NULL;
+
+        /* Build up chain blocks for each command */
+        for (j = 0; j < nr_cmds; j++) {
+                /* Need a block of chainsized s/g elements. */
+                cmd_sg_list[j] = kmalloc((chainsize *
+                        sizeof(*cmd_sg_list[j])), GFP_KERNEL);
+                if (!cmd_sg_list[j]) {
+                        dev_err(&h->pdev->dev, "Cannot get memory "
+                                "for s/g chains.\n");
+                        goto clean;
+                }
+        }
+        return cmd_sg_list;
+clean:
+        cciss_free_sg_chain_blocks(cmd_sg_list, nr_cmds);
+        return NULL;
+}
+
+static void cciss_unmap_sg_chain_block(ctlr_info_t *h, CommandList_struct *c)
+{
+        SGDescriptor_struct *chain_sg;
+        u64bit temp64;
+
+        if (c->Header.SGTotal <= h->max_cmd_sgentries)
+                return;
+
+        chain_sg = &c->SG[h->max_cmd_sgentries - 1];
+        temp64.val32.lower = chain_sg->Addr.lower;
+        temp64.val32.upper = chain_sg->Addr.upper;
+        pci_unmap_single(h->pdev, temp64.val, chain_sg->Len, PCI_DMA_TODEVICE);
+}
+
+static void cciss_map_sg_chain_block(ctlr_info_t *h, CommandList_struct *c,
+        SGDescriptor_struct *chain_block, int len)
+{
+        SGDescriptor_struct *chain_sg;
+        u64bit temp64;
+
+        chain_sg = &c->SG[h->max_cmd_sgentries - 1];
+        chain_sg->Ext = CCISS_SG_CHAIN;
+        chain_sg->Len = len;
+        temp64.val = pci_map_single(h->pdev, chain_block, len,
+                                PCI_DMA_TODEVICE);
+        chain_sg->Addr.lower = temp64.val32.lower;
+        chain_sg->Addr.upper = temp64.val32.upper;
+}
+
 #include "cciss_scsi.c"         /* For SCSI tape support */
 
 static const char *raid_label[] = { "0", "4", "1(1+0)", "5", "5+1", "ADG",
@@ -1344,26 +1417,27 @@ static int cciss_ioctl(struct block_device *bdev, fmode_t mode,
                                 kfree(buff);
                                 return -ENOMEM;
                         }
-                        // Fill in the command type
+                        /* Fill in the command type */
                         c->cmd_type = CMD_IOCTL_PEND;
-                        // Fill in Command Header
-                        c->Header.ReplyQueue = 0;       // unused in simple mode
-                        if (iocommand.buf_size > 0)     // buffer to fill
+                        /* Fill in Command Header */
+                        c->Header.ReplyQueue = 0;   /* unused in simple mode */
+                        if (iocommand.buf_size > 0) /* buffer to fill */
                         {
                                 c->Header.SGList = 1;
                                 c->Header.SGTotal = 1;
-                        } else  // no buffers to fill
+                        } else /* no buffers to fill */
                         {
                                 c->Header.SGList = 0;
                                 c->Header.SGTotal = 0;
                         }
                         c->Header.LUN = iocommand.LUN_info;
-                        c->Header.Tag.lower = c->busaddr;       // use the kernel address the cmd block for tag
+                        /* use the kernel address the cmd block for tag */
+                        c->Header.Tag.lower = c->busaddr;
 
-                        // Fill in Request block
+                        /* Fill in Request block */
                         c->Request = iocommand.Request;
 
-                        // Fill in the scatter gather information
+                        /* Fill in the scatter gather information */
                         if (iocommand.buf_size > 0) {
                                 temp64.val = pci_map_single(host->pdev, buff,
                                         iocommand.buf_size,
@@ -1371,7 +1445,7 @@ static int cciss_ioctl(struct block_device *bdev, fmode_t mode,
                                 c->SG[0].Addr.lower = temp64.val32.lower;
                                 c->SG[0].Addr.upper = temp64.val32.upper;
                                 c->SG[0].Len = iocommand.buf_size;
-                                c->SG[0].Ext = 0;       // we are not chaining
+                                c->SG[0].Ext = 0;  /* we are not chaining */
                         }
                         c->waiting = &wait;
 
@@ -1670,14 +1744,9 @@ static void cciss_softirq_done(struct request *rq)
         /* unmap the DMA mapping for all the scatter gather elements */
         for (i = 0; i < cmd->Header.SGList; i++) {
                 if (curr_sg[sg_index].Ext == CCISS_SG_CHAIN) {
-                        temp64.val32.lower = cmd->SG[i].Addr.lower;
-                        temp64.val32.upper = cmd->SG[i].Addr.upper;
-                        pci_dma_sync_single_for_cpu(h->pdev, temp64.val,
-                                                cmd->SG[i].Len, ddir);
-                        pci_unmap_single(h->pdev, temp64.val,
-                                                cmd->SG[i].Len, ddir);
+                        cciss_unmap_sg_chain_block(h, cmd);
                         /* Point to the next block */
-                        curr_sg = h->cmd_sg_list[cmd->cmdindex]->sgchain;
+                        curr_sg = h->cmd_sg_list[cmd->cmdindex];
                         sg_index = 0;
                 }
                 temp64.val32.lower = curr_sg[sg_index].Addr.lower;
@@ -1796,12 +1865,9 @@ static int cciss_add_disk(ctlr_info_t *h, struct gendisk *disk,
         blk_queue_bounce_limit(disk->queue, h->pdev->dma_mask);
 
         /* This is a hardware imposed limit. */
-        blk_queue_max_hw_segments(disk->queue, h->maxsgentries);
-
-        /* This is a limit in the driver and could be eliminated. */
-        blk_queue_max_phys_segments(disk->queue, h->maxsgentries);
+        blk_queue_max_segments(disk->queue, h->maxsgentries);
 
-        blk_queue_max_sectors(disk->queue, h->cciss_max_sectors);
+        blk_queue_max_hw_sectors(disk->queue, h->cciss_max_sectors);
 
         blk_queue_softirq_done(disk->queue, cciss_softirq_done);
 
@@ -2425,7 +2491,7 @@ static int fill_cmd(CommandList_struct *c, __u8 cmd, int ctlr, void *buff,
                         c->Request.Type.Direction = XFER_READ;
                         c->Request.Timeout = 0;
                         c->Request.CDB[0] = cmd;
-                        c->Request.CDB[6] = (size >> 24) & 0xFF;        //MSB
+                        c->Request.CDB[6] = (size >> 24) & 0xFF; /* MSB */
                         c->Request.CDB[7] = (size >> 16) & 0xFF;
                         c->Request.CDB[8] = (size >> 8) & 0xFF;
                         c->Request.CDB[9] = size & 0xFF;
@@ -2694,7 +2760,7 @@ static void cciss_geometry_inquiry(int ctlr, int logvol,
                                "cciss: reading geometry failed, volume "
                                "does not support reading geometry\n");
                         drv->heads = 255;
-                        drv->sectors = 32;      // Sectors per track
+                        drv->sectors = 32;      /* Sectors per track */
                         drv->cylinders = total_size + 1;
                         drv->raid_level = RAID_UNKNOWN;
                 } else {
@@ -3082,7 +3148,6 @@ static void do_cciss_request(struct request_queue *q)
         SGDescriptor_struct *curr_sg;
         drive_info_struct *drv;
         int i, dir;
-        int nseg = 0;
         int sg_index = 0;
         int chained = 0;
 
@@ -3112,19 +3177,19 @@ static void do_cciss_request(struct request_queue *q)
 
         /* fill in the request */
         drv = creq->rq_disk->private_data;
-        c->Header.ReplyQueue = 0;       // unused in simple mode
+        c->Header.ReplyQueue = 0;       /* unused in simple mode */
         /* got command from pool, so use the command block index instead */
         /* for direct lookups. */
         /* The first 2 bits are reserved for controller error reporting. */
         c->Header.Tag.lower = (c->cmdindex << 3);
         c->Header.Tag.lower |= 0x04;    /* flag for direct lookup. */
         memcpy(&c->Header.LUN, drv->LunID, sizeof(drv->LunID));
-        c->Request.CDBLen = 10; // 12 byte commands not in FW yet;
-        c->Request.Type.Type = TYPE_CMD;        // It is a command.
+        c->Request.CDBLen = 10; /* 12 byte commands not in FW yet; */
+        c->Request.Type.Type = TYPE_CMD;        /* It is a command. */
         c->Request.Type.Attribute = ATTR_SIMPLE;
         c->Request.Type.Direction =
             (rq_data_dir(creq) == READ) ? XFER_READ : XFER_WRITE;
-        c->Request.Timeout = 0; // Don't time out
+        c->Request.Timeout = 0; /* Don't time out */
         c->Request.CDB[0] =
             (rq_data_dir(creq) == READ) ? h->cciss_read : h->cciss_write;
         start_blk = blk_rq_pos(creq);
@@ -3149,13 +3214,8 @@ static void do_cciss_request(struct request_queue *q)
         for (i = 0; i < seg; i++) {
                 if (((sg_index+1) == (h->max_cmd_sgentries)) &&
                         !chained && ((seg - i) > 1)) {
-                        nseg = seg - i;
-                        curr_sg[sg_index].Len = (nseg) *
-                                        sizeof(SGDescriptor_struct);
-                        curr_sg[sg_index].Ext = CCISS_SG_CHAIN;
-
                         /* Point to next chain block. */
-                        curr_sg = h->cmd_sg_list[c->cmdindex]->sgchain;
+                        curr_sg = h->cmd_sg_list[c->cmdindex];
                         sg_index = 0;
                         chained = 1;
                 }
@@ -3166,31 +3226,12 @@ static void do_cciss_request(struct request_queue *q)
                 curr_sg[sg_index].Addr.lower = temp64.val32.lower;
                 curr_sg[sg_index].Addr.upper = temp64.val32.upper;
                 curr_sg[sg_index].Ext = 0;  /* we are not chaining */
-
                 ++sg_index;
         }
-
-        if (chained) {
-                int len;
-                curr_sg = c->SG;
-                sg_index = h->max_cmd_sgentries - 1;
-                len = curr_sg[sg_index].Len;
-                /* Setup pointer to next chain block.
-                 * Fill out last element in current chain
-                 * block with address of next chain block.
-                 */
-                temp64.val = pci_map_single(h->pdev,
-                                        h->cmd_sg_list[c->cmdindex]->sgchain,
-                                        len, dir);
-
-                h->cmd_sg_list[c->cmdindex]->sg_chain_dma = temp64.val;
-                curr_sg[sg_index].Addr.lower = temp64.val32.lower;
-                curr_sg[sg_index].Addr.upper = temp64.val32.upper;
-
-                pci_dma_sync_single_for_device(h->pdev,
-                                h->cmd_sg_list[c->cmdindex]->sg_chain_dma,
-                                len, dir);
-        }
+        if (chained)
+                cciss_map_sg_chain_block(h, c, h->cmd_sg_list[c->cmdindex],
+                        (seg - (h->max_cmd_sgentries - 1)) *
+                                sizeof(SGDescriptor_struct));
 
         /* track how many SG entries we are using */
         if (seg > h->maxSG)
@@ -3209,11 +3250,11 @@ static void do_cciss_request(struct request_queue *q)
         if (likely(blk_fs_request(creq))) {
                 if(h->cciss_read == CCISS_READ_10) {
                         c->Request.CDB[1] = 0;
-                        c->Request.CDB[2] = (start_blk >> 24) & 0xff;   //MSB
+                        c->Request.CDB[2] = (start_blk >> 24) & 0xff; /* MSB */
                         c->Request.CDB[3] = (start_blk >> 16) & 0xff;
                         c->Request.CDB[4] = (start_blk >> 8) & 0xff;
                         c->Request.CDB[5] = start_blk & 0xff;
-                        c->Request.CDB[6] = 0;  // (sect >> 24) & 0xff; MSB
+                        c->Request.CDB[6] = 0; /* (sect >> 24) & 0xff; MSB */
                         c->Request.CDB[7] = (blk_rq_sectors(creq) >> 8) & 0xff;
                         c->Request.CDB[8] = blk_rq_sectors(creq) & 0xff;
                         c->Request.CDB[9] = c->Request.CDB[11] = c->Request.CDB[12] = 0;
@@ -3222,7 +3263,7 @@ static void do_cciss_request(struct request_queue *q)
 
                         c->Request.CDBLen = 16;
                         c->Request.CDB[1]= 0;
-                        c->Request.CDB[2]= (upper32 >> 24) & 0xff;      //MSB
+                        c->Request.CDB[2]= (upper32 >> 24) & 0xff; /* MSB */
                         c->Request.CDB[3]= (upper32 >> 16) & 0xff;
                         c->Request.CDB[4]= (upper32 >>  8) & 0xff;
                         c->Request.CDB[5]= upper32 & 0xff;
@@ -4240,37 +4281,10 @@ static int __devinit cciss_init_one(struct pci_dev *pdev,
                         goto clean4;
                 }
         }
-        hba[i]->cmd_sg_list = kmalloc(sizeof(struct Cmd_sg_list *) *
-                                                hba[i]->nr_cmds,
-                                                GFP_KERNEL);
-        if (!hba[i]->cmd_sg_list) {
-                printk(KERN_ERR "cciss%d: Cannot get memory for "
-                        "s/g chaining.\n", i);
+        hba[i]->cmd_sg_list = cciss_allocate_sg_chain_blocks(hba[i],
+                hba[i]->chainsize, hba[i]->nr_cmds);
+        if (!hba[i]->cmd_sg_list && hba[i]->chainsize > 0)
                 goto clean4;
-        }
-        /* Build up chain blocks for each command */
-        if (hba[i]->chainsize > 0) {
-                for (j = 0; j < hba[i]->nr_cmds; j++) {
-                        hba[i]->cmd_sg_list[j] =
-                                        kmalloc(sizeof(struct Cmd_sg_list),
-                                                        GFP_KERNEL);
-                        if (!hba[i]->cmd_sg_list[j]) {
-                                printk(KERN_ERR "cciss%d: Cannot get memory "
-                                        "for chain block.\n", i);
-                                goto clean4;
-                        }
-                        /* Need a block of chainsized s/g elements. */
-                        hba[i]->cmd_sg_list[j]->sgchain =
-                                        kmalloc((hba[i]->chainsize *
-                                                sizeof(SGDescriptor_struct)),
-                                                GFP_KERNEL);
-                        if (!hba[i]->cmd_sg_list[j]->sgchain) {
-                                printk(KERN_ERR "cciss%d: Cannot get memory "
-                                        "for s/g chains\n", i);
-                                goto clean4;
-                        }
-                }
-        }
 
         spin_lock_init(&hba[i]->lock);
 
@@ -4329,16 +4343,7 @@ clean4:
         for (k = 0; k < hba[i]->nr_cmds; k++)
                 kfree(hba[i]->scatter_list[k]);
         kfree(hba[i]->scatter_list);
-        /* Only free up extra s/g lists if controller supports them */
-        if (hba[i]->chainsize > 0) {
-                for (j = 0; j < hba[i]->nr_cmds; j++) {
-                        if (hba[i]->cmd_sg_list[j]) {
-                                kfree(hba[i]->cmd_sg_list[j]->sgchain);
-                                kfree(hba[i]->cmd_sg_list[j]);
-                        }
-                }
-                kfree(hba[i]->cmd_sg_list);
-        }
+        cciss_free_sg_chain_blocks(hba[i]->cmd_sg_list, hba[i]->nr_cmds);
         if (hba[i]->cmd_pool)
                 pci_free_consistent(hba[i]->pdev,
                                     hba[i]->nr_cmds * sizeof(CommandList_struct),
@@ -4456,16 +4461,7 @@ static void __devexit cciss_remove_one(struct pci_dev *pdev)
         for (j = 0; j < hba[i]->nr_cmds; j++)
                 kfree(hba[i]->scatter_list[j]);
         kfree(hba[i]->scatter_list);
-        /* Only free up extra s/g lists if controller supports them */
-        if (hba[i]->chainsize > 0) {
-                for (j = 0; j < hba[i]->nr_cmds; j++) {
-                        if (hba[i]->cmd_sg_list[j]) {
-                                kfree(hba[i]->cmd_sg_list[j]->sgchain);
-                                kfree(hba[i]->cmd_sg_list[j]);
-                        }
-                }
-                kfree(hba[i]->cmd_sg_list);
-        }
+        cciss_free_sg_chain_blocks(hba[i]->cmd_sg_list, hba[i]->nr_cmds);
         /*
          * Deliberately omit pci_disable_device(): it does something nasty to
          * Smart Array controllers that pci_enable_device does not undo
@@ -4498,7 +4494,7 @@ static int __init cciss_init(void)
          * boundary. Given that we use pci_alloc_consistent() to allocate an
          * array of them, the size must be a multiple of 8 bytes.
          */
-        BUILD_BUG_ON(sizeof(CommandList_struct) % 8);
+        BUILD_BUG_ON(sizeof(CommandList_struct) % COMMANDLIST_ALIGNMENT);
 
         printk(KERN_INFO DRIVER_NAME "\n");
 
diff --git a/drivers/block/cciss.h b/drivers/block/cciss.h
index 1d95db254069..c5d411174db0 100644
--- a/drivers/block/cciss.h
+++ b/drivers/block/cciss.h
@@ -55,18 +55,12 @@ typedef struct _drive_info_struct
         char device_initialized;     /* indicates whether dev is initialized */
 } drive_info_struct;
 
-struct Cmd_sg_list {
-        SGDescriptor_struct     *sgchain;
-        dma_addr_t              sg_chain_dma;
-        int                     chain_block_size;
-};
-
 struct ctlr_info
 {
         int     ctlr;
         char    devname[8];
         char    *product_name;
-        char    firm_ver[4]; // Firmware version 
+        char    firm_ver[4]; /* Firmware version */
         struct pci_dev *pdev;
         __u32   board_id;
         void __iomem *vaddr;
@@ -89,7 +83,7 @@ struct ctlr_info
         int     maxsgentries;
         int     chainsize;
         int     max_cmd_sgentries;
-        struct Cmd_sg_list **cmd_sg_list;
+        SGDescriptor_struct **cmd_sg_list;
 
 #       define DOORBELL_INT     0
 #       define PERF_MODE_INT    1
@@ -103,7 +97,7 @@ struct ctlr_info
         BYTE    cciss_write;
         BYTE    cciss_read_capacity;
 
-        // information about each logical volume
+        /* information about each logical volume */
         drive_info_struct *drv[CISS_MAX_LUN];
 
         struct access_method access;
@@ -116,7 +110,7 @@ struct ctlr_info
         unsigned int maxSG;
         spinlock_t lock;
 
-        //* pointers to command and error info pool */ 
+        /* pointers to command and error info pool */
         CommandList_struct      *cmd_pool;
         dma_addr_t              cmd_pool_dhandle; 
         ErrorInfo_struct        *errinfo_pool;
@@ -134,12 +128,10 @@ struct ctlr_info
         */
         int                     next_to_run;
 
-        // Disk structures we need to pass back
+        /* Disk structures we need to pass back */
         struct gendisk   *gendisk[CISS_MAX_LUN];
 #ifdef CONFIG_CISS_SCSI_TAPE
-        void *scsi_ctlr; /* ptr to structure containing scsi related stuff */
-        /* list of block side commands the scsi error handling sucked up */
-        /* and saved for later processing */
+        struct cciss_scsi_adapter_data_t *scsi_ctlr;
 #endif
         unsigned char alive;
         struct list_head scan_list;
@@ -315,4 +307,3 @@ struct board_type {
 #define CCISS_LOCK(i)   (&hba[i]->lock)
 
 #endif /* CCISS_H */
-
diff --git a/drivers/block/cciss_cmd.h b/drivers/block/cciss_cmd.h
index 6afa700890ff..e624ff959cb6 100644
--- a/drivers/block/cciss_cmd.h
+++ b/drivers/block/cciss_cmd.h
@@ -1,31 +1,16 @@
 #ifndef CCISS_CMD_H
 #define CCISS_CMD_H
-//###########################################################################
-//DEFINES
-//###########################################################################
+
+#include <linux/cciss_defs.h>
+
+/* DEFINES */
 #define CISS_VERSION "1.00"
 
-//general boundary definitions
-#define SENSEINFOBYTES          32//note that this value may vary between host implementations
+/* general boundary definitions */
 #define MAXSGENTRIES            32
 #define CCISS_SG_CHAIN          0x80000000
 #define MAXREPLYQS              256
 
-//Command Status value
-#define CMD_SUCCESS             0x0000
-#define CMD_TARGET_STATUS       0x0001
-#define CMD_DATA_UNDERRUN       0x0002
-#define CMD_DATA_OVERRUN        0x0003
-#define CMD_INVALID             0x0004
-#define CMD_PROTOCOL_ERR        0x0005
-#define CMD_HARDWARE_ERR        0x0006
-#define CMD_CONNECTION_LOST     0x0007
-#define CMD_ABORTED             0x0008
-#define CMD_ABORT_FAILED        0x0009
-#define CMD_UNSOLICITED_ABORT   0x000A
-#define CMD_TIMEOUT             0x000B
-#define CMD_UNABORTABLE         0x000C
-
 /* Unit Attentions ASC's as defined for the MSA2012sa */
 #define POWER_OR_RESET                  0x29
 #define STATE_CHANGED                   0x2a
@@ -49,30 +34,13 @@
 #define ASYM_ACCESS_CHANGED             0x06
 #define LUN_CAPACITY_CHANGED            0x09
 
-//transfer direction
-#define XFER_NONE               0x00
-#define XFER_WRITE              0x01
-#define XFER_READ               0x02
-#define XFER_RSVD               0x03
-
-//task attribute
-#define ATTR_UNTAGGED           0x00
-#define ATTR_SIMPLE             0x04
-#define ATTR_HEADOFQUEUE        0x05
-#define ATTR_ORDERED            0x06
-#define ATTR_ACA                0x07
-
-//cdb type
-#define TYPE_CMD                                0x00
-#define TYPE_MSG                                0x01
-
-//config space register offsets
+/* config space register offsets */
 #define CFG_VENDORID            0x00
 #define CFG_DEVICEID            0x02
 #define CFG_I2OBAR              0x10
 #define CFG_MEM1BAR             0x14
 
-//i2o space register offsets
+/* i2o space register offsets */
 #define I2O_IBDB_SET            0x20
 #define I2O_IBDB_CLEAR          0x70
 #define I2O_INT_STATUS          0x30
@@ -81,7 +49,7 @@
 #define I2O_OBPOST_Q            0x44
 #define I2O_DMA1_CFG            0x214
 
-//Configuration Table
+/* Configuration Table */
 #define CFGTBL_ChangeReq        0x00000001l
 #define CFGTBL_AccCmds          0x00000001l
 
@@ -103,24 +71,17 @@ typedef union _u64bit
    __u64        val;
 } u64bit;
 
-// Type defs used in the following structs
-#define BYTE __u8
-#define WORD __u16
-#define HWORD __u16
-#define DWORD __u32
+/* Type defs used in the following structs */
 #define QWORD vals32 
 
-//###########################################################################
-//STRUCTURES
-//###########################################################################
-#define CISS_MAX_LUN    1024
+/* STRUCTURES */
 #define CISS_MAX_PHYS_LUN       1024
-// SCSI-3 Cmmands 
+/* SCSI-3 Cmmands */
 
 #pragma pack(1) 
 
 #define CISS_INQUIRY 0x12
-//Date returned
+/* Date returned */
 typedef struct _InquiryData_struct
 {
   BYTE data_byte[36];
@@ -128,7 +89,7 @@ typedef struct _InquiryData_struct
 
 #define CISS_REPORT_LOG 0xc2    /* Report Logical LUNs */
 #define CISS_REPORT_PHYS 0xc3   /* Report Physical LUNs */
-// Data returned
+/* Data returned */
 typedef struct _ReportLUNdata_struct
 {
   BYTE LUNListLength[4];
@@ -139,8 +100,8 @@ typedef struct _ReportLUNdata_struct
 #define CCISS_READ_CAPACITY 0x25 /* Read Capacity */ 
 typedef struct _ReadCapdata_struct
 {
-  BYTE total_size[4];   // Total size in blocks
-  BYTE block_size[4];   // Size of blocks in bytes
+  BYTE total_size[4];   /* Total size in blocks */
+  BYTE block_size[4];   /* Size of blocks in bytes */
 } ReadCapdata_struct;
 
 #define CCISS_READ_CAPACITY_16 0x9e /* Read Capacity 16 */
@@ -172,52 +133,13 @@ typedef struct _ReadCapdata_struct_16
 #define CDB_LEN10       10
 #define CDB_LEN16       16
 
-// BMIC commands 
+/* BMIC commands */
 #define BMIC_READ 0x26
 #define BMIC_WRITE 0x27
 #define BMIC_CACHE_FLUSH 0xc2
-#define CCISS_CACHE_FLUSH 0x01  //C2 was already being used by CCISS
-
-//Command List Structure
-typedef union _SCSI3Addr_struct {
-   struct {
-    BYTE Dev;
-    BYTE Bus:6;
-    BYTE Mode:2;        // b00
-  } PeripDev;
-   struct {
-    BYTE DevLSB;
-    BYTE DevMSB:6;
-    BYTE Mode:2;        // b01
-  } LogDev;
-   struct {
-    BYTE Dev:5;
-    BYTE Bus:3;
-    BYTE Targ:6;
-    BYTE Mode:2;        // b10
-  } LogUnit;
-} SCSI3Addr_struct;
-
-typedef struct _PhysDevAddr_struct {
-  DWORD             TargetId:24;
-  DWORD             Bus:6;
-  DWORD             Mode:2;
-  SCSI3Addr_struct  Target[2]; //2 level target device addr
-} PhysDevAddr_struct;
-  
-typedef struct _LogDevAddr_struct {
-  DWORD            VolId:30;
-  DWORD            Mode:2;
-  BYTE             reserved[4];
-} LogDevAddr_struct;
-
-typedef union _LUNAddr_struct {
-  BYTE               LunAddrBytes[8];
-  SCSI3Addr_struct   SCSI3Lun[4];
-  PhysDevAddr_struct PhysDev;
-  LogDevAddr_struct  LogDev;
-} LUNAddr_struct;
+#define CCISS_CACHE_FLUSH 0x01  /* C2 was already being used by CCISS */
 
+/* Command List Structure */
 #define CTLR_LUNID "\0\0\0\0\0\0\0\0"
 
 typedef struct _CommandListHeader_struct {
@@ -227,16 +149,6 @@ typedef struct _CommandListHeader_struct {
   QWORD             Tag;
   LUNAddr_struct    LUN;
 } CommandListHeader_struct;
-typedef struct _RequestBlock_struct {
-  BYTE   CDBLen;
-  struct {
-    BYTE Type:3;
-    BYTE Attribute:3;
-    BYTE Direction:2;
-  } Type;
-  HWORD  Timeout;
-  BYTE   CDB[16];
-} RequestBlock_struct;
 typedef struct _ErrDescriptor_struct {
   QWORD  Addr;
   DWORD  Len;
@@ -247,28 +159,6 @@ typedef struct _SGDescriptor_struct {
   DWORD  Ext;
 } SGDescriptor_struct;
 
-typedef union _MoreErrInfo_struct{
-  struct {
-    BYTE  Reserved[3];
-    BYTE  Type;
-    DWORD ErrorInfo;
-  }Common_Info;
-  struct{
-    BYTE  Reserved[2];
-    BYTE  offense_size;//size of offending entry
-    BYTE  offense_num; //byte # of offense 0-base
-    DWORD offense_value;
-  }Invalid_Cmd;
-}MoreErrInfo_struct;
-typedef struct _ErrorInfo_struct {
-  BYTE               ScsiStatus;
-  BYTE               SenseLen;
-  HWORD              CommandStatus;
-  DWORD              ResidualCnt;
-  MoreErrInfo_struct MoreErrInfo;
-  BYTE               SenseInfo[SENSEINFOBYTES];
-} ErrorInfo_struct;
-
 /* Command types */
 #define CMD_RWREQ       0x00
 #define CMD_IOCTL_PEND  0x01
@@ -277,10 +167,18 @@ typedef struct _ErrorInfo_struct {
 #define CMD_MSG_TIMEOUT 0x05
 #define CMD_MSG_STALE   0xff
 
-/* This structure needs to be divisible by 8 for new
- * indexing method.
+/* This structure needs to be divisible by COMMANDLIST_ALIGNMENT
+ * because low bits of the address are used to to indicate that
+ * whether the tag contains an index or an address.  PAD_32 and
+ * PAD_64 can be adjusted independently as needed for 32-bit
+ * and 64-bits systems.
  */
-#define PADSIZE (sizeof(long) - 4)
+#define COMMANDLIST_ALIGNMENT (8)
+#define IS_64_BIT ((sizeof(long) - 4)/4)
+#define IS_32_BIT (!IS_64_BIT)
+#define PAD_32 (0)
+#define PAD_64 (4)
+#define PADSIZE (IS_32_BIT * PAD_32 + IS_64_BIT * PAD_64)
 typedef struct _CommandList_struct {
   CommandListHeader_struct Header;
   RequestBlock_struct      Request;
@@ -300,7 +198,7 @@ typedef struct _CommandList_struct {
   char   pad[PADSIZE];
 } CommandList_struct;
 
-//Configuration Table Structure
+/* Configuration Table Structure */
 typedef struct _HostWrite_struct {
   DWORD TransportRequest;
   DWORD Reserved;
@@ -326,4 +224,4 @@ typedef struct _CfgTable_struct {
   DWORD            MaxPhysicalDrivesPerLogicalUnit;
 } CfgTable_struct;
 #pragma pack()   
-#endif // CCISS_CMD_H
+#endif /* CCISS_CMD_H */
diff --git a/drivers/block/cciss_scsi.c b/drivers/block/cciss_scsi.c
index 5d0e46dc3632..e1d0e2cfec72 100644
--- a/drivers/block/cciss_scsi.c
+++ b/drivers/block/cciss_scsi.c
@@ -84,7 +84,6 @@ static struct scsi_host_template cciss_driver_template = {
         .queuecommand           = cciss_scsi_queue_command,
         .can_queue              = SCSI_CCISS_CAN_QUEUE,
         .this_id                = 7,
-        .sg_tablesize           = MAXSGENTRIES,
         .cmd_per_lun            = 1,
         .use_clustering         = DISABLE_CLUSTERING,
         /* Can't have eh_bus_reset_handler or eh_host_reset_handler for cciss */
@@ -93,11 +92,16 @@ static struct scsi_host_template cciss_driver_template = {
 };
 
 #pragma pack(1)
+
+#define SCSI_PAD_32 0
+#define SCSI_PAD_64 0
+
 struct cciss_scsi_cmd_stack_elem_t {
         CommandList_struct cmd;
         ErrorInfo_struct Err;
         __u32 busaddr;
-        __u32 pad;
+        int cmdindex;
+        u8 pad[IS_32_BIT * SCSI_PAD_32 + IS_64_BIT * SCSI_PAD_64];
 };
 
 #pragma pack()
@@ -118,16 +122,15 @@ struct cciss_scsi_cmd_stack_t {
 struct cciss_scsi_adapter_data_t {
         struct Scsi_Host *scsi_host;
         struct cciss_scsi_cmd_stack_t cmd_stack;
+        SGDescriptor_struct **cmd_sg_list;
         int registered;
         spinlock_t lock; // to protect ccissscsi[ctlr]; 
 };
 
 #define CPQ_TAPE_LOCK(ctlr, flags) spin_lock_irqsave( \
-        &(((struct cciss_scsi_adapter_data_t *) \
-        hba[ctlr]->scsi_ctlr)->lock), flags);
+        &hba[ctlr]->scsi_ctlr->lock, flags);
 #define CPQ_TAPE_UNLOCK(ctlr, flags) spin_unlock_irqrestore( \
-        &(((struct cciss_scsi_adapter_data_t *) \
-        hba[ctlr]->scsi_ctlr)->lock), flags);
+        &hba[ctlr]->scsi_ctlr->lock, flags);
 
 static CommandList_struct *
 scsi_cmd_alloc(ctlr_info_t *h)
@@ -143,7 +146,7 @@ scsi_cmd_alloc(ctlr_info_t *h)
         struct cciss_scsi_cmd_stack_t *stk;
         u64bit temp64;
 
-        sa = (struct cciss_scsi_adapter_data_t *) h->scsi_ctlr;
+        sa = h->scsi_ctlr;
         stk = &sa->cmd_stack; 
 
         if (stk->top < 0) 
@@ -154,6 +157,7 @@ scsi_cmd_alloc(ctlr_info_t *h)
         memset(&c->Err, 0, sizeof(c->Err));
         /* set physical addr of cmd and addr of scsi parameters */
         c->cmd.busaddr = c->busaddr; 
+        c->cmd.cmdindex = c->cmdindex;
         /* (__u32) (stk->cmd_pool_handle + 
                 (sizeof(struct cciss_scsi_cmd_stack_elem_t)*stk->top)); */
 
@@ -182,7 +186,7 @@ scsi_cmd_free(ctlr_info_t *h, CommandList_struct *cmd)
         struct cciss_scsi_adapter_data_t *sa;
         struct cciss_scsi_cmd_stack_t *stk;
 
-        sa = (struct cciss_scsi_adapter_data_t *) h->scsi_ctlr;
+        sa = h->scsi_ctlr;
         stk = &sa->cmd_stack; 
         if (stk->top >= CMD_STACK_SIZE) {
                 printk("cciss: scsi_cmd_free called too many times.\n");
@@ -199,24 +203,31 @@ scsi_cmd_stack_setup(int ctlr, struct cciss_scsi_adapter_data_t *sa)
         struct cciss_scsi_cmd_stack_t *stk;
         size_t size;
 
+        sa->cmd_sg_list = cciss_allocate_sg_chain_blocks(hba[ctlr],
+                hba[ctlr]->chainsize, CMD_STACK_SIZE);
+        if (!sa->cmd_sg_list && hba[ctlr]->chainsize > 0)
+                return -ENOMEM;
+
         stk = &sa->cmd_stack; 
         size = sizeof(struct cciss_scsi_cmd_stack_elem_t) * CMD_STACK_SIZE;
 
-        // pci_alloc_consistent guarantees 32-bit DMA address will
-        // be used
-
+        /* Check alignment, see cciss_cmd.h near CommandList_struct def. */
+        BUILD_BUG_ON((sizeof(*stk->pool) % COMMANDLIST_ALIGNMENT) != 0);
+        /* pci_alloc_consistent guarantees 32-bit DMA address will be used */
         stk->pool = (struct cciss_scsi_cmd_stack_elem_t *)
                 pci_alloc_consistent(hba[ctlr]->pdev, size, &stk->cmd_pool_handle);
 
         if (stk->pool == NULL) {
-                printk("stk->pool is null\n");
-                return -1;
+                cciss_free_sg_chain_blocks(sa->cmd_sg_list, CMD_STACK_SIZE);
+                sa->cmd_sg_list = NULL;
+                return -ENOMEM;
         }
 
         for (i=0; i<CMD_STACK_SIZE; i++) {
                 stk->elem[i] = &stk->pool[i];
                 stk->elem[i]->busaddr = (__u32) (stk->cmd_pool_handle + 
                         (sizeof(struct cciss_scsi_cmd_stack_elem_t) * i));
+                stk->elem[i]->cmdindex = i;
         }
         stk->top = CMD_STACK_SIZE-1;
         return 0;
@@ -229,7 +240,7 @@ scsi_cmd_stack_free(int ctlr)
         struct cciss_scsi_cmd_stack_t *stk;
         size_t size;
 
-        sa = (struct cciss_scsi_adapter_data_t *) hba[ctlr]->scsi_ctlr;
+        sa = hba[ctlr]->scsi_ctlr;
         stk = &sa->cmd_stack; 
         if (stk->top != CMD_STACK_SIZE-1) {
                 printk( "cciss: %d scsi commands are still outstanding.\n",
@@ -241,6 +252,7 @@ scsi_cmd_stack_free(int ctlr)
 
         pci_free_consistent(hba[ctlr]->pdev, size, stk->pool, stk->cmd_pool_handle);
         stk->pool = NULL;
+        cciss_free_sg_chain_blocks(sa->cmd_sg_list, CMD_STACK_SIZE);
 }
 
 #if 0
@@ -530,8 +542,7 @@ adjust_cciss_scsi_table(int ctlr, int hostno,
         CPQ_TAPE_LOCK(ctlr, flags);
 
         if (hostno != -1)  /* if it's not the first time... */
-                sh = ((struct cciss_scsi_adapter_data_t *)
-                        hba[ctlr]->scsi_ctlr)->scsi_host;
+                sh = hba[ctlr]->scsi_ctlr->scsi_host;
 
         /* find any devices in ccissscsi[] that are not in 
            sd[] and remove them from ccissscsi[] */
@@ -702,7 +713,7 @@ cciss_scsi_setup(int cntl_num)
                 kfree(shba);
                 shba = NULL;
         }
-        hba[cntl_num]->scsi_ctlr = (void *) shba;
+        hba[cntl_num]->scsi_ctlr = shba;
         return;
 }
 
@@ -725,6 +736,8 @@ complete_scsi_command( CommandList_struct *cp, int timeout, __u32 tag)
         ctlr = hba[cp->ctlr];
 
         scsi_dma_unmap(cmd);
+        if (cp->Header.SGTotal > ctlr->max_cmd_sgentries)
+                cciss_unmap_sg_chain_block(ctlr, cp);
 
         cmd->result = (DID_OK << 16);           /* host byte */
         cmd->result |= (COMMAND_COMPLETE << 8); /* msg byte */
@@ -847,9 +860,10 @@ cciss_scsi_detect(int ctlr)
         sh->io_port = 0;        // good enough?  FIXME, 
         sh->n_io_port = 0;      // I don't think we use these two...
         sh->this_id = SELF_SCSI_ID;  
+        sh->sg_tablesize = hba[ctlr]->maxsgentries;
 
         ((struct cciss_scsi_adapter_data_t *) 
-                hba[ctlr]->scsi_ctlr)->scsi_host = (void *) sh;
+                hba[ctlr]->scsi_ctlr)->scsi_host = sh;
         sh->hostdata[0] = (unsigned long) hba[ctlr];
         sh->irq = hba[ctlr]->intr[SIMPLE_MODE_INT];
         sh->unique_id = sh->irq;
@@ -1364,34 +1378,54 @@ cciss_scsi_proc_info(struct Scsi_Host *sh,
    dma mapping  and fills in the scatter gather entries of the 
    cciss command, cp. */
 
-static void
-cciss_scatter_gather(struct pci_dev *pdev, 
-                CommandList_struct *cp, 
-                struct scsi_cmnd *cmd)
+static void cciss_scatter_gather(ctlr_info_t *h, CommandList_struct *cp,
+        struct scsi_cmnd *cmd)
 {
         unsigned int len;
         struct scatterlist *sg;
         __u64 addr64;
-        int use_sg, i;
-
-        BUG_ON(scsi_sg_count(cmd) > MAXSGENTRIES);
-
-        use_sg = scsi_dma_map(cmd);
-        if (use_sg) {   /* not too many addrs? */
-                scsi_for_each_sg(cmd, sg, use_sg, i) {
+        int request_nsgs, i, chained, sg_index;
+        struct cciss_scsi_adapter_data_t *sa = h->scsi_ctlr;
+        SGDescriptor_struct *curr_sg;
+
+        BUG_ON(scsi_sg_count(cmd) > h->maxsgentries);
+
+        chained = 0;
+        sg_index = 0;
+        curr_sg = cp->SG;
+        request_nsgs = scsi_dma_map(cmd);
+        if (request_nsgs) {
+                scsi_for_each_sg(cmd, sg, request_nsgs, i) {
+                        if (sg_index + 1 == h->max_cmd_sgentries &&
+                                !chained && request_nsgs - i > 1) {
+                                chained = 1;
+                                sg_index = 0;
+                                curr_sg = sa->cmd_sg_list[cp->cmdindex];
+                        }
                         addr64 = (__u64) sg_dma_address(sg);
                         len  = sg_dma_len(sg);
-                        cp->SG[i].Addr.lower =
-                                (__u32) (addr64 & (__u64) 0x00000000FFFFFFFF);
-                        cp->SG[i].Addr.upper =
-                                (__u32) ((addr64 >> 32) & (__u64) 0x00000000FFFFFFFF);
-                        cp->SG[i].Len = len;
-                        cp->SG[i].Ext = 0;  // we are not chaining
+                        curr_sg[sg_index].Addr.lower =
+                                (__u32) (addr64 & 0x0FFFFFFFFULL);
+                        curr_sg[sg_index].Addr.upper =
+                                (__u32) ((addr64 >> 32) & 0x0FFFFFFFFULL);
+                        curr_sg[sg_index].Len = len;
+                        curr_sg[sg_index].Ext = 0;
+                        ++sg_index;
                 }
+                if (chained)
+                        cciss_map_sg_chain_block(h, cp,
+                                sa->cmd_sg_list[cp->cmdindex],
+                                (request_nsgs - (h->max_cmd_sgentries - 1)) *
+                                        sizeof(SGDescriptor_struct));
         }
-
-        cp->Header.SGList = (__u8) use_sg;   /* no. SGs contig in this cmd */
-        cp->Header.SGTotal = (__u16) use_sg; /* total sgs in this cmd list */
+        /* track how many SG entries we are using */
+        if (request_nsgs > h->maxSG)
+                h->maxSG = request_nsgs;
+        cp->Header.SGTotal = (__u8) request_nsgs + chained;
+        if (request_nsgs > h->max_cmd_sgentries)
+                cp->Header.SGList = h->max_cmd_sgentries;
+        else
+                cp->Header.SGList = cp->Header.SGTotal;
         return;
 }
 
@@ -1399,7 +1433,7 @@ cciss_scatter_gather(struct pci_dev *pdev,
 static int
 cciss_scsi_queue_command (struct scsi_cmnd *cmd, void (* done)(struct scsi_cmnd *))
 {
-        ctlr_info_t **c;
+        ctlr_info_t *c;
         int ctlr, rc;
         unsigned char scsi3addr[8];
         CommandList_struct *cp;
@@ -1407,8 +1441,8 @@ cciss_scsi_queue_command (struct scsi_cmnd *cmd, void (* done)(struct scsi_cmnd
 
         // Get the ptr to our adapter structure (hba[i]) out of cmd->host.
         // We violate cmd->host privacy here.  (Is there another way?)
-        c = (ctlr_info_t **) &cmd->device->host->hostdata[0];   
-        ctlr = (*c)->ctlr;
+        c = (ctlr_info_t *) cmd->device->host->hostdata[0];
+        ctlr = c->ctlr;
 
         rc = lookup_scsi3addr(ctlr, cmd->device->channel, cmd->device->id, 
                         cmd->device->lun, scsi3addr);
@@ -1431,7 +1465,7 @@ cciss_scsi_queue_command (struct scsi_cmnd *cmd, void (* done)(struct scsi_cmnd
            see what the device thinks of it. */
 
         spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
-        cp = scsi_cmd_alloc(*c);
+        cp = scsi_cmd_alloc(c);
         spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
         if (cp == NULL) {                       /* trouble... */
                 printk("scsi_cmd_alloc returned NULL!\n");
@@ -1489,15 +1523,14 @@ cciss_scsi_queue_command (struct scsi_cmnd *cmd, void (* done)(struct scsi_cmnd
                 BUG();
                 break;
         }
-
-        cciss_scatter_gather((*c)->pdev, cp, cmd); // Fill the SG list
+        cciss_scatter_gather(c, cp, cmd);
 
         /* Put the request on the tail of the request queue */
 
         spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
-        addQ(&(*c)->reqQ, cp);
-        (*c)->Qdepth++;
-        start_io(*c);
+        addQ(&c->reqQ, cp);
+        c->Qdepth++;
+        start_io(c);
         spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
 
         /* the cmd'll come back via intr handler in complete_scsi_command()  */
@@ -1514,7 +1547,7 @@ cciss_unregister_scsi(int ctlr)
         /* we are being forcibly unloaded, and may not refuse. */
 
         spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
-        sa = (struct cciss_scsi_adapter_data_t *) hba[ctlr]->scsi_ctlr;
+        sa = hba[ctlr]->scsi_ctlr;
         stk = &sa->cmd_stack; 
 
         /* if we weren't ever actually registered, don't unregister */ 
@@ -1541,7 +1574,7 @@ cciss_engage_scsi(int ctlr)
         unsigned long flags;
 
         spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
-        sa = (struct cciss_scsi_adapter_data_t *) hba[ctlr]->scsi_ctlr;
+        sa = hba[ctlr]->scsi_ctlr;
         stk = &sa->cmd_stack; 
 
         if (sa->registered) {
@@ -1654,14 +1687,14 @@ static int cciss_eh_device_reset_handler(struct scsi_cmnd *scsicmd)
         int rc;
         CommandList_struct *cmd_in_trouble;
         unsigned char lunaddr[8];
-        ctlr_info_t **c;
+        ctlr_info_t *c;
         int ctlr;
 
         /* find the controller to which the command to be aborted was sent */
-        c = (ctlr_info_t **) &scsicmd->device->host->hostdata[0];       
+        c = (ctlr_info_t *) scsicmd->device->host->hostdata[0];
         if (c == NULL) /* paranoia */
                 return FAILED;
-        ctlr = (*c)->ctlr;
+        ctlr = c->ctlr;
         printk(KERN_WARNING "cciss%d: resetting tape drive or medium changer.\n", ctlr);
         /* find the command that's giving us trouble */
         cmd_in_trouble = (CommandList_struct *) scsicmd->host_scribble;
@@ -1671,7 +1704,7 @@ static int cciss_eh_device_reset_handler(struct scsi_cmnd *scsicmd)
         /* send a reset to the SCSI LUN which the command was sent to */
         rc = sendcmd_withirq(CCISS_RESET_MSG, ctlr, NULL, 0, 0, lunaddr,
                 TYPE_MSG);
-        if (rc == 0 && wait_for_device_to_become_ready(*c, lunaddr) == 0)
+        if (rc == 0 && wait_for_device_to_become_ready(c, lunaddr) == 0)
                 return SUCCESS;
         printk(KERN_WARNING "cciss%d: resetting device failed.\n", ctlr);
         return FAILED;
@@ -1682,14 +1715,14 @@ static int  cciss_eh_abort_handler(struct scsi_cmnd *scsicmd)
         int rc;
         CommandList_struct *cmd_to_abort;
         unsigned char lunaddr[8];
-        ctlr_info_t **c;
+        ctlr_info_t *c;
         int ctlr;
 
         /* find the controller to which the command to be aborted was sent */
-        c = (ctlr_info_t **) &scsicmd->device->host->hostdata[0];       
+        c = (ctlr_info_t *) scsicmd->device->host->hostdata[0];
         if (c == NULL) /* paranoia */
                 return FAILED;
-        ctlr = (*c)->ctlr;
+        ctlr = c->ctlr;
         printk(KERN_WARNING "cciss%d: aborting tardy SCSI cmd\n", ctlr);
 
         /* find the command to be aborted */
diff --git a/drivers/block/cciss_scsi.h b/drivers/block/cciss_scsi.h
index 7b750245ae76..6d5822fe851a 100644
--- a/drivers/block/cciss_scsi.h
+++ b/drivers/block/cciss_scsi.h
@@ -25,16 +25,16 @@
 
 #include <scsi/scsicam.h> /* possibly irrelevant, since we don't show disks */
 
-                // the scsi id of the adapter...
+                /* the scsi id of the adapter... */
 #define SELF_SCSI_ID 15
-                // 15 is somewhat arbitrary, since the scsi-2 bus
-                // that's presented by the driver to the OS is
-                // fabricated.  The "real" scsi-3 bus the 
-                // hardware presents is fabricated too.
-                // The actual, honest-to-goodness physical
-                // bus that the devices are attached to is not 
-                // addressible natively, and may in fact turn
-                // out to be not scsi at all.
+                /* 15 is somewhat arbitrary, since the scsi-2 bus
+                   that's presented by the driver to the OS is
+                   fabricated.  The "real" scsi-3 bus the
+                   hardware presents is fabricated too.
+                   The actual, honest-to-goodness physical
+                   bus that the devices are attached to is not
+                   addressible natively, and may in fact turn
+                   out to be not scsi at all. */
 
 #define SCSI_CCISS_CAN_QUEUE 2
 
diff --git a/drivers/block/cpqarray.c b/drivers/block/cpqarray.c
index 6422651ec364..91d11631cec9 100644
--- a/drivers/block/cpqarray.c
+++ b/drivers/block/cpqarray.c
@@ -448,11 +448,8 @@ static int __init cpqarray_register_ctlr( int i, struct pci_dev *pdev)
                 blk_queue_bounce_limit(q, hba[i]->pci_dev->dma_mask);
 
         /* This is a hardware imposed limit. */
-        blk_queue_max_hw_segments(q, SG_MAX);
+        blk_queue_max_segments(q, SG_MAX);
 
-        /* This is a driver limit and could be eliminated. */
-        blk_queue_max_phys_segments(q, SG_MAX);
-        
         init_timer(&hba[i]->timer);
         hba[i]->timer.expires = jiffies + IDA_TIMER;
         hba[i]->timer.data = (unsigned long)hba[i];
diff --git a/drivers/block/drbd/drbd_nl.c b/drivers/block/drbd/drbd_nl.c
index 1292e0620663..4df3b40b1057 100644
--- a/drivers/block/drbd/drbd_nl.c
+++ b/drivers/block/drbd/drbd_nl.c
@@ -709,9 +709,8 @@ void drbd_setup_queue_param(struct drbd_conf *mdev, unsigned int max_seg_s) __mu
 
         max_seg_s = min(queue_max_sectors(b) * queue_logical_block_size(b), max_seg_s);
 
-        blk_queue_max_sectors(q, max_seg_s >> 9);
-        blk_queue_max_phys_segments(q, max_segments ? max_segments : MAX_PHYS_SEGMENTS);
-        blk_queue_max_hw_segments(q, max_segments ? max_segments : MAX_HW_SEGMENTS);
+        blk_queue_max_hw_sectors(q, max_seg_s >> 9);
+        blk_queue_max_segments(q, max_segments ? max_segments : BLK_MAX_SEGMENTS);
         blk_queue_max_segment_size(q, max_seg_s);
         blk_queue_logical_block_size(q, 512);
         blk_queue_segment_boundary(q, PAGE_SIZE-1);
diff --git a/drivers/block/floppy.c b/drivers/block/floppy.c
index 3266b4f65daa..b9b117059b62 100644
--- a/drivers/block/floppy.c
+++ b/drivers/block/floppy.c
@@ -4234,7 +4234,7 @@ static int __init floppy_init(void)
                 err = -ENOMEM;
                 goto out_unreg_driver;
         }
-        blk_queue_max_sectors(floppy_queue, 64);
+        blk_queue_max_hw_sectors(floppy_queue, 64);
 
         blk_register_region(MKDEV(FLOPPY_MAJOR, 0), 256, THIS_MODULE,
                             floppy_find, NULL, NULL);
diff --git a/drivers/block/hd.c b/drivers/block/hd.c
index d5cdce08ffd2..5116c65c07cb 100644
--- a/drivers/block/hd.c
+++ b/drivers/block/hd.c
@@ -719,7 +719,7 @@ static int __init hd_init(void)
                 return -ENOMEM;
         }
 
-        blk_queue_max_sectors(hd_queue, 255);
+        blk_queue_max_hw_sectors(hd_queue, 255);
         init_timer(&device_timer);
         device_timer.function = hd_times_out;
         blk_queue_logical_block_size(hd_queue, 512);
diff --git a/drivers/block/mg_disk.c b/drivers/block/mg_disk.c
index 02b2583df7fc..5416c9a606e4 100644
--- a/drivers/block/mg_disk.c
+++ b/drivers/block/mg_disk.c
@@ -980,7 +980,7 @@ static int mg_probe(struct platform_device *plat_dev)
                                 __func__, __LINE__);
                 goto probe_err_6;
         }
-        blk_queue_max_sectors(host->breq, MG_MAX_SECTS);
+        blk_queue_max_hw_sectors(host->breq, MG_MAX_SECTS);
         blk_queue_logical_block_size(host->breq, MG_SECTOR_SIZE);
 
         init_timer(&host->timer);
diff --git a/drivers/block/paride/pd.c b/drivers/block/paride/pd.c
index 569e39e8f114..e712cd51af15 100644
--- a/drivers/block/paride/pd.c
+++ b/drivers/block/paride/pd.c
@@ -906,7 +906,7 @@ static int __init pd_init(void)
         if (!pd_queue)
                 goto out1;
 
-        blk_queue_max_sectors(pd_queue, cluster);
+        blk_queue_max_hw_sectors(pd_queue, cluster);
 
         if (register_blkdev(major, name))
                 goto out2;
diff --git a/drivers/block/paride/pf.c b/drivers/block/paride/pf.c
index ea54ea393553..ddb4f9abd480 100644
--- a/drivers/block/paride/pf.c
+++ b/drivers/block/paride/pf.c
@@ -956,8 +956,7 @@ static int __init pf_init(void)
                 return -ENOMEM;
         }
 
-        blk_queue_max_phys_segments(pf_queue, cluster);
-        blk_queue_max_hw_segments(pf_queue, cluster);
+        blk_queue_max_segments(pf_queue, cluster);
 
         for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++) {
                 struct gendisk *disk = pf->disk;
diff --git a/drivers/block/pktcdvd.c b/drivers/block/pktcdvd.c
index 68b5957f107c..b72935b8f203 100644
--- a/drivers/block/pktcdvd.c
+++ b/drivers/block/pktcdvd.c
@@ -569,6 +569,7 @@ static struct packet_data *pkt_alloc_packet_data(int frames)
         }
 
         spin_lock_init(&pkt->lock);
+        bio_list_init(&pkt->orig_bios);
 
         for (i = 0; i < frames; i++) {
                 struct bio *bio = pkt_bio_alloc(1);
@@ -721,43 +722,6 @@ static void pkt_rbtree_insert(struct pktcdvd_device *pd, struct pkt_rb_node *nod
 }
 
 /*
- * Add a bio to a single linked list defined by its head and tail pointers.
- */
-static void pkt_add_list_last(struct bio *bio, struct bio **list_head, struct bio **list_tail)
-{
-        bio->bi_next = NULL;
-        if (*list_tail) {
-                BUG_ON((*list_head) == NULL);
-                (*list_tail)->bi_next = bio;
-                (*list_tail) = bio;
-        } else {
-                BUG_ON((*list_head) != NULL);
-                (*list_head) = bio;
-                (*list_tail) = bio;
-        }
-}
-
-/*
- * Remove and return the first bio from a single linked list defined by its
- * head and tail pointers.
- */
-static inline struct bio *pkt_get_list_first(struct bio **list_head, struct bio **list_tail)
-{
-        struct bio *bio;
-
-        if (*list_head == NULL)
-                return NULL;
-
-        bio = *list_head;
-        *list_head = bio->bi_next;
-        if (*list_head == NULL)
-                *list_tail = NULL;
-
-        bio->bi_next = NULL;
-        return bio;
-}
-
-/*
  * Send a packet_command to the underlying block device and
  * wait for completion.
  */
@@ -876,13 +840,10 @@ static noinline_for_stack int pkt_set_speed(struct pktcdvd_device *pd,
 static void pkt_queue_bio(struct pktcdvd_device *pd, struct bio *bio)
 {
         spin_lock(&pd->iosched.lock);
-        if (bio_data_dir(bio) == READ) {
-                pkt_add_list_last(bio, &pd->iosched.read_queue,
-                                  &pd->iosched.read_queue_tail);
-        } else {
-                pkt_add_list_last(bio, &pd->iosched.write_queue,
-                                  &pd->iosched.write_queue_tail);
-        }
+        if (bio_data_dir(bio) == READ)
+                bio_list_add(&pd->iosched.read_queue, bio);
+        else
+                bio_list_add(&pd->iosched.write_queue, bio);
         spin_unlock(&pd->iosched.lock);
 
         atomic_set(&pd->iosched.attention, 1);
@@ -917,8 +878,8 @@ static void pkt_iosched_process_queue(struct pktcdvd_device *pd)
                 int reads_queued, writes_queued;
 
                 spin_lock(&pd->iosched.lock);
-                reads_queued = (pd->iosched.read_queue != NULL);
-                writes_queued = (pd->iosched.write_queue != NULL);
+                reads_queued = !bio_list_empty(&pd->iosched.read_queue);
+                writes_queued = !bio_list_empty(&pd->iosched.write_queue);
                 spin_unlock(&pd->iosched.lock);
 
                 if (!reads_queued && !writes_queued)
@@ -927,7 +888,7 @@ static void pkt_iosched_process_queue(struct pktcdvd_device *pd)
                 if (pd->iosched.writing) {
                         int need_write_seek = 1;
                         spin_lock(&pd->iosched.lock);
-                        bio = pd->iosched.write_queue;
+                        bio = bio_list_peek(&pd->iosched.write_queue);
                         spin_unlock(&pd->iosched.lock);
                         if (bio && (bio->bi_sector == pd->iosched.last_write))
                                 need_write_seek = 0;
@@ -950,13 +911,10 @@ static void pkt_iosched_process_queue(struct pktcdvd_device *pd)
                 }
 
                 spin_lock(&pd->iosched.lock);
-                if (pd->iosched.writing) {
-                        bio = pkt_get_list_first(&pd->iosched.write_queue,
-                                                 &pd->iosched.write_queue_tail);
-                } else {
-                        bio = pkt_get_list_first(&pd->iosched.read_queue,
-                                                 &pd->iosched.read_queue_tail);
-                }
+                if (pd->iosched.writing)
+                        bio = bio_list_pop(&pd->iosched.write_queue);
+                else
+                        bio = bio_list_pop(&pd->iosched.read_queue);
                 spin_unlock(&pd->iosched.lock);
 
                 if (!bio)
@@ -992,14 +950,14 @@ static void pkt_iosched_process_queue(struct pktcdvd_device *pd)
 static int pkt_set_segment_merging(struct pktcdvd_device *pd, struct request_queue *q)
 {
         if ((pd->settings.size << 9) / CD_FRAMESIZE
-            <= queue_max_phys_segments(q)) {
+            <= queue_max_segments(q)) {
                 /*
                  * The cdrom device can handle one segment/frame
                  */
                 clear_bit(PACKET_MERGE_SEGS, &pd->flags);
                 return 0;
         } else if ((pd->settings.size << 9) / PAGE_SIZE
-                   <= queue_max_phys_segments(q)) {
+                   <= queue_max_segments(q)) {
                 /*
                  * We can handle this case at the expense of some extra memory
                  * copies during write operations
@@ -1114,7 +1072,7 @@ static void pkt_gather_data(struct pktcdvd_device *pd, struct packet_data *pkt)
         int f;
         char written[PACKET_MAX_SIZE];
 
-        BUG_ON(!pkt->orig_bios);
+        BUG_ON(bio_list_empty(&pkt->orig_bios));
 
         atomic_set(&pkt->io_wait, 0);
         atomic_set(&pkt->io_errors, 0);
@@ -1124,7 +1082,7 @@ static void pkt_gather_data(struct pktcdvd_device *pd, struct packet_data *pkt)
          */
         memset(written, 0, sizeof(written));
         spin_lock(&pkt->lock);
-        for (bio = pkt->orig_bios; bio; bio = bio->bi_next) {
+        bio_list_for_each(bio, &pkt->orig_bios) {
                 int first_frame = (bio->bi_sector - pkt->sector) / (CD_FRAMESIZE >> 9);
                 int num_frames = bio->bi_size / CD_FRAMESIZE;
                 pd->stats.secs_w += num_frames * (CD_FRAMESIZE >> 9);
@@ -1363,7 +1321,7 @@ try_next_bio:
                         break;
                 pkt_rbtree_erase(pd, node);
                 spin_lock(&pkt->lock);
-                pkt_add_list_last(bio, &pkt->orig_bios, &pkt->orig_bios_tail);
+                bio_list_add(&pkt->orig_bios, bio);
                 pkt->write_size += bio->bi_size / CD_FRAMESIZE;
                 spin_unlock(&pkt->lock);
         }
@@ -1409,7 +1367,7 @@ static void pkt_start_write(struct pktcdvd_device *pd, struct packet_data *pkt)
          */
         frames_write = 0;
         spin_lock(&pkt->lock);
-        for (bio = pkt->orig_bios; bio; bio = bio->bi_next) {
+        bio_list_for_each(bio, &pkt->orig_bios) {
                 int segment = bio->bi_idx;
                 int src_offs = 0;
                 int first_frame = (bio->bi_sector - pkt->sector) / (CD_FRAMESIZE >> 9);
@@ -1472,20 +1430,14 @@ static void pkt_start_write(struct pktcdvd_device *pd, struct packet_data *pkt)
 
 static void pkt_finish_packet(struct packet_data *pkt, int uptodate)
 {
-        struct bio *bio, *next;
+        struct bio *bio;
 
         if (!uptodate)
                 pkt->cache_valid = 0;
 
         /* Finish all bios corresponding to this packet */
-        bio = pkt->orig_bios;
-        while (bio) {
-                next = bio->bi_next;
-                bio->bi_next = NULL;
+        while ((bio = bio_list_pop(&pkt->orig_bios)))
                 bio_endio(bio, uptodate ? 0 : -EIO);
-                bio = next;
-        }
-        pkt->orig_bios = pkt->orig_bios_tail = NULL;
 }
 
 static void pkt_run_state_machine(struct pktcdvd_device *pd, struct packet_data *pkt)
@@ -2360,7 +2312,7 @@ static int pkt_open_dev(struct pktcdvd_device *pd, fmode_t write)
                  * even if the size is a multiple of the packet size.
                  */
                 spin_lock_irq(q->queue_lock);
-                blk_queue_max_sectors(q, pd->settings.size);
+                blk_queue_max_hw_sectors(q, pd->settings.size);
                 spin_unlock_irq(q->queue_lock);
                 set_bit(PACKET_WRITABLE, &pd->flags);
         } else {
@@ -2567,8 +2519,7 @@ static int pkt_make_request(struct request_queue *q, struct bio *bio)
                         spin_lock(&pkt->lock);
                         if ((pkt->state == PACKET_WAITING_STATE) ||
                             (pkt->state == PACKET_READ_WAIT_STATE)) {
-                                pkt_add_list_last(bio, &pkt->orig_bios,
-                                                  &pkt->orig_bios_tail);
+                                bio_list_add(&pkt->orig_bios, bio);
                                 pkt->write_size += bio->bi_size / CD_FRAMESIZE;
                                 if ((pkt->write_size >= pkt->frames) &&
                                     (pkt->state == PACKET_WAITING_STATE)) {
@@ -2662,7 +2613,7 @@ static void pkt_init_queue(struct pktcdvd_device *pd)
 
         blk_queue_make_request(q, pkt_make_request);
         blk_queue_logical_block_size(q, CD_FRAMESIZE);
-        blk_queue_max_sectors(q, PACKET_MAX_SECTORS);
+        blk_queue_max_hw_sectors(q, PACKET_MAX_SECTORS);
         blk_queue_merge_bvec(q, pkt_merge_bvec);
         q->queuedata = pd;
 }
@@ -2898,6 +2849,8 @@ static int pkt_setup_dev(dev_t dev, dev_t* pkt_dev)
 
         spin_lock_init(&pd->lock);
         spin_lock_init(&pd->iosched.lock);
+        bio_list_init(&pd->iosched.read_queue);
+        bio_list_init(&pd->iosched.write_queue);
         sprintf(pd->name, DRIVER_NAME"%d", idx);
         init_waitqueue_head(&pd->wqueue);
         pd->bio_queue = RB_ROOT;
diff --git a/drivers/block/ps3disk.c b/drivers/block/ps3disk.c
index 03a130dca8ab..bc95469d33c1 100644
--- a/drivers/block/ps3disk.c
+++ b/drivers/block/ps3disk.c
@@ -474,7 +474,7 @@ static int __devinit ps3disk_probe(struct ps3_system_bus_device *_dev)
 
         blk_queue_bounce_limit(queue, BLK_BOUNCE_HIGH);
 
-        blk_queue_max_sectors(queue, dev->bounce_size >> 9);
+        blk_queue_max_hw_sectors(queue, dev->bounce_size >> 9);
         blk_queue_segment_boundary(queue, -1UL);
         blk_queue_dma_alignment(queue, dev->blk_size-1);
         blk_queue_logical_block_size(queue, dev->blk_size);
@@ -482,8 +482,7 @@ static int __devinit ps3disk_probe(struct ps3_system_bus_device *_dev)
         blk_queue_ordered(queue, QUEUE_ORDERED_DRAIN_FLUSH,
                           ps3disk_prepare_flush);
 
-        blk_queue_max_phys_segments(queue, -1);
-        blk_queue_max_hw_segments(queue, -1);
+        blk_queue_max_segments(queue, -1);
         blk_queue_max_segment_size(queue, dev->bounce_size);
 
         gendisk = alloc_disk(PS3DISK_MINORS);
diff --git a/drivers/block/ps3vram.c b/drivers/block/ps3vram.c
index 1fb6c3135fc8..e44608229972 100644
--- a/drivers/block/ps3vram.c
+++ b/drivers/block/ps3vram.c
@@ -751,10 +751,9 @@ static int __devinit ps3vram_probe(struct ps3_system_bus_device *dev)
         priv->queue = queue;
         queue->queuedata = dev;
         blk_queue_make_request(queue, ps3vram_make_request);
-        blk_queue_max_phys_segments(queue, MAX_PHYS_SEGMENTS);
-        blk_queue_max_hw_segments(queue, MAX_HW_SEGMENTS);
-        blk_queue_max_segment_size(queue, MAX_SEGMENT_SIZE);
-        blk_queue_max_sectors(queue, SAFE_MAX_SECTORS);
+        blk_queue_max_segments(queue, BLK_MAX_SEGMENTS);
+        blk_queue_max_segment_size(queue, BLK_MAX_SEGMENT_SIZE);
+        blk_queue_max_hw_sectors(queue, BLK_SAFE_MAX_SECTORS);
 
         gendisk = alloc_disk(1);
         if (!gendisk) {
diff --git a/drivers/block/sunvdc.c b/drivers/block/sunvdc.c
index 411f064760b4..48e8fee9f2d4 100644
--- a/drivers/block/sunvdc.c
+++ b/drivers/block/sunvdc.c
@@ -691,9 +691,8 @@ static int probe_disk(struct vdc_port *port)
 
         port->disk = g;
 
-        blk_queue_max_hw_segments(q, port->ring_cookies);
-        blk_queue_max_phys_segments(q, port->ring_cookies);
-        blk_queue_max_sectors(q, port->max_xfer_size);
+        blk_queue_max_segments(q, port->ring_cookies);
+        blk_queue_max_hw_sectors(q, port->max_xfer_size);
         g->major = vdc_major;
         g->first_minor = port->vio.vdev->dev_no << PARTITION_SHIFT;
         strcpy(g->disk_name, port->disk_name);
diff --git a/drivers/block/sx8.c b/drivers/block/sx8.c
index a7c4184f4a63..b70f0fca9a42 100644
--- a/drivers/block/sx8.c
+++ b/drivers/block/sx8.c
@@ -409,7 +409,7 @@ static int carm_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
 static void carm_remove_one (struct pci_dev *pdev);
 static int carm_bdev_getgeo(struct block_device *bdev, struct hd_geometry *geo);
 
-static struct pci_device_id carm_pci_tbl[] = {
+static const struct pci_device_id carm_pci_tbl[] = {
         { PCI_VENDOR_ID_PROMISE, 0x8000, PCI_ANY_ID, PCI_ANY_ID, 0, 0, },
         { PCI_VENDOR_ID_PROMISE, 0x8002, PCI_ANY_ID, PCI_ANY_ID, 0, 0, },
         { }     /* terminate list */
@@ -1518,8 +1518,7 @@ static int carm_init_disks(struct carm_host *host)
                         break;
                 }
                 disk->queue = q;
-                blk_queue_max_hw_segments(q, CARM_MAX_REQ_SG);
-                blk_queue_max_phys_segments(q, CARM_MAX_REQ_SG);
+                blk_queue_max_segments(q, CARM_MAX_REQ_SG);
                 blk_queue_segment_boundary(q, CARM_SG_BOUNDARY);
 
                 q->queuedata = port;
diff --git a/drivers/block/ub.c b/drivers/block/ub.c
index c739b203fe91..2e889838e819 100644
--- a/drivers/block/ub.c
+++ b/drivers/block/ub.c
@@ -393,7 +393,7 @@ static int ub_probe_lun(struct ub_dev *sc, int lnum);
 #define ub_usb_ids  usb_storage_usb_ids
 #else
 
-static struct usb_device_id ub_usb_ids[] = {
+static const struct usb_device_id ub_usb_ids[] = {
         { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_SCSI, US_PR_BULK) },
         { }
 };
@@ -2320,10 +2320,9 @@ static int ub_probe_lun(struct ub_dev *sc, int lnum)
         disk->queue = q;
 
         blk_queue_bounce_limit(q, BLK_BOUNCE_HIGH);
-        blk_queue_max_hw_segments(q, UB_MAX_REQ_SG);
-        blk_queue_max_phys_segments(q, UB_MAX_REQ_SG);
+        blk_queue_max_segments(q, UB_MAX_REQ_SG);
         blk_queue_segment_boundary(q, 0xffffffff);      /* Dubious. */
-        blk_queue_max_sectors(q, UB_MAX_SECTORS);
+        blk_queue_max_hw_sectors(q, UB_MAX_SECTORS);
         blk_queue_logical_block_size(q, lun->capacity.bsize);
 
         lun->disk = disk;
diff --git a/drivers/block/viodasd.c b/drivers/block/viodasd.c
index 1b3def1e8591..788d93882ab9 100644
--- a/drivers/block/viodasd.c
+++ b/drivers/block/viodasd.c
@@ -462,9 +462,8 @@ retry:
         }
 
         d->disk = g;
-        blk_queue_max_hw_segments(q, VIOMAXBLOCKDMA);
-        blk_queue_max_phys_segments(q, VIOMAXBLOCKDMA);
-        blk_queue_max_sectors(q, VIODASD_MAXSECTORS);
+        blk_queue_max_segments(q, VIOMAXBLOCKDMA);
+        blk_queue_max_hw_sectors(q, VIODASD_MAXSECTORS);
         g->major = VIODASD_MAJOR;
         g->first_minor = dev_no << PARTITION_SHIFT;
         if (dev_no >= 26)
diff --git a/drivers/block/virtio_blk.c b/drivers/block/virtio_blk.c
index 7eff828b2117..3c64af05fa82 100644
--- a/drivers/block/virtio_blk.c
+++ b/drivers/block/virtio_blk.c
@@ -435,7 +435,7 @@ static void __devexit virtblk_remove(struct virtio_device *vdev)
         kfree(vblk);
 }
 
-static struct virtio_device_id id_table[] = {
+static const struct virtio_device_id id_table[] = {
         { VIRTIO_ID_BLOCK, VIRTIO_DEV_ANY_ID },
         { 0 },
 };
diff --git a/drivers/block/xd.c b/drivers/block/xd.c
index d1fd032e7514..1a325fb05c92 100644
--- a/drivers/block/xd.c
+++ b/drivers/block/xd.c
@@ -242,7 +242,7 @@ static int __init xd_init(void)
         }
 
         /* xd_maxsectors depends on controller - so set after detection */
-        blk_queue_max_sectors(xd_queue, xd_maxsectors);
+        blk_queue_max_hw_sectors(xd_queue, xd_maxsectors);
 
         for (i = 0; i < xd_drives; i++)
                 add_disk(xd_gendisk[i]);
diff --git a/drivers/block/xen-blkfront.c b/drivers/block/xen-blkfront.c
index 05a31e55d278..9c09694b2520 100644
--- a/drivers/block/xen-blkfront.c
+++ b/drivers/block/xen-blkfront.c
@@ -346,15 +346,14 @@ static int xlvbd_init_blk_queue(struct gendisk *gd, u16 sector_size)
 
         /* Hard sector size and max sectors impersonate the equiv. hardware. */
         blk_queue_logical_block_size(rq, sector_size);
-        blk_queue_max_sectors(rq, 512);
+        blk_queue_max_hw_sectors(rq, 512);
 
         /* Each segment in a request is up to an aligned page in size. */
         blk_queue_segment_boundary(rq, PAGE_SIZE - 1);
         blk_queue_max_segment_size(rq, PAGE_SIZE);
 
         /* Ensure a merged request will fit in a single I/O ring slot. */
-        blk_queue_max_phys_segments(rq, BLKIF_MAX_SEGMENTS_PER_REQUEST);
-        blk_queue_max_hw_segments(rq, BLKIF_MAX_SEGMENTS_PER_REQUEST);
+        blk_queue_max_segments(rq, BLKIF_MAX_SEGMENTS_PER_REQUEST);
 
         /* Make sure buffer addresses are sector-aligned. */
         blk_queue_dma_alignment(rq, 511);
@@ -1050,7 +1049,7 @@ static const struct block_device_operations xlvbd_block_fops =
 };
 
 
-static struct xenbus_device_id blkfront_ids[] = {
+static const struct xenbus_device_id blkfront_ids[] = {
         { "vbd" },
         { "" }
 };
diff --git a/drivers/block/xsysace.c b/drivers/block/xsysace.c
index e5c5415eb45e..e1c95e208a66 100644
--- a/drivers/block/xsysace.c
+++ b/drivers/block/xsysace.c
@@ -1227,7 +1227,7 @@ static int __devexit ace_of_remove(struct of_device *op)
 }
 
 /* Match table for of_platform binding */
-static struct of_device_id ace_of_match[] __devinitdata = {
+static const struct of_device_id ace_of_match[] __devinitconst = {
         { .compatible = "xlnx,opb-sysace-1.00.b", },
         { .compatible = "xlnx,opb-sysace-1.00.c", },
         { .compatible = "xlnx,xps-sysace-1.00.a", },
diff --git a/drivers/cdrom/gdrom.c b/drivers/cdrom/gdrom.c
index e789e6c9a422..03c71f7698cb 100644
--- a/drivers/cdrom/gdrom.c
+++ b/drivers/cdrom/gdrom.c
@@ -741,7 +741,7 @@ static int __devinit probe_gdrom_setupqueue(void)
 {
         blk_queue_logical_block_size(gd.gdrom_rq, GDROM_HARD_SECTOR);
         /* using DMA so memory will need to be contiguous */
-        blk_queue_max_hw_segments(gd.gdrom_rq, 1);
+        blk_queue_max_segments(gd.gdrom_rq, 1);
         /* set a large max size to get most from DMA */
         blk_queue_max_segment_size(gd.gdrom_rq, 0x40000);
         gd.disk->queue = gd.gdrom_rq;
diff --git a/drivers/cdrom/viocd.c b/drivers/cdrom/viocd.c
index 57ca69e0ac55..cc435be0bc13 100644
--- a/drivers/cdrom/viocd.c
+++ b/drivers/cdrom/viocd.c
@@ -616,9 +616,8 @@ static int viocd_probe(struct vio_dev *vdev, const struct vio_device_id *id)
         gendisk->first_minor = deviceno;
         strncpy(gendisk->disk_name, c->name,
                         sizeof(gendisk->disk_name));
-        blk_queue_max_hw_segments(q, 1);
-        blk_queue_max_phys_segments(q, 1);
-        blk_queue_max_sectors(q, 4096 / 512);
+        blk_queue_max_segments(q, 1);
+        blk_queue_max_hw_sectors(q, 4096 / 512);
         gendisk->queue = q;
         gendisk->fops = &viocd_fops;
         gendisk->flags = GENHD_FL_CD|GENHD_FL_REMOVABLE;
diff --git a/drivers/firewire/sbp2.c b/drivers/firewire/sbp2.c
index d485cdd8cbac..70fef40cd22f 100644
--- a/drivers/firewire/sbp2.c
+++ b/drivers/firewire/sbp2.c
@@ -1571,7 +1571,7 @@ static int sbp2_scsi_slave_configure(struct scsi_device *sdev)
                 sdev->start_stop_pwr_cond = 1;
 
         if (lu->tgt->workarounds & SBP2_WORKAROUND_128K_MAX_TRANS)
-                blk_queue_max_sectors(sdev->request_queue, 128 * 1024 / 512);
+                blk_queue_max_hw_sectors(sdev->request_queue, 128 * 1024 / 512);
 
         blk_queue_max_segment_size(sdev->request_queue, SBP2_MAX_SEG_SIZE);
 
diff --git a/drivers/ide/ide-disk.c b/drivers/ide/ide-disk.c
index 7f878017b736..3b128dce9c3a 100644
--- a/drivers/ide/ide-disk.c
+++ b/drivers/ide/ide-disk.c
@@ -679,7 +679,7 @@ static void ide_disk_setup(ide_drive_t *drive)
                 if (max_s > hwif->rqsize)
                         max_s = hwif->rqsize;
 
-                blk_queue_max_sectors(q, max_s);
+                blk_queue_max_hw_sectors(q, max_s);
         }
 
         printk(KERN_INFO "%s: max request size: %dKiB\n", drive->name,
diff --git a/drivers/ide/ide-floppy.c b/drivers/ide/ide-floppy.c
index fefbdfc8db06..efd907623469 100644
--- a/drivers/ide/ide-floppy.c
+++ b/drivers/ide/ide-floppy.c
@@ -486,7 +486,7 @@ static void ide_floppy_setup(ide_drive_t *drive)
                 drive->atapi_flags |= IDE_AFLAG_ZIP_DRIVE;
                 /* This value will be visible in the /proc/ide/hdx/settings */
                 drive->pc_delay = IDEFLOPPY_PC_DELAY;
-                blk_queue_max_sectors(drive->queue, 64);
+                blk_queue_max_hw_sectors(drive->queue, 64);
         }
 
         /*
@@ -494,7 +494,7 @@ static void ide_floppy_setup(ide_drive_t *drive)
          * nasty clicking noises without it, so please don't remove this.
          */
         if (strncmp((char *)&id[ATA_ID_PROD], "IOMEGA Clik!", 11) == 0) {
-                blk_queue_max_sectors(drive->queue, 64);
+                blk_queue_max_hw_sectors(drive->queue, 64);
                 drive->atapi_flags |= IDE_AFLAG_CLIK_DRIVE;
                 /* IOMEGA Clik! drives do not support lock/unlock commands */
                 drive->dev_flags &= ~IDE_DFLAG_DOORLOCKING;
diff --git a/drivers/ide/ide-probe.c b/drivers/ide/ide-probe.c
index 4d76ba473097..f8c1ae6ad74c 100644
--- a/drivers/ide/ide-probe.c
+++ b/drivers/ide/ide-probe.c
@@ -774,7 +774,7 @@ static int ide_init_queue(ide_drive_t *drive)
 
         if (hwif->rqsize < max_sectors)
                 max_sectors = hwif->rqsize;
-        blk_queue_max_sectors(q, max_sectors);
+        blk_queue_max_hw_sectors(q, max_sectors);
 
 #ifdef CONFIG_PCI
         /* When we have an IOMMU, we may have a problem where pci_map_sg()
@@ -790,8 +790,7 @@ static int ide_init_queue(ide_drive_t *drive)
                 max_sg_entries >>= 1;
 #endif /* CONFIG_PCI */
 
-        blk_queue_max_hw_segments(q, max_sg_entries);
-        blk_queue_max_phys_segments(q, max_sg_entries);
+        blk_queue_max_segments(q, max_sg_entries);
 
         /* assign drive queue */
         drive->queue = q;
diff --git a/drivers/ieee1394/sbp2.c b/drivers/ieee1394/sbp2.c
index f199896c4113..c88696a6cf8a 100644
--- a/drivers/ieee1394/sbp2.c
+++ b/drivers/ieee1394/sbp2.c
@@ -2020,7 +2020,7 @@ static int sbp2scsi_slave_configure(struct scsi_device *sdev)
         if (lu->workarounds & SBP2_WORKAROUND_POWER_CONDITION)
                 sdev->start_stop_pwr_cond = 1;
         if (lu->workarounds & SBP2_WORKAROUND_128K_MAX_TRANS)
-                blk_queue_max_sectors(sdev->request_queue, 128 * 1024 / 512);
+                blk_queue_max_hw_sectors(sdev->request_queue, 128 * 1024 / 512);
 
         blk_queue_max_segment_size(sdev->request_queue, SBP2_MAX_SEG_SIZE);
         return 0;
diff --git a/drivers/md/linear.c b/drivers/md/linear.c
index 00435bd20699..af2d39d603c7 100644
--- a/drivers/md/linear.c
+++ b/drivers/md/linear.c
@@ -177,7 +177,7 @@ static linear_conf_t *linear_conf(mddev_t *mddev, int raid_disks)
                  */
                 if (rdev->bdev->bd_disk->queue->merge_bvec_fn &&
                     queue_max_sectors(mddev->queue) > (PAGE_SIZE>>9))
-                        blk_queue_max_sectors(mddev->queue, PAGE_SIZE>>9);
+                        blk_queue_max_hw_sectors(mddev->queue, PAGE_SIZE>>9);
 
                 conf->array_sectors += rdev->sectors;
                 cnt++;
diff --git a/drivers/md/multipath.c b/drivers/md/multipath.c
index 32a662fc55c9..4b323f45ad74 100644
--- a/drivers/md/multipath.c
+++ b/drivers/md/multipath.c
@@ -308,7 +308,7 @@ static int multipath_add_disk(mddev_t *mddev, mdk_rdev_t *rdev)
                  */
                         if (q->merge_bvec_fn &&
                             queue_max_sectors(q) > (PAGE_SIZE>>9))
-                                blk_queue_max_sectors(mddev->queue, PAGE_SIZE>>9);
+                                blk_queue_max_hw_sectors(mddev->queue, PAGE_SIZE>>9);
 
                         conf->working_disks++;
                         mddev->degraded--;
@@ -478,7 +478,7 @@ static int multipath_run (mddev_t *mddev)
                  * a merge_bvec_fn to be involved in multipath */
                 if (rdev->bdev->bd_disk->queue->merge_bvec_fn &&
                     queue_max_sectors(mddev->queue) > (PAGE_SIZE>>9))
-                        blk_queue_max_sectors(mddev->queue, PAGE_SIZE>>9);
+                        blk_queue_max_hw_sectors(mddev->queue, PAGE_SIZE>>9);
 
                 if (!test_bit(Faulty, &rdev->flags))
                         conf->working_disks++;
diff --git a/drivers/md/raid0.c b/drivers/md/raid0.c
index 77605cdceaf1..a1f7147b757f 100644
--- a/drivers/md/raid0.c
+++ b/drivers/md/raid0.c
@@ -182,7 +182,7 @@ static int create_strip_zones(mddev_t *mddev)
 
                 if (rdev1->bdev->bd_disk->queue->merge_bvec_fn &&
                     queue_max_sectors(mddev->queue) > (PAGE_SIZE>>9))
-                        blk_queue_max_sectors(mddev->queue, PAGE_SIZE>>9);
+                        blk_queue_max_hw_sectors(mddev->queue, PAGE_SIZE>>9);
 
                 if (!smallest || (rdev1->sectors < smallest->sectors))
                         smallest = rdev1;
@@ -325,7 +325,7 @@ static int raid0_run(mddev_t *mddev)
         }
         if (md_check_no_bitmap(mddev))
                 return -EINVAL;
-        blk_queue_max_sectors(mddev->queue, mddev->chunk_sectors);
+        blk_queue_max_hw_sectors(mddev->queue, mddev->chunk_sectors);
         mddev->queue->queue_lock = &mddev->queue->__queue_lock;
 
         ret = create_strip_zones(mddev);
diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index 859bd3ffe435..5a06122abd3b 100644
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -1158,7 +1158,7 @@ static int raid1_add_disk(mddev_t *mddev, mdk_rdev_t *rdev)
                          */
                         if (rdev->bdev->bd_disk->queue->merge_bvec_fn &&
                             queue_max_sectors(mddev->queue) > (PAGE_SIZE>>9))
-                                blk_queue_max_sectors(mddev->queue, PAGE_SIZE>>9);
+                                blk_queue_max_hw_sectors(mddev->queue, PAGE_SIZE>>9);
 
                         p->head_position = 0;
                         rdev->raid_disk = mirror;
@@ -2103,7 +2103,7 @@ static int run(mddev_t *mddev)
                  */
                 if (rdev->bdev->bd_disk->queue->merge_bvec_fn &&
                     queue_max_sectors(mddev->queue) > (PAGE_SIZE>>9))
-                        blk_queue_max_sectors(mddev->queue, PAGE_SIZE>>9);
+                        blk_queue_max_hw_sectors(mddev->queue, PAGE_SIZE>>9);
         }
 
         mddev->degraded = 0;
diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index d119b7b75e71..7584f9ab9bcf 100644
--- a/drivers/md/raid10.c
+++ b/drivers/md/raid10.c
@@ -1161,7 +1161,7 @@ static int raid10_add_disk(mddev_t *mddev, mdk_rdev_t *rdev)
                          */
                         if (rdev->bdev->bd_disk->queue->merge_bvec_fn &&
                             queue_max_sectors(mddev->queue) > (PAGE_SIZE>>9))
-                                blk_queue_max_sectors(mddev->queue, PAGE_SIZE>>9);
+                                blk_queue_max_hw_sectors(mddev->queue, PAGE_SIZE>>9);
 
                         p->head_position = 0;
                         rdev->raid_disk = mirror;
@@ -2260,7 +2260,7 @@ static int run(mddev_t *mddev)
                  */
                 if (rdev->bdev->bd_disk->queue->merge_bvec_fn &&
                     queue_max_sectors(mddev->queue) > (PAGE_SIZE>>9))
-                        blk_queue_max_sectors(mddev->queue, PAGE_SIZE>>9);
+                        blk_queue_max_hw_sectors(mddev->queue, PAGE_SIZE>>9);
 
                 disk->head_position = 0;
         }
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index ceb24afdc147..509c8f3dd9a5 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -3739,7 +3739,7 @@ static int bio_fits_rdev(struct bio *bi)
         if ((bi->bi_size>>9) > queue_max_sectors(q))
                 return 0;
         blk_recount_segments(q, bi);
-        if (bi->bi_phys_segments > queue_max_phys_segments(q))
+        if (bi->bi_phys_segments > queue_max_segments(q))
                 return 0;
 
         if (q->merge_bvec_fn)
diff --git a/drivers/memstick/core/mspro_block.c b/drivers/memstick/core/mspro_block.c
index bd83fa0a4970..972b87069d55 100644
--- a/drivers/memstick/core/mspro_block.c
+++ b/drivers/memstick/core/mspro_block.c
@@ -1226,9 +1226,8 @@ static int mspro_block_init_disk(struct memstick_dev *card)
         blk_queue_prep_rq(msb->queue, mspro_block_prepare_req);
 
         blk_queue_bounce_limit(msb->queue, limit);
-        blk_queue_max_sectors(msb->queue, MSPRO_BLOCK_MAX_PAGES);
-        blk_queue_max_phys_segments(msb->queue, MSPRO_BLOCK_MAX_SEGS);
-        blk_queue_max_hw_segments(msb->queue, MSPRO_BLOCK_MAX_SEGS);
+        blk_queue_max_hw_sectors(msb->queue, MSPRO_BLOCK_MAX_PAGES);
+        blk_queue_max_segments(msb->queue, MSPRO_BLOCK_MAX_SEGS);
         blk_queue_max_segment_size(msb->queue,
                                    MSPRO_BLOCK_MAX_PAGES * msb->page_size);
 
diff --git a/drivers/message/i2o/i2o_block.c b/drivers/message/i2o/i2o_block.c
index e39986a78273..2658b1484a2c 100644
--- a/drivers/message/i2o/i2o_block.c
+++ b/drivers/message/i2o/i2o_block.c
@@ -1065,9 +1065,8 @@ static int i2o_block_probe(struct device *dev)
         queue = gd->queue;
         queue->queuedata = i2o_blk_dev;
 
-        blk_queue_max_phys_segments(queue, I2O_MAX_PHYS_SEGMENTS);
-        blk_queue_max_sectors(queue, max_sectors);
-        blk_queue_max_hw_segments(queue, i2o_sg_tablesize(c, body_size));
+        blk_queue_max_hw_sectors(queue, max_sectors);
+        blk_queue_max_segments(queue, i2o_sg_tablesize(c, body_size));
 
         osm_debug("max sectors = %d\n", queue->max_sectors);
         osm_debug("phys segments = %d\n", queue->max_phys_segments);
diff --git a/drivers/mmc/card/queue.c b/drivers/mmc/card/queue.c
index c5a7a855f4b1..381fe032caa1 100644
--- a/drivers/mmc/card/queue.c
+++ b/drivers/mmc/card/queue.c
@@ -154,9 +154,8 @@ int mmc_init_queue(struct mmc_queue *mq, struct mmc_card *card, spinlock_t *lock
 
                 if (mq->bounce_buf) {
                         blk_queue_bounce_limit(mq->queue, BLK_BOUNCE_ANY);
-                        blk_queue_max_sectors(mq->queue, bouncesz / 512);
-                        blk_queue_max_phys_segments(mq->queue, bouncesz / 512);
-                        blk_queue_max_hw_segments(mq->queue, bouncesz / 512);
+                        blk_queue_max_hw_sectors(mq->queue, bouncesz / 512);
+                        blk_queue_max_segments(mq->queue, bouncesz / 512);
                         blk_queue_max_segment_size(mq->queue, bouncesz);
 
                         mq->sg = kmalloc(sizeof(struct scatterlist),
@@ -180,10 +179,9 @@ int mmc_init_queue(struct mmc_queue *mq, struct mmc_card *card, spinlock_t *lock
 
         if (!mq->bounce_buf) {
                 blk_queue_bounce_limit(mq->queue, limit);
-                blk_queue_max_sectors(mq->queue,
+                blk_queue_max_hw_sectors(mq->queue,
                         min(host->max_blk_count, host->max_req_size / 512));
-                blk_queue_max_phys_segments(mq->queue, host->max_phys_segs);
-                blk_queue_max_hw_segments(mq->queue, host->max_hw_segs);
+                blk_queue_max_segments(mq->queue, host->max_hw_segs);
                 blk_queue_max_segment_size(mq->queue, host->max_seg_size);
 
                 mq->sg = kmalloc(sizeof(struct scatterlist) *
diff --git a/drivers/s390/block/dasd.c b/drivers/s390/block/dasd.c
index 9ab1ae40565f..4951aa82e9f5 100644
--- a/drivers/s390/block/dasd.c
+++ b/drivers/s390/block/dasd.c
@@ -2139,9 +2139,8 @@ static void dasd_setup_queue(struct dasd_block *block)
 
         blk_queue_logical_block_size(block->request_queue, block->bp_block);
         max = block->base->discipline->max_blocks << block->s2b_shift;
-        blk_queue_max_sectors(block->request_queue, max);
-        blk_queue_max_phys_segments(block->request_queue, -1L);
-        blk_queue_max_hw_segments(block->request_queue, -1L);
+        blk_queue_max_hw_sectors(block->request_queue, max);
+        blk_queue_max_segments(block->request_queue, -1L);
         /* with page sized segments we can translate each segement into
          * one idaw/tidaw
          */
diff --git a/drivers/s390/char/tape_block.c b/drivers/s390/char/tape_block.c
index 8d3d720737da..097da8ce6be6 100644
--- a/drivers/s390/char/tape_block.c
+++ b/drivers/s390/char/tape_block.c
@@ -222,9 +222,8 @@ tapeblock_setup_device(struct tape_device * device)
                 goto cleanup_queue;
 
         blk_queue_logical_block_size(blkdat->request_queue, TAPEBLOCK_HSEC_SIZE);
-        blk_queue_max_sectors(blkdat->request_queue, TAPEBLOCK_MAX_SEC);
-        blk_queue_max_phys_segments(blkdat->request_queue, -1L);
-        blk_queue_max_hw_segments(blkdat->request_queue, -1L);
+        blk_queue_max_hw_sectors(blkdat->request_queue, TAPEBLOCK_MAX_SEC);
+        blk_queue_max_segments(blkdat->request_queue, -1L);
         blk_queue_max_segment_size(blkdat->request_queue, -1L);
         blk_queue_segment_boundary(blkdat->request_queue, -1L);
 
diff --git a/drivers/scsi/ibmvscsi/ibmvfc.c b/drivers/scsi/ibmvscsi/ibmvfc.c
index 87b536a97cb4..732f6d35b4a8 100644
--- a/drivers/scsi/ibmvscsi/ibmvfc.c
+++ b/drivers/scsi/ibmvscsi/ibmvfc.c
@@ -4195,7 +4195,7 @@ static void ibmvfc_tgt_add_rport(struct ibmvfc_target *tgt)
                 if (tgt->service_parms.class3_parms[0] & 0x80000000)
                         rport->supported_classes |= FC_COS_CLASS3;
                 if (rport->rqst_q)
-                        blk_queue_max_hw_segments(rport->rqst_q, 1);
+                        blk_queue_max_segments(rport->rqst_q, 1);
         } else
                 tgt_dbg(tgt, "rport add failed\n");
         spin_unlock_irqrestore(vhost->host->host_lock, flags);
@@ -4669,7 +4669,7 @@ static int ibmvfc_probe(struct vio_dev *vdev, const struct vio_device_id *id)
         }
 
         if (shost_to_fc_host(shost)->rqst_q)
-                blk_queue_max_hw_segments(shost_to_fc_host(shost)->rqst_q, 1);
+                blk_queue_max_segments(shost_to_fc_host(shost)->rqst_q, 1);
         dev_set_drvdata(dev, vhost);
         spin_lock(&ibmvfc_driver_lock);
         list_add_tail(&vhost->queue, &ibmvfc_head);
diff --git a/drivers/scsi/ipr.c b/drivers/scsi/ipr.c
index 9e52d16c7c39..032f0d0e6cb4 100644
--- a/drivers/scsi/ipr.c
+++ b/drivers/scsi/ipr.c
@@ -3674,7 +3674,7 @@ static int ipr_slave_configure(struct scsi_device *sdev)
                 if (ipr_is_vset_device(res)) {
                         blk_queue_rq_timeout(sdev->request_queue,
                                              IPR_VSET_RW_TIMEOUT);
-                        blk_queue_max_sectors(sdev->request_queue, IPR_VSET_MAX_SECTORS);
+                        blk_queue_max_hw_sectors(sdev->request_queue, IPR_VSET_MAX_SECTORS);
                 }
                 if (ipr_is_vset_device(res) || ipr_is_scsi_disk(res))
                         sdev->allow_restart = 1;
diff --git a/drivers/scsi/pmcraid.c b/drivers/scsi/pmcraid.c
index b6f1ef954af1..9b1c1433c26b 100644
--- a/drivers/scsi/pmcraid.c
+++ b/drivers/scsi/pmcraid.c
@@ -235,7 +235,7 @@ static int pmcraid_slave_configure(struct scsi_device *scsi_dev)
                 scsi_dev->allow_restart = 1;
                 blk_queue_rq_timeout(scsi_dev->request_queue,
                                      PMCRAID_VSET_IO_TIMEOUT);
-                blk_queue_max_sectors(scsi_dev->request_queue,
+                blk_queue_max_hw_sectors(scsi_dev->request_queue,
                                       PMCRAID_VSET_MAX_SECTORS);
         }
 
diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index 56977097de9f..1646fe7cbd4b 100644
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -1630,10 +1630,10 @@ struct request_queue *__scsi_alloc_queue(struct Scsi_Host *shost,
         /*
          * this limit is imposed by hardware restrictions
          */
-        blk_queue_max_hw_segments(q, shost->sg_tablesize);
-        blk_queue_max_phys_segments(q, SCSI_MAX_SG_CHAIN_SEGMENTS);
+        blk_queue_max_segments(q, min_t(unsigned short, shost->sg_tablesize,
+                                        SCSI_MAX_SG_CHAIN_SEGMENTS));
 
-        blk_queue_max_sectors(q, shost->max_sectors);
+        blk_queue_max_hw_sectors(q, shost->max_sectors);
         blk_queue_bounce_limit(q, scsi_calculate_bounce_limit(shost));
         blk_queue_segment_boundary(q, shost->dma_boundary);
         dma_set_seg_boundary(dev, shost->dma_boundary);
diff --git a/drivers/scsi/scsi_scan.c b/drivers/scsi/scsi_scan.c
index f697229ae5a9..4bc8b77a2ef3 100644
--- a/drivers/scsi/scsi_scan.c
+++ b/drivers/scsi/scsi_scan.c
@@ -879,7 +879,7 @@ static int scsi_add_lun(struct scsi_device *sdev, unsigned char *inq_result,
          * broken RA4x00 Compaq Disk Array
          */
         if (*bflags & BLIST_MAX_512)
-                blk_queue_max_sectors(sdev->request_queue, 512);
+                blk_queue_max_hw_sectors(sdev->request_queue, 512);
 
         /*
          * Some devices may not want to have a start command automatically
diff --git a/drivers/scsi/sg.c b/drivers/scsi/sg.c
index 040f751809ea..c996d98636f3 100644
--- a/drivers/scsi/sg.c
+++ b/drivers/scsi/sg.c
@@ -287,8 +287,7 @@ sg_open(struct inode *inode, struct file *filp)
         if (list_empty(&sdp->sfds)) {   /* no existing opens on this device */
                 sdp->sgdebug = 0;
                 q = sdp->device->request_queue;
-                sdp->sg_tablesize = min(queue_max_hw_segments(q),
-                                        queue_max_phys_segments(q));
+                sdp->sg_tablesize = queue_max_segments(q);
         }
         if ((sfp = sg_add_sfp(sdp, dev)))
                 filp->private_data = sfp;
@@ -1376,8 +1375,7 @@ static Sg_device *sg_alloc(struct gendisk *disk, struct scsi_device *scsidp)
         sdp->device = scsidp;
         INIT_LIST_HEAD(&sdp->sfds);
         init_waitqueue_head(&sdp->o_excl_wait);
-        sdp->sg_tablesize = min(queue_max_hw_segments(q),
-                                queue_max_phys_segments(q));
+        sdp->sg_tablesize = queue_max_segments(q);
         sdp->index = k;
         kref_init(&sdp->d_ref);
 
diff --git a/drivers/scsi/st.c b/drivers/scsi/st.c
index d04ea9a6f673..f67d1a159aad 100644
--- a/drivers/scsi/st.c
+++ b/drivers/scsi/st.c
@@ -3983,8 +3983,7 @@ static int st_probe(struct device *dev)
                 return -ENODEV;
         }
 
-        i = min(queue_max_hw_segments(SDp->request_queue),
-                queue_max_phys_segments(SDp->request_queue));
+        i = queue_max_segments(SDp->request_queue);
         if (st_max_sg_segs < i)
                 i = st_max_sg_segs;
         buffer = new_tape_buffer((SDp->host)->unchecked_isa_dma, i);
diff --git a/drivers/staging/hv/blkvsc_drv.c b/drivers/staging/hv/blkvsc_drv.c
index 62b282844a53..45d908114d11 100644
--- a/drivers/staging/hv/blkvsc_drv.c
+++ b/drivers/staging/hv/blkvsc_drv.c
@@ -363,10 +363,7 @@ static int blkvsc_probe(struct device *device)
         blkdev->gd->queue = blk_init_queue(blkvsc_request, &blkdev->lock);
 
         blk_queue_max_segment_size(blkdev->gd->queue, PAGE_SIZE);
-        blk_queue_max_phys_segments(blkdev->gd->queue,
-                                    MAX_MULTIPAGE_BUFFER_COUNT);
-        blk_queue_max_hw_segments(blkdev->gd->queue,
-                                  MAX_MULTIPAGE_BUFFER_COUNT);
+        blk_queue_max_segments(blkdev->gd->queue, MAX_MULTIPAGE_BUFFER_COUNT);
         blk_queue_segment_boundary(blkdev->gd->queue, PAGE_SIZE-1);
         blk_queue_bounce_limit(blkdev->gd->queue, BLK_BOUNCE_ANY);
         blk_queue_dma_alignment(blkdev->gd->queue, 511);
diff --git a/drivers/usb/storage/scsiglue.c b/drivers/usb/storage/scsiglue.c
index e5e6df39e737..aadc16b5eed7 100644
--- a/drivers/usb/storage/scsiglue.c
+++ b/drivers/usb/storage/scsiglue.c
@@ -134,14 +134,14 @@ static int slave_configure(struct scsi_device *sdev)
                 if (us->fflags & US_FL_MAX_SECTORS_MIN)
                         max_sectors = PAGE_CACHE_SIZE >> 9;
                 if (queue_max_sectors(sdev->request_queue) > max_sectors)
-                        blk_queue_max_sectors(sdev->request_queue,
+                        blk_queue_max_hw_sectors(sdev->request_queue,
                                               max_sectors);
         } else if (sdev->type == TYPE_TAPE) {
                 /* Tapes need much higher max_sector limits, so just
                  * raise it to the maximum possible (4 GB / 512) and
                  * let the queue segment size sort out the real limit.
                  */
-                blk_queue_max_sectors(sdev->request_queue, 0x7FFFFF);
+                blk_queue_max_hw_sectors(sdev->request_queue, 0x7FFFFF);
         }
 
         /* Some USB host controllers can't do DMA; they have to use PIO.
@@ -495,7 +495,7 @@ static ssize_t store_max_sectors(struct device *dev, struct device_attribute *at
         unsigned short ms;
 
         if (sscanf(buf, "%hu", &ms) > 0 && ms <= SCSI_DEFAULT_MAX_SECTORS) {
-                blk_queue_max_sectors(sdev->request_queue, ms);
+                blk_queue_max_hw_sectors(sdev->request_queue, ms);
                 return strlen(buf);
         }
         return -EINVAL;