34 files changed, 1624 insertions, 1247 deletions
diff --git a/drivers/block/DAC960.c b/drivers/block/DAC960.c
index f22ed6cc69f2..668dc234b8e2 100644
--- a/drivers/block/DAC960.c
+++ b/drivers/block/DAC960.c
@@ -3321,7 +3321,7 @@ static int DAC960_process_queue(DAC960_Controller_T *Controller, struct request_
        DAC960_Command_T *Command;
   while(1) {
-        Request = elv_next_request(req_q);
+        Request = blk_peek_request(req_q);
        if (!Request)
                return 1;
@@ -3338,10 +3338,10 @@ static int DAC960_process_queue(DAC960_Controller_T *Controller, struct request_
        }
        Command->Completion = Request->end_io_data;
        Command->LogicalDriveNumber = (long)Request->rq_disk->private_data;
-        Command->BlockNumber = Request->sector;
+        Command->BlockNumber = blk_rq_pos(Request);
-        Command->BlockCount = Request->nr_sectors;
+        Command->BlockCount = blk_rq_sectors(Request);
        Command->Request = Request;
-        blkdev_dequeue_request(Request);
+        blk_start_request(Request);
        Command->SegmentCount = blk_rq_map_sg(req_q,
                  Command->Request, Command->cmd_sglist);
        /* pci_map_sg MAY change the value of SegCount */
@@ -3431,7 +3431,7 @@ static void DAC960_queue_partial_rw(DAC960_Command_T *Command)
   * successfully as possible.
   */
  Command->SegmentCount = 1;
-  Command->BlockNumber = Request->sector;
+  Command->BlockNumber = blk_rq_pos(Request);
  Command->BlockCount = 1;
  DAC960_QueueReadWriteCommand(Command);
  return;
diff --git a/drivers/block/Kconfig b/drivers/block/Kconfig
index ddea8e485cc9..bb72ada9f074 100644
--- a/drivers/block/Kconfig
+++ b/drivers/block/Kconfig
@@ -112,7 +112,7 @@ config GDROM
          with up to 1 GB of data. This drive will also read standard CD ROM
          disks. Select this option to access any disks in your GD ROM drive.
          Most users will want to say "Y" here.
-          You can also build this as a module which will be called gdrom.ko
+          You can also build this as a module which will be called gdrom.
 source "drivers/block/paride/Kconfig"
@@ -412,7 +412,7 @@ config ATA_OVER_ETH
 config MG_DISK
        tristate "mGine mflash, gflash support"
-        depends on ARM && ATA && GPIOLIB
+        depends on ARM && GPIOLIB
        help
          mGine mFlash(gFlash) block device driver
@@ -438,7 +438,7 @@ source "drivers/s390/block/Kconfig"
 config XILINX_SYSACE
        tristate "Xilinx SystemACE support"
-        depends on 4xx
+        depends on 4xx || MICROBLAZE
        help
          Include support for the Xilinx SystemACE CompactFlash interface
diff --git a/drivers/block/amiflop.c b/drivers/block/amiflop.c
index 8df436ff7068..9c6e5b0fe894 100644
--- a/drivers/block/amiflop.c
+++ b/drivers/block/amiflop.c
@@ -112,8 +112,6 @@ module_param(fd_def_df0, ulong, 0);
 MODULE_LICENSE("GPL");
 static struct request_queue *floppy_queue;
-#define QUEUE (floppy_queue)
-#define CURRENT elv_next_request(floppy_queue)
 /*
 *  Macros
@@ -1335,64 +1333,60 @@ static int get_track(int drive, int track)
 static void redo_fd_request(void)
 {
+        struct request *rq;
        unsigned int cnt, block, track, sector;
        int drive;
        struct amiga_floppy_struct *floppy;
        char *data;
        unsigned long flags;
+        int err;
- repeat:
+next_req:
-        if (!CURRENT) {
+        rq = blk_fetch_request(floppy_queue);
+        if (!rq) {
                /* Nothing left to do */
                return;
        }
-        floppy = CURRENT->rq_disk->private_data;
+        floppy = rq->rq_disk->private_data;
        drive = floppy - unit;
+next_segment:
        /* Here someone could investigate to be more efficient */
-        for (cnt = 0; cnt < CURRENT->current_nr_sectors; cnt++) { 
+        for (cnt = 0, err = 0; cnt < blk_rq_cur_sectors(rq); cnt++) {
 #ifdef DEBUG
                printk("fd: sector %ld + %d requested for %s\n",
-                       CURRENT->sector,cnt,
+                       blk_rq_pos(rq), cnt,
-                       (rq_data_dir(CURRENT) == READ) ? "read" : "write");
+                       (rq_data_dir(rq) == READ) ? "read" : "write");
 #endif
-                block = CURRENT->sector + cnt;
+                block = blk_rq_pos(rq) + cnt;
                if ((int)block > floppy->blocks) {
-                        end_request(CURRENT, 0);
+                        err = -EIO;
-                        goto repeat;
+                        break;
                }
                track = block / (floppy->dtype->sects * floppy->type->sect_mult);
                sector = block % (floppy->dtype->sects * floppy->type->sect_mult);
-                data = CURRENT->buffer + 512 * cnt;
+                data = rq->buffer + 512 * cnt;
 #ifdef DEBUG
                printk("access to track %d, sector %d, with buffer at "
                       "0x%08lx\n", track, sector, data);
 #endif
-                if ((rq_data_dir(CURRENT) != READ) && (rq_data_dir(CURRENT) != WRITE)) {
-                        printk(KERN_WARNING "do_fd_request: unknown command\n");
-                        end_request(CURRENT, 0);
-                        goto repeat;
-                }
                if (get_track(drive, track) == -1) {
-                        end_request(CURRENT, 0);
+                        err = -EIO;
-                        goto repeat;
+                        break;
                }
-                switch (rq_data_dir(CURRENT)) {
+                if (rq_data_dir(rq) == READ) {
-                case READ:
                        memcpy(data, floppy->trackbuf + sector * 512, 512);
-                        break;
+                } else {
-                case WRITE:
                        memcpy(floppy->trackbuf + sector * 512, data, 512);
                        /* keep the drive spinning while writes are scheduled */
                        if (!fd_motor_on(drive)) {
-                                end_request(CURRENT, 0);
+                                err = -EIO;
-                                goto repeat;
+                                break;
                        }
                        /*
                         * setup a callback to write the track buffer
@@ -1404,14 +1398,12 @@ static void redo_fd_request(void)
                        /* reset the timer */
                        mod_timer (flush_track_timer + drive, jiffies + 1);
                        local_irq_restore(flags);
-                        break;
                }
        }
-        CURRENT->nr_sectors -= CURRENT->current_nr_sectors;
-        CURRENT->sector += CURRENT->current_nr_sectors;
-        end_request(CURRENT, 1);
+        if (__blk_end_request_cur(rq, err))
-        goto repeat;
+                goto next_segment;
+        goto next_req;
 }
 static void do_fd_request(struct request_queue * q)
diff --git a/drivers/block/aoe/aoechr.c b/drivers/block/aoe/aoechr.c
index 200efc4d2c1e..19888354188f 100644
--- a/drivers/block/aoe/aoechr.c
+++ b/drivers/block/aoe/aoechr.c
@@ -266,6 +266,11 @@ static const struct file_operations aoe_fops = {
        .owner = THIS_MODULE,
 };
+static char *aoe_nodename(struct device *dev)
+{
+        return kasprintf(GFP_KERNEL, "etherd/%s", dev_name(dev));
+}
 int __init
 aoechr_init(void)
 {
@@ -283,6 +288,8 @@ aoechr_init(void)
                unregister_chrdev(AOE_MAJOR, "aoechr");
                return PTR_ERR(aoe_class);
        }
+        aoe_class->nodename = aoe_nodename;
        for (i = 0; i < ARRAY_SIZE(chardevs); ++i)
                device_create(aoe_class, NULL,
                              MKDEV(AOE_MAJOR, chardevs[i].minor), NULL,
diff --git a/drivers/block/aoe/aoecmd.c b/drivers/block/aoe/aoecmd.c
index 31693bc24444..965ece2c7e4d 100644
--- a/drivers/block/aoe/aoecmd.c
+++ b/drivers/block/aoe/aoecmd.c
@@ -34,13 +34,6 @@ new_skb(ulong len)
                skb_reset_mac_header(skb);
                skb_reset_network_header(skb);
                skb->protocol = __constant_htons(ETH_P_AOE);
-                skb->priority = 0;
-                skb->next = skb->prev = NULL;
-                /* tell the network layer not to perform IP checksums
-                 * or to get the NIC to do it
-                 */
-                skb->ip_summed = CHECKSUM_NONE;
        }
        return skb;
 }
diff --git a/drivers/block/ataflop.c b/drivers/block/ataflop.c
index 4234c11c1e4c..f5e7180d7f47 100644
--- a/drivers/block/ataflop.c
+++ b/drivers/block/ataflop.c
@@ -79,9 +79,7 @@
 #undef DEBUG
 static struct request_queue *floppy_queue;
+static struct request *fd_request;
-#define QUEUE (floppy_queue)
-#define CURRENT elv_next_request(floppy_queue)
 /* Disk types: DD, HD, ED */
 static struct atari_disk_type {
@@ -376,6 +374,12 @@ static DEFINE_TIMER(readtrack_timer, fd_readtrack_check, 0, 0);
 static DEFINE_TIMER(timeout_timer, fd_times_out, 0, 0);
 static DEFINE_TIMER(fd_timer, check_change, 0, 0);
        
+static void fd_end_request_cur(int err)
+{
+        if (!__blk_end_request_cur(fd_request, err))
+                fd_request = NULL;
+}
 static inline void start_motor_off_timer(void)
 {
        mod_timer(&motor_off_timer, jiffies + FD_MOTOR_OFF_DELAY);
@@ -606,15 +610,15 @@ static void fd_error( void )
                return;
        }
-        if (!CURRENT)
+        if (!fd_request)
                return;
-        CURRENT->errors++;
+        fd_request->errors++;
-        if (CURRENT->errors >= MAX_ERRORS) {
+        if (fd_request->errors >= MAX_ERRORS) {
                printk(KERN_ERR "fd%d: too many errors.\n", SelectedDrive );
-                end_request(CURRENT, 0);
+                fd_end_request_cur(-EIO);
        }
-        else if (CURRENT->errors == RECALIBRATE_ERRORS) {
+        else if (fd_request->errors == RECALIBRATE_ERRORS) {
                printk(KERN_WARNING "fd%d: recalibrating\n", SelectedDrive );
                if (SelectedDrive != -1)
                        SUD.track = -1;
@@ -725,16 +729,14 @@ static void do_fd_action( int drive )
            if (IS_BUFFERED( drive, ReqSide, ReqTrack )) {
                if (ReqCmd == READ) {
                    copy_buffer( SECTOR_BUFFER(ReqSector), ReqData );
-                    if (++ReqCnt < CURRENT->current_nr_sectors) {
+                    if (++ReqCnt < blk_rq_cur_sectors(fd_request)) {
                        /* read next sector */
                        setup_req_params( drive );
                        goto repeat;
                    }
                    else {
                        /* all sectors finished */
-                        CURRENT->nr_sectors -= CURRENT->current_nr_sectors;
+                        fd_end_request_cur(0);
-                        CURRENT->sector += CURRENT->current_nr_sectors;
-                        end_request(CURRENT, 1);
                        redo_fd_request();
                        return;
                    }
@@ -1132,16 +1134,14 @@ static void fd_rwsec_done1(int status)
                }
        }
  
-        if (++ReqCnt < CURRENT->current_nr_sectors) {
+        if (++ReqCnt < blk_rq_cur_sectors(fd_request)) {
                /* read next sector */
                setup_req_params( SelectedDrive );
                do_fd_action( SelectedDrive );
        }
        else {
                /* all sectors finished */
-                CURRENT->nr_sectors -= CURRENT->current_nr_sectors;
+                fd_end_request_cur(0);
-                CURRENT->sector += CURRENT->current_nr_sectors;
-                end_request(CURRENT, 1);
                redo_fd_request();
        }
        return;
@@ -1382,7 +1382,7 @@ static void setup_req_params( int drive )
        ReqData = ReqBuffer + 512 * ReqCnt;
        if (UseTrackbuffer)
-                read_track = (ReqCmd == READ && CURRENT->errors == 0);
+                read_track = (ReqCmd == READ && fd_request->errors == 0);
        else
                read_track = 0;
@@ -1396,25 +1396,27 @@ static void redo_fd_request(void)
        int drive, type;
        struct atari_floppy_struct *floppy;
-        DPRINT(("redo_fd_request: CURRENT=%p dev=%s CURRENT->sector=%ld\n",
+        DPRINT(("redo_fd_request: fd_request=%p dev=%s fd_request->sector=%ld\n",
-                CURRENT, CURRENT ? CURRENT->rq_disk->disk_name : "",
+                fd_request, fd_request ? fd_request->rq_disk->disk_name : "",
-                CURRENT ? CURRENT->sector : 0 ));
+                fd_request ? blk_rq_pos(fd_request) : 0 ));
        IsFormatting = 0;
 repeat:
+        if (!fd_request) {
+                fd_request = blk_fetch_request(floppy_queue);
+                if (!fd_request)
+                        goto the_end;
+        }
-        if (!CURRENT)
+        floppy = fd_request->rq_disk->private_data;
-                goto the_end;
-        floppy = CURRENT->rq_disk->private_data;
        drive = floppy - unit;
        type = floppy->type;
        
        if (!UD.connected) {
                /* drive not connected */
                printk(KERN_ERR "Unknown Device: fd%d\n", drive );
-                end_request(CURRENT, 0);
+                fd_end_request_cur(-EIO);
                goto repeat;
        }
                
@@ -1430,12 +1432,12 @@ repeat:
                /* user supplied disk type */
                if (--type >= NUM_DISK_MINORS) {
                        printk(KERN_WARNING "fd%d: invalid disk format", drive );
-                        end_request(CURRENT, 0);
+                        fd_end_request_cur(-EIO);
                        goto repeat;
                }
                if (minor2disktype[type].drive_types > DriveType)  {
                        printk(KERN_WARNING "fd%d: unsupported disk format", drive );
-                        end_request(CURRENT, 0);
+                        fd_end_request_cur(-EIO);
                        goto repeat;
                }
                type = minor2disktype[type].index;
@@ -1444,8 +1446,8 @@ repeat:
                UD.autoprobe = 0;
        }
        
-        if (CURRENT->sector + 1 > UDT->blocks) {
+        if (blk_rq_pos(fd_request) + 1 > UDT->blocks) {
-                end_request(CURRENT, 0);
+                fd_end_request_cur(-EIO);
                goto repeat;
        }
@@ -1453,9 +1455,9 @@ repeat:
        del_timer( &motor_off_timer );
                
        ReqCnt = 0;
-        ReqCmd = rq_data_dir(CURRENT);
+        ReqCmd = rq_data_dir(fd_request);
-        ReqBlock = CURRENT->sector;
+        ReqBlock = blk_rq_pos(fd_request);
-        ReqBuffer = CURRENT->buffer;
+        ReqBuffer = fd_request->buffer;
        setup_req_params( drive );
        do_fd_action( drive );
diff --git a/drivers/block/brd.c b/drivers/block/brd.c
index 5f7e64ba87e5..4bf8705b3ace 100644
--- a/drivers/block/brd.c
+++ b/drivers/block/brd.c
@@ -407,12 +407,7 @@ static int __init ramdisk_size(char *str)
        rd_size = simple_strtol(str, NULL, 0);
        return 1;
 }
-static int __init ramdisk_size2(char *str)
+__setup("ramdisk_size=", ramdisk_size);
-{
-        return ramdisk_size(str);
-}
-__setup("ramdisk=", ramdisk_size);
-__setup("ramdisk_size=", ramdisk_size2);
 #endif
 /*
diff --git a/drivers/block/cciss.c b/drivers/block/cciss.c
index 4d4d5e0d3fa6..c7a527c08a09 100644
--- a/drivers/block/cciss.c
+++ b/drivers/block/cciss.c
@@ -38,7 +38,6 @@
 #include <linux/hdreg.h>
 #include <linux/spinlock.h>
 #include <linux/compat.h>
-#include <linux/blktrace_api.h>
 #include <asm/uaccess.h>
 #include <asm/io.h>
@@ -180,11 +179,13 @@ static void __devinit cciss_interrupt_mode(ctlr_info_t *, struct pci_dev *,
                                           __u32);
 static void start_io(ctlr_info_t *h);
 static int sendcmd(__u8 cmd, int ctlr, void *buff, size_t size,
-                   unsigned int use_unit_num, unsigned int log_unit,
                   __u8 page_code, unsigned char *scsi3addr, int cmd_type);
 static int sendcmd_withirq(__u8 cmd, int ctlr, void *buff, size_t size,
-                           unsigned int use_unit_num, unsigned int log_unit,
+                        __u8 page_code, unsigned char scsi3addr[],
-                           __u8 page_code, int cmd_type);
+                        int cmd_type);
+static int sendcmd_withirq_core(ctlr_info_t *h, CommandList_struct *c,
+        int attempt_retry);
+static int process_sendcmd_error(ctlr_info_t *h, CommandList_struct *c);
 static void fail_all_cmds(unsigned long ctlr);
 static int scan_thread(void *data);
@@ -437,6 +438,194 @@ static void __devinit cciss_procinit(int i)
 }
 #endif                          /* CONFIG_PROC_FS */
+#define MAX_PRODUCT_NAME_LEN 19
+#define to_hba(n) container_of(n, struct ctlr_info, dev)
+#define to_drv(n) container_of(n, drive_info_struct, dev)
+static struct device_type cciss_host_type = {
+        .name           = "cciss_host",
+};
+static ssize_t dev_show_unique_id(struct device *dev,
+                                 struct device_attribute *attr,
+                                 char *buf)
+{
+        drive_info_struct *drv = to_drv(dev);
+        struct ctlr_info *h = to_hba(drv->dev.parent);
+        __u8 sn[16];
+        unsigned long flags;
+        int ret = 0;
+        spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
+        if (h->busy_configuring)
+                ret = -EBUSY;
+        else
+                memcpy(sn, drv->serial_no, sizeof(sn));
+        spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
+        if (ret)
+                return ret;
+        else
+                return snprintf(buf, 16 * 2 + 2,
+                                "%02X%02X%02X%02X%02X%02X%02X%02X"
+                                "%02X%02X%02X%02X%02X%02X%02X%02X\n",
+                                sn[0], sn[1], sn[2], sn[3],
+                                sn[4], sn[5], sn[6], sn[7],
+                                sn[8], sn[9], sn[10], sn[11],
+                                sn[12], sn[13], sn[14], sn[15]);
+}
+DEVICE_ATTR(unique_id, S_IRUGO, dev_show_unique_id, NULL);
+static ssize_t dev_show_vendor(struct device *dev,
+                               struct device_attribute *attr,
+                               char *buf)
+{
+        drive_info_struct *drv = to_drv(dev);
+        struct ctlr_info *h = to_hba(drv->dev.parent);
+        char vendor[VENDOR_LEN + 1];
+        unsigned long flags;
+        int ret = 0;
+        spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
+        if (h->busy_configuring)
+                ret = -EBUSY;
+        else
+                memcpy(vendor, drv->vendor, VENDOR_LEN + 1);
+        spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
+        if (ret)
+                return ret;
+        else
+                return snprintf(buf, sizeof(vendor) + 1, "%s\n", drv->vendor);
+}
+DEVICE_ATTR(vendor, S_IRUGO, dev_show_vendor, NULL);
+static ssize_t dev_show_model(struct device *dev,
+                              struct device_attribute *attr,
+                              char *buf)
+{
+        drive_info_struct *drv = to_drv(dev);
+        struct ctlr_info *h = to_hba(drv->dev.parent);
+        char model[MODEL_LEN + 1];
+        unsigned long flags;
+        int ret = 0;
+        spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
+        if (h->busy_configuring)
+                ret = -EBUSY;
+        else
+                memcpy(model, drv->model, MODEL_LEN + 1);
+        spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
+        if (ret)
+                return ret;
+        else
+                return snprintf(buf, sizeof(model) + 1, "%s\n", drv->model);
+}
+DEVICE_ATTR(model, S_IRUGO, dev_show_model, NULL);
+static ssize_t dev_show_rev(struct device *dev,
+                            struct device_attribute *attr,
+                            char *buf)
+{
+        drive_info_struct *drv = to_drv(dev);
+        struct ctlr_info *h = to_hba(drv->dev.parent);
+        char rev[REV_LEN + 1];
+        unsigned long flags;
+        int ret = 0;
+        spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
+        if (h->busy_configuring)
+                ret = -EBUSY;
+        else
+                memcpy(rev, drv->rev, REV_LEN + 1);
+        spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
+        if (ret)
+                return ret;
+        else
+                return snprintf(buf, sizeof(rev) + 1, "%s\n", drv->rev);
+}
+DEVICE_ATTR(rev, S_IRUGO, dev_show_rev, NULL);
+static struct attribute *cciss_dev_attrs[] = {
+        &dev_attr_unique_id.attr,
+        &dev_attr_model.attr,
+        &dev_attr_vendor.attr,
+        &dev_attr_rev.attr,
+        NULL
+};
+static struct attribute_group cciss_dev_attr_group = {
+        .attrs = cciss_dev_attrs,
+};
+static struct attribute_group *cciss_dev_attr_groups[] = {
+        &cciss_dev_attr_group,
+        NULL
+};
+static struct device_type cciss_dev_type = {
+        .name           = "cciss_device",
+        .groups         = cciss_dev_attr_groups,
+};
+static struct bus_type cciss_bus_type = {
+        .name           = "cciss",
+};
+/*
+ * Initialize sysfs entry for each controller.  This sets up and registers
+ * the 'cciss#' directory for each individual controller under
+ * /sys/bus/pci/devices/<dev>/.
+ */
+static int cciss_create_hba_sysfs_entry(struct ctlr_info *h)
+{
+        device_initialize(&h->dev);
+        h->dev.type = &cciss_host_type;
+        h->dev.bus = &cciss_bus_type;
+        dev_set_name(&h->dev, "%s", h->devname);
+        h->dev.parent = &h->pdev->dev;
+        return device_add(&h->dev);
+}
+/*
+ * Remove sysfs entries for an hba.
+ */
+static void cciss_destroy_hba_sysfs_entry(struct ctlr_info *h)
+{
+        device_del(&h->dev);
+}
+/*
+ * Initialize sysfs for each logical drive.  This sets up and registers
+ * the 'c#d#' directory for each individual logical drive under
+ * /sys/bus/pci/devices/<dev/ccis#/. We also create a link from
+ * /sys/block/cciss!c#d# to this entry.
+ */
+static int cciss_create_ld_sysfs_entry(struct ctlr_info *h,
+                                       drive_info_struct *drv,
+                                       int drv_index)
+{
+        device_initialize(&drv->dev);
+        drv->dev.type = &cciss_dev_type;
+        drv->dev.bus = &cciss_bus_type;
+        dev_set_name(&drv->dev, "c%dd%d", h->ctlr, drv_index);
+        drv->dev.parent = &h->dev;
+        return device_add(&drv->dev);
+}
+/*
+ * Remove sysfs entries for a logical drive.
+ */
+static void cciss_destroy_ld_sysfs_entry(drive_info_struct *drv)
+{
+        device_del(&drv->dev);
+}
 /*
 * For operations that cannot sleep, a command block is allocated at init,
 * and managed by cmd_alloc() and cmd_free() using a simple bitmap to track
@@ -1299,7 +1488,6 @@ static void cciss_softirq_done(struct request *rq)
 {
        CommandList_struct *cmd = rq->completion_data;
        ctlr_info_t *h = hba[cmd->ctlr];
-        unsigned int nr_bytes;
        unsigned long flags;
        u64bit temp64;
        int i, ddir;
@@ -1321,15 +1509,11 @@ static void cciss_softirq_done(struct request *rq)
        printk("Done with %p\n", rq);
 #endif                          /* CCISS_DEBUG */
-        /*
+        /* set the residual count for pc requests */
-         * Store the full size and set the residual count for pc requests
-         */
-        nr_bytes = blk_rq_bytes(rq);
        if (blk_pc_request(rq))
-                rq->data_len = cmd->err_info->ResidualCnt;
+                rq->resid_len = cmd->err_info->ResidualCnt;
-        if (blk_end_request(rq, (rq->errors == 0) ? 0 : -EIO, nr_bytes))
+        blk_end_request_all(rq, (rq->errors == 0) ? 0 : -EIO);
-                BUG();
        spin_lock_irqsave(&h->lock, flags);
        cmd_free(h, cmd, 1);
@@ -1337,6 +1521,56 @@ static void cciss_softirq_done(struct request *rq)
        spin_unlock_irqrestore(&h->lock, flags);
 }
+static void log_unit_to_scsi3addr(ctlr_info_t *h, unsigned char scsi3addr[],
+        uint32_t log_unit)
+{
+        log_unit = h->drv[log_unit].LunID & 0x03fff;
+        memset(&scsi3addr[4], 0, 4);
+        memcpy(&scsi3addr[0], &log_unit, 4);
+        scsi3addr[3] |= 0x40;
+}
+/* This function gets the SCSI vendor, model, and revision of a logical drive
+ * via the inquiry page 0.  Model, vendor, and rev are set to empty strings if
+ * they cannot be read.
+ */
+static void cciss_get_device_descr(int ctlr, int logvol, int withirq,
+                                   char *vendor, char *model, char *rev)
+{
+        int rc;
+        InquiryData_struct *inq_buf;
+        unsigned char scsi3addr[8];
+        *vendor = '\0';
+        *model = '\0';
+        *rev = '\0';
+        inq_buf = kzalloc(sizeof(InquiryData_struct), GFP_KERNEL);
+        if (!inq_buf)
+                return;
+        log_unit_to_scsi3addr(hba[ctlr], scsi3addr, logvol);
+        if (withirq)
+                rc = sendcmd_withirq(CISS_INQUIRY, ctlr, inq_buf,
+                             sizeof(InquiryData_struct), 0,
+                                scsi3addr, TYPE_CMD);
+        else
+                rc = sendcmd(CISS_INQUIRY, ctlr, inq_buf,
+                             sizeof(InquiryData_struct), 0,
+                                scsi3addr, TYPE_CMD);
+        if (rc == IO_OK) {
+                memcpy(vendor, &inq_buf->data_byte[8], VENDOR_LEN);
+                vendor[VENDOR_LEN] = '\0';
+                memcpy(model, &inq_buf->data_byte[16], MODEL_LEN);
+                model[MODEL_LEN] = '\0';
+                memcpy(rev, &inq_buf->data_byte[32], REV_LEN);
+                rev[REV_LEN] = '\0';
+        }
+        kfree(inq_buf);
+        return;
+}
 /* This function gets the serial number of a logical drive via
 * inquiry page 0x83.  Serial no. is 16 bytes.  If the serial
 * number cannot be had, for whatever reason, 16 bytes of 0xff
@@ -1348,6 +1582,7 @@ static void cciss_get_serial_no(int ctlr, int logvol, int withirq,
 #define PAGE_83_INQ_BYTES 64
        int rc;
        unsigned char *buf;
+        unsigned char scsi3addr[8];
        if (buflen > 16)
                buflen = 16;
@@ -1356,12 +1591,13 @@ static void cciss_get_serial_no(int ctlr, int logvol, int withirq,
        if (!buf)
                return;
        memset(serial_no, 0, buflen);
+        log_unit_to_scsi3addr(hba[ctlr], scsi3addr, logvol);
        if (withirq)
                rc = sendcmd_withirq(CISS_INQUIRY, ctlr, buf,
-                        PAGE_83_INQ_BYTES, 1, logvol, 0x83, TYPE_CMD);
+                        PAGE_83_INQ_BYTES, 0x83, scsi3addr, TYPE_CMD);
        else
                rc = sendcmd(CISS_INQUIRY, ctlr, buf,
-                        PAGE_83_INQ_BYTES, 1, logvol, 0x83, NULL, TYPE_CMD);
+                        PAGE_83_INQ_BYTES, 0x83, scsi3addr, TYPE_CMD);
        if (rc == IO_OK)
                memcpy(serial_no, &buf[8], buflen);
        kfree(buf);
@@ -1377,7 +1613,7 @@ static void cciss_add_disk(ctlr_info_t *h, struct gendisk *disk,
        disk->first_minor = drv_index << NWD_SHIFT;
        disk->fops = &cciss_fops;
        disk->private_data = &h->drv[drv_index];
-        disk->driverfs_dev = &h->pdev->dev;
+        disk->driverfs_dev = &h->drv[drv_index].dev;
        /* Set up queue information */
        blk_queue_bounce_limit(disk->queue, h->pdev->dma_mask);
@@ -1394,8 +1630,8 @@ static void cciss_add_disk(ctlr_info_t *h, struct gendisk *disk,
        disk->queue->queuedata = h;
-        blk_queue_hardsect_size(disk->queue,
+        blk_queue_logical_block_size(disk->queue,
-                                h->drv[drv_index].block_size);
+                                     h->drv[drv_index].block_size);
        /* Make sure all queue data is written out before */
        /* setting h->drv[drv_index].queue, as setting this */
@@ -1468,6 +1704,8 @@ static void cciss_update_drive_info(int ctlr, int drv_index, int first_time)
        drvinfo->block_size = block_size;
        drvinfo->nr_blocks = total_size + 1;
+        cciss_get_device_descr(ctlr, drv_index, 1, drvinfo->vendor,
+                                drvinfo->model, drvinfo->rev);
        cciss_get_serial_no(ctlr, drv_index, 1, drvinfo->serial_no,
                        sizeof(drvinfo->serial_no));
@@ -1517,6 +1755,9 @@ static void cciss_update_drive_info(int ctlr, int drv_index, int first_time)
        h->drv[drv_index].cylinders = drvinfo->cylinders;
        h->drv[drv_index].raid_level = drvinfo->raid_level;
        memcpy(h->drv[drv_index].serial_no, drvinfo->serial_no, 16);
+        memcpy(h->drv[drv_index].vendor, drvinfo->vendor, VENDOR_LEN + 1);
+        memcpy(h->drv[drv_index].model, drvinfo->model, MODEL_LEN + 1);
+        memcpy(h->drv[drv_index].rev, drvinfo->rev, REV_LEN + 1);
        ++h->num_luns;
        disk = h->gendisk[drv_index];
@@ -1591,6 +1832,8 @@ static int cciss_add_gendisk(ctlr_info_t *h, __u32 lunid, int controller_node)
                }
        }
        h->drv[drv_index].LunID = lunid;
+        if (cciss_create_ld_sysfs_entry(h, &h->drv[drv_index], drv_index))
+                goto err_free_disk;
        /* Don't need to mark this busy because nobody */
        /* else knows about this disk yet to contend */
@@ -1598,6 +1841,11 @@ static int cciss_add_gendisk(ctlr_info_t *h, __u32 lunid, int controller_node)
        h->drv[drv_index].busy_configuring = 0;
        wmb();
        return drv_index;
+err_free_disk:
+        put_disk(h->gendisk[drv_index]);
+        h->gendisk[drv_index] = NULL;
+        return -1;
 }
 /* This is for the special case of a controller which
@@ -1668,8 +1916,8 @@ static int rebuild_lun_table(ctlr_info_t *h, int first_time)
                goto mem_msg;
        return_code = sendcmd_withirq(CISS_REPORT_LOG, ctlr, ld_buff,
-                                      sizeof(ReportLunData_struct), 0,
+                                      sizeof(ReportLunData_struct),
-                                      0, 0, TYPE_CMD);
+                                      0, CTLR_LUNID, TYPE_CMD);
        if (return_code == IO_OK)
                listlength = be32_to_cpu(*(__be32 *) ld_buff->LUNListLength);
@@ -1718,6 +1966,7 @@ static int rebuild_lun_table(ctlr_info_t *h, int first_time)
                        h->drv[i].busy_configuring = 1;
                        spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
                        return_code = deregister_disk(h, i, 1);
+                        cciss_destroy_ld_sysfs_entry(&h->drv[i]);
                        h->drv[i].busy_configuring = 0;
                }
        }
@@ -1877,11 +2126,9 @@ static int deregister_disk(ctlr_info_t *h, int drv_index,
        return 0;
 }
-static int fill_cmd(CommandList_struct *c, __u8 cmd, int ctlr, void *buff, size_t size, unsigned int use_unit_num,      /* 0: address the controller,
+static int fill_cmd(CommandList_struct *c, __u8 cmd, int ctlr, void *buff,
-                                                                                                                           1: address logical volume log_unit,
+                size_t size, __u8 page_code, unsigned char *scsi3addr,
-                                                                                                                           2: periph device address is scsi3addr */
+                int cmd_type)
-                    unsigned int log_unit, __u8 page_code,
-                    unsigned char *scsi3addr, int cmd_type)
 {
        ctlr_info_t *h = hba[ctlr];
        u64bit buff_dma_handle;
@@ -1897,27 +2144,12 @@ static int fill_cmd(CommandList_struct *c, __u8 cmd, int ctlr, void *buff, size_
                c->Header.SGTotal = 0;
        }
        c->Header.Tag.lower = c->busaddr;
+        memcpy(c->Header.LUN.LunAddrBytes, scsi3addr, 8);
        c->Request.Type.Type = cmd_type;
        if (cmd_type == TYPE_CMD) {
                switch (cmd) {
                case CISS_INQUIRY:
-                        /* If the logical unit number is 0 then, this is going
-                           to controller so It's a physical command
-                           mode = 0 target = 0.  So we have nothing to write.
-                           otherwise, if use_unit_num == 1,
-                           mode = 1(volume set addressing) target = LUNID
-                           otherwise, if use_unit_num == 2,
-                           mode = 0(periph dev addr) target = scsi3addr */
-                        if (use_unit_num == 1) {
-                                c->Header.LUN.LogDev.VolId =
-                                    h->drv[log_unit].LunID;
-                                c->Header.LUN.LogDev.Mode = 1;
-                        } else if (use_unit_num == 2) {
-                                memcpy(c->Header.LUN.LunAddrBytes, scsi3addr,
-                                       8);
-                                c->Header.LUN.LogDev.Mode = 0;
-                        }
                        /* are we trying to read a vital product page */
                        if (page_code != 0) {
                                c->Request.CDB[1] = 0x01;
@@ -1947,8 +2179,6 @@ static int fill_cmd(CommandList_struct *c, __u8 cmd, int ctlr, void *buff, size_
                        break;
                case CCISS_READ_CAPACITY:
-                        c->Header.LUN.LogDev.VolId = h->drv[log_unit].LunID;
-                        c->Header.LUN.LogDev.Mode = 1;
                        c->Request.CDBLen = 10;
                        c->Request.Type.Attribute = ATTR_SIMPLE;
                        c->Request.Type.Direction = XFER_READ;
@@ -1956,8 +2186,6 @@ static int fill_cmd(CommandList_struct *c, __u8 cmd, int ctlr, void *buff, size_
                        c->Request.CDB[0] = cmd;
                        break;
                case CCISS_READ_CAPACITY_16:
-                        c->Header.LUN.LogDev.VolId = h->drv[log_unit].LunID;
-                        c->Header.LUN.LogDev.Mode = 1;
                        c->Request.CDBLen = 16;
                        c->Request.Type.Attribute = ATTR_SIMPLE;
                        c->Request.Type.Direction = XFER_READ;
@@ -1979,6 +2207,12 @@ static int fill_cmd(CommandList_struct *c, __u8 cmd, int ctlr, void *buff, size_
                        c->Request.CDB[0] = BMIC_WRITE;
                        c->Request.CDB[6] = BMIC_CACHE_FLUSH;
                        break;
+                case TEST_UNIT_READY:
+                        c->Request.CDBLen = 6;
+                        c->Request.Type.Attribute = ATTR_SIMPLE;
+                        c->Request.Type.Direction = XFER_NONE;
+                        c->Request.Timeout = 0;
+                        break;
                default:
                        printk(KERN_WARNING
                               "cciss%d:  Unknown Command 0x%c\n", ctlr, cmd);
@@ -1997,13 +2231,13 @@ static int fill_cmd(CommandList_struct *c, __u8 cmd, int ctlr, void *buff, size_
                        memcpy(&c->Request.CDB[4], buff, 8);
                        break;
                case 1: /* RESET message */
-                        c->Request.CDBLen = 12;
+                        c->Request.CDBLen = 16;
                        c->Request.Type.Attribute = ATTR_SIMPLE;
-                        c->Request.Type.Direction = XFER_WRITE;
+                        c->Request.Type.Direction = XFER_NONE;
                        c->Request.Timeout = 0;
                        memset(&c->Request.CDB[0], 0, sizeof(c->Request.CDB));
                        c->Request.CDB[0] = cmd;        /* reset */
-                        c->Request.CDB[1] = 0x04;       /* reset a LUN */
+                        c->Request.CDB[1] = 0x03;       /* reset a target */
                        break;
                case 3: /* No-Op message */
                        c->Request.CDBLen = 1;
@@ -2035,114 +2269,152 @@ static int fill_cmd(CommandList_struct *c, __u8 cmd, int ctlr, void *buff, size_
        return status;
 }
-static int sendcmd_withirq(__u8 cmd,
+static int check_target_status(ctlr_info_t *h, CommandList_struct *c)
-                           int ctlr,
-                           void *buff,
-                           size_t size,
-                           unsigned int use_unit_num,
-                           unsigned int log_unit, __u8 page_code, int cmd_type)
 {
-        ctlr_info_t *h = hba[ctlr];
+        switch (c->err_info->ScsiStatus) {
-        CommandList_struct *c;
+        case SAM_STAT_GOOD:
+                return IO_OK;
+        case SAM_STAT_CHECK_CONDITION:
+                switch (0xf & c->err_info->SenseInfo[2]) {
+                case 0: return IO_OK; /* no sense */
+                case 1: return IO_OK; /* recovered error */
+                default:
+                        printk(KERN_WARNING "cciss%d: cmd 0x%02x "
+                                "check condition, sense key = 0x%02x\n",
+                                h->ctlr, c->Request.CDB[0],
+                                c->err_info->SenseInfo[2]);
+                }
+                break;
+        default:
+                printk(KERN_WARNING "cciss%d: cmd 0x%02x"
+                        "scsi status = 0x%02x\n", h->ctlr,
+                        c->Request.CDB[0], c->err_info->ScsiStatus);
+                break;
+        }
+        return IO_ERROR;
+}
+static int process_sendcmd_error(ctlr_info_t *h, CommandList_struct *c)
+{
+        int return_status = IO_OK;
+        if (c->err_info->CommandStatus == CMD_SUCCESS)
+                return IO_OK;
+        switch (c->err_info->CommandStatus) {
+        case CMD_TARGET_STATUS:
+                return_status = check_target_status(h, c);
+                break;
+        case CMD_DATA_UNDERRUN:
+        case CMD_DATA_OVERRUN:
+                /* expected for inquiry and report lun commands */
+                break;
+        case CMD_INVALID:
+                printk(KERN_WARNING "cciss: cmd 0x%02x is "
+                       "reported invalid\n", c->Request.CDB[0]);
+                return_status = IO_ERROR;
+                break;
+        case CMD_PROTOCOL_ERR:
+                printk(KERN_WARNING "cciss: cmd 0x%02x has "
+                       "protocol error \n", c->Request.CDB[0]);
+                return_status = IO_ERROR;
+                break;
+        case CMD_HARDWARE_ERR:
+                printk(KERN_WARNING "cciss: cmd 0x%02x had "
+                       " hardware error\n", c->Request.CDB[0]);
+                return_status = IO_ERROR;
+                break;
+        case CMD_CONNECTION_LOST:
+                printk(KERN_WARNING "cciss: cmd 0x%02x had "
+                       "connection lost\n", c->Request.CDB[0]);
+                return_status = IO_ERROR;
+                break;
+        case CMD_ABORTED:
+                printk(KERN_WARNING "cciss: cmd 0x%02x was "
+                       "aborted\n", c->Request.CDB[0]);
+                return_status = IO_ERROR;
+                break;
+        case CMD_ABORT_FAILED:
+                printk(KERN_WARNING "cciss: cmd 0x%02x reports "
+                       "abort failed\n", c->Request.CDB[0]);
+                return_status = IO_ERROR;
+                break;
+        case CMD_UNSOLICITED_ABORT:
+                printk(KERN_WARNING
+                       "cciss%d: unsolicited abort 0x%02x\n", h->ctlr,
+                        c->Request.CDB[0]);
+                return_status = IO_NEEDS_RETRY;
+                break;
+        default:
+                printk(KERN_WARNING "cciss: cmd 0x%02x returned "
+                       "unknown status %x\n", c->Request.CDB[0],
+                       c->err_info->CommandStatus);
+                return_status = IO_ERROR;
+        }
+        return return_status;
+}
+static int sendcmd_withirq_core(ctlr_info_t *h, CommandList_struct *c,
+        int attempt_retry)
+{
+        DECLARE_COMPLETION_ONSTACK(wait);
        u64bit buff_dma_handle;
        unsigned long flags;
-        int return_status;
+        int return_status = IO_OK;
-        DECLARE_COMPLETION_ONSTACK(wait);
-        if ((c = cmd_alloc(h, 0)) == NULL)
+resend_cmd2:
-                return -ENOMEM;
-        return_status = fill_cmd(c, cmd, ctlr, buff, size, use_unit_num,
-                                 log_unit, page_code, NULL, cmd_type);
-        if (return_status != IO_OK) {
-                cmd_free(h, c, 0);
-                return return_status;
-        }
-      resend_cmd2:
        c->waiting = &wait;
        /* Put the request on the tail of the queue and send it */
-        spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
+        spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
        addQ(&h->reqQ, c);
        h->Qdepth++;
        start_io(h);
-        spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
+        spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
        wait_for_completion(&wait);
-        if (c->err_info->CommandStatus != 0) {  /* an error has occurred */
+        if (c->err_info->CommandStatus == 0 || !attempt_retry)
-                switch (c->err_info->CommandStatus) {
+                goto command_done;
-                case CMD_TARGET_STATUS:
-                        printk(KERN_WARNING "cciss: cmd %p has "
-                               " completed with errors\n", c);
-                        if (c->err_info->ScsiStatus) {
-                                printk(KERN_WARNING "cciss: cmd %p "
-                                       "has SCSI Status = %x\n",
-                                       c, c->err_info->ScsiStatus);
-                        }
-                        break;
+        return_status = process_sendcmd_error(h, c);
-                case CMD_DATA_UNDERRUN:
-                case CMD_DATA_OVERRUN:
+        if (return_status == IO_NEEDS_RETRY &&
-                        /* expected for inquire and report lun commands */
+                c->retry_count < MAX_CMD_RETRIES) {
-                        break;
+                printk(KERN_WARNING "cciss%d: retrying 0x%02x\n", h->ctlr,
-                case CMD_INVALID:
+                        c->Request.CDB[0]);
-                        printk(KERN_WARNING "cciss: Cmd %p is "
+                c->retry_count++;
-                               "reported invalid\n", c);
+                /* erase the old error information */
-                        return_status = IO_ERROR;
+                memset(c->err_info, 0, sizeof(ErrorInfo_struct));
-                        break;
+                return_status = IO_OK;
-                case CMD_PROTOCOL_ERR:
+                INIT_COMPLETION(wait);
-                        printk(KERN_WARNING "cciss: cmd %p has "
+                goto resend_cmd2;
-                               "protocol error \n", c);
-                        return_status = IO_ERROR;
-                        break;
-                case CMD_HARDWARE_ERR:
-                        printk(KERN_WARNING "cciss: cmd %p had "
-                               " hardware error\n", c);
-                        return_status = IO_ERROR;
-                        break;
-                case CMD_CONNECTION_LOST:
-                        printk(KERN_WARNING "cciss: cmd %p had "
-                               "connection lost\n", c);
-                        return_status = IO_ERROR;
-                        break;
-                case CMD_ABORTED:
-                        printk(KERN_WARNING "cciss: cmd %p was "
-                               "aborted\n", c);
-                        return_status = IO_ERROR;
-                        break;
-                case CMD_ABORT_FAILED:
-                        printk(KERN_WARNING "cciss: cmd %p reports "
-                               "abort failed\n", c);
-                        return_status = IO_ERROR;
-                        break;
-                case CMD_UNSOLICITED_ABORT:
-                        printk(KERN_WARNING
-                               "cciss%d: unsolicited abort %p\n", ctlr, c);
-                        if (c->retry_count < MAX_CMD_RETRIES) {
-                                printk(KERN_WARNING
-                                       "cciss%d: retrying %p\n", ctlr, c);
-                                c->retry_count++;
-                                /* erase the old error information */
-                                memset(c->err_info, 0,
-                                       sizeof(ErrorInfo_struct));
-                                return_status = IO_OK;
-                                INIT_COMPLETION(wait);
-                                goto resend_cmd2;
-                        }
-                        return_status = IO_ERROR;
-                        break;
-                default:
-                        printk(KERN_WARNING "cciss: cmd %p returned "
-                               "unknown status %x\n", c,
-                               c->err_info->CommandStatus);
-                        return_status = IO_ERROR;
-                }
        }
+command_done:
        /* unlock the buffers from DMA */
        buff_dma_handle.val32.lower = c->SG[0].Addr.lower;
        buff_dma_handle.val32.upper = c->SG[0].Addr.upper;
        pci_unmap_single(h->pdev, (dma_addr_t) buff_dma_handle.val,
                         c->SG[0].Len, PCI_DMA_BIDIRECTIONAL);
+        return return_status;
+}
+static int sendcmd_withirq(__u8 cmd, int ctlr, void *buff, size_t size,
+                           __u8 page_code, unsigned char scsi3addr[],
+                        int cmd_type)
+{
+        ctlr_info_t *h = hba[ctlr];
+        CommandList_struct *c;
+        int return_status;
+        c = cmd_alloc(h, 0);
+        if (!c)
+                return -ENOMEM;
+        return_status = fill_cmd(c, cmd, ctlr, buff, size, page_code,
+                scsi3addr, cmd_type);
+        if (return_status == IO_OK)
+                return_status = sendcmd_withirq_core(h, c, 1);
        cmd_free(h, c, 0);
        return return_status;
 }
@@ -2155,15 +2427,17 @@ static void cciss_geometry_inquiry(int ctlr, int logvol,
 {
        int return_code;
        unsigned long t;
+        unsigned char scsi3addr[8];
        memset(inq_buff, 0, sizeof(InquiryData_struct));
+        log_unit_to_scsi3addr(hba[ctlr], scsi3addr, logvol);
        if (withirq)
                return_code = sendcmd_withirq(CISS_INQUIRY, ctlr,
-                                              inq_buff, sizeof(*inq_buff), 1,
+                                              inq_buff, sizeof(*inq_buff),
-                                              logvol, 0xC1, TYPE_CMD);
+                                              0xC1, scsi3addr, TYPE_CMD);
        else
                return_code = sendcmd(CISS_INQUIRY, ctlr, inq_buff,
-                                      sizeof(*inq_buff), 1, logvol, 0xC1, NULL,
+                                      sizeof(*inq_buff), 0xC1, scsi3addr,
                                      TYPE_CMD);
        if (return_code == IO_OK) {
                if (inq_buff->data_byte[8] == 0xFF) {
@@ -2204,6 +2478,7 @@ cciss_read_capacity(int ctlr, int logvol, int withirq, sector_t *total_size,
 {
        ReadCapdata_struct *buf;
        int return_code;
+        unsigned char scsi3addr[8];
        buf = kzalloc(sizeof(ReadCapdata_struct), GFP_KERNEL);
        if (!buf) {
@@ -2211,14 +2486,15 @@ cciss_read_capacity(int ctlr, int logvol, int withirq, sector_t *total_size,
                return;
        }
+        log_unit_to_scsi3addr(hba[ctlr], scsi3addr, logvol);
        if (withirq)
                return_code = sendcmd_withirq(CCISS_READ_CAPACITY,
                                ctlr, buf, sizeof(ReadCapdata_struct),
-                                        1, logvol, 0, TYPE_CMD);
+                                        0, scsi3addr, TYPE_CMD);
        else
                return_code = sendcmd(CCISS_READ_CAPACITY,
                                ctlr, buf, sizeof(ReadCapdata_struct),
-                                        1, logvol, 0, NULL, TYPE_CMD);
+                                        0, scsi3addr, TYPE_CMD);
        if (return_code == IO_OK) {
                *total_size = be32_to_cpu(*(__be32 *) buf->total_size);
                *block_size = be32_to_cpu(*(__be32 *) buf->block_size);
@@ -2238,6 +2514,7 @@ cciss_read_capacity_16(int ctlr, int logvol, int withirq, sector_t *total_size,
 {
        ReadCapdata_struct_16 *buf;
        int return_code;
+        unsigned char scsi3addr[8];
        buf = kzalloc(sizeof(ReadCapdata_struct_16), GFP_KERNEL);
        if (!buf) {
@@ -2245,15 +2522,16 @@ cciss_read_capacity_16(int ctlr, int logvol, int withirq, sector_t *total_size,
                return;
        }
+        log_unit_to_scsi3addr(hba[ctlr], scsi3addr, logvol);
        if (withirq) {
                return_code = sendcmd_withirq(CCISS_READ_CAPACITY_16,
                        ctlr, buf, sizeof(ReadCapdata_struct_16),
-                                1, logvol, 0, TYPE_CMD);
+                                0, scsi3addr, TYPE_CMD);
        }
        else {
                return_code = sendcmd(CCISS_READ_CAPACITY_16,
                        ctlr, buf, sizeof(ReadCapdata_struct_16),
-                                1, logvol, 0, NULL, TYPE_CMD);
+                                0, scsi3addr, TYPE_CMD);
        }
        if (return_code == IO_OK) {
                *total_size = be64_to_cpu(*(__be64 *) buf->total_size);
@@ -2303,7 +2581,7 @@ static int cciss_revalidate(struct gendisk *disk)
        cciss_geometry_inquiry(h->ctlr, logvol, 1, total_size, block_size,
                               inq_buff, drv);
-        blk_queue_hardsect_size(drv->queue, drv->block_size);
+        blk_queue_logical_block_size(drv->queue, drv->block_size);
        set_capacity(disk, drv->nr_blocks);
        kfree(inq_buff);
@@ -2333,86 +2611,21 @@ static unsigned long pollcomplete(int ctlr)
        return 1;
 }
-static int add_sendcmd_reject(__u8 cmd, int ctlr, unsigned long complete)
+/* Send command c to controller h and poll for it to complete.
-{
+ * Turns interrupts off on the board.  Used at driver init time
-        /* We get in here if sendcmd() is polling for completions
+ * and during SCSI error recovery.
-           and gets some command back that it wasn't expecting --
-           something other than that which it just sent down.
-           Ordinarily, that shouldn't happen, but it can happen when
-           the scsi tape stuff gets into error handling mode, and
-           starts using sendcmd() to try to abort commands and
-           reset tape drives.  In that case, sendcmd may pick up
-           completions of commands that were sent to logical drives
-           through the block i/o system, or cciss ioctls completing, etc.
-           In that case, we need to save those completions for later
-           processing by the interrupt handler.
-         */
-#ifdef CONFIG_CISS_SCSI_TAPE
-        struct sendcmd_reject_list *srl = &hba[ctlr]->scsi_rejects;
-        /* If it's not the scsi tape stuff doing error handling, (abort */
-        /* or reset) then we don't expect anything weird. */
-        if (cmd != CCISS_RESET_MSG && cmd != CCISS_ABORT_MSG) {
-#endif
-                printk(KERN_WARNING "cciss cciss%d: SendCmd "
-                       "Invalid command list address returned! (%lx)\n",
-                       ctlr, complete);
-                /* not much we can do. */
-#ifdef CONFIG_CISS_SCSI_TAPE
-                return 1;
-        }
-        /* We've sent down an abort or reset, but something else
-           has completed */
-        if (srl->ncompletions >= (hba[ctlr]->nr_cmds + 2)) {
-                /* Uh oh.  No room to save it for later... */
-                printk(KERN_WARNING "cciss%d: Sendcmd: Invalid command addr, "
-                       "reject list overflow, command lost!\n", ctlr);
-                return 1;
-        }
-        /* Save it for later */
-        srl->complete[srl->ncompletions] = complete;
-        srl->ncompletions++;
-#endif
-        return 0;
-}
-/*
- * Send a command to the controller, and wait for it to complete.
- * Only used at init time.
 */
-static int sendcmd(__u8 cmd, int ctlr, void *buff, size_t size, unsigned int use_unit_num,      /* 0: address the controller,
+static int sendcmd_core(ctlr_info_t *h, CommandList_struct *c)
-                                                                                                   1: address logical volume log_unit,
-                                                                                                   2: periph device address is scsi3addr */
-                   unsigned int log_unit,
-                   __u8 page_code, unsigned char *scsi3addr, int cmd_type)
 {
-        CommandList_struct *c;
        int i;
        unsigned long complete;
-        ctlr_info_t *info_p = hba[ctlr];
+        int status = IO_ERROR;
        u64bit buff_dma_handle;
-        int status, done = 0;
-        if ((c = cmd_alloc(info_p, 1)) == NULL) {
+resend_cmd1:
-                printk(KERN_WARNING "cciss: unable to get memory");
-                return IO_ERROR;
+        /* Disable interrupt on the board. */
-        }
+        h->access.set_intr_mask(h, CCISS_INTR_OFF);
-        status = fill_cmd(c, cmd, ctlr, buff, size, use_unit_num,
-                          log_unit, page_code, scsi3addr, cmd_type);
-        if (status != IO_OK) {
-                cmd_free(info_p, c, 1);
-                return status;
-        }
-      resend_cmd1:
-        /*
-         * Disable interrupt
-         */
-#ifdef CCISS_DEBUG
-        printk(KERN_DEBUG "cciss: turning intr off\n");
-#endif                          /* CCISS_DEBUG */
-        info_p->access.set_intr_mask(info_p, CCISS_INTR_OFF);
        /* Make sure there is room in the command FIFO */
        /* Actually it should be completely empty at this time */
@@ -2420,21 +2633,15 @@ static int sendcmd(__u8 cmd, int ctlr, void *buff, size_t size, unsigned int use
        /* tape side of the driver. */
        for (i = 200000; i > 0; i--) {
                /* if fifo isn't full go */
-                if (!(info_p->access.fifo_full(info_p))) {
+                if (!(h->access.fifo_full(h)))
                        break;
-                }
                udelay(10);
                printk(KERN_WARNING "cciss cciss%d: SendCmd FIFO full,"
-                       " waiting!\n", ctlr);
+                       " waiting!\n", h->ctlr);
        }
-        /*
+        h->access.submit_command(h, c); /* Send the cmd */
-         * Send the cmd
-         */
-        info_p->access.submit_command(info_p, c);
-        done = 0;
        do {
-                complete = pollcomplete(ctlr);
+                complete = pollcomplete(h->ctlr);
 #ifdef CCISS_DEBUG
                printk(KERN_DEBUG "cciss: command completed\n");
@@ -2443,97 +2650,102 @@ static int sendcmd(__u8 cmd, int ctlr, void *buff, size_t size, unsigned int use
                if (complete == 1) {
                        printk(KERN_WARNING
                               "cciss cciss%d: SendCmd Timeout out, "
-                               "No command list address returned!\n", ctlr);
+                               "No command list address returned!\n", h->ctlr);
                        status = IO_ERROR;
-                        done = 1;
                        break;
                }
-                /* This will need to change for direct lookup completions */
+                /* Make sure it's the command we're expecting. */
-                if ((complete & CISS_ERROR_BIT)
+                if ((complete & ~CISS_ERROR_BIT) != c->busaddr) {
-                    && (complete & ~CISS_ERROR_BIT) == c->busaddr) {
+                        printk(KERN_WARNING "cciss%d: Unexpected command "
-                        /* if data overrun or underun on Report command
+                                "completion.\n", h->ctlr);
-                           ignore it
+                        continue;
-                         */
+                }
-                        if (((c->Request.CDB[0] == CISS_REPORT_LOG) ||
-                             (c->Request.CDB[0] == CISS_REPORT_PHYS) ||
+                /* It is our command.  If no error, we're done. */
-                             (c->Request.CDB[0] == CISS_INQUIRY)) &&
+                if (!(complete & CISS_ERROR_BIT)) {
-                            ((c->err_info->CommandStatus ==
+                        status = IO_OK;
-                              CMD_DATA_OVERRUN) ||
+                        break;
-                             (c->err_info->CommandStatus == CMD_DATA_UNDERRUN)
-                            )) {
-                                complete = c->busaddr;
-                        } else {
-                                if (c->err_info->CommandStatus ==
-                                    CMD_UNSOLICITED_ABORT) {
-                                        printk(KERN_WARNING "cciss%d: "
-                                               "unsolicited abort %p\n",
-                                               ctlr, c);
-                                        if (c->retry_count < MAX_CMD_RETRIES) {
-                                                printk(KERN_WARNING
-                                                       "cciss%d: retrying %p\n",
-                                                       ctlr, c);
-                                                c->retry_count++;
-                                                /* erase the old error */
-                                                /* information */
-                                                memset(c->err_info, 0,
-                                                       sizeof
-                                                       (ErrorInfo_struct));
-                                                goto resend_cmd1;
-                                        } else {
-                                                printk(KERN_WARNING
-                                                       "cciss%d: retried %p too "
-                                                       "many times\n", ctlr, c);
-                                                status = IO_ERROR;
-                                                goto cleanup1;
-                                        }
-                                } else if (c->err_info->CommandStatus ==
-                                           CMD_UNABORTABLE) {
-                                        printk(KERN_WARNING
-                                               "cciss%d: command could not be aborted.\n",
-                                               ctlr);
-                                        status = IO_ERROR;
-                                        goto cleanup1;
-                                }
-                                printk(KERN_WARNING "ciss ciss%d: sendcmd"
-                                       " Error %x \n", ctlr,
-                                       c->err_info->CommandStatus);
-                                printk(KERN_WARNING "ciss ciss%d: sendcmd"
-                                       " offensive info\n"
-                                       "  size %x\n   num %x   value %x\n",
-                                       ctlr,
-                                       c->err_info->MoreErrInfo.Invalid_Cmd.
-                                       offense_size,
-                                       c->err_info->MoreErrInfo.Invalid_Cmd.
-                                       offense_num,
-                                       c->err_info->MoreErrInfo.Invalid_Cmd.
-                                       offense_value);
-                                status = IO_ERROR;
-                                goto cleanup1;
-                        }
                }
-                /* This will need changing for direct lookup completions */
-                if (complete != c->busaddr) {
+                /* There is an error... */
-                        if (add_sendcmd_reject(cmd, ctlr, complete) != 0) {
-                                BUG();  /* we are pretty much hosed if we get here. */
+                /* if data overrun or underun on Report command ignore it */
+                if (((c->Request.CDB[0] == CISS_REPORT_LOG) ||
+                     (c->Request.CDB[0] == CISS_REPORT_PHYS) ||
+                     (c->Request.CDB[0] == CISS_INQUIRY)) &&
+                        ((c->err_info->CommandStatus == CMD_DATA_OVERRUN) ||
+                         (c->err_info->CommandStatus == CMD_DATA_UNDERRUN))) {
+                        complete = c->busaddr;
+                        status = IO_OK;
+                        break;
+                }
+                if (c->err_info->CommandStatus == CMD_UNSOLICITED_ABORT) {
+                        printk(KERN_WARNING "cciss%d: unsolicited abort %p\n",
+                                h->ctlr, c);
+                        if (c->retry_count < MAX_CMD_RETRIES) {
+                                printk(KERN_WARNING "cciss%d: retrying %p\n",
+                                   h->ctlr, c);
+                                c->retry_count++;
+                                /* erase the old error information */
+                                memset(c->err_info, 0, sizeof(c->err_info));
+                                goto resend_cmd1;
                        }
-                        continue;
+                        printk(KERN_WARNING "cciss%d: retried %p too many "
-                } else
+                                "times\n", h->ctlr, c);
-                        done = 1;
+                        status = IO_ERROR;
-        } while (!done);
+                        break;
+                }
+                if (c->err_info->CommandStatus == CMD_UNABORTABLE) {
+                        printk(KERN_WARNING "cciss%d: command could not be "
+                                "aborted.\n", h->ctlr);
+                        status = IO_ERROR;
+                        break;
+                }
+                if (c->err_info->CommandStatus == CMD_TARGET_STATUS) {
+                        status = check_target_status(h, c);
+                        break;
+                }
+                printk(KERN_WARNING "cciss%d: sendcmd error\n", h->ctlr);
+                printk(KERN_WARNING "cmd = 0x%02x, CommandStatus = 0x%02x\n",
+                        c->Request.CDB[0], c->err_info->CommandStatus);
+                status = IO_ERROR;
+                break;
+        } while (1);
-      cleanup1:
        /* unlock the data buffer from DMA */
        buff_dma_handle.val32.lower = c->SG[0].Addr.lower;
        buff_dma_handle.val32.upper = c->SG[0].Addr.upper;
-        pci_unmap_single(info_p->pdev, (dma_addr_t) buff_dma_handle.val,
+        pci_unmap_single(h->pdev, (dma_addr_t) buff_dma_handle.val,
                         c->SG[0].Len, PCI_DMA_BIDIRECTIONAL);
-#ifdef CONFIG_CISS_SCSI_TAPE
+        return status;
-        /* if we saved some commands for later, process them now. */
+}
-        if (info_p->scsi_rejects.ncompletions > 0)
-                do_cciss_intr(0, info_p);
+/*
-#endif
+ * Send a command to the controller, and wait for it to complete.
-        cmd_free(info_p, c, 1);
+ * Used at init time, and during SCSI error recovery.
+ */
+static int sendcmd(__u8 cmd, int ctlr, void *buff, size_t size,
+        __u8 page_code, unsigned char *scsi3addr, int cmd_type)
+{
+        CommandList_struct *c;
+        int status;
+        c = cmd_alloc(hba[ctlr], 1);
+        if (!c) {
+                printk(KERN_WARNING "cciss: unable to get memory");
+                return IO_ERROR;
+        }
+        status = fill_cmd(c, cmd, ctlr, buff, size, page_code,
+                scsi3addr, cmd_type);
+        if (status == IO_OK)
+                status = sendcmd_core(hba[ctlr], c);
+        cmd_free(hba[ctlr], c, 1);
        return status;
 }
@@ -2691,7 +2903,7 @@ static inline void complete_command(ctlr_info_t *h, CommandList_struct *cmd,
                        printk(KERN_WARNING "cciss: cmd %p has"
                               " completed with data underrun "
                               "reported\n", cmd);
-                        cmd->rq->data_len = cmd->err_info->ResidualCnt;
+                        cmd->rq->resid_len = cmd->err_info->ResidualCnt;
                }
                break;
        case CMD_DATA_OVERRUN:
@@ -2806,7 +3018,7 @@ static void do_cciss_request(struct request_queue *q)
                goto startio;
      queue:
-        creq = elv_next_request(q);
+        creq = blk_peek_request(q);
        if (!creq)
                goto startio;
@@ -2815,7 +3027,7 @@ static void do_cciss_request(struct request_queue *q)
        if ((c = cmd_alloc(h, 1)) == NULL)
                goto full;
-        blkdev_dequeue_request(creq);
+        blk_start_request(creq);
        spin_unlock_irq(q->queue_lock);
@@ -2840,10 +3052,10 @@ static void do_cciss_request(struct request_queue *q)
        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 = creq->sector;
+        start_blk = blk_rq_pos(creq);
 #ifdef CCISS_DEBUG
-        printk(KERN_DEBUG "ciss: sector =%d nr_sectors=%d\n", (int)creq->sector,
+        printk(KERN_DEBUG "ciss: sector =%d nr_sectors=%d\n",
-               (int)creq->nr_sectors);
+               (int)blk_rq_pos(creq), (int)blk_rq_sectors(creq));
 #endif                          /* CCISS_DEBUG */
        sg_init_table(tmp_sg, MAXSGENTRIES);
@@ -2869,8 +3081,8 @@ static void do_cciss_request(struct request_queue *q)
                h->maxSG = seg;
 #ifdef CCISS_DEBUG
-        printk(KERN_DEBUG "cciss: Submitting %lu sectors in %d segments\n",
+        printk(KERN_DEBUG "cciss: Submitting %u sectors in %d segments\n",
-               creq->nr_sectors, seg);
+               blk_rq_sectors(creq), seg);
 #endif                          /* CCISS_DEBUG */
        c->Header.SGList = c->Header.SGTotal = seg;
@@ -2882,8 +3094,8 @@ static void do_cciss_request(struct request_queue *q)
                        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[7] = (creq->nr_sectors >> 8) & 0xff;
+                        c->Request.CDB[7] = (blk_rq_sectors(creq) >> 8) & 0xff;
-                        c->Request.CDB[8] = creq->nr_sectors & 0xff;
+                        c->Request.CDB[8] = blk_rq_sectors(creq) & 0xff;
                        c->Request.CDB[9] = c->Request.CDB[11] = c->Request.CDB[12] = 0;
                } else {
                        u32 upper32 = upper_32_bits(start_blk);
@@ -2898,10 +3110,10 @@ static void do_cciss_request(struct request_queue *q)
                        c->Request.CDB[7]= (start_blk >> 16) & 0xff;
                        c->Request.CDB[8]= (start_blk >>  8) & 0xff;
                        c->Request.CDB[9]= start_blk & 0xff;
-                        c->Request.CDB[10]= (creq->nr_sectors >>  24) & 0xff;
+                        c->Request.CDB[10]= (blk_rq_sectors(creq) >> 24) & 0xff;
-                        c->Request.CDB[11]= (creq->nr_sectors >>  16) & 0xff;
+                        c->Request.CDB[11]= (blk_rq_sectors(creq) >> 16) & 0xff;
-                        c->Request.CDB[12]= (creq->nr_sectors >>  8) & 0xff;
+                        c->Request.CDB[12]= (blk_rq_sectors(creq) >>  8) & 0xff;
-                        c->Request.CDB[13]= creq->nr_sectors & 0xff;
+                        c->Request.CDB[13]= blk_rq_sectors(creq) & 0xff;
                        c->Request.CDB[14] = c->Request.CDB[15] = 0;
                }
        } else if (blk_pc_request(creq)) {
@@ -2931,44 +3143,18 @@ startio:
 static inline unsigned long get_next_completion(ctlr_info_t *h)
 {
-#ifdef CONFIG_CISS_SCSI_TAPE
-        /* Any rejects from sendcmd() lying around? Process them first */
-        if (h->scsi_rejects.ncompletions == 0)
-                return h->access.command_completed(h);
-        else {
-                struct sendcmd_reject_list *srl;
-                int n;
-                srl = &h->scsi_rejects;
-                n = --srl->ncompletions;
-                /* printk("cciss%d: processing saved reject\n", h->ctlr); */
-                printk("p");
-                return srl->complete[n];
-        }
-#else
        return h->access.command_completed(h);
-#endif
 }
 static inline int interrupt_pending(ctlr_info_t *h)
 {
-#ifdef CONFIG_CISS_SCSI_TAPE
-        return (h->access.intr_pending(h)
-                || (h->scsi_rejects.ncompletions > 0));
-#else
        return h->access.intr_pending(h);
-#endif
 }
 static inline long interrupt_not_for_us(ctlr_info_t *h)
 {
-#ifdef CONFIG_CISS_SCSI_TAPE
-        return (((h->access.intr_pending(h) == 0) ||
-                 (h->interrupts_enabled == 0))
-                && (h->scsi_rejects.ncompletions == 0));
-#else
        return (((h->access.intr_pending(h) == 0) ||
                 (h->interrupts_enabled == 0)));
-#endif
 }
 static irqreturn_t do_cciss_intr(int irq, void *dev_id)
@@ -3723,12 +3909,15 @@ static int __devinit cciss_init_one(struct pci_dev *pdev,
        INIT_HLIST_HEAD(&hba[i]->reqQ);
        if (cciss_pci_init(hba[i], pdev) != 0)
-                goto clean1;
+                goto clean0;
        sprintf(hba[i]->devname, "cciss%d", i);
        hba[i]->ctlr = i;
        hba[i]->pdev = pdev;
+        if (cciss_create_hba_sysfs_entry(hba[i]))
+                goto clean0;
        /* configure PCI DMA stuff */
        if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64)))
                dac = 1;
@@ -3787,15 +3976,6 @@ static int __devinit cciss_init_one(struct pci_dev *pdev,
                printk(KERN_ERR "cciss: out of memory");
                goto clean4;
        }
-#ifdef CONFIG_CISS_SCSI_TAPE
-        hba[i]->scsi_rejects.complete =
-            kmalloc(sizeof(hba[i]->scsi_rejects.complete[0]) *
-                    (hba[i]->nr_cmds + 5), GFP_KERNEL);
-        if (hba[i]->scsi_rejects.complete == NULL) {
-                printk(KERN_ERR "cciss: out of memory");
-                goto clean4;
-        }
-#endif
        spin_lock_init(&hba[i]->lock);
        /* Initialize the pdev driver private data.
@@ -3828,7 +4008,7 @@ static int __devinit cciss_init_one(struct pci_dev *pdev,
        }
        return_code = sendcmd_withirq(CISS_INQUIRY, i, inq_buff,
-                sizeof(InquiryData_struct), 0, 0 , 0, TYPE_CMD);
+                sizeof(InquiryData_struct), 0, CTLR_LUNID, TYPE_CMD);
        if (return_code == IO_OK) {
                hba[i]->firm_ver[0] = inq_buff->data_byte[32];
                hba[i]->firm_ver[1] = inq_buff->data_byte[33];
@@ -3855,9 +4035,6 @@ static int __devinit cciss_init_one(struct pci_dev *pdev,
 clean4:
        kfree(inq_buff);
-#ifdef CONFIG_CISS_SCSI_TAPE
-        kfree(hba[i]->scsi_rejects.complete);
-#endif
        kfree(hba[i]->cmd_pool_bits);
        if (hba[i]->cmd_pool)
                pci_free_consistent(hba[i]->pdev,
@@ -3872,6 +4049,8 @@ clean4:
 clean2:
        unregister_blkdev(hba[i]->major, hba[i]->devname);
 clean1:
+        cciss_destroy_hba_sysfs_entry(hba[i]);
+clean0:
        hba[i]->busy_initializing = 0;
        /* cleanup any queues that may have been initialized */
        for (j=0; j <= hba[i]->highest_lun; j++){
@@ -3907,8 +4086,8 @@ static void cciss_shutdown(struct pci_dev *pdev)
        /* sendcmd will turn off interrupt, and send the flush...
         * To write all data in the battery backed cache to disks */
        memset(flush_buf, 0, 4);
-        return_code = sendcmd(CCISS_CACHE_FLUSH, i, flush_buf, 4, 0, 0, 0, NULL,
+        return_code = sendcmd(CCISS_CACHE_FLUSH, i, flush_buf, 4, 0,
-                              TYPE_CMD);
+                CTLR_LUNID, TYPE_CMD);
        if (return_code == IO_OK) {
                printk(KERN_INFO "Completed flushing cache on controller %d\n", i);
        } else {
@@ -3973,15 +4152,13 @@ static void __devexit cciss_remove_one(struct pci_dev *pdev)
        pci_free_consistent(hba[i]->pdev, hba[i]->nr_cmds * sizeof(ErrorInfo_struct),
                            hba[i]->errinfo_pool, hba[i]->errinfo_pool_dhandle);
        kfree(hba[i]->cmd_pool_bits);
-#ifdef CONFIG_CISS_SCSI_TAPE
-        kfree(hba[i]->scsi_rejects.complete);
-#endif
        /*
         * Deliberately omit pci_disable_device(): it does something nasty to
         * Smart Array controllers that pci_enable_device does not undo
         */
        pci_release_regions(pdev);
        pci_set_drvdata(pdev, NULL);
+        cciss_destroy_hba_sysfs_entry(hba[i]);
        free_hba(i);
 }
@@ -3999,6 +4176,8 @@ static struct pci_driver cciss_pci_driver = {
 */
 static int __init cciss_init(void)
 {
+        int err;
        /*
         * The hardware requires that commands are aligned on a 64-bit
         * boundary. Given that we use pci_alloc_consistent() to allocate an
@@ -4008,8 +4187,20 @@ static int __init cciss_init(void)
        printk(KERN_INFO DRIVER_NAME "\n");
+        err = bus_register(&cciss_bus_type);
+        if (err)
+                return err;
        /* Register for our PCI devices */
-        return pci_register_driver(&cciss_pci_driver);
+        err = pci_register_driver(&cciss_pci_driver);
+        if (err)
+                goto err_bus_register;
+        return 0;
+err_bus_register:
+        bus_unregister(&cciss_bus_type);
+        return err;
 }
 static void __exit cciss_cleanup(void)
@@ -4026,6 +4217,7 @@ static void __exit cciss_cleanup(void)
                }
        }
        remove_proc_entry("driver/cciss", NULL);
+        bus_unregister(&cciss_bus_type);
 }
 static void fail_all_cmds(unsigned long ctlr)
diff --git a/drivers/block/cciss.h b/drivers/block/cciss.h
index 703e08038fb9..06a5db25b298 100644
--- a/drivers/block/cciss.h
+++ b/drivers/block/cciss.h
@@ -11,6 +11,11 @@
 #define IO_OK           0
 #define IO_ERROR        1
+#define IO_NEEDS_RETRY  3
+#define VENDOR_LEN      8
+#define MODEL_LEN       16
+#define REV_LEN         4
 struct ctlr_info;
 typedef struct ctlr_info ctlr_info_t;
@@ -34,23 +39,20 @@ typedef struct _drive_info_struct
        int     cylinders;
        int     raid_level; /* set to -1 to indicate that
                             * the drive is not in use/configured
-                            */
+                             */
-        int     busy_configuring; /*This is set when the drive is being removed
+        int     busy_configuring; /* This is set when a drive is being removed
-                                   *to prevent it from being opened or it's queue
+                                   * to prevent it from being opened or it's
-                                   *from being started.
+                                   * queue from being started.
-                                  */
+                                   */
-        __u8 serial_no[16]; /* from inquiry page 0x83, */
+        struct  device dev;
-                            /* not necc. null terminated. */
+        __u8 serial_no[16]; /* from inquiry page 0x83,
+                             * not necc. null terminated.
+                             */
+        char vendor[VENDOR_LEN + 1]; /* SCSI vendor string */
+        char model[MODEL_LEN + 1];   /* SCSI model string */
+        char rev[REV_LEN + 1];       /* SCSI revision string */
 } drive_info_struct;
-#ifdef CONFIG_CISS_SCSI_TAPE
-struct sendcmd_reject_list {
-        int ncompletions;
-        unsigned long *complete; /* array of NR_CMDS tags */
-};
-#endif
 struct ctlr_info 
 {
        int     ctlr;
@@ -118,11 +120,11 @@ struct ctlr_info
        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 sendcmd_reject_list scsi_rejects;
 #endif
        unsigned char alive;
        struct completion *rescan_wait;
        struct task_struct *cciss_scan_thread;
+        struct device dev;
 };
 /*  Defining the diffent access_menthods */
diff --git a/drivers/block/cciss_cmd.h b/drivers/block/cciss_cmd.h
index 40b1b92dae7f..cd665b00c7c5 100644
--- a/drivers/block/cciss_cmd.h
+++ b/drivers/block/cciss_cmd.h
@@ -217,6 +217,8 @@ typedef union _LUNAddr_struct {
  LogDevAddr_struct  LogDev;
 } LUNAddr_struct;
+#define CTLR_LUNID "\0\0\0\0\0\0\0\0"
 typedef struct _CommandListHeader_struct {
  BYTE              ReplyQueue;
  BYTE              SGList;
diff --git a/drivers/block/cciss_scsi.c b/drivers/block/cciss_scsi.c
index a3fd87b41444..3315268b4ec7 100644
--- a/drivers/block/cciss_scsi.c
+++ b/drivers/block/cciss_scsi.c
@@ -44,20 +44,13 @@
 #define CCISS_ABORT_MSG 0x00
 #define CCISS_RESET_MSG 0x01
-/* some prototypes... */ 
+static int fill_cmd(CommandList_struct *c, __u8 cmd, int ctlr, void *buff,
-static int sendcmd(
+        size_t size,
-        __u8    cmd,
+        __u8 page_code, unsigned char *scsi3addr,
-        int     ctlr,
-        void    *buff,
-        size_t  size,
-        unsigned int use_unit_num, /* 0: address the controller,
-                                      1: address logical volume log_unit, 
-                                      2: address is in scsi3addr */
-        unsigned int log_unit,
-        __u8    page_code,
-        unsigned char *scsi3addr,
        int cmd_type);
+static CommandList_struct *cmd_alloc(ctlr_info_t *h, int get_from_pool);
+static void cmd_free(ctlr_info_t *h, CommandList_struct *c, int got_from_pool);
 static int cciss_scsi_proc_info(
                struct Scsi_Host *sh,
@@ -1575,6 +1568,75 @@ cciss_seq_tape_report(struct seq_file *seq, int ctlr)
        CPQ_TAPE_UNLOCK(ctlr, flags);
 }
+static int wait_for_device_to_become_ready(ctlr_info_t *h,
+        unsigned char lunaddr[])
+{
+        int rc;
+        int count = 0;
+        int waittime = HZ;
+        CommandList_struct *c;
+        c = cmd_alloc(h, 1);
+        if (!c) {
+                printk(KERN_WARNING "cciss%d: out of memory in "
+                        "wait_for_device_to_become_ready.\n", h->ctlr);
+                return IO_ERROR;
+        }
+        /* Send test unit ready until device ready, or give up. */
+        while (count < 20) {
+                /* Wait for a bit.  do this first, because if we send
+                 * the TUR right away, the reset will just abort it.
+                 */
+                schedule_timeout_uninterruptible(waittime);
+                count++;
+                /* Increase wait time with each try, up to a point. */
+                if (waittime < (HZ * 30))
+                        waittime = waittime * 2;
+                /* Send the Test Unit Ready */
+                rc = fill_cmd(c, TEST_UNIT_READY, h->ctlr, NULL, 0, 0,
+                        lunaddr, TYPE_CMD);
+                if (rc == 0)
+                        rc = sendcmd_withirq_core(h, c, 0);
+                (void) process_sendcmd_error(h, c);
+                if (rc != 0)
+                        goto retry_tur;
+                if (c->err_info->CommandStatus == CMD_SUCCESS)
+                        break;
+                if (c->err_info->CommandStatus == CMD_TARGET_STATUS &&
+                        c->err_info->ScsiStatus == SAM_STAT_CHECK_CONDITION) {
+                        if (c->err_info->SenseInfo[2] == NO_SENSE)
+                                break;
+                        if (c->err_info->SenseInfo[2] == UNIT_ATTENTION) {
+                                unsigned char asc;
+                                asc = c->err_info->SenseInfo[12];
+                                check_for_unit_attention(h, c);
+                                if (asc == POWER_OR_RESET)
+                                        break;
+                        }
+                }
+retry_tur:
+                printk(KERN_WARNING "cciss%d: Waiting %d secs "
+                        "for device to become ready.\n",
+                        h->ctlr, waittime / HZ);
+                rc = 1; /* device not ready. */
+        }
+        if (rc)
+                printk("cciss%d: giving up on device.\n", h->ctlr);
+        else
+                printk(KERN_WARNING "cciss%d: device is ready.\n", h->ctlr);
+        cmd_free(h, c, 1);
+        return rc;
+}
 /* Need at least one of these error handlers to keep ../scsi/hosts.c from 
 * complaining.  Doing a host- or bus-reset can't do anything good here. 
@@ -1591,6 +1653,7 @@ 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;
        int ctlr;
@@ -1600,19 +1663,15 @@ static int cciss_eh_device_reset_handler(struct scsi_cmnd *scsicmd)
                return FAILED;
        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;
-        if (cmd_in_trouble == NULL) { /* paranoia */
+        if (cmd_in_trouble == NULL) /* paranoia */
                return FAILED;
-        }
+        memcpy(lunaddr, &cmd_in_trouble->Header.LUN.LunAddrBytes[0], 8);
        /* send a reset to the SCSI LUN which the command was sent to */
-        rc = sendcmd(CCISS_RESET_MSG, ctlr, NULL, 0, 2, 0, 0, 
+        rc = sendcmd_withirq(CCISS_RESET_MSG, ctlr, NULL, 0, 0, lunaddr,
-                (unsigned char *) &cmd_in_trouble->Header.LUN.LunAddrBytes[0], 
                TYPE_MSG);
-        /* sendcmd turned off interrupts on the board, turn 'em back on. */
+        if (rc == 0 && wait_for_device_to_become_ready(*c, lunaddr) == 0)
-        (*c)->access.set_intr_mask(*c, CCISS_INTR_ON);
-        if (rc == 0)
                return SUCCESS;
        printk(KERN_WARNING "cciss%d: resetting device failed.\n", ctlr);
        return FAILED;
@@ -1622,6 +1681,7 @@ 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;
        int ctlr;
@@ -1636,12 +1696,9 @@ static int  cciss_eh_abort_handler(struct scsi_cmnd *scsicmd)
        cmd_to_abort = (CommandList_struct *) scsicmd->host_scribble;
        if (cmd_to_abort == NULL) /* paranoia */
                return FAILED;
-        rc = sendcmd(CCISS_ABORT_MSG, ctlr, &cmd_to_abort->Header.Tag, 
+        memcpy(lunaddr, &cmd_to_abort->Header.LUN.LunAddrBytes[0], 8);
-                0, 2, 0, 0, 
+        rc = sendcmd_withirq(CCISS_ABORT_MSG, ctlr, &cmd_to_abort->Header.Tag,
-                (unsigned char *) &cmd_to_abort->Header.LUN.LunAddrBytes[0], 
+                0, 0, lunaddr, TYPE_MSG);
-                TYPE_MSG);
-        /* sendcmd turned off interrupts on the board, turn 'em back on. */
-        (*c)->access.set_intr_mask(*c, CCISS_INTR_ON);
        if (rc == 0)
                return SUCCESS;
        return FAILED;
diff --git a/drivers/block/cpqarray.c b/drivers/block/cpqarray.c
index ca268ca11159..44fa2018f6b0 100644
--- a/drivers/block/cpqarray.c
+++ b/drivers/block/cpqarray.c
@@ -474,7 +474,7 @@ static int __init cpqarray_register_ctlr( int i, struct pci_dev *pdev)
                disk->fops = &ida_fops;
                if (j && !drv->nr_blks)
                        continue;
-                blk_queue_hardsect_size(hba[i]->queue, drv->blk_size);
+                blk_queue_logical_block_size(hba[i]->queue, drv->blk_size);
                set_capacity(disk, drv->nr_blks);
                disk->queue = hba[i]->queue;
                disk->private_data = drv;
@@ -903,7 +903,7 @@ static void do_ida_request(struct request_queue *q)
                goto startio;
 queue_next:
-        creq = elv_next_request(q);
+        creq = blk_peek_request(q);
        if (!creq)
                goto startio;
@@ -912,17 +912,18 @@ queue_next:
        if ((c = cmd_alloc(h,1)) == NULL)
                goto startio;
-        blkdev_dequeue_request(creq);
+        blk_start_request(creq);
        c->ctlr = h->ctlr;
        c->hdr.unit = (drv_info_t *)(creq->rq_disk->private_data) - h->drv;
        c->hdr.size = sizeof(rblk_t) >> 2;
        c->size += sizeof(rblk_t);
-        c->req.hdr.blk = creq->sector;
+        c->req.hdr.blk = blk_rq_pos(creq);
        c->rq = creq;
 DBGPX(
-        printk("sector=%d, nr_sectors=%d\n", creq->sector, creq->nr_sectors);
+        printk("sector=%d, nr_sectors=%u\n",
+               blk_rq_pos(creq), blk_rq_sectors(creq));
 );
        sg_init_table(tmp_sg, SG_MAX);
        seg = blk_rq_map_sg(q, creq, tmp_sg);
@@ -940,9 +941,9 @@ DBGPX(
                                                 tmp_sg[i].offset,
                                                 tmp_sg[i].length, dir);
        }
-DBGPX(  printk("Submitting %d sectors in %d segments\n", creq->nr_sectors, seg); );
+DBGPX(  printk("Submitting %u sectors in %d segments\n", blk_rq_sectors(creq), seg); );
        c->req.hdr.sg_cnt = seg;
-        c->req.hdr.blk_cnt = creq->nr_sectors;
+        c->req.hdr.blk_cnt = blk_rq_sectors(creq);
        c->req.hdr.cmd = (rq_data_dir(creq) == READ) ? IDA_READ : IDA_WRITE;
        c->type = CMD_RWREQ;
@@ -1024,8 +1025,7 @@ static inline void complete_command(cmdlist_t *cmd, int timeout)
                                cmd->req.sg[i].size, ddir);
        DBGPX(printk("Done with %p\n", rq););
-        if (__blk_end_request(rq, error, blk_rq_bytes(rq)))
+        __blk_end_request_all(rq, error);
-                BUG();
 }
 /*
@@ -1546,7 +1546,7 @@ static int revalidate_allvol(ctlr_info_t *host)
                drv_info_t *drv = &host->drv[i];
                if (i && !drv->nr_blks)
                        continue;
-                blk_queue_hardsect_size(host->queue, drv->blk_size);
+                blk_queue_logical_block_size(host->queue, drv->blk_size);
                set_capacity(disk, drv->nr_blks);
                disk->queue = host->queue;
                disk->private_data = drv;
diff --git a/drivers/block/floppy.c b/drivers/block/floppy.c
index 1300df6f1642..862b40c90181 100644
--- a/drivers/block/floppy.c
+++ b/drivers/block/floppy.c
@@ -931,7 +931,7 @@ static inline void unlock_fdc(void)
        del_timer(&fd_timeout);
        cont = NULL;
        clear_bit(0, &fdc_busy);
-        if (elv_next_request(floppy_queue))
+        if (current_req || blk_peek_request(floppy_queue))
                do_fd_request(floppy_queue);
        spin_unlock_irqrestore(&floppy_lock, flags);
        wake_up(&fdc_wait);
@@ -2303,7 +2303,7 @@ static void floppy_end_request(struct request *req, int error)
        /* current_count_sectors can be zero if transfer failed */
        if (error)
-                nr_sectors = req->current_nr_sectors;
+                nr_sectors = blk_rq_cur_sectors(req);
        if (__blk_end_request(req, error, nr_sectors << 9))
                return;
@@ -2332,7 +2332,7 @@ static void request_done(int uptodate)
        if (uptodate) {
                /* maintain values for invalidation on geometry
                 * change */
-                block = current_count_sectors + req->sector;
+                block = current_count_sectors + blk_rq_pos(req);
                INFBOUND(DRS->maxblock, block);
                if (block > _floppy->sect)
                        DRS->maxtrack = 1;
@@ -2346,10 +2346,10 @@ static void request_done(int uptodate)
                        /* record write error information */
                        DRWE->write_errors++;
                        if (DRWE->write_errors == 1) {
-                                DRWE->first_error_sector = req->sector;
+                                DRWE->first_error_sector = blk_rq_pos(req);
                                DRWE->first_error_generation = DRS->generation;
                        }
-                        DRWE->last_error_sector = req->sector;
+                        DRWE->last_error_sector = blk_rq_pos(req);
                        DRWE->last_error_generation = DRS->generation;
                }
                spin_lock_irqsave(q->queue_lock, flags);
@@ -2503,24 +2503,23 @@ static void copy_buffer(int ssize, int max_sector, int max_sector_2)
        max_sector = transfer_size(ssize,
                                   min(max_sector, max_sector_2),
-                                   current_req->nr_sectors);
+                                   blk_rq_sectors(current_req));
        if (current_count_sectors <= 0 && CT(COMMAND) == FD_WRITE &&
-            buffer_max > fsector_t + current_req->nr_sectors)
+            buffer_max > fsector_t + blk_rq_sectors(current_req))
                current_count_sectors = min_t(int, buffer_max - fsector_t,
-                                              current_req->nr_sectors);
+                                              blk_rq_sectors(current_req));
        remaining = current_count_sectors << 9;
 #ifdef FLOPPY_SANITY_CHECK
-        if ((remaining >> 9) > current_req->nr_sectors &&
+        if (remaining > blk_rq_bytes(current_req) && CT(COMMAND) == FD_WRITE) {
-            CT(COMMAND) == FD_WRITE) {
                DPRINT("in copy buffer\n");
                printk("current_count_sectors=%ld\n", current_count_sectors);
                printk("remaining=%d\n", remaining >> 9);
-                printk("current_req->nr_sectors=%ld\n",
+                printk("current_req->nr_sectors=%u\n",
-                       current_req->nr_sectors);
+                       blk_rq_sectors(current_req));
                printk("current_req->current_nr_sectors=%u\n",
-                       current_req->current_nr_sectors);
+                       blk_rq_cur_sectors(current_req));
                printk("max_sector=%d\n", max_sector);
                printk("ssize=%d\n", ssize);
        }
@@ -2530,7 +2529,7 @@ static void copy_buffer(int ssize, int max_sector, int max_sector_2)
        dma_buffer = floppy_track_buffer + ((fsector_t - buffer_min) << 9);
-        size = current_req->current_nr_sectors << 9;
+        size = blk_rq_cur_bytes(current_req);
        rq_for_each_segment(bv, current_req, iter) {
                if (!remaining)
@@ -2648,10 +2647,10 @@ static int make_raw_rw_request(void)
        max_sector = _floppy->sect * _floppy->head;
-        TRACK = (int)current_req->sector / max_sector;
+        TRACK = (int)blk_rq_pos(current_req) / max_sector;
-        fsector_t = (int)current_req->sector % max_sector;
+        fsector_t = (int)blk_rq_pos(current_req) % max_sector;
        if (_floppy->track && TRACK >= _floppy->track) {
-                if (current_req->current_nr_sectors & 1) {
+                if (blk_rq_cur_sectors(current_req) & 1) {
                        current_count_sectors = 1;
                        return 1;
                } else
@@ -2669,7 +2668,7 @@ static int make_raw_rw_request(void)
                if (fsector_t >= max_sector) {
                        current_count_sectors =
                            min_t(int, _floppy->sect - fsector_t,
-                                  current_req->nr_sectors);
+                                  blk_rq_sectors(current_req));
                        return 1;
                }
                SIZECODE = 2;
@@ -2720,7 +2719,7 @@ static int make_raw_rw_request(void)
        in_sector_offset = (fsector_t % _floppy->sect) % ssize;
        aligned_sector_t = fsector_t - in_sector_offset;
-        max_size = current_req->nr_sectors;
+        max_size = blk_rq_sectors(current_req);
        if ((raw_cmd->track == buffer_track) &&
            (current_drive == buffer_drive) &&
            (fsector_t >= buffer_min) && (fsector_t < buffer_max)) {
@@ -2729,10 +2728,10 @@ static int make_raw_rw_request(void)
                        copy_buffer(1, max_sector, buffer_max);
                        return 1;
                }
-        } else if (in_sector_offset || current_req->nr_sectors < ssize) {
+        } else if (in_sector_offset || blk_rq_sectors(current_req) < ssize) {
                if (CT(COMMAND) == FD_WRITE) {
-                        if (fsector_t + current_req->nr_sectors > ssize &&
+                        if (fsector_t + blk_rq_sectors(current_req) > ssize &&
-                            fsector_t + current_req->nr_sectors < ssize + ssize)
+                            fsector_t + blk_rq_sectors(current_req) < ssize + ssize)
                                max_size = ssize + ssize;
                        else
                                max_size = ssize;
@@ -2776,7 +2775,7 @@ static int make_raw_rw_request(void)
                    (indirect * 2 > direct * 3 &&
                     *errors < DP->max_errors.read_track && ((!probing
                       || (DP->read_track & (1 << DRS->probed_format)))))) {
-                        max_size = current_req->nr_sectors;
+                        max_size = blk_rq_sectors(current_req);
                } else {
                        raw_cmd->kernel_data = current_req->buffer;
                        raw_cmd->length = current_count_sectors << 9;
@@ -2801,7 +2800,7 @@ static int make_raw_rw_request(void)
            fsector_t > buffer_max ||
            fsector_t < buffer_min ||
            ((CT(COMMAND) == FD_READ ||
-              (!in_sector_offset && current_req->nr_sectors >= ssize)) &&
+              (!in_sector_offset && blk_rq_sectors(current_req) >= ssize)) &&
             max_sector > 2 * max_buffer_sectors + buffer_min &&
             max_size + fsector_t > 2 * max_buffer_sectors + buffer_min)
            /* not enough space */
@@ -2879,8 +2878,8 @@ static int make_raw_rw_request(void)
                                printk("write\n");
                        return 0;
                }
-        } else if (raw_cmd->length > current_req->nr_sectors << 9 ||
+        } else if (raw_cmd->length > blk_rq_bytes(current_req) ||
-                   current_count_sectors > current_req->nr_sectors) {
+                   current_count_sectors > blk_rq_sectors(current_req)) {
                DPRINT("buffer overrun in direct transfer\n");
                return 0;
        } else if (raw_cmd->length < current_count_sectors << 9) {
@@ -2913,7 +2912,7 @@ static void redo_fd_request(void)
                        struct request *req;
                        spin_lock_irq(floppy_queue->queue_lock);
-                        req = elv_next_request(floppy_queue);
+                        req = blk_fetch_request(floppy_queue);
                        spin_unlock_irq(floppy_queue->queue_lock);
                        if (!req) {
                                do_floppy = NULL;
@@ -2990,8 +2989,9 @@ static void do_fd_request(struct request_queue * q)
        if (usage_count == 0) {
                printk("warning: usage count=0, current_req=%p exiting\n",
                       current_req);
-                printk("sect=%ld type=%x flags=%x\n", (long)current_req->sector,
+                printk("sect=%ld type=%x flags=%x\n",
-                       current_req->cmd_type, current_req->cmd_flags);
+                       (long)blk_rq_pos(current_req), current_req->cmd_type,
+                       current_req->cmd_flags);
                return;
        }
        if (test_bit(0, &fdc_busy)) {
@@ -4148,6 +4148,24 @@ static void floppy_device_release(struct device *dev)
 {
 }
+static int floppy_resume(struct platform_device *dev)
+{
+        int fdc;
+        for (fdc = 0; fdc < N_FDC; fdc++)
+                if (FDCS->address != -1)
+                        user_reset_fdc(-1, FD_RESET_ALWAYS, 0);
+        return 0;
+}
+static struct platform_driver floppy_driver = {
+        .resume = floppy_resume,
+        .driver = {
+                .name = "floppy",
+        },
+};
 static struct platform_device floppy_device[N_DRIVE];
 static struct kobject *floppy_find(dev_t dev, int *part, void *data)
@@ -4196,10 +4214,14 @@ static int __init floppy_init(void)
        if (err)
                goto out_put_disk;
+        err = platform_driver_register(&floppy_driver);
+        if (err)
+                goto out_unreg_blkdev;
        floppy_queue = blk_init_queue(do_fd_request, &floppy_lock);
        if (!floppy_queue) {
                err = -ENOMEM;
-                goto out_unreg_blkdev;
+                goto out_unreg_driver;
        }
        blk_queue_max_sectors(floppy_queue, 64);
@@ -4346,6 +4368,8 @@ out_flush_work:
 out_unreg_region:
        blk_unregister_region(MKDEV(FLOPPY_MAJOR, 0), 256);
        blk_cleanup_queue(floppy_queue);
+out_unreg_driver:
+        platform_driver_unregister(&floppy_driver);
 out_unreg_blkdev:
        unregister_blkdev(FLOPPY_MAJOR, "fd");
 out_put_disk:
@@ -4566,6 +4590,7 @@ static void __exit floppy_module_exit(void)
        blk_unregister_region(MKDEV(FLOPPY_MAJOR, 0), 256);
        unregister_blkdev(FLOPPY_MAJOR, "fd");
+        platform_driver_unregister(&floppy_driver);
        for (drive = 0; drive < N_DRIVE; drive++) {
                del_timer_sync(&motor_off_timer[drive]);
diff --git a/drivers/block/hd.c b/drivers/block/hd.c
index baaa9e486e50..f9d01608cbe2 100644
--- a/drivers/block/hd.c
+++ b/drivers/block/hd.c
@@ -98,10 +98,7 @@
 static DEFINE_SPINLOCK(hd_lock);
 static struct request_queue *hd_queue;
+static struct request *hd_req;
-#define MAJOR_NR HD_MAJOR
-#define QUEUE (hd_queue)
-#define CURRENT elv_next_request(hd_queue)
 #define TIMEOUT_VALUE   (6*HZ)
 #define HD_DELAY        0
@@ -195,11 +192,24 @@ static void __init hd_setup(char *str, int *ints)
        NR_HD = hdind+1;
 }
+static bool hd_end_request(int err, unsigned int bytes)
+{
+        if (__blk_end_request(hd_req, err, bytes))
+                return true;
+        hd_req = NULL;
+        return false;
+}
+static bool hd_end_request_cur(int err)
+{
+        return hd_end_request(err, blk_rq_cur_bytes(hd_req));
+}
 static void dump_status(const char *msg, unsigned int stat)
 {
        char *name = "hd?";
-        if (CURRENT)
+        if (hd_req)
-                name = CURRENT->rq_disk->disk_name;
+                name = hd_req->rq_disk->disk_name;
 #ifdef VERBOSE_ERRORS
        printk("%s: %s: status=0x%02x { ", name, msg, stat & 0xff);
@@ -227,8 +237,8 @@ static void dump_status(const char *msg, unsigned int stat)
                if (hd_error & (BBD_ERR|ECC_ERR|ID_ERR|MARK_ERR)) {
                        printk(", CHS=%d/%d/%d", (inb(HD_HCYL)<<8) + inb(HD_LCYL),
                                inb(HD_CURRENT) & 0xf, inb(HD_SECTOR));
-                        if (CURRENT)
+                        if (hd_req)
-                                printk(", sector=%ld", CURRENT->sector);
+                                printk(", sector=%ld", blk_rq_pos(hd_req));
                }
                printk("\n");
        }
@@ -406,11 +416,12 @@ static void unexpected_hd_interrupt(void)
 */
 static void bad_rw_intr(void)
 {
-        struct request *req = CURRENT;
+        struct request *req = hd_req;
        if (req != NULL) {
                struct hd_i_struct *disk = req->rq_disk->private_data;
                if (++req->errors >= MAX_ERRORS || (hd_error & BBD_ERR)) {
-                        end_request(req, 0);
+                        hd_end_request_cur(-EIO);
                        disk->special_op = disk->recalibrate = 1;
                } else if (req->errors % RESET_FREQ == 0)
                        reset = 1;
@@ -452,37 +463,30 @@ static void read_intr(void)
        bad_rw_intr();
        hd_request();
        return;
 ok_to_read:
-        req = CURRENT;
+        req = hd_req;
        insw(HD_DATA, req->buffer, 256);
-        req->sector++;
-        req->buffer += 512;
-        req->errors = 0;
-        i = --req->nr_sectors;
-        --req->current_nr_sectors;
 #ifdef DEBUG
-        printk("%s: read: sector %ld, remaining = %ld, buffer=%p\n",
+        printk("%s: read: sector %ld, remaining = %u, buffer=%p\n",
-                req->rq_disk->disk_name, req->sector, req->nr_sectors,
+               req->rq_disk->disk_name, blk_rq_pos(req) + 1,
-                req->buffer+512);
+               blk_rq_sectors(req) - 1, req->buffer+512);
 #endif
-        if (req->current_nr_sectors <= 0)
+        if (hd_end_request(0, 512)) {
-                end_request(req, 1);
-        if (i > 0) {
                SET_HANDLER(&read_intr);
                return;
        }
        (void) inb_p(HD_STATUS);
 #if (HD_DELAY > 0)
        last_req = read_timer();
 #endif
-        if (elv_next_request(QUEUE))
+        hd_request();
-                hd_request();
-        return;
 }
 static void write_intr(void)
 {
-        struct request *req = CURRENT;
+        struct request *req = hd_req;
        int i;
        int retries = 100000;
@@ -492,30 +496,25 @@ static void write_intr(void)
                        continue;
                if (!OK_STATUS(i))
                        break;
-                if ((req->nr_sectors <= 1) || (i & DRQ_STAT))
+                if ((blk_rq_sectors(req) <= 1) || (i & DRQ_STAT))
                        goto ok_to_write;
        } while (--retries > 0);
        dump_status("write_intr", i);
        bad_rw_intr();
        hd_request();
        return;
 ok_to_write:
-        req->sector++;
+        if (hd_end_request(0, 512)) {
-        i = --req->nr_sectors;
-        --req->current_nr_sectors;
-        req->buffer += 512;
-        if (!i || (req->bio && req->current_nr_sectors <= 0))
-                end_request(req, 1);
-        if (i > 0) {
                SET_HANDLER(&write_intr);
                outsw(HD_DATA, req->buffer, 256);
-        } else {
+                return;
+        }
 #if (HD_DELAY > 0)
-                last_req = read_timer();
+        last_req = read_timer();
 #endif
-                hd_request();
+        hd_request();
-        }
-        return;
 }
 static void recal_intr(void)
@@ -537,18 +536,18 @@ static void hd_times_out(unsigned long dummy)
        do_hd = NULL;
-        if (!CURRENT)
+        if (!hd_req)
                return;
        spin_lock_irq(hd_queue->queue_lock);
        reset = 1;
-        name = CURRENT->rq_disk->disk_name;
+        name = hd_req->rq_disk->disk_name;
        printk("%s: timeout\n", name);
-        if (++CURRENT->errors >= MAX_ERRORS) {
+        if (++hd_req->errors >= MAX_ERRORS) {
 #ifdef DEBUG
                printk("%s: too many errors\n", name);
 #endif
-                end_request(CURRENT, 0);
+                hd_end_request_cur(-EIO);
        }
        hd_request();
        spin_unlock_irq(hd_queue->queue_lock);
@@ -563,7 +562,7 @@ static int do_special_op(struct hd_i_struct *disk, struct request *req)
        }
        if (disk->head > 16) {
                printk("%s: cannot handle device with more than 16 heads - giving up\n", req->rq_disk->disk_name);
-                end_request(req, 0);
+                hd_end_request_cur(-EIO);
        }
        disk->special_op = 0;
        return 1;
@@ -590,24 +589,27 @@ static void hd_request(void)
 repeat:
        del_timer(&device_timer);
-        req = CURRENT;
+        if (!hd_req) {
-        if (!req) {
+                hd_req = blk_fetch_request(hd_queue);
-                do_hd = NULL;
+                if (!hd_req) {
-                return;
+                        do_hd = NULL;
+                        return;
+                }
        }
+        req = hd_req;
        if (reset) {
                reset_hd();
                return;
        }
        disk = req->rq_disk->private_data;
-        block = req->sector;
+        block = blk_rq_pos(req);
-        nsect = req->nr_sectors;
+        nsect = blk_rq_sectors(req);
        if (block >= get_capacity(req->rq_disk) ||
            ((block+nsect) > get_capacity(req->rq_disk))) {
                printk("%s: bad access: block=%d, count=%d\n",
                        req->rq_disk->disk_name, block, nsect);
-                end_request(req, 0);
+                hd_end_request_cur(-EIO);
                goto repeat;
        }
@@ -647,7 +649,7 @@ repeat:
                        break;
                default:
                        printk("unknown hd-command\n");
-                        end_request(req, 0);
+                        hd_end_request_cur(-EIO);
                        break;
                }
        }
@@ -708,19 +710,19 @@ static int __init hd_init(void)
 {
        int drive;
-        if (register_blkdev(MAJOR_NR, "hd"))
+        if (register_blkdev(HD_MAJOR, "hd"))
                return -1;
        hd_queue = blk_init_queue(do_hd_request, &hd_lock);
        if (!hd_queue) {
-                unregister_blkdev(MAJOR_NR, "hd");
+                unregister_blkdev(HD_MAJOR, "hd");
                return -ENOMEM;
        }
        blk_queue_max_sectors(hd_queue, 255);
        init_timer(&device_timer);
        device_timer.function = hd_times_out;
-        blk_queue_hardsect_size(hd_queue, 512);
+        blk_queue_logical_block_size(hd_queue, 512);
        if (!NR_HD) {
                /*
@@ -747,7 +749,7 @@ static int __init hd_init(void)
                struct hd_i_struct *p = &hd_info[drive];
                if (!disk)
                        goto Enomem;
-                disk->major = MAJOR_NR;
+                disk->major = HD_MAJOR;
                disk->first_minor = drive << 6;
                disk->fops = &hd_fops;
                sprintf(disk->disk_name, "hd%c", 'a'+drive);
@@ -791,7 +793,7 @@ out1:
        NR_HD = 0;
 out:
        del_timer(&device_timer);
-        unregister_blkdev(MAJOR_NR, "hd");
+        unregister_blkdev(HD_MAJOR, "hd");
        blk_cleanup_queue(hd_queue);
        return -1;
 Enomem:
diff --git a/drivers/block/loop.c b/drivers/block/loop.c
index ddae80825899..801f4ab83302 100644
--- a/drivers/block/loop.c
+++ b/drivers/block/loop.c
@@ -511,11 +511,7 @@ out:
 */
 static void loop_add_bio(struct loop_device *lo, struct bio *bio)
 {
-        if (lo->lo_biotail) {
+        bio_list_add(&lo->lo_bio_list, bio);
-                lo->lo_biotail->bi_next = bio;
-                lo->lo_biotail = bio;
-        } else
-                lo->lo_bio = lo->lo_biotail = bio;
 }
 /*
@@ -523,16 +519,7 @@ static void loop_add_bio(struct loop_device *lo, struct bio *bio)
 */
 static struct bio *loop_get_bio(struct loop_device *lo)
 {
-        struct bio *bio;
+        return bio_list_pop(&lo->lo_bio_list);
-        if ((bio = lo->lo_bio)) {
-                if (bio == lo->lo_biotail)
-                        lo->lo_biotail = NULL;
-                lo->lo_bio = bio->bi_next;
-                bio->bi_next = NULL;
-        }
-        return bio;
 }
 static int loop_make_request(struct request_queue *q, struct bio *old_bio)
@@ -609,12 +596,13 @@ static int loop_thread(void *data)
        set_user_nice(current, -20);
-        while (!kthread_should_stop() || lo->lo_bio) {
+        while (!kthread_should_stop() || !bio_list_empty(&lo->lo_bio_list)) {
                wait_event_interruptible(lo->lo_event,
-                                lo->lo_bio || kthread_should_stop());
+                                !bio_list_empty(&lo->lo_bio_list) ||
+                                kthread_should_stop());
-                if (!lo->lo_bio)
+                if (bio_list_empty(&lo->lo_bio_list))
                        continue;
                spin_lock_irq(&lo->lo_lock);
                bio = loop_get_bio(lo);
@@ -721,10 +709,6 @@ static int loop_change_fd(struct loop_device *lo, struct block_device *bdev,
        if (!S_ISREG(inode->i_mode) && !S_ISBLK(inode->i_mode))
                goto out_putf;
-        /* new backing store needs to support loop (eg splice_read) */
-        if (!inode->i_fop->splice_read)
-                goto out_putf;
        /* size of the new backing store needs to be the same */
        if (get_loop_size(lo, file) != get_loop_size(lo, old_file))
                goto out_putf;
@@ -800,12 +784,7 @@ static int loop_set_fd(struct loop_device *lo, fmode_t mode,
        error = -EINVAL;
        if (S_ISREG(inode->i_mode) || S_ISBLK(inode->i_mode)) {
                const struct address_space_operations *aops = mapping->a_ops;
-                /*
-                 * If we can't read - sorry. If we only can't write - well,
-                 * it's going to be read-only.
-                 */
-                if (!file->f_op->splice_read)
-                        goto out_putf;
                if (aops->write_begin)
                        lo_flags |= LO_FLAGS_USE_AOPS;
                if (!(lo_flags & LO_FLAGS_USE_AOPS) && !file->f_op->write)
@@ -841,7 +820,7 @@ static int loop_set_fd(struct loop_device *lo, fmode_t mode,
        lo->old_gfp_mask = mapping_gfp_mask(mapping);
        mapping_set_gfp_mask(mapping, lo->old_gfp_mask & ~(__GFP_IO|__GFP_FS));
-        lo->lo_bio = lo->lo_biotail = NULL;
+        bio_list_init(&lo->lo_bio_list);
        /*
         * set queue make_request_fn, and add limits based on lower level
diff --git a/drivers/block/mg_disk.c b/drivers/block/mg_disk.c
index f3898353d0a8..f703f5478246 100644
--- a/drivers/block/mg_disk.c
+++ b/drivers/block/mg_disk.c
@@ -17,7 +17,7 @@
 #include <linux/fs.h>
 #include <linux/blkdev.h>
 #include <linux/hdreg.h>
-#include <linux/libata.h>
+#include <linux/ata.h>
 #include <linux/interrupt.h>
 #include <linux/delay.h>
 #include <linux/platform_device.h>
@@ -26,62 +26,185 @@
 #define MG_RES_SEC (CONFIG_MG_DISK_RES << 1)
+/* name for block device */
+#define MG_DISK_NAME "mgd"
+#define MG_DISK_MAJ 0
+#define MG_DISK_MAX_PART 16
+#define MG_SECTOR_SIZE 512
+#define MG_MAX_SECTS 256
+/* Register offsets */
+#define MG_BUFF_OFFSET                  0x8000
+#define MG_STORAGE_BUFFER_SIZE          0x200
+#define MG_REG_OFFSET                   0xC000
+#define MG_REG_FEATURE                  (MG_REG_OFFSET + 2)     /* write case */
+#define MG_REG_ERROR                    (MG_REG_OFFSET + 2)     /* read case */
+#define MG_REG_SECT_CNT                 (MG_REG_OFFSET + 4)
+#define MG_REG_SECT_NUM                 (MG_REG_OFFSET + 6)
+#define MG_REG_CYL_LOW                  (MG_REG_OFFSET + 8)
+#define MG_REG_CYL_HIGH                 (MG_REG_OFFSET + 0xA)
+#define MG_REG_DRV_HEAD                 (MG_REG_OFFSET + 0xC)
+#define MG_REG_COMMAND                  (MG_REG_OFFSET + 0xE)   /* write case */
+#define MG_REG_STATUS                   (MG_REG_OFFSET + 0xE)   /* read  case */
+#define MG_REG_DRV_CTRL                 (MG_REG_OFFSET + 0x10)
+#define MG_REG_BURST_CTRL               (MG_REG_OFFSET + 0x12)
+/* handy status */
+#define MG_STAT_READY   (ATA_DRDY | ATA_DSC)
+#define MG_READY_OK(s)  (((s) & (MG_STAT_READY | (ATA_BUSY | ATA_DF | \
+                                 ATA_ERR))) == MG_STAT_READY)
+/* error code for others */
+#define MG_ERR_NONE             0
+#define MG_ERR_TIMEOUT          0x100
+#define MG_ERR_INIT_STAT        0x101
+#define MG_ERR_TRANSLATION      0x102
+#define MG_ERR_CTRL_RST         0x103
+#define MG_ERR_INV_STAT         0x104
+#define MG_ERR_RSTOUT           0x105
+#define MG_MAX_ERRORS   6       /* Max read/write errors */
+/* command */
+#define MG_CMD_RD 0x20
+#define MG_CMD_WR 0x30
+#define MG_CMD_SLEEP 0x99
+#define MG_CMD_WAKEUP 0xC3
+#define MG_CMD_ID 0xEC
+#define MG_CMD_WR_CONF 0x3C
+#define MG_CMD_RD_CONF 0x40
+/* operation mode */
+#define MG_OP_CASCADE (1 << 0)
+#define MG_OP_CASCADE_SYNC_RD (1 << 1)
+#define MG_OP_CASCADE_SYNC_WR (1 << 2)
+#define MG_OP_INTERLEAVE (1 << 3)
+/* synchronous */
+#define MG_BURST_LAT_4 (3 << 4)
+#define MG_BURST_LAT_5 (4 << 4)
+#define MG_BURST_LAT_6 (5 << 4)
+#define MG_BURST_LAT_7 (6 << 4)
+#define MG_BURST_LAT_8 (7 << 4)
+#define MG_BURST_LEN_4 (1 << 1)
+#define MG_BURST_LEN_8 (2 << 1)
+#define MG_BURST_LEN_16 (3 << 1)
+#define MG_BURST_LEN_32 (4 << 1)
+#define MG_BURST_LEN_CONT (0 << 1)
+/* timeout value (unit: ms) */
+#define MG_TMAX_CONF_TO_CMD     1
+#define MG_TMAX_WAIT_RD_DRQ     10
+#define MG_TMAX_WAIT_WR_DRQ     500
+#define MG_TMAX_RST_TO_BUSY     10
+#define MG_TMAX_HDRST_TO_RDY    500
+#define MG_TMAX_SWRST_TO_RDY    500
+#define MG_TMAX_RSTOUT          3000
+#define MG_DEV_MASK (MG_BOOT_DEV | MG_STORAGE_DEV | MG_STORAGE_DEV_SKIP_RST)
+/* main structure for mflash driver */
+struct mg_host {
+        struct device *dev;
+        struct request_queue *breq;
+        struct request *req;
+        spinlock_t lock;
+        struct gendisk *gd;
+        struct timer_list timer;
+        void (*mg_do_intr) (struct mg_host *);
+        u16 id[ATA_ID_WORDS];
+        u16 cyls;
+        u16 heads;
+        u16 sectors;
+        u32 n_sectors;
+        u32 nres_sectors;
+        void __iomem *dev_base;
+        unsigned int irq;
+        unsigned int rst;
+        unsigned int rstout;
+        u32 major;
+        u32 error;
+};
+/*
+ * Debugging macro and defines
+ */
+#undef DO_MG_DEBUG
+#ifdef DO_MG_DEBUG
+#  define MG_DBG(fmt, args...) \
+        printk(KERN_DEBUG "%s:%d "fmt, __func__, __LINE__, ##args)
+#else /* CONFIG_MG_DEBUG */
+#  define MG_DBG(fmt, args...) do { } while (0)
+#endif /* CONFIG_MG_DEBUG */
 static void mg_request(struct request_queue *);
+static bool mg_end_request(struct mg_host *host, int err, unsigned int nr_bytes)
+{
+        if (__blk_end_request(host->req, err, nr_bytes))
+                return true;
+        host->req = NULL;
+        return false;
+}
+static bool mg_end_request_cur(struct mg_host *host, int err)
+{
+        return mg_end_request(host, err, blk_rq_cur_bytes(host->req));
+}
 static void mg_dump_status(const char *msg, unsigned int stat,
                struct mg_host *host)
 {
        char *name = MG_DISK_NAME;
-        struct request *req;
-        if (host->breq) {
+        if (host->req)
-                req = elv_next_request(host->breq);
+                name = host->req->rq_disk->disk_name;
-                if (req)
-                        name = req->rq_disk->disk_name;
-        }
        printk(KERN_ERR "%s: %s: status=0x%02x { ", name, msg, stat & 0xff);
-        if (stat & MG_REG_STATUS_BIT_BUSY)
+        if (stat & ATA_BUSY)
                printk("Busy ");
-        if (stat & MG_REG_STATUS_BIT_READY)
+        if (stat & ATA_DRDY)
                printk("DriveReady ");
-        if (stat & MG_REG_STATUS_BIT_WRITE_FAULT)
+        if (stat & ATA_DF)
                printk("WriteFault ");
-        if (stat & MG_REG_STATUS_BIT_SEEK_DONE)
+        if (stat & ATA_DSC)
                printk("SeekComplete ");
-        if (stat & MG_REG_STATUS_BIT_DATA_REQ)
+        if (stat & ATA_DRQ)
                printk("DataRequest ");
-        if (stat & MG_REG_STATUS_BIT_CORRECTED_ERROR)
+        if (stat & ATA_CORR)
                printk("CorrectedError ");
-        if (stat & MG_REG_STATUS_BIT_ERROR)
+        if (stat & ATA_ERR)
                printk("Error ");
        printk("}\n");
-        if ((stat & MG_REG_STATUS_BIT_ERROR) == 0) {
+        if ((stat & ATA_ERR) == 0) {
                host->error = 0;
        } else {
                host->error = inb((unsigned long)host->dev_base + MG_REG_ERROR);
                printk(KERN_ERR "%s: %s: error=0x%02x { ", name, msg,
                                host->error & 0xff);
-                if (host->error & MG_REG_ERR_BBK)
+                if (host->error & ATA_BBK)
                        printk("BadSector ");
-                if (host->error & MG_REG_ERR_UNC)
+                if (host->error & ATA_UNC)
                        printk("UncorrectableError ");
-                if (host->error & MG_REG_ERR_IDNF)
+                if (host->error & ATA_IDNF)
                        printk("SectorIdNotFound ");
-                if (host->error & MG_REG_ERR_ABRT)
+                if (host->error & ATA_ABORTED)
                        printk("DriveStatusError ");
-                if (host->error & MG_REG_ERR_AMNF)
+                if (host->error & ATA_AMNF)
                        printk("AddrMarkNotFound ");
                printk("}");
-                if (host->error &
+                if (host->error & (ATA_BBK | ATA_UNC | ATA_IDNF | ATA_AMNF)) {
-                                (MG_REG_ERR_BBK | MG_REG_ERR_UNC |
+                        if (host->req)
-                                 MG_REG_ERR_IDNF | MG_REG_ERR_AMNF)) {
+                                printk(", sector=%u",
-                        if (host->breq) {
+                                       (unsigned int)blk_rq_pos(host->req));
-                                req = elv_next_request(host->breq);
-                                if (req)
-                                        printk(", sector=%u", (u32)req->sector);
-                        }
                }
                printk("\n");
        }
@@ -100,12 +223,12 @@ static unsigned int mg_wait(struct mg_host *host, u32 expect, u32 msec)
        do {
                cur_jiffies = jiffies;
-                if (status & MG_REG_STATUS_BIT_BUSY) {
+                if (status & ATA_BUSY) {
-                        if (expect == MG_REG_STATUS_BIT_BUSY)
+                        if (expect == ATA_BUSY)
                                break;
                } else {
                        /* Check the error condition! */
-                        if (status & MG_REG_STATUS_BIT_ERROR) {
+                        if (status & ATA_ERR) {
                                mg_dump_status("mg_wait", status, host);
                                break;
                        }
@@ -114,8 +237,8 @@ static unsigned int mg_wait(struct mg_host *host, u32 expect, u32 msec)
                                if (MG_READY_OK(status))
                                        break;
-                        if (expect == MG_REG_STATUS_BIT_DATA_REQ)
+                        if (expect == ATA_DRQ)
-                                if (status & MG_REG_STATUS_BIT_DATA_REQ)
+                                if (status & ATA_DRQ)
                                        break;
                }
                if (!msec) {
@@ -173,6 +296,42 @@ static irqreturn_t mg_irq(int irq, void *dev_id)
        return IRQ_HANDLED;
 }
+/* local copy of ata_id_string() */
+static void mg_id_string(const u16 *id, unsigned char *s,
+                         unsigned int ofs, unsigned int len)
+{
+        unsigned int c;
+        BUG_ON(len & 1);
+        while (len > 0) {
+                c = id[ofs] >> 8;
+                *s = c;
+                s++;
+                c = id[ofs] & 0xff;
+                *s = c;
+                s++;
+                ofs++;
+                len -= 2;
+        }
+}
+/* local copy of ata_id_c_string() */
+static void mg_id_c_string(const u16 *id, unsigned char *s,
+                           unsigned int ofs, unsigned int len)
+{
+        unsigned char *p;
+        mg_id_string(id, s, ofs, len - 1);
+        p = s + strnlen(s, len - 1);
+        while (p > s && p[-1] == ' ')
+                p--;
+        *p = '\0';
+}
 static int mg_get_disk_id(struct mg_host *host)
 {
        u32 i;
@@ -184,12 +343,10 @@ static int mg_get_disk_id(struct mg_host *host)
        char serial[ATA_ID_SERNO_LEN + 1];
        if (!prv_data->use_polling)
-                outb(MG_REG_CTRL_INTR_DISABLE,
+                outb(ATA_NIEN, (unsigned long)host->dev_base + MG_REG_DRV_CTRL);
-                                (unsigned long)host->dev_base +
-                                MG_REG_DRV_CTRL);
        outb(MG_CMD_ID, (unsigned long)host->dev_base + MG_REG_COMMAND);
-        err = mg_wait(host, MG_REG_STATUS_BIT_DATA_REQ, MG_TMAX_WAIT_RD_DRQ);
+        err = mg_wait(host, ATA_DRQ, MG_TMAX_WAIT_RD_DRQ);
        if (err)
                return err;
@@ -219,9 +376,9 @@ static int mg_get_disk_id(struct mg_host *host)
                host->n_sectors -= host->nres_sectors;
        }
-        ata_id_c_string(id, fwrev, ATA_ID_FW_REV, sizeof(fwrev));
+        mg_id_c_string(id, fwrev, ATA_ID_FW_REV, sizeof(fwrev));
-        ata_id_c_string(id, model, ATA_ID_PROD, sizeof(model));
+        mg_id_c_string(id, model, ATA_ID_PROD, sizeof(model));
-        ata_id_c_string(id, serial, ATA_ID_SERNO, sizeof(serial));
+        mg_id_c_string(id, serial, ATA_ID_SERNO, sizeof(serial));
        printk(KERN_INFO "mg_disk: model: %s\n", model);
        printk(KERN_INFO "mg_disk: firm: %.8s\n", fwrev);
        printk(KERN_INFO "mg_disk: serial: %s\n", serial);
@@ -229,8 +386,7 @@ static int mg_get_disk_id(struct mg_host *host)
                        host->n_sectors, host->nres_sectors);
        if (!prv_data->use_polling)
-                outb(MG_REG_CTRL_INTR_ENABLE, (unsigned long)host->dev_base +
+                outb(0, (unsigned long)host->dev_base + MG_REG_DRV_CTRL);
-                                MG_REG_DRV_CTRL);
        return err;
 }
@@ -244,7 +400,7 @@ static int mg_disk_init(struct mg_host *host)
        /* hdd rst low */
        gpio_set_value(host->rst, 0);
-        err = mg_wait(host, MG_REG_STATUS_BIT_BUSY, MG_TMAX_RST_TO_BUSY);
+        err = mg_wait(host, ATA_BUSY, MG_TMAX_RST_TO_BUSY);
        if (err)
                return err;
@@ -255,17 +411,14 @@ static int mg_disk_init(struct mg_host *host)
                return err;
        /* soft reset on */
-        outb(MG_REG_CTRL_RESET |
+        outb(ATA_SRST | (prv_data->use_polling ? ATA_NIEN : 0),
-                        (prv_data->use_polling ? MG_REG_CTRL_INTR_DISABLE :
-                         MG_REG_CTRL_INTR_ENABLE),
                        (unsigned long)host->dev_base + MG_REG_DRV_CTRL);
-        err = mg_wait(host, MG_REG_STATUS_BIT_BUSY, MG_TMAX_RST_TO_BUSY);
+        err = mg_wait(host, ATA_BUSY, MG_TMAX_RST_TO_BUSY);
        if (err)
                return err;
        /* soft reset off */
-        outb(prv_data->use_polling ? MG_REG_CTRL_INTR_DISABLE :
+        outb(prv_data->use_polling ? ATA_NIEN : 0,
-                        MG_REG_CTRL_INTR_ENABLE,
                        (unsigned long)host->dev_base + MG_REG_DRV_CTRL);
        err = mg_wait(host, MG_STAT_READY, MG_TMAX_SWRST_TO_RDY);
        if (err)
@@ -281,11 +434,10 @@ static int mg_disk_init(struct mg_host *host)
 static void mg_bad_rw_intr(struct mg_host *host)
 {
-        struct request *req = elv_next_request(host->breq);
+        if (host->req)
-        if (req != NULL)
+                if (++host->req->errors >= MG_MAX_ERRORS ||
-                if (++req->errors >= MG_MAX_ERRORS ||
+                    host->error == MG_ERR_TIMEOUT)
-                                host->error == MG_ERR_TIMEOUT)
+                        mg_end_request_cur(host, -EIO);
-                        end_request(req, 0);
 }
 static unsigned int mg_out(struct mg_host *host,
@@ -311,7 +463,7 @@ static unsigned int mg_out(struct mg_host *host,
                        MG_REG_CYL_LOW);
        outb((u8)(sect_num >> 16), (unsigned long)host->dev_base +
                        MG_REG_CYL_HIGH);
-        outb((u8)((sect_num >> 24) | MG_REG_HEAD_LBA_MODE),
+        outb((u8)((sect_num >> 24) | ATA_LBA | ATA_DEVICE_OBS),
                        (unsigned long)host->dev_base + MG_REG_DRV_HEAD);
        outb(cmd, (unsigned long)host->dev_base + MG_REG_COMMAND);
        return MG_ERR_NONE;
@@ -319,105 +471,77 @@ static unsigned int mg_out(struct mg_host *host,
 static void mg_read(struct request *req)
 {
-        u32 remains, j;
+        u32 j;
        struct mg_host *host = req->rq_disk->private_data;
-        remains = req->nr_sectors;
+        if (mg_out(host, blk_rq_pos(req), blk_rq_sectors(req),
+                   MG_CMD_RD, NULL) != MG_ERR_NONE)
-        if (mg_out(host, req->sector, req->nr_sectors, MG_CMD_RD, NULL) !=
-                        MG_ERR_NONE)
                mg_bad_rw_intr(host);
        MG_DBG("requested %d sects (from %ld), buffer=0x%p\n",
-                        remains, req->sector, req->buffer);
+               blk_rq_sectors(req), blk_rq_pos(req), req->buffer);
+        do {
+                u16 *buff = (u16 *)req->buffer;
-        while (remains) {
+                if (mg_wait(host, ATA_DRQ,
-                if (mg_wait(host, MG_REG_STATUS_BIT_DATA_REQ,
+                            MG_TMAX_WAIT_RD_DRQ) != MG_ERR_NONE) {
-                                        MG_TMAX_WAIT_RD_DRQ) != MG_ERR_NONE) {
                        mg_bad_rw_intr(host);
                        return;
                }
-                for (j = 0; j < MG_SECTOR_SIZE >> 1; j++) {
+                for (j = 0; j < MG_SECTOR_SIZE >> 1; j++)
-                        *(u16 *)req->buffer =
+                        *buff++ = inw((unsigned long)host->dev_base +
-                                inw((unsigned long)host->dev_base +
+                                      MG_BUFF_OFFSET + (j << 1));
-                                                MG_BUFF_OFFSET + (j << 1));
-                        req->buffer += 2;
-                }
-                req->sector++;
-                req->errors = 0;
-                remains = --req->nr_sectors;
-                --req->current_nr_sectors;
-                if (req->current_nr_sectors <= 0) {
-                        MG_DBG("remain : %d sects\n", remains);
-                        end_request(req, 1);
-                        if (remains > 0)
-                                req = elv_next_request(host->breq);
-                }
                outb(MG_CMD_RD_CONF, (unsigned long)host->dev_base +
                                MG_REG_COMMAND);
-        }
+        } while (mg_end_request(host, 0, MG_SECTOR_SIZE));
 }
 static void mg_write(struct request *req)
 {
-        u32 remains, j;
+        u32 j;
        struct mg_host *host = req->rq_disk->private_data;
-        remains = req->nr_sectors;
+        if (mg_out(host, blk_rq_pos(req), blk_rq_sectors(req),
+                   MG_CMD_WR, NULL) != MG_ERR_NONE) {
-        if (mg_out(host, req->sector, req->nr_sectors, MG_CMD_WR, NULL) !=
-                        MG_ERR_NONE) {
                mg_bad_rw_intr(host);
                return;
        }
        MG_DBG("requested %d sects (from %ld), buffer=0x%p\n",
-                        remains, req->sector, req->buffer);
+               blk_rq_sectors(req), blk_rq_pos(req), req->buffer);
-        while (remains) {
-                if (mg_wait(host, MG_REG_STATUS_BIT_DATA_REQ,
+        do {
-                                        MG_TMAX_WAIT_WR_DRQ) != MG_ERR_NONE) {
+                u16 *buff = (u16 *)req->buffer;
+        if (mg_wait(host, ATA_DRQ, MG_TMAX_WAIT_WR_DRQ) != MG_ERR_NONE) {
                        mg_bad_rw_intr(host);
                        return;
                }
-                for (j = 0; j < MG_SECTOR_SIZE >> 1; j++) {
+                for (j = 0; j < MG_SECTOR_SIZE >> 1; j++)
-                        outw(*(u16 *)req->buffer,
+                        outw(*buff++, (unsigned long)host->dev_base +
-                                        (unsigned long)host->dev_base +
+                                      MG_BUFF_OFFSET + (j << 1));
-                                        MG_BUFF_OFFSET + (j << 1));
-                        req->buffer += 2;
-                }
-                req->sector++;
-                remains = --req->nr_sectors;
-                --req->current_nr_sectors;
-                if (req->current_nr_sectors <= 0) {
-                        MG_DBG("remain : %d sects\n", remains);
-                        end_request(req, 1);
-                        if (remains > 0)
-                                req = elv_next_request(host->breq);
-                }
                outb(MG_CMD_WR_CONF, (unsigned long)host->dev_base +
                                MG_REG_COMMAND);
-        }
+        } while (mg_end_request(host, 0, MG_SECTOR_SIZE));
 }
 static void mg_read_intr(struct mg_host *host)
 {
+        struct request *req = host->req;
        u32 i;
-        struct request *req;
+        u16 *buff;
        /* check status */
        do {
                i = inb((unsigned long)host->dev_base + MG_REG_STATUS);
-                if (i & MG_REG_STATUS_BIT_BUSY)
+                if (i & ATA_BUSY)
                        break;
                if (!MG_READY_OK(i))
                        break;
-                if (i & MG_REG_STATUS_BIT_DATA_REQ)
+                if (i & ATA_DRQ)
                        goto ok_to_read;
        } while (0);
        mg_dump_status("mg_read_intr", i, host);
@@ -427,60 +551,42 @@ static void mg_read_intr(struct mg_host *host)
 ok_to_read:
        /* get current segment of request */
-        req = elv_next_request(host->breq);
+        buff = (u16 *)req->buffer;
        /* read 1 sector */
-        for (i = 0; i < MG_SECTOR_SIZE >> 1; i++) {
+        for (i = 0; i < MG_SECTOR_SIZE >> 1; i++)
-                *(u16 *)req->buffer =
+                *buff++ = inw((unsigned long)host->dev_base + MG_BUFF_OFFSET +
-                        inw((unsigned long)host->dev_base + MG_BUFF_OFFSET +
+                              (i << 1));
-                                        (i << 1));
-                req->buffer += 2;
-        }
-        /* manipulate request */
        MG_DBG("sector %ld, remaining=%ld, buffer=0x%p\n",
-                        req->sector, req->nr_sectors - 1, req->buffer);
+               blk_rq_pos(req), blk_rq_sectors(req) - 1, req->buffer);
-        req->sector++;
-        req->errors = 0;
-        i = --req->nr_sectors;
-        --req->current_nr_sectors;
-        /* let know if current segment done */
-        if (req->current_nr_sectors <= 0)
-                end_request(req, 1);
-        /* set handler if read remains */
-        if (i > 0) {
-                host->mg_do_intr = mg_read_intr;
-                mod_timer(&host->timer, jiffies + 3 * HZ);
-        }
        /* send read confirm */
        outb(MG_CMD_RD_CONF, (unsigned long)host->dev_base + MG_REG_COMMAND);
-        /* goto next request */
+        if (mg_end_request(host, 0, MG_SECTOR_SIZE)) {
-        if (!i)
+                /* set handler if read remains */
+                host->mg_do_intr = mg_read_intr;
+                mod_timer(&host->timer, jiffies + 3 * HZ);
+        } else /* goto next request */
                mg_request(host->breq);
 }
 static void mg_write_intr(struct mg_host *host)
 {
+        struct request *req = host->req;
        u32 i, j;
        u16 *buff;
-        struct request *req;
+        bool rem;
-        /* get current segment of request */
-        req = elv_next_request(host->breq);
        /* check status */
        do {
                i = inb((unsigned long)host->dev_base + MG_REG_STATUS);
-                if (i & MG_REG_STATUS_BIT_BUSY)
+                if (i & ATA_BUSY)
                        break;
                if (!MG_READY_OK(i))
                        break;
-                if ((req->nr_sectors <= 1) || (i & MG_REG_STATUS_BIT_DATA_REQ))
+                if ((blk_rq_sectors(req) <= 1) || (i & ATA_DRQ))
                        goto ok_to_write;
        } while (0);
        mg_dump_status("mg_write_intr", i, host);
@@ -489,18 +595,8 @@ static void mg_write_intr(struct mg_host *host)
        return;
 ok_to_write:
-        /* manipulate request */
+        if ((rem = mg_end_request(host, 0, MG_SECTOR_SIZE))) {
-        req->sector++;
+                /* write 1 sector and set handler if remains */
-        i = --req->nr_sectors;
-        --req->current_nr_sectors;
-        req->buffer += MG_SECTOR_SIZE;
-        /* let know if current segment or all done */
-        if (!i || (req->bio && req->current_nr_sectors <= 0))
-                end_request(req, 1);
-        /* write 1 sector and set handler if remains */
-        if (i > 0) {
                buff = (u16 *)req->buffer;
                for (j = 0; j < MG_STORAGE_BUFFER_SIZE >> 1; j++) {
                        outw(*buff, (unsigned long)host->dev_base +
@@ -508,7 +604,7 @@ ok_to_write:
                        buff++;
                }
                MG_DBG("sector %ld, remaining=%ld, buffer=0x%p\n",
-                                req->sector, req->nr_sectors, req->buffer);
+                       blk_rq_pos(req), blk_rq_sectors(req), req->buffer);
                host->mg_do_intr = mg_write_intr;
                mod_timer(&host->timer, jiffies + 3 * HZ);
        }
@@ -516,7 +612,7 @@ ok_to_write:
        /* send write confirm */
        outb(MG_CMD_WR_CONF, (unsigned long)host->dev_base + MG_REG_COMMAND);
-        if (!i)
+        if (!rem)
                mg_request(host->breq);
 }
@@ -524,49 +620,45 @@ void mg_times_out(unsigned long data)
 {
        struct mg_host *host = (struct mg_host *)data;
        char *name;
-        struct request *req;
        spin_lock_irq(&host->lock);
-        req = elv_next_request(host->breq);
+        if (!host->req)
-        if (!req)
                goto out_unlock;
        host->mg_do_intr = NULL;
-        name = req->rq_disk->disk_name;
+        name = host->req->rq_disk->disk_name;
        printk(KERN_DEBUG "%s: timeout\n", name);
        host->error = MG_ERR_TIMEOUT;
        mg_bad_rw_intr(host);
-        mg_request(host->breq);
 out_unlock:
+        mg_request(host->breq);
        spin_unlock_irq(&host->lock);
 }
 static void mg_request_poll(struct request_queue *q)
 {
-        struct request *req;
+        struct mg_host *host = q->queuedata;
-        struct mg_host *host;
-        while ((req = elv_next_request(q)) != NULL) {
+        while (1) {
-                host = req->rq_disk->private_data;
+                if (!host->req) {
-                if (blk_fs_request(req)) {
+                        host->req = blk_fetch_request(q);
-                        switch (rq_data_dir(req)) {
+                        if (!host->req)
-                        case READ:
-                                mg_read(req);
-                                break;
-                        case WRITE:
-                                mg_write(req);
-                                break;
-                        default:
-                                printk(KERN_WARNING "%s:%d unknown command\n",
-                                                __func__, __LINE__);
-                                end_request(req, 0);
                                break;
-                        }
                }
+                if (unlikely(!blk_fs_request(host->req))) {
+                        mg_end_request_cur(host, -EIO);
+                        continue;
+                }
+                if (rq_data_dir(host->req) == READ)
+                        mg_read(host->req);
+                else
+                        mg_write(host->req);
        }
 }
@@ -588,18 +680,15 @@ static unsigned int mg_issue_req(struct request *req,
                break;
        case WRITE:
                /* TODO : handler */
-                outb(MG_REG_CTRL_INTR_DISABLE,
+                outb(ATA_NIEN, (unsigned long)host->dev_base + MG_REG_DRV_CTRL);
-                                (unsigned long)host->dev_base +
-                                MG_REG_DRV_CTRL);
                if (mg_out(host, sect_num, sect_cnt, MG_CMD_WR, &mg_write_intr)
                                != MG_ERR_NONE) {
                        mg_bad_rw_intr(host);
                        return host->error;
                }
                del_timer(&host->timer);
-                mg_wait(host, MG_REG_STATUS_BIT_DATA_REQ, MG_TMAX_WAIT_WR_DRQ);
+                mg_wait(host, ATA_DRQ, MG_TMAX_WAIT_WR_DRQ);
-                outb(MG_REG_CTRL_INTR_ENABLE, (unsigned long)host->dev_base +
+                outb(0, (unsigned long)host->dev_base + MG_REG_DRV_CTRL);
-                                MG_REG_DRV_CTRL);
                if (host->error) {
                        mg_bad_rw_intr(host);
                        return host->error;
@@ -614,11 +703,6 @@ static unsigned int mg_issue_req(struct request *req,
                outb(MG_CMD_WR_CONF, (unsigned long)host->dev_base +
                                MG_REG_COMMAND);
                break;
-        default:
-                printk(KERN_WARNING "%s:%d unknown command\n",
-                                __func__, __LINE__);
-                end_request(req, 0);
-                break;
        }
        return MG_ERR_NONE;
 }
@@ -626,16 +710,17 @@ static unsigned int mg_issue_req(struct request *req,
 /* This function also called from IRQ context */
 static void mg_request(struct request_queue *q)
 {
+        struct mg_host *host = q->queuedata;
        struct request *req;
-        struct mg_host *host;
        u32 sect_num, sect_cnt;
        while (1) {
-                req = elv_next_request(q);
+                if (!host->req) {
-                if (!req)
+                        host->req = blk_fetch_request(q);
-                        return;
+                        if (!host->req)
+                                break;
-                host = req->rq_disk->private_data;
+                }
+                req = host->req;
                /* check unwanted request call */
                if (host->mg_do_intr)
@@ -643,9 +728,9 @@ static void mg_request(struct request_queue *q)
                del_timer(&host->timer);
-                sect_num = req->sector;
+                sect_num = blk_rq_pos(req);
                /* deal whole segments */
-                sect_cnt = req->nr_sectors;
+                sect_cnt = blk_rq_sectors(req);
                /* sanity check */
                if (sect_num >= get_capacity(req->rq_disk) ||
@@ -655,12 +740,14 @@ static void mg_request(struct request_queue *q)
                                        "%s: bad access: sector=%d, count=%d\n",
                                        req->rq_disk->disk_name,
                                        sect_num, sect_cnt);
-                        end_request(req, 0);
+                        mg_end_request_cur(host, -EIO);
                        continue;
                }
-                if (!blk_fs_request(req))
+                if (unlikely(!blk_fs_request(req))) {
-                        return;
+                        mg_end_request_cur(host, -EIO);
+                        continue;
+                }
                if (!mg_issue_req(req, host, sect_num, sect_cnt))
                        return;
@@ -690,9 +777,7 @@ static int mg_suspend(struct platform_device *plat_dev, pm_message_t state)
                return -EIO;
        if (!prv_data->use_polling)
-                outb(MG_REG_CTRL_INTR_DISABLE,
+                outb(ATA_NIEN, (unsigned long)host->dev_base + MG_REG_DRV_CTRL);
-                                (unsigned long)host->dev_base +
-                                MG_REG_DRV_CTRL);
        outb(MG_CMD_SLEEP, (unsigned long)host->dev_base + MG_REG_COMMAND);
        /* wait until mflash deep sleep */
@@ -700,9 +785,7 @@ static int mg_suspend(struct platform_device *plat_dev, pm_message_t state)
        if (mg_wait(host, MG_STAT_READY, MG_TMAX_CONF_TO_CMD)) {
                if (!prv_data->use_polling)
-                        outb(MG_REG_CTRL_INTR_ENABLE,
+                        outb(0, (unsigned long)host->dev_base + MG_REG_DRV_CTRL);
-                                        (unsigned long)host->dev_base +
-                                        MG_REG_DRV_CTRL);
                return -EIO;
        }
@@ -725,8 +808,7 @@ static int mg_resume(struct platform_device *plat_dev)
                return -EIO;
        if (!prv_data->use_polling)
-                outb(MG_REG_CTRL_INTR_ENABLE, (unsigned long)host->dev_base +
+                outb(0, (unsigned long)host->dev_base + MG_REG_DRV_CTRL);
-                                MG_REG_DRV_CTRL);
        return 0;
 }
@@ -877,6 +959,7 @@ static int mg_probe(struct platform_device *plat_dev)
                                __func__, __LINE__);
                goto probe_err_5;
        }
+        host->breq->queuedata = host;
        /* mflash is random device, thanx for the noop */
        elevator_exit(host->breq->elevator);
@@ -887,7 +970,7 @@ static int mg_probe(struct platform_device *plat_dev)
                goto probe_err_6;
        }
        blk_queue_max_sectors(host->breq, MG_MAX_SECTS);
-        blk_queue_hardsect_size(host->breq, MG_SECTOR_SIZE);
+        blk_queue_logical_block_size(host->breq, MG_SECTOR_SIZE);
        init_timer(&host->timer);
        host->timer.function = mg_times_out;
diff --git a/drivers/block/nbd.c b/drivers/block/nbd.c
index 4d6de4f15ccb..5d23ffad7c77 100644
--- a/drivers/block/nbd.c
+++ b/drivers/block/nbd.c
@@ -110,7 +110,7 @@ static void nbd_end_request(struct request *req)
                        req, error ? "failed" : "done");
        spin_lock_irqsave(q->queue_lock, flags);
-        __blk_end_request(req, error, req->nr_sectors << 9);
+        __blk_end_request_all(req, error);
        spin_unlock_irqrestore(q->queue_lock, flags);
 }
@@ -231,19 +231,19 @@ static int nbd_send_req(struct nbd_device *lo, struct request *req)
 {
        int result, flags;
        struct nbd_request request;
-        unsigned long size = req->nr_sectors << 9;
+        unsigned long size = blk_rq_bytes(req);
        request.magic = htonl(NBD_REQUEST_MAGIC);
        request.type = htonl(nbd_cmd(req));
-        request.from = cpu_to_be64((u64) req->sector << 9);
+        request.from = cpu_to_be64((u64)blk_rq_pos(req) << 9);
        request.len = htonl(size);
        memcpy(request.handle, &req, sizeof(req));
-        dprintk(DBG_TX, "%s: request %p: sending control (%s@%llu,%luB)\n",
+        dprintk(DBG_TX, "%s: request %p: sending control (%s@%llu,%uB)\n",
                        lo->disk->disk_name, req,
                        nbdcmd_to_ascii(nbd_cmd(req)),
-                        (unsigned long long)req->sector << 9,
+                        (unsigned long long)blk_rq_pos(req) << 9,
-                        req->nr_sectors << 9);
+                        blk_rq_bytes(req));
        result = sock_xmit(lo, 1, &request, sizeof(request),
                        (nbd_cmd(req) == NBD_CMD_WRITE) ? MSG_MORE : 0);
        if (result <= 0) {
@@ -533,11 +533,9 @@ static void do_nbd_request(struct request_queue *q)
 {
        struct request *req;
        
-        while ((req = elv_next_request(q)) != NULL) {
+        while ((req = blk_fetch_request(q)) != NULL) {
                struct nbd_device *lo;
-                blkdev_dequeue_request(req);
                spin_unlock_irq(q->queue_lock);
                dprintk(DBG_BLKDEV, "%s: request %p: dequeued (flags=%x)\n",
@@ -580,13 +578,6 @@ static int __nbd_ioctl(struct block_device *bdev, struct nbd_device *lo,
                blk_rq_init(NULL, &sreq);
                sreq.cmd_type = REQ_TYPE_SPECIAL;
                nbd_cmd(&sreq) = NBD_CMD_DISC;
-                /*
-                 * Set these to sane values in case server implementation
-                 * fails to check the request type first and also to keep
-                 * debugging output cleaner.
-                 */
-                sreq.sector = 0;
-                sreq.nr_sectors = 0;
                if (!lo->sock)
                        return -EINVAL;
                nbd_send_req(lo, &sreq);
diff --git a/drivers/block/paride/pcd.c b/drivers/block/paride/pcd.c
index e91d4b4b014f..911dfd98d813 100644
--- a/drivers/block/paride/pcd.c
+++ b/drivers/block/paride/pcd.c
@@ -719,32 +719,37 @@ static void do_pcd_request(struct request_queue * q)
        if (pcd_busy)
                return;
        while (1) {
-                pcd_req = elv_next_request(q);
+                if (!pcd_req) {
-                if (!pcd_req)
+                        pcd_req = blk_fetch_request(q);
-                        return;
+                        if (!pcd_req)
+                                return;
+                }
                if (rq_data_dir(pcd_req) == READ) {
                        struct pcd_unit *cd = pcd_req->rq_disk->private_data;
                        if (cd != pcd_current)
                                pcd_bufblk = -1;
                        pcd_current = cd;
-                        pcd_sector = pcd_req->sector;
+                        pcd_sector = blk_rq_pos(pcd_req);
-                        pcd_count = pcd_req->current_nr_sectors;
+                        pcd_count = blk_rq_cur_sectors(pcd_req);
                        pcd_buf = pcd_req->buffer;
                        pcd_busy = 1;
                        ps_set_intr(do_pcd_read, NULL, 0, nice);
                        return;
-                } else
+                } else {
-                        end_request(pcd_req, 0);
+                        __blk_end_request_all(pcd_req, -EIO);
+                        pcd_req = NULL;
+                }
        }
 }
-static inline void next_request(int success)
+static inline void next_request(int err)
 {
        unsigned long saved_flags;
        spin_lock_irqsave(&pcd_lock, saved_flags);
-        end_request(pcd_req, success);
+        if (!__blk_end_request_cur(pcd_req, err))
+                pcd_req = NULL;
        pcd_busy = 0;
        do_pcd_request(pcd_queue);
        spin_unlock_irqrestore(&pcd_lock, saved_flags);
@@ -781,7 +786,7 @@ static void pcd_start(void)
        if (pcd_command(pcd_current, rd_cmd, 2048, "read block")) {
                pcd_bufblk = -1;
-                next_request(0);
+                next_request(-EIO);
                return;
        }
@@ -796,7 +801,7 @@ static void do_pcd_read(void)
        pcd_retries = 0;
        pcd_transfer();
        if (!pcd_count) {
-                next_request(1);
+                next_request(0);
                return;
        }
@@ -815,7 +820,7 @@ static void do_pcd_read_drq(void)
                        return;
                }
                pcd_bufblk = -1;
-                next_request(0);
+                next_request(-EIO);
                return;
        }
diff --git a/drivers/block/paride/pd.c b/drivers/block/paride/pd.c
index 9299455b0af6..bf5955b3d873 100644
--- a/drivers/block/paride/pd.c
+++ b/drivers/block/paride/pd.c
@@ -410,10 +410,12 @@ static void run_fsm(void)
                                pd_claimed = 0;
                                phase = NULL;
                                spin_lock_irqsave(&pd_lock, saved_flags);
-                                end_request(pd_req, res);
+                                if (!__blk_end_request_cur(pd_req,
-                                pd_req = elv_next_request(pd_queue);
+                                                res == Ok ? 0 : -EIO)) {
-                                if (!pd_req)
+                                        pd_req = blk_fetch_request(pd_queue);
-                                        stop = 1;
+                                        if (!pd_req)
+                                                stop = 1;
+                                }
                                spin_unlock_irqrestore(&pd_lock, saved_flags);
                                if (stop)
                                        return;
@@ -443,11 +445,11 @@ static enum action do_pd_io_start(void)
        pd_cmd = rq_data_dir(pd_req);
        if (pd_cmd == READ || pd_cmd == WRITE) {
-                pd_block = pd_req->sector;
+                pd_block = blk_rq_pos(pd_req);
-                pd_count = pd_req->current_nr_sectors;
+                pd_count = blk_rq_cur_sectors(pd_req);
                if (pd_block + pd_count > get_capacity(pd_req->rq_disk))
                        return Fail;
-                pd_run = pd_req->nr_sectors;
+                pd_run = blk_rq_sectors(pd_req);
                pd_buf = pd_req->buffer;
                pd_retries = 0;
                if (pd_cmd == READ)
@@ -477,8 +479,8 @@ static int pd_next_buf(void)
        if (pd_count)
                return 0;
        spin_lock_irqsave(&pd_lock, saved_flags);
-        end_request(pd_req, 1);
+        __blk_end_request_cur(pd_req, 0);
-        pd_count = pd_req->current_nr_sectors;
+        pd_count = blk_rq_cur_sectors(pd_req);
        pd_buf = pd_req->buffer;
        spin_unlock_irqrestore(&pd_lock, saved_flags);
        return 0;
@@ -702,7 +704,7 @@ static void do_pd_request(struct request_queue * q)
 {
        if (pd_req)
                return;
-        pd_req = elv_next_request(q);
+        pd_req = blk_fetch_request(q);
        if (!pd_req)
                return;
diff --git a/drivers/block/paride/pf.c b/drivers/block/paride/pf.c
index bef3b997ba3e..68a90834e993 100644
--- a/drivers/block/paride/pf.c
+++ b/drivers/block/paride/pf.c
@@ -750,12 +750,10 @@ static int pf_ready(void)
 static struct request_queue *pf_queue;
-static void pf_end_request(int uptodate)
+static void pf_end_request(int err)
 {
-        if (pf_req) {
+        if (pf_req && !__blk_end_request_cur(pf_req, err))
-                end_request(pf_req, uptodate);
                pf_req = NULL;
-        }
 }
 static void do_pf_request(struct request_queue * q)
@@ -763,17 +761,19 @@ static void do_pf_request(struct request_queue * q)
        if (pf_busy)
                return;
 repeat:
-        pf_req = elv_next_request(q);
+        if (!pf_req) {
-        if (!pf_req)
+                pf_req = blk_fetch_request(q);
-                return;
+                if (!pf_req)
+                        return;
+        }
        pf_current = pf_req->rq_disk->private_data;
-        pf_block = pf_req->sector;
+        pf_block = blk_rq_pos(pf_req);
-        pf_run = pf_req->nr_sectors;
+        pf_run = blk_rq_sectors(pf_req);
-        pf_count = pf_req->current_nr_sectors;
+        pf_count = blk_rq_cur_sectors(pf_req);
        if (pf_block + pf_count > get_capacity(pf_req->rq_disk)) {
-                pf_end_request(0);
+                pf_end_request(-EIO);
                goto repeat;
        }
@@ -788,7 +788,7 @@ repeat:
                pi_do_claimed(pf_current->pi, do_pf_write);
        else {
                pf_busy = 0;
-                pf_end_request(0);
+                pf_end_request(-EIO);
                goto repeat;
        }
 }
@@ -805,23 +805,22 @@ static int pf_next_buf(void)
                return 1;
        if (!pf_count) {
                spin_lock_irqsave(&pf_spin_lock, saved_flags);
-                pf_end_request(1);
+                pf_end_request(0);
-                pf_req = elv_next_request(pf_queue);
                spin_unlock_irqrestore(&pf_spin_lock, saved_flags);
                if (!pf_req)
                        return 1;
-                pf_count = pf_req->current_nr_sectors;
+                pf_count = blk_rq_cur_sectors(pf_req);
                pf_buf = pf_req->buffer;
        }
        return 0;
 }
-static inline void next_request(int success)
+static inline void next_request(int err)
 {
        unsigned long saved_flags;
        spin_lock_irqsave(&pf_spin_lock, saved_flags);
-        pf_end_request(success);
+        pf_end_request(err);
        pf_busy = 0;
        do_pf_request(pf_queue);
        spin_unlock_irqrestore(&pf_spin_lock, saved_flags);
@@ -844,7 +843,7 @@ static void do_pf_read_start(void)
                        pi_do_claimed(pf_current->pi, do_pf_read_start);
                        return;
                }
-                next_request(0);
+                next_request(-EIO);
                return;
        }
        pf_mask = STAT_DRQ;
@@ -863,7 +862,7 @@ static void do_pf_read_drq(void)
                                pi_do_claimed(pf_current->pi, do_pf_read_start);
                                return;
                        }
-                        next_request(0);
+                        next_request(-EIO);
                        return;
                }
                pi_read_block(pf_current->pi, pf_buf, 512);
@@ -871,7 +870,7 @@ static void do_pf_read_drq(void)
                        break;
        }
        pi_disconnect(pf_current->pi);
-        next_request(1);
+        next_request(0);
 }
 static void do_pf_write(void)
@@ -890,7 +889,7 @@ static void do_pf_write_start(void)
                        pi_do_claimed(pf_current->pi, do_pf_write_start);
                        return;
                }
-                next_request(0);
+                next_request(-EIO);
                return;
        }
@@ -903,7 +902,7 @@ static void do_pf_write_start(void)
                                pi_do_claimed(pf_current->pi, do_pf_write_start);
                                return;
                        }
-                        next_request(0);
+                        next_request(-EIO);
                        return;
                }
                pi_write_block(pf_current->pi, pf_buf, 512);
@@ -923,11 +922,11 @@ static void do_pf_write_done(void)
                        pi_do_claimed(pf_current->pi, do_pf_write_start);
                        return;
                }
-                next_request(0);
+                next_request(-EIO);
                return;
        }
        pi_disconnect(pf_current->pi);
-        next_request(1);
+        next_request(0);
 }
 static int __init pf_init(void)
diff --git a/drivers/block/pktcdvd.c b/drivers/block/pktcdvd.c
index dc7a8c352da2..83650e00632d 100644
--- a/drivers/block/pktcdvd.c
+++ b/drivers/block/pktcdvd.c
@@ -430,7 +430,7 @@ static void pkt_sysfs_cleanup(void)
 /********************************************************************
  entries in debugfs
-  /debugfs/pktcdvd[0-7]/
+  /sys/kernel/debug/pktcdvd[0-7]/
                        info
 *******************************************************************/
@@ -991,13 +991,15 @@ 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 <= q->max_phys_segments) {
+        if ((pd->settings.size << 9) / CD_FRAMESIZE
+            <= queue_max_phys_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 <= q->max_phys_segments) {
+        } else if ((pd->settings.size << 9) / PAGE_SIZE
+                   <= queue_max_phys_segments(q)) {
                /*
                 * We can handle this case at the expense of some extra memory
                 * copies during write operations
@@ -2657,7 +2659,7 @@ static void pkt_init_queue(struct pktcdvd_device *pd)
        struct request_queue *q = pd->disk->queue;
        blk_queue_make_request(q, pkt_make_request);
-        blk_queue_hardsect_size(q, CD_FRAMESIZE);
+        blk_queue_logical_block_size(q, CD_FRAMESIZE);
        blk_queue_max_sectors(q, PACKET_MAX_SECTORS);
        blk_queue_merge_bvec(q, pkt_merge_bvec);
        q->queuedata = pd;
@@ -2853,6 +2855,11 @@ static struct block_device_operations pktcdvd_ops = {
        .media_changed =        pkt_media_changed,
 };
+static char *pktcdvd_nodename(struct gendisk *gd)
+{
+        return kasprintf(GFP_KERNEL, "pktcdvd/%s", gd->disk_name);
+}
 /*
 * Set up mapping from pktcdvd device to CD-ROM device.
 */
@@ -2905,6 +2912,7 @@ static int pkt_setup_dev(dev_t dev, dev_t* pkt_dev)
        disk->fops = &pktcdvd_ops;
        disk->flags = GENHD_FL_REMOVABLE;
        strcpy(disk->disk_name, pd->name);
+        disk->nodename = pktcdvd_nodename;
        disk->private_data = pd;
        disk->queue = blk_alloc_queue(GFP_KERNEL);
        if (!disk->queue)
@@ -3060,6 +3068,7 @@ static const struct file_operations pkt_ctl_fops = {
 static struct miscdevice pkt_misc = {
        .minor          = MISC_DYNAMIC_MINOR,
        .name           = DRIVER_NAME,
+        .name           = "pktcdvd/control",
        .fops           = &pkt_ctl_fops
 };
diff --git a/drivers/block/ps3disk.c b/drivers/block/ps3disk.c
index bccc42bb9212..34cbb7f3efa8 100644
--- a/drivers/block/ps3disk.c
+++ b/drivers/block/ps3disk.c
@@ -120,7 +120,7 @@ static void ps3disk_scatter_gather(struct ps3_storage_device *dev,
 static int ps3disk_submit_request_sg(struct ps3_storage_device *dev,
                                     struct request *req)
 {
-        struct ps3disk_private *priv = dev->sbd.core.driver_data;
+        struct ps3disk_private *priv = ps3_system_bus_get_drvdata(&dev->sbd);
        int write = rq_data_dir(req), res;
        const char *op = write ? "write" : "read";
        u64 start_sector, sectors;
@@ -134,13 +134,12 @@ static int ps3disk_submit_request_sg(struct ps3_storage_device *dev,
        rq_for_each_segment(bv, req, iter)
                n++;
        dev_dbg(&dev->sbd.core,
-                "%s:%u: %s req has %u bvecs for %lu sectors %lu hard sectors\n",
+                "%s:%u: %s req has %u bvecs for %u sectors\n",
-                __func__, __LINE__, op, n, req->nr_sectors,
+                __func__, __LINE__, op, n, blk_rq_sectors(req));
-                req->hard_nr_sectors);
 #endif
-        start_sector = req->sector * priv->blocking_factor;
+        start_sector = blk_rq_pos(req) * priv->blocking_factor;
-        sectors = req->nr_sectors * priv->blocking_factor;
+        sectors = blk_rq_sectors(req) * priv->blocking_factor;
        dev_dbg(&dev->sbd.core, "%s:%u: %s %llu sectors starting at %llu\n",
                __func__, __LINE__, op, sectors, start_sector);
@@ -158,7 +157,7 @@ static int ps3disk_submit_request_sg(struct ps3_storage_device *dev,
        if (res) {
                dev_err(&dev->sbd.core, "%s:%u: %s failed %d\n", __func__,
                        __LINE__, op, res);
-                end_request(req, 0);
+                __blk_end_request_all(req, -EIO);
                return 0;
        }
@@ -169,7 +168,7 @@ static int ps3disk_submit_request_sg(struct ps3_storage_device *dev,
 static int ps3disk_submit_flush_request(struct ps3_storage_device *dev,
                                        struct request *req)
 {
-        struct ps3disk_private *priv = dev->sbd.core.driver_data;
+        struct ps3disk_private *priv = ps3_system_bus_get_drvdata(&dev->sbd);
        u64 res;
        dev_dbg(&dev->sbd.core, "%s:%u: flush request\n", __func__, __LINE__);
@@ -180,7 +179,7 @@ static int ps3disk_submit_flush_request(struct ps3_storage_device *dev,
        if (res) {
                dev_err(&dev->sbd.core, "%s:%u: sync cache failed 0x%llx\n",
                        __func__, __LINE__, res);
-                end_request(req, 0);
+                __blk_end_request_all(req, -EIO);
                return 0;
        }
@@ -195,7 +194,7 @@ static void ps3disk_do_request(struct ps3_storage_device *dev,
        dev_dbg(&dev->sbd.core, "%s:%u\n", __func__, __LINE__);
-        while ((req = elv_next_request(q))) {
+        while ((req = blk_fetch_request(q))) {
                if (blk_fs_request(req)) {
                        if (ps3disk_submit_request_sg(dev, req))
                                break;
@@ -205,7 +204,7 @@ static void ps3disk_do_request(struct ps3_storage_device *dev,
                                break;
                } else {
                        blk_dump_rq_flags(req, DEVICE_NAME " bad request");
-                        end_request(req, 0);
+                        __blk_end_request_all(req, -EIO);
                        continue;
                }
        }
@@ -214,7 +213,7 @@ static void ps3disk_do_request(struct ps3_storage_device *dev,
 static void ps3disk_request(struct request_queue *q)
 {
        struct ps3_storage_device *dev = q->queuedata;
-        struct ps3disk_private *priv = dev->sbd.core.driver_data;
+        struct ps3disk_private *priv = ps3_system_bus_get_drvdata(&dev->sbd);
        if (priv->req) {
                dev_dbg(&dev->sbd.core, "%s:%u busy\n", __func__, __LINE__);
@@ -231,7 +230,6 @@ static irqreturn_t ps3disk_interrupt(int irq, void *data)
        struct request *req;
        int res, read, error;
        u64 tag, status;
-        unsigned long num_sectors;
        const char *op;
        res = lv1_storage_get_async_status(dev->sbd.dev_id, &tag, &status);
@@ -247,7 +245,7 @@ static irqreturn_t ps3disk_interrupt(int irq, void *data)
                return IRQ_HANDLED;
        }
-        priv = dev->sbd.core.driver_data;
+        priv = ps3_system_bus_get_drvdata(&dev->sbd);
        req = priv->req;
        if (!req) {
                dev_dbg(&dev->sbd.core,
@@ -261,11 +259,9 @@ static irqreturn_t ps3disk_interrupt(int irq, void *data)
        if (req->cmd_type == REQ_TYPE_LINUX_BLOCK &&
            req->cmd[0] == REQ_LB_OP_FLUSH) {
                read = 0;
-                num_sectors = req->hard_cur_sectors;
                op = "flush";
        } else {
                read = !rq_data_dir(req);
-                num_sectors = req->nr_sectors;
                op = read ? "read" : "write";
        }
        if (status) {
@@ -281,7 +277,7 @@ static irqreturn_t ps3disk_interrupt(int irq, void *data)
        }
        spin_lock(&priv->lock);
-        __blk_end_request(req, error, num_sectors << 9);
+        __blk_end_request_all(req, error);
        priv->req = NULL;
        ps3disk_do_request(dev, priv->queue);
        spin_unlock(&priv->lock);
@@ -368,7 +364,7 @@ static void ata_id_c_string(const u16 *id, unsigned char *s, unsigned int ofs,
 static int ps3disk_identify(struct ps3_storage_device *dev)
 {
-        struct ps3disk_private *priv = dev->sbd.core.driver_data;
+        struct ps3disk_private *priv = ps3_system_bus_get_drvdata(&dev->sbd);
        struct lv1_ata_cmnd_block ata_cmnd;
        u16 *id = dev->bounce_buf;
        u64 res;
@@ -449,7 +445,7 @@ static int __devinit ps3disk_probe(struct ps3_system_bus_device *_dev)
                goto fail;
        }
-        dev->sbd.core.driver_data = priv;
+        ps3_system_bus_set_drvdata(_dev, priv);
        spin_lock_init(&priv->lock);
        dev->bounce_size = BOUNCE_SIZE;
@@ -481,7 +477,7 @@ static int __devinit ps3disk_probe(struct ps3_system_bus_device *_dev)
        blk_queue_max_sectors(queue, dev->bounce_size >> 9);
        blk_queue_segment_boundary(queue, -1UL);
        blk_queue_dma_alignment(queue, dev->blk_size-1);
-        blk_queue_hardsect_size(queue, dev->blk_size);
+        blk_queue_logical_block_size(queue, dev->blk_size);
        blk_queue_ordered(queue, QUEUE_ORDERED_DRAIN_FLUSH,
                          ps3disk_prepare_flush);
@@ -527,7 +523,7 @@ fail_free_bounce:
        kfree(dev->bounce_buf);
 fail_free_priv:
        kfree(priv);
-        dev->sbd.core.driver_data = NULL;
+        ps3_system_bus_set_drvdata(_dev, NULL);
 fail:
        mutex_lock(&ps3disk_mask_mutex);
        __clear_bit(devidx, &ps3disk_mask);
@@ -538,7 +534,7 @@ fail:
 static int ps3disk_remove(struct ps3_system_bus_device *_dev)
 {
        struct ps3_storage_device *dev = to_ps3_storage_device(&_dev->core);
-        struct ps3disk_private *priv = dev->sbd.core.driver_data;
+        struct ps3disk_private *priv = ps3_system_bus_get_drvdata(&dev->sbd);
        mutex_lock(&ps3disk_mask_mutex);
        __clear_bit(MINOR(disk_devt(priv->gendisk)) / PS3DISK_MINORS,
@@ -552,7 +548,7 @@ static int ps3disk_remove(struct ps3_system_bus_device *_dev)
        ps3stor_teardown(dev);
        kfree(dev->bounce_buf);
        kfree(priv);
-        dev->sbd.core.driver_data = NULL;
+        ps3_system_bus_set_drvdata(_dev, NULL);
        return 0;
 }
diff --git a/drivers/block/ps3vram.c b/drivers/block/ps3vram.c
index 8eddef373a91..095f97e60665 100644
--- a/drivers/block/ps3vram.c
+++ b/drivers/block/ps3vram.c
@@ -14,8 +14,10 @@
 #include <linux/seq_file.h>
 #include <asm/firmware.h>
+#include <asm/iommu.h>
 #include <asm/lv1call.h>
 #include <asm/ps3.h>
+#include <asm/ps3gpu.h>
 #define DEVICE_NAME             "ps3vram"
@@ -45,8 +47,6 @@
 #define NV_MEMORY_TO_MEMORY_FORMAT_OFFSET_IN    0x0000030c
 #define NV_MEMORY_TO_MEMORY_FORMAT_NOTIFY       0x00000104
-#define L1GPU_CONTEXT_ATTRIBUTE_FB_BLIT 0x601
 #define CACHE_PAGE_PRESENT 1
 #define CACHE_PAGE_DIRTY   2
@@ -72,8 +72,7 @@ struct ps3vram_priv {
        u64 memory_handle;
        u64 context_handle;
        u32 *ctrl;
-        u32 *reports;
+        void *reports;
-        u8 __iomem *ddr_base;
        u8 *xdr_buf;
        u32 *fifo_base;
@@ -81,8 +80,8 @@ struct ps3vram_priv {
        struct ps3vram_cache cache;
-        /* Used to serialize cache/DMA operations */
+        spinlock_t lock;        /* protecting list of bios */
-        struct mutex lock;
+        struct bio_list list;
 };
@@ -103,15 +102,15 @@ static char *size = "256M";
 module_param(size, charp, 0);
 MODULE_PARM_DESC(size, "memory size");
-static u32 *ps3vram_get_notifier(u32 *reports, int notifier)
+static u32 *ps3vram_get_notifier(void *reports, int notifier)
 {
-        return (void *)reports + DMA_NOTIFIER_OFFSET_BASE +
+        return reports + DMA_NOTIFIER_OFFSET_BASE +
               DMA_NOTIFIER_SIZE * notifier;
 }
 static void ps3vram_notifier_reset(struct ps3_system_bus_device *dev)
 {
-        struct ps3vram_priv *priv = dev->core.driver_data;
+        struct ps3vram_priv *priv = ps3_system_bus_get_drvdata(dev);
        u32 *notify = ps3vram_get_notifier(priv->reports, NOTIFIER);
        int i;
@@ -122,7 +121,7 @@ static void ps3vram_notifier_reset(struct ps3_system_bus_device *dev)
 static int ps3vram_notifier_wait(struct ps3_system_bus_device *dev,
                                 unsigned int timeout_ms)
 {
-        struct ps3vram_priv *priv = dev->core.driver_data;
+        struct ps3vram_priv *priv = ps3_system_bus_get_drvdata(dev);
        u32 *notify = ps3vram_get_notifier(priv->reports, NOTIFIER);
        unsigned long timeout = jiffies + msecs_to_jiffies(timeout_ms);
@@ -137,7 +136,7 @@ static int ps3vram_notifier_wait(struct ps3_system_bus_device *dev,
 static void ps3vram_init_ring(struct ps3_system_bus_device *dev)
 {
-        struct ps3vram_priv *priv = dev->core.driver_data;
+        struct ps3vram_priv *priv = ps3_system_bus_get_drvdata(dev);
        priv->ctrl[CTRL_PUT] = FIFO_BASE + FIFO_OFFSET;
        priv->ctrl[CTRL_GET] = FIFO_BASE + FIFO_OFFSET;
@@ -146,7 +145,7 @@ static void ps3vram_init_ring(struct ps3_system_bus_device *dev)
 static int ps3vram_wait_ring(struct ps3_system_bus_device *dev,
                             unsigned int timeout_ms)
 {
-        struct ps3vram_priv *priv = dev->core.driver_data;
+        struct ps3vram_priv *priv = ps3_system_bus_get_drvdata(dev);
        unsigned long timeout = jiffies + msecs_to_jiffies(timeout_ms);
        do {
@@ -175,7 +174,7 @@ static void ps3vram_begin_ring(struct ps3vram_priv *priv, u32 chan, u32 tag,
 static void ps3vram_rewind_ring(struct ps3_system_bus_device *dev)
 {
-        struct ps3vram_priv *priv = dev->core.driver_data;
+        struct ps3vram_priv *priv = ps3_system_bus_get_drvdata(dev);
        int status;
        ps3vram_out_ring(priv, 0x20000000 | (FIFO_BASE + FIFO_OFFSET));
@@ -183,20 +182,17 @@ static void ps3vram_rewind_ring(struct ps3_system_bus_device *dev)
        priv->ctrl[CTRL_PUT] = FIFO_BASE + FIFO_OFFSET;
        /* asking the HV for a blit will kick the FIFO */
-        status = lv1_gpu_context_attribute(priv->context_handle,
+        status = lv1_gpu_fb_blit(priv->context_handle, 0, 0, 0, 0);
-                                           L1GPU_CONTEXT_ATTRIBUTE_FB_BLIT, 0,
-                                           0, 0, 0);
        if (status)
-                dev_err(&dev->core,
+                dev_err(&dev->core, "%s: lv1_gpu_fb_blit failed %d\n",
-                        "%s: lv1_gpu_context_attribute failed %d\n", __func__,
+                        __func__, status);
-                        status);
        priv->fifo_ptr = priv->fifo_base;
 }
 static void ps3vram_fire_ring(struct ps3_system_bus_device *dev)
 {
-        struct ps3vram_priv *priv = dev->core.driver_data;
+        struct ps3vram_priv *priv = ps3_system_bus_get_drvdata(dev);
        int status;
        mutex_lock(&ps3_gpu_mutex);
@@ -205,13 +201,10 @@ static void ps3vram_fire_ring(struct ps3_system_bus_device *dev)
                               (priv->fifo_ptr - priv->fifo_base) * sizeof(u32);
        /* asking the HV for a blit will kick the FIFO */
-        status = lv1_gpu_context_attribute(priv->context_handle,
+        status = lv1_gpu_fb_blit(priv->context_handle, 0, 0, 0, 0);
-                                           L1GPU_CONTEXT_ATTRIBUTE_FB_BLIT, 0,
-                                           0, 0, 0);
        if (status)
-                dev_err(&dev->core,
+                dev_err(&dev->core, "%s: lv1_gpu_fb_blit failed %d\n",
-                        "%s: lv1_gpu_context_attribute failed %d\n", __func__,
+                        __func__, status);
-                        status);
        if ((priv->fifo_ptr - priv->fifo_base) * sizeof(u32) >
            FIFO_SIZE - 1024) {
@@ -225,7 +218,7 @@ static void ps3vram_fire_ring(struct ps3_system_bus_device *dev)
 static void ps3vram_bind(struct ps3_system_bus_device *dev)
 {
-        struct ps3vram_priv *priv = dev->core.driver_data;
+        struct ps3vram_priv *priv = ps3_system_bus_get_drvdata(dev);
        ps3vram_begin_ring(priv, UPLOAD_SUBCH, 0, 1);
        ps3vram_out_ring(priv, 0x31337303);
@@ -248,7 +241,7 @@ static int ps3vram_upload(struct ps3_system_bus_device *dev,
                          unsigned int src_offset, unsigned int dst_offset,
                          int len, int count)
 {
-        struct ps3vram_priv *priv = dev->core.driver_data;
+        struct ps3vram_priv *priv = ps3_system_bus_get_drvdata(dev);
        ps3vram_begin_ring(priv, UPLOAD_SUBCH,
                           NV_MEMORY_TO_MEMORY_FORMAT_OFFSET_IN, 8);
@@ -280,7 +273,7 @@ static int ps3vram_download(struct ps3_system_bus_device *dev,
                            unsigned int src_offset, unsigned int dst_offset,
                            int len, int count)
 {
-        struct ps3vram_priv *priv = dev->core.driver_data;
+        struct ps3vram_priv *priv = ps3_system_bus_get_drvdata(dev);
        ps3vram_begin_ring(priv, DOWNLOAD_SUBCH,
                           NV_MEMORY_TO_MEMORY_FORMAT_OFFSET_IN, 8);
@@ -310,7 +303,7 @@ static int ps3vram_download(struct ps3_system_bus_device *dev,
 static void ps3vram_cache_evict(struct ps3_system_bus_device *dev, int entry)
 {
-        struct ps3vram_priv *priv = dev->core.driver_data;
+        struct ps3vram_priv *priv = ps3_system_bus_get_drvdata(dev);
        struct ps3vram_cache *cache = &priv->cache;
        if (!(cache->tags[entry].flags & CACHE_PAGE_DIRTY))
@@ -332,7 +325,7 @@ static void ps3vram_cache_evict(struct ps3_system_bus_device *dev, int entry)
 static void ps3vram_cache_load(struct ps3_system_bus_device *dev, int entry,
                               unsigned int address)
 {
-        struct ps3vram_priv *priv = dev->core.driver_data;
+        struct ps3vram_priv *priv = ps3_system_bus_get_drvdata(dev);
        struct ps3vram_cache *cache = &priv->cache;
        dev_dbg(&dev->core, "Fetching %d: 0x%08x\n", entry, address);
@@ -352,7 +345,7 @@ static void ps3vram_cache_load(struct ps3_system_bus_device *dev, int entry,
 static void ps3vram_cache_flush(struct ps3_system_bus_device *dev)
 {
-        struct ps3vram_priv *priv = dev->core.driver_data;
+        struct ps3vram_priv *priv = ps3_system_bus_get_drvdata(dev);
        struct ps3vram_cache *cache = &priv->cache;
        int i;
@@ -366,7 +359,7 @@ static void ps3vram_cache_flush(struct ps3_system_bus_device *dev)
 static unsigned int ps3vram_cache_match(struct ps3_system_bus_device *dev,
                                        loff_t address)
 {
-        struct ps3vram_priv *priv = dev->core.driver_data;
+        struct ps3vram_priv *priv = ps3_system_bus_get_drvdata(dev);
        struct ps3vram_cache *cache = &priv->cache;
        unsigned int base;
        unsigned int offset;
@@ -400,7 +393,7 @@ static unsigned int ps3vram_cache_match(struct ps3_system_bus_device *dev,
 static int ps3vram_cache_init(struct ps3_system_bus_device *dev)
 {
-        struct ps3vram_priv *priv = dev->core.driver_data;
+        struct ps3vram_priv *priv = ps3_system_bus_get_drvdata(dev);
        priv->cache.page_count = CACHE_PAGE_COUNT;
        priv->cache.page_size = CACHE_PAGE_SIZE;
@@ -419,7 +412,7 @@ static int ps3vram_cache_init(struct ps3_system_bus_device *dev)
 static void ps3vram_cache_cleanup(struct ps3_system_bus_device *dev)
 {
-        struct ps3vram_priv *priv = dev->core.driver_data;
+        struct ps3vram_priv *priv = ps3_system_bus_get_drvdata(dev);
        ps3vram_cache_flush(dev);
        kfree(priv->cache.tags);
@@ -428,7 +421,7 @@ static void ps3vram_cache_cleanup(struct ps3_system_bus_device *dev)
 static int ps3vram_read(struct ps3_system_bus_device *dev, loff_t from,
                        size_t len, size_t *retlen, u_char *buf)
 {
-        struct ps3vram_priv *priv = dev->core.driver_data;
+        struct ps3vram_priv *priv = ps3_system_bus_get_drvdata(dev);
        unsigned int cached, count;
        dev_dbg(&dev->core, "%s: from=0x%08x len=0x%zx\n", __func__,
@@ -449,8 +442,6 @@ static int ps3vram_read(struct ps3_system_bus_device *dev, loff_t from,
                offset = (unsigned int) (from & (priv->cache.page_size - 1));
                avail  = priv->cache.page_size - offset;
-                mutex_lock(&priv->lock);
                entry = ps3vram_cache_match(dev, from);
                cached = CACHE_OFFSET + entry * priv->cache.page_size + offset;
@@ -462,8 +453,6 @@ static int ps3vram_read(struct ps3_system_bus_device *dev, loff_t from,
                        avail = count;
                memcpy(buf, priv->xdr_buf + cached, avail);
-                mutex_unlock(&priv->lock);
                buf += avail;
                count -= avail;
                from += avail;
@@ -476,7 +465,7 @@ static int ps3vram_read(struct ps3_system_bus_device *dev, loff_t from,
 static int ps3vram_write(struct ps3_system_bus_device *dev, loff_t to,
                         size_t len, size_t *retlen, const u_char *buf)
 {
-        struct ps3vram_priv *priv = dev->core.driver_data;
+        struct ps3vram_priv *priv = ps3_system_bus_get_drvdata(dev);
        unsigned int cached, count;
        if (to >= priv->size)
@@ -494,8 +483,6 @@ static int ps3vram_write(struct ps3_system_bus_device *dev, loff_t to,
                offset = (unsigned int) (to & (priv->cache.page_size - 1));
                avail  = priv->cache.page_size - offset;
-                mutex_lock(&priv->lock);
                entry = ps3vram_cache_match(dev, to);
                cached = CACHE_OFFSET + entry * priv->cache.page_size + offset;
@@ -509,8 +496,6 @@ static int ps3vram_write(struct ps3_system_bus_device *dev, loff_t to,
                priv->cache.tags[entry].flags |= CACHE_PAGE_DIRTY;
-                mutex_unlock(&priv->lock);
                buf += avail;
                count -= avail;
                to += avail;
@@ -543,28 +528,26 @@ static const struct file_operations ps3vram_proc_fops = {
 static void __devinit ps3vram_proc_init(struct ps3_system_bus_device *dev)
 {
-        struct ps3vram_priv *priv = dev->core.driver_data;
+        struct ps3vram_priv *priv = ps3_system_bus_get_drvdata(dev);
        struct proc_dir_entry *pde;
-        pde = proc_create(DEVICE_NAME, 0444, NULL, &ps3vram_proc_fops);
+        pde = proc_create_data(DEVICE_NAME, 0444, NULL, &ps3vram_proc_fops,
-        if (!pde) {
+                               priv);
+        if (!pde)
                dev_warn(&dev->core, "failed to create /proc entry\n");
-                return;
-        }
-        pde->data = priv;
 }
-static int ps3vram_make_request(struct request_queue *q, struct bio *bio)
+static struct bio *ps3vram_do_bio(struct ps3_system_bus_device *dev,
+                                  struct bio *bio)
 {
-        struct ps3_system_bus_device *dev = q->queuedata;
+        struct ps3vram_priv *priv = ps3_system_bus_get_drvdata(dev);
        int write = bio_data_dir(bio) == WRITE;
        const char *op = write ? "write" : "read";
        loff_t offset = bio->bi_sector << 9;
        int error = 0;
        struct bio_vec *bvec;
        unsigned int i;
+        struct bio *next;
-        dev_dbg(&dev->core, "%s\n", __func__);
        bio_for_each_segment(bvec, bio, i) {
                /* PS3 is ppc64, so we don't handle highmem */
@@ -585,6 +568,7 @@ static int ps3vram_make_request(struct request_queue *q, struct bio *bio)
                if (retlen != len) {
                        dev_err(&dev->core, "Short %s\n", op);
+                        error = -EIO;
                        goto out;
                }
@@ -594,7 +578,35 @@ static int ps3vram_make_request(struct request_queue *q, struct bio *bio)
        dev_dbg(&dev->core, "%s completed\n", op);
 out:
+        spin_lock_irq(&priv->lock);
+        bio_list_pop(&priv->list);
+        next = bio_list_peek(&priv->list);
+        spin_unlock_irq(&priv->lock);
        bio_endio(bio, error);
+        return next;
+}
+static int ps3vram_make_request(struct request_queue *q, struct bio *bio)
+{
+        struct ps3_system_bus_device *dev = q->queuedata;
+        struct ps3vram_priv *priv = ps3_system_bus_get_drvdata(dev);
+        int busy;
+        dev_dbg(&dev->core, "%s\n", __func__);
+        spin_lock_irq(&priv->lock);
+        busy = !bio_list_empty(&priv->list);
+        bio_list_add(&priv->list, bio);
+        spin_unlock_irq(&priv->lock);
+        if (busy)
+                return 0;
+        do {
+                bio = ps3vram_do_bio(dev, bio);
+        } while (bio);
        return 0;
 }
@@ -604,8 +616,8 @@ static int __devinit ps3vram_probe(struct ps3_system_bus_device *dev)
        int error, status;
        struct request_queue *queue;
        struct gendisk *gendisk;
-        u64 ddr_lpar, ctrl_lpar, info_lpar, reports_lpar, ddr_size,
+        u64 ddr_size, ddr_lpar, ctrl_lpar, info_lpar, reports_lpar,
-            reports_size;
+            reports_size, xdr_lpar;
        char *rest;
        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
@@ -614,10 +626,9 @@ static int __devinit ps3vram_probe(struct ps3_system_bus_device *dev)
                goto fail;
        }
-        mutex_init(&priv->lock);
+        spin_lock_init(&priv->lock);
-        dev->core.driver_data = priv;
+        bio_list_init(&priv->list);
+        ps3_system_bus_set_drvdata(dev, priv);
-        priv = dev->core.driver_data;
        /* Allocate XDR buffer (1MiB aligned) */
        priv->xdr_buf = (void *)__get_free_pages(GFP_KERNEL,
@@ -636,7 +647,7 @@ static int __devinit ps3vram_probe(struct ps3_system_bus_device *dev)
        if (ps3_open_hv_device(dev)) {
                dev_err(&dev->core, "ps3_open_hv_device failed\n");
                error = -EAGAIN;
-                goto out_close_gpu;
+                goto out_free_xdr_buf;
        }
        /* Request memory */
@@ -660,7 +671,7 @@ static int __devinit ps3vram_probe(struct ps3_system_bus_device *dev)
                dev_err(&dev->core, "lv1_gpu_memory_allocate failed %d\n",
                        status);
                error = -ENOMEM;
-                goto out_free_xdr_buf;
+                goto out_close_gpu;
        }
        /* Request context */
@@ -676,9 +687,11 @@ static int __devinit ps3vram_probe(struct ps3_system_bus_device *dev)
        }
        /* Map XDR buffer to RSX */
+        xdr_lpar = ps3_mm_phys_to_lpar(__pa(priv->xdr_buf));
        status = lv1_gpu_context_iomap(priv->context_handle, XDR_IOIF,
-                                       ps3_mm_phys_to_lpar(__pa(priv->xdr_buf)),
+                                       xdr_lpar, XDR_BUF_SIZE,
-                                       XDR_BUF_SIZE, 0);
+                                       CBE_IOPTE_PP_W | CBE_IOPTE_PP_R |
+                                       CBE_IOPTE_M);
        if (status) {
                dev_err(&dev->core, "lv1_gpu_context_iomap failed %d\n",
                        status);
@@ -686,19 +699,11 @@ static int __devinit ps3vram_probe(struct ps3_system_bus_device *dev)
                goto out_free_context;
        }
-        priv->ddr_base = ioremap_flags(ddr_lpar, ddr_size, _PAGE_NO_CACHE);
-        if (!priv->ddr_base) {
-                dev_err(&dev->core, "ioremap DDR failed\n");
-                error = -ENOMEM;
-                goto out_free_context;
-        }
        priv->ctrl = ioremap(ctrl_lpar, 64 * 1024);
        if (!priv->ctrl) {
                dev_err(&dev->core, "ioremap CTRL failed\n");
                error = -ENOMEM;
-                goto out_unmap_vram;
+                goto out_unmap_context;
        }
        priv->reports = ioremap(reports_lpar, reports_size);
@@ -775,8 +780,9 @@ out_unmap_reports:
        iounmap(priv->reports);
 out_unmap_ctrl:
        iounmap(priv->ctrl);
-out_unmap_vram:
+out_unmap_context:
-        iounmap(priv->ddr_base);
+        lv1_gpu_context_iomap(priv->context_handle, XDR_IOIF, xdr_lpar,
+                              XDR_BUF_SIZE, CBE_IOPTE_M);
 out_free_context:
        lv1_gpu_context_free(priv->context_handle);
 out_free_memory:
@@ -787,14 +793,14 @@ out_free_xdr_buf:
        free_pages((unsigned long) priv->xdr_buf, get_order(XDR_BUF_SIZE));
 fail_free_priv:
        kfree(priv);
-        dev->core.driver_data = NULL;
+        ps3_system_bus_set_drvdata(dev, NULL);
 fail:
        return error;
 }
 static int ps3vram_remove(struct ps3_system_bus_device *dev)
 {
-        struct ps3vram_priv *priv = dev->core.driver_data;
+        struct ps3vram_priv *priv = ps3_system_bus_get_drvdata(dev);
        del_gendisk(priv->gendisk);
        put_disk(priv->gendisk);
@@ -803,13 +809,15 @@ static int ps3vram_remove(struct ps3_system_bus_device *dev)
        ps3vram_cache_cleanup(dev);
        iounmap(priv->reports);
        iounmap(priv->ctrl);
-        iounmap(priv->ddr_base);
+        lv1_gpu_context_iomap(priv->context_handle, XDR_IOIF,
+                              ps3_mm_phys_to_lpar(__pa(priv->xdr_buf)),
+                              XDR_BUF_SIZE, CBE_IOPTE_M);
        lv1_gpu_context_free(priv->context_handle);
        lv1_gpu_memory_free(priv->memory_handle);
        ps3_close_hv_device(dev);
        free_pages((unsigned long) priv->xdr_buf, get_order(XDR_BUF_SIZE));
        kfree(priv);
-        dev->core.driver_data = NULL;
+        ps3_system_bus_set_drvdata(dev, NULL);
        return 0;
 }
diff --git a/drivers/block/sunvdc.c b/drivers/block/sunvdc.c
index 5861e33efe63..cbfd9c0aef03 100644
--- a/drivers/block/sunvdc.c
+++ b/drivers/block/sunvdc.c
@@ -212,11 +212,6 @@ static void vdc_end_special(struct vdc_port *port, struct vio_disk_desc *desc)
        vdc_finish(&port->vio, -err, WAITING_FOR_GEN_CMD);
 }
-static void vdc_end_request(struct request *req, int error, int num_sectors)
-{
-        __blk_end_request(req, error, num_sectors << 9);
-}
 static void vdc_end_one(struct vdc_port *port, struct vio_dring_state *dr,
                        unsigned int index)
 {
@@ -239,7 +234,7 @@ static void vdc_end_one(struct vdc_port *port, struct vio_dring_state *dr,
        rqe->req = NULL;
-        vdc_end_request(req, (desc->status ? -EIO : 0), desc->size >> 9);
+        __blk_end_request(req, (desc->status ? -EIO : 0), desc->size);
        if (blk_queue_stopped(port->disk->queue))
                blk_start_queue(port->disk->queue);
@@ -421,7 +416,7 @@ static int __send_request(struct request *req)
                desc->slice = 0;
        }
        desc->status = ~0;
-        desc->offset = (req->sector << 9) / port->vdisk_block_size;
+        desc->offset = (blk_rq_pos(req) << 9) / port->vdisk_block_size;
        desc->size = len;
        desc->ncookies = err;
@@ -446,14 +441,13 @@ out:
 static void do_vdc_request(struct request_queue *q)
 {
        while (1) {
-                struct request *req = elv_next_request(q);
+                struct request *req = blk_fetch_request(q);
                if (!req)
                        break;
-                blkdev_dequeue_request(req);
                if (__send_request(req) < 0)
-                        vdc_end_request(req, -EIO, req->hard_nr_sectors);
+                        __blk_end_request_all(req, -EIO);
        }
 }
diff --git a/drivers/block/swim.c b/drivers/block/swim.c
index d22cc3856937..cf7877fb8a7d 100644
--- a/drivers/block/swim.c
+++ b/drivers/block/swim.c
@@ -514,7 +514,7 @@ static int floppy_read_sectors(struct floppy_state *fs,
                        ret = swim_read_sector(fs, side, track, sector,
                                                buffer);
                        if (try-- == 0)
-                                return -1;
+                                return -EIO;
                } while (ret != 512);
                buffer += ret;
@@ -528,45 +528,31 @@ static void redo_fd_request(struct request_queue *q)
        struct request *req;
        struct floppy_state *fs;
-        while ((req = elv_next_request(q))) {
+        req = blk_fetch_request(q);
+        while (req) {
+                int err = -EIO;
                fs = req->rq_disk->private_data;
-                if (req->sector < 0 || req->sector >= fs->total_secs) {
+                if (blk_rq_pos(req) >= fs->total_secs)
-                        end_request(req, 0);
+                        goto done;
-                        continue;
+                if (!fs->disk_in)
-                }
+                        goto done;
-                if (req->current_nr_sectors == 0) {
+                if (rq_data_dir(req) == WRITE && fs->write_protected)
-                        end_request(req, 1);
+                        goto done;
-                        continue;
-                }
-                if (!fs->disk_in) {
-                        end_request(req, 0);
-                        continue;
-                }
-                if (rq_data_dir(req) == WRITE) {
-                        if (fs->write_protected) {
-                                end_request(req, 0);
-                                continue;
-                        }
-                }
                switch (rq_data_dir(req)) {
                case WRITE:
                        /* NOT IMPLEMENTED */
-                        end_request(req, 0);
                        break;
                case READ:
-                        if (floppy_read_sectors(fs, req->sector,
+                        err = floppy_read_sectors(fs, blk_rq_pos(req),
-                                                req->current_nr_sectors,
+                                                  blk_rq_cur_sectors(req),
-                                                req->buffer)) {
+                                                  req->buffer);
-                                end_request(req, 0);
-                                continue;
-                        }
-                        req->nr_sectors -= req->current_nr_sectors;
-                        req->sector += req->current_nr_sectors;
-                        req->buffer += req->current_nr_sectors * 512;
-                        end_request(req, 1);
                        break;
                }
+        done:
+                if (!__blk_end_request_cur(req, err))
+                        req = blk_fetch_request(q);
        }
 }
diff --git a/drivers/block/swim3.c b/drivers/block/swim3.c
index 612965307ba0..80df93e3cdd0 100644
--- a/drivers/block/swim3.c
+++ b/drivers/block/swim3.c
@@ -251,6 +251,20 @@ static int floppy_release(struct gendisk *disk, fmode_t mode);
 static int floppy_check_change(struct gendisk *disk);
 static int floppy_revalidate(struct gendisk *disk);
+static bool swim3_end_request(int err, unsigned int nr_bytes)
+{
+        if (__blk_end_request(fd_req, err, nr_bytes))
+                return true;
+        fd_req = NULL;
+        return false;
+}
+static bool swim3_end_request_cur(int err)
+{
+        return swim3_end_request(err, blk_rq_cur_bytes(fd_req));
+}
 static void swim3_select(struct floppy_state *fs, int sel)
 {
        struct swim3 __iomem *sw = fs->swim3;
@@ -310,25 +324,27 @@ static void start_request(struct floppy_state *fs)
                wake_up(&fs->wait);
                return;
        }
-        while (fs->state == idle && (req = elv_next_request(swim3_queue))) {
+        while (fs->state == idle) {
+                if (!fd_req) {
+                        fd_req = blk_fetch_request(swim3_queue);
+                        if (!fd_req)
+                                break;
+                }
+                req = fd_req;
 #if 0
-                printk("do_fd_req: dev=%s cmd=%d sec=%ld nr_sec=%ld buf=%p\n",
+                printk("do_fd_req: dev=%s cmd=%d sec=%ld nr_sec=%u buf=%p\n",
                       req->rq_disk->disk_name, req->cmd,
-                       (long)req->sector, req->nr_sectors, req->buffer);
+                       (long)blk_rq_pos(req), blk_rq_sectors(req), req->buffer);
-                printk("           errors=%d current_nr_sectors=%ld\n",
+                printk("           errors=%d current_nr_sectors=%u\n",
-                       req->errors, req->current_nr_sectors);
+                       req->errors, blk_rq_cur_sectors(req));
 #endif
-                if (req->sector < 0 || req->sector >= fs->total_secs) {
+                if (blk_rq_pos(req) >= fs->total_secs) {
-                        end_request(req, 0);
+                        swim3_end_request_cur(-EIO);
-                        continue;
-                }
-                if (req->current_nr_sectors == 0) {
-                        end_request(req, 1);
                        continue;
                }
                if (fs->ejected) {
-                        end_request(req, 0);
+                        swim3_end_request_cur(-EIO);
                        continue;
                }
@@ -336,18 +352,19 @@ static void start_request(struct floppy_state *fs)
                        if (fs->write_prot < 0)
                                fs->write_prot = swim3_readbit(fs, WRITE_PROT);
                        if (fs->write_prot) {
-                                end_request(req, 0);
+                                swim3_end_request_cur(-EIO);
                                continue;
                        }
                }
-                /* Do not remove the cast. req->sector is now a sector_t and
+                /* Do not remove the cast. blk_rq_pos(req) is now a
-                 * can be 64 bits, but it will never go past 32 bits for this
+                 * sector_t and can be 64 bits, but it will never go
-                 * driver anyway, so we can safely cast it down and not have
+                 * past 32 bits for this driver anyway, so we can
-                 * to do a 64/32 division
+                 * safely cast it down and not have to do a 64/32
+                 * division
                 */
-                fs->req_cyl = ((long)req->sector) / fs->secpercyl;
+                fs->req_cyl = ((long)blk_rq_pos(req)) / fs->secpercyl;
-                x = ((long)req->sector) % fs->secpercyl;
+                x = ((long)blk_rq_pos(req)) % fs->secpercyl;
                fs->head = x / fs->secpertrack;
                fs->req_sector = x % fs->secpertrack + 1;
                fd_req = req;
@@ -424,7 +441,7 @@ static inline void setup_transfer(struct floppy_state *fs)
        struct dbdma_cmd *cp = fs->dma_cmd;
        struct dbdma_regs __iomem *dr = fs->dma;
-        if (fd_req->current_nr_sectors <= 0) {
+        if (blk_rq_cur_sectors(fd_req) <= 0) {
                printk(KERN_ERR "swim3: transfer 0 sectors?\n");
                return;
        }
@@ -432,8 +449,8 @@ static inline void setup_transfer(struct floppy_state *fs)
                n = 1;
        else {
                n = fs->secpertrack - fs->req_sector + 1;
-                if (n > fd_req->current_nr_sectors)
+                if (n > blk_rq_cur_sectors(fd_req))
-                        n = fd_req->current_nr_sectors;
+                        n = blk_rq_cur_sectors(fd_req);
        }
        fs->scount = n;
        swim3_select(fs, fs->head? READ_DATA_1: READ_DATA_0);
@@ -508,7 +525,7 @@ static void act(struct floppy_state *fs)
                case do_transfer:
                        if (fs->cur_cyl != fs->req_cyl) {
                                if (fs->retries > 5) {
-                                        end_request(fd_req, 0);
+                                        swim3_end_request_cur(-EIO);
                                        fs->state = idle;
                                        return;
                                }
@@ -540,7 +557,7 @@ static void scan_timeout(unsigned long data)
        out_8(&sw->intr_enable, 0);
        fs->cur_cyl = -1;
        if (fs->retries > 5) {
-                end_request(fd_req, 0);
+                swim3_end_request_cur(-EIO);
                fs->state = idle;
                start_request(fs);
        } else {
@@ -559,7 +576,7 @@ static void seek_timeout(unsigned long data)
        out_8(&sw->select, RELAX);
        out_8(&sw->intr_enable, 0);
        printk(KERN_ERR "swim3: seek timeout\n");
-        end_request(fd_req, 0);
+        swim3_end_request_cur(-EIO);
        fs->state = idle;
        start_request(fs);
 }
@@ -583,7 +600,7 @@ static void settle_timeout(unsigned long data)
                return;
        }
        printk(KERN_ERR "swim3: seek settle timeout\n");
-        end_request(fd_req, 0);
+        swim3_end_request_cur(-EIO);
        fs->state = idle;
        start_request(fs);
 }
@@ -593,8 +610,6 @@ static void xfer_timeout(unsigned long data)
        struct floppy_state *fs = (struct floppy_state *) data;
        struct swim3 __iomem *sw = fs->swim3;
        struct dbdma_regs __iomem *dr = fs->dma;
-        struct dbdma_cmd *cp = fs->dma_cmd;
-        unsigned long s;
        int n;
        fs->timeout_pending = 0;
@@ -605,17 +620,10 @@ static void xfer_timeout(unsigned long data)
        out_8(&sw->intr_enable, 0);
        out_8(&sw->control_bic, WRITE_SECTORS | DO_ACTION);
        out_8(&sw->select, RELAX);
-        if (rq_data_dir(fd_req) == WRITE)
-                ++cp;
-        if (ld_le16(&cp->xfer_status) != 0)
-                s = fs->scount - ((ld_le16(&cp->res_count) + 511) >> 9);
-        else
-                s = 0;
-        fd_req->sector += s;
-        fd_req->current_nr_sectors -= s;
        printk(KERN_ERR "swim3: timeout %sing sector %ld\n",
-               (rq_data_dir(fd_req)==WRITE? "writ": "read"), (long)fd_req->sector);
+               (rq_data_dir(fd_req)==WRITE? "writ": "read"),
-        end_request(fd_req, 0);
+               (long)blk_rq_pos(fd_req));
+        swim3_end_request_cur(-EIO);
        fs->state = idle;
        start_request(fs);
 }
@@ -646,7 +654,7 @@ static irqreturn_t swim3_interrupt(int irq, void *dev_id)
                                printk(KERN_ERR "swim3: seen sector but cyl=ff?\n");
                                fs->cur_cyl = -1;
                                if (fs->retries > 5) {
-                                        end_request(fd_req, 0);
+                                        swim3_end_request_cur(-EIO);
                                        fs->state = idle;
                                        start_request(fs);
                                } else {
@@ -719,9 +727,7 @@ static irqreturn_t swim3_interrupt(int irq, void *dev_id)
                if (intr & ERROR_INTR) {
                        n = fs->scount - 1 - resid / 512;
                        if (n > 0) {
-                                fd_req->sector += n;
+                                blk_update_request(fd_req, 0, n << 9);
-                                fd_req->current_nr_sectors -= n;
-                                fd_req->buffer += n * 512;
                                fs->req_sector += n;
                        }
                        if (fs->retries < 5) {
@@ -730,8 +736,8 @@ static irqreturn_t swim3_interrupt(int irq, void *dev_id)
                        } else {
                                printk("swim3: error %sing block %ld (err=%x)\n",
                                       rq_data_dir(fd_req) == WRITE? "writ": "read",
-                                       (long)fd_req->sector, err);
+                                       (long)blk_rq_pos(fd_req), err);
-                                end_request(fd_req, 0);
+                                swim3_end_request_cur(-EIO);
                                fs->state = idle;
                        }
                } else {
@@ -740,18 +746,12 @@ static irqreturn_t swim3_interrupt(int irq, void *dev_id)
                                printk(KERN_ERR "swim3: fd dma: stat=%x resid=%d\n", stat, resid);
                                printk(KERN_ERR "  state=%d, dir=%x, intr=%x, err=%x\n",
                                       fs->state, rq_data_dir(fd_req), intr, err);
-                                end_request(fd_req, 0);
+                                swim3_end_request_cur(-EIO);
                                fs->state = idle;
                                start_request(fs);
                                break;
                        }
-                        fd_req->sector += fs->scount;
+                        if (swim3_end_request(0, fs->scount << 9)) {
-                        fd_req->current_nr_sectors -= fs->scount;
-                        fd_req->buffer += fs->scount * 512;
-                        if (fd_req->current_nr_sectors <= 0) {
-                                end_request(fd_req, 1);
-                                fs->state = idle;
-                        } else {
                                fs->req_sector += fs->scount;
                                if (fs->req_sector > fs->secpertrack) {
                                        fs->req_sector -= fs->secpertrack;
@@ -761,7 +761,8 @@ static irqreturn_t swim3_interrupt(int irq, void *dev_id)
                                        }
                                }
                                act(fs);
-                        }
+                        } else
+                                fs->state = idle;
                }
                if (fs->state == idle)
                        start_request(fs);
diff --git a/drivers/block/sx8.c b/drivers/block/sx8.c
index ff0448e4bf03..da403b6a7f43 100644
--- a/drivers/block/sx8.c
+++ b/drivers/block/sx8.c
@@ -749,8 +749,7 @@ static inline void carm_end_request_queued(struct carm_host *host,
        struct request *req = crq->rq;
        int rc;
-        rc = __blk_end_request(req, error, blk_rq_bytes(req));
+        __blk_end_request_all(req, error);
-        assert(rc == 0);
        rc = carm_put_request(host, crq);
        assert(rc == 0);
@@ -811,12 +810,10 @@ static void carm_oob_rq_fn(struct request_queue *q)
        while (1) {
                DPRINTK("get req\n");
-                rq = elv_next_request(q);
+                rq = blk_fetch_request(q);
                if (!rq)
                        break;
-                blkdev_dequeue_request(rq);
                crq = rq->special;
                assert(crq != NULL);
                assert(crq->rq == rq);
@@ -847,7 +844,7 @@ static void carm_rq_fn(struct request_queue *q)
 queue_one_request:
        VPRINTK("get req\n");
-        rq = elv_next_request(q);
+        rq = blk_peek_request(q);
        if (!rq)
                return;
@@ -858,7 +855,7 @@ queue_one_request:
        }
        crq->rq = rq;
-        blkdev_dequeue_request(rq);
+        blk_start_request(rq);
        if (rq_data_dir(rq) == WRITE) {
                writing = 1;
@@ -904,10 +901,10 @@ queue_one_request:
        msg->sg_count   = n_elem;
        msg->sg_type    = SGT_32BIT;
        msg->handle     = cpu_to_le32(TAG_ENCODE(crq->tag));
-        msg->lba        = cpu_to_le32(rq->sector & 0xffffffff);
+        msg->lba        = cpu_to_le32(blk_rq_pos(rq) & 0xffffffff);
-        tmp             = (rq->sector >> 16) >> 16;
+        tmp             = (blk_rq_pos(rq) >> 16) >> 16;
        msg->lba_high   = cpu_to_le16( (u16) tmp );
-        msg->lba_count  = cpu_to_le16(rq->nr_sectors);
+        msg->lba_count  = cpu_to_le16(blk_rq_sectors(rq));
        msg_size = sizeof(struct carm_msg_rw) - sizeof(msg->sg);
        for (i = 0; i < n_elem; i++) {
diff --git a/drivers/block/ub.c b/drivers/block/ub.c
index 689cd27ac890..cc54473b8e77 100644
--- a/drivers/block/ub.c
+++ b/drivers/block/ub.c
@@ -360,8 +360,7 @@ static void ub_cmd_build_block(struct ub_dev *sc, struct ub_lun *lun,
 static void ub_cmd_build_packet(struct ub_dev *sc, struct ub_lun *lun,
    struct ub_scsi_cmd *cmd, struct ub_request *urq);
 static void ub_rw_cmd_done(struct ub_dev *sc, struct ub_scsi_cmd *cmd);
-static void ub_end_rq(struct request *rq, unsigned int status,
+static void ub_end_rq(struct request *rq, unsigned int status);
-    unsigned int cmd_len);
 static int ub_rw_cmd_retry(struct ub_dev *sc, struct ub_lun *lun,
    struct ub_request *urq, struct ub_scsi_cmd *cmd);
 static int ub_submit_scsi(struct ub_dev *sc, struct ub_scsi_cmd *cmd);
@@ -627,7 +626,7 @@ static void ub_request_fn(struct request_queue *q)
        struct ub_lun *lun = q->queuedata;
        struct request *rq;
-        while ((rq = elv_next_request(q)) != NULL) {
+        while ((rq = blk_peek_request(q)) != NULL) {
                if (ub_request_fn_1(lun, rq) != 0) {
                        blk_stop_queue(q);
                        break;
@@ -643,14 +642,14 @@ static int ub_request_fn_1(struct ub_lun *lun, struct request *rq)
        int n_elem;
        if (atomic_read(&sc->poison)) {
-                blkdev_dequeue_request(rq);
+                blk_start_request(rq);
-                ub_end_rq(rq, DID_NO_CONNECT << 16, blk_rq_bytes(rq));
+                ub_end_rq(rq, DID_NO_CONNECT << 16);
                return 0;
        }
        if (lun->changed && !blk_pc_request(rq)) {
-                blkdev_dequeue_request(rq);
+                blk_start_request(rq);
-                ub_end_rq(rq, SAM_STAT_CHECK_CONDITION, blk_rq_bytes(rq));
+                ub_end_rq(rq, SAM_STAT_CHECK_CONDITION);
                return 0;
        }
@@ -660,7 +659,7 @@ static int ub_request_fn_1(struct ub_lun *lun, struct request *rq)
                return -1;
        memset(cmd, 0, sizeof(struct ub_scsi_cmd));
-        blkdev_dequeue_request(rq);
+        blk_start_request(rq);
        urq = &lun->urq;
        memset(urq, 0, sizeof(struct ub_request));
@@ -702,7 +701,7 @@ static int ub_request_fn_1(struct ub_lun *lun, struct request *rq)
 drop:
        ub_put_cmd(lun, cmd);
-        ub_end_rq(rq, DID_ERROR << 16, blk_rq_bytes(rq));
+        ub_end_rq(rq, DID_ERROR << 16);
        return 0;
 }
@@ -723,11 +722,11 @@ static void ub_cmd_build_block(struct ub_dev *sc, struct ub_lun *lun,
        /*
         * build the command
         *
-         * The call to blk_queue_hardsect_size() guarantees that request
+         * The call to blk_queue_logical_block_size() guarantees that request
         * is aligned, but it is given in terms of 512 byte units, always.
         */
-        block = rq->sector >> lun->capacity.bshift;
+        block = blk_rq_pos(rq) >> lun->capacity.bshift;
-        nblks = rq->nr_sectors >> lun->capacity.bshift;
+        nblks = blk_rq_sectors(rq) >> lun->capacity.bshift;
        cmd->cdb[0] = (cmd->dir == UB_DIR_READ)? READ_10: WRITE_10;
        /* 10-byte uses 4 bytes of LBA: 2147483648KB, 2097152MB, 2048GB */
@@ -739,7 +738,7 @@ static void ub_cmd_build_block(struct ub_dev *sc, struct ub_lun *lun,
        cmd->cdb[8] = nblks;
        cmd->cdb_len = 10;
-        cmd->len = rq->nr_sectors * 512;
+        cmd->len = blk_rq_bytes(rq);
 }
 static void ub_cmd_build_packet(struct ub_dev *sc, struct ub_lun *lun,
@@ -747,7 +746,7 @@ static void ub_cmd_build_packet(struct ub_dev *sc, struct ub_lun *lun,
 {
        struct request *rq = urq->rq;
-        if (rq->data_len == 0) {
+        if (blk_rq_bytes(rq) == 0) {
                cmd->dir = UB_DIR_NONE;
        } else {
                if (rq_data_dir(rq) == WRITE)
@@ -762,7 +761,7 @@ static void ub_cmd_build_packet(struct ub_dev *sc, struct ub_lun *lun,
        memcpy(&cmd->cdb, rq->cmd, rq->cmd_len);
        cmd->cdb_len = rq->cmd_len;
-        cmd->len = rq->data_len;
+        cmd->len = blk_rq_bytes(rq);
        /*
         * To reapply this to every URB is not as incorrect as it looks.
@@ -777,16 +776,15 @@ static void ub_rw_cmd_done(struct ub_dev *sc, struct ub_scsi_cmd *cmd)
        struct ub_request *urq = cmd->back;
        struct request *rq;
        unsigned int scsi_status;
-        unsigned int cmd_len;
        rq = urq->rq;
        if (cmd->error == 0) {
                if (blk_pc_request(rq)) {
-                        if (cmd->act_len >= rq->data_len)
+                        if (cmd->act_len >= rq->resid_len)
-                                rq->data_len = 0;
+                                rq->resid_len = 0;
                        else
-                                rq->data_len -= cmd->act_len;
+                                rq->resid_len -= cmd->act_len;
                        scsi_status = 0;
                } else {
                        if (cmd->act_len != cmd->len) {
@@ -818,17 +816,14 @@ static void ub_rw_cmd_done(struct ub_dev *sc, struct ub_scsi_cmd *cmd)
        urq->rq = NULL;
-        cmd_len = cmd->len;
        ub_put_cmd(lun, cmd);
-        ub_end_rq(rq, scsi_status, cmd_len);
+        ub_end_rq(rq, scsi_status);
        blk_start_queue(lun->disk->queue);
 }
-static void ub_end_rq(struct request *rq, unsigned int scsi_status,
+static void ub_end_rq(struct request *rq, unsigned int scsi_status)
-    unsigned int cmd_len)
 {
        int error;
-        long rqlen;
        if (scsi_status == 0) {
                error = 0;
@@ -836,12 +831,7 @@ static void ub_end_rq(struct request *rq, unsigned int scsi_status,
                error = -EIO;
                rq->errors = scsi_status;
        }
-        rqlen = blk_rq_bytes(rq);    /* Oddly enough, this is the residue. */
+        __blk_end_request_all(rq, error);
-        if (__blk_end_request(rq, error, cmd_len)) {
-                printk(KERN_WARNING DRV_NAME
-                    ": __blk_end_request blew, %s-cmd total %u rqlen %ld\n",
-                    blk_pc_request(rq)? "pc": "fs", cmd_len, rqlen);
-        }
 }
 static int ub_rw_cmd_retry(struct ub_dev *sc, struct ub_lun *lun,
@@ -1759,7 +1749,7 @@ static int ub_bd_revalidate(struct gendisk *disk)
        ub_revalidate(lun->udev, lun);
        /* XXX Support sector size switching like in sr.c */
-        blk_queue_hardsect_size(disk->queue, lun->capacity.bsize);
+        blk_queue_logical_block_size(disk->queue, lun->capacity.bsize);
        set_capacity(disk, lun->capacity.nsec);
        // set_disk_ro(sdkp->disk, lun->readonly);
@@ -2334,7 +2324,7 @@ static int ub_probe_lun(struct ub_dev *sc, int lnum)
        blk_queue_max_phys_segments(q, UB_MAX_REQ_SG);
        blk_queue_segment_boundary(q, 0xffffffff);      /* Dubious. */
        blk_queue_max_sectors(q, UB_MAX_SECTORS);
-        blk_queue_hardsect_size(q, lun->capacity.bsize);
+        blk_queue_logical_block_size(q, lun->capacity.bsize);
        lun->disk = disk;
        q->queuedata = lun;
diff --git a/drivers/block/viodasd.c b/drivers/block/viodasd.c
index ecccf65dce2f..390d69bb7c48 100644
--- a/drivers/block/viodasd.c
+++ b/drivers/block/viodasd.c
@@ -252,7 +252,7 @@ static int send_request(struct request *req)
        struct viodasd_device *d;
        unsigned long flags;
-        start = (u64)req->sector << 9;
+        start = (u64)blk_rq_pos(req) << 9;
        if (rq_data_dir(req) == READ) {
                direction = DMA_FROM_DEVICE;
@@ -361,19 +361,17 @@ static void do_viodasd_request(struct request_queue *q)
         * back later.
         */
        while (num_req_outstanding < VIOMAXREQ) {
-                req = elv_next_request(q);
+                req = blk_fetch_request(q);
                if (req == NULL)
                        return;
-                /* dequeue the current request from the queue */
-                blkdev_dequeue_request(req);
                /* check that request contains a valid command */
                if (!blk_fs_request(req)) {
-                        viodasd_end_request(req, -EIO, req->hard_nr_sectors);
+                        viodasd_end_request(req, -EIO, blk_rq_sectors(req));
                        continue;
                }
                /* Try sending the request */
                if (send_request(req) != 0)
-                        viodasd_end_request(req, -EIO, req->hard_nr_sectors);
+                        viodasd_end_request(req, -EIO, blk_rq_sectors(req));
        }
 }
@@ -590,7 +588,7 @@ static int viodasd_handle_read_write(struct vioblocklpevent *bevent)
                err = vio_lookup_rc(viodasd_err_table, bevent->sub_result);
                printk(VIOD_KERN_WARNING "read/write error %d:0x%04x (%s)\n",
                                event->xRc, bevent->sub_result, err->msg);
-                num_sect = req->hard_nr_sectors;
+                num_sect = blk_rq_sectors(req);
        }
        qlock = req->q->queue_lock;
        spin_lock_irqsave(qlock, irq_flags);
diff --git a/drivers/block/virtio_blk.c b/drivers/block/virtio_blk.c
index 5d34764c8a87..43db3ea15b54 100644
--- a/drivers/block/virtio_blk.c
+++ b/drivers/block/virtio_blk.c
@@ -37,6 +37,7 @@ struct virtblk_req
        struct list_head list;
        struct request *req;
        struct virtio_blk_outhdr out_hdr;
+        struct virtio_scsi_inhdr in_hdr;
        u8 status;
 };
@@ -50,6 +51,7 @@ static void blk_done(struct virtqueue *vq)
        spin_lock_irqsave(&vblk->lock, flags);
        while ((vbr = vblk->vq->vq_ops->get_buf(vblk->vq, &len)) != NULL) {
                int error;
                switch (vbr->status) {
                case VIRTIO_BLK_S_OK:
                        error = 0;
@@ -62,7 +64,13 @@ static void blk_done(struct virtqueue *vq)
                        break;
                }
-                __blk_end_request(vbr->req, error, blk_rq_bytes(vbr->req));
+                if (blk_pc_request(vbr->req)) {
+                        vbr->req->resid_len = vbr->in_hdr.residual;
+                        vbr->req->sense_len = vbr->in_hdr.sense_len;
+                        vbr->req->errors = vbr->in_hdr.errors;
+                }
+                __blk_end_request_all(vbr->req, error);
                list_del(&vbr->list);
                mempool_free(vbr, vblk->pool);
        }
@@ -74,7 +82,7 @@ static void blk_done(struct virtqueue *vq)
 static bool do_req(struct request_queue *q, struct virtio_blk *vblk,
                   struct request *req)
 {
-        unsigned long num, out, in;
+        unsigned long num, out = 0, in = 0;
        struct virtblk_req *vbr;
        vbr = mempool_alloc(vblk->pool, GFP_ATOMIC);
@@ -85,7 +93,7 @@ static bool do_req(struct request_queue *q, struct virtio_blk *vblk,
        vbr->req = req;
        if (blk_fs_request(vbr->req)) {
                vbr->out_hdr.type = 0;
-                vbr->out_hdr.sector = vbr->req->sector;
+                vbr->out_hdr.sector = blk_rq_pos(vbr->req);
                vbr->out_hdr.ioprio = req_get_ioprio(vbr->req);
        } else if (blk_pc_request(vbr->req)) {
                vbr->out_hdr.type = VIRTIO_BLK_T_SCSI_CMD;
@@ -99,18 +107,36 @@ static bool do_req(struct request_queue *q, struct virtio_blk *vblk,
        if (blk_barrier_rq(vbr->req))
                vbr->out_hdr.type |= VIRTIO_BLK_T_BARRIER;
-        sg_set_buf(&vblk->sg[0], &vbr->out_hdr, sizeof(vbr->out_hdr));
+        sg_set_buf(&vblk->sg[out++], &vbr->out_hdr, sizeof(vbr->out_hdr));
-        num = blk_rq_map_sg(q, vbr->req, vblk->sg+1);
-        sg_set_buf(&vblk->sg[num+1], &vbr->status, sizeof(vbr->status));
-        if (rq_data_dir(vbr->req) == WRITE) {
+        /*
-                vbr->out_hdr.type |= VIRTIO_BLK_T_OUT;
+         * If this is a packet command we need a couple of additional headers.
-                out = 1 + num;
+         * Behind the normal outhdr we put a segment with the scsi command
-                in = 1;
+         * block, and before the normal inhdr we put the sense data and the
-        } else {
+         * inhdr with additional status information before the normal inhdr.
-                vbr->out_hdr.type |= VIRTIO_BLK_T_IN;
+         */
-                out = 1;
+        if (blk_pc_request(vbr->req))
-                in = 1 + num;
+                sg_set_buf(&vblk->sg[out++], vbr->req->cmd, vbr->req->cmd_len);
+        num = blk_rq_map_sg(q, vbr->req, vblk->sg + out);
+        if (blk_pc_request(vbr->req)) {
+                sg_set_buf(&vblk->sg[num + out + in++], vbr->req->sense, 96);
+                sg_set_buf(&vblk->sg[num + out + in++], &vbr->in_hdr,
+                           sizeof(vbr->in_hdr));
+        }
+        sg_set_buf(&vblk->sg[num + out + in++], &vbr->status,
+                   sizeof(vbr->status));
+        if (num) {
+                if (rq_data_dir(vbr->req) == WRITE) {
+                        vbr->out_hdr.type |= VIRTIO_BLK_T_OUT;
+                        out += num;
+                } else {
+                        vbr->out_hdr.type |= VIRTIO_BLK_T_IN;
+                        in += num;
+                }
        }
        if (vblk->vq->vq_ops->add_buf(vblk->vq, vblk->sg, out, in, vbr)) {
@@ -124,12 +150,11 @@ static bool do_req(struct request_queue *q, struct virtio_blk *vblk,
 static void do_virtblk_request(struct request_queue *q)
 {
-        struct virtio_blk *vblk = NULL;
+        struct virtio_blk *vblk = q->queuedata;
        struct request *req;
        unsigned int issued = 0;
-        while ((req = elv_next_request(q)) != NULL) {
+        while ((req = blk_peek_request(q)) != NULL) {
-                vblk = req->rq_disk->private_data;
                BUG_ON(req->nr_phys_segments + 2 > vblk->sg_elems);
                /* If this request fails, stop queue and wait for something to
@@ -138,7 +163,7 @@ static void do_virtblk_request(struct request_queue *q)
                        blk_stop_queue(q);
                        break;
                }
-                blkdev_dequeue_request(req);
+                blk_start_request(req);
                issued++;
        }
@@ -146,12 +171,51 @@ static void do_virtblk_request(struct request_queue *q)
                vblk->vq->vq_ops->kick(vblk->vq);
 }
+/* return ATA identify data
+ */
+static int virtblk_identify(struct gendisk *disk, void *argp)
+{
+        struct virtio_blk *vblk = disk->private_data;
+        void *opaque;
+        int err = -ENOMEM;
+        opaque = kmalloc(VIRTIO_BLK_ID_BYTES, GFP_KERNEL);
+        if (!opaque)
+                goto out;
+        err = virtio_config_buf(vblk->vdev, VIRTIO_BLK_F_IDENTIFY,
+                offsetof(struct virtio_blk_config, identify), opaque,
+                VIRTIO_BLK_ID_BYTES);
+        if (err)
+                goto out_kfree;
+        if (copy_to_user(argp, opaque, VIRTIO_BLK_ID_BYTES))
+                err = -EFAULT;
+out_kfree:
+        kfree(opaque);
+out:
+        return err;
+}
 static int virtblk_ioctl(struct block_device *bdev, fmode_t mode,
                         unsigned cmd, unsigned long data)
 {
-        return scsi_cmd_ioctl(bdev->bd_disk->queue,
+        struct gendisk *disk = bdev->bd_disk;
-                              bdev->bd_disk, mode, cmd,
+        struct virtio_blk *vblk = disk->private_data;
-                              (void __user *)data);
+        void __user *argp = (void __user *)data;
+        if (cmd == HDIO_GET_IDENTITY)
+                return virtblk_identify(disk, argp);
+        /*
+         * Only allow the generic SCSI ioctls if the host can support it.
+         */
+        if (!virtio_has_feature(vblk->vdev, VIRTIO_BLK_F_SCSI))
+                return -ENOIOCTLCMD;
+        return scsi_cmd_ioctl(disk->queue, disk, mode, cmd, argp);
 }
 /* We provide getgeo only to please some old bootloader/partitioning tools */
@@ -190,7 +254,7 @@ static int index_to_minor(int index)
        return index << PART_BITS;
 }
-static int virtblk_probe(struct virtio_device *vdev)
+static int __devinit virtblk_probe(struct virtio_device *vdev)
 {
        struct virtio_blk *vblk;
        int err;
@@ -224,7 +288,7 @@ static int virtblk_probe(struct virtio_device *vdev)
        sg_init_table(vblk->sg, vblk->sg_elems);
        /* We expect one virtqueue, for output. */
-        vblk->vq = vdev->config->find_vq(vdev, 0, blk_done);
+        vblk->vq = virtio_find_single_vq(vdev, blk_done, "requests");
        if (IS_ERR(vblk->vq)) {
                err = PTR_ERR(vblk->vq);
                goto out_free_vblk;
@@ -249,6 +313,7 @@ static int virtblk_probe(struct virtio_device *vdev)
                goto out_put_disk;
        }
+        vblk->disk->queue->queuedata = vblk;
        queue_flag_set_unlocked(QUEUE_FLAG_VIRT, vblk->disk->queue);
        if (index < 26) {
@@ -313,7 +378,7 @@ static int virtblk_probe(struct virtio_device *vdev)
                                offsetof(struct virtio_blk_config, blk_size),
                                &blk_size);
        if (!err)
-                blk_queue_hardsect_size(vblk->disk->queue, blk_size);
+                blk_queue_logical_block_size(vblk->disk->queue, blk_size);
        add_disk(vblk->disk);
        return 0;
@@ -323,14 +388,14 @@ out_put_disk:
 out_mempool:
        mempool_destroy(vblk->pool);
 out_free_vq:
-        vdev->config->del_vq(vblk->vq);
+        vdev->config->del_vqs(vdev);
 out_free_vblk:
        kfree(vblk);
 out:
        return err;
 }
-static void virtblk_remove(struct virtio_device *vdev)
+static void __devexit virtblk_remove(struct virtio_device *vdev)
 {
        struct virtio_blk *vblk = vdev->priv;
@@ -344,7 +409,7 @@ static void virtblk_remove(struct virtio_device *vdev)
        blk_cleanup_queue(vblk->disk->queue);
        put_disk(vblk->disk);
        mempool_destroy(vblk->pool);
-        vdev->config->del_vq(vblk->vq);
+        vdev->config->del_vqs(vdev);
        kfree(vblk);
 }
@@ -356,6 +421,7 @@ static struct virtio_device_id id_table[] = {
 static unsigned int features[] = {
        VIRTIO_BLK_F_BARRIER, VIRTIO_BLK_F_SEG_MAX, VIRTIO_BLK_F_SIZE_MAX,
        VIRTIO_BLK_F_GEOMETRY, VIRTIO_BLK_F_RO, VIRTIO_BLK_F_BLK_SIZE,
+        VIRTIO_BLK_F_SCSI, VIRTIO_BLK_F_IDENTIFY
 };
 static struct virtio_driver virtio_blk = {
diff --git a/drivers/block/xd.c b/drivers/block/xd.c
index 64b496fce98b..ce2429219925 100644
--- a/drivers/block/xd.c
+++ b/drivers/block/xd.c
@@ -305,30 +305,25 @@ static void do_xd_request (struct request_queue * q)
        if (xdc_busy)
                return;
-        while ((req = elv_next_request(q)) != NULL) {
+        req = blk_fetch_request(q);
-                unsigned block = req->sector;
+        while (req) {
-                unsigned count = req->nr_sectors;
+                unsigned block = blk_rq_pos(req);
-                int rw = rq_data_dir(req);
+                unsigned count = blk_rq_cur_sectors(req);
                XD_INFO *disk = req->rq_disk->private_data;
-                int res = 0;
+                int res = -EIO;
                int retry;
-                if (!blk_fs_request(req)) {
+                if (!blk_fs_request(req))
-                        end_request(req, 0);
+                        goto done;
-                        continue;
+                if (block + count > get_capacity(req->rq_disk))
-                }
+                        goto done;
-                if (block + count > get_capacity(req->rq_disk)) {
-                        end_request(req, 0);
-                        continue;
-                }
-                if (rw != READ && rw != WRITE) {
-                        printk("do_xd_request: unknown request\n");
-                        end_request(req, 0);
-                        continue;
-                }
                for (retry = 0; (retry < XD_RETRIES) && !res; retry++)
-                        res = xd_readwrite(rw, disk, req->buffer, block, count);
+                        res = xd_readwrite(rq_data_dir(req), disk, req->buffer,
-                end_request(req, res);  /* wrap up, 0 = fail, 1 = success */
+                                           block, count);
+        done:
+                /* wrap up, 0 = success, -errno = fail */
+                if (!__blk_end_request_cur(req, res))
+                        req = blk_fetch_request(q);
        }
 }
@@ -418,7 +413,7 @@ static int xd_readwrite (u_char operation,XD_INFO *p,char *buffer,u_int block,u_
                                printk("xd%c: %s timeout, recalibrating drive\n",'a'+drive,(operation == READ ? "read" : "write"));
                                xd_recalibrate(drive);
                                spin_lock_irq(&xd_lock);
-                                return (0);
+                                return -EIO;
                        case 2:
                                if (sense[0] & 0x30) {
                                        printk("xd%c: %s - ",'a'+drive,(operation == READ ? "reading" : "writing"));
@@ -439,7 +434,7 @@ static int xd_readwrite (u_char operation,XD_INFO *p,char *buffer,u_int block,u_
                                else
                                        printk(" - no valid disk address\n");
                                spin_lock_irq(&xd_lock);
-                                return (0);
+                                return -EIO;
                }
                if (xd_dma_buffer)
                        for (i=0; i < (temp * 0x200); i++)
@@ -448,7 +443,7 @@ static int xd_readwrite (u_char operation,XD_INFO *p,char *buffer,u_int block,u_
                count -= temp, buffer += temp * 0x200, block += temp;
        }
        spin_lock_irq(&xd_lock);
-        return (1);
+        return 0;
 }
 /* xd_recalibrate: recalibrate a given drive and reset controller if necessary */
diff --git a/drivers/block/xen-blkfront.c b/drivers/block/xen-blkfront.c
index a6cbf7b808e6..e53284767f7c 100644
--- a/drivers/block/xen-blkfront.c
+++ b/drivers/block/xen-blkfront.c
@@ -122,7 +122,7 @@ static DEFINE_SPINLOCK(blkif_io_lock);
 static int get_id_from_freelist(struct blkfront_info *info)
 {
        unsigned long free = info->shadow_free;
-        BUG_ON(free > BLK_RING_SIZE);
+        BUG_ON(free >= BLK_RING_SIZE);
        info->shadow_free = info->shadow[free].req.id;
        info->shadow[free].req.id = 0x0fffffee; /* debug */
        return free;
@@ -231,7 +231,7 @@ static int blkif_queue_request(struct request *req)
        info->shadow[id].request = (unsigned long)req;
        ring_req->id = id;
-        ring_req->sector_number = (blkif_sector_t)req->sector;
+        ring_req->sector_number = (blkif_sector_t)blk_rq_pos(req);
        ring_req->handle = info->handle;
        ring_req->operation = rq_data_dir(req) ?
@@ -299,25 +299,25 @@ static void do_blkif_request(struct request_queue *rq)
        queued = 0;
-        while ((req = elv_next_request(rq)) != NULL) {
+        while ((req = blk_peek_request(rq)) != NULL) {
                info = req->rq_disk->private_data;
-                if (!blk_fs_request(req)) {
-                        end_request(req, 0);
-                        continue;
-                }
                if (RING_FULL(&info->ring))
                        goto wait;
-                pr_debug("do_blk_req %p: cmd %p, sec %lx, "
+                blk_start_request(req);
-                         "(%u/%li) buffer:%p [%s]\n",
-                         req, req->cmd, (unsigned long)req->sector,
-                         req->current_nr_sectors,
-                         req->nr_sectors, req->buffer,
-                         rq_data_dir(req) ? "write" : "read");
+                if (!blk_fs_request(req)) {
+                        __blk_end_request_all(req, -EIO);
+                        continue;
+                }
+                pr_debug("do_blk_req %p: cmd %p, sec %lx, "
+                         "(%u/%u) buffer:%p [%s]\n",
+                         req, req->cmd, (unsigned long)blk_rq_pos(req),
+                         blk_rq_cur_sectors(req), blk_rq_sectors(req),
+                         req->buffer, rq_data_dir(req) ? "write" : "read");
-                blkdev_dequeue_request(req);
                if (blkif_queue_request(req)) {
                        blk_requeue_request(rq, req);
 wait:
@@ -344,7 +344,7 @@ static int xlvbd_init_blk_queue(struct gendisk *gd, u16 sector_size)
        queue_flag_set_unlocked(QUEUE_FLAG_VIRT, rq);
        /* Hard sector size and max sectors impersonate the equiv. hardware. */
-        blk_queue_hardsect_size(rq, sector_size);
+        blk_queue_logical_block_size(rq, sector_size);
        blk_queue_max_sectors(rq, 512);
        /* Each segment in a request is up to an aligned page in size. */
@@ -551,7 +551,6 @@ static irqreturn_t blkif_interrupt(int irq, void *dev_id)
        for (i = info->ring.rsp_cons; i != rp; i++) {
                unsigned long id;
-                int ret;
                bret = RING_GET_RESPONSE(&info->ring, i);
                id   = bret->id;
@@ -578,8 +577,7 @@ static irqreturn_t blkif_interrupt(int irq, void *dev_id)
                                dev_dbg(&info->xbdev->dev, "Bad return from blkdev data "
                                        "request: %x\n", bret->status);
-                        ret = __blk_end_request(req, error, blk_rq_bytes(req));
+                        __blk_end_request_all(req, error);
-                        BUG_ON(ret);
                        break;
                default:
                        BUG();
@@ -755,12 +753,12 @@ static int blkfront_probe(struct xenbus_device *dev,
        /* Front end dir is a number, which is used as the id. */
        info->handle = simple_strtoul(strrchr(dev->nodename, '/')+1, NULL, 0);
-        dev->dev.driver_data = info;
+        dev_set_drvdata(&dev->dev, info);
        err = talk_to_backend(dev, info);
        if (err) {
                kfree(info);
-                dev->dev.driver_data = NULL;
+                dev_set_drvdata(&dev->dev, NULL);
                return err;
        }
@@ -845,7 +843,7 @@ static int blkif_recover(struct blkfront_info *info)
 */
 static int blkfront_resume(struct xenbus_device *dev)
 {
-        struct blkfront_info *info = dev->dev.driver_data;
+        struct blkfront_info *info = dev_get_drvdata(&dev->dev);
        int err;
        dev_dbg(&dev->dev, "blkfront_resume: %s\n", dev->nodename);
@@ -924,7 +922,7 @@ static void blkfront_connect(struct blkfront_info *info)
 */
 static void blkfront_closing(struct xenbus_device *dev)
 {
-        struct blkfront_info *info = dev->dev.driver_data;
+        struct blkfront_info *info = dev_get_drvdata(&dev->dev);
        unsigned long flags;
        dev_dbg(&dev->dev, "blkfront_closing: %s removed\n", dev->nodename);
@@ -959,7 +957,7 @@ static void blkfront_closing(struct xenbus_device *dev)
 static void backend_changed(struct xenbus_device *dev,
                            enum xenbus_state backend_state)
 {
-        struct blkfront_info *info = dev->dev.driver_data;
+        struct blkfront_info *info = dev_get_drvdata(&dev->dev);
        struct block_device *bd;
        dev_dbg(&dev->dev, "blkfront:backend_changed.\n");
@@ -999,7 +997,7 @@ static void backend_changed(struct xenbus_device *dev,
 static int blkfront_remove(struct xenbus_device *dev)
 {
-        struct blkfront_info *info = dev->dev.driver_data;
+        struct blkfront_info *info = dev_get_drvdata(&dev->dev);
        dev_dbg(&dev->dev, "blkfront_remove: %s removed\n", dev->nodename);
@@ -1012,7 +1010,7 @@ static int blkfront_remove(struct xenbus_device *dev)
 static int blkfront_is_ready(struct xenbus_device *dev)
 {
-        struct blkfront_info *info = dev->dev.driver_data;
+        struct blkfront_info *info = dev_get_drvdata(&dev->dev);
        return info->is_ready;
 }
diff --git a/drivers/block/xsysace.c b/drivers/block/xsysace.c
index 4aecf5dc6a93..f08491a3a813 100644
--- a/drivers/block/xsysace.c
+++ b/drivers/block/xsysace.c
@@ -463,10 +463,11 @@ struct request *ace_get_next_request(struct request_queue * q)
 {
        struct request *req;
-        while ((req = elv_next_request(q)) != NULL) {
+        while ((req = blk_peek_request(q)) != NULL) {
                if (blk_fs_request(req))
                        break;
-                end_request(req, 0);
+                blk_start_request(req);
+                __blk_end_request_all(req, -EIO);
        }
        return req;
 }
@@ -492,9 +493,13 @@ static void ace_fsm_dostate(struct ace_device *ace)
                set_capacity(ace->gd, 0);
                dev_info(ace->dev, "No CF in slot\n");
-                /* Drop all pending requests */
+                /* Drop all in-flight and pending requests */
-                while ((req = elv_next_request(ace->queue)) != NULL)
+                if (ace->req) {
-                        end_request(req, 0);
+                        __blk_end_request_all(ace->req, -EIO);
+                        ace->req = NULL;
+                }
+                while ((req = blk_fetch_request(ace->queue)) != NULL)
+                        __blk_end_request_all(req, -EIO);
                /* Drop back to IDLE state and notify waiters */
                ace->fsm_state = ACE_FSM_STATE_IDLE;
@@ -642,19 +647,21 @@ static void ace_fsm_dostate(struct ace_device *ace)
                        ace->fsm_state = ACE_FSM_STATE_IDLE;
                        break;
                }
+                blk_start_request(req);
                /* Okay, it's a data request, set it up for transfer */
                dev_dbg(ace->dev,
-                        "request: sec=%llx hcnt=%lx, ccnt=%x, dir=%i\n",
+                        "request: sec=%llx hcnt=%x, ccnt=%x, dir=%i\n",
-                        (unsigned long long) req->sector, req->hard_nr_sectors,
+                        (unsigned long long)blk_rq_pos(req),
-                        req->current_nr_sectors, rq_data_dir(req));
+                        blk_rq_sectors(req), blk_rq_cur_sectors(req),
+                        rq_data_dir(req));
                ace->req = req;
                ace->data_ptr = req->buffer;
-                ace->data_count = req->current_nr_sectors * ACE_BUF_PER_SECTOR;
+                ace->data_count = blk_rq_cur_sectors(req) * ACE_BUF_PER_SECTOR;
-                ace_out32(ace, ACE_MPULBA, req->sector & 0x0FFFFFFF);
+                ace_out32(ace, ACE_MPULBA, blk_rq_pos(req) & 0x0FFFFFFF);
-                count = req->hard_nr_sectors;
+                count = blk_rq_sectors(req);
                if (rq_data_dir(req)) {
                        /* Kick off write request */
                        dev_dbg(ace->dev, "write data\n");
@@ -688,7 +695,7 @@ static void ace_fsm_dostate(struct ace_device *ace)
                        dev_dbg(ace->dev,
                                "CFBSY set; t=%i iter=%i c=%i dc=%i irq=%i\n",
                                ace->fsm_task, ace->fsm_iter_num,
-                                ace->req->current_nr_sectors * 16,
+                                blk_rq_cur_sectors(ace->req) * 16,
                                ace->data_count, ace->in_irq);
                        ace_fsm_yield(ace);     /* need to poll CFBSY bit */
                        break;
@@ -697,7 +704,7 @@ static void ace_fsm_dostate(struct ace_device *ace)
                        dev_dbg(ace->dev,
                                "DATABUF not set; t=%i iter=%i c=%i dc=%i irq=%i\n",
                                ace->fsm_task, ace->fsm_iter_num,
-                                ace->req->current_nr_sectors * 16,
+                                blk_rq_cur_sectors(ace->req) * 16,
                                ace->data_count, ace->in_irq);
                        ace_fsm_yieldirq(ace);
                        break;
@@ -717,14 +724,13 @@ static void ace_fsm_dostate(struct ace_device *ace)
                }
                /* bio finished; is there another one? */
-                if (__blk_end_request(ace->req, 0,
+                if (__blk_end_request_cur(ace->req, 0)) {
-                                        blk_rq_cur_bytes(ace->req))) {
+                        /* dev_dbg(ace->dev, "next block; h=%u c=%u\n",
-                        /* dev_dbg(ace->dev, "next block; h=%li c=%i\n",
+                         *      blk_rq_sectors(ace->req),
-                         *      ace->req->hard_nr_sectors,
+                         *      blk_rq_cur_sectors(ace->req));
-                         *      ace->req->current_nr_sectors);
                         */
                        ace->data_ptr = ace->req->buffer;
-                        ace->data_count = ace->req->current_nr_sectors * 16;
+                        ace->data_count = blk_rq_cur_sectors(ace->req) * 16;
                        ace_fsm_yieldirq(ace);
                        break;
                }
@@ -978,7 +984,7 @@ static int __devinit ace_setup(struct ace_device *ace)
        ace->queue = blk_init_queue(ace_request, &ace->lock);
        if (ace->queue == NULL)
                goto err_blk_initq;
-        blk_queue_hardsect_size(ace->queue, 512);
+        blk_queue_logical_block_size(ace->queue, 512);
        /*
         * Allocate and initialize GD structure
diff --git a/drivers/block/z2ram.c b/drivers/block/z2ram.c
index 80754cdd3119..4575171e5beb 100644
--- a/drivers/block/z2ram.c
+++ b/drivers/block/z2ram.c
@@ -70,15 +70,18 @@ static struct gendisk *z2ram_gendisk;
 static void do_z2_request(struct request_queue *q)
 {
        struct request *req;
-        while ((req = elv_next_request(q)) != NULL) {
-                unsigned long start = req->sector << 9;
+        req = blk_fetch_request(q);
-                unsigned long len  = req->current_nr_sectors << 9;
+        while (req) {
+                unsigned long start = blk_rq_pos(req) << 9;
+                unsigned long len  = blk_rq_cur_bytes(req);
+                int err = 0;
                if (start + len > z2ram_size) {
                        printk( KERN_ERR DEVICE_NAME ": bad access: block=%lu, count=%u\n",
-                                req->sector, req->current_nr_sectors);
+                                blk_rq_pos(req), blk_rq_cur_sectors(req));
-                        end_request(req, 0);
+                        err = -EIO;
-                        continue;
+                        goto done;
                }
                while (len) {
                        unsigned long addr = start & Z2RAM_CHUNKMASK;
@@ -93,7 +96,9 @@ static void do_z2_request(struct request_queue *q)
                        start += size;
                        len -= size;
                }
-                end_request(req, 1);
+        done:
+                if (!__blk_end_request_cur(req, err))
+                        req = blk_fetch_request(q);
        }
 }