dma-mapping: replace all DMA_32BIT_MASK macro with DMA_BIT_MASK(32)
authorYang Hongyang <yanghy@cn.fujitsu.com>
Tue, 7 Apr 2009 02:01:15 +0000 (19:01 -0700)
committerLinus Torvalds <torvalds@linux-foundation.org>
Tue, 7 Apr 2009 15:31:11 +0000 (08:31 -0700)
Replace all DMA_32BIT_MASK macro with DMA_BIT_MASK(32)

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>
173 files changed:
arch/arm/mach-davinci/board-evm.c
arch/arm/mach-davinci/usb.c
arch/arm/mach-kirkwood/common.c
arch/arm/mach-orion5x/common.c
arch/arm/plat-iop/adma.c
arch/avr32/boards/hammerhead/flash.c
arch/avr32/mach-at32ap/at32ap700x.c
arch/ia64/kernel/pci-dma.c
arch/mips/alchemy/common/platform.c
arch/mips/alchemy/devboards/pb1200/platform.c
arch/mips/nxp/pnx833x/common/platform.c
arch/mips/nxp/pnx8550/common/platform.c
arch/mips/pmc-sierra/msp71xx/msp_usb.c
arch/powerpc/kernel/dma.c
arch/powerpc/kernel/of_platform.c
arch/powerpc/platforms/iseries/iommu.c
arch/powerpc/platforms/ps3/system-bus.c
arch/x86/include/asm/dma-mapping.h
arch/x86/kernel/pci-dma.c
arch/x86/kernel/pci-nommu.c
drivers/ata/ahci.c
drivers/ata/pata_cs5520.c
drivers/ata/pata_ixp4xx_cf.c
drivers/ata/pdc_adma.c
drivers/ata/sata_inic162x.c
drivers/ata/sata_mv.c
drivers/ata/sata_qstor.c
drivers/ata/sata_sil24.c
drivers/ata/sata_vsc.c
drivers/atm/he.c
drivers/atm/lanai.c
drivers/block/DAC960.c
drivers/block/cciss.c
drivers/block/sx8.c
drivers/block/umem.c
drivers/crypto/hifn_795x.c
drivers/crypto/ixp4xx_crypto.c
drivers/dma/ioat.c
drivers/firmware/dcdbas.c
drivers/ide/cs5520.c
drivers/ide/setup-pci.c
drivers/ieee1394/pcilynx.c
drivers/infiniband/hw/amso1100/c2.c
drivers/infiniband/hw/ipath/ipath_driver.c
drivers/infiniband/hw/mthca/mthca_main.c
drivers/infiniband/hw/nes/nes.c
drivers/media/dvb/dm1105/dm1105.c
drivers/media/dvb/pluto2/pluto2.c
drivers/media/video/bt8xx/bttv-driver.c
drivers/media/video/cx88/cx88-alsa.c
drivers/media/video/cx88/cx88-mpeg.c
drivers/media/video/cx88/cx88-video.c
drivers/media/video/meye.c
drivers/media/video/saa7134/saa7134-core.c
drivers/memstick/host/jmb38x_ms.c
drivers/message/fusion/mptbase.c
drivers/message/i2o/memory.c
drivers/message/i2o/pci.c
drivers/misc/tifm_7xx1.c
drivers/mmc/host/sdhci-pci.c
drivers/net/8139cp.c
drivers/net/acenic.c
drivers/net/amd8111e.c
drivers/net/atl1e/atl1e_main.c
drivers/net/atlx/atl1.c
drivers/net/atlx/atl2.c
drivers/net/bnx2.c
drivers/net/bnx2x_main.c
drivers/net/cassini.c
drivers/net/chelsio/cxgb2.c
drivers/net/cxgb3/cxgb3_main.c
drivers/net/e100.c
drivers/net/e1000/e1000_main.c
drivers/net/e1000e/netdev.c
drivers/net/enic/enic_main.c
drivers/net/hp100.c
drivers/net/igb/igb_main.c
drivers/net/ioc3-eth.c
drivers/net/ipg.c
drivers/net/ixgb/ixgb_main.c
drivers/net/ixgbe/ixgbe_main.c
drivers/net/jme.c
drivers/net/mlx4/main.c
drivers/net/myri10ge/myri10ge.c
drivers/net/niu.c
drivers/net/ns83820.c
drivers/net/qla3xxx.c
drivers/net/qlge/qlge_main.c
drivers/net/r6040.c
drivers/net/r8169.c
drivers/net/s2io.c
drivers/net/sc92031.c
drivers/net/sis190.c
drivers/net/sis900.c
drivers/net/skge.c
drivers/net/sky2.c
drivers/net/smsc9420.c
drivers/net/sungem.c
drivers/net/tehuti.c
drivers/net/tehuti.h
drivers/net/tg3.c
drivers/net/tlan.c
drivers/net/tokenring/lanstreamer.c
drivers/net/tulip/dmfe.c
drivers/net/tulip/uli526x.c
drivers/net/tulip/winbond-840.c
drivers/net/typhoon.c
drivers/net/via-rhine.c
drivers/net/wan/wanxl.c
drivers/net/wireless/adm8211.c
drivers/net/wireless/ath5k/base.c
drivers/net/wireless/b43/dma.c
drivers/net/wireless/b43legacy/dma.c
drivers/net/wireless/ipw2x00/ipw2100.c
drivers/net/wireless/ipw2x00/ipw2200.c
drivers/net/wireless/iwlwifi/iwl3945-base.c
drivers/net/wireless/prism54/islpci_hotplug.c
drivers/net/wireless/rt2x00/rt2x00pci.c
drivers/pci/intel-iommu.c
drivers/rapidio/rio-scan.c
drivers/scsi/3w-9xxx.c
drivers/scsi/3w-xxxx.h
drivers/scsi/BusLogic.c
drivers/scsi/a100u2w.c
drivers/scsi/aacraid/aachba.c
drivers/scsi/aacraid/commsup.c
drivers/scsi/aacraid/linit.c
drivers/scsi/aic7xxx/aic79xx_osm_pci.c
drivers/scsi/aic7xxx/aic7xxx_osm_pci.c
drivers/scsi/aic94xx/aic94xx_init.c
drivers/scsi/arcmsr/arcmsr_hba.c
drivers/scsi/atp870u.c
drivers/scsi/dpt_i2o.c
drivers/scsi/eata.c
drivers/scsi/gdth.c
drivers/scsi/hptiop.c
drivers/scsi/initio.c
drivers/scsi/ipr.c
drivers/scsi/ips.c
drivers/scsi/lasi700.c
drivers/scsi/lpfc/lpfc_init.c
drivers/scsi/megaraid.c
drivers/scsi/megaraid/megaraid_mbox.c
drivers/scsi/megaraid/megaraid_sas.c
drivers/scsi/mvsas.c
drivers/scsi/nsp32.c
drivers/scsi/qla1280.c
drivers/scsi/qla2xxx/qla_os.c
drivers/scsi/qla4xxx/ql4_os.c
drivers/scsi/sni_53c710.c
drivers/scsi/stex.c
drivers/scsi/sym53c8xx_2/sym_glue.c
drivers/scsi/sym53c8xx_2/sym_hipd.h
drivers/staging/agnx/pci.c
drivers/staging/altpciechdma/altpciechdma.c
drivers/staging/sxg/sxg.c
drivers/usb/host/ehci-ps3.c
drivers/usb/host/ohci-ps3.c
drivers/uwb/whci.c
include/linux/dma-mapping.h
lib/swiotlb.c
sound/pci/ad1889.c
sound/pci/au88x0/au88x0.c
sound/pci/aw2/aw2-alsa.c
sound/pci/ca0106/ca0106_main.c
sound/pci/cs5535audio/cs5535audio.c
sound/pci/mixart/mixart.c
sound/pci/pcxhr/pcxhr.c
sound/soc/blackfin/bf5xx-ac97-pcm.c
sound/soc/blackfin/bf5xx-i2s-pcm.c
sound/soc/omap/omap-pcm.c
sound/soc/pxa/pxa2xx-pcm.c
sound/soc/s3c24xx/s3c24xx-pcm.c

index 38b6a9ce2a93cc8caecaa2d471e30c3198ce4421..0b97a528902b34d81ac93968e60fcf4ea10acd30 100644 (file)
@@ -118,7 +118,7 @@ static struct resource ide_resources[] = {
        },
 };
 
-static u64 ide_dma_mask = DMA_32BIT_MASK;
+static u64 ide_dma_mask = DMA_BIT_MASK(32);
 
 static struct platform_device ide_dev = {
        .name           = "palm_bk3710",
@@ -127,7 +127,7 @@ static struct platform_device ide_dev = {
        .num_resources  = ARRAY_SIZE(ide_resources),
        .dev = {
                .dma_mask               = &ide_dma_mask,
-               .coherent_dma_mask      = DMA_32BIT_MASK,
+               .coherent_dma_mask      = DMA_BIT_MASK(32),
        },
 };
 
index 69680784448a20a259f96ef059e2c4c375b0ea17..2429b79f6da2edf38926dd360dd6d72211f1ee1f 100644 (file)
@@ -64,7 +64,7 @@ static struct resource usb_resources[] = {
        },
 };
 
-static u64 usb_dmamask = DMA_32BIT_MASK;
+static u64 usb_dmamask = DMA_BIT_MASK(32);
 
 static struct platform_device usb_dev = {
        .name           = "musb_hdrc",
@@ -72,7 +72,7 @@ static struct platform_device usb_dev = {
        .dev = {
                .platform_data          = &usb_data,
                .dma_mask               = &usb_dmamask,
-               .coherent_dma_mask      = DMA_32BIT_MASK,
+               .coherent_dma_mask      = DMA_BIT_MASK(32),
        },
        .resource       = usb_resources,
        .num_resources  = ARRAY_SIZE(usb_resources),
index c691848714d92e81dfc2905cf3ef9fb7a4259a99..16dc9ea0839398ea3c040bc636a991842fbba6cb 100644 (file)
@@ -508,7 +508,7 @@ static struct mv_xor_platform_shared_data kirkwood_xor_shared_data = {
        .dram           = &kirkwood_mbus_dram_info,
 };
 
-static u64 kirkwood_xor_dmamask = DMA_32BIT_MASK;
+static u64 kirkwood_xor_dmamask = DMA_BIT_MASK(32);
 
 
 /*****************************************************************************
index e8d42e8cb46585f9f1cf5abcc18ae928b37a4b1b..6af99ddabdfb92e0159ba96252654549dc04b9ce 100644 (file)
@@ -463,7 +463,7 @@ static struct platform_device orion5x_xor_shared = {
        .resource       = orion5x_xor_shared_resources,
 };
 
-static u64 orion5x_xor_dmamask = DMA_32BIT_MASK;
+static u64 orion5x_xor_dmamask = DMA_BIT_MASK(32);
 
 static struct resource orion5x_xor0_resources[] = {
        [0] = {
index a2a94f6d2e7c1e5780f2e05e25e983e8bc9dec74..3c127aabe214e4bb8d7a2ff00c37061836a88cff 100644 (file)
@@ -119,7 +119,7 @@ static struct resource iop3xx_aau_resources[] = {
        }
 };
 
-static u64 iop3xx_adma_dmamask = DMA_32BIT_MASK;
+static u64 iop3xx_adma_dmamask = DMA_BIT_MASK(32);
 
 static struct iop_adma_platform_data iop3xx_dma_0_data = {
        .hw_id = DMA0_ID,
index 559bbcb03f9b696cb0589d649a803c8356772668..776c3cb9b6e410cfd7299149d49e667b8cb5f2b6 100644 (file)
@@ -280,13 +280,13 @@ static struct resource hh_fpga0_resource[] = {
        },
 };
 
-static u64 hh_fpga0_dma_mask = DMA_32BIT_MASK;
+static u64 hh_fpga0_dma_mask = DMA_BIT_MASK(32);
 static struct platform_device hh_fpga0_device = {
        .name           = "hh_fpga",
        .id             = 0,
        .dev            = {
                .dma_mask = &hh_fpga0_dma_mask,
-               .coherent_dma_mask = DMA_32BIT_MASK,
+               .coherent_dma_mask = DMA_BIT_MASK(32),
        },
        .resource       = hh_fpga0_resource,
        .num_resources  = ARRAY_SIZE(hh_fpga0_resource),
index 7cc6537983275d1bea9c6a183619e37a9c8392cc..eb9d4dc2e86dff84df6cc0905505d1efb97cfb59 100644 (file)
  * don't ... tc, smc, pio, rtc, watchdog, pwm, ps2, and more.
  */
 #define DEFINE_DEV(_name, _id)                                 \
-static u64 _name##_id##_dma_mask = DMA_32BIT_MASK;             \
+static u64 _name##_id##_dma_mask = DMA_BIT_MASK(32);           \
 static struct platform_device _name##_id##_device = {          \
        .name           = #_name,                               \
        .id             = _id,                                  \
        .dev            = {                                     \
                .dma_mask = &_name##_id##_dma_mask,             \
-               .coherent_dma_mask = DMA_32BIT_MASK,            \
+               .coherent_dma_mask = DMA_BIT_MASK(32),          \
        },                                                      \
        .resource       = _name##_id##_resource,                \
        .num_resources  = ARRAY_SIZE(_name##_id##_resource),    \
 }
 #define DEFINE_DEV_DATA(_name, _id)                            \
-static u64 _name##_id##_dma_mask = DMA_32BIT_MASK;             \
+static u64 _name##_id##_dma_mask = DMA_BIT_MASK(32);           \
 static struct platform_device _name##_id##_device = {          \
        .name           = #_name,                               \
        .id             = _id,                                  \
        .dev            = {                                     \
                .dma_mask = &_name##_id##_dma_mask,             \
                .platform_data  = &_name##_id##_data,           \
-               .coherent_dma_mask = DMA_32BIT_MASK,            \
+               .coherent_dma_mask = DMA_BIT_MASK(32),          \
        },                                                      \
        .resource       = _name##_id##_resource,                \
        .num_resources  = ARRAY_SIZE(_name##_id##_resource),    \
index 8f34f3ddb83b77b2a69d77a1c4a4776237f4fb8e..f82b0ee6bb1f8ea0d3f052428dfb834f980d103b 100644 (file)
@@ -37,7 +37,7 @@ int force_iommu __read_mostly;
    to i386. */
 struct device fallback_dev = {
        .init_name = "fallback device",
-       .coherent_dma_mask = DMA_32BIT_MASK,
+       .coherent_dma_mask = DMA_BIT_MASK(32),
        .dma_mask = &fallback_dev.coherent_dma_mask,
 };
 
index 5c76c6448e04c41d9c82e5e3eec4544f5f218f02..117f99f70649547f137a4442021444b2e8ef73fd 100644 (file)
@@ -80,14 +80,14 @@ static struct resource au1xxx_usb_ohci_resources[] = {
 };
 
 /* The dmamask must be set for OHCI to work */
-static u64 ohci_dmamask = DMA_32BIT_MASK;
+static u64 ohci_dmamask = DMA_BIT_MASK(32);
 
 static struct platform_device au1xxx_usb_ohci_device = {
        .name           = "au1xxx-ohci",
        .id             = 0,
        .dev = {
                .dma_mask               = &ohci_dmamask,
-               .coherent_dma_mask      = DMA_32BIT_MASK,
+               .coherent_dma_mask      = DMA_BIT_MASK(32),
        },
        .num_resources  = ARRAY_SIZE(au1xxx_usb_ohci_resources),
        .resource       = au1xxx_usb_ohci_resources,
@@ -109,14 +109,14 @@ static struct resource au1100_lcd_resources[] = {
        }
 };
 
-static u64 au1100_lcd_dmamask = DMA_32BIT_MASK;
+static u64 au1100_lcd_dmamask = DMA_BIT_MASK(32);
 
 static struct platform_device au1100_lcd_device = {
        .name           = "au1100-lcd",
        .id             = 0,
        .dev = {
                .dma_mask               = &au1100_lcd_dmamask,
-               .coherent_dma_mask      = DMA_32BIT_MASK,
+               .coherent_dma_mask      = DMA_BIT_MASK(32),
        },
        .num_resources  = ARRAY_SIZE(au1100_lcd_resources),
        .resource       = au1100_lcd_resources,
@@ -138,14 +138,14 @@ static struct resource au1xxx_usb_ehci_resources[] = {
        },
 };
 
-static u64 ehci_dmamask = DMA_32BIT_MASK;
+static u64 ehci_dmamask = DMA_BIT_MASK(32);
 
 static struct platform_device au1xxx_usb_ehci_device = {
        .name           = "au1xxx-ehci",
        .id             = 0,
        .dev = {
                .dma_mask               = &ehci_dmamask,
-               .coherent_dma_mask      = DMA_32BIT_MASK,
+               .coherent_dma_mask      = DMA_BIT_MASK(32),
        },
        .num_resources  = ARRAY_SIZE(au1xxx_usb_ehci_resources),
        .resource       = au1xxx_usb_ehci_resources,
@@ -165,14 +165,14 @@ static struct resource au1xxx_usb_gdt_resources[] = {
        },
 };
 
-static u64 udc_dmamask = DMA_32BIT_MASK;
+static u64 udc_dmamask = DMA_BIT_MASK(32);
 
 static struct platform_device au1xxx_usb_gdt_device = {
        .name           = "au1xxx-udc",
        .id             = 0,
        .dev = {
                .dma_mask               = &udc_dmamask,
-               .coherent_dma_mask      = DMA_32BIT_MASK,
+               .coherent_dma_mask      = DMA_BIT_MASK(32),
        },
        .num_resources  = ARRAY_SIZE(au1xxx_usb_gdt_resources),
        .resource       = au1xxx_usb_gdt_resources,
@@ -192,14 +192,14 @@ static struct resource au1xxx_usb_otg_resources[] = {
        },
 };
 
-static u64 uoc_dmamask = DMA_32BIT_MASK;
+static u64 uoc_dmamask = DMA_BIT_MASK(32);
 
 static struct platform_device au1xxx_usb_otg_device = {
        .name           = "au1xxx-uoc",
        .id             = 0,
        .dev = {
                .dma_mask               = &uoc_dmamask,
-               .coherent_dma_mask      = DMA_32BIT_MASK,
+               .coherent_dma_mask      = DMA_BIT_MASK(32),
        },
        .num_resources  = ARRAY_SIZE(au1xxx_usb_otg_resources),
        .resource       = au1xxx_usb_otg_resources,
@@ -218,20 +218,20 @@ static struct resource au1200_lcd_resources[] = {
        }
 };
 
-static u64 au1200_lcd_dmamask = DMA_32BIT_MASK;
+static u64 au1200_lcd_dmamask = DMA_BIT_MASK(32);
 
 static struct platform_device au1200_lcd_device = {
        .name           = "au1200-lcd",
        .id             = 0,
        .dev = {
                .dma_mask               = &au1200_lcd_dmamask,
-               .coherent_dma_mask      = DMA_32BIT_MASK,
+               .coherent_dma_mask      = DMA_BIT_MASK(32),
        },
        .num_resources  = ARRAY_SIZE(au1200_lcd_resources),
        .resource       = au1200_lcd_resources,
 };
 
-static u64 au1xxx_mmc_dmamask =  DMA_32BIT_MASK;
+static u64 au1xxx_mmc_dmamask =  DMA_BIT_MASK(32);
 
 extern struct au1xmmc_platform_data au1xmmc_platdata[2];
 
@@ -263,7 +263,7 @@ static struct platform_device au1200_mmc0_device = {
        .id = 0,
        .dev = {
                .dma_mask               = &au1xxx_mmc_dmamask,
-               .coherent_dma_mask      = DMA_32BIT_MASK,
+               .coherent_dma_mask      = DMA_BIT_MASK(32),
                .platform_data          = &au1xmmc_platdata[0],
        },
        .num_resources  = ARRAY_SIZE(au1200_mmc0_resources),
@@ -299,7 +299,7 @@ static struct platform_device au1200_mmc1_device = {
        .id = 1,
        .dev = {
                .dma_mask               = &au1xxx_mmc_dmamask,
-               .coherent_dma_mask      = DMA_32BIT_MASK,
+               .coherent_dma_mask      = DMA_BIT_MASK(32),
                .platform_data          = &au1xmmc_platdata[1],
        },
        .num_resources  = ARRAY_SIZE(au1200_mmc1_resources),
index 0d68e1985ffd15d2ca62b67280600fd4c088b150..b93dff4a6789ca4e5c054a42302e640b619e9f69 100644 (file)
@@ -119,14 +119,14 @@ static struct resource ide_resources[] = {
        }
 };
 
-static u64 ide_dmamask = DMA_32BIT_MASK;
+static u64 ide_dmamask = DMA_BIT_MASK(32);
 
 static struct platform_device ide_device = {
        .name           = "au1200-ide",
        .id             = 0,
        .dev = {
                .dma_mask               = &ide_dmamask,
-               .coherent_dma_mask      = DMA_32BIT_MASK,
+               .coherent_dma_mask      = DMA_BIT_MASK(32),
        },
        .num_resources  = ARRAY_SIZE(ide_resources),
        .resource       = ide_resources
index b1ccbcc18f783aea6697d734677493d9f9231278..01f8345a2069d0fcf129b98f1c08ddd97b055b1c 100644 (file)
@@ -42,7 +42,7 @@
 #include <irq-mapping.h>
 #include <pnx833x.h>
 
-static u64 uart_dmamask     = DMA_32BIT_MASK;
+static u64 uart_dmamask     = DMA_BIT_MASK(32);
 
 static struct resource pnx833x_uart_resources[] = {
        [0] = {
@@ -101,14 +101,14 @@ static struct platform_device pnx833x_uart_device = {
        .id             = -1,
        .dev = {
                .dma_mask               = &uart_dmamask,
-               .coherent_dma_mask      = DMA_32BIT_MASK,
+               .coherent_dma_mask      = DMA_BIT_MASK(32),
                .platform_data          = pnx8xxx_ports,
        },
        .num_resources  = ARRAY_SIZE(pnx833x_uart_resources),
        .resource       = pnx833x_uart_resources,
 };
 
-static u64 ehci_dmamask     = DMA_32BIT_MASK;
+static u64 ehci_dmamask     = DMA_BIT_MASK(32);
 
 static struct resource pnx833x_usb_ehci_resources[] = {
        [0] = {
@@ -128,7 +128,7 @@ static struct platform_device pnx833x_usb_ehci_device = {
        .id             = -1,
        .dev = {
                .dma_mask               = &ehci_dmamask,
-               .coherent_dma_mask      = DMA_32BIT_MASK,
+               .coherent_dma_mask      = DMA_BIT_MASK(32),
        },
        .num_resources  = ARRAY_SIZE(pnx833x_usb_ehci_resources),
        .resource       = pnx833x_usb_ehci_resources,
@@ -198,7 +198,7 @@ static struct platform_device pnx833x_i2c1_device = {
 };
 #endif
 
-static u64 ethernet_dmamask = DMA_32BIT_MASK;
+static u64 ethernet_dmamask = DMA_BIT_MASK(32);
 
 static struct resource pnx833x_ethernet_resources[] = {
        [0] = {
@@ -218,7 +218,7 @@ static struct platform_device pnx833x_ethernet_device = {
        .id   = -1,
        .dev  = {
                .dma_mask          = &ethernet_dmamask,
-               .coherent_dma_mask = DMA_32BIT_MASK,
+               .coherent_dma_mask = DMA_BIT_MASK(32),
        },
        .num_resources = ARRAY_SIZE(pnx833x_ethernet_resources),
        .resource      = pnx833x_ethernet_resources,
index 21d2955359b3d97dfaee1094e1ce9dad9cb493f6..5264cc09a27bacbe2057ca7a66e50645a3eefd04 100644 (file)
@@ -92,16 +92,16 @@ struct pnx8xxx_port pnx8xxx_ports[] = {
 };
 
 /* The dmamask must be set for OHCI to work */
-static u64 ohci_dmamask = DMA_32BIT_MASK;
+static u64 ohci_dmamask = DMA_BIT_MASK(32);
 
-static u64 uart_dmamask = DMA_32BIT_MASK;
+static u64 uart_dmamask = DMA_BIT_MASK(32);
 
 static struct platform_device pnx8550_usb_ohci_device = {
        .name           = "pnx8550-ohci",
        .id             = -1,
        .dev = {
                .dma_mask               = &ohci_dmamask,
-               .coherent_dma_mask      = DMA_32BIT_MASK,
+               .coherent_dma_mask      = DMA_BIT_MASK(32),
        },
        .num_resources  = ARRAY_SIZE(pnx8550_usb_ohci_resources),
        .resource       = pnx8550_usb_ohci_resources,
@@ -112,7 +112,7 @@ static struct platform_device pnx8550_uart_device = {
        .id             = -1,
        .dev = {
                .dma_mask               = &uart_dmamask,
-               .coherent_dma_mask      = DMA_32BIT_MASK,
+               .coherent_dma_mask      = DMA_BIT_MASK(32),
                .platform_data = pnx8xxx_ports,
        },
        .num_resources  = ARRAY_SIZE(pnx8550_uart_resources),
index f7ca4f58233168ea3a2e9fd84dfa208f2fbaa596..0ee01e359dd8aa4f0a1fcaa20d3fb0c05709cbde 100644 (file)
@@ -49,14 +49,14 @@ static struct resource msp_usbhost_resources [] = {
        },
 };
 
-static u64 msp_usbhost_dma_mask = DMA_32BIT_MASK;
+static u64 msp_usbhost_dma_mask = DMA_BIT_MASK(32);
 
 static struct platform_device msp_usbhost_device = {
        .name   = "pmcmsp-ehci",
        .id     = 0,
        .dev    = {
                .dma_mask = &msp_usbhost_dma_mask,
-               .coherent_dma_mask = DMA_32BIT_MASK,
+               .coherent_dma_mask = DMA_BIT_MASK(32),
        },
        .num_resources  = ARRAY_SIZE(msp_usbhost_resources),
        .resource       = msp_usbhost_resources,
@@ -77,14 +77,14 @@ static struct resource msp_usbdev_resources [] = {
        },
 };
 
-static u64 msp_usbdev_dma_mask = DMA_32BIT_MASK;
+static u64 msp_usbdev_dma_mask = DMA_BIT_MASK(32);
 
 static struct platform_device msp_usbdev_device = {
        .name   = "msp71xx_udc",
        .id     = 0,
        .dev    = {
                .dma_mask = &msp_usbdev_dma_mask,
-               .coherent_dma_mask = DMA_32BIT_MASK,
+               .coherent_dma_mask = DMA_BIT_MASK(32),
        },
        .num_resources  = ARRAY_SIZE(msp_usbdev_resources),
        .resource       = msp_usbdev_resources,
index 1c5c8a6fc129ff825bd1b4cb4da985e15ba85707..53c7788cba78d2978002e2edc5d03027f459e974 100644 (file)
@@ -94,7 +94,7 @@ static int dma_direct_dma_supported(struct device *dev, u64 mask)
         * done via some global so platforms can set the limit in case
         * they have limited DMA windows
         */
-       return mask >= DMA_32BIT_MASK;
+       return mask >= DMA_BIT_MASK(32);
 #else
        return 1;
 #endif
index 3f37a6e6277163d715b9d1b2988984fed19c789a..87df428e35880f1da99b2a40e6a3276e1f0a4f70 100644 (file)
@@ -76,7 +76,7 @@ struct of_device* of_platform_device_create(struct device_node *np,
                return NULL;
 
        dev->dma_mask = 0xffffffffUL;
-       dev->dev.coherent_dma_mask = DMA_32BIT_MASK;
+       dev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
 
        dev->dev.bus = &of_platform_bus_type;
 
index 6ed75bffc8ab55d089faec045c04607d7ed8efde..ff43f1fd8343519d027f5abe3c138f4471fefe39 100644 (file)
@@ -202,7 +202,7 @@ static struct iommu_table vio_iommu_table;
 void *iseries_hv_alloc(size_t size, dma_addr_t *dma_handle, gfp_t flag)
 {
        return iommu_alloc_coherent(NULL, &vio_iommu_table, size, dma_handle,
-                               DMA_32BIT_MASK, flag, -1);
+                               DMA_BIT_MASK(32), flag, -1);
 }
 EXPORT_SYMBOL_GPL(iseries_hv_alloc);
 
@@ -217,7 +217,7 @@ dma_addr_t iseries_hv_map(void *vaddr, size_t size,
 {
        return iommu_map_page(NULL, &vio_iommu_table, virt_to_page(vaddr),
                              (unsigned long)vaddr % PAGE_SIZE, size,
-                             DMA_32BIT_MASK, direction, NULL);
+                             DMA_BIT_MASK(32), direction, NULL);
 }
 
 void iseries_hv_unmap(dma_addr_t dma_handle, size_t size,
index a705fffbb498e3ec8c14f56c33f3e48b065ddca1..9a73d0238639307cd2f1f16d5352def20aa27e86 100644 (file)
@@ -689,7 +689,7 @@ static void ps3_ioc0_unmap_sg(struct device *_dev, struct scatterlist *sg,
 
 static int ps3_dma_supported(struct device *_dev, u64 mask)
 {
-       return mask >= DMA_32BIT_MASK;
+       return mask >= DMA_BIT_MASK(32);
 }
 
 static struct dma_mapping_ops ps3_sb_dma_ops = {
index cea7b74963e9758e9338c7c739c02bb53e9d63e2..10a6be94eb77325f429b7a4005eb52e6b56e5498 100644 (file)
@@ -238,7 +238,7 @@ static inline unsigned long dma_alloc_coherent_mask(struct device *dev,
 
        dma_mask = dev->coherent_dma_mask;
        if (!dma_mask)
-               dma_mask = (gfp & GFP_DMA) ? DMA_24BIT_MASK : DMA_32BIT_MASK;
+               dma_mask = (gfp & GFP_DMA) ? DMA_24BIT_MASK : DMA_BIT_MASK(32);
 
        return dma_mask;
 }
@@ -250,7 +250,7 @@ static inline gfp_t dma_alloc_coherent_gfp_flags(struct device *dev, gfp_t gfp)
        if (dma_mask <= DMA_24BIT_MASK)
                gfp |= GFP_DMA;
 #ifdef CONFIG_X86_64
-       if (dma_mask <= DMA_32BIT_MASK && !(gfp & GFP_DMA))
+       if (dma_mask <= DMA_BIT_MASK(32) && !(gfp & GFP_DMA))
                gfp |= GFP_DMA32;
 #endif
        return gfp;
index 0cf2d900422bd28000be0d721db0f5e700262f7f..136a01d52db011bb5492730fb04f0aef5c505477 100644 (file)
@@ -40,7 +40,7 @@ EXPORT_SYMBOL(bad_dma_address);
    to older i386. */
 struct device x86_dma_fallback_dev = {
        .init_name = "fallback device",
-       .coherent_dma_mask = DMA_32BIT_MASK,
+       .coherent_dma_mask = DMA_BIT_MASK(32),
        .dma_mask = &x86_dma_fallback_dev.coherent_dma_mask,
 };
 EXPORT_SYMBOL(x86_dma_fallback_dev);
@@ -148,7 +148,7 @@ again:
        if (!is_buffer_dma_capable(dma_mask, addr, size)) {
                __free_pages(page, get_order(size));
 
-               if (dma_mask < DMA_32BIT_MASK && !(flag & GFP_DMA)) {
+               if (dma_mask < DMA_BIT_MASK(32) && !(flag & GFP_DMA)) {
                        flag = (flag & ~GFP_DMA32) | GFP_DMA;
                        goto again;
                }
index c6d703b393261c2e5f45002b188b4d56638bc530..71d412a09f30ea2f529bd9a07cbd8b8d74072772 100644 (file)
@@ -15,7 +15,7 @@ static int
 check_addr(char *name, struct device *hwdev, dma_addr_t bus, size_t size)
 {
        if (hwdev && !is_buffer_dma_capable(*hwdev->dma_mask, bus, size)) {
-               if (*hwdev->dma_mask >= DMA_32BIT_MASK)
+               if (*hwdev->dma_mask >= DMA_BIT_MASK(32))
                        printk(KERN_ERR
                            "nommu_%s: overflow %Lx+%zu of device mask %Lx\n",
                                name, (long long)bus, size,
index 207d775c3c27c325f318bbe52842e2ae9b31d39c..f75dac57dc2be16e1453bada8f27b81326b499cb 100644 (file)
@@ -2408,7 +2408,7 @@ static int ahci_configure_dma_masks(struct pci_dev *pdev, int using_dac)
            !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);
+                       rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
                        if (rc) {
                                dev_printk(KERN_ERR, &pdev->dev,
                                           "64-bit DMA enable failed\n");
@@ -2416,13 +2416,13 @@ static int ahci_configure_dma_masks(struct pci_dev *pdev, int using_dac)
                        }
                }
        } else {
-               rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
+               rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
                if (rc) {
                        dev_printk(KERN_ERR, &pdev->dev,
                                   "32-bit DMA enable failed\n");
                        return rc;
                }
-               rc = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
+               rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
                if (rc) {
                        dev_printk(KERN_ERR, &pdev->dev,
                                   "32-bit consistent DMA enable failed\n");
index db6a96984f3fbbfcdce793191d16d1e42a74981e..0df83cf742337d4d481822e2d705b3a1802196aa 100644 (file)
@@ -203,11 +203,11 @@ static int __devinit cs5520_init_one(struct pci_dev *pdev, const struct pci_devi
                return -ENODEV;
        }
 
-       if (pci_set_dma_mask(pdev, DMA_32BIT_MASK)) {
+       if (pci_set_dma_mask(pdev, 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_32BIT_MASK)) {
+       if (pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32))) {
                printk(KERN_ERR DRV_NAME ": unable to configure consistent DMA mask.\n");
                return -ENODEV;
        }
index 19fdecf319a662f3de793a12501dd424fdec3011..ba54b089f98c799edbaf4a8848d5b9ed072406e2 100644 (file)
@@ -157,7 +157,7 @@ static __devinit int ixp4xx_pata_probe(struct platform_device *pdev)
                return -ENOMEM;
 
        /* acquire resources and fill host */
-       pdev->dev.coherent_dma_mask = DMA_32BIT_MASK;
+       pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
 
        data->cs0 = devm_ioremap(&pdev->dev, cs0->start, 0x1000);
        data->cs1 = devm_ioremap(&pdev->dev, cs1->start, 0x1000);
index 39588178d028d5e3780cd38bc766bed78c3df185..6c65b0776a2cc900c6b97dd437a458cc7fd125ed 100644 (file)
@@ -607,13 +607,13 @@ static int adma_set_dma_masks(struct pci_dev *pdev, void __iomem *mmio_base)
 {
        int rc;
 
-       rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
+       rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
        if (rc) {
                dev_printk(KERN_ERR, &pdev->dev,
                        "32-bit DMA enable failed\n");
                return rc;
        }
-       rc = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
+       rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
        if (rc) {
                dev_printk(KERN_ERR, &pdev->dev,
                        "32-bit consistent DMA enable failed\n");
index 305a4f825f538ce8eaafd7a861971330081a0bb2..8d890cc5a7ee06fb273daeed1739c7113c5896ba 100644 (file)
@@ -861,14 +861,14 @@ 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_32BIT_MASK);
+       rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
        if (rc) {
                dev_printk(KERN_ERR, &pdev->dev,
                           "32-bit DMA enable failed\n");
                return rc;
        }
 
-       rc = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
+       rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
        if (rc) {
                dev_printk(KERN_ERR, &pdev->dev,
                           "32-bit consistent DMA enable failed\n");
index 45e0fe191afc3a45e9e95db5eb8762e1c286234b..5af3ea19d3c5feec73ff754d97f02dcf5683e988 100644 (file)
@@ -3916,7 +3916,7 @@ static int pci_go_64(struct pci_dev *pdev)
        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);
+                       rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
                        if (rc) {
                                dev_printk(KERN_ERR, &pdev->dev,
                                           "64-bit DMA enable failed\n");
@@ -3924,13 +3924,13 @@ static int pci_go_64(struct pci_dev *pdev)
                        }
                }
        } else {
-               rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
+               rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
                if (rc) {
                        dev_printk(KERN_ERR, &pdev->dev,
                                   "32-bit DMA enable failed\n");
                        return rc;
                }
-               rc = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
+               rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
                if (rc) {
                        dev_printk(KERN_ERR, &pdev->dev,
                                   "32-bit consistent DMA enable failed\n");
index 7b37c27d7972c9c08a03defa49dc65c3d27bd21d..326c0cfc29b34c366c146ea0c2a6c128d5f7f2f4 100644 (file)
@@ -587,7 +587,7 @@ static int qs_set_dma_masks(struct pci_dev *pdev, void __iomem *mmio_base)
            !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);
+                       rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
                        if (rc) {
                                dev_printk(KERN_ERR, &pdev->dev,
                                           "64-bit DMA enable failed\n");
@@ -595,13 +595,13 @@ static int qs_set_dma_masks(struct pci_dev *pdev, void __iomem *mmio_base)
                        }
                }
        } else {
-               rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
+               rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
                if (rc) {
                        dev_printk(KERN_ERR, &pdev->dev,
                                "32-bit DMA enable failed\n");
                        return rc;
                }
-               rc = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
+               rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
                if (rc) {
                        dev_printk(KERN_ERR, &pdev->dev,
                                "32-bit consistent DMA enable failed\n");
index 37730bc2f09ff5142af87401d927961f8109fc65..77aa8d7ecec47488369d968e32379ae8373c82ee 100644 (file)
@@ -1300,7 +1300,7 @@ static int sil24_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
        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);
+                       rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
                        if (rc) {
                                dev_printk(KERN_ERR, &pdev->dev,
                                           "64-bit DMA enable failed\n");
@@ -1308,13 +1308,13 @@ static int sil24_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
                        }
                }
        } else {
-               rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
+               rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
                if (rc) {
                        dev_printk(KERN_ERR, &pdev->dev,
                                   "32-bit DMA enable failed\n");
                        return rc;
                }
-               rc = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
+               rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
                if (rc) {
                        dev_printk(KERN_ERR, &pdev->dev,
                                   "32-bit consistent DMA enable failed\n");
index ed70bd28fa2cb558371170642c238f3236f99f13..8b2a278b25471af9427b8e32f705c2e3d8c01304 100644 (file)
@@ -399,10 +399,10 @@ static int __devinit 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_32BIT_MASK);
+       rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
        if (rc)
                return rc;
-       rc = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
+       rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
        if (rc)
                return rc;
 
index bdbad7edf682b847b48231df7b042a1e364f8e66..2de64065aa1b203b113f62e8428319f140b0b382 100644 (file)
@@ -358,7 +358,7 @@ he_init_one(struct pci_dev *pci_dev, const struct pci_device_id *pci_ent)
 
        if (pci_enable_device(pci_dev))
                return -EIO;
-       if (pci_set_dma_mask(pci_dev, DMA_32BIT_MASK) != 0) {
+       if (pci_set_dma_mask(pci_dev, DMA_BIT_MASK(32)) != 0) {
                printk(KERN_WARNING "he: no suitable dma available\n");
                err = -EIO;
                goto init_one_failure;
index 8733a2ea04c2b39a02fede69c6e4dbd69035cd3a..cf97c34cbaf142dfeb1c5df68f0c5121a4cf6b4b 100644 (file)
@@ -1957,12 +1957,12 @@ static int __devinit lanai_pci_start(struct lanai_dev *lanai)
                return -ENXIO;
        }
        pci_set_master(pci);
-       if (pci_set_dma_mask(pci, DMA_32BIT_MASK) != 0) {
+       if (pci_set_dma_mask(pci, DMA_BIT_MASK(32)) != 0) {
                printk(KERN_WARNING DEV_LABEL
                    "(itf %d): No suitable DMA available.\n", lanai->number);
                return -EBUSY;
        }
-       if (pci_set_consistent_dma_mask(pci, DMA_32BIT_MASK) != 0) {
+       if (pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(32)) != 0) {
                printk(KERN_WARNING DEV_LABEL
                    "(itf %d): No suitable DMA available.\n", lanai->number);
                return -EBUSY;
index 5496865b297e574ff8a385637de2da286556b8c9..f22ed6cc69f286f916c9c064871ffaad77babeca 100644 (file)
@@ -1169,9 +1169,9 @@ static bool DAC960_V1_EnableMemoryMailboxInterface(DAC960_Controller_T
   int i;
 
   
-  if (pci_set_dma_mask(Controller->PCIDevice, DMA_32BIT_MASK))
+  if (pci_set_dma_mask(Controller->PCIDevice, DMA_BIT_MASK(32)))
        return DAC960_Failure(Controller, "DMA mask out of range");
-  Controller->BounceBufferLimit = DMA_32BIT_MASK;
+  Controller->BounceBufferLimit = DMA_BIT_MASK(32);
 
   if ((hw_type == DAC960_PD_Controller) || (hw_type == DAC960_P_Controller)) {
     CommandMailboxesSize =  0;
@@ -1374,8 +1374,8 @@ static bool DAC960_V2_EnableMemoryMailboxInterface(DAC960_Controller_T
 
        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 if (!pci_set_dma_mask(Controller->PCIDevice, DMA_BIT_MASK(32)))
+               Controller->BounceBufferLimit = DMA_BIT_MASK(32);
        else
                return DAC960_Failure(Controller, "DMA mask out of range");
 
index 149a611e8fe5634e8a0a72131a921e637dee33a4..a6c55432819bd17fc14e42e5edd1a4cbb7219a94 100644 (file)
@@ -3639,7 +3639,7 @@ static int __devinit cciss_init_one(struct pci_dev *pdev,
        /* configure PCI DMA stuff */
        if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64)))
                dac = 1;
-       else if (!pci_set_dma_mask(pdev, DMA_32BIT_MASK))
+       else if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(32)))
                dac = 0;
        else {
                printk(KERN_ERR "cciss: no suitable DMA available\n");
index db5783ace1e47c3c233b72248b24b6998f5f0ce7..ff0448e4bf036d36fc6e2a2a071be0ff13b19f99 100644 (file)
@@ -1597,7 +1597,7 @@ static int carm_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
                pci_dac = 1;
        } else {
 #endif
-               rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
+               rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
                if (rc) {
                        printk(KERN_ERR DRV_NAME "(%s): DMA mask failure\n",
                                pci_name(pdev));
index e93e99c9103cab771f514c2cc02e677deed910c8..9744d59a69f210b3ab2ba61bc5446e9ddf156455 100644 (file)
@@ -830,7 +830,7 @@ static int __devinit mm_pci_probe(struct pci_dev *dev,
          "Micro Memory(tm) controller found (PCI Mem Module (Battery Backup))\n");
 
        if (pci_set_dma_mask(dev, DMA_BIT_MASK(64)) &&
-           pci_set_dma_mask(dev, DMA_32BIT_MASK)) {
+           pci_set_dma_mask(dev, DMA_BIT_MASK(32))) {
                dev_printk(KERN_WARNING, &dev->dev, "NO suitable DMA found\n");
                return  -ENOMEM;
        }
index 4d85402a9e4a0990d2db5afdfac0c66376b1af09..2bef086fb34268afaf0e65ec01e5017627142721 100644 (file)
@@ -2575,7 +2575,7 @@ static int hifn_probe(struct pci_dev *pdev, const struct pci_device_id *id)
                return err;
        pci_set_master(pdev);
 
-       err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
+       err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
        if (err)
                goto err_out_disable_pci_device;
 
index af9761ccf9f132a6414aacec926251b06c8b64c6..f9f05d7a707d09bd53a489d99acde270b2f26521 100644 (file)
@@ -209,7 +209,7 @@ static struct platform_device pseudo_dev = {
        .id   = 0,
        .num_resources = 0,
        .dev  = {
-               .coherent_dma_mask = DMA_32BIT_MASK,
+               .coherent_dma_mask = DMA_BIT_MASK(32),
                .release = dev_release,
        }
 };
index 22e9f1911111a95f0c09fed5f17b0fbee1f07470..2225bb6ba3d14c55790eeeea78dace956fa905b0 100644 (file)
@@ -100,13 +100,13 @@ static int __devinit ioat_probe(struct pci_dev *pdev,
 
        err = pci_set_dma_mask(pdev, DMA_BIT_MASK(64));
        if (err)
-               err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
+               err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
        if (err)
                goto err_set_dma_mask;
 
        err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
        if (err)
-               err = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
+               err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
        if (err)
                goto err_set_dma_mask;
 
index 3009e0171e54958f2c99ea3b568d4619ff237b7c..18d65fb42ee71850d0914f5fd44cd6a91eaf3111 100644 (file)
@@ -545,7 +545,7 @@ static int __devinit dcdbas_probe(struct platform_device *dev)
         * BIOS SMI calls require buffer addresses be in 32-bit address space.
         * This is done by setting the DMA mask below.
         */
-       dcdbas_pdev->dev.coherent_dma_mask = DMA_32BIT_MASK;
+       dcdbas_pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
        dcdbas_pdev->dev.dma_mask = &dcdbas_pdev->dev.coherent_dma_mask;
 
        error = sysfs_create_group(&dev->dev.kobj, &dcdbas_attr_group);
index 58fb90e5b7635c08ae16545b876776c46af095d0..87987a7d36c9c3c6d0cf391c92cd12a9c5426ae0 100644 (file)
@@ -122,7 +122,7 @@ static int __devinit cs5520_init_one(struct pci_dev *dev, const struct pci_devic
                return -ENODEV;
        }
        pci_set_master(dev);
-       if (pci_set_dma_mask(dev, DMA_32BIT_MASK)) {
+       if (pci_set_dma_mask(dev, DMA_BIT_MASK(32))) {
                printk(KERN_WARNING "%s: No suitable DMA available.\n",
                        d->name);
                return -ENODEV;
index a19dbccd76179cd4a234b168e2d18197bf86b18e..7a3a12d6e638eae21a9bbce4f3f269d55b5a8aa6 100644 (file)
@@ -208,7 +208,7 @@ static int ide_pci_enable(struct pci_dev *dev, const struct ide_port_info *d)
         * a DMA mask field to the struct ide_port_info if we need it
         * (or let lower level driver set the DMA mask)
         */
-       ret = pci_set_dma_mask(dev, DMA_32BIT_MASK);
+       ret = pci_set_dma_mask(dev, DMA_BIT_MASK(32));
        if (ret < 0) {
                printk(KERN_ERR "%s %s: can't set DMA mask\n",
                        d->name, pci_name(dev));
index 38f71203620120dd36a5bd1fb33e41be0c059e02..9555fd2538658561526400f6202dd1d13a7c2bc7 100644 (file)
@@ -1171,7 +1171,7 @@ static int __devinit add_card(struct pci_dev *dev,
 
         error = -ENXIO;
 
-        if (pci_set_dma_mask(dev, DMA_32BIT_MASK))
+        if (pci_set_dma_mask(dev, DMA_BIT_MASK(32)))
                 FAIL("DMA address limits not supported for PCILynx hardware");
         if (pci_enable_device(dev))
                 FAIL("failed to enable PCILynx hardware");
index 54d2e0760abfa9587d10185878960a770961848c..0cfbb6d2f762b5699c4edef953ab5757196dae5c 100644 (file)
@@ -995,7 +995,7 @@ static int __devinit c2_probe(struct pci_dev *pcidev,
                        goto bail2;
                }
        } else {
-               ret = pci_set_dma_mask(pcidev, DMA_32BIT_MASK);
+               ret = pci_set_dma_mask(pcidev, DMA_BIT_MASK(32));
                if (ret < 0) {
                        printk(KERN_ERR PFX "32b DMA configuration failed\n");
                        goto bail2;
index 77b2fb5b7c351099d8b73f7211496ca9d326b752..04e88b600558caceaa0cedaf073b4ffeb7145ba5 100644 (file)
@@ -477,7 +477,7 @@ static int __devinit ipath_init_one(struct pci_dev *pdev,
                 * do not setup 64 bit maps on systems with 2GB or less
                 * memory installed.
                 */
-               ret = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
+               ret = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
                if (ret) {
                        dev_info(&pdev->dev,
                                "Unable to set DMA mask for unit %u: %d\n",
@@ -486,7 +486,7 @@ static int __devinit ipath_init_one(struct pci_dev *pdev,
                }
                else {
                        ipath_dbg("No 64bit DMA mask, used 32 bit mask\n");
-                       ret = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
+                       ret = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
                        if (ret)
                                dev_info(&pdev->dev,
                                        "Unable to set DMA consistent mask "
index 5d234204f7b7718bfcdb38603a4a4364ff1cc6ef..1d83cf7caf38a4893a1e23355092cf134bb83a61 100644 (file)
@@ -1019,7 +1019,7 @@ static int __mthca_init_one(struct pci_dev *pdev, int hca_type)
        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);
+               err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
                if (err) {
                        dev_err(&pdev->dev, "Can't set PCI DMA mask, aborting.\n");
                        goto err_free_res;
@@ -1029,7 +1029,7 @@ static int __mthca_init_one(struct pci_dev *pdev, int hca_type)
        if (err) {
                dev_warn(&pdev->dev, "Warning: couldn't set 64-bit "
                         "consistent PCI DMA mask.\n");
-               err = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
+               err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
                if (err) {
                        dev_err(&pdev->dev, "Can't set consistent PCI DMA mask, "
                                "aborting.\n");
index 7446810446e16772168a1e7652cc1582bba41c35..cbde0cfe27e0a7e3eeb784003317b90e262df6ae 100644 (file)
@@ -489,12 +489,12 @@ static int __devinit nes_probe(struct pci_dev *pcidev, const struct pci_device_i
                        goto bail2;
                }
        } else {
-               ret = pci_set_dma_mask(pcidev, DMA_32BIT_MASK);
+               ret = pci_set_dma_mask(pcidev, DMA_BIT_MASK(32));
                if (ret < 0) {
                        printk(KERN_ERR PFX "32b DMA mask configuration failed\n");
                        goto bail2;
                }
-               ret = pci_set_consistent_dma_mask(pcidev, DMA_32BIT_MASK);
+               ret = pci_set_consistent_dma_mask(pcidev, DMA_BIT_MASK(32));
                if (ret) {
                        printk(KERN_ERR PFX "32b DMA consistent mask configuration failed\n");
                        goto bail2;
index 5b20cf5a29f02fa056834bca9cdbd7969e291578..971a8b18f6dd7214a9b797697e09baf386ff7ed8 100644 (file)
@@ -662,7 +662,7 @@ static int __devinit dm1105_probe(struct pci_dev *pdev,
        if (ret < 0)
                goto err_kfree;
 
-       ret = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
+       ret = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
        if (ret < 0)
                goto err_pci_disable_device;
 
index ee89623be85aa32a3a749c1e00217efd9d2d4bcb..598eaf8acc6e4ef4881fe1a862716142698b5c97 100644 (file)
@@ -616,7 +616,7 @@ static int __devinit pluto2_probe(struct pci_dev *pdev,
        /* enable interrupts */
        pci_write_config_dword(pdev, 0x6c, 0x8000);
 
-       ret = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
+       ret = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
        if (ret < 0)
                goto err_pci_disable_device;
 
index 74f619d6cc93a2c7bf28156555e29a33a7bdbe4e..23b7499b31852d5aa7f0b3f52c5f5c2f37b481f6 100644 (file)
@@ -4317,7 +4317,7 @@ static int __devinit bttv_probe(struct pci_dev *dev,
                       btv->c.nr);
                return -EIO;
        }
-       if (pci_set_dma_mask(dev, DMA_32BIT_MASK)) {
+       if (pci_set_dma_mask(dev, DMA_BIT_MASK(32))) {
                printk(KERN_WARNING "bttv%d: No suitable DMA available.\n",
                       btv->c.nr);
                return -EIO;
index ce98d955231ae4f505b8e018836698d33a3ebde8..0ccdf36626e30a0f30d47e7bb7fb44c2bfe04833 100644 (file)
@@ -745,7 +745,7 @@ static int __devinit snd_cx88_create(struct snd_card *card,
                return err;
        }
 
-       if (!pci_dma_supported(pci,DMA_32BIT_MASK)) {
+       if (!pci_dma_supported(pci,DMA_BIT_MASK(32))) {
                dprintk(0, "%s/1: Oops: no 32bit PCI DMA ???\n",core->name);
                err = -EIO;
                cx88_core_put(core,pci);
index b295b76737e35acb4749cedef61f9c4f1edeaa67..da4e3912cd374991ba37f560779e2a871f05cf28 100644 (file)
@@ -455,7 +455,7 @@ static int cx8802_init_common(struct cx8802_dev *dev)
        if (pci_enable_device(dev->pci))
                return -EIO;
        pci_set_master(dev->pci);
-       if (!pci_dma_supported(dev->pci,DMA_32BIT_MASK)) {
+       if (!pci_dma_supported(dev->pci,DMA_BIT_MASK(32))) {
                printk("%s/2: Oops: no 32bit PCI DMA ???\n",dev->core->name);
                return -EIO;
        }
index ec0425d9043aee027649da17c60f97fee24fb4c6..b993d42fe73c138f5bfc9c289d16d1aa0a13ce13 100644 (file)
@@ -1832,7 +1832,7 @@ static int __devinit cx8800_initdev(struct pci_dev *pci_dev,
               dev->pci_lat,(unsigned long long)pci_resource_start(pci_dev,0));
 
        pci_set_master(pci_dev);
-       if (!pci_dma_supported(pci_dev,DMA_32BIT_MASK)) {
+       if (!pci_dma_supported(pci_dev,DMA_BIT_MASK(32))) {
                printk("%s/0: Oops: no 32bit PCI DMA ???\n",core->name);
                err = -EIO;
                goto fail_core;
index 2ad11f0999c69a843d289d8af4ced5a88f2a2e04..1d66855a379a99209aa51cfa418e7aa1f6e0d0db 100644 (file)
@@ -117,7 +117,7 @@ static int ptable_alloc(void)
        memset(meye.mchip_ptable, 0, sizeof(meye.mchip_ptable));
 
        /* give only 32 bit DMA addresses */
-       if (dma_set_mask(&meye.mchip_dev->dev, DMA_32BIT_MASK))
+       if (dma_set_mask(&meye.mchip_dev->dev, DMA_BIT_MASK(32)))
                return -1;
 
        meye.mchip_ptable_toc = dma_alloc_coherent(&meye.mchip_dev->dev,
index 0bb09f1723d10beee592d3d545ea41f3a4ce2e26..2def6fec814bb31adaf6e2e32d476b13bdeb6107 100644 (file)
@@ -911,7 +911,7 @@ static int __devinit saa7134_initdev(struct pci_dev *pci_dev,
               pci_name(pci_dev), dev->pci_rev, pci_dev->irq,
               dev->pci_lat,(unsigned long long)pci_resource_start(pci_dev,0));
        pci_set_master(pci_dev);
-       if (!pci_dma_supported(pci_dev, DMA_32BIT_MASK)) {
+       if (!pci_dma_supported(pci_dev, DMA_BIT_MASK(32))) {
                printk("%s: Oops: no 32bit PCI DMA ???\n",dev->name);
                err = -EIO;
                goto fail1;
index 2fb95a5b72eb2ede1c55c295ab946c3b2cede474..f4a162a4bece30532ca15cf4a4f49e247787b160 100644 (file)
@@ -877,7 +877,7 @@ static int jmb38x_ms_probe(struct pci_dev *pdev,
        int pci_dev_busy = 0;
        int rc, cnt;
 
-       rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
+       rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
        if (rc)
                return rc;
 
index 98026016a9353b1fa0358d9ae7b43cb7e8d1733f..d0d126c6935497df2b2e09c6b9adae235b90e8b8 100644 (file)
@@ -1539,8 +1539,8 @@ mpt_mapresources(MPT_ADAPTER *ioc)
                dinitprintk(ioc, printk(MYIOC_s_INFO_FMT
                    ": 64 BIT PCI BUS DMA ADDRESSING SUPPORTED\n",
                    ioc->name));
-       } else if (!pci_set_dma_mask(pdev, DMA_32BIT_MASK)
-           && !pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK)) {
+       } else if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(32))
+           && !pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32))) {
                dinitprintk(ioc, printk(MYIOC_s_INFO_FMT
                    ": 32 BIT PCI BUS DMA ADDRESSING SUPPORTED\n",
                    ioc->name));
index 9a08d8e4551623cb709c74ed6019da8a270c0c21..292b41e49fbd57c5881c03cf7daa889a72404948 100644 (file)
@@ -187,7 +187,7 @@ int i2o_dma_alloc(struct device *dev, struct i2o_dma *addr, size_t len)
        mutex_lock(&mem_lock);
        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)) {
+               if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) {
                        mutex_unlock(&mem_lock);
                        return -ENOMEM;
                }
index ed17ac5af3e0d0aa80754d2ca71ebb927165273d..35ba2ae38b4233d541efed5ae35b7af98586a511 100644 (file)
@@ -334,7 +334,7 @@ static int __devinit i2o_pci_probe(struct pci_dev *pdev,
                return rc;
        }
 
-       if (pci_set_dma_mask(pdev, DMA_32BIT_MASK)) {
+       if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) {
                printk(KERN_WARNING "i2o: no suitable DMA found for %s\n",
                       pci_name(pdev));
                rc = -ENODEV;
index be5672a98702615bb21585871ad0b2deefc8efdb..a6ef18259da033ea7a9d6426f53575de1a35e027 100644 (file)
@@ -324,7 +324,7 @@ static int tifm_7xx1_probe(struct pci_dev *dev,
        int pci_dev_busy = 0;
        int rc;
 
-       rc = pci_set_dma_mask(dev, DMA_32BIT_MASK);
+       rc = pci_set_dma_mask(dev, DMA_BIT_MASK(32));
        if (rc)
                return rc;
 
index 406da9a8d453718b7d057e174199a139cab332e1..c5b316e22371e687076eee25142bc0ae73de868c 100644 (file)
@@ -380,7 +380,7 @@ static int sdhci_pci_enable_dma(struct sdhci_host *host)
                        "doesn't fully claim to support it.\n");
        }
 
-       ret = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
+       ret = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
        if (ret)
                return ret;
 
index d08475a7f6762b9166f95d449ed5f0c390f0c2b7..02330f3d5a55d35e1201e22aefc3b8e491f65f9f 100644 (file)
@@ -1530,7 +1530,7 @@ static void cp_get_ethtool_stats (struct net_device *dev,
 
        /* begin NIC statistics dump */
        cpw32(StatsAddr + 4, (u64)dma >> 32);
-       cpw32(StatsAddr, ((u64)dma & DMA_32BIT_MASK) | DumpStats);
+       cpw32(StatsAddr, ((u64)dma & DMA_BIT_MASK(32)) | DumpStats);
        cpr32(StatsAddr);
 
        for (i = 0; i < 1000; i++) {
@@ -1935,13 +1935,13 @@ static int cp_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
        } else {
                pci_using_dac = 0;
 
-               rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
+               rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
                if (rc) {
                        dev_err(&pdev->dev,
                                   "No usable DMA configuration, aborting.\n");
                        goto err_out_res;
                }
-               rc = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
+               rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
                if (rc) {
                        dev_err(&pdev->dev,
                                   "No usable consistent DMA configuration, "
index 9509c17b366713a6be4db9af5785fd34a4336d2d..57bc7152785050b893cad09fd85b2f639daf1696 100644 (file)
@@ -1163,7 +1163,7 @@ static int __devinit ace_init(struct net_device *dev)
         */
        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)) {
+       } else if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) {
                ap->pci_using_dac = 0;
        } else {
                ecode = -ENODEV;
index cb9c95d3ed0ab45854da0e1b1e8e0240c6c044d6..19831bd64016f850416afe1387dc71b4e7fb18ea 100644 (file)
@@ -1871,7 +1871,7 @@ static int __devinit amd8111e_probe_one(struct pci_dev *pdev,
        }
 
        /* Initialize DMA */
-       if (pci_set_dma_mask(pdev, DMA_32BIT_MASK) < 0) {
+       if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) < 0) {
                printk(KERN_ERR "amd8111e: DMA not supported,"
                        "exiting.\n");
                goto err_free_reg;
index c758884728a53ee545879d61cc5b128de2bbe219..fb57b750866bf53657ba680c7301b7fe683e9136 100644 (file)
@@ -2326,8 +2326,8 @@ static int __devinit atl1e_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;
        }
index 43fc1b2ca3cd62d70cfacaa14dbc54ca89eb4490..0ab22540bf597a8ec6b97f8c4f54f2055608af0e 100644 (file)
@@ -2929,7 +2929,7 @@ static int __devinit atl1_probe(struct pci_dev *pdev,
         * various kernel subsystems to support the mechanics required by a
         * fixed-high-32-bit system.
         */
-       err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
+       err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
        if (err) {
                dev_err(&pdev->dev, "no usable DMA configuration\n");
                goto err_dma;
index 9fe06c3f409731b429371fbe0166693ec958c5e8..c734b1983ec14667bc2debd4d5eec05b4f66369d 100644 (file)
@@ -1358,8 +1358,8 @@ static int __devinit atl2_probe(struct pci_dev *pdev,
         * until the kernel has the proper infrastructure to support 64-bit DMA
         * on these devices.
         */
-       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))) {
                printk(KERN_ERR "atl2: No usable DMA configuration, aborting\n");
                goto err_dma;
        }
index 5fd57703c65abed03d79a9072b1426ca6ea9c8de..9d268be0b670e70a9921cdf66694400b76e7d788 100644 (file)
@@ -7538,7 +7538,7 @@ bnx2_init_board(struct pci_dev *pdev, struct net_device *dev)
                                "pci_set_consistent_dma_mask failed, aborting.\n");
                        goto err_out_unmap;
                }
-       } else if ((rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK)) != 0) {
+       } else if ((rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) != 0) {
                dev_err(&pdev->dev, "System does not support DMA, aborting.\n");
                goto err_out_unmap;
        }
index 03e01243b45e323596f368b72814443eaedc86eb..ad5ef25add3e0dde70a1ab8c7f2d01c5116dd81d 100644 (file)
@@ -10988,7 +10988,7 @@ static int __devinit bnx2x_init_dev(struct pci_dev *pdev,
                        goto err_out_release;
                }
 
-       } else if (pci_set_dma_mask(pdev, DMA_32BIT_MASK) != 0) {
+       } else if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) != 0) {
                printk(KERN_ERR PFX "System does not support DMA,"
                       " aborting\n");
                rc = -EIO;
index c2895240e467de388525a49878903275baa09a40..f5222764061c4677b8e9ac2f2661d3f5b7eb0107 100644 (file)
@@ -5085,7 +5085,7 @@ static int __devinit cas_init_one(struct pci_dev *pdev,
                }
 
        } else {
-               err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
+               err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
                if (err) {
                        dev_err(&pdev->dev, "No usable DMA configuration, "
                               "aborting.\n");
index 57cfbc369f510c4e082f4f46bb733bca54e22a81..fa06994f973770e4f46c27d902e8fc0c7a28ed10 100644 (file)
@@ -1066,7 +1066,7 @@ static int __devinit init_one(struct pci_dev *pdev,
                        goto out_disable_pdev;
                }
 
-       } else if ((err = pci_set_dma_mask(pdev, DMA_32BIT_MASK)) != 0) {
+       } else if ((err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) != 0) {
                CH_ERR("%s: no usable DMA configuration\n", pci_name(pdev));
                goto out_disable_pdev;
        }
index ec35d3b8240925738e6a22e8a5e9dc76b2c42937..ab0e5febef83302f1b19fdda095a8e54e7029a60 100644 (file)
@@ -3046,7 +3046,7 @@ static int __devinit init_one(struct pci_dev *pdev,
                               "coherent allocations\n");
                        goto out_disable_device;
                }
-       } else if ((err = pci_set_dma_mask(pdev, DMA_32BIT_MASK)) != 0) {
+       } else if ((err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) != 0) {
                dev_err(&pdev->dev, "no usable DMA configuration\n");
                goto out_disable_device;
        }
index 0504db9ad6434c50bf1e9585b5a00b2090f7db26..5c0b457c7868aa40b527c845ad34a16ea9804a12 100644 (file)
@@ -2604,7 +2604,7 @@ static int __devinit e100_probe(struct pci_dev *pdev,
                goto err_out_disable_pdev;
        }
 
-       if ((err = pci_set_dma_mask(pdev, DMA_32BIT_MASK))) {
+       if ((err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32)))) {
                DPRINTK(PROBE, ERR, "No usable DMA configuration, aborting.\n");
                goto err_out_free_res;
        }
index caa71dffb3d07ad400cfa601bfa5c29e2dc357a4..ddc5c533e89c41d6e9468c7b3051301ffd0b2429 100644 (file)
@@ -966,9 +966,9 @@ static int __devinit e1000_probe(struct pci_dev *pdev,
            !pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64))) {
                pci_using_dac = 1;
        } else {
-               err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
+               err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
                if (err) {
-                       err = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
+                       err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
                        if (err) {
                                E1000_ERR("No usable DMA configuration, "
                                          "aborting\n");
index 4a61160052a33374819b214131388b4462cb0a4f..409b58cad0e50df0c34e77f6f31a943b0c306029 100644 (file)
@@ -2203,7 +2203,7 @@ static void e1000_configure_tx(struct e1000_adapter *adapter)
        /* Setup the HW Tx Head and Tail descriptor pointers */
        tdba = tx_ring->dma;
        tdlen = tx_ring->count * sizeof(struct e1000_tx_desc);
-       ew32(TDBAL, (tdba & DMA_32BIT_MASK));
+       ew32(TDBAL, (tdba & DMA_BIT_MASK(32)));
        ew32(TDBAH, (tdba >> 32));
        ew32(TDLEN, tdlen);
        ew32(TDH, 0);
@@ -2459,7 +2459,7 @@ static void e1000_configure_rx(struct e1000_adapter *adapter)
         * the Base and Length of the Rx Descriptor Ring
         */
        rdba = rx_ring->dma;
-       ew32(RDBAL, (rdba & DMA_32BIT_MASK));
+       ew32(RDBAL, (rdba & DMA_BIT_MASK(32)));
        ew32(RDBAH, (rdba >> 32));
        ew32(RDLEN, rdlen);
        ew32(RDH, 0);
@@ -4769,10 +4769,10 @@ static int __devinit e1000_probe(struct pci_dev *pdev,
                if (!err)
                        pci_using_dac = 1;
        } else {
-               err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
+               err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
                if (err) {
                        err = pci_set_consistent_dma_mask(pdev,
-                                                         DMA_32BIT_MASK);
+                                                         DMA_BIT_MASK(32));
                        if (err) {
                                dev_err(&pdev->dev, "No usable DMA "
                                        "configuration, aborting\n");
index 5b87105ac9e0de45e4165a3084e42154fa1d33ee..9080f07da8fe01f23e81a52eef0690151017b47c 100644 (file)
@@ -1687,13 +1687,13 @@ static int __devinit enic_probe(struct pci_dev *pdev,
 
        err = pci_set_dma_mask(pdev, DMA_BIT_MASK(40));
        if (err) {
-               err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
+               err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
                if (err) {
                        printk(KERN_ERR PFX
                                "No usable DMA configuration, aborting.\n");
                        goto err_out_release_regions;
                }
-               err = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
+               err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
                if (err) {
                        printk(KERN_ERR PFX
                                "Unable to obtain 32-bit DMA "
index ad8be7e78290da315d4a8a2d649dc6334f3d2855..de3f49f991a3d61c3f25362414b649c673cf2612 100644 (file)
@@ -580,7 +580,7 @@ static int __devinit hp100_probe1(struct net_device *dev, int ioaddr,
                         * Also, we can have EISA Busmaster cards (not tested),
                         * so beware !!! - Jean II */
                        if((bus == HP100_BUS_PCI) &&
-                          (pci_set_dma_mask(pci_dev, DMA_32BIT_MASK))) {
+                          (pci_set_dma_mask(pci_dev, DMA_BIT_MASK(32)))) {
                                /* Gracefully fallback to shared memory */
                                goto busmasterfail;
                        }
index 82278beaac8305c4bfa0015f29fea4d35d1e72f8..6b0697c565b95bbd055b35b995eed55eaa9a73c8 100644 (file)
@@ -1160,9 +1160,9 @@ static int __devinit igb_probe(struct pci_dev *pdev,
                if (!err)
                        pci_using_dac = 1;
        } else {
-               err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
+               err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
                if (err) {
-                       err = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
+                       err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
                        if (err) {
                                dev_err(&pdev->dev, "No usable DMA "
                                        "configuration, aborting\n");
index 43be0b01f12c42b82b2ba419f52a9bcb9b06929d..cbc63ff13add7be86cbf22aca2c00ea61ec2b83b 100644 (file)
@@ -1236,7 +1236,7 @@ static int __devinit ioc3_probe(struct pci_dev *pdev,
                        goto out;
                }
        } else {
-               err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
+               err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
                if (err) {
                        printk(KERN_ERR "%s: No usable DMA configuration, "
                               "aborting.\n", pci_name(pdev));
index ed9ded939d96165c8a6f8ce908c2aab805f95a00..43019461b7766fbbba0b03ec433715ae44c8af8d 100644 (file)
@@ -2242,7 +2242,7 @@ static int __devinit ipg_probe(struct pci_dev *pdev,
 
        rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(40));
        if (rc < 0) {
-               rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
+               rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
                if (rc < 0) {
                        printk(KERN_ERR "%s: DMA config failed.\n",
                               pci_name(pdev));
index 0ac51758bc6c789e65a4ef6eebf41f7bd743a4dc..4a0826b8f6f2bda1498f72fe5d9314ec33f07210 100644 (file)
@@ -369,8 +369,8 @@ ixgb_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
            !(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)) ||
-                   (err = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK))) {
+               if ((err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) ||
+                   (err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32)))) {
                        printk(KERN_ERR
                         "ixgb: No usable DMA configuration, aborting\n");
                        goto err_dma_mask;
index 126735ca6d7f1ca9d23b343b5cf16ecb07a9c478..9ef128ae6458e7fd0a913e496ec4364789d3b879 100644 (file)
@@ -1643,7 +1643,7 @@ static void ixgbe_configure_tx(struct ixgbe_adapter *adapter)
                tdba = ring->dma;
                tdlen = ring->count * sizeof(union ixgbe_adv_tx_desc);
                IXGBE_WRITE_REG(hw, IXGBE_TDBAL(j),
-                               (tdba & DMA_32BIT_MASK));
+                               (tdba & DMA_BIT_MASK(32)));
                IXGBE_WRITE_REG(hw, IXGBE_TDBAH(j), (tdba >> 32));
                IXGBE_WRITE_REG(hw, IXGBE_TDLEN(j), tdlen);
                IXGBE_WRITE_REG(hw, IXGBE_TDH(j), 0);
@@ -1782,7 +1782,7 @@ static void ixgbe_configure_rx(struct ixgbe_adapter *adapter)
        for (i = 0; i < adapter->num_rx_queues; i++) {
                rdba = adapter->rx_ring[i].dma;
                j = adapter->rx_ring[i].reg_idx;
-               IXGBE_WRITE_REG(hw, IXGBE_RDBAL(j), (rdba & DMA_32BIT_MASK));
+               IXGBE_WRITE_REG(hw, IXGBE_RDBAL(j), (rdba & DMA_BIT_MASK(32)));
                IXGBE_WRITE_REG(hw, IXGBE_RDBAH(j), (rdba >> 32));
                IXGBE_WRITE_REG(hw, IXGBE_RDLEN(j), rdlen);
                IXGBE_WRITE_REG(hw, IXGBE_RDH(j), 0);
@@ -4513,9 +4513,9 @@ static int __devinit ixgbe_probe(struct pci_dev *pdev,
            !pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64))) {
                pci_using_dac = 1;
        } else {
-               err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
+               err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
                if (err) {
-                       err = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
+                       err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
                        if (err) {
                                dev_err(&pdev->dev, "No usable DMA "
                                        "configuration, aborting\n");
index 860dcd98a07c1c036d3aa97286152ea5a061f05f..ece35040288c5de1e6344ae0d4367ca1378ef2e4 100644 (file)
@@ -2600,8 +2600,8 @@ jme_pci_dma64(struct pci_dev *pdev)
                if (!pci_set_consistent_dma_mask(pdev, DMA_40BIT_MASK))
                        return 1;
 
-       if (!pci_set_dma_mask(pdev, DMA_32BIT_MASK))
-               if (!pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK))
+       if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(32)))
+               if (!pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32)))
                        return 0;
 
        return -1;
index fed53fbaf54524288398fbdc12c3355041b407a5..102bac90a302fcdecccead75e03e3c5ade175b55 100644 (file)
@@ -1079,7 +1079,7 @@ static int __mlx4_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
        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);
+               err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
                if (err) {
                        dev_err(&pdev->dev, "Can't set PCI DMA mask, aborting.\n");
                        goto err_release_bar2;
@@ -1089,7 +1089,7 @@ static int __mlx4_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
        if (err) {
                dev_warn(&pdev->dev, "Warning: couldn't set 64-bit "
                         "consistent PCI DMA mask.\n");
-               err = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
+               err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
                if (err) {
                        dev_err(&pdev->dev, "Can't set consistent PCI DMA mask, "
                                "aborting.\n");
index 27655466dbebf77a5f326108e8142228fa5acaac..9eed126a82f0009e30464d432eb5e43670e02b99 100644 (file)
@@ -1130,7 +1130,7 @@ myri10ge_submit_8rx(struct mcp_kreq_ether_recv __iomem * dst,
        __be32 low;
 
        low = src->addr_low;
-       src->addr_low = htonl(DMA_32BIT_MASK);
+       src->addr_low = htonl(DMA_BIT_MASK(32));
        myri10ge_pio_copy(dst, src, 4 * sizeof(*src));
        mb();
        myri10ge_pio_copy(dst + 4, src + 4, 4 * sizeof(*src));
@@ -3798,7 +3798,7 @@ static int myri10ge_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                dev_err(&pdev->dev,
                        "64-bit pci address mask was refused, "
                        "trying 32-bit\n");
-               status = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
+               status = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
        }
        if (status != 0) {
                dev_err(&pdev->dev, "Error %d setting DMA mask\n", status);
index 02c37e2f08a9fadc9dfaaa222193f97b036b0ba3..73cac6c78cb6f97131ec0a52ec56340a93f56594 100644 (file)
@@ -9889,8 +9889,8 @@ static int __devinit niu_pci_init_one(struct pci_dev *pdev,
                        goto err_out_release_parent;
                }
        }
-       if (err || dma_mask == DMA_32BIT_MASK) {
-               err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
+       if (err || dma_mask == DMA_BIT_MASK(32)) {
+               err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
                if (err) {
                        dev_err(&pdev->dev, PFX "No usable DMA configuration, "
                                "aborting.\n");
index e30ab06e71037ae964d50de349c27b51d9a17123..d531614a90b551135de193fb34800a0f7b7a2d60 100644 (file)
@@ -1975,7 +1975,7 @@ static int __devinit ns83820_init_one(struct pci_dev *pci_dev,
        if (sizeof(dma_addr_t) == 8 &&
                !pci_set_dma_mask(pci_dev, DMA_BIT_MASK(64))) {
                using_dac = 1;
-       } else if (!pci_set_dma_mask(pci_dev, DMA_32BIT_MASK)) {
+       } else if (!pci_set_dma_mask(pci_dev, DMA_BIT_MASK(32))) {
                using_dac = 0;
        } else {
                dev_warn(&pci_dev->dev, "pci_set_dma_mask failed!\n");
index aef047e4515ac1fd8ad4a734bb409b46902b3fd4..cadc32c94c1e64da93b48ca26fb7ce448be88ef6 100644 (file)
@@ -3937,9 +3937,9 @@ static int __devinit ql3xxx_probe(struct pci_dev *pdev,
        if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) {
                pci_using_dac = 1;
                err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
-       } else if (!(err = pci_set_dma_mask(pdev, DMA_32BIT_MASK))) {
+       } else if (!(err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32)))) {
                pci_using_dac = 0;
-               err = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
+               err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
        }
 
        if (err) {
index 0add30d38d625625d995a41ae28de6bf594581a0..c92ced2479478729e5e329463f7acd1e49599f90 100644 (file)
@@ -3730,9 +3730,9 @@ static int __devinit ql_init_device(struct pci_dev *pdev,
                set_bit(QL_DMA64, &qdev->flags);
                err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
        } else {
-               err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
+               err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
                if (!err)
-                      err = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
+                      err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
        }
 
        if (err) {
index 0a37f9902a074d0f106db698a8232fb3bce0d2c9..5e8540b6ffa11d7184cbcf1e5ee11f88f1d57043 100644 (file)
@@ -1085,13 +1085,13 @@ static int __devinit r6040_init_one(struct pci_dev *pdev,
                goto err_out;
 
        /* this should always be supported */
-       err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
+       err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
        if (err) {
                printk(KERN_ERR DRV_NAME ": 32-bit PCI DMA addresses"
                                "not supported by the card\n");
                goto err_out;
        }
-       err = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
+       err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
        if (err) {
                printk(KERN_ERR DRV_NAME ": 32-bit PCI DMA addresses"
                                "not supported by the card\n");
index fe676d38d34274a4e61554b80ce7a4261530cc74..0b6e8c89683581efdfc35925adaa018998468db5 100644 (file)
@@ -1148,7 +1148,7 @@ static void rtl8169_update_counters(struct net_device *dev)
                return;
 
        RTL_W32(CounterAddrHigh, (u64)paddr >> 32);
-       cmd = (u64)paddr & DMA_32BIT_MASK;
+       cmd = (u64)paddr & DMA_BIT_MASK(32);
        RTL_W32(CounterAddrLow, cmd);
        RTL_W32(CounterAddrLow, cmd | CounterDump);
 
@@ -2050,7 +2050,7 @@ rtl8169_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
                tp->cp_cmd |= PCIDAC;
                dev->features |= NETIF_F_HIGHDMA;
        } else {
-               rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
+               rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
                if (rc < 0) {
                        if (netif_msg_probe(tp)) {
                                dev_err(&pdev->dev,
@@ -2343,9 +2343,9 @@ static void rtl_set_rx_tx_desc_registers(struct rtl8169_private *tp,
         * Switching from MMIO to I/O access fixes the issue as well.
         */
        RTL_W32(TxDescStartAddrHigh, ((u64) tp->TxPhyAddr) >> 32);
-       RTL_W32(TxDescStartAddrLow, ((u64) tp->TxPhyAddr) & DMA_32BIT_MASK);
+       RTL_W32(TxDescStartAddrLow, ((u64) tp->TxPhyAddr) & DMA_BIT_MASK(32));
        RTL_W32(RxDescAddrHigh, ((u64) tp->RxPhyAddr) >> 32);
-       RTL_W32(RxDescAddrLow, ((u64) tp->RxPhyAddr) & DMA_32BIT_MASK);
+       RTL_W32(RxDescAddrLow, ((u64) tp->RxPhyAddr) & DMA_BIT_MASK(32));
 }
 
 static u16 rtl_rw_cpluscmd(void __iomem *ioaddr)
index 7c8d5613a1da6482b45acb98e7880aa491c53268..1a4979f27fb5af83e82c31ad448f4a63774b67e4 100644 (file)
@@ -7786,7 +7786,7 @@ s2io_init_nic(struct pci_dev *pdev, const struct pci_device_id *pre)
                        pci_disable_device(pdev);
                        return -ENOMEM;
                }
-       } else if (!pci_set_dma_mask(pdev, DMA_32BIT_MASK)) {
+       } else if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) {
                DBG_PRINT(INIT_DBG, "s2io_init_nic: Using 32bit DMA\n");
        } else {
                pci_disable_device(pdev);
index c13cbf099b88e6ef61fd51ba2cacc6973f4d8e30..18821f217e19fa286a732973cfc917463638e672 100644 (file)
@@ -1427,11 +1427,11 @@ static int __devinit sc92031_probe(struct pci_dev *pdev,
 
        pci_set_master(pdev);
 
-       err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
+       err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
        if (unlikely(err < 0))
                goto out_set_dma_mask;
 
-       err = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
+       err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
        if (unlikely(err < 0))
                goto out_set_dma_mask;
 
index a9732686134b844884fd8ab0441070efc636d6c1..55ccd51d247efc3fa20cddd6616ddc8607637e17 100644 (file)
@@ -1467,7 +1467,7 @@ static struct net_device * __devinit sis190_init_board(struct pci_dev *pdev)
                goto err_pci_disable_2;
        }
 
-       rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
+       rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
        if (rc < 0) {
                net_probe(tp, KERN_ERR "%s: DMA configuration failed.\n",
                          pci_name(pdev));
index 8a70de72ea2cb8db4471d44299fb590e4dcd430c..2d4617b3e2087c9a7bcc9bf33a83f3e00bbf77cb 100644 (file)
@@ -432,7 +432,7 @@ static int __devinit sis900_probe(struct pci_dev *pci_dev,
        ret = pci_enable_device(pci_dev);
        if(ret) return ret;
 
-       i = pci_set_dma_mask(pci_dev, DMA_32BIT_MASK);
+       i = pci_set_dma_mask(pci_dev, DMA_BIT_MASK(32));
        if(i){
                printk(KERN_ERR "sis900.c: architecture does not support "
                        "32bit PCI busmaster DMA\n");
index 18a7b662aff1c1345f90d2a5546791be2ca6e12a..b8978d4af1b76677bd2f0138089be2605bdd5ab7 100644 (file)
@@ -3915,9 +3915,9 @@ static int __devinit skge_probe(struct pci_dev *pdev,
        if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) {
                using_dac = 1;
                err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
-       } else if (!(err = pci_set_dma_mask(pdev, DMA_32BIT_MASK))) {
+       } else if (!(err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32)))) {
                using_dac = 0;
-               err = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
+               err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
        }
 
        if (err) {
index da570f44b12ba4c78910715f64d81c8a0e8b78d1..a2ff9cb1e7ac55e4f4a80311d11326268345e87c 100644 (file)
@@ -4383,7 +4383,7 @@ static int __devinit sky2_probe(struct pci_dev *pdev,
                        goto err_out_free_regions;
                }
        } else {
-               err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
+               err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
                if (err) {
                        dev_err(&pdev->dev, "no usable DMA configuration\n");
                        goto err_out_free_regions;
index 5959ae86e57dd6575f44c94baab0b02c693fa7c4..60abdb1081ad5277c5044227c59540ff6d4348a1 100644 (file)
@@ -1598,7 +1598,7 @@ smsc9420_probe(struct pci_dev *pdev, const struct pci_device_id *id)
                goto out_free_netdev_2;
        }
 
-       if (pci_set_dma_mask(pdev, DMA_32BIT_MASK)) {
+       if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) {
                printk(KERN_ERR "No usable DMA configuration, aborting.\n");
                goto out_free_regions_3;
        }
index 2312d10f3b54647d01267f046132d1b0707b3293..d2dfe0ab5106eab3b333216d76302ace27490992 100644 (file)
@@ -3045,7 +3045,7 @@ static int __devinit gem_init_one(struct pci_dev *pdev,
            !pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) {
                pci_using_dac = 1;
        } else {
-               err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
+               err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
                if (err) {
                        printk(KERN_ERR PFX "No usable DMA configuration, "
                               "aborting.\n");
index d77a0918a325f63218468f5b81950be5f43247e2..7f4a9683ba1e4962ebcf08025cce066383ec0e0d 100644 (file)
@@ -1945,8 +1945,8 @@ bdx_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
            !(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)) ||
-                   (err = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK))) {
+               if ((err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) ||
+                   (err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32)))) {
                        printk(KERN_ERR "tehuti: No usable DMA configuration"
                                        ", aborting\n");
                        goto err_dma;
index 121dda917fdc1850797c1464e07ee82edf335bda..4fc875e5dcddfe2617436aa3059515594465714d 100644 (file)
 #define READ_REG(pp, reg)         readl(pp->pBdxRegs + reg)
 #define WRITE_REG(pp, reg, val)   writel(val, pp->pBdxRegs + reg)
 
-#ifndef DMA_32BIT_MASK
-#   define DMA_32BIT_MASK  0x00000000ffffffffULL
-#endif
-
 #ifndef NET_IP_ALIGN
 #   define NET_IP_ALIGN 2
 #endif
index 5ba91d7f7587216701489e635777ddf33100b4f3..6a736dda3ee2e199ef176b2f4ae7ec96fdbc8d25 100644 (file)
@@ -13228,7 +13228,7 @@ static int __devinit tg3_init_one(struct pci_dev *pdev,
         * do DMA address check in tg3_start_xmit().
         */
        if (tp->tg3_flags2 & TG3_FLG2_IS_5788)
-               persist_dma_mask = dma_mask = DMA_32BIT_MASK;
+               persist_dma_mask = dma_mask = DMA_BIT_MASK(32);
        else if (tp->tg3_flags & TG3_FLAG_40BIT_DMA_BUG) {
                persist_dma_mask = dma_mask = DMA_BIT_MASK(40);
 #ifdef CONFIG_HIGHMEM
@@ -13238,7 +13238,7 @@ static int __devinit tg3_init_one(struct pci_dev *pdev,
                persist_dma_mask = dma_mask = DMA_BIT_MASK(64);
 
        /* Configure DMA attributes. */
-       if (dma_mask > DMA_32BIT_MASK) {
+       if (dma_mask > DMA_BIT_MASK(32)) {
                err = pci_set_dma_mask(pdev, dma_mask);
                if (!err) {
                        dev->features |= NETIF_F_HIGHDMA;
@@ -13251,8 +13251,8 @@ static int __devinit tg3_init_one(struct pci_dev *pdev,
                        }
                }
        }
-       if (err || dma_mask == DMA_32BIT_MASK) {
-               err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
+       if (err || dma_mask == DMA_BIT_MASK(32)) {
+               err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
                if (err) {
                        printk(KERN_ERR PFX "No usable DMA configuration, "
                               "aborting.\n");
@@ -13393,7 +13393,7 @@ static int __devinit tg3_init_one(struct pci_dev *pdev,
               (tp->tg3_flags2 & TG3_FLG2_TSO_CAPABLE) != 0);
        printk(KERN_INFO "%s: dma_rwctrl[%08x] dma_mask[%d-bit]\n",
               dev->name, tp->dma_rwctrl,
-              (pdev->dma_mask == DMA_32BIT_MASK) ? 32 :
+              (pdev->dma_mask == DMA_BIT_MASK(32)) ? 32 :
                (((u64) pdev->dma_mask == DMA_BIT_MASK(40)) ? 40 : 64));
 
        return 0;
index 68b967b585aa95318389d91e5da5d5199f654c73..aa6964922d5e20b54be7d5c6238b2ca72312a8f3 100644 (file)
@@ -570,7 +570,7 @@ static int __devinit TLan_probe1(struct pci_dev *pdev,
 
                priv->adapter = &board_info[ent->driver_data];
 
-               rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
+               rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
                if (rc) {
                        printk(KERN_ERR "TLAN: No suitable PCI mapping available.\n");
                        goto err_out_free_dev;
index f309b8f703bd9fa828f338f62f234815b22ee54a..2e70ee8f1459981089a73fd4a75b722cc112c46d 100644 (file)
@@ -267,7 +267,7 @@ static int __devinit streamer_init_one(struct pci_dev *pdev,
 #endif
 #endif
 
-       rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
+       rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
        if (rc) {
                printk(KERN_ERR "%s: No suitable PCI mapping available.\n",
                                dev->name);
index e2c9d0f5a75507c39ce512824deccee80d002e4c..f2e669974c787e0270a403f85235e0e4375dc0b4 100644 (file)
@@ -383,7 +383,7 @@ static int __devinit dmfe_init_one (struct pci_dev *pdev,
                return -ENOMEM;
        SET_NETDEV_DEV(dev, &pdev->dev);
 
-       if (pci_set_dma_mask(pdev, DMA_32BIT_MASK)) {
+       if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) {
                printk(KERN_WARNING DRV_NAME
                        ": 32-bit PCI DMA not available.\n");
                err = -ENODEV;
index c227db0796214b011a2f268bea94ed95f5f33fd9..8761a5a5bd79bdc620d3af577202a9b6e688239e 100644 (file)
@@ -282,7 +282,7 @@ static int __devinit uli526x_init_one (struct pci_dev *pdev,
                return -ENOMEM;
        SET_NETDEV_DEV(dev, &pdev->dev);
 
-       if (pci_set_dma_mask(pdev, DMA_32BIT_MASK)) {
+       if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) {
                printk(KERN_WARNING DRV_NAME ": 32-bit PCI DMA not available.\n");
                err = -ENODEV;
                goto err_out_free;
index c61a01b029af78439addf39c35a2a4e9c6e43346..264e61404f345a8d36d9ee2cdabf2df4ec2a99f9 100644 (file)
@@ -375,7 +375,7 @@ static int __devinit w840_probe1 (struct pci_dev *pdev,
 
        irq = pdev->irq;
 
-       if (pci_set_dma_mask(pdev, DMA_32BIT_MASK)) {
+       if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) {
                printk(KERN_WARNING "Winbond-840: Device %s disabled due to DMA limitations.\n",
                       pci_name(pdev));
                return -EIO;
index 9dd4f76a2ff5846ee4c14f066939593768e2a328..cf25eb41b1ce7023559c90f02422d502703feb1e 100644 (file)
@@ -2406,7 +2406,7 @@ typhoon_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
                goto error_out_disable;
        }
 
-       err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
+       err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
        if(err < 0) {
                printk(ERR_PFX "%s: No usable DMA configuration\n",
                       pci_name(pdev));
index 880eaf07413b0fc33ce99a404d27bf859a60e207..45daba726b665fd753a1338244536595a00099f6 100644 (file)
@@ -686,7 +686,7 @@ static int __devinit rhine_init_one(struct pci_dev *pdev,
                goto err_out;
 
        /* this should always be supported */
-       rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
+       rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
        if (rc) {
                printk(KERN_ERR "32-bit PCI DMA addresses not supported by "
                       "the card!?\n");
index 887acb0dc8075f183925c19225d5d4cf725695dd..850d70d7b05dc9adce9dc2828095e7cfc983402e 100644 (file)
@@ -633,8 +633,8 @@ static int __devinit wanxl_pci_init_one(struct pci_dev *pdev,
        /* FIXME when PCI/DMA subsystems are fixed.
           We set both dma_mask and consistent_dma_mask back to 32 bits
           to indicate the card can do 32-bit DMA addressing */
-       if (pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK) ||
-           pci_set_dma_mask(pdev, DMA_32BIT_MASK)) {
+       if (pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32)) ||
+           pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) {
                printk(KERN_ERR "wanXL: No usable DMA configuration\n");
                wanxl_pci_remove_one(pdev);
                return -EIO;
index fc0897fb22390c87d908ceefdc0a4ea05193e383..f7182179501800e31e23ba4f3db5562d87a843bc 100644 (file)
@@ -1804,8 +1804,8 @@ static int __devinit adm8211_probe(struct pci_dev *pdev,
                return err; /* someone else grabbed it? don't disable it */
        }
 
-       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))) {
                printk(KERN_ERR "%s (adm8211): No suitable DMA available\n",
                       pci_name(pdev));
                goto err_free_reg;
index 5d57d774e466b0308b47df24b5871005dcc4fc51..a08bc8a4fb6916f17850f87d0ee7e651648744dc 100644 (file)
@@ -445,7 +445,7 @@ ath5k_pci_probe(struct pci_dev *pdev,
        }
 
        /* XXX 32-bit addressing only */
-       ret = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
+       ret = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
        if (ret) {
                dev_err(&pdev->dev, "32-bit DMA not available\n");
                goto err_dis;
index 461d680d2cec4355591ef797f5c42323658100dc..de1964f7d9e00f0c08322da9a2581044d94a58e1 100644 (file)
@@ -777,7 +777,7 @@ static u64 supported_dma_mask(struct b43_wldev *dev)
        b43_write32(dev, mmio_base + B43_DMA32_TXCTL, B43_DMA32_TXADDREXT_MASK);
        tmp = b43_read32(dev, mmio_base + B43_DMA32_TXCTL);
        if (tmp & B43_DMA32_TXADDREXT_MASK)
-               return DMA_32BIT_MASK;
+               return DMA_BIT_MASK(32);
 
        return DMA_30BIT_MASK;
 }
@@ -786,7 +786,7 @@ static enum b43_dmatype dma_mask_to_engine_type(u64 dmamask)
 {
        if (dmamask == DMA_30BIT_MASK)
                return B43_DMA_30BIT;
-       if (dmamask == DMA_32BIT_MASK)
+       if (dmamask == DMA_BIT_MASK(32))
                return B43_DMA_32BIT;
        if (dmamask == DMA_BIT_MASK(64))
                return B43_DMA_64BIT;
@@ -1000,11 +1000,11 @@ static int b43_dma_set_mask(struct b43_wldev *dev, u64 mask)
                if (!err)
                        break;
                if (mask == DMA_BIT_MASK(64)) {
-                       mask = DMA_32BIT_MASK;
+                       mask = DMA_BIT_MASK(32);
                        fallback = 1;
                        continue;
                }
-               if (mask == DMA_32BIT_MASK) {
+               if (mask == DMA_BIT_MASK(32)) {
                        mask = DMA_30BIT_MASK;
                        fallback = 1;
                        continue;
index 61bb91266aa874a2834bcd87a87f6958f3840bf3..1d3e0d239314cb96ecd266d76fb2ba429aec57ef 100644 (file)
@@ -854,7 +854,7 @@ static u64 supported_dma_mask(struct b43legacy_wldev *dev)
        tmp = b43legacy_read32(dev, mmio_base +
                               B43legacy_DMA32_TXCTL);
        if (tmp & B43legacy_DMA32_TXADDREXT_MASK)
-               return DMA_32BIT_MASK;
+               return DMA_BIT_MASK(32);
 
        return DMA_30BIT_MASK;
 }
@@ -863,7 +863,7 @@ static enum b43legacy_dmatype dma_mask_to_engine_type(u64 dmamask)
 {
        if (dmamask == DMA_30BIT_MASK)
                return B43legacy_DMA_30BIT;
-       if (dmamask == DMA_32BIT_MASK)
+       if (dmamask == DMA_BIT_MASK(32))
                return B43legacy_DMA_32BIT;
        if (dmamask == DMA_BIT_MASK(64))
                return B43legacy_DMA_64BIT;
@@ -1043,11 +1043,11 @@ static int b43legacy_dma_set_mask(struct b43legacy_wldev *dev, u64 mask)
                if (!err)
                        break;
                if (mask == DMA_BIT_MASK(64)) {
-                       mask = DMA_32BIT_MASK;
+                       mask = DMA_BIT_MASK(32);
                        fallback = 1;
                        continue;
                }
-               if (mask == DMA_32BIT_MASK) {
+               if (mask == DMA_BIT_MASK(32)) {
                        mask = DMA_30BIT_MASK;
                        fallback = 1;
                        continue;
index f4e963ba768bd49537186d0c3b2112e0b9213ff3..97e5647ff050d665fb7bd5c9f587d1b64f5be046 100644 (file)
@@ -6207,7 +6207,7 @@ static int ipw2100_pci_init_one(struct pci_dev *pci_dev,
        pci_set_master(pci_dev);
        pci_set_drvdata(pci_dev, priv);
 
-       err = pci_set_dma_mask(pci_dev, DMA_32BIT_MASK);
+       err = pci_set_dma_mask(pci_dev, DMA_BIT_MASK(32));
        if (err) {
                printk(KERN_WARNING DRV_NAME
                       "Error calling pci_set_dma_mask.\n");
index e17a4593e1f5f1d3c82fa5830b51d7c9bf78628a..bd4dbcfe1bbe9c54b675b07a8a9ed74004894a8f 100644 (file)
@@ -11631,9 +11631,9 @@ static int __devinit ipw_pci_probe(struct pci_dev *pdev,
 
        pci_set_master(pdev);
 
-       err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
+       err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
        if (!err)
-               err = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
+               err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
        if (err) {
                printk(KERN_WARNING DRV_NAME ": No suitable DMA available.\n");
                goto out_pci_disable_device;
index 9d5f97dd7c738508afb731ac1b6ac0fe7fbbe928..ce729281ff62957db12127e095fe3cc96d1559f2 100644 (file)
@@ -4998,9 +4998,9 @@ static int iwl3945_pci_probe(struct pci_dev *pdev, const struct pci_device_id *e
 
        pci_set_master(pdev);
 
-       err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
+       err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
        if (!err)
-               err = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
+               err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
        if (err) {
                IWL_WARN(priv, "No suitable DMA available.\n");
                goto out_pci_disable_device;
index 9a72b1e3e163bb597a075a11c65e9a66a3958312..30876728d7e6ecd4d7a3b64085f9c44c883f33f0 100644 (file)
@@ -120,7 +120,7 @@ prism54_probe(struct pci_dev *pdev, const struct pci_device_id *id)
        }
 
        /* enable PCI DMA */
-       if (pci_set_dma_mask(pdev, DMA_32BIT_MASK)) {
+       if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) {
                printk(KERN_ERR "%s: 32-bit PCI DMA not supported", DRV_NAME);
                goto do_pci_disable_device;
         }
index e616c20d4a782c4dd014927057342e779396548a..43fa0f849003f5811c752168d37f9d274ef76705 100644 (file)
@@ -288,7 +288,7 @@ int rt2x00pci_probe(struct pci_dev *pci_dev, const struct pci_device_id *id)
        if (pci_set_mwi(pci_dev))
                ERROR_PROBE("MWI not available.\n");
 
-       if (dma_set_mask(&pci_dev->dev, DMA_32BIT_MASK)) {
+       if (dma_set_mask(&pci_dev->dev, DMA_BIT_MASK(32))) {
                ERROR_PROBE("PCI DMA not supported.\n");
                retval = -EIO;
                goto exit_disable_device;
index 09dc98b84553bd9bd7e17357ac404ed0abd85208..fb3a3f3fca7a4835aab7fef7bb45edd84a2df182 100644 (file)
@@ -56,7 +56,7 @@
 #define DOMAIN_MAX_ADDR(gaw) ((((u64)1) << gaw) - 1)
 
 #define IOVA_PFN(addr)         ((addr) >> PAGE_SHIFT)
-#define DMA_32BIT_PFN          IOVA_PFN(DMA_32BIT_MASK)
+#define DMA_32BIT_PFN          IOVA_PFN(DMA_BIT_MASK(32))
 #define DMA_64BIT_PFN          IOVA_PFN(DMA_BIT_MASK(64))
 
 /* global iommu list, set NULL for ignored DMAR units */
@@ -2080,15 +2080,15 @@ __intel_alloc_iova(struct device *dev, struct dmar_domain *domain,
        struct pci_dev *pdev = to_pci_dev(dev);
        struct iova *iova = NULL;
 
-       if (dma_mask <= DMA_32BIT_MASK || dmar_forcedac)
+       if (dma_mask <= DMA_BIT_MASK(32) || dmar_forcedac)
                iova = iommu_alloc_iova(domain, size, dma_mask);
        else {
                /*
                 * First try to allocate an io virtual address in
-                * DMA_32BIT_MASK and if that fails then try allocating
+                * DMA_BIT_MASK(32) and if that fails then try allocating
                 * from higher range
                 */
-               iova = iommu_alloc_iova(domain, size, DMA_32BIT_MASK);
+               iova = iommu_alloc_iova(domain, size, DMA_BIT_MASK(32));
                if (!iova)
                        iova = iommu_alloc_iova(domain, size, dma_mask);
        }
index 5c13f61bfb1b5003f67ea3142275444f776242e4..74d0bfa3f3108c020ed9c7b59a0262e8549188df 100644 (file)
@@ -381,9 +381,9 @@ static struct rio_dev *rio_setup_device(struct rio_net *net,
        rdev->dev.release = rio_release_dev;
        rio_dev_get(rdev);
 
-       rdev->dma_mask = DMA_32BIT_MASK;
+       rdev->dma_mask = DMA_BIT_MASK(32);
        rdev->dev.dma_mask = &rdev->dma_mask;
-       rdev->dev.coherent_dma_mask = DMA_32BIT_MASK;
+       rdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
 
        if ((rdev->pef & RIO_PEF_INB_DOORBELL) &&
            (rdev->dst_ops & RIO_DST_OPS_DOORBELL))
index 6697652740b8dfbd8a35a3aadf7dbf9d595d8c03..fdb14ec4fd47aeb156c1adb9558acfb18b3b4ddd 100644 (file)
@@ -2018,8 +2018,8 @@ static int __devinit twa_probe(struct pci_dev *pdev, const struct pci_device_id
 
        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)) {
+               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, 0x23, "Failed to set dma mask");
                        retval = -ENODEV;
                        goto out_disable_device;
index 0742e68466565459fffc6a7ae6ffaae4f91c9422..8e71e5e122b37c4b0d60263976abe27acf19a6d2 100644 (file)
@@ -234,7 +234,7 @@ static unsigned char tw_sense_table[][4] =
 #define TW_IOCTL_TIMEOUT                      25 /* 25 seconds */
 #define TW_IOCTL_CHRDEV_TIMEOUT               60 /* 60 seconds */
 #define TW_IOCTL_CHRDEV_FREE                  -1
-#define TW_DMA_MASK                          DMA_32BIT_MASK
+#define TW_DMA_MASK                          DMA_BIT_MASK(32)
 #define TW_MAX_CDB_LEN                       16
 
 /* Bitmask macros to eliminate bitfields */
index 2d689af2466419a70d51afddad85572db31dc507..1ddcf4031d4cf6b21dac5bb95e06ae7117eb577a 100644 (file)
@@ -667,7 +667,7 @@ static int __init BusLogic_InitializeMultiMasterProbeInfo(struct BusLogic_HostAd
                if (pci_enable_device(PCI_Device))
                        continue;
 
-               if (pci_set_dma_mask(PCI_Device, DMA_32BIT_MASK ))
+               if (pci_set_dma_mask(PCI_Device, DMA_BIT_MASK(32) ))
                        continue;
 
                Bus = PCI_Device->bus->number;
@@ -834,7 +834,7 @@ static int __init BusLogic_InitializeMultiMasterProbeInfo(struct BusLogic_HostAd
                if (pci_enable_device(PCI_Device))
                        continue;
 
-               if (pci_set_dma_mask(PCI_Device, DMA_32BIT_MASK))
+               if (pci_set_dma_mask(PCI_Device, DMA_BIT_MASK(32)))
                        continue;
 
                Bus = PCI_Device->bus->number;
@@ -888,7 +888,7 @@ static int __init BusLogic_InitializeFlashPointProbeInfo(struct BusLogic_HostAda
                if (pci_enable_device(PCI_Device))
                        continue;
 
-               if (pci_set_dma_mask(PCI_Device, DMA_32BIT_MASK))
+               if (pci_set_dma_mask(PCI_Device, DMA_BIT_MASK(32)))
                        continue;
 
                Bus = PCI_Device->bus->number;
index 964769f66eac98e9bc4ef8423a9e99d112323739..208d6df9ed5905d36b8fa56a82e95ae2f085ac5a 100644 (file)
@@ -1094,7 +1094,7 @@ static int __devinit inia100_probe_one(struct pci_dev *pdev,
 
        if (pci_enable_device(pdev))
                goto out;
-       if (pci_set_dma_mask(pdev, DMA_32BIT_MASK)) {
+       if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) {
                printk(KERN_WARNING "Unable to set 32bit DMA "
                                    "on inia100 adapter, ignoring.\n");
                goto out_disable_device;
index e83ef8aaa98c8d808ed1f5c81619e8075772cc61..280261c451d6fbf89a9ee86bb4bb7f2aee9dbd09 100644 (file)
@@ -1407,8 +1407,8 @@ int aac_get_adapter_info(struct aac_dev* dev)
                        if (!dev->in_reset)
                                printk(KERN_INFO"%s%d: 64 Bit DAC enabled\n",
                                        dev->name, dev->id);
-               } else if (!pci_set_dma_mask(dev->pdev, DMA_32BIT_MASK) &&
-                       !pci_set_consistent_dma_mask(dev->pdev, DMA_32BIT_MASK)) {
+               } else if (!pci_set_dma_mask(dev->pdev, DMA_BIT_MASK(32)) &&
+                       !pci_set_consistent_dma_mask(dev->pdev, DMA_BIT_MASK(32))) {
                        printk(KERN_INFO"%s%d: DMA mask set failed, 64 Bit DAC disabled\n",
                                dev->name, dev->id);
                        dev->dac_support = 0;
index d24c2670040bd4d09d9f2df14832efc3bb3befa1..3b69c2d98dd6e6b15acca67bdbed5210ecb5cc2a 100644 (file)
@@ -1210,14 +1210,14 @@ static int _aac_reset_adapter(struct aac_dev *aac, int forced)
                  ((retval = pci_set_consistent_dma_mask(aac->pdev, DMA_31BIT_MASK))))
                        goto out;
        } else {
-               if (((retval = pci_set_dma_mask(aac->pdev, DMA_32BIT_MASK))) ||
-                 ((retval = pci_set_consistent_dma_mask(aac->pdev, DMA_32BIT_MASK))))
+               if (((retval = pci_set_dma_mask(aac->pdev, DMA_BIT_MASK(32)))) ||
+                 ((retval = pci_set_consistent_dma_mask(aac->pdev, DMA_BIT_MASK(32)))))
                        goto out;
        }
        if ((retval = (*(aac_get_driver_ident(index)->init))(aac)))
                goto out;
        if (quirks & AAC_QUIRK_31BIT)
-               if ((retval = pci_set_dma_mask(aac->pdev, DMA_32BIT_MASK)))
+               if ((retval = pci_set_dma_mask(aac->pdev, DMA_BIT_MASK(32))))
                        goto out;
        if (jafo) {
                aac->thread = kthread_run(aac_command_thread, aac, aac->name);
index c507719c0d445ab548ca38cd8aa77bc176efd148..3c3ed4b3311a3e0dde1ca1b51229c99096a73452 100644 (file)
@@ -1095,8 +1095,8 @@ static int __devinit aac_probe_one(struct pci_dev *pdev,
                goto out;
        error = -ENODEV;
 
-       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)))
                goto out_disable_pdev;
        /*
         * If the quirk31 bit is set, the adapter needs adapter
@@ -1154,7 +1154,7 @@ static int __devinit aac_probe_one(struct pci_dev *pdev,
         * address space.
         */
        if (aac_drivers[index].quirks & AAC_QUIRK_31BIT)
-               if (pci_set_dma_mask(pdev, DMA_32BIT_MASK))
+               if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32)))
                        goto out_deinit;
 
        aac->maximum_num_channels = aac_drivers[index].channels;
index c583d89f569a92da61b85d68e9fed85eadd2b363..8f686122d54ecc61104b5549f341c97e7e346fb5 100644 (file)
@@ -197,13 +197,13 @@ ahd_linux_pci_dev_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                if (required_mask > DMA_BIT_MASK(39) &&
                    dma_set_mask(dev, DMA_BIT_MASK(64)) == 0)
                        ahd->flags |= AHD_64BIT_ADDRESSING;
-               else if (required_mask > DMA_32BIT_MASK &&
+               else if (required_mask > DMA_BIT_MASK(32) &&
                         dma_set_mask(dev, DMA_BIT_MASK(39)) == 0)
                        ahd->flags |= AHD_39BIT_ADDRESSING;
                else
-                       dma_set_mask(dev, DMA_32BIT_MASK);
+                       dma_set_mask(dev, DMA_BIT_MASK(32));
        } else {
-               dma_set_mask(dev, DMA_32BIT_MASK);
+               dma_set_mask(dev, DMA_BIT_MASK(32));
        }
        ahd->dev_softc = pci;
        error = ahd_pci_config(ahd, entry);
index 00f5b98685749ae567f2e63c444407f6fe644c61..78fc70c24e078638478b8f9defd9dbd801eaea4f 100644 (file)
@@ -241,10 +241,10 @@ ahc_linux_pci_dev_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
        if (sizeof(dma_addr_t) > 4
            && ahc->features & AHC_LARGE_SCBS
            && dma_set_mask(dev, mask_39bit) == 0
-           && dma_get_required_mask(dev) > DMA_32BIT_MASK) {
+           && dma_get_required_mask(dev) > DMA_BIT_MASK(32)) {
                ahc->flags |= AHC_39BIT_ADDRESSING;
        } else {
-               if (dma_set_mask(dev, DMA_32BIT_MASK)) {
+               if (dma_set_mask(dev, DMA_BIT_MASK(32))) {
                        ahc_free(ahc);
                        printk(KERN_WARNING "aic7xxx: No suitable DMA available.\n");
                        return (-ENODEV);
index 7edbe4309c614cf347a003c8920b4190340b7b9a..996f7224f90e2d32e39d9a109b5da16a814237e1 100644 (file)
@@ -793,8 +793,8 @@ static int __devinit asd_pci_probe(struct pci_dev *dev,
        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))
+       else if (!pci_set_dma_mask(dev, DMA_BIT_MASK(32))
+                && !pci_set_consistent_dma_mask(dev, DMA_BIT_MASK(32)))
                ;
        else {
                asd_printk("no suitable DMA mask for %s\n", pci_name(dev));
index e95b72dd34b11641d0c52e4c8ac44799c3e4e93b..80aac01b5a6f31c2f18e9eb9ae63ae9a21a0425d 100644 (file)
@@ -395,7 +395,7 @@ static int arcmsr_probe(struct pci_dev *pdev,
 
        error = pci_set_dma_mask(pdev, DMA_BIT_MASK(64));
        if (error) {
-               error = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
+               error = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
                if (error) {
                        printk(KERN_WARNING
                               "scsi%d: No suitable DMA mask available\n",
index 20ca0a6374b56a51f52777b18323aecb2e1a825f..b137e561f5bc715951145592d5569bae80e19893 100644 (file)
@@ -2568,7 +2568,7 @@ static int atp870u_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
        if (pci_enable_device(pdev))
                goto err_eio;
 
-        if (!pci_set_dma_mask(pdev, DMA_32BIT_MASK)) {
+        if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) {
                 printk(KERN_INFO "atp870u: use 32bit DMA mask.\n");
         } else {
                 printk(KERN_ERR "atp870u: DMA mask required but not available.\n");
index 75a94e438fa580a5f974461ccb6e59121c456d99..b6af63ca980b4f1cb6be6acb2ca6762fe3f67548 100644 (file)
@@ -1015,14 +1015,14 @@ static int adpt_install_hba(struct scsi_host_template* sht, struct pci_dev* pDev
         */
        if (sizeof(dma_addr_t) > 4 &&
            pci_set_dma_mask(pDev, DMA_BIT_MASK(64)) == 0) {
-               if (dma_get_required_mask(&pDev->dev) > DMA_32BIT_MASK)
+               if (dma_get_required_mask(&pDev->dev) > DMA_BIT_MASK(32))
                        dma64 = 1;
        }
-       if (!dma64 && pci_set_dma_mask(pDev, DMA_32BIT_MASK) != 0)
+       if (!dma64 && pci_set_dma_mask(pDev, DMA_BIT_MASK(32)) != 0)
                return -EINVAL;
 
        /* adapter only supports message blocks below 4GB */
-       pci_set_consistent_dma_mask(pDev, DMA_32BIT_MASK);
+       pci_set_consistent_dma_mask(pDev, DMA_BIT_MASK(32));
 
        base_addr0_phys = pci_resource_start(pDev,0);
        hba_map0_area_size = pci_resource_len(pDev,0);
index 976cdd5c94efc3cfd9530dfa9383e384d69f36dd..be5099dd94b5d4e655385ad59364dbd585da1910 100644 (file)
@@ -1426,7 +1426,7 @@ static int port_detect(unsigned long port_base, unsigned int j,
 
        if (ha->pdev) {
                pci_set_master(ha->pdev);
-               if (pci_set_dma_mask(ha->pdev, DMA_32BIT_MASK))
+               if (pci_set_dma_mask(ha->pdev, DMA_BIT_MASK(32)))
                        printk("%s: warning, pci_set_dma_mask failed.\n",
                               ha->board_name);
        }
index 4982344f1f097c748b0fbda3241482aa23988f89..185e6bc4dd40076519dea524d9687fa8cc0f51f5 100644 (file)
@@ -5023,7 +5023,7 @@ static int __devinit gdth_pci_probe_one(gdth_pci_str *pcistr,
        /* 64-bit DMA only supported from FW >= x.43 */
        if (!(ha->cache_feat & ha->raw_feat & ha->screen_feat & GDT_64BIT) ||
            !ha->dma64_support) {
-               if (pci_set_dma_mask(pdev, DMA_32BIT_MASK)) {
+               if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) {
                        printk(KERN_WARNING "GDT-PCI %d: "
                                "Unable to set 32-bit DMA\n", ha->hanum);
                                goto out_free_coal_stat;
@@ -5032,7 +5032,7 @@ static int __devinit gdth_pci_probe_one(gdth_pci_str *pcistr,
                shp->max_cmd_len = 16;
                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)) {
+               } else if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) {
                        printk(KERN_WARNING "GDT-PCI %d: "
                                "Unable to set 64/32-bit DMA\n", ha->hanum);
                        goto out_free_coal_stat;
index a13d78150cb509c22754b0a56b1398e26382ea18..c596ab5f05c358b3a95ded2d34e248e941412d49 100644 (file)
@@ -959,7 +959,7 @@ static int __devinit hptiop_probe(struct pci_dev *pcidev,
 
        /* Enable 64bit DMA if possible */
        if (pci_set_dma_mask(pcidev, DMA_BIT_MASK(64))) {
-               if (pci_set_dma_mask(pcidev, DMA_32BIT_MASK)) {
+               if (pci_set_dma_mask(pcidev, DMA_BIT_MASK(32))) {
                        printk(KERN_ERR "hptiop: fail to set dma_mask\n");
                        goto disable_pci_device;
                }
index 5529518ff2fa8871c610857c39528adc28c37c98..89a59484be02f58be4cbbfbf864d9f9ecf8ee48f 100644 (file)
@@ -2856,7 +2856,7 @@ static int initio_probe_one(struct pci_dev *pdev,
                reg = 0;
        bios_seg = (bios_seg << 8) + ((u16) ((reg & 0xFF00) >> 8));
 
-       if (pci_set_dma_mask(pdev, DMA_32BIT_MASK)) {
+       if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) {
                printk(KERN_WARNING  "i91u: Could not set 32 bit DMA mask\n");
                error = -ENODEV;
                goto out_disable_device;
index def473f0a98f78c239988741fcf7e70e05f52416..c09d77591f92b8576432544243781ed4df11d39a 100644 (file)
@@ -7498,7 +7498,7 @@ static int __devinit ipr_probe_ioa(struct pci_dev *pdev,
 
        pci_set_master(pdev);
 
-       rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
+       rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
        if (rc < 0) {
                dev_err(&pdev->dev, "Failed to set PCI DMA mask\n");
                goto cleanup_nomem;
index 45296a975f8be63136786e795a051b88ccc741c5..f83a116955f2f1c6409acfae27d2e91719d42276 100644 (file)
@@ -7051,7 +7051,7 @@ ips_init_phase1(struct pci_dev *pci_dev, int *indexPtr)
            !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) {
+               if (pci_set_dma_mask(ha->pcidev, DMA_BIT_MASK(32)) != 0) {
                        printk(KERN_WARNING "Unable to set DMA Mask\n");
                        return ips_abort_init(ha, index);
                }
index f23c4ca9a2ee334a89bd0d8a9354f988b64723c3..b3d31315ac32daea6321968eedca52cb921ade3a 100644 (file)
@@ -108,7 +108,7 @@ lasi700_probe(struct parisc_device *dev)
        }
 
        hostdata->dev = &dev->dev;
-       dma_set_mask(&dev->dev, DMA_32BIT_MASK);
+       dma_set_mask(&dev->dev, DMA_BIT_MASK(32));
        hostdata->base = ioremap_nocache(base, 0x100);
        hostdata->differential = 0;
 
index c255b4d94b1b944bb7365a58bd3252cdce8ff86b..06874e6009ea8931ddad8feef4333637ea49f858 100644 (file)
@@ -2661,7 +2661,7 @@ lpfc_pci_probe_one(struct pci_dev *pdev, const struct pci_device_id *pid)
        pci_try_set_mwi(pdev);
 
        if (pci_set_dma_mask(phba->pcidev, DMA_BIT_MASK(64)) != 0)
-               if (pci_set_dma_mask(phba->pcidev, DMA_32BIT_MASK) != 0)
+               if (pci_set_dma_mask(phba->pcidev, DMA_BIT_MASK(32)) != 0)
                        goto out_idr_remove;
 
        /*
index 112991d46d95d6398adcff7a20c87b420da65bce..49eb0612d5af03f10e8b2ad591ed0bbf25943557 100644 (file)
@@ -2021,7 +2021,7 @@ make_local_pdev(adapter_t *adapter, struct pci_dev **pdev)
 
        memcpy(*pdev, adapter->dev, sizeof(struct pci_dev));
 
-       if( pci_set_dma_mask(*pdev, DMA_32BIT_MASK) != 0 ) {
+       if( pci_set_dma_mask(*pdev, DMA_BIT_MASK(32)) != 0 ) {
                kfree(*pdev);
                return -1;
        }
@@ -4796,7 +4796,7 @@ megaraid_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
                pci_set_dma_mask(pdev, DMA_BIT_MASK(64));
                adapter->has_64bit_addr = 1;
        } else  {
-               pci_set_dma_mask(pdev, DMA_32BIT_MASK);
+               pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
                adapter->has_64bit_addr = 0;
        }
                
index b2c19449119dd43ac527b4547c5175f6cd290f08..234f0b7eb21c1783b2503c7c49724139cae45618 100644 (file)
@@ -473,7 +473,7 @@ megaraid_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
 
        // Setup the default DMA mask. This would be changed later on
        // depending on hardware capabilities
-       if (pci_set_dma_mask(adapter->pdev, DMA_32BIT_MASK) != 0) {
+       if (pci_set_dma_mask(adapter->pdev, DMA_BIT_MASK(32)) != 0) {
 
                con_log(CL_ANN, (KERN_WARNING
                        "megaraid: pci_set_dma_mask failed:%d\n", __LINE__));
@@ -904,7 +904,7 @@ megaraid_init_mbox(adapter_t *adapter)
                        con_log(CL_ANN, (KERN_WARNING
                                "megaraid: DMA mask for 64-bit failed\n"));
 
-                       if (pci_set_dma_mask (adapter->pdev, DMA_32BIT_MASK)) {
+                       if (pci_set_dma_mask (adapter->pdev, DMA_BIT_MASK(32))) {
                                con_log(CL_ANN, (KERN_WARNING
                                        "megaraid: 32-bit DMA mask failed\n"));
                                goto out_free_sysfs_res;
index 713de85771f3baa6747b4488f80719348d12c291..7dc3d1894b1a281580a83aff2f4660b46daebfa1 100644 (file)
@@ -2499,11 +2499,11 @@ megasas_set_dma_mask(struct pci_dev *pdev)
        if (IS_DMA64) {
                if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64)) != 0) {
 
-                       if (pci_set_dma_mask(pdev, DMA_32BIT_MASK) != 0)
+                       if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) != 0)
                                goto fail_set_dma_mask;
                }
        } else {
-               if (pci_set_dma_mask(pdev, DMA_32BIT_MASK) != 0)
+               if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) != 0)
                        goto fail_set_dma_mask;
        }
        return 0;
index d8093a2884388cf088e3a95599b3273e96eb4b4a..e4acebd10d1b772efa0f323eaff61e842df31e64 100644 (file)
@@ -878,7 +878,7 @@ static int pci_go_64(struct pci_dev *pdev)
        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);
+                       rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
                        if (rc) {
                                dev_printk(KERN_ERR, &pdev->dev,
                                           "64-bit DMA enable failed\n");
@@ -886,13 +886,13 @@ static int pci_go_64(struct pci_dev *pdev)
                        }
                }
        } else {
-               rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
+               rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
                if (rc) {
                        dev_printk(KERN_ERR, &pdev->dev,
                                   "32-bit DMA enable failed\n");
                        return rc;
                }
-               rc = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
+               rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
                if (rc) {
                        dev_printk(KERN_ERR, &pdev->dev,
                                   "32-bit consistent DMA enable failed\n");
index d06ec5aa69249f1f86dc24ef715907f66ba59fd5..2be7d5b018d2d216827e0cd3c7cd27953a10d2e0 100644 (file)
@@ -2672,7 +2672,7 @@ static int nsp32_detect(struct pci_dev *pdev)
        /*
         * setup DMA 
         */
-       if (pci_set_dma_mask(pdev, DMA_32BIT_MASK) != 0) {
+       if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) != 0) {
                nsp32_msg (KERN_ERR, "failed to set PCI DMA mask");
                goto scsi_unregister;
        }
index 18f7f98ba571ee88b6b1e35ba2d5e38dff42b5be..687dcf2d01542e5aca608399a227aeb9ce4cacc5 100644 (file)
@@ -4276,7 +4276,7 @@ qla1280_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
 
 #ifdef QLA_64BIT_PTR
        if (pci_set_dma_mask(ha->pdev, DMA_BIT_MASK(64))) {
-               if (pci_set_dma_mask(ha->pdev, DMA_32BIT_MASK)) {
+               if (pci_set_dma_mask(ha->pdev, DMA_BIT_MASK(32))) {
                        printk(KERN_WARNING "scsi(%li): Unable to set a "
                               "suitable DMA mask - aborting\n", ha->host_no);
                        error = -ENODEV;
@@ -4286,7 +4286,7 @@ qla1280_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
                dprintk(2, "scsi(%li): 64 Bit PCI Addressing Enabled\n",
                        ha->host_no);
 #else
-       if (pci_set_dma_mask(ha->pdev, DMA_32BIT_MASK)) {
+       if (pci_set_dma_mask(ha->pdev, DMA_BIT_MASK(32))) {
                printk(KERN_WARNING "scsi(%li): Unable to set a "
                       "suitable DMA mask - aborting\n", ha->host_no);
                error = -ENODEV;
index f60e136b5e1b5bd30ed5c8e9d91911bcf84468cf..e4fdcdad80d0b7c12c1be44b0eb75a834ef37d49 100644 (file)
@@ -1188,8 +1188,8 @@ qla2x00_config_dma_addressing(struct qla_hw_data *ha)
                }
        }
 
-       dma_set_mask(&ha->pdev->dev, DMA_32BIT_MASK);
-       pci_set_consistent_dma_mask(ha->pdev, DMA_32BIT_MASK);
+       dma_set_mask(&ha->pdev->dev, DMA_BIT_MASK(32));
+       pci_set_consistent_dma_mask(ha->pdev, DMA_BIT_MASK(32));
 }
 
 static void
index d427fab7a183a89fb1d17f881444d24053eb3f5e..ec9da6ce8489ceedf36ab7efe8bd59c56cebfc45 100644 (file)
@@ -1375,10 +1375,10 @@ static void qla4xxx_config_dma_addressing(struct scsi_qla_host *ha)
                                  "Failed to set 64 bit PCI consistent mask; "
                                   "using 32 bit.\n");
                        retval = pci_set_consistent_dma_mask(ha->pdev,
-                                                            DMA_32BIT_MASK);
+                                                            DMA_BIT_MASK(32));
                }
        } else
-               retval = pci_set_dma_mask(ha->pdev, DMA_32BIT_MASK);
+               retval = pci_set_dma_mask(ha->pdev, DMA_BIT_MASK(32));
 }
 
 static int qla4xxx_slave_alloc(struct scsi_device *sdev)
index 77f0b2cdaa943c3784469c049eb5a24cafc894c7..37b3359e863e427e4a088366ea382a04273a6a69 100644 (file)
@@ -83,7 +83,7 @@ static int __init snirm710_probe(struct platform_device *dev)
        }
 
        hostdata->dev = &dev->dev;
-       dma_set_mask(&dev->dev, DMA_32BIT_MASK);
+       dma_set_mask(&dev->dev, DMA_BIT_MASK(32));
        hostdata->base = ioremap_nocache(base, 0x100);
        hostdata->differential = 0;
 
index 7cb8063c43554d435acb44d64684c6944c842327..8d2a95c4e5b56af930c46a76d760e53a9c9931a9 100644 (file)
@@ -1398,9 +1398,9 @@ static int stex_set_dma_mask(struct pci_dev * pdev)
        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);
+       ret = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
        if (!ret)
-               ret = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
+               ret = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
        return ret;
 }
 
index 23e782015880173a47684b166bff6196ea864963..583966ec82661f9959fe2434c853d50e2139d771 100644 (file)
@@ -1349,7 +1349,7 @@ static struct Scsi_Host * __devinit sym_attach(struct scsi_host_template *tpnt,
        if ((SYM_CONF_DMA_ADDRESSING_MODE > 0) && (np->features & FE_DAC) &&
                        !pci_set_dma_mask(pdev, DMA_DAC_MASK)) {
                set_dac(np);
-       } else if (pci_set_dma_mask(pdev, DMA_32BIT_MASK)) {
+       } else if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) {
                printf_warning("%s: No suitable DMA available\n", sym_name(np));
                goto attach_failed;
        }
index b707abe9082132ded3c36d58056b64f023861304..9ebc8706b6bfc7b70fcdd884a5328130d53e65d4 100644 (file)
@@ -1080,7 +1080,7 @@ int sym_hcb_attach(struct Scsi_Host *shost, struct sym_fw *fw, struct sym_nvram
  */
 
 #if   SYM_CONF_DMA_ADDRESSING_MODE == 0
-#define DMA_DAC_MASK   DMA_32BIT_MASK
+#define DMA_DAC_MASK   DMA_BIT_MASK(32)
 #define sym_build_sge(np, data, badd, len)     \
 do {                                           \
        (data)->addr = cpu_to_scr(badd);        \
index 4ff4c16014233b8e94fb32ed9c1de251ff91bfa6..25c0ffd2faa00bd73cf6642abeade61292f4d6e6 100644 (file)
@@ -477,8 +477,8 @@ static int __devinit agnx_pci_probe(struct pci_dev *pdev,
                return err;
        }
 
-       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))) {
                printk(KERN_ERR PFX "No suitable DMA available\n");
                goto err_free_reg;
        }
index 6a4d0b8e09607d33a5aff530b65f757e2b83a5a9..5869e1484a952e4491fb6825dba9829b6117c993 100644 (file)
@@ -855,9 +855,9 @@ static int __devinit probe(struct pci_dev *dev, const struct pci_device_id *id)
                printk(KERN_DEBUG "Using a 64-bit DMA mask.\n");
        } else
 #endif
-       if (!pci_set_dma_mask(dev, DMA_32BIT_MASK)) {
+       if (!pci_set_dma_mask(dev, DMA_BIT_MASK(32))) {
                printk(KERN_DEBUG "Could not set 64-bit DMA mask.\n");
-               pci_set_consistent_dma_mask(dev, DMA_32BIT_MASK);
+               pci_set_consistent_dma_mask(dev, DMA_BIT_MASK(32));
                /* use 32-bit DMA */
                printk(KERN_DEBUG "Using a 32-bit DMA mask.\n");
        } else {
index a77e1eee56934984c684e33a4dacc7a4bd418849..891f6e334672d61ee867af2ff453c406ee5aba86 100644 (file)
@@ -937,13 +937,13 @@ static int sxg_entry_probe(struct pci_dev *pcidev,
        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))) {
+               if ((err = pci_set_dma_mask(pcidev, DMA_BIT_MASK(32)))) {
                        DBG_ERROR
                            ("No usable DMA configuration, aborting  err[%x]\n",
                             err);
                        return err;
                }
-               DBG_ERROR("pci_set_dma_mask(DMA_32BIT_MASK) successful\n");
+               DBG_ERROR("pci_set_dma_mask(DMA_BIT_MASK(32)) successful\n");
        }
 
        DBG_ERROR("Call pci_request_regions\n");
index 9c9da35abc6c010c6929a1e515fc4179ef898111..1ba9f9a8c3088bd607fb95b5599e0982c6c8c9d2 100644 (file)
@@ -81,7 +81,7 @@ static int ps3_ehci_probe(struct ps3_system_bus_device *dev)
        int result;
        struct usb_hcd *hcd;
        unsigned int virq;
-       static u64 dummy_mask = DMA_32BIT_MASK;
+       static u64 dummy_mask = DMA_BIT_MASK(32);
 
        if (usb_disabled()) {
                result = -ENODEV;
index 3c1a3b5f89f19fb19dde0962b8b4e6a2e704b9e4..3d19103173286e849e54a21ede9012b04426ee24 100644 (file)
@@ -80,7 +80,7 @@ static int ps3_ohci_probe(struct ps3_system_bus_device *dev)
        int result;
        struct usb_hcd *hcd;
        unsigned int virq;
-       static u64 dummy_mask = DMA_32BIT_MASK;
+       static u64 dummy_mask = DMA_BIT_MASK(32);
 
        if (usb_disabled()) {
                result = -ENODEV;
index 79bb06c7a76b8dcd50a7e198fd393e2f19f3d95e..2e2784627ad66cf8502361fa59c2ad029e138d82 100644 (file)
@@ -162,8 +162,8 @@ static int whci_probe(struct pci_dev *pci, const struct pci_device_id *id)
        err = -ENXIO;
        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 if (!pci_set_dma_mask(pci, DMA_BIT_MASK(32)))
+               pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(32));
        else
                goto error_dma;
 
index d7d090d210317b258f400239fdf42d76bd8db7f6..8083b6a36a384c23ba1917b965328650d09535f3 100644 (file)
@@ -115,7 +115,7 @@ static inline u64 dma_get_mask(struct device *dev)
 {
        if (dev && dev->dma_mask && *dev->dma_mask)
                return *dev->dma_mask;
-       return DMA_32BIT_MASK;
+       return DMA_BIT_MASK(32);
 }
 
 extern u64 dma_get_required_mask(struct device *dev);
index 32e2bd3b11424ca7b0d7905930d3ea9b6adf14ff..2b0b5a7d2ced165b1e2b83e2df888c237349f23f 100644 (file)
@@ -549,7 +549,7 @@ swiotlb_alloc_coherent(struct device *hwdev, size_t size,
        dma_addr_t dev_addr;
        void *ret;
        int order = get_order(size);
-       u64 dma_mask = DMA_32BIT_MASK;
+       u64 dma_mask = DMA_BIT_MASK(32);
 
        if (hwdev && hwdev->coherent_dma_mask)
                dma_mask = hwdev->coherent_dma_mask;
index d1f242bd0ac544584ad9c7f4349261c7c7f37588..8f5098f92c370f81c937f8159827736b34c9742d 100644 (file)
@@ -909,8 +909,8 @@ snd_ad1889_create(struct snd_card *card,
                return err;
 
        /* check PCI availability (32bit DMA) */
-       if (pci_set_dma_mask(pci, DMA_32BIT_MASK) < 0 ||
-           pci_set_consistent_dma_mask(pci, DMA_32BIT_MASK) < 0) {
+       if (pci_set_dma_mask(pci, DMA_BIT_MASK(32)) < 0 ||
+           pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(32)) < 0) {
                printk(KERN_ERR PFX "error setting 32-bit DMA mask.\n");
                pci_disable_device(pci);
                return -ENXIO;
index 9ec122383eefbab4492fe9d180e6737f7b4f9ed0..7b72c88e449d24748ac043bb650a69b91f3dafa7 100644 (file)
@@ -151,8 +151,8 @@ snd_vortex_create(struct snd_card *card, struct pci_dev *pci, vortex_t ** rchip)
        // check PCI availability (DMA).
        if ((err = pci_enable_device(pci)) < 0)
                return err;
-       if (pci_set_dma_mask(pci, DMA_32BIT_MASK) < 0 ||
-           pci_set_consistent_dma_mask(pci, DMA_32BIT_MASK) < 0) {
+       if (pci_set_dma_mask(pci, DMA_BIT_MASK(32)) < 0 ||
+           pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(32)) < 0) {
                printk(KERN_ERR "error to set DMA mask\n");
                pci_disable_device(pci);
                return -ENXIO;
index 8eea29fc42fe8b7d56769ba9d40de84f38fc400f..4d34bb0d99d327120dde4bf5bea211f98a30105a 100644 (file)
@@ -279,8 +279,8 @@ static int __devinit snd_aw2_create(struct snd_card *card,
        pci_set_master(pci);
 
        /* check PCI availability (32bit DMA) */
-       if ((pci_set_dma_mask(pci, DMA_32BIT_MASK) < 0) ||
-           (pci_set_consistent_dma_mask(pci, DMA_32BIT_MASK) < 0)) {
+       if ((pci_set_dma_mask(pci, DMA_BIT_MASK(32)) < 0) ||
+           (pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(32)) < 0)) {
                printk(KERN_ERR "aw2: Impossible to set 32bit mask DMA\n");
                pci_disable_device(pci);
                return -ENXIO;
index df757575798a8db40d80fc982cd380dd89eff4e1..bfac30f7929f3094b0f95c343f2659cd0381a4a0 100644 (file)
@@ -1589,8 +1589,8 @@ static int __devinit snd_ca0106_create(int dev, struct snd_card *card,
        err = pci_enable_device(pci);
        if (err < 0)
                return err;
-       if (pci_set_dma_mask(pci, DMA_32BIT_MASK) < 0 ||
-           pci_set_consistent_dma_mask(pci, DMA_32BIT_MASK) < 0) {
+       if (pci_set_dma_mask(pci, DMA_BIT_MASK(32)) < 0 ||
+           pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(32)) < 0) {
                printk(KERN_ERR "error to set 32bit mask DMA\n");
                pci_disable_device(pci);
                return -ENXIO;
index c89ed1f5bc2bd5e6f29f357944de60aca751bae0..05f56e04849b8e083e05def751b3d17bdb2e96a3 100644 (file)
@@ -285,8 +285,8 @@ static int __devinit snd_cs5535audio_create(struct snd_card *card,
        if ((err = pci_enable_device(pci)) < 0)
                return err;
 
-       if (pci_set_dma_mask(pci, DMA_32BIT_MASK) < 0 ||
-           pci_set_consistent_dma_mask(pci, DMA_32BIT_MASK) < 0) {
+       if (pci_set_dma_mask(pci, DMA_BIT_MASK(32)) < 0 ||
+           pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(32)) < 0) {
                printk(KERN_WARNING "unable to get 32bit dma\n");
                err = -ENXIO;
                goto pcifail;
index c1eb84a14c4264f0c35728675cba420d927daf1a..82bc5b9e7629db8537e66af68624feb14e0d17e1 100644 (file)
@@ -1291,7 +1291,7 @@ static int __devinit snd_mixart_probe(struct pci_dev *pci,
        pci_set_master(pci);
 
        /* check if we can restrict PCI DMA transfers to 32 bits */
-       if (pci_set_dma_mask(pci, DMA_32BIT_MASK) < 0) {
+       if (pci_set_dma_mask(pci, DMA_BIT_MASK(32)) < 0) {
                snd_printk(KERN_ERR "architecture does not support 32bit PCI busmaster DMA\n");
                pci_disable_device(pci);
                return -ENXIO;
index 80e064a3efff94d1c37c81276d15b7d95c9b5533..833e9c7b27c7bce4b66d52b7a45ca1455ca6f912 100644 (file)
@@ -1449,7 +1449,7 @@ static int __devinit pcxhr_probe(struct pci_dev *pci,
        pci_set_master(pci);
 
        /* check if we can restrict PCI DMA transfers to 32 bits */
-       if (pci_set_dma_mask(pci, DMA_32BIT_MASK) < 0) {
+       if (pci_set_dma_mask(pci, DMA_BIT_MASK(32)) < 0) {
                snd_printk(KERN_ERR "architecture does not support "
                           "32bit PCI busmaster DMA\n");
                pci_disable_device(pci);
index 8cfed1a5dcbea6cfd80ec1c15fb3756cc236760d..cf0dfb7ca22146baba398d3f9d0c70a3e1b4ce22 100644 (file)
@@ -413,7 +413,7 @@ static void bf5xx_pcm_free_dma_buffers(struct snd_pcm *pcm)
                sport_done(sport_handle);
 }
 
-static u64 bf5xx_pcm_dmamask = DMA_32BIT_MASK;
+static u64 bf5xx_pcm_dmamask = DMA_BIT_MASK(32);
 
 int bf5xx_pcm_ac97_new(struct snd_card *card, struct snd_soc_dai *dai,
        struct snd_pcm *pcm)
@@ -424,7 +424,7 @@ int bf5xx_pcm_ac97_new(struct snd_card *card, struct snd_soc_dai *dai,
        if (!card->dev->dma_mask)
                card->dev->dma_mask = &bf5xx_pcm_dmamask;
        if (!card->dev->coherent_dma_mask)
-               card->dev->coherent_dma_mask = DMA_32BIT_MASK;
+               card->dev->coherent_dma_mask = DMA_BIT_MASK(32);
 
        if (dai->playback.channels_min) {
                ret = bf5xx_pcm_preallocate_dma_buffer(pcm,
index 1318c4f627b7c52f9a90829b0dd10498aa6cdd1b..62fbb8459569a6d78690bbf7b100a3aa47ea745a 100644 (file)
@@ -245,7 +245,7 @@ static void bf5xx_pcm_free_dma_buffers(struct snd_pcm *pcm)
                sport_done(sport_handle);
 }
 
-static u64 bf5xx_pcm_dmamask = DMA_32BIT_MASK;
+static u64 bf5xx_pcm_dmamask = DMA_BIT_MASK(32);
 
 int bf5xx_pcm_i2s_new(struct snd_card *card, struct snd_soc_dai *dai,
        struct snd_pcm *pcm)
@@ -256,7 +256,7 @@ int bf5xx_pcm_i2s_new(struct snd_card *card, struct snd_soc_dai *dai,
        if (!card->dev->dma_mask)
                card->dev->dma_mask = &bf5xx_pcm_dmamask;
        if (!card->dev->coherent_dma_mask)
-               card->dev->coherent_dma_mask = DMA_32BIT_MASK;
+               card->dev->coherent_dma_mask = DMA_BIT_MASK(32);
 
        if (dai->playback.channels_min) {
                ret = bf5xx_pcm_preallocate_dma_buffer(pcm,
index 8e1431cb46bbcb20008c6597e512b7eb71e41545..1bdbb04271830a33fe948a847b6983525ad9f1dd 100644 (file)
@@ -327,7 +327,7 @@ int omap_pcm_new(struct snd_card *card, struct snd_soc_dai *dai,
        if (!card->dev->dma_mask)
                card->dev->dma_mask = &omap_pcm_dmamask;
        if (!card->dev->coherent_dma_mask)
-               card->dev->coherent_dma_mask = DMA_32BIT_MASK;
+               card->dev->coherent_dma_mask = DMA_BIT_MASK(32);
 
        if (dai->playback.channels_min) {
                ret = omap_pcm_preallocate_dma_buffer(pcm,
index 53b9fb127a6d7f1b05121b7fe3979022d5c9acf2..d38e39575f510a6519b0b115189848012dc7a73a 100644 (file)
@@ -81,7 +81,7 @@ static struct snd_pcm_ops pxa2xx_pcm_ops = {
        .mmap           = pxa2xx_pcm_mmap,
 };
 
-static u64 pxa2xx_pcm_dmamask = DMA_32BIT_MASK;
+static u64 pxa2xx_pcm_dmamask = DMA_BIT_MASK(32);
 
 static int pxa2xx_soc_pcm_new(struct snd_card *card, struct snd_soc_dai *dai,
        struct snd_pcm *pcm)
@@ -91,7 +91,7 @@ static int pxa2xx_soc_pcm_new(struct snd_card *card, struct snd_soc_dai *dai,
        if (!card->dev->dma_mask)
                card->dev->dma_mask = &pxa2xx_pcm_dmamask;
        if (!card->dev->coherent_dma_mask)
-               card->dev->coherent_dma_mask = DMA_32BIT_MASK;
+               card->dev->coherent_dma_mask = DMA_BIT_MASK(32);
 
        if (dai->playback.channels_min) {
                ret = pxa2xx_pcm_preallocate_dma_buffer(pcm,
index a9d68fa2b34a337b8d3ac853a0b2467612cb290f..169ddad31575e9601e3e703074a75c1fca398533 100644 (file)
@@ -419,7 +419,7 @@ static void s3c24xx_pcm_free_dma_buffers(struct snd_pcm *pcm)
        }
 }
 
-static u64 s3c24xx_pcm_dmamask = DMA_32BIT_MASK;
+static u64 s3c24xx_pcm_dmamask = DMA_BIT_MASK(32);
 
 static int s3c24xx_pcm_new(struct snd_card *card,
        struct snd_soc_dai *dai, struct snd_pcm *pcm)