libata: eliminate the home grown dma padding in favour of

that provided by the block layer

ATA requires that all DMA transfers begin and end on word boundaries.
Because of this, a large amount of machinery grew up in ide to adjust
scatterlists on this basis.  However, as of 2.5, the block layer has a
dma_alignment variable which ensures both the beginning and length of a
DMA transfer are aligned on the dma_alignment boundary.  Although the
block layer does adjust the beginning of the transfer to ensure this
happens, it doesn't actually adjust the length, it merely makes sure
that space is allocated for transfers beyond the declared length.  The
upshot of this is that scatterlists may be padded to any size between
the actual length and the length adjusted to the dma_alignment safely
knowing that memory is allocated in this region.

Right at the moment, SCSI takes the default dma_aligment which is on a
512 byte boundary.  Note that this aligment only applies to transfers
coming in from user space.  However, since all kernel allocations are
automatically aligned on a minimum of 32 byte boundaries, it is safe to
adjust them in this manner as well.

tj: * Adjusting sg after padding is done in block layer.  Make libata
      set queue alignment correctly for ATAPI devices and drop broken
      sg mangling from ata_sg_setup().
    * Use request->raw_data_len for ATAPI transfer chunk size.
    * Killed qc->raw_nbytes.
    * Separated out killing qc->n_iter.

Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jens Axboe <jens.axboe@oracle.com>

1 files changed, 9 insertions, 136 deletions

diff --git a/drivers/ata/libata-core.c b/drivers/ata/libata-core.c
index a109ccbda9ca..3587ac3fe3f3 100644
--- a/drivers/ata/libata-core.c
+++ b/drivers/ata/libata-core.c
@@ -4493,30 +4493,13 @@ void ata_sg_clean(struct ata_queued_cmd *qc)
         struct ata_port *ap = qc->ap;
         struct scatterlist *sg = qc->sg;
         int dir = qc->dma_dir;
-        void *pad_buf = NULL;
 
         WARN_ON(sg == NULL);
 
-        VPRINTK("unmapping %u sg elements\n", qc->mapped_n_elem);
+        VPRINTK("unmapping %u sg elements\n", qc->n_elem);
 
-        /* if we padded the buffer out to 32-bit bound, and data
-         * xfer direction is from-device, we must copy from the
-         * pad buffer back into the supplied buffer
-         */
-        if (qc->pad_len && !(qc->tf.flags & ATA_TFLAG_WRITE))
-                pad_buf = ap->pad + (qc->tag * ATA_DMA_PAD_SZ);
-
-        if (qc->mapped_n_elem)
-                dma_unmap_sg(ap->dev, sg, qc->mapped_n_elem, dir);
-        /* restore last sg */
-        if (qc->last_sg)
-                *qc->last_sg = qc->saved_last_sg;
-        if (pad_buf) {
-                struct scatterlist *psg = &qc->extra_sg[1];
-                void *addr = kmap_atomic(sg_page(psg), KM_IRQ0);
-                memcpy(addr + psg->offset, pad_buf, qc->pad_len);
-                kunmap_atomic(addr, KM_IRQ0);
-        }
+        if (qc->n_elem)
+                dma_unmap_sg(ap->dev, sg, qc->n_elem, dir);
 
         qc->flags &= ~ATA_QCFLAG_DMAMAP;
         qc->sg = NULL;
@@ -4767,97 +4750,6 @@ void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg,
         qc->cursg = qc->sg;
 }
 
-static unsigned int ata_sg_setup_extra(struct ata_queued_cmd *qc,
-                                       unsigned int *n_elem_extra,
-                                       unsigned int *nbytes_extra)
-{
-        struct ata_port *ap = qc->ap;
-        unsigned int n_elem = qc->n_elem;
-        struct scatterlist *lsg, *copy_lsg = NULL, *tsg = NULL, *esg = NULL;
-
-        *n_elem_extra = 0;
-        *nbytes_extra = 0;
-
-        /* needs padding? */
-        qc->pad_len = qc->nbytes & 3;
-
-        if (likely(!qc->pad_len))
-                return n_elem;
-
-        /* locate last sg and save it */
-        lsg = sg_last(qc->sg, n_elem);
-        qc->last_sg = lsg;
-        qc->saved_last_sg = *lsg;
-
-        sg_init_table(qc->extra_sg, ARRAY_SIZE(qc->extra_sg));
-
-        if (qc->pad_len) {
-                struct scatterlist *psg = &qc->extra_sg[1];
-                void *pad_buf = ap->pad + (qc->tag * ATA_DMA_PAD_SZ);
-                unsigned int offset;
-
-                WARN_ON(qc->dev->class != ATA_DEV_ATAPI);
-
-                memset(pad_buf, 0, ATA_DMA_PAD_SZ);
-
-                /* psg->page/offset are used to copy to-be-written
-                 * data in this function or read data in ata_sg_clean.
-                 */
-                offset = lsg->offset + lsg->length - qc->pad_len;
-                sg_set_page(psg, nth_page(sg_page(lsg), offset >> PAGE_SHIFT),
-                            qc->pad_len, offset_in_page(offset));
-
-                if (qc->tf.flags & ATA_TFLAG_WRITE) {
-                        void *addr = kmap_atomic(sg_page(psg), KM_IRQ0);
-                        memcpy(pad_buf, addr + psg->offset, qc->pad_len);
-                        kunmap_atomic(addr, KM_IRQ0);
-                }
-
-                sg_dma_address(psg) = ap->pad_dma + (qc->tag * ATA_DMA_PAD_SZ);
-                sg_dma_len(psg) = ATA_DMA_PAD_SZ;
-
-                /* Trim the last sg entry and chain the original and
-                 * padding sg lists.
-                 *
-                 * Because chaining consumes one sg entry, one extra
-                 * sg entry is allocated and the last sg entry is
-                 * copied to it if the length isn't zero after padded
-                 * amount is removed.
-                 *
-                 * If the last sg entry is completely replaced by
-                 * padding sg entry, the first sg entry is skipped
-                 * while chaining.
-                 */
-                lsg->length -= qc->pad_len;
-                if (lsg->length) {
-                        copy_lsg = &qc->extra_sg[0];
-                        tsg = &qc->extra_sg[0];
-                } else {
-                        n_elem--;
-                        tsg = &qc->extra_sg[1];
-                }
-
-                esg = &qc->extra_sg[1];
-
-                (*n_elem_extra)++;
-                (*nbytes_extra) += 4 - qc->pad_len;
-        }
-
-        if (copy_lsg)
-                sg_set_page(copy_lsg, sg_page(lsg), lsg->length, lsg->offset);
-
-        sg_chain(lsg, 1, tsg);
-        sg_mark_end(esg);
-
-        /* sglist can't start with chaining sg entry, fast forward */
-        if (qc->sg == lsg) {
-                qc->sg = tsg;
-                qc->cursg = tsg;
-        }
-
-        return n_elem;
-}
-
 /**
  *      ata_sg_setup - DMA-map the scatter-gather table associated with a command.
  *      @qc: Command with scatter-gather table to be mapped.
@@ -4874,26 +4766,17 @@ static unsigned int ata_sg_setup_extra(struct ata_queued_cmd *qc,
 static int ata_sg_setup(struct ata_queued_cmd *qc)
 {
         struct ata_port *ap = qc->ap;
-        unsigned int n_elem, n_elem_extra, nbytes_extra;
+        unsigned int n_elem;
 
         VPRINTK("ENTER, ata%u\n", ap->print_id);
 
-        n_elem = ata_sg_setup_extra(qc, &n_elem_extra, &nbytes_extra);
+        n_elem = dma_map_sg(ap->dev, qc->sg, qc->n_elem, qc->dma_dir);
+        if (n_elem < 1)
+                return -1;
 
-        if (n_elem) {
-                n_elem = dma_map_sg(ap->dev, qc->sg, n_elem, qc->dma_dir);
-                if (n_elem < 1) {
-                        /* restore last sg */
-                        if (qc->last_sg)
-                                *qc->last_sg = qc->saved_last_sg;
-                        return -1;
-                }
-                DPRINTK("%d sg elements mapped\n", n_elem);
-        }
+        DPRINTK("%d sg elements mapped\n", n_elem);
 
-        qc->n_elem = qc->mapped_n_elem = n_elem;
-        qc->n_elem += n_elem_extra;
-        qc->nbytes += nbytes_extra;
+        qc->n_elem = n_elem;
         qc->flags |= ATA_QCFLAG_DMAMAP;
 
         return 0;
@@ -5962,9 +5845,6 @@ void ata_qc_issue(struct ata_queued_cmd *qc)
          */
         BUG_ON(ata_is_data(prot) && (!qc->sg || !qc->n_elem || !qc->nbytes));
 
-        /* ata_sg_setup() may update nbytes */
-        qc->raw_nbytes = qc->nbytes;
-
         if (ata_is_dma(prot) || (ata_is_pio(prot) &&
                                  (ap->flags & ATA_FLAG_PIO_DMA)))
                 if (ata_sg_setup(qc))
@@ -6573,19 +6453,12 @@ void ata_host_resume(struct ata_host *host)
 int ata_port_start(struct ata_port *ap)
 {
         struct device *dev = ap->dev;
-        int rc;
 
         ap->prd = dmam_alloc_coherent(dev, ATA_PRD_TBL_SZ, &ap->prd_dma,
                                       GFP_KERNEL);
         if (!ap->prd)
                 return -ENOMEM;
 
-        rc = ata_pad_alloc(ap, dev);
-        if (rc)
-                return rc;
-
-        DPRINTK("prd alloc, virt %p, dma %llx\n", ap->prd,
-                (unsigned long long)ap->prd_dma);
         return 0;
 }