Merge branch 'post-2.6.15' of git://brick.kernel.dk/data/git/linux-2.6-block

Manual fixup for merge with Jens' "Suspend support for libata", commit
ID 9b847548663ef1039dd49f0eb4463d001e596bc3.

Signed-off-by: Linus Torvalds <torvalds@osdl.org>

20 files changed, 103 insertions, 125 deletions

diff --git a/drivers/scsi/ahci.c b/drivers/scsi/ahci.c
index 887eaa2a3ebf..d113290b5fc0 100644
--- a/drivers/scsi/ahci.c
+++ b/drivers/scsi/ahci.c
@@ -214,7 +214,6 @@ static struct scsi_host_template ahci_sht = {
         .dma_boundary           = AHCI_DMA_BOUNDARY,
         .slave_configure        = ata_scsi_slave_config,
         .bios_param             = ata_std_bios_param,
-        .ordered_flush          = 1,
 };
 
 static const struct ata_port_operations ahci_ops = {
diff --git a/drivers/scsi/ata_piix.c b/drivers/scsi/ata_piix.c
index f79630340028..557788ec4eec 100644
--- a/drivers/scsi/ata_piix.c
+++ b/drivers/scsi/ata_piix.c
@@ -187,7 +187,6 @@ static struct scsi_host_template piix_sht = {
         .dma_boundary           = ATA_DMA_BOUNDARY,
         .slave_configure        = ata_scsi_slave_config,
         .bios_param             = ata_std_bios_param,
-        .ordered_flush          = 1,
         .resume                 = ata_scsi_device_resume,
         .suspend                = ata_scsi_device_suspend,
 };
diff --git a/drivers/scsi/hosts.c b/drivers/scsi/hosts.c
index 5b9c2c5a7f0e..66783c860a19 100644
--- a/drivers/scsi/hosts.c
+++ b/drivers/scsi/hosts.c
@@ -347,17 +347,8 @@ struct Scsi_Host *scsi_host_alloc(struct scsi_host_template *sht, int privsize)
         shost->cmd_per_lun = sht->cmd_per_lun;
         shost->unchecked_isa_dma = sht->unchecked_isa_dma;
         shost->use_clustering = sht->use_clustering;
-        shost->ordered_flush = sht->ordered_flush;
         shost->ordered_tag = sht->ordered_tag;
 
-        /*
-         * hosts/devices that do queueing must support ordered tags
-         */
-        if (shost->can_queue > 1 && shost->ordered_flush) {
-                printk(KERN_ERR "scsi: ordered flushes don't support queueing\n");
-                shost->ordered_flush = 0;
-        }
-
         if (sht->max_host_blocked)
                 shost->max_host_blocked = sht->max_host_blocked;
         else
diff --git a/drivers/scsi/ide-scsi.c b/drivers/scsi/ide-scsi.c
index 4cb1f3ed9100..3c688ef54660 100644
--- a/drivers/scsi/ide-scsi.c
+++ b/drivers/scsi/ide-scsi.c
@@ -1046,7 +1046,7 @@ static int idescsi_eh_reset (struct scsi_cmnd *cmd)
 
         /* kill current request */
         blkdev_dequeue_request(req);
-        end_that_request_last(req);
+        end_that_request_last(req, 0);
         if (req->flags & REQ_SENSE)
                 kfree(scsi->pc->buffer);
         kfree(scsi->pc);
@@ -1056,7 +1056,7 @@ static int idescsi_eh_reset (struct scsi_cmnd *cmd)
         /* now nuke the drive queue */
         while ((req = elv_next_request(drive->queue))) {
                 blkdev_dequeue_request(req);
-                end_that_request_last(req);
+                end_that_request_last(req, 0);
         }
 
         HWGROUP(drive)->rq = NULL;
diff --git a/drivers/scsi/libata-core.c b/drivers/scsi/libata-core.c
index 9c66d4059399..f55b9b3f7b37 100644
--- a/drivers/scsi/libata-core.c
+++ b/drivers/scsi/libata-core.c
@@ -562,16 +562,28 @@ static const u8 ata_rw_cmds[] = {
         ATA_CMD_WRITE_MULTI,
         ATA_CMD_READ_MULTI_EXT,
         ATA_CMD_WRITE_MULTI_EXT,
+        0,
+        0,
+        0,
+        ATA_CMD_WRITE_MULTI_FUA_EXT,
         /* pio */
         ATA_CMD_PIO_READ,
         ATA_CMD_PIO_WRITE,
         ATA_CMD_PIO_READ_EXT,
         ATA_CMD_PIO_WRITE_EXT,
+        0,
+        0,
+        0,
+        0,
         /* dma */
         ATA_CMD_READ,
         ATA_CMD_WRITE,
         ATA_CMD_READ_EXT,
-        ATA_CMD_WRITE_EXT
+        ATA_CMD_WRITE_EXT,
+        0,
+        0,
+        0,
+        ATA_CMD_WRITE_FUA_EXT
 };
 
 /**
@@ -584,25 +596,32 @@ static const u8 ata_rw_cmds[] = {
  *      LOCKING:
  *      caller.
  */
-void ata_rwcmd_protocol(struct ata_queued_cmd *qc)
+int ata_rwcmd_protocol(struct ata_queued_cmd *qc)
 {
         struct ata_taskfile *tf = &qc->tf;
         struct ata_device *dev = qc->dev;
+        u8 cmd;
 
-        int index, lba48, write;
+        int index, fua, lba48, write;
  
+        fua = (tf->flags & ATA_TFLAG_FUA) ? 4 : 0;
         lba48 = (tf->flags & ATA_TFLAG_LBA48) ? 2 : 0;
         write = (tf->flags & ATA_TFLAG_WRITE) ? 1 : 0;
 
         if (dev->flags & ATA_DFLAG_PIO) {
                 tf->protocol = ATA_PROT_PIO;
-                index = dev->multi_count ? 0 : 4;
+                index = dev->multi_count ? 0 : 8;
         } else {
                 tf->protocol = ATA_PROT_DMA;
-                index = 8;
+                index = 16;
         }
 
-        tf->command = ata_rw_cmds[index + lba48 + write];
+        cmd = ata_rw_cmds[index + fua + lba48 + write];
+        if (cmd) {
+                tf->command = cmd;
+                return 0;
+        }
+        return -1;
 }
 
 static const char * const xfer_mode_str[] = {
diff --git a/drivers/scsi/libata-scsi.c b/drivers/scsi/libata-scsi.c
index c1ebede14a48..cfbceb504718 100644
--- a/drivers/scsi/libata-scsi.c
+++ b/drivers/scsi/libata-scsi.c
@@ -1096,11 +1096,13 @@ static unsigned int ata_scsi_rw_xlat(struct ata_queued_cmd *qc, const u8 *scsicm
             scsicmd[0] == WRITE_16)
                 tf->flags |= ATA_TFLAG_WRITE;
 
-        /* Calculate the SCSI LBA and transfer length. */
+        /* Calculate the SCSI LBA, transfer length and FUA. */
         switch (scsicmd[0]) {
         case READ_10:
         case WRITE_10:
                 scsi_10_lba_len(scsicmd, &block, &n_block);
+                if (unlikely(scsicmd[1] & (1 << 3)))
+                        tf->flags |= ATA_TFLAG_FUA;
                 break;
         case READ_6:
         case WRITE_6:
@@ -1115,6 +1117,8 @@ static unsigned int ata_scsi_rw_xlat(struct ata_queued_cmd *qc, const u8 *scsicm
         case READ_16:
         case WRITE_16:
                 scsi_16_lba_len(scsicmd, &block, &n_block);
+                if (unlikely(scsicmd[1] & (1 << 3)))
+                        tf->flags |= ATA_TFLAG_FUA;
                 break;
         default:
                 DPRINTK("no-byte command\n");
@@ -1158,7 +1162,8 @@ static unsigned int ata_scsi_rw_xlat(struct ata_queued_cmd *qc, const u8 *scsicm
                         tf->device |= (block >> 24) & 0xf;
                 }
 
-                ata_rwcmd_protocol(qc);
+                if (unlikely(ata_rwcmd_protocol(qc) < 0))
+                        goto invalid_fld;
 
                 qc->nsect = n_block;
                 tf->nsect = n_block & 0xff;
@@ -1176,7 +1181,8 @@ static unsigned int ata_scsi_rw_xlat(struct ata_queued_cmd *qc, const u8 *scsicm
                 if ((block >> 28) || (n_block > 256))
                         goto out_of_range;
 
-                ata_rwcmd_protocol(qc);
+                if (unlikely(ata_rwcmd_protocol(qc) < 0))
+                        goto invalid_fld;
 
                 /* Convert LBA to CHS */
                 track = (u32)block / dev->sectors;
@@ -1711,6 +1717,7 @@ static unsigned int ata_msense_rw_recovery(u8 **ptr_io, const u8 *last)
 unsigned int ata_scsiop_mode_sense(struct ata_scsi_args *args, u8 *rbuf,
                                   unsigned int buflen)
 {
+        struct ata_device *dev = args->dev;
         u8 *scsicmd = args->cmd->cmnd, *p, *last;
         const u8 sat_blk_desc[] = {
                 0, 0, 0, 0,     /* number of blocks: sat unspecified */
@@ -1719,6 +1726,7 @@ unsigned int ata_scsiop_mode_sense(struct ata_scsi_args *args, u8 *rbuf,
         };
         u8 pg, spg;
         unsigned int ebd, page_control, six_byte, output_len, alloc_len, minlen;
+        u8 dpofua;
 
         VPRINTK("ENTER\n");
 
@@ -1787,9 +1795,17 @@ unsigned int ata_scsiop_mode_sense(struct ata_scsi_args *args, u8 *rbuf,
 
         if (minlen < 1)
                 return 0;
+
+        dpofua = 0;
+        if (ata_id_has_fua(args->id) && dev->flags & ATA_DFLAG_LBA48 &&
+            (!(dev->flags & ATA_DFLAG_PIO) || dev->multi_count))
+                dpofua = 1 << 4;
+
         if (six_byte) {
                 output_len--;
                 rbuf[0] = output_len;
+                if (minlen > 2)
+                        rbuf[2] |= dpofua;
                 if (ebd) {
                         if (minlen > 3)
                                 rbuf[3] = sizeof(sat_blk_desc);
@@ -1802,6 +1818,8 @@ unsigned int ata_scsiop_mode_sense(struct ata_scsi_args *args, u8 *rbuf,
                 rbuf[0] = output_len >> 8;
                 if (minlen > 1)
                         rbuf[1] = output_len;
+                if (minlen > 3)
+                        rbuf[3] |= dpofua;
                 if (ebd) {
                         if (minlen > 7)
                                 rbuf[7] = sizeof(sat_blk_desc);
@@ -2462,7 +2480,7 @@ int ata_scsi_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
                 if (xlat_func)
                         ata_scsi_translate(ap, dev, cmd, done, xlat_func);
                 else
-                        ata_scsi_simulate(dev->id, cmd, done);
+                        ata_scsi_simulate(ap, dev, cmd, done);
         } else
                 ata_scsi_translate(ap, dev, cmd, done, atapi_xlat);
 
@@ -2485,14 +2503,16 @@ out_unlock:
  *      spin_lock_irqsave(host_set lock)
  */
 
-void ata_scsi_simulate(u16 *id,
+void ata_scsi_simulate(struct ata_port *ap, struct ata_device *dev,
                       struct scsi_cmnd *cmd,
                       void (*done)(struct scsi_cmnd *))
 {
         struct ata_scsi_args args;
         const u8 *scsicmd = cmd->cmnd;
 
-        args.id = id;
+        args.ap = ap;
+        args.dev = dev;
+        args.id = dev->id;
         args.cmd = cmd;
         args.done = done;
 
diff --git a/drivers/scsi/libata.h b/drivers/scsi/libata.h
index 251e53bdc6e0..e03ce48b7b4b 100644
--- a/drivers/scsi/libata.h
+++ b/drivers/scsi/libata.h
@@ -32,6 +32,8 @@
 #define DRV_VERSION     "1.20"  /* must be exactly four chars */
 
 struct ata_scsi_args {
+        struct ata_port         *ap;
+        struct ata_device       *dev;
         u16                     *id;
         struct scsi_cmnd        *cmd;
         void                    (*done)(struct scsi_cmnd *);
@@ -41,7 +43,7 @@ struct ata_scsi_args {
 extern int atapi_enabled;
 extern struct ata_queued_cmd *ata_qc_new_init(struct ata_port *ap,
                                       struct ata_device *dev);
-extern void ata_rwcmd_protocol(struct ata_queued_cmd *qc);
+extern int ata_rwcmd_protocol(struct ata_queued_cmd *qc);
 extern void ata_qc_free(struct ata_queued_cmd *qc);
 extern int ata_qc_issue(struct ata_queued_cmd *qc);
 extern int ata_check_atapi_dma(struct ata_queued_cmd *qc);
diff --git a/drivers/scsi/sata_mv.c b/drivers/scsi/sata_mv.c
index b2bf16a9bf4b..cd54244058b5 100644
--- a/drivers/scsi/sata_mv.c
+++ b/drivers/scsi/sata_mv.c
@@ -374,7 +374,6 @@ static struct scsi_host_template mv_sht = {
         .dma_boundary           = MV_DMA_BOUNDARY,
         .slave_configure        = ata_scsi_slave_config,
         .bios_param             = ata_std_bios_param,
-        .ordered_flush          = 1,
 };
 
 static const struct ata_port_operations mv5_ops = {
diff --git a/drivers/scsi/sata_nv.c b/drivers/scsi/sata_nv.c
index 4954896dfdb9..c0cf52cb975a 100644
--- a/drivers/scsi/sata_nv.c
+++ b/drivers/scsi/sata_nv.c
@@ -235,7 +235,6 @@ static struct scsi_host_template nv_sht = {
         .dma_boundary           = ATA_DMA_BOUNDARY,
         .slave_configure        = ata_scsi_slave_config,
         .bios_param             = ata_std_bios_param,
-        .ordered_flush          = 1,
 };
 
 static const struct ata_port_operations nv_ops = {
diff --git a/drivers/scsi/sata_promise.c b/drivers/scsi/sata_promise.c
index da7fa04b8a73..3d1ea09a06a1 100644
--- a/drivers/scsi/sata_promise.c
+++ b/drivers/scsi/sata_promise.c
@@ -114,7 +114,6 @@ static struct scsi_host_template pdc_ata_sht = {
         .dma_boundary           = ATA_DMA_BOUNDARY,
         .slave_configure        = ata_scsi_slave_config,
         .bios_param             = ata_std_bios_param,
-        .ordered_flush          = 1,
 };
 
 static const struct ata_port_operations pdc_sata_ops = {
diff --git a/drivers/scsi/sata_sil.c b/drivers/scsi/sata_sil.c
index d2053487c73b..b017f85e6d6a 100644
--- a/drivers/scsi/sata_sil.c
+++ b/drivers/scsi/sata_sil.c
@@ -147,7 +147,6 @@ static struct scsi_host_template sil_sht = {
         .dma_boundary           = ATA_DMA_BOUNDARY,
         .slave_configure        = ata_scsi_slave_config,
         .bios_param             = ata_std_bios_param,
-        .ordered_flush          = 1,
 };
 
 static const struct ata_port_operations sil_ops = {
diff --git a/drivers/scsi/sata_sil24.c b/drivers/scsi/sata_sil24.c
index a0ad3ed2200a..923130185a9e 100644
--- a/drivers/scsi/sata_sil24.c
+++ b/drivers/scsi/sata_sil24.c
@@ -292,7 +292,6 @@ static struct scsi_host_template sil24_sht = {
         .dma_boundary           = ATA_DMA_BOUNDARY,
         .slave_configure        = ata_scsi_slave_config,
         .bios_param             = ata_std_bios_param,
-        .ordered_flush          = 1, /* NCQ not supported yet */
 };
 
 static const struct ata_port_operations sil24_ops = {
diff --git a/drivers/scsi/sata_sis.c b/drivers/scsi/sata_sis.c
index 32e12620b162..2df8c5632ac3 100644
--- a/drivers/scsi/sata_sis.c
+++ b/drivers/scsi/sata_sis.c
@@ -99,7 +99,6 @@ static struct scsi_host_template sis_sht = {
         .dma_boundary           = ATA_DMA_BOUNDARY,
         .slave_configure        = ata_scsi_slave_config,
         .bios_param             = ata_std_bios_param,
-        .ordered_flush          = 1,
 };
 
 static const struct ata_port_operations sis_ops = {
diff --git a/drivers/scsi/sata_svw.c b/drivers/scsi/sata_svw.c
index 6e7f7c83a75a..668373590aa4 100644
--- a/drivers/scsi/sata_svw.c
+++ b/drivers/scsi/sata_svw.c
@@ -303,7 +303,6 @@ static struct scsi_host_template k2_sata_sht = {
         .proc_info              = k2_sata_proc_info,
 #endif
         .bios_param             = ata_std_bios_param,
-        .ordered_flush          = 1,
 };
 
 
diff --git a/drivers/scsi/sata_sx4.c b/drivers/scsi/sata_sx4.c
index 94b253b80da8..bc87c16c80d2 100644
--- a/drivers/scsi/sata_sx4.c
+++ b/drivers/scsi/sata_sx4.c
@@ -194,7 +194,6 @@ static struct scsi_host_template pdc_sata_sht = {
         .dma_boundary           = ATA_DMA_BOUNDARY,
         .slave_configure        = ata_scsi_slave_config,
         .bios_param             = ata_std_bios_param,
-        .ordered_flush          = 1,
 };
 
 static const struct ata_port_operations pdc_20621_ops = {
diff --git a/drivers/scsi/sata_uli.c b/drivers/scsi/sata_uli.c
index b2422a0f25c8..9635ca700977 100644
--- a/drivers/scsi/sata_uli.c
+++ b/drivers/scsi/sata_uli.c
@@ -87,7 +87,6 @@ static struct scsi_host_template uli_sht = {
         .dma_boundary           = ATA_DMA_BOUNDARY,
         .slave_configure        = ata_scsi_slave_config,
         .bios_param             = ata_std_bios_param,
-        .ordered_flush          = 1,
 };
 
 static const struct ata_port_operations uli_ops = {
diff --git a/drivers/scsi/sata_via.c b/drivers/scsi/sata_via.c
index c76215692da2..6d5b0a794cfd 100644
--- a/drivers/scsi/sata_via.c
+++ b/drivers/scsi/sata_via.c
@@ -106,7 +106,6 @@ static struct scsi_host_template svia_sht = {
         .dma_boundary           = ATA_DMA_BOUNDARY,
         .slave_configure        = ata_scsi_slave_config,
         .bios_param             = ata_std_bios_param,
-        .ordered_flush          = 1,
 };
 
 static const struct ata_port_operations svia_sata_ops = {
diff --git a/drivers/scsi/sata_vsc.c b/drivers/scsi/sata_vsc.c
index fcfa486965b4..2e2c3b7acb0c 100644
--- a/drivers/scsi/sata_vsc.c
+++ b/drivers/scsi/sata_vsc.c
@@ -235,7 +235,6 @@ static struct scsi_host_template vsc_sata_sht = {
         .dma_boundary           = ATA_DMA_BOUNDARY,
         .slave_configure        = ata_scsi_slave_config,
         .bios_param             = ata_std_bios_param,
-        .ordered_flush          = 1,
 };
 
 
diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index a7f3f0c84db7..ba93d6e66d48 100644
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -308,7 +308,7 @@ struct scsi_io_context {
 
 static kmem_cache_t *scsi_io_context_cache;
 
-static void scsi_end_async(struct request *req)
+static void scsi_end_async(struct request *req, int uptodate)
 {
         struct scsi_io_context *sioc = req->end_io_data;
 
@@ -791,7 +791,7 @@ static struct scsi_cmnd *scsi_end_request(struct scsi_cmnd *cmd, int uptodate,
         spin_lock_irqsave(q->queue_lock, flags);
         if (blk_rq_tagged(req))
                 blk_queue_end_tag(q, req);
-        end_that_request_last(req);
+        end_that_request_last(req, uptodate);
         spin_unlock_irqrestore(q->queue_lock, flags);
 
         /*
@@ -932,9 +932,6 @@ void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes,
         int sense_valid = 0;
         int sense_deferred = 0;
 
-        if (blk_complete_barrier_rq(q, req, good_bytes >> 9))
-                return;
-
         /*
          * Free up any indirection buffers we allocated for DMA purposes. 
          * For the case of a READ, we need to copy the data out of the
@@ -1199,38 +1196,6 @@ static int scsi_init_io(struct scsi_cmnd *cmd)
         return BLKPREP_KILL;
 }
 
-static int scsi_prepare_flush_fn(request_queue_t *q, struct request *rq)
-{
-        struct scsi_device *sdev = q->queuedata;
-        struct scsi_driver *drv;
-
-        if (sdev->sdev_state == SDEV_RUNNING) {
-                drv = *(struct scsi_driver **) rq->rq_disk->private_data;
-
-                if (drv->prepare_flush)
-                        return drv->prepare_flush(q, rq);
-        }
-
-        return 0;
-}
-
-static void scsi_end_flush_fn(request_queue_t *q, struct request *rq)
-{
-        struct scsi_device *sdev = q->queuedata;
-        struct request *flush_rq = rq->end_io_data;
-        struct scsi_driver *drv;
-
-        if (flush_rq->errors) {
-                printk("scsi: barrier error, disabling flush support\n");
-                blk_queue_ordered(q, QUEUE_ORDERED_NONE);
-        }
-
-        if (sdev->sdev_state == SDEV_RUNNING) {
-                drv = *(struct scsi_driver **) rq->rq_disk->private_data;
-                drv->end_flush(q, rq);
-        }
-}
-
 static int scsi_issue_flush_fn(request_queue_t *q, struct gendisk *disk,
                                sector_t *error_sector)
 {
@@ -1703,17 +1668,6 @@ struct request_queue *scsi_alloc_queue(struct scsi_device *sdev)
         blk_queue_segment_boundary(q, shost->dma_boundary);
         blk_queue_issue_flush_fn(q, scsi_issue_flush_fn);
 
-        /*
-         * ordered tags are superior to flush ordering
-         */
-        if (shost->ordered_tag)
-                blk_queue_ordered(q, QUEUE_ORDERED_TAG);
-        else if (shost->ordered_flush) {
-                blk_queue_ordered(q, QUEUE_ORDERED_FLUSH);
-                q->prepare_flush_fn = scsi_prepare_flush_fn;
-                q->end_flush_fn = scsi_end_flush_fn;
-        }
-
         if (!shost->use_clustering)
                 clear_bit(QUEUE_FLAG_CLUSTER, &q->queue_flags);
         return q;
diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
index 3d3ad7d1b779..32d4d8d7b9f3 100644
--- a/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@ -102,6 +102,7 @@ struct scsi_disk {
         u8              write_prot;
         unsigned        WCE : 1;        /* state of disk WCE bit */
         unsigned        RCD : 1;        /* state of disk RCD bit, unused */
+        unsigned        DPOFUA : 1;     /* state of disk DPOFUA bit */
 };
 
 static DEFINE_IDR(sd_index_idr);
@@ -121,8 +122,7 @@ static void sd_shutdown(struct device *dev);
 static void sd_rescan(struct device *);
 static int sd_init_command(struct scsi_cmnd *);
 static int sd_issue_flush(struct device *, sector_t *);
-static void sd_end_flush(request_queue_t *, struct request *);
-static int sd_prepare_flush(request_queue_t *, struct request *);
+static void sd_prepare_flush(request_queue_t *, struct request *);
 static void sd_read_capacity(struct scsi_disk *sdkp, char *diskname,
                              unsigned char *buffer);
 
@@ -137,8 +137,6 @@ static struct scsi_driver sd_template = {
         .rescan                 = sd_rescan,
         .init_command           = sd_init_command,
         .issue_flush            = sd_issue_flush,
-        .prepare_flush          = sd_prepare_flush,
-        .end_flush              = sd_end_flush,
 };
 
 /*
@@ -346,6 +344,7 @@ static int sd_init_command(struct scsi_cmnd * SCpnt)
         
         if (block > 0xffffffff) {
                 SCpnt->cmnd[0] += READ_16 - READ_6;
+                SCpnt->cmnd[1] |= blk_fua_rq(rq) ? 0x8 : 0;
                 SCpnt->cmnd[2] = sizeof(block) > 4 ? (unsigned char) (block >> 56) & 0xff : 0;
                 SCpnt->cmnd[3] = sizeof(block) > 4 ? (unsigned char) (block >> 48) & 0xff : 0;
                 SCpnt->cmnd[4] = sizeof(block) > 4 ? (unsigned char) (block >> 40) & 0xff : 0;
@@ -365,6 +364,7 @@ static int sd_init_command(struct scsi_cmnd * SCpnt)
                         this_count = 0xffff;
 
                 SCpnt->cmnd[0] += READ_10 - READ_6;
+                SCpnt->cmnd[1] |= blk_fua_rq(rq) ? 0x8 : 0;
                 SCpnt->cmnd[2] = (unsigned char) (block >> 24) & 0xff;
                 SCpnt->cmnd[3] = (unsigned char) (block >> 16) & 0xff;
                 SCpnt->cmnd[4] = (unsigned char) (block >> 8) & 0xff;
@@ -373,6 +373,17 @@ static int sd_init_command(struct scsi_cmnd * SCpnt)
                 SCpnt->cmnd[7] = (unsigned char) (this_count >> 8) & 0xff;
                 SCpnt->cmnd[8] = (unsigned char) this_count & 0xff;
         } else {
+                if (unlikely(blk_fua_rq(rq))) {
+                        /*
+                         * This happens only if this drive failed
+                         * 10byte rw command with ILLEGAL_REQUEST
+                         * during operation and thus turned off
+                         * use_10_for_rw.
+                         */
+                        printk(KERN_ERR "sd: FUA write on READ/WRITE(6) drive\n");
+                        return 0;
+                }
+
                 SCpnt->cmnd[1] |= (unsigned char) ((block >> 16) & 0x1f);
                 SCpnt->cmnd[2] = (unsigned char) ((block >> 8) & 0xff);
                 SCpnt->cmnd[3] = (unsigned char) block & 0xff;
@@ -729,42 +740,13 @@ static int sd_issue_flush(struct device *dev, sector_t *error_sector)
         return ret;
 }
 
-static void sd_end_flush(request_queue_t *q, struct request *flush_rq)
-{
-        struct request *rq = flush_rq->end_io_data;
-        struct scsi_cmnd *cmd = rq->special;
-        unsigned int bytes = rq->hard_nr_sectors << 9;
-
-        if (!flush_rq->errors) {
-                spin_unlock(q->queue_lock);
-                scsi_io_completion(cmd, bytes, 0);
-                spin_lock(q->queue_lock);
-        } else if (blk_barrier_postflush(rq)) {
-                spin_unlock(q->queue_lock);
-                scsi_io_completion(cmd, 0, bytes);
-                spin_lock(q->queue_lock);
-        } else {
-                /*
-                 * force journal abort of barriers
-                 */
-                end_that_request_first(rq, -EOPNOTSUPP, rq->hard_nr_sectors);
-                end_that_request_last(rq);
-        }
-}
-
-static int sd_prepare_flush(request_queue_t *q, struct request *rq)
+static void sd_prepare_flush(request_queue_t *q, struct request *rq)
 {
-        struct scsi_device *sdev = q->queuedata;
-        struct scsi_disk *sdkp = dev_get_drvdata(&sdev->sdev_gendev);
-
-        if (!sdkp || !sdkp->WCE)
-                return 0;
-
         memset(rq->cmd, 0, sizeof(rq->cmd));
-        rq->flags |= REQ_BLOCK_PC | REQ_SOFTBARRIER;
+        rq->flags |= REQ_BLOCK_PC;
         rq->timeout = SD_TIMEOUT;
         rq->cmd[0] = SYNCHRONIZE_CACHE;
-        return 1;
+        rq->cmd_len = 10;
 }
 
 static void sd_rescan(struct device *dev)
@@ -1427,10 +1409,18 @@ sd_read_cache_type(struct scsi_disk *sdkp, char *diskname,
                         sdkp->RCD = 0;
                 }
 
+                sdkp->DPOFUA = (data.device_specific & 0x10) != 0;
+                if (sdkp->DPOFUA && !sdkp->device->use_10_for_rw) {
+                        printk(KERN_NOTICE "SCSI device %s: uses "
+                               "READ/WRITE(6), disabling FUA\n", diskname);
+                        sdkp->DPOFUA = 0;
+                }
+
                 ct =  sdkp->RCD + 2*sdkp->WCE;
 
-                printk(KERN_NOTICE "SCSI device %s: drive cache: %s\n",
-                       diskname, types[ct]);
+                printk(KERN_NOTICE "SCSI device %s: drive cache: %s%s\n",
+                       diskname, types[ct],
+                       sdkp->DPOFUA ? " w/ FUA" : "");
 
                 return;
         }
@@ -1462,6 +1452,7 @@ static int sd_revalidate_disk(struct gendisk *disk)
         struct scsi_disk *sdkp = scsi_disk(disk);
         struct scsi_device *sdp = sdkp->device;
         unsigned char *buffer;
+        unsigned ordered;
 
         SCSI_LOG_HLQUEUE(3, printk("sd_revalidate_disk: disk=%s\n", disk->disk_name));
 
@@ -1498,7 +1489,21 @@ static int sd_revalidate_disk(struct gendisk *disk)
                 sd_read_write_protect_flag(sdkp, disk->disk_name, buffer);
                 sd_read_cache_type(sdkp, disk->disk_name, buffer);
         }
-                
+
+        /*
+         * We now have all cache related info, determine how we deal
+         * with ordered requests.  Note that as the current SCSI
+         * dispatch function can alter request order, we cannot use
+         * QUEUE_ORDERED_TAG_* even when ordered tag is supported.
+         */
+        if (sdkp->WCE)
+                ordered = sdkp->DPOFUA
+                        ? QUEUE_ORDERED_DRAIN_FUA : QUEUE_ORDERED_DRAIN_FLUSH;
+        else
+                ordered = QUEUE_ORDERED_DRAIN;
+
+        blk_queue_ordered(sdkp->disk->queue, ordered, sd_prepare_flush);
+
         set_capacity(disk, sdkp->capacity);
         kfree(buffer);
 
@@ -1598,6 +1603,7 @@ static int sd_probe(struct device *dev)
         strcpy(gd->devfs_name, sdp->devfs_name);
 
         gd->private_data = &sdkp->driver;
+        gd->queue = sdkp->device->request_queue;
 
         sd_revalidate_disk(gd);
 
@@ -1605,7 +1611,6 @@ static int sd_probe(struct device *dev)
         gd->flags = GENHD_FL_DRIVERFS;
         if (sdp->removable)
                 gd->flags |= GENHD_FL_REMOVABLE;
-        gd->queue = sdkp->device->request_queue;
 
         dev_set_drvdata(dev, sdkp);
         add_disk(gd);