Minki/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2024-11-10 14:11:52 +00:00
Code Issues Packages Projects Releases Wiki Activity

dma-mapping: replace all DMA_32BIT_MASK macro with DMA_BIT_MASK(32)

Browse Source 
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>
This commit is contained in:
Yang Hongyang 2009-04-06 19:01:15 -07:00 committed by Linus Torvalds
parent 6afd142fd0
commit 284901a90a
173 changed files with 309 additions and 313 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
arch/arm/mach-davinci/board-evm.c
View 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 = { static struct platform_device ide_dev = {
.name = "palm_bk3710", .name = "palm_bk3710",
@ -127,7 +127,7 @@ static struct platform_device ide_dev = {
.num_resources = ARRAY_SIZE(ide_resources), .num_resources = ARRAY_SIZE(ide_resources),
.dev = { .dev = {
.dma_mask = &ide_dma_mask, .dma_mask = &ide_dma_mask,
.coherent_dma_mask = DMA_32BIT_MASK, .coherent_dma_mask = DMA_BIT_MASK(32),
}, },
}; };

4
arch/arm/mach-davinci/usb.c
View 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 = { static struct platform_device usb_dev = {
.name = "musb_hdrc", .name = "musb_hdrc",
@ -72,7 +72,7 @@ static struct platform_device usb_dev = {
.dev = { .dev = {
.platform_data = &usb_data, .platform_data = &usb_data,
.dma_mask = &usb_dmamask, .dma_mask = &usb_dmamask,
.coherent_dma_mask = DMA_32BIT_MASK, .coherent_dma_mask = DMA_BIT_MASK(32),
}, },
.resource = usb_resources, .resource = usb_resources,
.num_resources = ARRAY_SIZE(usb_resources), .num_resources = ARRAY_SIZE(usb_resources),

2
arch/arm/mach-kirkwood/common.c
View File

@ -508,7 +508,7 @@ static struct mv_xor_platform_shared_data kirkwood_xor_shared_data = {
.dram = &kirkwood_mbus_dram_info, .dram = &kirkwood_mbus_dram_info,
}; };
static u64 kirkwood_xor_dmamask = DMA_32BIT_MASK; static u64 kirkwood_xor_dmamask = DMA_BIT_MASK(32);
/***************************************************************************** /*****************************************************************************

2
arch/arm/mach-orion5x/common.c
View File

@ -463,7 +463,7 @@ static struct platform_device orion5x_xor_shared = {
.resource = orion5x_xor_shared_resources, .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[] = { static struct resource orion5x_xor0_resources[] = {
[0] = { [0] = {

2
arch/arm/plat-iop/adma.c
View 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 = { static struct iop_adma_platform_data iop3xx_dma_0_data = {
.hw_id = DMA0_ID, .hw_id = DMA0_ID,

4
arch/avr32/boards/hammerhead/flash.c
View 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 = { static struct platform_device hh_fpga0_device = {
.name = "hh_fpga", .name = "hh_fpga",
.id = 0, .id = 0,
.dev = { .dev = {
.dma_mask = &hh_fpga0_dma_mask, .dma_mask = &hh_fpga0_dma_mask,
.coherent_dma_mask = DMA_32BIT_MASK, .coherent_dma_mask = DMA_BIT_MASK(32),
}, },
.resource = hh_fpga0_resource, .resource = hh_fpga0_resource,
.num_resources = ARRAY_SIZE(hh_fpga0_resource), .num_resources = ARRAY_SIZE(hh_fpga0_resource),

8
arch/avr32/mach-at32ap/at32ap700x.c
View File

@ -60,26 +60,26 @@
* don't ... tc, smc, pio, rtc, watchdog, pwm, ps2, and more. * don't ... tc, smc, pio, rtc, watchdog, pwm, ps2, and more.
*/ */
#define DEFINE_DEV(_name, _id) \ #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 = { \ static struct platform_device _name##_id##_device = { \
.name = #_name, \ .name = #_name, \
.id = _id, \ .id = _id, \
.dev = { \ .dev = { \
.dma_mask = &_name##_id##_dma_mask, \ .dma_mask = &_name##_id##_dma_mask, \
.coherent_dma_mask = DMA_32BIT_MASK, \ .coherent_dma_mask = DMA_BIT_MASK(32), \
}, \ }, \
.resource = _name##_id##_resource, \ .resource = _name##_id##_resource, \
.num_resources = ARRAY_SIZE(_name##_id##_resource), \ .num_resources = ARRAY_SIZE(_name##_id##_resource), \
} }
#define DEFINE_DEV_DATA(_name, _id) \ #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 = { \ static struct platform_device _name##_id##_device = { \
.name = #_name, \ .name = #_name, \
.id = _id, \ .id = _id, \
.dev = { \ .dev = { \
.dma_mask = &_name##_id##_dma_mask, \ .dma_mask = &_name##_id##_dma_mask, \
.platform_data = &_name##_id##_data, \ .platform_data = &_name##_id##_data, \
.coherent_dma_mask = DMA_32BIT_MASK, \ .coherent_dma_mask = DMA_BIT_MASK(32), \
}, \ }, \
.resource = _name##_id##_resource, \ .resource = _name##_id##_resource, \
.num_resources = ARRAY_SIZE(_name##_id##_resource), \ .num_resources = ARRAY_SIZE(_name##_id##_resource), \

2
arch/ia64/kernel/pci-dma.c
View File

@ -37,7 +37,7 @@ int force_iommu __read_mostly;
to i386. */ to i386. */
struct device fallback_dev = { struct device fallback_dev = {
.init_name = "fallback device", .init_name = "fallback device",
.coherent_dma_mask = DMA_32BIT_MASK, .coherent_dma_mask = DMA_BIT_MASK(32),
.dma_mask = &fallback_dev.coherent_dma_mask, .dma_mask = &fallback_dev.coherent_dma_mask,
}; };

30
arch/mips/alchemy/common/platform.c
View File

@ -80,14 +80,14 @@ static struct resource au1xxx_usb_ohci_resources[] = {
}; };
/* The dmamask must be set for OHCI to work */ /* 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 = { static struct platform_device au1xxx_usb_ohci_device = {
.name = "au1xxx-ohci", .name = "au1xxx-ohci",
.id = 0, .id = 0,
.dev = { .dev = {
.dma_mask = &ohci_dmamask, .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), .num_resources = ARRAY_SIZE(au1xxx_usb_ohci_resources),
.resource = 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 = { static struct platform_device au1100_lcd_device = {
.name = "au1100-lcd", .name = "au1100-lcd",
.id = 0, .id = 0,
.dev = { .dev = {
.dma_mask = &au1100_lcd_dmamask, .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), .num_resources = ARRAY_SIZE(au1100_lcd_resources),
.resource = 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 = { static struct platform_device au1xxx_usb_ehci_device = {
.name = "au1xxx-ehci", .name = "au1xxx-ehci",
.id = 0, .id = 0,
.dev = { .dev = {
.dma_mask = &ehci_dmamask, .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), .num_resources = ARRAY_SIZE(au1xxx_usb_ehci_resources),
.resource = 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 = { static struct platform_device au1xxx_usb_gdt_device = {
.name = "au1xxx-udc", .name = "au1xxx-udc",
.id = 0, .id = 0,
.dev = { .dev = {
.dma_mask = &udc_dmamask, .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), .num_resources = ARRAY_SIZE(au1xxx_usb_gdt_resources),
.resource = 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 = { static struct platform_device au1xxx_usb_otg_device = {
.name = "au1xxx-uoc", .name = "au1xxx-uoc",
.id = 0, .id = 0,
.dev = { .dev = {
.dma_mask = &uoc_dmamask, .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), .num_resources = ARRAY_SIZE(au1xxx_usb_otg_resources),
.resource = 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 = { static struct platform_device au1200_lcd_device = {
.name = "au1200-lcd", .name = "au1200-lcd",
.id = 0, .id = 0,
.dev = { .dev = {
.dma_mask = &au1200_lcd_dmamask, .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), .num_resources = ARRAY_SIZE(au1200_lcd_resources),
.resource = 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]; extern struct au1xmmc_platform_data au1xmmc_platdata[2];
@ -263,7 +263,7 @@ static struct platform_device au1200_mmc0_device = {
.id = 0, .id = 0,
.dev = { .dev = {
.dma_mask = &au1xxx_mmc_dmamask, .dma_mask = &au1xxx_mmc_dmamask,
.coherent_dma_mask = DMA_32BIT_MASK, .coherent_dma_mask = DMA_BIT_MASK(32),
.platform_data = &au1xmmc_platdata[0], .platform_data = &au1xmmc_platdata[0],
}, },
.num_resources = ARRAY_SIZE(au1200_mmc0_resources), .num_resources = ARRAY_SIZE(au1200_mmc0_resources),
@ -299,7 +299,7 @@ static struct platform_device au1200_mmc1_device = {
.id = 1, .id = 1,
.dev = { .dev = {
.dma_mask = &au1xxx_mmc_dmamask, .dma_mask = &au1xxx_mmc_dmamask,
.coherent_dma_mask = DMA_32BIT_MASK, .coherent_dma_mask = DMA_BIT_MASK(32),
.platform_data = &au1xmmc_platdata[1], .platform_data = &au1xmmc_platdata[1],
}, },
.num_resources = ARRAY_SIZE(au1200_mmc1_resources), .num_resources = ARRAY_SIZE(au1200_mmc1_resources),

4
arch/mips/alchemy/devboards/pb1200/platform.c
View 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 = { static struct platform_device ide_device = {
.name = "au1200-ide", .name = "au1200-ide",
.id = 0, .id = 0,
.dev = { .dev = {
.dma_mask = &ide_dmamask, .dma_mask = &ide_dmamask,
.coherent_dma_mask = DMA_32BIT_MASK, .coherent_dma_mask = DMA_BIT_MASK(32),
}, },
.num_resources = ARRAY_SIZE(ide_resources), .num_resources = ARRAY_SIZE(ide_resources),
.resource = ide_resources .resource = ide_resources

12
arch/mips/nxp/pnx833x/common/platform.c
View File

@ -42,7 +42,7 @@
#include <irq-mapping.h> #include <irq-mapping.h>
#include <pnx833x.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[] = { static struct resource pnx833x_uart_resources[] = {
[0] = { [0] = {
@ -101,14 +101,14 @@ static struct platform_device pnx833x_uart_device = {
.id = -1, .id = -1,
.dev = { .dev = {
.dma_mask = &uart_dmamask, .dma_mask = &uart_dmamask,
.coherent_dma_mask = DMA_32BIT_MASK, .coherent_dma_mask = DMA_BIT_MASK(32),
.platform_data = pnx8xxx_ports, .platform_data = pnx8xxx_ports,
}, },
.num_resources = ARRAY_SIZE(pnx833x_uart_resources), .num_resources = ARRAY_SIZE(pnx833x_uart_resources),
.resource = 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[] = { static struct resource pnx833x_usb_ehci_resources[] = {
[0] = { [0] = {
@ -128,7 +128,7 @@ static struct platform_device pnx833x_usb_ehci_device = {
.id = -1, .id = -1,
.dev = { .dev = {
.dma_mask = &ehci_dmamask, .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), .num_resources = ARRAY_SIZE(pnx833x_usb_ehci_resources),
.resource = pnx833x_usb_ehci_resources, .resource = pnx833x_usb_ehci_resources,
@ -198,7 +198,7 @@ static struct platform_device pnx833x_i2c1_device = {
}; };
#endif #endif
static u64 ethernet_dmamask = DMA_32BIT_MASK; static u64 ethernet_dmamask = DMA_BIT_MASK(32);
static struct resource pnx833x_ethernet_resources[] = { static struct resource pnx833x_ethernet_resources[] = {
[0] = { [0] = {
@ -218,7 +218,7 @@ static struct platform_device pnx833x_ethernet_device = {
.id = -1, .id = -1,
.dev = { .dev = {
.dma_mask = &ethernet_dmamask, .dma_mask = &ethernet_dmamask,
.coherent_dma_mask = DMA_32BIT_MASK, .coherent_dma_mask = DMA_BIT_MASK(32),
}, },
.num_resources = ARRAY_SIZE(pnx833x_ethernet_resources), .num_resources = ARRAY_SIZE(pnx833x_ethernet_resources),
.resource = pnx833x_ethernet_resources, .resource = pnx833x_ethernet_resources,

8
arch/mips/nxp/pnx8550/common/platform.c
View File

@ -92,16 +92,16 @@ struct pnx8xxx_port pnx8xxx_ports[] = {
}; };
/* The dmamask must be set for OHCI to work */ /* 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 = { static struct platform_device pnx8550_usb_ohci_device = {
.name = "pnx8550-ohci", .name = "pnx8550-ohci",
.id = -1, .id = -1,
.dev = { .dev = {
.dma_mask = &ohci_dmamask, .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), .num_resources = ARRAY_SIZE(pnx8550_usb_ohci_resources),
.resource = pnx8550_usb_ohci_resources, .resource = pnx8550_usb_ohci_resources,
@ -112,7 +112,7 @@ static struct platform_device pnx8550_uart_device = {
.id = -1, .id = -1,
.dev = { .dev = {
.dma_mask = &uart_dmamask, .dma_mask = &uart_dmamask,
.coherent_dma_mask = DMA_32BIT_MASK, .coherent_dma_mask = DMA_BIT_MASK(32),
.platform_data = pnx8xxx_ports, .platform_data = pnx8xxx_ports,
}, },
.num_resources = ARRAY_SIZE(pnx8550_uart_resources), .num_resources = ARRAY_SIZE(pnx8550_uart_resources),

8
arch/mips/pmc-sierra/msp71xx/msp_usb.c
View 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 = { static struct platform_device msp_usbhost_device = {
.name = "pmcmsp-ehci", .name = "pmcmsp-ehci",
.id = 0, .id = 0,
.dev = { .dev = {
.dma_mask = &msp_usbhost_dma_mask, .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), .num_resources = ARRAY_SIZE(msp_usbhost_resources),
.resource = 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 = { static struct platform_device msp_usbdev_device = {
.name = "msp71xx_udc", .name = "msp71xx_udc",
.id = 0, .id = 0,
.dev = { .dev = {
.dma_mask = &msp_usbdev_dma_mask, .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), .num_resources = ARRAY_SIZE(msp_usbdev_resources),
.resource = msp_usbdev_resources, .resource = msp_usbdev_resources,

2
arch/powerpc/kernel/dma.c
View 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 * done via some global so platforms can set the limit in case
* they have limited DMA windows * they have limited DMA windows
*/ */
return mask >= DMA_32BIT_MASK; return mask >= DMA_BIT_MASK(32);
#else #else
return 1; return 1;
#endif #endif

2
arch/powerpc/kernel/of_platform.c
View File

@ -76,7 +76,7 @@ struct of_device* of_platform_device_create(struct device_node *np,
return NULL; return NULL;
dev->dma_mask = 0xffffffffUL; 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; dev->dev.bus = &of_platform_bus_type;

4
arch/powerpc/platforms/iseries/iommu.c
View 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) 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, 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); 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), return iommu_map_page(NULL, &vio_iommu_table, virt_to_page(vaddr),
(unsigned long)vaddr % PAGE_SIZE, size, (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, void iseries_hv_unmap(dma_addr_t dma_handle, size_t size,

2
arch/powerpc/platforms/ps3/system-bus.c
View 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) 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 = { static struct dma_mapping_ops ps3_sb_dma_ops = {

4
arch/x86/include/asm/dma-mapping.h
View File

@ -238,7 +238,7 @@ static inline unsigned long dma_alloc_coherent_mask(struct device *dev,
dma_mask = dev->coherent_dma_mask; dma_mask = dev->coherent_dma_mask;
if (!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; 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) if (dma_mask <= DMA_24BIT_MASK)
gfp |= GFP_DMA; gfp |= GFP_DMA;
#ifdef CONFIG_X86_64 #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; gfp |= GFP_DMA32;
#endif #endif
return gfp; return gfp;

4
arch/x86/kernel/pci-dma.c
View File

@ -40,7 +40,7 @@ EXPORT_SYMBOL(bad_dma_address);
to older i386. */ to older i386. */
struct device x86_dma_fallback_dev = { struct device x86_dma_fallback_dev = {
.init_name = "fallback device", .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, .dma_mask = &x86_dma_fallback_dev.coherent_dma_mask,
}; };
EXPORT_SYMBOL(x86_dma_fallback_dev); EXPORT_SYMBOL(x86_dma_fallback_dev);
@ -148,7 +148,7 @@ again:
if (!is_buffer_dma_capable(dma_mask, addr, size)) { if (!is_buffer_dma_capable(dma_mask, addr, size)) {
__free_pages(page, get_order(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; flag = (flag & ~GFP_DMA32) | GFP_DMA;
goto again; goto again;
} }

2
arch/x86/kernel/pci-nommu.c
View File

@ -15,7 +15,7 @@ static int
check_addr(char *name, struct device *hwdev, dma_addr_t bus, size_t size) 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 && !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 printk(KERN_ERR
"nommu_%s: overflow %Lx+%zu of device mask %Lx\n", "nommu_%s: overflow %Lx+%zu of device mask %Lx\n",
name, (long long)bus, size, name, (long long)bus, size,

6
drivers/ata/ahci.c
View 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))) { !pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) {
rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)); rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
if (rc) { 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) { if (rc) {
dev_printk(KERN_ERR, &pdev->dev, dev_printk(KERN_ERR, &pdev->dev,
"64-bit DMA enable failed\n"); "64-bit DMA enable failed\n");
@ -2416,13 +2416,13 @@ static int ahci_configure_dma_masks(struct pci_dev *pdev, int using_dac)
} }
} }
} else { } else {
rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK); rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
if (rc) { if (rc) {
dev_printk(KERN_ERR, &pdev->dev, dev_printk(KERN_ERR, &pdev->dev,
"32-bit DMA enable failed\n"); "32-bit DMA enable failed\n");
return 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) { if (rc) {
dev_printk(KERN_ERR, &pdev->dev, dev_printk(KERN_ERR, &pdev->dev,
"32-bit consistent DMA enable failed\n"); "32-bit consistent DMA enable failed\n");

4
drivers/ata/pata_cs5520.c
View File

@ -203,11 +203,11 @@ static int __devinit cs5520_init_one(struct pci_dev *pdev, const struct pci_devi
return -ENODEV; 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"); printk(KERN_ERR DRV_NAME ": unable to configure DMA mask.\n");
return -ENODEV; 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"); printk(KERN_ERR DRV_NAME ": unable to configure consistent DMA mask.\n");
return -ENODEV; return -ENODEV;
} }

2
drivers/ata/pata_ixp4xx_cf.c
View File

@ -157,7 +157,7 @@ static __devinit int ixp4xx_pata_probe(struct platform_device *pdev)
return -ENOMEM; return -ENOMEM;
/* acquire resources and fill host */ /* 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->cs0 = devm_ioremap(&pdev->dev, cs0->start, 0x1000);
data->cs1 = devm_ioremap(&pdev->dev, cs1->start, 0x1000); data->cs1 = devm_ioremap(&pdev->dev, cs1->start, 0x1000);

4
drivers/ata/pdc_adma.c
View File

@ -607,13 +607,13 @@ static int adma_set_dma_masks(struct pci_dev *pdev, void __iomem *mmio_base)
{ {
int rc; int rc;
rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK); rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
if (rc) { if (rc) {
dev_printk(KERN_ERR, &pdev->dev, dev_printk(KERN_ERR, &pdev->dev,
"32-bit DMA enable failed\n"); "32-bit DMA enable failed\n");
return 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) { if (rc) {
dev_printk(KERN_ERR, &pdev->dev, dev_printk(KERN_ERR, &pdev->dev,
"32-bit consistent DMA enable failed\n"); "32-bit consistent DMA enable failed\n");

4
drivers/ata/sata_inic162x.c
View 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. */ /* 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) { if (rc) {
dev_printk(KERN_ERR, &pdev->dev, dev_printk(KERN_ERR, &pdev->dev,
"32-bit DMA enable failed\n"); "32-bit DMA enable failed\n");
return 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) { if (rc) {
dev_printk(KERN_ERR, &pdev->dev, dev_printk(KERN_ERR, &pdev->dev,
"32-bit consistent DMA enable failed\n"); "32-bit consistent DMA enable failed\n");

6
drivers/ata/sata_mv.c
View File

@ -3916,7 +3916,7 @@ static int pci_go_64(struct pci_dev *pdev)
if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) { if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) {
rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)); rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
if (rc) { 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) { if (rc) {
dev_printk(KERN_ERR, &pdev->dev, dev_printk(KERN_ERR, &pdev->dev,
"64-bit DMA enable failed\n"); "64-bit DMA enable failed\n");
@ -3924,13 +3924,13 @@ static int pci_go_64(struct pci_dev *pdev)
} }
} }
} else { } else {
rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK); rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
if (rc) { if (rc) {
dev_printk(KERN_ERR, &pdev->dev, dev_printk(KERN_ERR, &pdev->dev,
"32-bit DMA enable failed\n"); "32-bit DMA enable failed\n");
return 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) { if (rc) {
dev_printk(KERN_ERR, &pdev->dev, dev_printk(KERN_ERR, &pdev->dev,
"32-bit consistent DMA enable failed\n"); "32-bit consistent DMA enable failed\n");

6
drivers/ata/sata_qstor.c
View 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))) { !pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) {
rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)); rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
if (rc) { 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) { if (rc) {
dev_printk(KERN_ERR, &pdev->dev, dev_printk(KERN_ERR, &pdev->dev,
"64-bit DMA enable failed\n"); "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 { } else {
rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK); rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
if (rc) { if (rc) {
dev_printk(KERN_ERR, &pdev->dev, dev_printk(KERN_ERR, &pdev->dev,
"32-bit DMA enable failed\n"); "32-bit DMA enable failed\n");
return 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) { if (rc) {
dev_printk(KERN_ERR, &pdev->dev, dev_printk(KERN_ERR, &pdev->dev,
"32-bit consistent DMA enable failed\n"); "32-bit consistent DMA enable failed\n");

6
drivers/ata/sata_sil24.c
View 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))) { if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) {
rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)); rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
if (rc) { 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) { if (rc) {
dev_printk(KERN_ERR, &pdev->dev, dev_printk(KERN_ERR, &pdev->dev,
"64-bit DMA enable failed\n"); "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 { } else {
rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK); rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
if (rc) { if (rc) {
dev_printk(KERN_ERR, &pdev->dev, dev_printk(KERN_ERR, &pdev->dev,
"32-bit DMA enable failed\n"); "32-bit DMA enable failed\n");
return 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) { if (rc) {
dev_printk(KERN_ERR, &pdev->dev, dev_printk(KERN_ERR, &pdev->dev,
"32-bit consistent DMA enable failed\n"); "32-bit consistent DMA enable failed\n");

4
drivers/ata/sata_vsc.c
View 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. * 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) if (rc)
return 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) if (rc)
return rc; return rc;

2
drivers/atm/he.c
View 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)) if (pci_enable_device(pci_dev))
return -EIO; 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"); printk(KERN_WARNING "he: no suitable dma available\n");
err = -EIO; err = -EIO;
goto init_one_failure; goto init_one_failure;

4
drivers/atm/lanai.c
View File

@ -1957,12 +1957,12 @@ static int __devinit lanai_pci_start(struct lanai_dev *lanai)
return -ENXIO; return -ENXIO;
} }
pci_set_master(pci); 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 printk(KERN_WARNING DEV_LABEL
"(itf %d): No suitable DMA available.\n", lanai->number); "(itf %d): No suitable DMA available.\n", lanai->number);
return -EBUSY; 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 printk(KERN_WARNING DEV_LABEL
"(itf %d): No suitable DMA available.\n", lanai->number); "(itf %d): No suitable DMA available.\n", lanai->number);
return -EBUSY; return -EBUSY;

8
drivers/block/DAC960.c
View File

@ -1169,9 +1169,9 @@ static bool DAC960_V1_EnableMemoryMailboxInterface(DAC960_Controller_T
int i; 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"); 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)) { if ((hw_type == DAC960_PD_Controller) || (hw_type == DAC960_P_Controller)) {
CommandMailboxesSize = 0; 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))) if (!pci_set_dma_mask(Controller->PCIDevice, DMA_BIT_MASK(64)))
Controller->BounceBufferLimit = DMA_BIT_MASK(64); Controller->BounceBufferLimit = DMA_BIT_MASK(64);
else if (!pci_set_dma_mask(Controller->PCIDevice, DMA_32BIT_MASK)) else if (!pci_set_dma_mask(Controller->PCIDevice, DMA_BIT_MASK(32)))
Controller->BounceBufferLimit = DMA_32BIT_MASK; Controller->BounceBufferLimit = DMA_BIT_MASK(32);
else else
return DAC960_Failure(Controller, "DMA mask out of range"); return DAC960_Failure(Controller, "DMA mask out of range");

2
drivers/block/cciss.c
View File

@ -3639,7 +3639,7 @@ static int __devinit cciss_init_one(struct pci_dev *pdev,
/* configure PCI DMA stuff */ /* configure PCI DMA stuff */
if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64)))
dac = 1; 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; dac = 0;
else { else {
printk(KERN_ERR "cciss: no suitable DMA available\n"); printk(KERN_ERR "cciss: no suitable DMA available\n");

2
drivers/block/sx8.c
View File

@ -1597,7 +1597,7 @@ static int carm_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
pci_dac = 1; pci_dac = 1;
} else { } else {
#endif #endif
rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK); rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
if (rc) { if (rc) {
printk(KERN_ERR DRV_NAME "(%s): DMA mask failure\n", printk(KERN_ERR DRV_NAME "(%s): DMA mask failure\n",
pci_name(pdev)); pci_name(pdev));

2
drivers/block/umem.c
View 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"); "Micro Memory(tm) controller found (PCI Mem Module (Battery Backup))\n");
if (pci_set_dma_mask(dev, DMA_BIT_MASK(64)) && 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"); dev_printk(KERN_WARNING, &dev->dev, "NO suitable DMA found\n");
return -ENOMEM; return -ENOMEM;
} }

2
drivers/crypto/hifn_795x.c
View File

@ -2575,7 +2575,7 @@ static int hifn_probe(struct pci_dev *pdev, const struct pci_device_id *id)
return err; return err;
pci_set_master(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) if (err)
goto err_out_disable_pci_device; goto err_out_disable_pci_device;

2
drivers/crypto/ixp4xx_crypto.c
View File

@ -209,7 +209,7 @@ static struct platform_device pseudo_dev = {
.id = 0, .id = 0,
.num_resources = 0, .num_resources = 0,
.dev = { .dev = {
.coherent_dma_mask = DMA_32BIT_MASK, .coherent_dma_mask = DMA_BIT_MASK(32),
.release = dev_release, .release = dev_release,
} }
}; };

4
drivers/dma/ioat.c
View File

@ -100,13 +100,13 @@ static int __devinit ioat_probe(struct pci_dev *pdev,
err = pci_set_dma_mask(pdev, DMA_BIT_MASK(64)); err = pci_set_dma_mask(pdev, DMA_BIT_MASK(64));
if (err) if (err)
err = pci_set_dma_mask(pdev, DMA_32BIT_MASK); err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
if (err) if (err)
goto err_set_dma_mask; goto err_set_dma_mask;
err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)); err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
if (err) 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) if (err)
goto err_set_dma_mask; goto err_set_dma_mask;

2
drivers/firmware/dcdbas.c
View 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. * BIOS SMI calls require buffer addresses be in 32-bit address space.
* This is done by setting the DMA mask below. * 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; dcdbas_pdev->dev.dma_mask = &dcdbas_pdev->dev.coherent_dma_mask;
error = sysfs_create_group(&dev->dev.kobj, &dcdbas_attr_group); error = sysfs_create_group(&dev->dev.kobj, &dcdbas_attr_group);

2
drivers/ide/cs5520.c
View File

@ -122,7 +122,7 @@ static int __devinit cs5520_init_one(struct pci_dev *dev, const struct pci_devic
return -ENODEV; return -ENODEV;
} }
pci_set_master(dev); 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", printk(KERN_WARNING "%s: No suitable DMA available.\n",
d->name); d->name);
return -ENODEV; return -ENODEV;

2
drivers/ide/setup-pci.c
View 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 * a DMA mask field to the struct ide_port_info if we need it
* (or let lower level driver set the DMA mask) * (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) { if (ret < 0) {
printk(KERN_ERR "%s %s: can't set DMA mask\n", printk(KERN_ERR "%s %s: can't set DMA mask\n",
d->name, pci_name(dev)); d->name, pci_name(dev));

2
drivers/ieee1394/pcilynx.c
View File

@ -1171,7 +1171,7 @@ static int __devinit add_card(struct pci_dev *dev,
error = -ENXIO; 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"); FAIL("DMA address limits not supported for PCILynx hardware");
if (pci_enable_device(dev)) if (pci_enable_device(dev))
FAIL("failed to enable PCILynx hardware"); FAIL("failed to enable PCILynx hardware");

2
drivers/infiniband/hw/amso1100/c2.c
View File

@ -995,7 +995,7 @@ static int __devinit c2_probe(struct pci_dev *pcidev,
goto bail2; goto bail2;
} }
} else { } else {
ret = pci_set_dma_mask(pcidev, DMA_32BIT_MASK); ret = pci_set_dma_mask(pcidev, DMA_BIT_MASK(32));
if (ret < 0) { if (ret < 0) {
printk(KERN_ERR PFX "32b DMA configuration failed\n"); printk(KERN_ERR PFX "32b DMA configuration failed\n");
goto bail2; goto bail2;

4
drivers/infiniband/hw/ipath/ipath_driver.c
View 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 * do not setup 64 bit maps on systems with 2GB or less
* memory installed. * memory installed.
*/ */
ret = pci_set_dma_mask(pdev, DMA_32BIT_MASK); ret = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
if (ret) { if (ret) {
dev_info(&pdev->dev, dev_info(&pdev->dev,
"Unable to set DMA mask for unit %u: %d\n", "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 { else {
ipath_dbg("No 64bit DMA mask, used 32 bit mask\n"); 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) if (ret)
dev_info(&pdev->dev, dev_info(&pdev->dev,
"Unable to set DMA consistent mask " "Unable to set DMA consistent mask "

4
drivers/infiniband/hw/mthca/mthca_main.c
View 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)); err = pci_set_dma_mask(pdev, DMA_BIT_MASK(64));
if (err) { if (err) {
dev_warn(&pdev->dev, "Warning: couldn't set 64-bit PCI DMA mask.\n"); 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) { if (err) {
dev_err(&pdev->dev, "Can't set PCI DMA mask, aborting.\n"); dev_err(&pdev->dev, "Can't set PCI DMA mask, aborting.\n");
goto err_free_res; goto err_free_res;
@ -1029,7 +1029,7 @@ static int __mthca_init_one(struct pci_dev *pdev, int hca_type)
if (err) { if (err) {
dev_warn(&pdev->dev, "Warning: couldn't set 64-bit " dev_warn(&pdev->dev, "Warning: couldn't set 64-bit "
"consistent PCI DMA mask.\n"); "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) { if (err) {
dev_err(&pdev->dev, "Can't set consistent PCI DMA mask, " dev_err(&pdev->dev, "Can't set consistent PCI DMA mask, "
"aborting.\n"); "aborting.\n");

4
drivers/infiniband/hw/nes/nes.c
View File

@ -489,12 +489,12 @@ static int __devinit nes_probe(struct pci_dev *pcidev, const struct pci_device_i
goto bail2; goto bail2;
} }
} else { } else {
ret = pci_set_dma_mask(pcidev, DMA_32BIT_MASK); ret = pci_set_dma_mask(pcidev, DMA_BIT_MASK(32));
if (ret < 0) { if (ret < 0) {
printk(KERN_ERR PFX "32b DMA mask configuration failed\n"); printk(KERN_ERR PFX "32b DMA mask configuration failed\n");
goto bail2; 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) { if (ret) {
printk(KERN_ERR PFX "32b DMA consistent mask configuration failed\n"); printk(KERN_ERR PFX "32b DMA consistent mask configuration failed\n");
goto bail2; goto bail2;

2
drivers/media/dvb/dm1105/dm1105.c
View File

@ -662,7 +662,7 @@ static int __devinit dm1105_probe(struct pci_dev *pdev,
if (ret < 0) if (ret < 0)
goto err_kfree; 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) if (ret < 0)
goto err_pci_disable_device; goto err_pci_disable_device;

2
drivers/media/dvb/pluto2/pluto2.c
View File

@ -616,7 +616,7 @@ static int __devinit pluto2_probe(struct pci_dev *pdev,
/* enable interrupts */ /* enable interrupts */
pci_write_config_dword(pdev, 0x6c, 0x8000); 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) if (ret < 0)
goto err_pci_disable_device; goto err_pci_disable_device;

2
drivers/media/video/bt8xx/bttv-driver.c
View File

@ -4317,7 +4317,7 @@ static int __devinit bttv_probe(struct pci_dev *dev,
btv->c.nr); btv->c.nr);
return -EIO; 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", printk(KERN_WARNING "bttv%d: No suitable DMA available.\n",
btv->c.nr); btv->c.nr);
return -EIO; return -EIO;

2
drivers/media/video/cx88/cx88-alsa.c
View File

@ -745,7 +745,7 @@ static int __devinit snd_cx88_create(struct snd_card *card,
return err; 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); dprintk(0, "%s/1: Oops: no 32bit PCI DMA ???\n",core->name);
err = -EIO; err = -EIO;
cx88_core_put(core,pci); cx88_core_put(core,pci);

2
drivers/media/video/cx88/cx88-mpeg.c
View File

@ -455,7 +455,7 @@ static int cx8802_init_common(struct cx8802_dev *dev)
if (pci_enable_device(dev->pci)) if (pci_enable_device(dev->pci))
return -EIO; return -EIO;
pci_set_master(dev->pci); 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); printk("%s/2: Oops: no 32bit PCI DMA ???\n",dev->core->name);
return -EIO; return -EIO;
} }

2
drivers/media/video/cx88/cx88-video.c
View 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)); dev->pci_lat,(unsigned long long)pci_resource_start(pci_dev,0));
pci_set_master(pci_dev); 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); printk("%s/0: Oops: no 32bit PCI DMA ???\n",core->name);
err = -EIO; err = -EIO;
goto fail_core; goto fail_core;

2
drivers/media/video/meye.c
View File

@ -117,7 +117,7 @@ static int ptable_alloc(void)
memset(meye.mchip_ptable, 0, sizeof(meye.mchip_ptable)); memset(meye.mchip_ptable, 0, sizeof(meye.mchip_ptable));
/* give only 32 bit DMA addresses */ /* 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; return -1;
meye.mchip_ptable_toc = dma_alloc_coherent(&meye.mchip_dev->dev, meye.mchip_ptable_toc = dma_alloc_coherent(&meye.mchip_dev->dev,

2
drivers/media/video/saa7134/saa7134-core.c
View 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, pci_name(pci_dev), dev->pci_rev, pci_dev->irq,
dev->pci_lat,(unsigned long long)pci_resource_start(pci_dev,0)); dev->pci_lat,(unsigned long long)pci_resource_start(pci_dev,0));
pci_set_master(pci_dev); 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); printk("%s: Oops: no 32bit PCI DMA ???\n",dev->name);
err = -EIO; err = -EIO;
goto fail1; goto fail1;

2
drivers/memstick/host/jmb38x_ms.c
View File

@ -877,7 +877,7 @@ static int jmb38x_ms_probe(struct pci_dev *pdev,
int pci_dev_busy = 0; int pci_dev_busy = 0;
int rc, cnt; int rc, cnt;
rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK); rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
if (rc) if (rc)
return rc; return rc;

4
drivers/message/fusion/mptbase.c
View File

@ -1539,8 +1539,8 @@ mpt_mapresources(MPT_ADAPTER *ioc)
dinitprintk(ioc, printk(MYIOC_s_INFO_FMT dinitprintk(ioc, printk(MYIOC_s_INFO_FMT
": 64 BIT PCI BUS DMA ADDRESSING SUPPORTED\n", ": 64 BIT PCI BUS DMA ADDRESSING SUPPORTED\n",
ioc->name)); ioc->name));
} else if (!pci_set_dma_mask(pdev, DMA_32BIT_MASK) } else if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(32))
&& !pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK)) { && !pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32))) {
dinitprintk(ioc, printk(MYIOC_s_INFO_FMT dinitprintk(ioc, printk(MYIOC_s_INFO_FMT
": 32 BIT PCI BUS DMA ADDRESSING SUPPORTED\n", ": 32 BIT PCI BUS DMA ADDRESSING SUPPORTED\n",
ioc->name)); ioc->name));

2
drivers/message/i2o/memory.c
View File

@ -187,7 +187,7 @@ int i2o_dma_alloc(struct device *dev, struct i2o_dma *addr, size_t len)
mutex_lock(&mem_lock); mutex_lock(&mem_lock);
if ((sizeof(dma_addr_t) > 4) && (pdev->dma_mask == DMA_BIT_MASK(64))) { if ((sizeof(dma_addr_t) > 4) && (pdev->dma_mask == DMA_BIT_MASK(64))) {
dma_64 = 1; 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); mutex_unlock(&mem_lock);
return -ENOMEM; return -ENOMEM;
} }

2
drivers/message/i2o/pci.c
View File

@ -334,7 +334,7 @@ static int __devinit i2o_pci_probe(struct pci_dev *pdev,
return rc; 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", printk(KERN_WARNING "i2o: no suitable DMA found for %s\n",
pci_name(pdev)); pci_name(pdev));
rc = -ENODEV; rc = -ENODEV;

2
drivers/misc/tifm_7xx1.c
View File

@ -324,7 +324,7 @@ static int tifm_7xx1_probe(struct pci_dev *dev,
int pci_dev_busy = 0; int pci_dev_busy = 0;
int rc; int rc;
rc = pci_set_dma_mask(dev, DMA_32BIT_MASK); rc = pci_set_dma_mask(dev, DMA_BIT_MASK(32));
if (rc) if (rc)
return rc; return rc;

2
drivers/mmc/host/sdhci-pci.c
View File

@ -380,7 +380,7 @@ static int sdhci_pci_enable_dma(struct sdhci_host *host)
"doesn't fully claim to support it.\n"); "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) if (ret)
return ret; return ret;

6
drivers/net/8139cp.c
View File

@ -1530,7 +1530,7 @@ static void cp_get_ethtool_stats (struct net_device *dev,
/* begin NIC statistics dump */ /* begin NIC statistics dump */
cpw32(StatsAddr + 4, (u64)dma >> 32); 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); cpr32(StatsAddr);
for (i = 0; i < 1000; i++) { 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 { } else {
pci_using_dac = 0; 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) { if (rc) {
dev_err(&pdev->dev, dev_err(&pdev->dev,
"No usable DMA configuration, aborting.\n"); "No usable DMA configuration, aborting.\n");
goto err_out_res; 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) { if (rc) {
dev_err(&pdev->dev, dev_err(&pdev->dev,
"No usable consistent DMA configuration, " "No usable consistent DMA configuration, "

2
drivers/net/acenic.c
View File

@ -1163,7 +1163,7 @@ static int __devinit ace_init(struct net_device *dev)
*/ */
if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) { if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) {
ap->pci_using_dac = 1; 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; ap->pci_using_dac = 0;
} else { } else {
ecode = -ENODEV; ecode = -ENODEV;

2
drivers/net/amd8111e.c
View File

@ -1871,7 +1871,7 @@ static int __devinit amd8111e_probe_one(struct pci_dev *pdev,
} }
/* Initialize DMA */ /* 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," printk(KERN_ERR "amd8111e: DMA not supported,"
"exiting.\n"); "exiting.\n");
goto err_free_reg; goto err_free_reg;

4
drivers/net/atl1e/atl1e_main.c
View File

@ -2326,8 +2326,8 @@ static int __devinit atl1e_probe(struct pci_dev *pdev,
* various kernel subsystems to support the mechanics required by a * various kernel subsystems to support the mechanics required by a
* fixed-high-32-bit system. * fixed-high-32-bit system.
*/ */
if ((pci_set_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_32BIT_MASK) != 0)) { (pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32)) != 0)) {
dev_err(&pdev->dev, "No usable DMA configuration,aborting\n"); dev_err(&pdev->dev, "No usable DMA configuration,aborting\n");
goto err_dma; goto err_dma;
} }

2
drivers/net/atlx/atl1.c
View File

@ -2929,7 +2929,7 @@ static int __devinit atl1_probe(struct pci_dev *pdev,
* various kernel subsystems to support the mechanics required by a * various kernel subsystems to support the mechanics required by a
* fixed-high-32-bit system. * 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) { if (err) {
dev_err(&pdev->dev, "no usable DMA configuration\n"); dev_err(&pdev->dev, "no usable DMA configuration\n");
goto err_dma; goto err_dma;

4
drivers/net/atlx/atl2.c
View 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 * until the kernel has the proper infrastructure to support 64-bit DMA
* on these devices. * on these devices.
*/ */
if (pci_set_dma_mask(pdev, DMA_32BIT_MASK) && if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) &&
pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK)) { pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32))) {
printk(KERN_ERR "atl2: No usable DMA configuration, aborting\n"); printk(KERN_ERR "atl2: No usable DMA configuration, aborting\n");
goto err_dma; goto err_dma;
} }

2
drivers/net/bnx2.c
View File

@ -7538,7 +7538,7 @@ bnx2_init_board(struct pci_dev *pdev, struct net_device *dev)
"pci_set_consistent_dma_mask failed, aborting.\n"); "pci_set_consistent_dma_mask failed, aborting.\n");
goto err_out_unmap; 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"); dev_err(&pdev->dev, "System does not support DMA, aborting.\n");
goto err_out_unmap; goto err_out_unmap;
} }

2
drivers/net/bnx2x_main.c
View File

@ -10988,7 +10988,7 @@ static int __devinit bnx2x_init_dev(struct pci_dev *pdev,
goto err_out_release; 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," printk(KERN_ERR PFX "System does not support DMA,"
" aborting\n"); " aborting\n");
rc = -EIO; rc = -EIO;

2
drivers/net/cassini.c
View File

@ -5085,7 +5085,7 @@ static int __devinit cas_init_one(struct pci_dev *pdev,
} }
} else { } else {
err = pci_set_dma_mask(pdev, DMA_32BIT_MASK); err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
if (err) { if (err) {
dev_err(&pdev->dev, "No usable DMA configuration, " dev_err(&pdev->dev, "No usable DMA configuration, "
"aborting.\n"); "aborting.\n");

2
drivers/net/chelsio/cxgb2.c
View File

@ -1066,7 +1066,7 @@ static int __devinit init_one(struct pci_dev *pdev,
goto out_disable_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)); CH_ERR("%s: no usable DMA configuration\n", pci_name(pdev));
goto out_disable_pdev; goto out_disable_pdev;
} }

2
drivers/net/cxgb3/cxgb3_main.c
View File

@ -3046,7 +3046,7 @@ static int __devinit init_one(struct pci_dev *pdev,
"coherent allocations\n"); "coherent allocations\n");
goto out_disable_device; 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"); dev_err(&pdev->dev, "no usable DMA configuration\n");
goto out_disable_device; goto out_disable_device;
} }

2
drivers/net/e100.c
View File

@ -2604,7 +2604,7 @@ static int __devinit e100_probe(struct pci_dev *pdev,
goto err_out_disable_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"); DPRINTK(PROBE, ERR, "No usable DMA configuration, aborting.\n");
goto err_out_free_res; goto err_out_free_res;
} }

4
drivers/net/e1000/e1000_main.c
View 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_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64))) {
pci_using_dac = 1; pci_using_dac = 1;
} else { } else {
err = pci_set_dma_mask(pdev, DMA_32BIT_MASK); err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
if (err) { 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) { if (err) {
E1000_ERR("No usable DMA configuration, " E1000_ERR("No usable DMA configuration, "
"aborting\n"); "aborting\n");

8
drivers/net/e1000e/netdev.c
View File

@ -2203,7 +2203,7 @@ static void e1000_configure_tx(struct e1000_adapter *adapter)
/* Setup the HW Tx Head and Tail descriptor pointers */ /* Setup the HW Tx Head and Tail descriptor pointers */
tdba = tx_ring->dma; tdba = tx_ring->dma;
tdlen = tx_ring->count * sizeof(struct e1000_tx_desc); 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(TDBAH, (tdba >> 32));
ew32(TDLEN, tdlen); ew32(TDLEN, tdlen);
ew32(TDH, 0); 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 * the Base and Length of the Rx Descriptor Ring
*/ */
rdba = rx_ring->dma; rdba = rx_ring->dma;
ew32(RDBAL, (rdba & DMA_32BIT_MASK)); ew32(RDBAL, (rdba & DMA_BIT_MASK(32)));
ew32(RDBAH, (rdba >> 32)); ew32(RDBAH, (rdba >> 32));
ew32(RDLEN, rdlen); ew32(RDLEN, rdlen);
ew32(RDH, 0); ew32(RDH, 0);
@ -4769,10 +4769,10 @@ static int __devinit e1000_probe(struct pci_dev *pdev,
if (!err) if (!err)
pci_using_dac = 1; pci_using_dac = 1;
} else { } else {
err = pci_set_dma_mask(pdev, DMA_32BIT_MASK); err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
if (err) { if (err) {
err = pci_set_consistent_dma_mask(pdev, err = pci_set_consistent_dma_mask(pdev,
DMA_32BIT_MASK); DMA_BIT_MASK(32));
if (err) { if (err) {
dev_err(&pdev->dev, "No usable DMA " dev_err(&pdev->dev, "No usable DMA "
"configuration, aborting\n"); "configuration, aborting\n");

4
drivers/net/enic/enic_main.c
View File

@ -1687,13 +1687,13 @@ static int __devinit enic_probe(struct pci_dev *pdev,
err = pci_set_dma_mask(pdev, DMA_BIT_MASK(40)); err = pci_set_dma_mask(pdev, DMA_BIT_MASK(40));
if (err) { if (err) {
err = pci_set_dma_mask(pdev, DMA_32BIT_MASK); err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
if (err) { if (err) {
printk(KERN_ERR PFX printk(KERN_ERR PFX
"No usable DMA configuration, aborting.\n"); "No usable DMA configuration, aborting.\n");
goto err_out_release_regions; 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) { if (err) {
printk(KERN_ERR PFX printk(KERN_ERR PFX
"Unable to obtain 32-bit DMA " "Unable to obtain 32-bit DMA "

2
drivers/net/hp100.c
View 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), * Also, we can have EISA Busmaster cards (not tested),
* so beware !!! - Jean II */ * so beware !!! - Jean II */
if((bus == HP100_BUS_PCI) && 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 */ /* Gracefully fallback to shared memory */
goto busmasterfail; goto busmasterfail;
} }

4
drivers/net/igb/igb_main.c
View File

@ -1160,9 +1160,9 @@ static int __devinit igb_probe(struct pci_dev *pdev,
if (!err) if (!err)
pci_using_dac = 1; pci_using_dac = 1;
} else { } else {
err = pci_set_dma_mask(pdev, DMA_32BIT_MASK); err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
if (err) { 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) { if (err) {
dev_err(&pdev->dev, "No usable DMA " dev_err(&pdev->dev, "No usable DMA "
"configuration, aborting\n"); "configuration, aborting\n");

2
drivers/net/ioc3-eth.c
View File

@ -1236,7 +1236,7 @@ static int __devinit ioc3_probe(struct pci_dev *pdev,
goto out; goto out;
} }
} else { } else {
err = pci_set_dma_mask(pdev, DMA_32BIT_MASK); err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
if (err) { if (err) {
printk(KERN_ERR "%s: No usable DMA configuration, " printk(KERN_ERR "%s: No usable DMA configuration, "
"aborting.\n", pci_name(pdev)); "aborting.\n", pci_name(pdev));

2
drivers/net/ipg.c
View File

@ -2242,7 +2242,7 @@ static int __devinit ipg_probe(struct pci_dev *pdev,
rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(40)); rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(40));
if (rc < 0) { 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) { if (rc < 0) {
printk(KERN_ERR "%s: DMA config failed.\n", printk(KERN_ERR "%s: DMA config failed.\n",
pci_name(pdev)); pci_name(pdev));

4
drivers/net/ixgb/ixgb_main.c
View 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)))) { !(err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)))) {
pci_using_dac = 1; pci_using_dac = 1;
} else { } else {
if ((err = pci_set_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_32BIT_MASK))) { (err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32)))) {
printk(KERN_ERR printk(KERN_ERR
"ixgb: No usable DMA configuration, aborting\n"); "ixgb: No usable DMA configuration, aborting\n");
goto err_dma_mask; goto err_dma_mask;

8
drivers/net/ixgbe/ixgbe_main.c
View File

@ -1643,7 +1643,7 @@ static void ixgbe_configure_tx(struct ixgbe_adapter *adapter)
tdba = ring->dma; tdba = ring->dma;
tdlen = ring->count * sizeof(union ixgbe_adv_tx_desc); tdlen = ring->count * sizeof(union ixgbe_adv_tx_desc);
IXGBE_WRITE_REG(hw, IXGBE_TDBAL(j), 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_TDBAH(j), (tdba >> 32));
IXGBE_WRITE_REG(hw, IXGBE_TDLEN(j), tdlen); IXGBE_WRITE_REG(hw, IXGBE_TDLEN(j), tdlen);
IXGBE_WRITE_REG(hw, IXGBE_TDH(j), 0); 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++) { for (i = 0; i < adapter->num_rx_queues; i++) {
rdba = adapter->rx_ring[i].dma; rdba = adapter->rx_ring[i].dma;
j = adapter->rx_ring[i].reg_idx; 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_RDBAH(j), (rdba >> 32));
IXGBE_WRITE_REG(hw, IXGBE_RDLEN(j), rdlen); IXGBE_WRITE_REG(hw, IXGBE_RDLEN(j), rdlen);
IXGBE_WRITE_REG(hw, IXGBE_RDH(j), 0); 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_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64))) {
pci_using_dac = 1; pci_using_dac = 1;
} else { } else {
err = pci_set_dma_mask(pdev, DMA_32BIT_MASK); err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
if (err) { 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) { if (err) {
dev_err(&pdev->dev, "No usable DMA " dev_err(&pdev->dev, "No usable DMA "
"configuration, aborting\n"); "configuration, aborting\n");

4
drivers/net/jme.c
View File

@ -2600,8 +2600,8 @@ jme_pci_dma64(struct pci_dev *pdev)
if (!pci_set_consistent_dma_mask(pdev, DMA_40BIT_MASK)) if (!pci_set_consistent_dma_mask(pdev, DMA_40BIT_MASK))
return 1; return 1;
if (!pci_set_dma_mask(pdev, DMA_32BIT_MASK)) if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(32)))
if (!pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK)) if (!pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32)))
return 0; return 0;
return -1; return -1;

4
drivers/net/mlx4/main.c
View 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)); err = pci_set_dma_mask(pdev, DMA_BIT_MASK(64));
if (err) { if (err) {
dev_warn(&pdev->dev, "Warning: couldn't set 64-bit PCI DMA mask.\n"); 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) { if (err) {
dev_err(&pdev->dev, "Can't set PCI DMA mask, aborting.\n"); dev_err(&pdev->dev, "Can't set PCI DMA mask, aborting.\n");
goto err_release_bar2; 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) { if (err) {
dev_warn(&pdev->dev, "Warning: couldn't set 64-bit " dev_warn(&pdev->dev, "Warning: couldn't set 64-bit "
"consistent PCI DMA mask.\n"); "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) { if (err) {
dev_err(&pdev->dev, "Can't set consistent PCI DMA mask, " dev_err(&pdev->dev, "Can't set consistent PCI DMA mask, "
"aborting.\n"); "aborting.\n");

4
drivers/net/myri10ge/myri10ge.c
View File

@ -1130,7 +1130,7 @@ myri10ge_submit_8rx(struct mcp_kreq_ether_recv __iomem * dst,
__be32 low; __be32 low;
low = src->addr_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)); myri10ge_pio_copy(dst, src, 4 * sizeof(*src));
mb(); mb();
myri10ge_pio_copy(dst + 4, src + 4, 4 * sizeof(*src)); 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, dev_err(&pdev->dev,
"64-bit pci address mask was refused, " "64-bit pci address mask was refused, "
"trying 32-bit\n"); "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) { if (status != 0) {
dev_err(&pdev->dev, "Error %d setting DMA mask\n", status); dev_err(&pdev->dev, "Error %d setting DMA mask\n", status);

4
drivers/net/niu.c
View File

@ -9889,8 +9889,8 @@ static int __devinit niu_pci_init_one(struct pci_dev *pdev,
goto err_out_release_parent; goto err_out_release_parent;
} }
} }
if (err || dma_mask == DMA_32BIT_MASK) { if (err || dma_mask == DMA_BIT_MASK(32)) {
err = pci_set_dma_mask(pdev, DMA_32BIT_MASK); err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
if (err) { if (err) {
dev_err(&pdev->dev, PFX "No usable DMA configuration, " dev_err(&pdev->dev, PFX "No usable DMA configuration, "
"aborting.\n"); "aborting.\n");

2
drivers/net/ns83820.c
View File

@ -1975,7 +1975,7 @@ static int __devinit ns83820_init_one(struct pci_dev *pci_dev,
if (sizeof(dma_addr_t) == 8 && if (sizeof(dma_addr_t) == 8 &&
!pci_set_dma_mask(pci_dev, DMA_BIT_MASK(64))) { !pci_set_dma_mask(pci_dev, DMA_BIT_MASK(64))) {
using_dac = 1; 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; using_dac = 0;
} else { } else {
dev_warn(&pci_dev->dev, "pci_set_dma_mask failed!\n"); dev_warn(&pci_dev->dev, "pci_set_dma_mask failed!\n");

4
drivers/net/qla3xxx.c
View File

@ -3937,9 +3937,9 @@ static int __devinit ql3xxx_probe(struct pci_dev *pdev,
if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) { if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) {
pci_using_dac = 1; pci_using_dac = 1;
err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)); 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; 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) { if (err) {

4
drivers/net/qlge/qlge_main.c
View File

@ -3730,9 +3730,9 @@ static int __devinit ql_init_device(struct pci_dev *pdev,
set_bit(QL_DMA64, &qdev->flags); set_bit(QL_DMA64, &qdev->flags);
err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)); err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
} else { } else {
err = pci_set_dma_mask(pdev, DMA_32BIT_MASK); err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
if (!err) 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) { if (err) {

4
drivers/net/r6040.c
View File

@ -1085,13 +1085,13 @@ static int __devinit r6040_init_one(struct pci_dev *pdev,
goto err_out; goto err_out;
/* this should always be supported */ /* 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) { if (err) {
printk(KERN_ERR DRV_NAME ": 32-bit PCI DMA addresses" printk(KERN_ERR DRV_NAME ": 32-bit PCI DMA addresses"
"not supported by the card\n"); "not supported by the card\n");
goto err_out; 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) { if (err) {
printk(KERN_ERR DRV_NAME ": 32-bit PCI DMA addresses" printk(KERN_ERR DRV_NAME ": 32-bit PCI DMA addresses"
"not supported by the card\n"); "not supported by the card\n");

8
drivers/net/r8169.c
View File

@ -1148,7 +1148,7 @@ static void rtl8169_update_counters(struct net_device *dev)
return; return;
RTL_W32(CounterAddrHigh, (u64)paddr >> 32); 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);
RTL_W32(CounterAddrLow, cmd | CounterDump); 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; tp->cp_cmd |= PCIDAC;
dev->features |= NETIF_F_HIGHDMA; dev->features |= NETIF_F_HIGHDMA;
} else { } else {
rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK); rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
if (rc < 0) { if (rc < 0) {
if (netif_msg_probe(tp)) { if (netif_msg_probe(tp)) {
dev_err(&pdev->dev, 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. * Switching from MMIO to I/O access fixes the issue as well.
*/ */
RTL_W32(TxDescStartAddrHigh, ((u64) tp->TxPhyAddr) >> 32); 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(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) static u16 rtl_rw_cpluscmd(void __iomem *ioaddr)

2
drivers/net/s2io.c
View File

@ -7786,7 +7786,7 @@ s2io_init_nic(struct pci_dev *pdev, const struct pci_device_id *pre)
pci_disable_device(pdev); pci_disable_device(pdev);
return -ENOMEM; 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"); DBG_PRINT(INIT_DBG, "s2io_init_nic: Using 32bit DMA\n");
} else { } else {
pci_disable_device(pdev); pci_disable_device(pdev);

4
drivers/net/sc92031.c
View File

@ -1427,11 +1427,11 @@ static int __devinit sc92031_probe(struct pci_dev *pdev,
pci_set_master(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)) if (unlikely(err < 0))
goto out_set_dma_mask; 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)) if (unlikely(err < 0))
goto out_set_dma_mask; goto out_set_dma_mask;

2
drivers/net/sis190.c
View File

@ -1467,7 +1467,7 @@ static struct net_device * __devinit sis190_init_board(struct pci_dev *pdev)
goto err_pci_disable_2; 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) { if (rc < 0) {
net_probe(tp, KERN_ERR "%s: DMA configuration failed.\n", net_probe(tp, KERN_ERR "%s: DMA configuration failed.\n",
pci_name(pdev)); pci_name(pdev));

2
drivers/net/sis900.c
View File

@ -432,7 +432,7 @@ static int __devinit sis900_probe(struct pci_dev *pci_dev,
ret = pci_enable_device(pci_dev); ret = pci_enable_device(pci_dev);
if(ret) return ret; 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){ if(i){
printk(KERN_ERR "sis900.c: architecture does not support " printk(KERN_ERR "sis900.c: architecture does not support "
"32bit PCI busmaster DMA\n"); "32bit PCI busmaster DMA\n");

4
drivers/net/skge.c
View File

@ -3915,9 +3915,9 @@ static int __devinit skge_probe(struct pci_dev *pdev,
if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) { if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) {
using_dac = 1; using_dac = 1;
err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)); 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; 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) { if (err) {

2
drivers/net/sky2.c
View File

@ -4383,7 +4383,7 @@ static int __devinit sky2_probe(struct pci_dev *pdev,
goto err_out_free_regions; goto err_out_free_regions;
} }
} else { } else {
err = pci_set_dma_mask(pdev, DMA_32BIT_MASK); err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
if (err) { if (err) {
dev_err(&pdev->dev, "no usable DMA configuration\n"); dev_err(&pdev->dev, "no usable DMA configuration\n");
goto err_out_free_regions; goto err_out_free_regions;

2
drivers/net/smsc9420.c
View File

@ -1598,7 +1598,7 @@ smsc9420_probe(struct pci_dev *pdev, const struct pci_device_id *id)
goto out_free_netdev_2; 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"); printk(KERN_ERR "No usable DMA configuration, aborting.\n");
goto out_free_regions_3; goto out_free_regions_3;
} }

2
drivers/net/sungem.c
View 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_set_dma_mask(pdev, DMA_BIT_MASK(64))) {
pci_using_dac = 1; pci_using_dac = 1;
} else { } else {
err = pci_set_dma_mask(pdev, DMA_32BIT_MASK); err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
if (err) { if (err) {
printk(KERN_ERR PFX "No usable DMA configuration, " printk(KERN_ERR PFX "No usable DMA configuration, "
"aborting.\n"); "aborting.\n");

4
drivers/net/tehuti.c
View 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)))) { !(err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)))) {
pci_using_dac = 1; pci_using_dac = 1;
} else { } else {
if ((err = pci_set_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_32BIT_MASK))) { (err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32)))) {
printk(KERN_ERR "tehuti: No usable DMA configuration" printk(KERN_ERR "tehuti: No usable DMA configuration"
", aborting\n"); ", aborting\n");
goto err_dma; goto err_dma;

4
drivers/net/tehuti.h
View File

@ -99,10 +99,6 @@
#define READ_REG(pp, reg) readl(pp->pBdxRegs + reg) #define READ_REG(pp, reg) readl(pp->pBdxRegs + reg)
#define WRITE_REG(pp, reg, val) writel(val, 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 #ifndef NET_IP_ALIGN
# define NET_IP_ALIGN 2 # define NET_IP_ALIGN 2
#endif #endif

Some files were not shown because too many files have changed in this diff Show More