1 files changed, 56 insertions, 19 deletions

diff --git a/drivers/ata/libata-scsi.c b/drivers/ata/libata-scsi.c
index 1cea18f62abc..0562b0a49f3b 100644
--- a/drivers/ata/libata-scsi.c
+++ b/drivers/ata/libata-scsi.c
@@ -826,30 +826,61 @@ static void ata_scsi_sdev_config(struct scsi_device *sdev)
         sdev->max_device_blocked = 1;
 }
 
-static void ata_scsi_dev_config(struct scsi_device *sdev,
-                                struct ata_device *dev)
+/**
+ *      atapi_drain_needed - Check whether data transfer may overflow
+ *      @rq: request to be checked
+ *
+ *      ATAPI commands which transfer variable length data to host
+ *      might overflow due to application error or hardare bug.  This
+ *      function checks whether overflow should be drained and ignored
+ *      for @request.
+ *
+ *      LOCKING:
+ *      None.
+ *
+ *      RETURNS:
+ *      1 if ; otherwise, 0.
+ */
+static int atapi_drain_needed(struct request *rq)
+{
+        if (likely(!blk_pc_request(rq)))
+                return 0;
+
+        if (!rq->data_len || (rq->cmd_flags & REQ_RW))
+                return 0;
+
+        return atapi_cmd_type(rq->cmd[0]) == ATAPI_MISC;
+}
+
+static int ata_scsi_dev_config(struct scsi_device *sdev,
+                               struct ata_device *dev)
 {
         /* configure max sectors */
         blk_queue_max_sectors(sdev->request_queue, dev->max_sectors);
 
-        /* SATA DMA transfers must be multiples of 4 byte, so
-         * we need to pad ATAPI transfers using an extra sg.
-         * Decrement max hw segments accordingly.
-         */
         if (dev->class == ATA_DEV_ATAPI) {
                 struct request_queue *q = sdev->request_queue;
-                blk_queue_max_hw_segments(q, q->max_hw_segments - 1);
+                void *buf;
 
                 /* set the min alignment */
                 blk_queue_update_dma_alignment(sdev->request_queue,
                                                ATA_DMA_PAD_SZ - 1);
-        } else
+
+                /* configure draining */
+                buf = kmalloc(ATAPI_MAX_DRAIN, q->bounce_gfp | GFP_KERNEL);
+                if (!buf) {
+                        ata_dev_printk(dev, KERN_ERR,
+                                       "drain buffer allocation failed\n");
+                        return -ENOMEM;
+                }
+
+                blk_queue_dma_drain(q, atapi_drain_needed, buf, ATAPI_MAX_DRAIN);
+        } else {
                 /* ATA devices must be sector aligned */
                 blk_queue_update_dma_alignment(sdev->request_queue,
                                                ATA_SECT_SIZE - 1);
-
-        if (dev->class == ATA_DEV_ATA)
                 sdev->manage_start_stop = 1;
+        }
 
         if (dev->flags & ATA_DFLAG_AN)
                 set_bit(SDEV_EVT_MEDIA_CHANGE, sdev->supported_events);
@@ -861,6 +892,8 @@ static void ata_scsi_dev_config(struct scsi_device *sdev,
                 depth = min(ATA_MAX_QUEUE - 1, depth);
                 scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG, depth);
         }
+
+        return 0;
 }
 
 /**
@@ -879,13 +912,14 @@ int ata_scsi_slave_config(struct scsi_device *sdev)
 {
         struct ata_port *ap = ata_shost_to_port(sdev->host);
         struct ata_device *dev = __ata_scsi_find_dev(ap, sdev);
+        int rc = 0;
 
         ata_scsi_sdev_config(sdev);
 
         if (dev)
-                ata_scsi_dev_config(sdev, dev);
+                rc = ata_scsi_dev_config(sdev, dev);
 
-        return 0;
+        return rc;
 }
 
 /**
@@ -905,6 +939,7 @@ int ata_scsi_slave_config(struct scsi_device *sdev)
 void ata_scsi_slave_destroy(struct scsi_device *sdev)
 {
         struct ata_port *ap = ata_shost_to_port(sdev->host);
+        struct request_queue *q = sdev->request_queue;
         unsigned long flags;
         struct ata_device *dev;
 
@@ -920,6 +955,10 @@ void ata_scsi_slave_destroy(struct scsi_device *sdev)
                 ata_port_schedule_eh(ap);
         }
         spin_unlock_irqrestore(ap->lock, flags);
+
+        kfree(q->dma_drain_buffer);
+        q->dma_drain_buffer = NULL;
+        q->dma_drain_size = 0;
 }
 
 /**
@@ -2500,7 +2539,7 @@ static unsigned int atapi_xlat(struct ata_queued_cmd *qc)
          * want to set it properly, and for DMA where it is
          * effectively meaningless.
          */
-        nbytes = min(qc->nbytes, (unsigned int)63 * 1024);
+        nbytes = min(scmd->request->raw_data_len, (unsigned int)63 * 1024);
 
         /* Most ATAPI devices which honor transfer chunk size don't
          * behave according to the spec when odd chunk size which
@@ -2543,7 +2582,8 @@ static unsigned int atapi_xlat(struct ata_queued_cmd *qc)
                 qc->tf.protocol = ATAPI_PROT_DMA;
                 qc->tf.feature |= ATAPI_PKT_DMA;
 
-                if (atapi_dmadir && (scmd->sc_data_direction != DMA_TO_DEVICE))
+                if ((dev->flags & ATA_DFLAG_DMADIR) &&
+                    (scmd->sc_data_direction != DMA_TO_DEVICE))
                         /* some SATA bridges need us to indicate data xfer direction */
                         qc->tf.feature |= ATAPI_DMADIR;
         }
@@ -3555,7 +3595,7 @@ EXPORT_SYMBOL_GPL(ata_sas_port_alloc);
  *      @ap: Port to initialize
  *
  *      Called just after data structures for each port are
- *      initialized.  Allocates DMA pad.
+ *      initialized.
  *
  *      May be used as the port_start() entry in ata_port_operations.
  *
@@ -3564,7 +3604,7 @@ EXPORT_SYMBOL_GPL(ata_sas_port_alloc);
  */
 int ata_sas_port_start(struct ata_port *ap)
 {
-        return ata_pad_alloc(ap, ap->dev);
+        return 0;
 }
 EXPORT_SYMBOL_GPL(ata_sas_port_start);
 
@@ -3572,8 +3612,6 @@ EXPORT_SYMBOL_GPL(ata_sas_port_start);
  *      ata_port_stop - Undo ata_sas_port_start()
  *      @ap: Port to shut down
  *
- *      Frees the DMA pad.
- *
  *      May be used as the port_stop() entry in ata_port_operations.
  *
  *      LOCKING:
@@ -3582,7 +3620,6 @@ EXPORT_SYMBOL_GPL(ata_sas_port_start);
 
 void ata_sas_port_stop(struct ata_port *ap)
 {
-        ata_pad_free(ap, ap->dev);
 }
 EXPORT_SYMBOL_GPL(ata_sas_port_stop);