microsoft
/
WSL2-Linux-Kernel
зеркало из https://github.com/microsoft/WSL2-Linux-Kernel.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

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

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 коммит произвёл Linus Torvalds
Родитель 6afd142fd0
Коммит 284901a90a
173 изменённых файлов: 309 добавлений и 313 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

4
arch/arm/mach-davinci/board-evm.c
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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

Некоторые файлы не были показаны из-за слишком большого количества измененных файлов Показать больше