libata-sff: ata_sff_[dumb_]qc_prep are BMDMA specific

Both qc_prep functions deal only with BMDMA PRD setup and PIO only SFF
drivers don't need them.  Rename to ata_bmdma_[dumb_]qc_prep() and
relocate.

All usages are renamed except for pdc_adma and sata_qstor.  Those two
drivers are not BMDMA drivers and don't need to call BMDMA qc_prep
functions.  Calls to ata_sff_qc_prep() in the two drivers are removed.

Signed-off-by: Tejun Heo <tj@kernel.org>
Signed-off-by: Jeff Garzik <jgarzik@redhat.com>

8 files changed, 154 insertions, 156 deletions

diff --git a/drivers/ata/libata-sff.c b/drivers/ata/libata-sff.c
index aa378c04ed87..a58693bdde9d 100644
--- a/drivers/ata/libata-sff.c
+++ b/drivers/ata/libata-sff.c
@@ -45,7 +45,7 @@ static struct workqueue_struct *ata_sff_wq;
 const struct ata_port_operations ata_sff_port_ops = {
         .inherits               = &ata_base_port_ops,
 
-        .qc_prep                = ata_sff_qc_prep,
+        .qc_prep                = ata_noop_qc_prep,
         .qc_issue               = ata_sff_qc_issue,
         .qc_fill_rtf            = ata_sff_qc_fill_rtf,
 
@@ -71,149 +71,6 @@ const struct ata_port_operations ata_sff_port_ops = {
 EXPORT_SYMBOL_GPL(ata_sff_port_ops);
 
 /**
- *      ata_fill_sg - Fill PCI IDE PRD table
- *      @qc: Metadata associated with taskfile to be transferred
- *
- *      Fill PCI IDE PRD (scatter-gather) table with segments
- *      associated with the current disk command.
- *
- *      LOCKING:
- *      spin_lock_irqsave(host lock)
- *
- */
-static void ata_fill_sg(struct ata_queued_cmd *qc)
-{
-        struct ata_port *ap = qc->ap;
-        struct scatterlist *sg;
-        unsigned int si, pi;
-
-        pi = 0;
-        for_each_sg(qc->sg, sg, qc->n_elem, si) {
-                u32 addr, offset;
-                u32 sg_len, len;
-
-                /* determine if physical DMA addr spans 64K boundary.
-                 * Note h/w doesn't support 64-bit, so we unconditionally
-                 * truncate dma_addr_t to u32.
-                 */
-                addr = (u32) sg_dma_address(sg);
-                sg_len = sg_dma_len(sg);
-
-                while (sg_len) {
-                        offset = addr & 0xffff;
-                        len = sg_len;
-                        if ((offset + sg_len) > 0x10000)
-                                len = 0x10000 - offset;
-
-                        ap->prd[pi].addr = cpu_to_le32(addr);
-                        ap->prd[pi].flags_len = cpu_to_le32(len & 0xffff);
-                        VPRINTK("PRD[%u] = (0x%X, 0x%X)\n", pi, addr, len);
-
-                        pi++;
-                        sg_len -= len;
-                        addr += len;
-                }
-        }
-
-        ap->prd[pi - 1].flags_len |= cpu_to_le32(ATA_PRD_EOT);
-}
-
-/**
- *      ata_fill_sg_dumb - Fill PCI IDE PRD table
- *      @qc: Metadata associated with taskfile to be transferred
- *
- *      Fill PCI IDE PRD (scatter-gather) table with segments
- *      associated with the current disk command. Perform the fill
- *      so that we avoid writing any length 64K records for
- *      controllers that don't follow the spec.
- *
- *      LOCKING:
- *      spin_lock_irqsave(host lock)
- *
- */
-static void ata_fill_sg_dumb(struct ata_queued_cmd *qc)
-{
-        struct ata_port *ap = qc->ap;
-        struct scatterlist *sg;
-        unsigned int si, pi;
-
-        pi = 0;
-        for_each_sg(qc->sg, sg, qc->n_elem, si) {
-                u32 addr, offset;
-                u32 sg_len, len, blen;
-
-                /* determine if physical DMA addr spans 64K boundary.
-                 * Note h/w doesn't support 64-bit, so we unconditionally
-                 * truncate dma_addr_t to u32.
-                 */
-                addr = (u32) sg_dma_address(sg);
-                sg_len = sg_dma_len(sg);
-
-                while (sg_len) {
-                        offset = addr & 0xffff;
-                        len = sg_len;
-                        if ((offset + sg_len) > 0x10000)
-                                len = 0x10000 - offset;
-
-                        blen = len & 0xffff;
-                        ap->prd[pi].addr = cpu_to_le32(addr);
-                        if (blen == 0) {
-                                /* Some PATA chipsets like the CS5530 can't
-                                   cope with 0x0000 meaning 64K as the spec
-                                   says */
-                                ap->prd[pi].flags_len = cpu_to_le32(0x8000);
-                                blen = 0x8000;
-                                ap->prd[++pi].addr = cpu_to_le32(addr + 0x8000);
-                        }
-                        ap->prd[pi].flags_len = cpu_to_le32(blen);
-                        VPRINTK("PRD[%u] = (0x%X, 0x%X)\n", pi, addr, len);
-
-                        pi++;
-                        sg_len -= len;
-                        addr += len;
-                }
-        }
-
-        ap->prd[pi - 1].flags_len |= cpu_to_le32(ATA_PRD_EOT);
-}
-
-/**
- *      ata_sff_qc_prep - Prepare taskfile for submission
- *      @qc: Metadata associated with taskfile to be prepared
- *
- *      Prepare ATA taskfile for submission.
- *
- *      LOCKING:
- *      spin_lock_irqsave(host lock)
- */
-void ata_sff_qc_prep(struct ata_queued_cmd *qc)
-{
-        if (!(qc->flags & ATA_QCFLAG_DMAMAP))
-                return;
-
-        ata_fill_sg(qc);
-}
-EXPORT_SYMBOL_GPL(ata_sff_qc_prep);
-
-/**
- *      ata_sff_dumb_qc_prep - Prepare taskfile for submission
- *      @qc: Metadata associated with taskfile to be prepared
- *
- *      Prepare ATA taskfile for submission.
- *
- *      LOCKING:
- *      spin_lock_irqsave(host lock)
- */
-void ata_sff_dumb_qc_prep(struct ata_queued_cmd *qc)
-{
-        if (!(qc->flags & ATA_QCFLAG_DMAMAP))
-                return;
-
-        ata_fill_sg_dumb(qc);
-}
-EXPORT_SYMBOL_GPL(ata_sff_dumb_qc_prep);
-
-/**
  *      ata_sff_check_status - Read device status reg & clear interrupt
  *      @ap: port where the device is
  *
@@ -2760,6 +2617,8 @@ const struct ata_port_operations ata_bmdma_port_ops = {
         .error_handler          = ata_bmdma_error_handler,
         .post_internal_cmd      = ata_bmdma_post_internal_cmd,
 
+        .qc_prep                = ata_bmdma_qc_prep,
+
         .bmdma_setup            = ata_bmdma_setup,
         .bmdma_start            = ata_bmdma_start,
         .bmdma_stop             = ata_bmdma_stop,
@@ -2778,6 +2637,149 @@ const struct ata_port_operations ata_bmdma32_port_ops = {
 EXPORT_SYMBOL_GPL(ata_bmdma32_port_ops);
 
 /**
+ *      ata_bmdma_fill_sg - Fill PCI IDE PRD table
+ *      @qc: Metadata associated with taskfile to be transferred
+ *
+ *      Fill PCI IDE PRD (scatter-gather) table with segments
+ *      associated with the current disk command.
+ *
+ *      LOCKING:
+ *      spin_lock_irqsave(host lock)
+ *
+ */
+static void ata_bmdma_fill_sg(struct ata_queued_cmd *qc)
+{
+        struct ata_port *ap = qc->ap;
+        struct scatterlist *sg;
+        unsigned int si, pi;
+
+        pi = 0;
+        for_each_sg(qc->sg, sg, qc->n_elem, si) {
+                u32 addr, offset;
+                u32 sg_len, len;
+
+                /* determine if physical DMA addr spans 64K boundary.
+                 * Note h/w doesn't support 64-bit, so we unconditionally
+                 * truncate dma_addr_t to u32.
+                 */
+                addr = (u32) sg_dma_address(sg);
+                sg_len = sg_dma_len(sg);
+
+                while (sg_len) {
+                        offset = addr & 0xffff;
+                        len = sg_len;
+                        if ((offset + sg_len) > 0x10000)
+                                len = 0x10000 - offset;
+
+                        ap->prd[pi].addr = cpu_to_le32(addr);
+                        ap->prd[pi].flags_len = cpu_to_le32(len & 0xffff);
+                        VPRINTK("PRD[%u] = (0x%X, 0x%X)\n", pi, addr, len);
+
+                        pi++;
+                        sg_len -= len;
+                        addr += len;
+                }
+        }
+
+        ap->prd[pi - 1].flags_len |= cpu_to_le32(ATA_PRD_EOT);
+}
+
+/**
+ *      ata_bmdma_fill_sg_dumb - Fill PCI IDE PRD table
+ *      @qc: Metadata associated with taskfile to be transferred
+ *
+ *      Fill PCI IDE PRD (scatter-gather) table with segments
+ *      associated with the current disk command. Perform the fill
+ *      so that we avoid writing any length 64K records for
+ *      controllers that don't follow the spec.
+ *
+ *      LOCKING:
+ *      spin_lock_irqsave(host lock)
+ *
+ */
+static void ata_bmdma_fill_sg_dumb(struct ata_queued_cmd *qc)
+{
+        struct ata_port *ap = qc->ap;
+        struct scatterlist *sg;
+        unsigned int si, pi;
+
+        pi = 0;
+        for_each_sg(qc->sg, sg, qc->n_elem, si) {
+                u32 addr, offset;
+                u32 sg_len, len, blen;
+
+                /* determine if physical DMA addr spans 64K boundary.
+                 * Note h/w doesn't support 64-bit, so we unconditionally
+                 * truncate dma_addr_t to u32.
+                 */
+                addr = (u32) sg_dma_address(sg);
+                sg_len = sg_dma_len(sg);
+
+                while (sg_len) {
+                        offset = addr & 0xffff;
+                        len = sg_len;
+                        if ((offset + sg_len) > 0x10000)
+                                len = 0x10000 - offset;
+
+                        blen = len & 0xffff;
+                        ap->prd[pi].addr = cpu_to_le32(addr);
+                        if (blen == 0) {
+                                /* Some PATA chipsets like the CS5530 can't
+                                   cope with 0x0000 meaning 64K as the spec
+                                   says */
+                                ap->prd[pi].flags_len = cpu_to_le32(0x8000);
+                                blen = 0x8000;
+                                ap->prd[++pi].addr = cpu_to_le32(addr + 0x8000);
+                        }
+                        ap->prd[pi].flags_len = cpu_to_le32(blen);
+                        VPRINTK("PRD[%u] = (0x%X, 0x%X)\n", pi, addr, len);
+
+                        pi++;
+                        sg_len -= len;
+                        addr += len;
+                }
+        }
+
+        ap->prd[pi - 1].flags_len |= cpu_to_le32(ATA_PRD_EOT);
+}
+
+/**
+ *      ata_bmdma_qc_prep - Prepare taskfile for submission
+ *      @qc: Metadata associated with taskfile to be prepared
+ *
+ *      Prepare ATA taskfile for submission.
+ *
+ *      LOCKING:
+ *      spin_lock_irqsave(host lock)
+ */
+void ata_bmdma_qc_prep(struct ata_queued_cmd *qc)
+{
+        if (!(qc->flags & ATA_QCFLAG_DMAMAP))
+                return;
+
+        ata_bmdma_fill_sg(qc);
+}
+EXPORT_SYMBOL_GPL(ata_bmdma_qc_prep);
+
+/**
+ *      ata_bmdma_dumb_qc_prep - Prepare taskfile for submission
+ *      @qc: Metadata associated with taskfile to be prepared
+ *
+ *      Prepare ATA taskfile for submission.
+ *
+ *      LOCKING:
+ *      spin_lock_irqsave(host lock)
+ */
+void ata_bmdma_dumb_qc_prep(struct ata_queued_cmd *qc)
+{
+        if (!(qc->flags & ATA_QCFLAG_DMAMAP))
+                return;
+
+        ata_bmdma_fill_sg_dumb(qc);
+}
+EXPORT_SYMBOL_GPL(ata_bmdma_dumb_qc_prep);
+
+/**
  *      ata_bmdma_error_handler - Stock error handler for BMDMA controller
  *      @ap: port to handle error for
  *
diff --git a/drivers/ata/pata_atiixp.c b/drivers/ata/pata_atiixp.c
index cbaf2eddac6b..44d88b380ddd 100644
--- a/drivers/ata/pata_atiixp.c
+++ b/drivers/ata/pata_atiixp.c
@@ -217,7 +217,7 @@ static struct scsi_host_template atiixp_sht = {
 static struct ata_port_operations atiixp_port_ops = {
         .inherits       = &ata_bmdma_port_ops,
 
-        .qc_prep        = ata_sff_dumb_qc_prep,
+        .qc_prep        = ata_bmdma_dumb_qc_prep,
         .bmdma_start    = atiixp_bmdma_start,
         .bmdma_stop     = atiixp_bmdma_stop,
 
diff --git a/drivers/ata/pata_cs5520.c b/drivers/ata/pata_cs5520.c
index 95ebdac517f2..17c5f346ff01 100644
--- a/drivers/ata/pata_cs5520.c
+++ b/drivers/ata/pata_cs5520.c
@@ -110,7 +110,7 @@ static struct scsi_host_template cs5520_sht = {
 
 static struct ata_port_operations cs5520_port_ops = {
         .inherits               = &ata_bmdma_port_ops,
-        .qc_prep                = ata_sff_dumb_qc_prep,
+        .qc_prep                = ata_bmdma_dumb_qc_prep,
         .cable_detect           = ata_cable_40wire,
         .set_piomode            = cs5520_set_piomode,
 };
diff --git a/drivers/ata/pata_cs5530.c b/drivers/ata/pata_cs5530.c
index 738ad2e14a97..4b9a66f18de6 100644
--- a/drivers/ata/pata_cs5530.c
+++ b/drivers/ata/pata_cs5530.c
@@ -167,7 +167,7 @@ static struct scsi_host_template cs5530_sht = {
 static struct ata_port_operations cs5530_port_ops = {
         .inherits       = &ata_bmdma_port_ops,
 
-        .qc_prep        = ata_sff_dumb_qc_prep,
+        .qc_prep        = ata_bmdma_dumb_qc_prep,
         .qc_issue       = cs5530_qc_issue,
 
         .cable_detect   = ata_cable_40wire,
diff --git a/drivers/ata/pata_sc1200.c b/drivers/ata/pata_sc1200.c
index dfecc6f964b0..599e648a722f 100644
--- a/drivers/ata/pata_sc1200.c
+++ b/drivers/ata/pata_sc1200.c
@@ -209,7 +209,7 @@ static struct scsi_host_template sc1200_sht = {
 
 static struct ata_port_operations sc1200_port_ops = {
         .inherits       = &ata_bmdma_port_ops,
-        .qc_prep        = ata_sff_dumb_qc_prep,
+        .qc_prep        = ata_bmdma_dumb_qc_prep,
         .qc_issue       = sc1200_qc_issue,
         .qc_defer       = sc1200_qc_defer,
         .cable_detect   = ata_cable_40wire,
diff --git a/drivers/ata/pdc_adma.c b/drivers/ata/pdc_adma.c
index bb4f838655b6..adbe0426c8f0 100644
--- a/drivers/ata/pdc_adma.c
+++ b/drivers/ata/pdc_adma.c
@@ -324,10 +324,8 @@ static void adma_qc_prep(struct ata_queued_cmd *qc)
         VPRINTK("ENTER\n");
 
         adma_enter_reg_mode(qc->ap);
-        if (qc->tf.protocol != ATA_PROT_DMA) {
-                ata_sff_qc_prep(qc);
+        if (qc->tf.protocol != ATA_PROT_DMA)
                 return;
-        }
 
         buf[i++] = 0;   /* Response flags */
         buf[i++] = 0;   /* reserved */
diff --git a/drivers/ata/sata_nv.c b/drivers/ata/sata_nv.c
index 64e99824d8c1..7a283d5d68f3 100644
--- a/drivers/ata/sata_nv.c
+++ b/drivers/ata/sata_nv.c
@@ -1409,7 +1409,7 @@ static void nv_adma_qc_prep(struct ata_queued_cmd *qc)
                 BUG_ON(!(pp->flags & NV_ADMA_ATAPI_SETUP_COMPLETE) &&
                         (qc->flags & ATA_QCFLAG_DMAMAP));
                 nv_adma_register_mode(qc->ap);
-                ata_sff_qc_prep(qc);
+                ata_bmdma_qc_prep(qc);
                 return;
         }
 
@@ -2012,7 +2012,7 @@ static int nv_swncq_port_start(struct ata_port *ap)
 static void nv_swncq_qc_prep(struct ata_queued_cmd *qc)
 {
         if (qc->tf.protocol != ATA_PROT_NCQ) {
-                ata_sff_qc_prep(qc);
+                ata_bmdma_qc_prep(qc);
                 return;
         }
 
diff --git a/drivers/ata/sata_qstor.c b/drivers/ata/sata_qstor.c
index d3a22f2ae7b6..d533b3d20ca1 100644
--- a/drivers/ata/sata_qstor.c
+++ b/drivers/ata/sata_qstor.c
@@ -303,10 +303,8 @@ static void qs_qc_prep(struct ata_queued_cmd *qc)
         VPRINTK("ENTER\n");
 
         qs_enter_reg_mode(qc->ap);
-        if (qc->tf.protocol != ATA_PROT_DMA) {
-                ata_sff_qc_prep(qc);
+        if (qc->tf.protocol != ATA_PROT_DMA)
                 return;
-        }
 
         nelem = qs_fill_sg(qc);