ata: remove deprecated use of pci api

Replace occurences of the pci api by appropriate call to the dma api.

A simplified version of the semantic patch that finds this problem is as
follows: (http://coccinelle.lip6.fr)

@deprecated@
idexpression id;
position p;
@@

(
  pci_dma_supported@p ( id, ...)
|
  pci_alloc_consistent@p ( id, ...)
)

@bad1@
idexpression id;
position deprecated.p;
@@
...when != &id->dev
   when != pci_get_drvdata ( id )
   when != pci_enable_device ( id )
(
  pci_dma_supported@p ( id, ...)
|
  pci_alloc_consistent@p ( id, ...)
)

@depends on !bad1@
idexpression id;
expression direction;
position deprecated.p;
@@

(
- pci_dma_supported@p ( id,
+ dma_supported ( &id->dev,
...
+ , GFP_ATOMIC
  )
|
- pci_alloc_consistent@p ( id,
+ dma_alloc_coherent ( &id->dev,
...
+ , GFP_ATOMIC
  )
)

Signed-off-by: Quentin Lambert <lambert.quentin@gmail.com>
Signed-off-by: Tejun Heo <tj@kernel.org>

diff --git a/drivers/ata/acard-ahci.c b/drivers/ata/acard-ahci.c
index c962886d7e7149fdde2c7ecda9ecf68ab04379ce..12489ce863c4bf06c06a38aa182124785346e365 100644 (file)
--- a/drivers/ata/acard-ahci.c
+++ b/drivers/ata/acard-ahci.c
@@ -181,10 +181,10 @@ static int acard_ahci_configure_dma_masks(struct pci_dev *pdev, int using_dac)
        int rc;
 
        if (using_dac &&
-           !pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) {
-               rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
+           !dma_set_mask(&pdev->dev, DMA_BIT_MASK(64))) {
+               rc = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(64));
                if (rc) {
-                       rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
+                       rc = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32));
                        if (rc) {
                                dev_err(&pdev->dev,
                                           "64-bit DMA enable failed\n");
@@ -192,12 +192,12 @@ static int acard_ahci_configure_dma_masks(struct pci_dev *pdev, int using_dac)
                        }
                }
        } else {
-               rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
+               rc = dma_set_mask(&pdev->dev, DMA_BIT_MASK(32));
                if (rc) {
                        dev_err(&pdev->dev, "32-bit DMA enable failed\n");
                        return rc;
                }
-               rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
+               rc = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32));
                if (rc) {
                        dev_err(&pdev->dev,
                                "32-bit consistent DMA enable failed\n");

diff --git a/drivers/ata/ahci.c b/drivers/ata/ahci.c
index 33bb06e006c9d6cbd9689b92a08df1481b12c568..c7a92a743ed035e9af81ac779180fc65456a8390 100644 (file)
--- a/drivers/ata/ahci.c
+++ b/drivers/ata/ahci.c
@@ -738,10 +738,10 @@ static int ahci_configure_dma_masks(struct pci_dev *pdev, int using_dac)
                return 0;
 
        if (using_dac &&
-           !pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) {
-               rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
+           !dma_set_mask(&pdev->dev, DMA_BIT_MASK(64))) {
+               rc = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(64));
                if (rc) {
-                       rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
+                       rc = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32));
                        if (rc) {
                                dev_err(&pdev->dev,
                                        "64-bit DMA enable failed\n");
@@ -749,12 +749,12 @@ static int ahci_configure_dma_masks(struct pci_dev *pdev, int using_dac)
                        }
                }
        } else {
-               rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
+               rc = dma_set_mask(&pdev->dev, DMA_BIT_MASK(32));
                if (rc) {
                        dev_err(&pdev->dev, "32-bit DMA enable failed\n");
                        return rc;
                }
-               rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
+               rc = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32));
                if (rc) {
                        dev_err(&pdev->dev,
                                "32-bit consistent DMA enable failed\n");

diff --git a/drivers/ata/libata-sff.c b/drivers/ata/libata-sff.c
index 2e86e3b852666e3b57e55aafde26ba1c13f8c695..cdf6215a9a22beb93ede75a702797e12c5ad4870 100644 (file)
--- a/drivers/ata/libata-sff.c
+++ b/drivers/ata/libata-sff.c
@@ -3220,11 +3220,11 @@ void ata_pci_bmdma_init(struct ata_host *host)
         * ->sff_irq_clear method.  Try to initialize bmdma_addr
         * regardless of dma masks.
         */
-       rc = pci_set_dma_mask(pdev, ATA_DMA_MASK);
+       rc = dma_set_mask(&pdev->dev, ATA_DMA_MASK);
        if (rc)
                ata_bmdma_nodma(host, "failed to set dma mask");
        if (!rc) {
-               rc = pci_set_consistent_dma_mask(pdev, ATA_DMA_MASK);
+               rc = dma_set_coherent_mask(&pdev->dev, ATA_DMA_MASK);
                if (rc)
                        ata_bmdma_nodma(host,
                                        "failed to set consistent dma mask");

diff --git a/drivers/ata/pata_atp867x.c b/drivers/ata/pata_atp867x.c
index a705cfca90f7210806f7d61e4897aaec738a0f8f..3ea50dc5ea47480d0cf81b5f69825b8675737070 100644 (file)
--- a/drivers/ata/pata_atp867x.c
+++ b/drivers/ata/pata_atp867x.c
@@ -475,11 +475,11 @@ static int atp867x_ata_pci_sff_init_host(struct ata_host *host)
 
        atp867x_fixup(host);
 
-       rc = pci_set_dma_mask(pdev, ATA_DMA_MASK);
+       rc = dma_set_mask(&pdev->dev, ATA_DMA_MASK);
        if (rc)
                return rc;
 
-       rc = pci_set_consistent_dma_mask(pdev, ATA_DMA_MASK);
+       rc = dma_set_coherent_mask(&pdev->dev, ATA_DMA_MASK);
        return rc;
 }
 

diff --git a/drivers/ata/pata_cs5520.c b/drivers/ata/pata_cs5520.c
index d65cb9d2fa8c1966dc8c33c1a535a580b7bea3d2..4cb24070cc2d23d6f51a40341db48ea236497b0c 100644 (file)
--- a/drivers/ata/pata_cs5520.c
+++ b/drivers/ata/pata_cs5520.c
@@ -164,11 +164,11 @@ static int cs5520_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
                return -ENODEV;
        }
 
-       if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) {
+       if (dma_set_mask(&pdev->dev, DMA_BIT_MASK(32))) {
                printk(KERN_ERR DRV_NAME ": unable to configure DMA mask.\n");
                return -ENODEV;
        }
-       if (pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32))) {
+       if (dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32))) {
                printk(KERN_ERR DRV_NAME ": unable to configure consistent DMA mask.\n");
                return -ENODEV;
        }

diff --git a/drivers/ata/pata_hpt3x3.c b/drivers/ata/pata_hpt3x3.c
index d019cdd5bc9f3deb0e1f6a70000c0fb9b7c89090..b2fc023783b15c3338160d3a0370a4e494b5db6f 100644 (file)
--- a/drivers/ata/pata_hpt3x3.c
+++ b/drivers/ata/pata_hpt3x3.c
@@ -221,10 +221,10 @@ static int hpt3x3_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
        if (rc)
                return rc;
        host->iomap = pcim_iomap_table(pdev);
-       rc = pci_set_dma_mask(pdev, ATA_DMA_MASK);
+       rc = dma_set_mask(&pdev->dev, ATA_DMA_MASK);
        if (rc)
                return rc;
-       rc = pci_set_consistent_dma_mask(pdev, ATA_DMA_MASK);
+       rc = dma_set_coherent_mask(&pdev->dev, ATA_DMA_MASK);
        if (rc)
                return rc;
 

diff --git a/drivers/ata/pata_ninja32.c b/drivers/ata/pata_ninja32.c
index efb272da8567e9c5c8b4605f5d38df6f25591a01..633aa2934a18f5c05f5e03cdaf5742a9b0735f99 100644 (file)
--- a/drivers/ata/pata_ninja32.c
+++ b/drivers/ata/pata_ninja32.c
@@ -122,10 +122,10 @@ static int ninja32_init_one(struct pci_dev *dev, const struct pci_device_id *id)
                return rc;
 
        host->iomap = pcim_iomap_table(dev);
-       rc = pci_set_dma_mask(dev, ATA_DMA_MASK);
+       rc = dma_set_mask(&dev->dev, ATA_DMA_MASK);
        if (rc)
                return rc;
-       rc = pci_set_consistent_dma_mask(dev, ATA_DMA_MASK);
+       rc = dma_set_coherent_mask(&dev->dev, ATA_DMA_MASK);
        if (rc)
                return rc;
        pci_set_master(dev);

diff --git a/drivers/ata/pata_pdc2027x.c b/drivers/ata/pata_pdc2027x.c
index dca8251b1aeaed1fd38769f9a8e118d3b4357da5..d9ef9e276225456b5b2c5825ab6ca79c7f192582 100644 (file)
--- a/drivers/ata/pata_pdc2027x.c
+++ b/drivers/ata/pata_pdc2027x.c
@@ -730,11 +730,11 @@ static int pdc2027x_init_one(struct pci_dev *pdev,
                return rc;
        host->iomap = pcim_iomap_table(pdev);
 
-       rc = pci_set_dma_mask(pdev, ATA_DMA_MASK);
+       rc = dma_set_mask(&pdev->dev, ATA_DMA_MASK);
        if (rc)
                return rc;
 
-       rc = pci_set_consistent_dma_mask(pdev, ATA_DMA_MASK);
+       rc = dma_set_coherent_mask(&pdev->dev, ATA_DMA_MASK);
        if (rc)
                return rc;
 

diff --git a/drivers/ata/pata_scc.c b/drivers/ata/pata_scc.c
index 7f4cb76ed9fac1c6ff51a5f91ad4df0468ac5096..5cd60d6388ec88b683e88688f2df0d71cfbfa119 100644 (file)
--- a/drivers/ata/pata_scc.c
+++ b/drivers/ata/pata_scc.c
@@ -1029,10 +1029,10 @@ static int scc_host_init(struct ata_host *host)
        if (rc)
                return rc;
 
-       rc = pci_set_dma_mask(pdev, ATA_DMA_MASK);
+       rc = dma_set_mask(&pdev->dev, ATA_DMA_MASK);
        if (rc)
                return rc;
-       rc = pci_set_consistent_dma_mask(pdev, ATA_DMA_MASK);
+       rc = dma_set_coherent_mask(&pdev->dev, ATA_DMA_MASK);
        if (rc)
                return rc;
 

diff --git a/drivers/ata/pata_sil680.c b/drivers/ata/pata_sil680.c
index f597edccedecd1ab952d95fd0dd178e4c1be8c4c..c14071be4f55f2f5222f5599b7570bba6de4d430 100644 (file)
--- a/drivers/ata/pata_sil680.c
+++ b/drivers/ata/pata_sil680.c
@@ -374,10 +374,10 @@ static int sil680_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
        host->iomap = pcim_iomap_table(pdev);
 
        /* Setup DMA masks */
-       rc = pci_set_dma_mask(pdev, ATA_DMA_MASK);
+       rc = dma_set_mask(&pdev->dev, ATA_DMA_MASK);
        if (rc)
                return rc;
-       rc = pci_set_consistent_dma_mask(pdev, ATA_DMA_MASK);
+       rc = dma_set_coherent_mask(&pdev->dev, ATA_DMA_MASK);
        if (rc)
                return rc;
        pci_set_master(pdev);

diff --git a/drivers/ata/pdc_adma.c b/drivers/ata/pdc_adma.c
index f10631beffa87cd258950bb4c85778ce166205e0..64d682c6ee57e2afb7dc475cc3a15d70ff75d9d5 100644 (file)
--- a/drivers/ata/pdc_adma.c
+++ b/drivers/ata/pdc_adma.c
@@ -593,12 +593,12 @@ static int adma_set_dma_masks(struct pci_dev *pdev, void __iomem *mmio_base)
 {
        int rc;
 
-       rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
+       rc = dma_set_mask(&pdev->dev, DMA_BIT_MASK(32));
        if (rc) {
                dev_err(&pdev->dev, "32-bit DMA enable failed\n");
                return rc;
        }
-       rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
+       rc = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32));
        if (rc) {
                dev_err(&pdev->dev, "32-bit consistent DMA enable failed\n");
                return rc;

diff --git a/drivers/ata/sata_inic162x.c b/drivers/ata/sata_inic162x.c
index 069827826b20ea9c0ec6a9d13e61dee850ccd524..e81a8217f1ff7be37ea2c3d61d6d1326f9f55a5e 100644 (file)
--- a/drivers/ata/sata_inic162x.c
+++ b/drivers/ata/sata_inic162x.c
@@ -856,13 +856,13 @@ static int inic_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
        }
 
        /* Set dma_mask.  This devices doesn't support 64bit addressing. */
-       rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
+       rc = dma_set_mask(&pdev->dev, DMA_BIT_MASK(32));
        if (rc) {
                dev_err(&pdev->dev, "32-bit DMA enable failed\n");
                return rc;
        }
 
-       rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
+       rc = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32));
        if (rc) {
                dev_err(&pdev->dev, "32-bit consistent DMA enable failed\n");
                return rc;

diff --git a/drivers/ata/sata_mv.c b/drivers/ata/sata_mv.c
index 0281785c7a284cb9c9f9603b975cdfd59add6398..bd74ee555278513118d057e832b3ec599923bb69 100644 (file)
--- a/drivers/ata/sata_mv.c
+++ b/drivers/ata/sata_mv.c
@@ -4320,10 +4320,10 @@ static int pci_go_64(struct pci_dev *pdev)
 {
        int rc;
 
-       if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) {
-               rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
+       if (!dma_set_mask(&pdev->dev, DMA_BIT_MASK(64))) {
+               rc = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(64));
                if (rc) {
-                       rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
+                       rc = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32));
                        if (rc) {
                                dev_err(&pdev->dev,
                                        "64-bit DMA enable failed\n");
@@ -4331,12 +4331,12 @@ static int pci_go_64(struct pci_dev *pdev)
                        }
                }
        } else {
-               rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
+               rc = dma_set_mask(&pdev->dev, DMA_BIT_MASK(32));
                if (rc) {
                        dev_err(&pdev->dev, "32-bit DMA enable failed\n");
                        return rc;
                }
-               rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
+               rc = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32));
                if (rc) {
                        dev_err(&pdev->dev,
                                "32-bit consistent DMA enable failed\n");

diff --git a/drivers/ata/sata_nv.c b/drivers/ata/sata_nv.c
index 1db6f5ce5e8912b149f33b49f8876ebc608fc8e8..7ece85f43020967a9f9b3b5657bf7ce50ae22c9f 100644 (file)
--- a/drivers/ata/sata_nv.c
+++ b/drivers/ata/sata_nv.c
@@ -756,10 +756,10 @@ static int nv_adma_slave_config(struct scsi_device *sdev)
                        blk_queue_bounce_limit(sdev1->request_queue,
                                               ATA_DMA_MASK);
 
-               pci_set_dma_mask(pdev, ATA_DMA_MASK);
+               dma_set_mask(&pdev->dev, ATA_DMA_MASK);
        } else {
                /** This shouldn't fail as it was set to this value before */
-               pci_set_dma_mask(pdev, pp->adma_dma_mask);
+               dma_set_mask(&pdev->dev, pp->adma_dma_mask);
                if (sdev0)
                        blk_queue_bounce_limit(sdev0->request_queue,
                                               pp->adma_dma_mask);
@@ -1133,10 +1133,10 @@ static int nv_adma_port_start(struct ata_port *ap)
 
        /* Ensure DMA mask is set to 32-bit before allocating legacy PRD and
           pad buffers */
-       rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
+       rc = dma_set_mask(&pdev->dev, DMA_BIT_MASK(32));
        if (rc)
                return rc;
-       rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
+       rc = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32));
        if (rc)
                return rc;
 
@@ -1161,8 +1161,8 @@ static int nv_adma_port_start(struct ata_port *ap)
           These are allowed to fail since we store the value that ends up
           being used to set as the bounce limit in slave_config later if
           needed. */
-       pci_set_dma_mask(pdev, DMA_BIT_MASK(64));
-       pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
+       dma_set_mask(&pdev->dev, DMA_BIT_MASK(64));
+       dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(64));
        pp->adma_dma_mask = *dev->dma_mask;
 
        mem = dmam_alloc_coherent(dev, NV_ADMA_PORT_PRIV_DMA_SZ,

diff --git a/drivers/ata/sata_promise.c b/drivers/ata/sata_promise.c
index 3638887476f610a933d57b29cae7f84c4d6f229f..0fa211e2831cda6381320ae4f208273a1502c66b 100644 (file)
--- a/drivers/ata/sata_promise.c
+++ b/drivers/ata/sata_promise.c
@@ -1246,10 +1246,10 @@ static int pdc_ata_init_one(struct pci_dev *pdev,
        /* initialize adapter */
        pdc_host_init(host);
 
-       rc = pci_set_dma_mask(pdev, ATA_DMA_MASK);
+       rc = dma_set_mask(&pdev->dev, ATA_DMA_MASK);
        if (rc)
                return rc;
-       rc = pci_set_consistent_dma_mask(pdev, ATA_DMA_MASK);
+       rc = dma_set_coherent_mask(&pdev->dev, ATA_DMA_MASK);
        if (rc)
                return rc;
 

diff --git a/drivers/ata/sata_qstor.c b/drivers/ata/sata_qstor.c
index 9a6bd4cd29a0661cefd71f686e7c4bbc778911ed..af987a4f33d1904b70f5dc226f0c8c154d6b83ff 100644 (file)
--- a/drivers/ata/sata_qstor.c
+++ b/drivers/ata/sata_qstor.c
@@ -557,10 +557,10 @@ static int qs_set_dma_masks(struct pci_dev *pdev, void __iomem *mmio_base)
        int rc, have_64bit_bus = (bus_info & QS_HPHY_64BIT);
 
        if (have_64bit_bus &&
-           !pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) {
-               rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
+           !dma_set_mask(&pdev->dev, DMA_BIT_MASK(64))) {
+               rc = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(64));
                if (rc) {
-                       rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
+                       rc = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32));
                        if (rc) {
                                dev_err(&pdev->dev,
                                        "64-bit DMA enable failed\n");
@@ -568,12 +568,12 @@ static int qs_set_dma_masks(struct pci_dev *pdev, void __iomem *mmio_base)
                        }
                }
        } else {
-               rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
+               rc = dma_set_mask(&pdev->dev, DMA_BIT_MASK(32));
                if (rc) {
                        dev_err(&pdev->dev, "32-bit DMA enable failed\n");
                        return rc;
                }
-               rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
+               rc = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32));
                if (rc) {
                        dev_err(&pdev->dev,
                                "32-bit consistent DMA enable failed\n");

diff --git a/drivers/ata/sata_sil.c b/drivers/ata/sata_sil.c
index 40b76b2d18c6968af8e977e6c8f94b080a65649e..dea6edcbf145c3d1eaf45d8265ae7f971d6c808c 100644 (file)
--- a/drivers/ata/sata_sil.c
+++ b/drivers/ata/sata_sil.c
@@ -770,10 +770,10 @@ static int sil_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
                return rc;
        host->iomap = pcim_iomap_table(pdev);
 
-       rc = pci_set_dma_mask(pdev, ATA_DMA_MASK);
+       rc = dma_set_mask(&pdev->dev, ATA_DMA_MASK);
        if (rc)
                return rc;
-       rc = pci_set_consistent_dma_mask(pdev, ATA_DMA_MASK);
+       rc = dma_set_coherent_mask(&pdev->dev, ATA_DMA_MASK);
        if (rc)
                return rc;
 

diff --git a/drivers/ata/sata_sil24.c b/drivers/ata/sata_sil24.c
index 52428971ba9468e98da6db30b5b60f2ca6f74fde..4b1995e2d044ba7e4da5f6e36ec0c2d2dedafd50 100644 (file)
--- a/drivers/ata/sata_sil24.c
+++ b/drivers/ata/sata_sil24.c
@@ -1312,10 +1312,10 @@ static int sil24_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
        host->iomap = iomap;
 
        /* configure and activate the device */
-       if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) {
-               rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
+       if (!dma_set_mask(&pdev->dev, DMA_BIT_MASK(64))) {
+               rc = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(64));
                if (rc) {
-                       rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
+                       rc = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32));
                        if (rc) {
                                dev_err(&pdev->dev,
                                        "64-bit DMA enable failed\n");
@@ -1323,12 +1323,12 @@ static int sil24_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
                        }
                }
        } else {
-               rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
+               rc = dma_set_mask(&pdev->dev, DMA_BIT_MASK(32));
                if (rc) {
                        dev_err(&pdev->dev, "32-bit DMA enable failed\n");
                        return rc;
                }
-               rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
+               rc = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32));
                if (rc) {
                        dev_err(&pdev->dev,
                                "32-bit consistent DMA enable failed\n");

diff --git a/drivers/ata/sata_svw.c b/drivers/ata/sata_svw.c
index c630fa81262439939c3ad770f3538e48c0862522..ff8307b30ff0ebc12b681e8e72aef711d8aaea1f 100644 (file)
--- a/drivers/ata/sata_svw.c
+++ b/drivers/ata/sata_svw.c
@@ -496,10 +496,10 @@ static int k2_sata_init_one(struct pci_dev *pdev, const struct pci_device_id *en
                ata_port_pbar_desc(ap, 5, offset, "port");
        }
 
-       rc = pci_set_dma_mask(pdev, ATA_DMA_MASK);
+       rc = dma_set_mask(&pdev->dev, ATA_DMA_MASK);
        if (rc)
                return rc;
-       rc = pci_set_consistent_dma_mask(pdev, ATA_DMA_MASK);
+       rc = dma_set_coherent_mask(&pdev->dev, ATA_DMA_MASK);
        if (rc)
                return rc;
 

diff --git a/drivers/ata/sata_sx4.c b/drivers/ata/sata_sx4.c
index 39b5de60a1f96a93a80193b5a7ce8ec6e0ecea43..3a18a8a719b4ff1fa562a515b4701da241e4aeb7 100644 (file)
--- a/drivers/ata/sata_sx4.c
+++ b/drivers/ata/sata_sx4.c
@@ -1476,10 +1476,10 @@ static int pdc_sata_init_one(struct pci_dev *pdev,
        }
 
        /* configure and activate */
-       rc = pci_set_dma_mask(pdev, ATA_DMA_MASK);
+       rc = dma_set_mask(&pdev->dev, ATA_DMA_MASK);
        if (rc)
                return rc;
-       rc = pci_set_consistent_dma_mask(pdev, ATA_DMA_MASK);
+       rc = dma_set_coherent_mask(&pdev->dev, ATA_DMA_MASK);
        if (rc)
                return rc;
 

diff --git a/drivers/ata/sata_via.c b/drivers/ata/sata_via.c
index 47bf89464cef80d57e490187d37b23d4656ca299..17d31fc009abbcf14e0ea3f14ad9c06be8ac5b35 100644 (file)
--- a/drivers/ata/sata_via.c
+++ b/drivers/ata/sata_via.c
@@ -502,10 +502,10 @@ static int vt6421_prepare_host(struct pci_dev *pdev, struct ata_host **r_host)
        for (i = 0; i < host->n_ports; i++)
                vt6421_init_addrs(host->ports[i]);
 
-       rc = pci_set_dma_mask(pdev, ATA_DMA_MASK);
+       rc = dma_set_mask(&pdev->dev, ATA_DMA_MASK);
        if (rc)
                return rc;
-       rc = pci_set_consistent_dma_mask(pdev, ATA_DMA_MASK);
+       rc = dma_set_coherent_mask(&pdev->dev, ATA_DMA_MASK);
        if (rc)
                return rc;
 

diff --git a/drivers/ata/sata_vsc.c b/drivers/ata/sata_vsc.c
index 29e847aac34be5ea88871ff03c99856b20c4492e..183eb52085df148a8795a8328452c5c5cd6a8532 100644 (file)
--- a/drivers/ata/sata_vsc.c
+++ b/drivers/ata/sata_vsc.c
@@ -387,10 +387,10 @@ static int vsc_sata_init_one(struct pci_dev *pdev,
        /*
         * Use 32 bit DMA mask, because 64 bit address support is poor.
         */
-       rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
+       rc = dma_set_mask(&pdev->dev, DMA_BIT_MASK(32));
        if (rc)
                return rc;
-       rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
+       rc = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32));
        if (rc)
                return rc;