dma-mapping: replace all DMA_64BIT_MASK macro with DMA_BIT_MASK(64)

Replace all DMA_64BIT_MASK macro with DMA_BIT_MASK(64)

Signed-off-by: Yang Hongyang<yanghy@cn.fujitsu.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

diff --git a/arch/arm/mach-iop13xx/setup.c b/arch/arm/mach-iop13xx/setup.c
index cfd4d2e6dacd6d1f7fb235c84c98552c99347a0e..bee42c609df6c6db3c491e9826fc5c4d5973225d 100644 (file)
--- a/arch/arm/mach-iop13xx/setup.c
+++ b/arch/arm/mach-iop13xx/setup.c
@@ -307,7 +307,7 @@ static struct resource iop13xx_adma_2_resources[] = {
        }
 };
 
-static u64 iop13xx_adma_dmamask = DMA_64BIT_MASK;
+static u64 iop13xx_adma_dmamask = DMA_BIT_MASK(64);
 static struct iop_adma_platform_data iop13xx_adma_0_data = {
        .hw_id = 0,
        .pool_size = PAGE_SIZE,
@@ -331,7 +331,7 @@ static struct platform_device iop13xx_adma_0_channel = {
        .resource = iop13xx_adma_0_resources,
        .dev = {
                .dma_mask = &iop13xx_adma_dmamask,
-               .coherent_dma_mask = DMA_64BIT_MASK,
+               .coherent_dma_mask = DMA_BIT_MASK(64),
                .platform_data = (void *) &iop13xx_adma_0_data,
        },
 };
@@ -343,7 +343,7 @@ static struct platform_device iop13xx_adma_1_channel = {
        .resource = iop13xx_adma_1_resources,
        .dev = {
                .dma_mask = &iop13xx_adma_dmamask,
-               .coherent_dma_mask = DMA_64BIT_MASK,
+               .coherent_dma_mask = DMA_BIT_MASK(64),
                .platform_data = (void *) &iop13xx_adma_1_data,
        },
 };
@@ -355,7 +355,7 @@ static struct platform_device iop13xx_adma_2_channel = {
        .resource = iop13xx_adma_2_resources,
        .dev = {
                .dma_mask = &iop13xx_adma_dmamask,
-               .coherent_dma_mask = DMA_64BIT_MASK,
+               .coherent_dma_mask = DMA_BIT_MASK(64),
                .platform_data = (void *) &iop13xx_adma_2_data,
        },
 };

diff --git a/arch/arm/mach-iop13xx/tpmi.c b/arch/arm/mach-iop13xx/tpmi.c
index c6af1e1bee32e5a844d13686eabf02ade6f10c57..6fdad7a0425af0e1a6565b1fc3a45aab5f27aa35 100644 (file)
--- a/arch/arm/mach-iop13xx/tpmi.c
+++ b/arch/arm/mach-iop13xx/tpmi.c
@@ -151,7 +151,7 @@ static struct resource iop13xx_tpmi_3_resources[] = {
        }
 };
 
-u64 iop13xx_tpmi_mask = DMA_64BIT_MASK;
+u64 iop13xx_tpmi_mask = DMA_BIT_MASK(64);
 static struct platform_device iop13xx_tpmi_0_device = {
        .name = "iop-tpmi",
        .id = 0,
@@ -159,7 +159,7 @@ static struct platform_device iop13xx_tpmi_0_device = {
        .resource = iop13xx_tpmi_0_resources,
        .dev = {
                .dma_mask          = &iop13xx_tpmi_mask,
-               .coherent_dma_mask = DMA_64BIT_MASK,
+               .coherent_dma_mask = DMA_BIT_MASK(64),
        },
 };
 
@@ -170,7 +170,7 @@ static struct platform_device iop13xx_tpmi_1_device = {
        .resource = iop13xx_tpmi_1_resources,
        .dev = {
                .dma_mask          = &iop13xx_tpmi_mask,
-               .coherent_dma_mask = DMA_64BIT_MASK,
+               .coherent_dma_mask = DMA_BIT_MASK(64),
        },
 };
 
@@ -181,7 +181,7 @@ static struct platform_device iop13xx_tpmi_2_device = {
        .resource = iop13xx_tpmi_2_resources,
        .dev = {
                .dma_mask          = &iop13xx_tpmi_mask,
-               .coherent_dma_mask = DMA_64BIT_MASK,
+               .coherent_dma_mask = DMA_BIT_MASK(64),
        },
 };
 
@@ -192,7 +192,7 @@ static struct platform_device iop13xx_tpmi_3_device = {
        .resource = iop13xx_tpmi_3_resources,
        .dev = {
                .dma_mask          = &iop13xx_tpmi_mask,
-               .coherent_dma_mask = DMA_64BIT_MASK,
+               .coherent_dma_mask = DMA_BIT_MASK(64),
        },
 };
 

diff --git a/arch/arm/mach-kirkwood/common.c b/arch/arm/mach-kirkwood/common.c
index 3d2fae84651231dcd835c017c9630250ab66884a..c691848714d92e81dfc2905cf3ef9fb7a4259a99 100644 (file)
--- a/arch/arm/mach-kirkwood/common.c
+++ b/arch/arm/mach-kirkwood/common.c
@@ -559,7 +559,7 @@ static struct platform_device kirkwood_xor00_channel = {
        .resource       = kirkwood_xor00_resources,
        .dev            = {
                .dma_mask               = &kirkwood_xor_dmamask,
-               .coherent_dma_mask      = DMA_64BIT_MASK,
+               .coherent_dma_mask      = DMA_BIT_MASK(64),
                .platform_data          = (void *)&kirkwood_xor00_data,
        },
 };
@@ -585,7 +585,7 @@ static struct platform_device kirkwood_xor01_channel = {
        .resource       = kirkwood_xor01_resources,
        .dev            = {
                .dma_mask               = &kirkwood_xor_dmamask,
-               .coherent_dma_mask      = DMA_64BIT_MASK,
+               .coherent_dma_mask      = DMA_BIT_MASK(64),
                .platform_data          = (void *)&kirkwood_xor01_data,
        },
 };
@@ -657,7 +657,7 @@ static struct platform_device kirkwood_xor10_channel = {
        .resource       = kirkwood_xor10_resources,
        .dev            = {
                .dma_mask               = &kirkwood_xor_dmamask,
-               .coherent_dma_mask      = DMA_64BIT_MASK,
+               .coherent_dma_mask      = DMA_BIT_MASK(64),
                .platform_data          = (void *)&kirkwood_xor10_data,
        },
 };
@@ -683,7 +683,7 @@ static struct platform_device kirkwood_xor11_channel = {
        .resource       = kirkwood_xor11_resources,
        .dev            = {
                .dma_mask               = &kirkwood_xor_dmamask,
-               .coherent_dma_mask      = DMA_64BIT_MASK,
+               .coherent_dma_mask      = DMA_BIT_MASK(64),
                .platform_data          = (void *)&kirkwood_xor11_data,
        },
 };

diff --git a/arch/arm/mach-orion5x/common.c b/arch/arm/mach-orion5x/common.c
index 68cc3efae56736a47894c4fd304e55d3f4126012..e8d42e8cb46585f9f1cf5abcc18ae928b37a4b1b 100644 (file)
--- a/arch/arm/mach-orion5x/common.c
+++ b/arch/arm/mach-orion5x/common.c
@@ -486,7 +486,7 @@ static struct platform_device orion5x_xor0_channel = {
        .resource       = orion5x_xor0_resources,
        .dev            = {
                .dma_mask               = &orion5x_xor_dmamask,
-               .coherent_dma_mask      = DMA_64BIT_MASK,
+               .coherent_dma_mask      = DMA_BIT_MASK(64),
                .platform_data          = (void *)&orion5x_xor0_data,
        },
 };
@@ -512,7 +512,7 @@ static struct platform_device orion5x_xor1_channel = {
        .resource       = orion5x_xor1_resources,
        .dev            = {
                .dma_mask               = &orion5x_xor_dmamask,
-               .coherent_dma_mask      = DMA_64BIT_MASK,
+               .coherent_dma_mask      = DMA_BIT_MASK(64),
                .platform_data          = (void *)&orion5x_xor1_data,
        },
 };

diff --git a/arch/arm/plat-iop/adma.c b/arch/arm/plat-iop/adma.c
index f724208216199ef8ae3b1e5228b70c7d48ba7f60..a2a94f6d2e7c1e5780f2e05e25e983e8bc9dec74 100644 (file)
--- a/arch/arm/plat-iop/adma.c
+++ b/arch/arm/plat-iop/adma.c
@@ -143,7 +143,7 @@ struct platform_device iop3xx_dma_0_channel = {
        .resource = iop3xx_dma_0_resources,
        .dev = {
                .dma_mask = &iop3xx_adma_dmamask,
-               .coherent_dma_mask = DMA_64BIT_MASK,
+               .coherent_dma_mask = DMA_BIT_MASK(64),
                .platform_data = (void *) &iop3xx_dma_0_data,
        },
 };
@@ -155,7 +155,7 @@ struct platform_device iop3xx_dma_1_channel = {
        .resource = iop3xx_dma_1_resources,
        .dev = {
                .dma_mask = &iop3xx_adma_dmamask,
-               .coherent_dma_mask = DMA_64BIT_MASK,
+               .coherent_dma_mask = DMA_BIT_MASK(64),
                .platform_data = (void *) &iop3xx_dma_1_data,
        },
 };
@@ -167,7 +167,7 @@ struct platform_device iop3xx_aau_channel = {
        .resource = iop3xx_aau_resources,
        .dev = {
                .dma_mask = &iop3xx_adma_dmamask,
-               .coherent_dma_mask = DMA_64BIT_MASK,
+               .coherent_dma_mask = DMA_BIT_MASK(64),
                .platform_data = (void *) &iop3xx_aau_data,
        },
 };

diff --git a/arch/ia64/sn/pci/pci_dma.c b/arch/ia64/sn/pci/pci_dma.c
index 8c130e8f00e1d3aee8052eb3141b8e33eb3ec3bd..d876423e4e755465d8249f4aeb01610490f62cff 100644 (file)
--- a/arch/ia64/sn/pci/pci_dma.c
+++ b/arch/ia64/sn/pci/pci_dma.c
@@ -349,7 +349,7 @@ static int sn_dma_mapping_error(struct device *dev, dma_addr_t dma_addr)
 
 u64 sn_dma_get_required_mask(struct device *dev)
 {
-       return DMA_64BIT_MASK;
+       return DMA_BIT_MASK(64);
 }
 EXPORT_SYMBOL_GPL(sn_dma_get_required_mask);
 

diff --git a/arch/powerpc/platforms/cell/iommu.c b/arch/powerpc/platforms/cell/iommu.c
index 5744527a7f2ac777bd9c94985c71e47ff4afd146..bed4690de3944162eca2918e8df1164e1fd5b678 100644 (file)
--- a/arch/powerpc/platforms/cell/iommu.c
+++ b/arch/powerpc/platforms/cell/iommu.c
@@ -644,7 +644,7 @@ static void dma_fixed_unmap_sg(struct device *dev, struct scatterlist *sg,
 
 static int dma_fixed_dma_supported(struct device *dev, u64 mask)
 {
-       return mask == DMA_64BIT_MASK;
+       return mask == DMA_BIT_MASK(64);
 }
 
 static int dma_set_mask_and_switch(struct device *dev, u64 dma_mask);

diff --git a/drivers/ata/ahci.c b/drivers/ata/ahci.c
index 788bba2b1e1798fc8b60336f701e06348c0396c8..207d775c3c27c325f318bbe52842e2ae9b31d39c 100644 (file)
--- a/drivers/ata/ahci.c
+++ b/drivers/ata/ahci.c
@@ -2405,8 +2405,8 @@ static int ahci_configure_dma_masks(struct pci_dev *pdev, int using_dac)
        int rc;
 
        if (using_dac &&
-           !pci_set_dma_mask(pdev, DMA_64BIT_MASK)) {
-               rc = pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK);
+           !pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) {
+               rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
                if (rc) {
                        rc = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
                        if (rc) {

diff --git a/drivers/ata/sata_mv.c b/drivers/ata/sata_mv.c
index a377226b81c8954005f37cfaac9aeb69ebff1677..45e0fe191afc3a45e9e95db5eb8762e1c286234b 100644 (file)
--- a/drivers/ata/sata_mv.c
+++ b/drivers/ata/sata_mv.c
@@ -3913,8 +3913,8 @@ static int pci_go_64(struct pci_dev *pdev)
 {
        int rc;
 
-       if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK)) {
-               rc = pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK);
+       if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) {
+               rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
                if (rc) {
                        rc = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
                        if (rc) {

diff --git a/drivers/ata/sata_qstor.c b/drivers/ata/sata_qstor.c
index c3936d35cdac5923e46810c9d7743be9760fbb98..7b37c27d7972c9c08a03defa49dc65c3d27bd21d 100644 (file)
--- a/drivers/ata/sata_qstor.c
+++ b/drivers/ata/sata_qstor.c
@@ -584,8 +584,8 @@ 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_64BIT_MASK)) {
-               rc = pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK);
+           !pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) {
+               rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
                if (rc) {
                        rc = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
                        if (rc) {

diff --git a/drivers/ata/sata_sil24.c b/drivers/ata/sata_sil24.c
index 0d8990dcdfcd832f4a2d96adfa000987ef460daf..37730bc2f09ff5142af87401d927961f8109fc65 100644 (file)
--- a/drivers/ata/sata_sil24.c
+++ b/drivers/ata/sata_sil24.c
@@ -1297,8 +1297,8 @@ 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_64BIT_MASK)) {
-               rc = pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK);
+       if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) {
+               rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
                if (rc) {
                        rc = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
                        if (rc) {

diff --git a/drivers/block/DAC960.c b/drivers/block/DAC960.c
index f6a337c34ac47e84a3d542b6d8e8af071bb49ffc..5496865b297e574ff8a385637de2da286556b8c9 100644 (file)
--- a/drivers/block/DAC960.c
+++ b/drivers/block/DAC960.c
@@ -1372,8 +1372,8 @@ static bool DAC960_V2_EnableMemoryMailboxInterface(DAC960_Controller_T
   dma_addr_t   CommandMailboxDMA;
   DAC960_V2_CommandStatus_T CommandStatus;
 
-       if (!pci_set_dma_mask(Controller->PCIDevice, DMA_64BIT_MASK))
-               Controller->BounceBufferLimit = DMA_64BIT_MASK;
+       if (!pci_set_dma_mask(Controller->PCIDevice, DMA_BIT_MASK(64)))
+               Controller->BounceBufferLimit = DMA_BIT_MASK(64);
        else if (!pci_set_dma_mask(Controller->PCIDevice, DMA_32BIT_MASK))
                Controller->BounceBufferLimit = DMA_32BIT_MASK;
        else

diff --git a/drivers/block/cciss.c b/drivers/block/cciss.c
index 5d0e135824f9c3e96bb76de0c5f88b259d50a241..149a611e8fe5634e8a0a72131a921e637dee33a4 100644 (file)
--- a/drivers/block/cciss.c
+++ b/drivers/block/cciss.c
@@ -3637,7 +3637,7 @@ static int __devinit cciss_init_one(struct pci_dev *pdev,
        hba[i]->pdev = pdev;
 
        /* configure PCI DMA stuff */
-       if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK))
+       if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64)))
                dac = 1;
        else if (!pci_set_dma_mask(pdev, DMA_32BIT_MASK))
                dac = 0;

diff --git a/drivers/block/sx8.c b/drivers/block/sx8.c
index a18e1ca0f76197e32bdef59323936a627372253e..db5783ace1e47c3c233b72248b24b6998f5f0ce7 100644 (file)
--- a/drivers/block/sx8.c
+++ b/drivers/block/sx8.c
@@ -1586,9 +1586,9 @@ static int carm_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
                goto err_out;
 
 #ifdef IF_64BIT_DMA_IS_POSSIBLE /* grrrr... */
-       rc = pci_set_dma_mask(pdev, DMA_64BIT_MASK);
+       rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(64));
        if (!rc) {
-               rc = pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK);
+               rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
                if (rc) {
                        printk(KERN_ERR DRV_NAME "(%s): consistent DMA mask failure\n",
                                pci_name(pdev));

diff --git a/drivers/block/umem.c b/drivers/block/umem.c
index c24e1bdbad438785b0b68fca6aba5699331436b2..e93e99c9103cab771f514c2cc02e677deed910c8 100644 (file)
--- a/drivers/block/umem.c
+++ b/drivers/block/umem.c
@@ -829,7 +829,7 @@ static int __devinit mm_pci_probe(struct pci_dev *dev,
        dev_printk(KERN_INFO, &dev->dev,
          "Micro Memory(tm) controller found (PCI Mem Module (Battery Backup))\n");
 
-       if (pci_set_dma_mask(dev, DMA_64BIT_MASK) &&
+       if (pci_set_dma_mask(dev, DMA_BIT_MASK(64)) &&
            pci_set_dma_mask(dev, DMA_32BIT_MASK)) {
                dev_printk(KERN_WARNING, &dev->dev, "NO suitable DMA found\n");
                return  -ENOMEM;

diff --git a/drivers/dma/ioat.c b/drivers/dma/ioat.c
index ed83dd9df192a5a4b65d5f1f15b3e1e2349178b3..22e9f1911111a95f0c09fed5f17b0fbee1f07470 100644 (file)
--- a/drivers/dma/ioat.c
+++ b/drivers/dma/ioat.c
@@ -98,13 +98,13 @@ static int __devinit ioat_probe(struct pci_dev *pdev,
        if (err)
                goto err_request_regions;
 
-       err = pci_set_dma_mask(pdev, DMA_64BIT_MASK);
+       err = pci_set_dma_mask(pdev, DMA_BIT_MASK(64));
        if (err)
                err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
        if (err)
                goto err_set_dma_mask;
 
-       err = pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK);
+       err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
        if (err)
                err = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
        if (err)

diff --git a/drivers/idle/i7300_idle.c b/drivers/idle/i7300_idle.c
index 17e8ddd013347623c39d8ecb8e150b99aaa29094..bf740394d70431f1cb0f37732f6ca68fd7aaa4ed 100644 (file)
--- a/drivers/idle/i7300_idle.c
+++ b/drivers/idle/i7300_idle.c
@@ -178,7 +178,7 @@ static int __init i7300_idle_ioat_selftest(u8 *ctl,
 
 static struct device dummy_dma_dev = {
        .init_name = "fallback device",
-       .coherent_dma_mask = DMA_64BIT_MASK,
+       .coherent_dma_mask = DMA_BIT_MASK(64),
        .dma_mask = &dummy_dma_dev.coherent_dma_mask,
 };
 

diff --git a/drivers/infiniband/hw/amso1100/c2.c b/drivers/infiniband/hw/amso1100/c2.c
index 7d79aa361e26c84677f87bcf665a288f2b4b6182..54d2e0760abfa9587d10185878960a770961848c 100644 (file)
--- a/drivers/infiniband/hw/amso1100/c2.c
+++ b/drivers/infiniband/hw/amso1100/c2.c
@@ -989,7 +989,7 @@ static int __devinit c2_probe(struct pci_dev *pcidev,
        }
 
        if ((sizeof(dma_addr_t) > 4)) {
-               ret = pci_set_dma_mask(pcidev, DMA_64BIT_MASK);
+               ret = pci_set_dma_mask(pcidev, DMA_BIT_MASK(64));
                if (ret < 0) {
                        printk(KERN_ERR PFX "64b DMA configuration failed\n");
                        goto bail2;

diff --git a/drivers/infiniband/hw/ipath/ipath_driver.c b/drivers/infiniband/hw/ipath/ipath_driver.c
index cb9daa6ac029d44a6cadd88057c9d3ddef57e020..77b2fb5b7c351099d8b73f7211496ca9d326b752 100644 (file)
--- a/drivers/infiniband/hw/ipath/ipath_driver.c
+++ b/drivers/infiniband/hw/ipath/ipath_driver.c
@@ -470,7 +470,7 @@ static int __devinit ipath_init_one(struct pci_dev *pdev,
                goto bail_disable;
        }
 
-       ret = pci_set_dma_mask(pdev, DMA_64BIT_MASK);
+       ret = pci_set_dma_mask(pdev, DMA_BIT_MASK(64));
        if (ret) {
                /*
                 * if the 64 bit setup fails, try 32 bit.  Some systems
@@ -496,7 +496,7 @@ static int __devinit ipath_init_one(struct pci_dev *pdev,
                }
        }
        else {
-               ret = pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK);
+               ret = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
                if (ret)
                        dev_info(&pdev->dev,
                                "Unable to set DMA consistent mask "

diff --git a/drivers/infiniband/hw/mthca/mthca_main.c b/drivers/infiniband/hw/mthca/mthca_main.c
index 52f60f4eea0070a2f763a2bcb8d3a5373f919963..5d234204f7b7718bfcdb38603a4a4364ff1cc6ef 100644 (file)
--- a/drivers/infiniband/hw/mthca/mthca_main.c
+++ b/drivers/infiniband/hw/mthca/mthca_main.c
@@ -1016,7 +1016,7 @@ static int __mthca_init_one(struct pci_dev *pdev, int hca_type)
 
        pci_set_master(pdev);
 
-       err = pci_set_dma_mask(pdev, DMA_64BIT_MASK);
+       err = pci_set_dma_mask(pdev, DMA_BIT_MASK(64));
        if (err) {
                dev_warn(&pdev->dev, "Warning: couldn't set 64-bit PCI DMA mask.\n");
                err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
@@ -1025,7 +1025,7 @@ static int __mthca_init_one(struct pci_dev *pdev, int hca_type)
                        goto err_free_res;
                }
        }
-       err = pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK);
+       err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
        if (err) {
                dev_warn(&pdev->dev, "Warning: couldn't set 64-bit "
                         "consistent PCI DMA mask.\n");

diff --git a/drivers/infiniband/hw/nes/nes.c b/drivers/infiniband/hw/nes/nes.c
index ca599767ffbdc20f1b45af616541c47631cfbf9c..7446810446e16772168a1e7652cc1582bba41c35 100644 (file)
--- a/drivers/infiniband/hw/nes/nes.c
+++ b/drivers/infiniband/hw/nes/nes.c
@@ -478,12 +478,12 @@ static int __devinit nes_probe(struct pci_dev *pcidev, const struct pci_device_i
        }
 
        if ((sizeof(dma_addr_t) > 4)) {
-               ret = pci_set_dma_mask(pcidev, DMA_64BIT_MASK);
+               ret = pci_set_dma_mask(pcidev, DMA_BIT_MASK(64));
                if (ret < 0) {
                        printk(KERN_ERR PFX "64b DMA mask configuration failed\n");
                        goto bail2;
                }
-               ret = pci_set_consistent_dma_mask(pcidev, DMA_64BIT_MASK);
+               ret = pci_set_consistent_dma_mask(pcidev, DMA_BIT_MASK(64));
                if (ret) {
                        printk(KERN_ERR PFX "64b DMA consistent mask configuration failed\n");
                        goto bail2;

diff --git a/drivers/message/fusion/mptbase.c b/drivers/message/fusion/mptbase.c
index ea3aafbbda449696b6653edc9ebf02094490e067..98026016a9353b1fa0358d9ae7b43cb7e8d1733f 100644 (file)
--- a/drivers/message/fusion/mptbase.c
+++ b/drivers/message/fusion/mptbase.c
@@ -1534,8 +1534,8 @@ mpt_mapresources(MPT_ADAPTER *ioc)
 
        pci_read_config_byte(pdev, PCI_CLASS_REVISION, &revision);
 
-       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_BIT_MASK(64))
+           && !pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64))) {
                dinitprintk(ioc, printk(MYIOC_s_INFO_FMT
                    ": 64 BIT PCI BUS DMA ADDRESSING SUPPORTED\n",
                    ioc->name));

diff --git a/drivers/message/i2o/memory.c b/drivers/message/i2o/memory.c
index f5cc95c564e22c1debd9b8d440ccb6ea29b65210..9a08d8e4551623cb709c74ed6019da8a270c0c21 100644 (file)
--- a/drivers/message/i2o/memory.c
+++ b/drivers/message/i2o/memory.c
@@ -185,7 +185,7 @@ int i2o_dma_alloc(struct device *dev, struct i2o_dma *addr, size_t len)
        int dma_64 = 0;
 
        mutex_lock(&mem_lock);
-       if ((sizeof(dma_addr_t) > 4) && (pdev->dma_mask == DMA_64BIT_MASK)) {
+       if ((sizeof(dma_addr_t) > 4) && (pdev->dma_mask == DMA_BIT_MASK(64))) {
                dma_64 = 1;
                if (pci_set_dma_mask(pdev, DMA_32BIT_MASK)) {
                        mutex_unlock(&mem_lock);
@@ -196,7 +196,7 @@ int i2o_dma_alloc(struct device *dev, struct i2o_dma *addr, size_t len)
        addr->virt = dma_alloc_coherent(dev, len, &addr->phys, GFP_KERNEL);
 
        if ((sizeof(dma_addr_t) > 4) && dma_64)
-               if (pci_set_dma_mask(pdev, DMA_64BIT_MASK))
+               if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64)))
                        printk(KERN_WARNING "i2o: unable to set 64-bit DMA");
        mutex_unlock(&mem_lock);
 

diff --git a/drivers/message/i2o/pci.c b/drivers/message/i2o/pci.c
index 25d6f234198367cd1f70895fc7ab7f030f7262e0..ed17ac5af3e0d0aa80754d2ca71ebb927165273d 100644 (file)
--- a/drivers/message/i2o/pci.c
+++ b/drivers/message/i2o/pci.c
@@ -397,7 +397,7 @@ static int __devinit i2o_pci_probe(struct pci_dev *pdev,
                }
 #ifdef CONFIG_I2O_EXT_ADAPTEC_DMA64
                if (sizeof(dma_addr_t) > 4) {
-                       if (pci_set_dma_mask(pdev, DMA_64BIT_MASK))
+                       if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64)))
                                printk(KERN_INFO "%s: 64-bit DMA unavailable\n",
                                       c->name);
                        else {

diff --git a/drivers/net/8139cp.c b/drivers/net/8139cp.c
index a09e3a7cac4f7c834c6e65d9a462ea6158d9dd4c..d08475a7f6762b9166f95d449ed5f0c390f0c2b7 100644 (file)
--- a/drivers/net/8139cp.c
+++ b/drivers/net/8139cp.c
@@ -1929,8 +1929,8 @@ static int cp_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
 
        /* Configure DMA attributes. */
        if ((sizeof(dma_addr_t) > 4) &&
-           !pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK) &&
-           !pci_set_dma_mask(pdev, DMA_64BIT_MASK)) {
+           !pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)) &&
+           !pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) {
                pci_using_dac = 1;
        } else {
                pci_using_dac = 0;

diff --git a/drivers/net/acenic.c b/drivers/net/acenic.c
index 06a9f11669f31c9176fce319fb579419db020ee0..9509c17b366713a6be4db9af5785fd34a4336d2d 100644 (file)
--- a/drivers/net/acenic.c
+++ b/drivers/net/acenic.c
@@ -1161,7 +1161,7 @@ static int __devinit ace_init(struct net_device *dev)
        /*
         * Configure DMA attributes.
         */
-       if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK)) {
+       if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) {
                ap->pci_using_dac = 1;
        } else if (!pci_set_dma_mask(pdev, DMA_32BIT_MASK)) {
                ap->pci_using_dac = 0;

diff --git a/drivers/net/bnx2.c b/drivers/net/bnx2.c
index 17cbc8c6be376a55596364e8ea5f575251261d24..aa75a4b96909ef893214e85a5d63763331a7290a 100644 (file)
--- a/drivers/net/bnx2.c
+++ b/drivers/net/bnx2.c
@@ -7527,7 +7527,7 @@ bnx2_init_board(struct pci_dev *pdev, struct net_device *dev)
        if (CHIP_NUM(bp) == CHIP_NUM_5708)
                persist_dma_mask = dma_mask = DMA_40BIT_MASK;
        else
-               persist_dma_mask = dma_mask = DMA_64BIT_MASK;
+               persist_dma_mask = dma_mask = DMA_BIT_MASK(64);
 
        /* Configure DMA attributes. */
        if (pci_set_dma_mask(pdev, dma_mask) == 0) {

diff --git a/drivers/net/bnx2x_main.c b/drivers/net/bnx2x_main.c
index 00a78e8677b01431a30bff2690884ca005e43bdb..03e01243b45e323596f368b72814443eaedc86eb 100644 (file)
--- a/drivers/net/bnx2x_main.c
+++ b/drivers/net/bnx2x_main.c
@@ -10979,9 +10979,9 @@ static int __devinit bnx2x_init_dev(struct pci_dev *pdev,
                goto err_out_release;
        }
 
-       if (pci_set_dma_mask(pdev, DMA_64BIT_MASK) == 0) {
+       if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64)) == 0) {
                bp->flags |= USING_DAC_FLAG;
-               if (pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK) != 0) {
+               if (pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)) != 0) {
                        printk(KERN_ERR PFX "pci_set_consistent_dma_mask"
                               " failed, aborting\n");
                        rc = -EIO;

diff --git a/drivers/net/cassini.c b/drivers/net/cassini.c
index 0effefa1b882036813a3b5e2401ed4b4fc126888..c2895240e467de388525a49878903275baa09a40 100644 (file)
--- a/drivers/net/cassini.c
+++ b/drivers/net/cassini.c
@@ -5074,10 +5074,10 @@ static int __devinit cas_init_one(struct pci_dev *pdev,
 
 
        /* Configure DMA attributes. */
-       if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK)) {
+       if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) {
                pci_using_dac = 1;
                err = pci_set_consistent_dma_mask(pdev,
-                                                 DMA_64BIT_MASK);
+                                                 DMA_BIT_MASK(64));
                if (err < 0) {
                        dev_err(&pdev->dev, "Unable to obtain 64-bit DMA "
                               "for consistent allocations\n");

diff --git a/drivers/net/chelsio/cxgb2.c b/drivers/net/chelsio/cxgb2.c
index 9b6011e7678e3552d51b9692d53aad4477724519..57cfbc369f510c4e082f4f46bb733bca54e22a81 100644 (file)
--- a/drivers/net/chelsio/cxgb2.c
+++ b/drivers/net/chelsio/cxgb2.c
@@ -1056,10 +1056,10 @@ static int __devinit init_one(struct pci_dev *pdev,
                goto out_disable_pdev;
        }
 
-       if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK)) {
+       if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) {
                pci_using_dac = 1;
 
-               if (pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK)) {
+               if (pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64))) {
                        CH_ERR("%s: unable to obtain 64-bit DMA for "
                               "consistent allocations\n", pci_name(pdev));
                        err = -ENODEV;

diff --git a/drivers/net/cxgb3/cxgb3_main.c b/drivers/net/cxgb3/cxgb3_main.c
index 2c2aaa741450a9e57e1101be652782386dee22d6..ec35d3b8240925738e6a22e8a5e9dc76b2c42937 100644 (file)
--- a/drivers/net/cxgb3/cxgb3_main.c
+++ b/drivers/net/cxgb3/cxgb3_main.c
@@ -3038,9 +3038,9 @@ static int __devinit init_one(struct pci_dev *pdev,
                goto out_release_regions;
        }
 
-       if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK)) {
+       if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) {
                pci_using_dac = 1;
-               err = pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK);
+               err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
                if (err) {
                        dev_err(&pdev->dev, "unable to obtain 64-bit DMA for "
                               "coherent allocations\n");

diff --git a/drivers/net/e1000/e1000_main.c b/drivers/net/e1000/e1000_main.c
index a65023d772cb9ffbac1ddd2a3e1f92b37a9c9471..caa71dffb3d07ad400cfa601bfa5c29e2dc357a4 100644 (file)
--- a/drivers/net/e1000/e1000_main.c
+++ b/drivers/net/e1000/e1000_main.c
@@ -962,8 +962,8 @@ static int __devinit e1000_probe(struct pci_dev *pdev,
        if (err)
                return err;
 
-       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_BIT_MASK(64)) &&
+           !pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64))) {
                pci_using_dac = 1;
        } else {
                err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);

diff --git a/drivers/net/e1000e/netdev.c b/drivers/net/e1000e/netdev.c
index bfb2d6c85c544cb8fa856f7b34900bac7c44756f..4a61160052a33374819b214131388b4462cb0a4f 100644 (file)
--- a/drivers/net/e1000e/netdev.c
+++ b/drivers/net/e1000e/netdev.c
@@ -4763,9 +4763,9 @@ static int __devinit e1000_probe(struct pci_dev *pdev,
                return err;
 
        pci_using_dac = 0;
-       err = pci_set_dma_mask(pdev, DMA_64BIT_MASK);
+       err = pci_set_dma_mask(pdev, DMA_BIT_MASK(64));
        if (!err) {
-               err = pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK);
+               err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
                if (!err)
                        pci_using_dac = 1;
        } else {

diff --git a/drivers/net/igb/igb_main.c b/drivers/net/igb/igb_main.c
index 03aa9593dd9e2d0e9efdc3660a5c25c5e88570ab..82278beaac8305c4bfa0015f29fea4d35d1e72f8 100644 (file)
--- a/drivers/net/igb/igb_main.c
+++ b/drivers/net/igb/igb_main.c
@@ -1154,9 +1154,9 @@ static int __devinit igb_probe(struct pci_dev *pdev,
                return err;
 
        pci_using_dac = 0;
-       err = pci_set_dma_mask(pdev, DMA_64BIT_MASK);
+       err = pci_set_dma_mask(pdev, DMA_BIT_MASK(64));
        if (!err) {
-               err = pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK);
+               err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
                if (!err)
                        pci_using_dac = 1;
        } else {

diff --git a/drivers/net/ioc3-eth.c b/drivers/net/ioc3-eth.c
index 170b12d1d70e49e2ab02918b41e1236bd9544a84..43be0b01f12c42b82b2ba419f52a9bcb9b06929d 100644 (file)
--- a/drivers/net/ioc3-eth.c
+++ b/drivers/net/ioc3-eth.c
@@ -1226,10 +1226,10 @@ static int __devinit ioc3_probe(struct pci_dev *pdev,
        int err, pci_using_dac;
 
        /* Configure DMA attributes. */
-       err = pci_set_dma_mask(pdev, DMA_64BIT_MASK);
+       err = pci_set_dma_mask(pdev, DMA_BIT_MASK(64));
        if (!err) {
                pci_using_dac = 1;
-               err = pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK);
+               err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
                if (err < 0) {
                        printk(KERN_ERR "%s: Unable to obtain 64 bit DMA "
                               "for consistent allocations\n", pci_name(pdev));

diff --git a/drivers/net/ixgb/ixgb_main.c b/drivers/net/ixgb/ixgb_main.c
index 4b0ea66d7a445e4345db9575745778acf9ce67bf..0ac51758bc6c789e65a4ef6eebf41f7bd743a4dc 100644 (file)
--- a/drivers/net/ixgb/ixgb_main.c
+++ b/drivers/net/ixgb/ixgb_main.c
@@ -365,8 +365,8 @@ ixgb_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
        if (err)
                return err;
 
-       if (!(err = pci_set_dma_mask(pdev, DMA_64BIT_MASK)) &&
-           !(err = pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK))) {
+       if (!(err = pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) &&
+           !(err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)))) {
                pci_using_dac = 1;
        } else {
                if ((err = pci_set_dma_mask(pdev, DMA_32BIT_MASK)) ||

diff --git a/drivers/net/ixgbe/ixgbe_main.c b/drivers/net/ixgbe/ixgbe_main.c
index 286ecc0e6ab75148c8ff08513c1776fe68f5cf04..126735ca6d7f1ca9d23b343b5cf16ecb07a9c478 100644 (file)
--- a/drivers/net/ixgbe/ixgbe_main.c
+++ b/drivers/net/ixgbe/ixgbe_main.c
@@ -4509,8 +4509,8 @@ static int __devinit ixgbe_probe(struct pci_dev *pdev,
        if (err)
                return err;
 
-       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_BIT_MASK(64)) &&
+           !pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64))) {
                pci_using_dac = 1;
        } else {
                err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);

diff --git a/drivers/net/mlx4/main.c b/drivers/net/mlx4/main.c
index a66f5b2fd288333d11e70f03cd64420e5b30ccab..fed53fbaf54524288398fbdc12c3355041b407a5 100644 (file)
--- a/drivers/net/mlx4/main.c
+++ b/drivers/net/mlx4/main.c
@@ -1076,7 +1076,7 @@ static int __mlx4_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
 
        pci_set_master(pdev);
 
-       err = pci_set_dma_mask(pdev, DMA_64BIT_MASK);
+       err = pci_set_dma_mask(pdev, DMA_BIT_MASK(64));
        if (err) {
                dev_warn(&pdev->dev, "Warning: couldn't set 64-bit PCI DMA mask.\n");
                err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
@@ -1085,7 +1085,7 @@ static int __mlx4_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
                        goto err_release_bar2;
                }
        }
-       err = pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK);
+       err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
        if (err) {
                dev_warn(&pdev->dev, "Warning: couldn't set 64-bit "
                         "consistent PCI DMA mask.\n");

diff --git a/drivers/net/myri10ge/myri10ge.c b/drivers/net/myri10ge/myri10ge.c
index aea9fdaa3cd50db7e9ba983bf7174f0b302eb0f1..27655466dbebf77a5f326108e8142228fa5acaac 100644 (file)
--- a/drivers/net/myri10ge/myri10ge.c
+++ b/drivers/net/myri10ge/myri10ge.c
@@ -3792,7 +3792,7 @@ static int myri10ge_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 
        pci_set_master(pdev);
        dac_enabled = 1;
-       status = pci_set_dma_mask(pdev, DMA_64BIT_MASK);
+       status = pci_set_dma_mask(pdev, DMA_BIT_MASK(64));
        if (status != 0) {
                dac_enabled = 0;
                dev_err(&pdev->dev,
@@ -3804,7 +3804,7 @@ static int myri10ge_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                dev_err(&pdev->dev, "Error %d setting DMA mask\n", status);
                goto abort_with_enabled;
        }
-       (void)pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK);
+       (void)pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
        mgp->cmd = dma_alloc_coherent(&pdev->dev, sizeof(*mgp->cmd),
                                      &mgp->cmd_bus, GFP_KERNEL);
        if (mgp->cmd == NULL)

diff --git a/drivers/net/ns83820.c b/drivers/net/ns83820.c
index 221b0c4c824a36bdb3e0ea1ece9e0e5497517a01..e30ab06e71037ae964d50de349c27b51d9a17123 100644 (file)
--- a/drivers/net/ns83820.c
+++ b/drivers/net/ns83820.c
@@ -1973,7 +1973,7 @@ static int __devinit ns83820_init_one(struct pci_dev *pci_dev,
 
        /* See if we can set the dma mask early on; failure is fatal. */
        if (sizeof(dma_addr_t) == 8 &&
-               !pci_set_dma_mask(pci_dev, DMA_64BIT_MASK)) {
+               !pci_set_dma_mask(pci_dev, DMA_BIT_MASK(64))) {
                using_dac = 1;
        } else if (!pci_set_dma_mask(pci_dev, DMA_32BIT_MASK)) {
                using_dac = 0;

diff --git a/drivers/net/qla3xxx.c b/drivers/net/qla3xxx.c
index 8b2823c8dccfafaf97b3b8c9f698cb25386d34c4..aef047e4515ac1fd8ad4a734bb409b46902b3fd4 100644 (file)
--- a/drivers/net/qla3xxx.c
+++ b/drivers/net/qla3xxx.c
@@ -3934,9 +3934,9 @@ static int __devinit ql3xxx_probe(struct pci_dev *pdev,
 
        pci_set_master(pdev);
 
-       if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK)) {
+       if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) {
                pci_using_dac = 1;
-               err = pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK);
+               err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
        } else if (!(err = pci_set_dma_mask(pdev, DMA_32BIT_MASK))) {
                pci_using_dac = 0;
                err = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);

diff --git a/drivers/net/qlge/qlge_main.c b/drivers/net/qlge/qlge_main.c
index 170d3540f9c9fb7185d66c9c0af5ce872a3f66e5..0add30d38d625625d995a41ae28de6bf594581a0 100644 (file)
--- a/drivers/net/qlge/qlge_main.c
+++ b/drivers/net/qlge/qlge_main.c
@@ -3726,9 +3726,9 @@ static int __devinit ql_init_device(struct pci_dev *pdev,
        }
 
        pci_set_master(pdev);
-       if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK)) {
+       if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) {
                set_bit(QL_DMA64, &qdev->flags);
-               err = pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK);
+               err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
        } else {
                err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
                if (!err)

diff --git a/drivers/net/r8169.c b/drivers/net/r8169.c
index e1a638a05f8621d15cfb74c6f15806bc33323fe8..fe676d38d34274a4e61554b80ce7a4261530cc74 100644 (file)
--- a/drivers/net/r8169.c
+++ b/drivers/net/r8169.c
@@ -2046,7 +2046,7 @@ rtl8169_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
        tp->cp_cmd = PCIMulRW | RxChkSum;
 
        if ((sizeof(dma_addr_t) > 4) &&
-           !pci_set_dma_mask(pdev, DMA_64BIT_MASK) && use_dac) {
+           !pci_set_dma_mask(pdev, DMA_BIT_MASK(64)) && use_dac) {
                tp->cp_cmd |= PCIDAC;
                dev->features |= NETIF_F_HIGHDMA;
        } else {

diff --git a/drivers/net/s2io.c b/drivers/net/s2io.c
index 16868b7a5d0aad2146b203200298d945947a631d..7c8d5613a1da6482b45acb98e7880aa491c53268 100644 (file)
--- a/drivers/net/s2io.c
+++ b/drivers/net/s2io.c
@@ -7775,11 +7775,11 @@ s2io_init_nic(struct pci_dev *pdev, const struct pci_device_id *pre)
                return ret;
        }
 
-       if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK)) {
+       if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) {
                DBG_PRINT(INIT_DBG, "s2io_init_nic: Using 64bit DMA\n");
                dma_flag = TRUE;
                if (pci_set_consistent_dma_mask
-                   (pdev, DMA_64BIT_MASK)) {
+                   (pdev, DMA_BIT_MASK(64))) {
                        DBG_PRINT(ERR_DBG,
                                  "Unable to obtain 64bit DMA for \
                                        consistent allocations\n");

diff --git a/drivers/net/skge.c b/drivers/net/skge.c
index 952d37ffee51f8de796a20b650b946678ca5e333..18a7b662aff1c1345f90d2a5546791be2ca6e12a 100644 (file)
--- a/drivers/net/skge.c
+++ b/drivers/net/skge.c
@@ -3912,9 +3912,9 @@ static int __devinit skge_probe(struct pci_dev *pdev,
 
        pci_set_master(pdev);
 
-       if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK)) {
+       if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) {
                using_dac = 1;
-               err = pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK);
+               err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
        } else if (!(err = pci_set_dma_mask(pdev, DMA_32BIT_MASK))) {
                using_dac = 0;
                err = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);

diff --git a/drivers/net/sky2.c b/drivers/net/sky2.c
index d01c56eb962759e511cf269a27d4952e85e15cfc..da570f44b12ba4c78910715f64d81c8a0e8b78d1 100644 (file)
--- a/drivers/net/sky2.c
+++ b/drivers/net/sky2.c
@@ -4374,9 +4374,9 @@ static int __devinit sky2_probe(struct pci_dev *pdev,
        pci_set_master(pdev);
 
        if (sizeof(dma_addr_t) > sizeof(u32) &&
-           !(err = pci_set_dma_mask(pdev, DMA_64BIT_MASK))) {
+           !(err = pci_set_dma_mask(pdev, DMA_BIT_MASK(64)))) {
                using_dac = 1;
-               err = pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK);
+               err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
                if (err < 0) {
                        dev_err(&pdev->dev, "unable to obtain 64 bit DMA "
                                "for consistent allocations\n");

diff --git a/drivers/net/sungem.c b/drivers/net/sungem.c
index c024352c92fd24facec33736b5d9305272e931dc..2312d10f3b54647d01267f046132d1b0707b3293 100644 (file)
--- a/drivers/net/sungem.c
+++ b/drivers/net/sungem.c
@@ -3042,7 +3042,7 @@ static int __devinit gem_init_one(struct pci_dev *pdev,
         */
        if (pdev->vendor == PCI_VENDOR_ID_SUN &&
            pdev->device == PCI_DEVICE_ID_SUN_GEM &&
-           !pci_set_dma_mask(pdev, DMA_64BIT_MASK)) {
+           !pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) {
                pci_using_dac = 1;
        } else {
                err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);

diff --git a/drivers/net/tehuti.c b/drivers/net/tehuti.c
index 7debd1e4e1f7d8c2ef18b3de5ee38d91e931c152..d77a0918a325f63218468f5b81950be5f43247e2 100644 (file)
--- a/drivers/net/tehuti.c
+++ b/drivers/net/tehuti.c
@@ -1941,8 +1941,8 @@ bdx_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
        if ((err = pci_enable_device(pdev)))    /* it trigers interrupt, dunno why. */
                goto err_pci;                   /* it's not a problem though */
 
-       if (!(err = pci_set_dma_mask(pdev, DMA_64BIT_MASK)) &&
-           !(err = pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK))) {
+       if (!(err = pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) &&
+           !(err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)))) {
                pci_using_dac = 1;
        } else {
                if ((err = pci_set_dma_mask(pdev, DMA_32BIT_MASK)) ||

diff --git a/drivers/net/tehuti.h b/drivers/net/tehuti.h
index dec67e0a9ca2b491a5a1636acb6eb4f4efe28bf3..121dda917fdc1850797c1464e07ee82edf335bda 100644 (file)
--- a/drivers/net/tehuti.h
+++ b/drivers/net/tehuti.h
@@ -31,6 +31,7 @@
 #include <linux/vmalloc.h>
 #include <linux/firmware.h>
 #include <asm/byteorder.h>
+#include <linux/dma-mapping.h>
 
 /* Compile Time Switches */
 /* start */
@@ -98,10 +99,6 @@
 #define READ_REG(pp, reg)         readl(pp->pBdxRegs + reg)
 #define WRITE_REG(pp, reg, val)   writel(val, pp->pBdxRegs + reg)
 
-#ifndef DMA_64BIT_MASK
-#   define DMA_64BIT_MASK  0xffffffffffffffffULL
-#endif
-
 #ifndef DMA_32BIT_MASK
 #   define DMA_32BIT_MASK  0x00000000ffffffffULL
 #endif

diff --git a/drivers/net/tg3.c b/drivers/net/tg3.c
index 437683aab32c8dab18a91fe92b5ae0741bfed03a..ec32e5f2354876c0501079780bad76f6e27c6771 100644 (file)
--- a/drivers/net/tg3.c
+++ b/drivers/net/tg3.c
@@ -13232,10 +13232,10 @@ static int __devinit tg3_init_one(struct pci_dev *pdev,
        else if (tp->tg3_flags & TG3_FLAG_40BIT_DMA_BUG) {
                persist_dma_mask = dma_mask = DMA_40BIT_MASK;
 #ifdef CONFIG_HIGHMEM
-               dma_mask = DMA_64BIT_MASK;
+               dma_mask = DMA_BIT_MASK(64);
 #endif
        } else
-               persist_dma_mask = dma_mask = DMA_64BIT_MASK;
+               persist_dma_mask = dma_mask = DMA_BIT_MASK(64);
 
        /* Configure DMA attributes. */
        if (dma_mask > DMA_32BIT_MASK) {

diff --git a/drivers/net/usb/usbnet.c b/drivers/net/usb/usbnet.c
index 659654f458806b36eeab21a8f84bb4aa450c0af2..f3a2fce6166ccebc68dc6650e9b7ac8ed6fb4be4 100644 (file)
--- a/drivers/net/usb/usbnet.c
+++ b/drivers/net/usb/usbnet.c
@@ -1180,7 +1180,7 @@ usbnet_probe (struct usb_interface *udev, const struct usb_device_id *prod)
 #if 0
 // dma_supported() is deeply broken on almost all architectures
        // possible with some EHCI controllers
-       if (dma_supported (&udev->dev, DMA_64BIT_MASK))
+       if (dma_supported (&udev->dev, DMA_BIT_MASK(64)))
                net->features |= NETIF_F_HIGHDMA;
 #endif
 

diff --git a/drivers/net/wireless/b43/dma.c b/drivers/net/wireless/b43/dma.c
index 0cc804d0a214fcad833c7dcdbd2afd6e7451aee3..461d680d2cec4355591ef797f5c42323658100dc 100644 (file)
--- a/drivers/net/wireless/b43/dma.c
+++ b/drivers/net/wireless/b43/dma.c
@@ -772,7 +772,7 @@ static u64 supported_dma_mask(struct b43_wldev *dev)
 
        tmp = b43_read32(dev, SSB_TMSHIGH);
        if (tmp & SSB_TMSHIGH_DMA64)
-               return DMA_64BIT_MASK;
+               return DMA_BIT_MASK(64);
        mmio_base = b43_dmacontroller_base(0, 0);
        b43_write32(dev, mmio_base + B43_DMA32_TXCTL, B43_DMA32_TXADDREXT_MASK);
        tmp = b43_read32(dev, mmio_base + B43_DMA32_TXCTL);
@@ -788,7 +788,7 @@ static enum b43_dmatype dma_mask_to_engine_type(u64 dmamask)
                return B43_DMA_30BIT;
        if (dmamask == DMA_32BIT_MASK)
                return B43_DMA_32BIT;
-       if (dmamask == DMA_64BIT_MASK)
+       if (dmamask == DMA_BIT_MASK(64))
                return B43_DMA_64BIT;
        B43_WARN_ON(1);
        return B43_DMA_30BIT;
@@ -999,7 +999,7 @@ static int b43_dma_set_mask(struct b43_wldev *dev, u64 mask)
                err = ssb_dma_set_mask(dev->dev, mask);
                if (!err)
                        break;
-               if (mask == DMA_64BIT_MASK) {
+               if (mask == DMA_BIT_MASK(64)) {
                        mask = DMA_32BIT_MASK;
                        fallback = 1;
                        continue;

diff --git a/drivers/net/wireless/b43legacy/dma.c b/drivers/net/wireless/b43legacy/dma.c
index 3649fc3670988219cd99185fc3acfbec6e162b3e..61bb91266aa874a2834bcd87a87f6958f3840bf3 100644 (file)
--- a/drivers/net/wireless/b43legacy/dma.c
+++ b/drivers/net/wireless/b43legacy/dma.c
@@ -846,7 +846,7 @@ static u64 supported_dma_mask(struct b43legacy_wldev *dev)
 
        tmp = b43legacy_read32(dev, SSB_TMSHIGH);
        if (tmp & SSB_TMSHIGH_DMA64)
-               return DMA_64BIT_MASK;
+               return DMA_BIT_MASK(64);
        mmio_base = b43legacy_dmacontroller_base(0, 0);
        b43legacy_write32(dev,
                        mmio_base + B43legacy_DMA32_TXCTL,
@@ -865,7 +865,7 @@ static enum b43legacy_dmatype dma_mask_to_engine_type(u64 dmamask)
                return B43legacy_DMA_30BIT;
        if (dmamask == DMA_32BIT_MASK)
                return B43legacy_DMA_32BIT;
-       if (dmamask == DMA_64BIT_MASK)
+       if (dmamask == DMA_BIT_MASK(64))
                return B43legacy_DMA_64BIT;
        B43legacy_WARN_ON(1);
        return B43legacy_DMA_30BIT;
@@ -1042,7 +1042,7 @@ static int b43legacy_dma_set_mask(struct b43legacy_wldev *dev, u64 mask)
                err = ssb_dma_set_mask(dev->dev, mask);
                if (!err)
                        break;
-               if (mask == DMA_64BIT_MASK) {
+               if (mask == DMA_BIT_MASK(64)) {
                        mask = DMA_32BIT_MASK;
                        fallback = 1;
                        continue;

diff --git a/drivers/pci/intel-iommu.c b/drivers/pci/intel-iommu.c
index dcda5212f3bb9b2540ff04bc6b8ef8e1a8e4f0f5..09dc98b84553bd9bd7e17357ac404ed0abd85208 100644 (file)
--- a/drivers/pci/intel-iommu.c
+++ b/drivers/pci/intel-iommu.c
@@ -57,7 +57,7 @@
 
 #define IOVA_PFN(addr)         ((addr) >> PAGE_SHIFT)
 #define DMA_32BIT_PFN          IOVA_PFN(DMA_32BIT_MASK)
-#define DMA_64BIT_PFN          IOVA_PFN(DMA_64BIT_MASK)
+#define DMA_64BIT_PFN          IOVA_PFN(DMA_BIT_MASK(64))
 
 /* global iommu list, set NULL for ignored DMAR units */
 static struct intel_iommu **g_iommus;

diff --git a/drivers/scsi/3w-9xxx.c b/drivers/scsi/3w-9xxx.c
index a12783ebb42d39a829c0a3d1c24c5c87222af302..6697652740b8dfbd8a35a3aadf7dbf9d595d8c03 100644 (file)
--- a/drivers/scsi/3w-9xxx.c
+++ b/drivers/scsi/3w-9xxx.c
@@ -2016,8 +2016,8 @@ static int __devinit twa_probe(struct pci_dev *pdev, const struct pci_device_id
        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_BIT_MASK(64))
+           || pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)))
                if (pci_set_dma_mask(pdev, DMA_32BIT_MASK)
                    || pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK)) {
                        TW_PRINTK(host, TW_DRIVER, 0x23, "Failed to set dma mask");

diff --git a/drivers/scsi/aacraid/aachba.c b/drivers/scsi/aacraid/aachba.c
index 21964aaebca5b502552cc698dbb966a39ed8ad46..e83ef8aaa98c8d808ed1f5c81619e8075772cc61 100644 (file)
--- a/drivers/scsi/aacraid/aachba.c
+++ b/drivers/scsi/aacraid/aachba.c
@@ -1402,8 +1402,8 @@ int aac_get_adapter_info(struct aac_dev* dev)
        }
 
        if(dev->dac_support != 0) {
-               if (!pci_set_dma_mask(dev->pdev, DMA_64BIT_MASK) &&
-                       !pci_set_consistent_dma_mask(dev->pdev, DMA_64BIT_MASK)) {
+               if (!pci_set_dma_mask(dev->pdev, DMA_BIT_MASK(64)) &&
+                       !pci_set_consistent_dma_mask(dev->pdev, DMA_BIT_MASK(64))) {
                        if (!dev->in_reset)
                                printk(KERN_INFO"%s%d: 64 Bit DAC enabled\n",
                                        dev->name, dev->id);

diff --git a/drivers/scsi/aic7xxx/aic79xx_osm_pci.c b/drivers/scsi/aic7xxx/aic79xx_osm_pci.c
index 6593056867f6d33b9ac472b49f19ff56d9dcd96f..032e2b120b32aa2727e3a3676e4e2515f3d09cfd 100644 (file)
--- a/drivers/scsi/aic7xxx/aic79xx_osm_pci.c
+++ b/drivers/scsi/aic7xxx/aic79xx_osm_pci.c
@@ -195,7 +195,7 @@ ahd_linux_pci_dev_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                const u64 required_mask = dma_get_required_mask(dev);
 
                if (required_mask > DMA_39BIT_MASK &&
-                   dma_set_mask(dev, DMA_64BIT_MASK) == 0)
+                   dma_set_mask(dev, DMA_BIT_MASK(64)) == 0)
                        ahd->flags |= AHD_64BIT_ADDRESSING;
                else if (required_mask > DMA_32BIT_MASK &&
                         dma_set_mask(dev, DMA_39BIT_MASK) == 0)

diff --git a/drivers/scsi/aic94xx/aic94xx_init.c b/drivers/scsi/aic94xx/aic94xx_init.c
index 2a730c470f6265abf3d1add4bf77bb8eb4280b96..7edbe4309c614cf347a003c8920b4190340b7b9a 100644 (file)
--- a/drivers/scsi/aic94xx/aic94xx_init.c
+++ b/drivers/scsi/aic94xx/aic94xx_init.c
@@ -790,8 +790,8 @@ static int __devinit asd_pci_probe(struct pci_dev *dev,
                goto Err_remove;
 
        err = -ENODEV;
-       if (!pci_set_dma_mask(dev, DMA_64BIT_MASK)
-           && !pci_set_consistent_dma_mask(dev, DMA_64BIT_MASK))
+       if (!pci_set_dma_mask(dev, DMA_BIT_MASK(64))
+           && !pci_set_consistent_dma_mask(dev, DMA_BIT_MASK(64)))
                ;
        else if (!pci_set_dma_mask(dev, DMA_32BIT_MASK)
                 && !pci_set_consistent_dma_mask(dev, DMA_32BIT_MASK))

diff --git a/drivers/scsi/arcmsr/arcmsr_hba.c b/drivers/scsi/arcmsr/arcmsr_hba.c
index 106c04d2d79374e68578c9abfdaf33231ebef3c0..e95b72dd34b11641d0c52e4c8ac44799c3e4e93b 100644 (file)
--- a/drivers/scsi/arcmsr/arcmsr_hba.c
+++ b/drivers/scsi/arcmsr/arcmsr_hba.c
@@ -393,7 +393,7 @@ static int arcmsr_probe(struct pci_dev *pdev,
        acb = (struct AdapterControlBlock *)host->hostdata;
        memset(acb, 0, sizeof (struct AdapterControlBlock));
 
-       error = pci_set_dma_mask(pdev, DMA_64BIT_MASK);
+       error = pci_set_dma_mask(pdev, DMA_BIT_MASK(64));
        if (error) {
                error = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
                if (error) {

diff --git a/drivers/scsi/dpt_i2o.c b/drivers/scsi/dpt_i2o.c
index 6194ed5d02c4e694bc2bfbe3faf9a56860a2ade5..75a94e438fa580a5f974461ccb6e59121c456d99 100644 (file)
--- a/drivers/scsi/dpt_i2o.c
+++ b/drivers/scsi/dpt_i2o.c
@@ -1014,7 +1014,7 @@ static int adpt_install_hba(struct scsi_host_template* sht, struct pci_dev* pDev
         *      See if we should enable dma64 mode.
         */
        if (sizeof(dma_addr_t) > 4 &&
-           pci_set_dma_mask(pDev, DMA_64BIT_MASK) == 0) {
+           pci_set_dma_mask(pDev, DMA_BIT_MASK(64)) == 0) {
                if (dma_get_required_mask(&pDev->dev) > DMA_32BIT_MASK)
                        dma64 = 1;
        }

diff --git a/drivers/scsi/gdth.c b/drivers/scsi/gdth.c
index fb247fdfa2bd51d91ea567918d51cd3e818371a9..4982344f1f097c748b0fbda3241482aa23988f89 100644 (file)
--- a/drivers/scsi/gdth.c
+++ b/drivers/scsi/gdth.c
@@ -5030,7 +5030,7 @@ static int __devinit gdth_pci_probe_one(gdth_pci_str *pcistr,
                }
        } else {
                shp->max_cmd_len = 16;
-               if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK)) {
+               if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) {
                        printk("GDT-PCI %d: 64-bit DMA enabled\n", ha->hanum);
                } else if (pci_set_dma_mask(pdev, DMA_32BIT_MASK)) {
                        printk(KERN_WARNING "GDT-PCI %d: "

diff --git a/drivers/scsi/hptiop.c b/drivers/scsi/hptiop.c
index af1f0af0c5acb96e7d6f87aad3a7ba4989db161e..a13d78150cb509c22754b0a56b1398e26382ea18 100644 (file)
--- a/drivers/scsi/hptiop.c
+++ b/drivers/scsi/hptiop.c
@@ -958,7 +958,7 @@ static int __devinit hptiop_probe(struct pci_dev *pcidev,
        pci_set_master(pcidev);
 
        /* Enable 64bit DMA if possible */
-       if (pci_set_dma_mask(pcidev, DMA_64BIT_MASK)) {
+       if (pci_set_dma_mask(pcidev, DMA_BIT_MASK(64))) {
                if (pci_set_dma_mask(pcidev, DMA_32BIT_MASK)) {
                        printk(KERN_ERR "hptiop: fail to set dma_mask\n");
                        goto disable_pci_device;

diff --git a/drivers/scsi/ips.c b/drivers/scsi/ips.c
index 457d76a4cfe5e18c8c448c42e41101ad90d9acce..45296a975f8be63136786e795a051b88ccc741c5 100644 (file)
--- a/drivers/scsi/ips.c
+++ b/drivers/scsi/ips.c
@@ -7048,7 +7048,7 @@ ips_init_phase1(struct pci_dev *pci_dev, int *indexPtr)
         * are guaranteed to be < 4G.
         */
        if (IPS_ENABLE_DMA64 && IPS_HAS_ENH_SGLIST(ha) &&
-           !pci_set_dma_mask(ha->pcidev, DMA_64BIT_MASK)) {
+           !pci_set_dma_mask(ha->pcidev, DMA_BIT_MASK(64))) {
                (ha)->flags |= IPS_HA_ENH_SG;
        } else {
                if (pci_set_dma_mask(ha->pcidev, DMA_32BIT_MASK) != 0) {

diff --git a/drivers/scsi/lpfc/lpfc_init.c b/drivers/scsi/lpfc/lpfc_init.c
index 6c867311cef1d295a8f7e39b2b1b7c43107f4202..c255b4d94b1b944bb7365a58bd3252cdce8ff86b 100644 (file)
--- a/drivers/scsi/lpfc/lpfc_init.c
+++ b/drivers/scsi/lpfc/lpfc_init.c
@@ -2660,7 +2660,7 @@ lpfc_pci_probe_one(struct pci_dev *pdev, const struct pci_device_id *pid)
        pci_save_state(pdev);
        pci_try_set_mwi(pdev);
 
-       if (pci_set_dma_mask(phba->pcidev, DMA_64BIT_MASK) != 0)
+       if (pci_set_dma_mask(phba->pcidev, DMA_BIT_MASK(64)) != 0)
                if (pci_set_dma_mask(phba->pcidev, DMA_32BIT_MASK) != 0)
                        goto out_idr_remove;
 

diff --git a/drivers/scsi/megaraid.c b/drivers/scsi/megaraid.c
index 9fdcd60c5493a53aee595a10eb3b47819c40c157..112991d46d95d6398adcff7a20c87b420da65bce 100644 (file)
--- a/drivers/scsi/megaraid.c
+++ b/drivers/scsi/megaraid.c
@@ -4793,7 +4793,7 @@ megaraid_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
 
        /* Set the Mode of addressing to 64 bit if we can */
        if ((adapter->flag & BOARD_64BIT) && (sizeof(dma_addr_t) == 8)) {
-               pci_set_dma_mask(pdev, DMA_64BIT_MASK);
+               pci_set_dma_mask(pdev, DMA_BIT_MASK(64));
                adapter->has_64bit_addr = 1;
        } else  {
                pci_set_dma_mask(pdev, DMA_32BIT_MASK);

diff --git a/drivers/scsi/megaraid/megaraid_mbox.c b/drivers/scsi/megaraid/megaraid_mbox.c
index 805bb61dde1871946b5c4cce24c0314e7efa79e5..b2c19449119dd43ac527b4547c5175f6cd290f08 100644 (file)
--- a/drivers/scsi/megaraid/megaraid_mbox.c
+++ b/drivers/scsi/megaraid/megaraid_mbox.c
@@ -900,7 +900,7 @@ megaraid_init_mbox(adapter_t *adapter)
                adapter->pdev->device == PCI_DEVICE_ID_PERC4_DI_EVERGLADES) ||
                (adapter->pdev->vendor == PCI_VENDOR_ID_DELL &&
                adapter->pdev->device == PCI_DEVICE_ID_PERC4E_DI_KOBUK)) {
-               if (pci_set_dma_mask(adapter->pdev, DMA_64BIT_MASK)) {
+               if (pci_set_dma_mask(adapter->pdev, DMA_BIT_MASK(64))) {
                        con_log(CL_ANN, (KERN_WARNING
                                "megaraid: DMA mask for 64-bit failed\n"));
 

diff --git a/drivers/scsi/megaraid/megaraid_sas.c b/drivers/scsi/megaraid/megaraid_sas.c
index 17ce7abe17ee02f7ea47055d296f95917b6e1b92..713de85771f3baa6747b4488f80719348d12c291 100644 (file)
--- a/drivers/scsi/megaraid/megaraid_sas.c
+++ b/drivers/scsi/megaraid/megaraid_sas.c
@@ -2497,7 +2497,7 @@ megasas_set_dma_mask(struct pci_dev *pdev)
         * All our contollers are capable of performing 64-bit DMA
         */
        if (IS_DMA64) {
-               if (pci_set_dma_mask(pdev, DMA_64BIT_MASK) != 0) {
+               if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64)) != 0) {
 
                        if (pci_set_dma_mask(pdev, DMA_32BIT_MASK) != 0)
                                goto fail_set_dma_mask;

diff --git a/drivers/scsi/mvsas.c b/drivers/scsi/mvsas.c
index 23e5a876bb10c01ee16f591a5f2bee93b4f2f90c..d8093a2884388cf088e3a95599b3273e96eb4b4a 100644 (file)
--- a/drivers/scsi/mvsas.c
+++ b/drivers/scsi/mvsas.c
@@ -875,8 +875,8 @@ static int pci_go_64(struct pci_dev *pdev)
 {
        int rc;
 
-       if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK)) {
-               rc = pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK);
+       if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) {
+               rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
                if (rc) {
                        rc = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
                        if (rc) {

diff --git a/drivers/scsi/qla1280.c b/drivers/scsi/qla1280.c
index 351b56ced925f8476a71d839a4ba48fb3836f196..18f7f98ba571ee88b6b1e35ba2d5e38dff42b5be 100644 (file)
--- a/drivers/scsi/qla1280.c
+++ b/drivers/scsi/qla1280.c
@@ -4275,7 +4275,7 @@ qla1280_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
        ha->devnum = devnum;    /* specifies microcode load address */
 
 #ifdef QLA_64BIT_PTR
-       if (pci_set_dma_mask(ha->pdev, DMA_64BIT_MASK)) {
+       if (pci_set_dma_mask(ha->pdev, DMA_BIT_MASK(64))) {
                if (pci_set_dma_mask(ha->pdev, DMA_32BIT_MASK)) {
                        printk(KERN_WARNING "scsi(%li): Unable to set a "
                               "suitable DMA mask - aborting\n", ha->host_no);

diff --git a/drivers/scsi/qla2xxx/qla_os.c b/drivers/scsi/qla2xxx/qla_os.c
index efe29924e058669bafe576ef711aa557ad2fb190..f60e136b5e1b5bd30ed5c8e9d91911bcf84468cf 100644 (file)
--- a/drivers/scsi/qla2xxx/qla_os.c
+++ b/drivers/scsi/qla2xxx/qla_os.c
@@ -1176,10 +1176,10 @@ qla2x00_config_dma_addressing(struct qla_hw_data *ha)
        /* Assume a 32bit DMA mask. */
        ha->flags.enable_64bit_addressing = 0;
 
-       if (!dma_set_mask(&ha->pdev->dev, DMA_64BIT_MASK)) {
+       if (!dma_set_mask(&ha->pdev->dev, DMA_BIT_MASK(64))) {
                /* Any upper-dword bits set? */
                if (MSD(dma_get_required_mask(&ha->pdev->dev)) &&
-                   !pci_set_consistent_dma_mask(ha->pdev, DMA_64BIT_MASK)) {
+                   !pci_set_consistent_dma_mask(ha->pdev, DMA_BIT_MASK(64))) {
                        /* Ok, a 64bit DMA mask is applicable. */
                        ha->flags.enable_64bit_addressing = 1;
                        ha->isp_ops->calc_req_entries = qla2x00_calc_iocbs_64;

diff --git a/drivers/scsi/qla4xxx/ql4_os.c b/drivers/scsi/qla4xxx/ql4_os.c
index eb3a414b189a111f8110385440c0911300085210..d427fab7a183a89fb1d17f881444d24053eb3f5e 100644 (file)
--- a/drivers/scsi/qla4xxx/ql4_os.c
+++ b/drivers/scsi/qla4xxx/ql4_os.c
@@ -1369,8 +1369,8 @@ static void qla4xxx_config_dma_addressing(struct scsi_qla_host *ha)
        int retval;
 
        /* Update our PCI device dma_mask for full 64 bit mask */
-       if (pci_set_dma_mask(ha->pdev, DMA_64BIT_MASK) == 0) {
-               if (pci_set_consistent_dma_mask(ha->pdev, DMA_64BIT_MASK)) {
+       if (pci_set_dma_mask(ha->pdev, DMA_BIT_MASK(64)) == 0) {
+               if (pci_set_consistent_dma_mask(ha->pdev, DMA_BIT_MASK(64))) {
                        dev_dbg(&ha->pdev->dev,
                                  "Failed to set 64 bit PCI consistent mask; "
                                   "using 32 bit.\n");

diff --git a/drivers/scsi/stex.c b/drivers/scsi/stex.c
index df7f96caa1ca3f36f9fd3e63736a7ff486e1256b..7cb8063c43554d435acb44d64684c6944c842327 100644 (file)
--- a/drivers/scsi/stex.c
+++ b/drivers/scsi/stex.c
@@ -1395,8 +1395,8 @@ static int stex_set_dma_mask(struct pci_dev * pdev)
 {
        int ret;
 
-       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_BIT_MASK(64))
+               && !pci_set_consistent_dma_mask(pdev,  DMA_BIT_MASK(64)))
                return 0;
        ret = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
        if (!ret)

diff --git a/drivers/scsi/sym53c8xx_2/sym_hipd.h b/drivers/scsi/sym53c8xx_2/sym_hipd.h
index 1588c90518d4137dd3988d23149d0e900a0b75b7..76f6295ee8812672397de8dce7cba7249c88cb66 100644 (file)
--- a/drivers/scsi/sym53c8xx_2/sym_hipd.h
+++ b/drivers/scsi/sym53c8xx_2/sym_hipd.h
@@ -1094,7 +1094,7 @@ do {                                                                      \
        (data)->size = cpu_to_scr((((badd) >> 8) & 0xff000000) + len);  \
 } while (0)
 #elif SYM_CONF_DMA_ADDRESSING_MODE == 2
-#define DMA_DAC_MASK   DMA_64BIT_MASK
+#define DMA_DAC_MASK   DMA_BIT_MASK(64)
 int sym_lookup_dmap(struct sym_hcb *np, u32 h, int s);
 static inline void
 sym_build_sge(struct sym_hcb *np, struct sym_tblmove *data, u64 badd, int len)

diff --git a/drivers/sn/ioc3.c b/drivers/sn/ioc3.c
index a0aa33dde0a43dc36b1acbae9f9f22da5c39c065..816d4c592a3ca6d609e4c9481ad2e4ef2ee05a9c 100644 (file)
--- a/drivers/sn/ioc3.c
+++ b/drivers/sn/ioc3.c
@@ -617,9 +617,9 @@ static int ioc3_probe(struct pci_dev *pdev, const struct pci_device_id *pci_id)
        pci_set_master(pdev);
 
 #ifdef USE_64BIT_DMA
-        ret = pci_set_dma_mask(pdev, DMA_64BIT_MASK);
+        ret = pci_set_dma_mask(pdev, DMA_BIT_MASK(64));
         if (!ret) {
-                ret = pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK);
+                ret = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
                 if (ret < 0) {
                         printk(KERN_WARNING "%s: Unable to obtain 64 bit DMA "
                                "for consistent allocations\n",

diff --git a/drivers/staging/altpciechdma/altpciechdma.c b/drivers/staging/altpciechdma/altpciechdma.c
index 3e41e0861481a033d983e4681814a51a32c922b9..6a4d0b8e09607d33a5aff530b65f757e2b83a5a9 100644 (file)
--- a/drivers/staging/altpciechdma/altpciechdma.c
+++ b/drivers/staging/altpciechdma/altpciechdma.c
@@ -849,8 +849,8 @@ static int __devinit probe(struct pci_dev *dev, const struct pci_device_id *id)
 #if 1   /* @todo For now, disable 64-bit, because I do not understand the implications (DAC!) */
        /* query for DMA transfer */
        /* @see Documentation/PCI/PCI-DMA-mapping.txt */
-       if (!pci_set_dma_mask(dev, DMA_64BIT_MASK)) {
-               pci_set_consistent_dma_mask(dev, DMA_64BIT_MASK);
+       if (!pci_set_dma_mask(dev, DMA_BIT_MASK(64))) {
+               pci_set_consistent_dma_mask(dev, DMA_BIT_MASK(64));
                /* use 64-bit DMA */
                printk(KERN_DEBUG "Using a 64-bit DMA mask.\n");
        } else

diff --git a/drivers/staging/slicoss/slicoss.c b/drivers/staging/slicoss/slicoss.c
index 953684f729da2db0d18bff065ce30ff415a9b6a5..94815634847872885b40a744a2e09662489249ba 100644 (file)
--- a/drivers/staging/slicoss/slicoss.c
+++ b/drivers/staging/slicoss/slicoss.c
@@ -371,9 +371,9 @@ static int __devinit slic_entry_probe(struct pci_dev *pcidev,
                printk(KERN_DEBUG "%s\n", slic_proc_version);
        }
 
-       err = pci_set_dma_mask(pcidev, DMA_64BIT_MASK);
+       err = pci_set_dma_mask(pcidev, DMA_BIT_MASK(64));
        if (err) {
-               err = pci_set_dma_mask(pcidev, DMA_32BIT_MASK);
+               err = pci_set_dma_mask(pcidev, DMA_BIT_MASK(32));
                if (err)
                        goto err_out_disable_pci;
        }

diff --git a/drivers/staging/sxg/sxg.c b/drivers/staging/sxg/sxg.c
index 0050a022010f1344c12716ee34b9caa393846943..a77e1eee56934984c684e33a4dacc7a4bd418849 100644 (file)
--- a/drivers/staging/sxg/sxg.c
+++ b/drivers/staging/sxg/sxg.c
@@ -934,8 +934,8 @@ static int sxg_entry_probe(struct pci_dev *pcidev,
 
        pci_read_config_byte(pcidev, PCI_REVISION_ID, &revision_id);
 
-       if (!(err = pci_set_dma_mask(pcidev, DMA_64BIT_MASK))) {
-               DBG_ERROR("pci_set_dma_mask(DMA_64BIT_MASK) successful\n");
+       if (!(err = pci_set_dma_mask(pcidev, DMA_BIT_MASK(64)))) {
+               DBG_ERROR("pci_set_dma_mask(DMA_BIT_MASK(64)) successful\n");
        } else {
                if ((err = pci_set_dma_mask(pcidev, DMA_32BIT_MASK))) {
                        DBG_ERROR

diff --git a/drivers/usb/host/ehci-hcd.c b/drivers/usb/host/ehci-hcd.c
index f2618d17710d248938632cee6278a2a3bb690a8b..c637207a1c80b63eab4bfa5587d4250bfe0d3c86 100644 (file)
--- a/drivers/usb/host/ehci-hcd.c
+++ b/drivers/usb/host/ehci-hcd.c
@@ -622,7 +622,7 @@ static int ehci_run (struct usb_hcd *hcd)
                ehci_writel(ehci, 0, &ehci->regs->segment);
 #if 0
 // this is deeply broken on almost all architectures
-               if (!dma_set_mask(hcd->self.controller, DMA_64BIT_MASK))
+               if (!dma_set_mask(hcd->self.controller, DMA_BIT_MASK(64)))
                        ehci_info(ehci, "enabled 64bit DMA\n");
 #endif
        }

diff --git a/drivers/uwb/whci.c b/drivers/uwb/whci.c
index 1f8964ed98825914d9b68ebde4a1345dac33a18e..79bb06c7a76b8dcd50a7e198fd393e2f19f3d95e 100644 (file)
--- a/drivers/uwb/whci.c
+++ b/drivers/uwb/whci.c
@@ -160,8 +160,8 @@ static int whci_probe(struct pci_dev *pci, const struct pci_device_id *id)
        pci_enable_msi(pci);
        pci_set_master(pci);
        err = -ENXIO;
-       if (!pci_set_dma_mask(pci, DMA_64BIT_MASK))
-               pci_set_consistent_dma_mask(pci, DMA_64BIT_MASK);
+       if (!pci_set_dma_mask(pci, DMA_BIT_MASK(64)))
+               pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(64));
        else if (!pci_set_dma_mask(pci, DMA_32BIT_MASK))
                pci_set_consistent_dma_mask(pci, DMA_32BIT_MASK);
        else