Replace all DMA_nBIT_MASK macro with DMA_BIT_MASK(n)

This is the second go through of the old DMA_nBIT_MASK macro,and there're not
so many of them left,so I put them into one patch.I hope this is the last round.
After this the definition of the old DMA_nBIT_MASK macro could be removed.

Signed-off-by: Yang Hongyang <yanghy@cn.fujitsu.com>
Cc: Russell King <rmk@arm.linux.org.uk>
Cc: Tony Lindgren <tony@atomide.com>
Cc: "David S. Miller" <davem@davemloft.net>
Cc: James Bottomley <James.Bottomley@HansenPartnership.com>
Cc: Greg KH <greg@kroah.com>
Cc: Takashi Iwai <tiwai@suse.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

diff --git a/arch/arm/mach-omap2/usb-musb.c b/arch/arm/mach-omap2/usb-musb.c
index fc74e913c415523dcf3965468b6b374b98c9654f..34a56a136efd3deaa8feabe139f5f0b689b553c8 100644 (file)
--- a/arch/arm/mach-omap2/usb-musb.c
+++ b/arch/arm/mach-omap2/usb-musb.c
@@ -131,14 +131,14 @@ static struct musb_hdrc_platform_data musb_plat = {
        .power          = 50,                   /* up to 100 mA */
 };
 
-static u64 musb_dmamask = DMA_32BIT_MASK;
+static u64 musb_dmamask = DMA_BIT_MASK(32);
 
 static struct platform_device musb_device = {
        .name           = "musb_hdrc",
        .id             = -1,
        .dev = {
                .dma_mask               = &musb_dmamask,
-               .coherent_dma_mask      = DMA_32BIT_MASK,
+               .coherent_dma_mask      = DMA_BIT_MASK(32),
                .platform_data          = &musb_plat,
        },
        .num_resources  = ARRAY_SIZE(musb_resources),
@@ -146,14 +146,14 @@ static struct platform_device musb_device = {
 };
 
 #ifdef CONFIG_NOP_USB_XCEIV
-static u64 nop_xceiv_dmamask = DMA_32BIT_MASK;
+static u64 nop_xceiv_dmamask = DMA_BIT_MASK(32);
 
 static struct platform_device nop_xceiv_device = {
        .name           = "nop_usb_xceiv",
        .id             = -1,
        .dev = {
                .dma_mask               = &nop_xceiv_dmamask,
-               .coherent_dma_mask      = DMA_32BIT_MASK,
+               .coherent_dma_mask      = DMA_BIT_MASK(32),
                .platform_data          = NULL,
        },
 };

diff --git a/arch/ia64/kernel/pci-swiotlb.c b/arch/ia64/kernel/pci-swiotlb.c
index 573f02c39a00295adb4edbbb1a2666e9e1e33da7..285aae8431c6278d08c6ff862a18fdf66b2e52bf 100644 (file)
--- a/arch/ia64/kernel/pci-swiotlb.c
+++ b/arch/ia64/kernel/pci-swiotlb.c
@@ -16,7 +16,7 @@ EXPORT_SYMBOL(swiotlb);
 static void *ia64_swiotlb_alloc_coherent(struct device *dev, size_t size,
                                         dma_addr_t *dma_handle, gfp_t gfp)
 {
-       if (dev->coherent_dma_mask != DMA_64BIT_MASK)
+       if (dev->coherent_dma_mask != DMA_BIT_MASK(64))
                gfp |= GFP_DMA;
        return swiotlb_alloc_coherent(dev, size, dma_handle, gfp);
 }

diff --git a/drivers/atm/solos-pci.c b/drivers/atm/solos-pci.c
index be204308cc1b1d6a222c85aa6d5fcde6063009f3..9359613addc5a7290e8190d0417e6cda7d8cebe9 100644 (file)
--- a/drivers/atm/solos-pci.c
+++ b/drivers/atm/solos-pci.c
@@ -1059,7 +1059,7 @@ static int fpga_probe(struct pci_dev *dev, const struct pci_device_id *id)
                goto out;
        }
 
-       err = pci_set_dma_mask(dev, DMA_32BIT_MASK);
+       err = pci_set_dma_mask(dev, DMA_BIT_MASK(32));
        if (err) {
                dev_warn(&dev->dev, "Failed to set 32-bit DMA mask\n");
                goto out;

diff --git a/drivers/block/cciss.c b/drivers/block/cciss.c
index 0ef6f08aa6eadfbdb685704eb5fe5f039ff8e474..4d4d5e0d3fa64af15faf87a3a78c2a3b0396ef9c 100644 (file)
--- a/drivers/block/cciss.c
+++ b/drivers/block/cciss.c
@@ -3505,7 +3505,7 @@ static __devinit int cciss_message(struct pci_dev *pdev, unsigned char opcode, u
        /* The Inbound Post Queue only accepts 32-bit physical addresses for the
           CCISS commands, so they must be allocated from the lower 4GiB of
           memory. */
-       err = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
+       err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
        if (err) {
                iounmap(vaddr);
                return -ENOMEM;

diff --git a/drivers/net/atl1c/atl1c_main.c b/drivers/net/atl1c/atl1c_main.c
index deb7b53167ee0bfd6448ccd416928a4d9b355a08..83a12125b94e24f694a982ef9f0d0cac8c70f23d 100644 (file)
--- a/drivers/net/atl1c/atl1c_main.c
+++ b/drivers/net/atl1c/atl1c_main.c
@@ -2532,8 +2532,8 @@ static int __devinit atl1c_probe(struct pci_dev *pdev,
         * various kernel subsystems to support the mechanics required by a
         * fixed-high-32-bit system.
         */
-       if ((pci_set_dma_mask(pdev, DMA_32BIT_MASK) != 0) ||
-           (pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK) != 0)) {
+       if ((pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) != 0) ||
+           (pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32)) != 0)) {
                dev_err(&pdev->dev, "No usable DMA configuration,aborting\n");
                goto err_dma;
        }

diff --git a/drivers/net/benet/be_main.c b/drivers/net/benet/be_main.c
index 9b75aa630062401886b404392ca0ecbc22d524e8..30d0c81c989e3c443f3254115f99319e79e1065c 100644 (file)
--- a/drivers/net/benet/be_main.c
+++ b/drivers/net/benet/be_main.c
@@ -1821,11 +1821,11 @@ static int __devinit be_probe(struct pci_dev *pdev,
 
        be_msix_enable(adapter);
 
-       status = pci_set_dma_mask(pdev, DMA_64BIT_MASK);
+       status = pci_set_dma_mask(pdev, DMA_BIT_MASK(64));
        if (!status) {
                netdev->features |= NETIF_F_HIGHDMA;
        } else {
-               status = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
+               status = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
                if (status) {
                        dev_err(&pdev->dev, "Could not set PCI DMA Mask\n");
                        goto free_netdev;

diff --git a/drivers/net/jme.c b/drivers/net/jme.c
index ece35040288c5de1e6344ae0d4367ca1378ef2e4..621a7c0c46ba7360e314878e1bd7d5a924673132 100644 (file)
--- a/drivers/net/jme.c
+++ b/drivers/net/jme.c
@@ -2591,13 +2591,13 @@ static int
 jme_pci_dma64(struct pci_dev *pdev)
 {
        if (pdev->device == PCI_DEVICE_ID_JMICRON_JMC250 &&
-           !pci_set_dma_mask(pdev, DMA_64BIT_MASK))
-               if (!pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK))
+           !pci_set_dma_mask(pdev, DMA_BIT_MASK(64)))
+               if (!pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)))
                        return 1;
 
        if (pdev->device == PCI_DEVICE_ID_JMICRON_JMC250 &&
-           !pci_set_dma_mask(pdev, DMA_40BIT_MASK))
-               if (!pci_set_consistent_dma_mask(pdev, DMA_40BIT_MASK))
+           !pci_set_dma_mask(pdev, DMA_BIT_MASK(40)))
+               if (!pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(40)))
                        return 1;
 
        if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(32)))

diff --git a/drivers/net/wireless/ath9k/pci.c b/drivers/net/wireless/ath9k/pci.c
index 6dbc58580abbc1d5df9223aa60a11925370c71aa..168411d322a2e2e5408a17051d0ac3bd23cb1bf8 100644 (file)
--- a/drivers/net/wireless/ath9k/pci.c
+++ b/drivers/net/wireless/ath9k/pci.c
@@ -93,14 +93,14 @@ static int ath_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id)
        if (pci_enable_device(pdev))
                return -EIO;
 
-       ret =  pci_set_dma_mask(pdev, DMA_32BIT_MASK);
+       ret =  pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
 
        if (ret) {
                printk(KERN_ERR "ath9k: 32-bit DMA not available\n");
                goto bad;
        }
 
-       ret = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
+       ret = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
 
        if (ret) {
                printk(KERN_ERR "ath9k: 32-bit DMA consistent "

diff --git a/drivers/net/wireless/p54/p54pci.c b/drivers/net/wireless/p54/p54pci.c
index e3569a0a952d2b6ca9e951a72c6bb10375da0a45..b1610ea4bb3da0c135b6bf8e416d0be4f91ca952 100644 (file)
--- a/drivers/net/wireless/p54/p54pci.c
+++ b/drivers/net/wireless/p54/p54pci.c
@@ -492,8 +492,8 @@ static int __devinit p54p_probe(struct pci_dev *pdev,
                goto err_disable_dev;
        }
 
-       if (pci_set_dma_mask(pdev, DMA_32BIT_MASK) ||
-           pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK)) {
+       if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) ||
+           pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32))) {
                dev_err(&pdev->dev, "No suitable DMA available\n");
                goto err_free_reg;
        }

diff --git a/drivers/scsi/3w-9xxx.c b/drivers/scsi/3w-9xxx.c
index fdb14ec4fd47aeb156c1adb9558acfb18b3b4ddd..8b7983aba8f75ceabf987c25fc8e5a2a7e7f2fda 100644 (file)
--- a/drivers/scsi/3w-9xxx.c
+++ b/drivers/scsi/3w-9xxx.c
@@ -2234,10 +2234,10 @@ static int twa_resume(struct pci_dev *pdev)
        pci_set_master(pdev);
        pci_try_set_mwi(pdev);
 
-       if (pci_set_dma_mask(pdev, DMA_64BIT_MASK)
-           || pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK))
-               if (pci_set_dma_mask(pdev, DMA_32BIT_MASK)
-                   || pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK)) {
+       if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64))
+           || pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)))
+               if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))
+                   || pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32))) {
                        TW_PRINTK(host, TW_DRIVER, 0x40, "Failed to set dma mask during resume");
                        retval = -ENODEV;
                        goto out_disable_device;

diff --git a/drivers/scsi/aacraid/aachba.c b/drivers/scsi/aacraid/aachba.c
index 280261c451d6fbf89a9ee86bb4bb7f2aee9dbd09..2a889853a106b96227d203881b84880db254b378 100644 (file)
--- a/drivers/scsi/aacraid/aachba.c
+++ b/drivers/scsi/aacraid/aachba.c
@@ -1378,7 +1378,7 @@ int aac_get_adapter_info(struct aac_dev* dev)
        if (dev->nondasd_support && !dev->in_reset)
                printk(KERN_INFO "%s%d: Non-DASD support enabled.\n",dev->name, dev->id);
 
-       if (dma_get_required_mask(&dev->pdev->dev) > DMA_32BIT_MASK)
+       if (dma_get_required_mask(&dev->pdev->dev) > DMA_BIT_MASK(32))
                dev->needs_dac = 1;
        dev->dac_support = 0;
        if ((sizeof(dma_addr_t) > 4) && dev->needs_dac &&

diff --git a/drivers/scsi/mpt2sas/mpt2sas_base.c b/drivers/scsi/mpt2sas/mpt2sas_base.c
index 52427a8324f57d5ff1aebcf943a3a0747f6ad5f0..a91f5143ceac3eb7cbfec5b4fad6f588bd5834b1 100644 (file)
--- a/drivers/scsi/mpt2sas/mpt2sas_base.c
+++ b/drivers/scsi/mpt2sas/mpt2sas_base.c
@@ -855,9 +855,9 @@ _base_config_dma_addressing(struct MPT2SAS_ADAPTER *ioc, struct pci_dev *pdev)
        if (sizeof(dma_addr_t) > 4) {
                const uint64_t required_mask =
                    dma_get_required_mask(&pdev->dev);
-               if ((required_mask > DMA_32BIT_MASK) && !pci_set_dma_mask(pdev,
-                   DMA_64BIT_MASK) && !pci_set_consistent_dma_mask(pdev,
-                   DMA_64BIT_MASK)) {
+               if ((required_mask > DMA_BIT_MASK(32)) && !pci_set_dma_mask(pdev,
+                   DMA_BIT_MASK(64)) && !pci_set_consistent_dma_mask(pdev,
+                   DMA_BIT_MASK(64))) {
                        ioc->base_add_sg_single = &_base_add_sg_single_64;
                        ioc->sge_size = sizeof(Mpi2SGESimple64_t);
                        desc = "64";
@@ -865,8 +865,8 @@ _base_config_dma_addressing(struct MPT2SAS_ADAPTER *ioc, struct pci_dev *pdev)
                }
        }
 
-       if (!pci_set_dma_mask(pdev, DMA_32BIT_MASK)
-           && !pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK)) {
+       if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(32))
+           && !pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32))) {
                ioc->base_add_sg_single = &_base_add_sg_single_32;
                ioc->sge_size = sizeof(Mpi2SGESimple32_t);
                desc = "32";

diff --git a/drivers/staging/b3dfg/b3dfg.c b/drivers/staging/b3dfg/b3dfg.c
index 0348072b3ab5cb0fc29e486556b097c2c831b3d5..75ebe338c6f2d24aee9092c10b36fe8c37b63e9f 100644 (file)
--- a/drivers/staging/b3dfg/b3dfg.c
+++ b/drivers/staging/b3dfg/b3dfg.c
@@ -1000,7 +1000,7 @@ static int __devinit b3dfg_probe(struct pci_dev *pdev,
 
        pci_set_master(pdev);
 
-       r = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
+       r = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
        if (r) {
                dev_err(&pdev->dev, "no usable DMA configuration\n");
                goto err_free_res;

diff --git a/drivers/usb/otg/nop-usb-xceiv.c b/drivers/usb/otg/nop-usb-xceiv.c
index 4b933f646f2eddf3e59509b9dd81bdbab68cedd2..c567168f89af54c63a1b1f386758088c99ec3de6 100644 (file)
--- a/drivers/usb/otg/nop-usb-xceiv.c
+++ b/drivers/usb/otg/nop-usb-xceiv.c
@@ -36,14 +36,14 @@ struct nop_usb_xceiv {
        struct device           *dev;
 };
 
-static u64 nop_xceiv_dmamask = DMA_32BIT_MASK;
+static u64 nop_xceiv_dmamask = DMA_BIT_MASK(32);
 
 static struct platform_device nop_xceiv_device = {
        .name           = "nop_usb_xceiv",
        .id             = -1,
        .dev = {
                .dma_mask               = &nop_xceiv_dmamask,
-               .coherent_dma_mask      = DMA_32BIT_MASK,
+               .coherent_dma_mask      = DMA_BIT_MASK(32),
                .platform_data          = NULL,
        },
 };

diff --git a/sound/pci/hda/hda_intel.c b/sound/pci/hda/hda_intel.c
index 30829ee920c3a8366ea841dbdb985787719b521e..7ba8db5d4c42176787b283aea0246685d63342f9 100644 (file)
--- a/sound/pci/hda/hda_intel.c
+++ b/sound/pci/hda/hda_intel.c
@@ -2260,11 +2260,11 @@ static int __devinit azx_create(struct snd_card *card, struct pci_dev *pci,
                gcap &= ~0x01;
 
        /* allow 64bit DMA address if supported by H/W */
-       if ((gcap & 0x01) && !pci_set_dma_mask(pci, DMA_64BIT_MASK))
-               pci_set_consistent_dma_mask(pci, DMA_64BIT_MASK);
+       if ((gcap & 0x01) && !pci_set_dma_mask(pci, DMA_BIT_MASK(64)))
+               pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(64));
        else {
-               pci_set_dma_mask(pci, DMA_32BIT_MASK);
-               pci_set_consistent_dma_mask(pci, DMA_32BIT_MASK);
+               pci_set_dma_mask(pci, DMA_BIT_MASK(32));
+               pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(32));
        }
 
        /* read number of streams from GCAP register instead of using