hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

[PATCH] Replace 0xff.. with correct DMA_xBIT_MASK 

Replace all occurences of 0xff..  in calls to function pci_set_dma_mask()
and pci_set_consistant_dma_mask() with the corresponding DMA_xBIT_MASK from
linux/dma-mapping.h.

Signed-off-by: Matthias Gehre <M.Gehre@gmx.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
This commit is contained in:
Matthias Gehre 2006-03-28 01:56:48 -08:00 committed by Linus Torvalds
parent 60c904ae5b
commit 910638ae7e
38 changed files with 88 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Documentation/DMA-mapping.txt
View File

@ -199,6 +199,8 @@ address during PCI bus mastering you might do something like:
"mydev: 24-bit DMA addressing not available.\n"); "mydev: 24-bit DMA addressing not available.\n");
goto ignore_this_device; goto ignore_this_device;
} }
[Better use DMA_24BIT_MASK instead of 0x00ffffff.
See linux/include/dma-mapping.h for reference.]
When pci_set_dma_mask() is successful, and returns zero, the PCI layer When pci_set_dma_mask() is successful, and returns zero, the PCI layer
saves away this mask you have provided. The PCI layer will use this saves away this mask you have provided. The PCI layer will use this

2
drivers/atm/lanai.c
View File

@ -1972,7 +1972,7 @@ static int __devinit lanai_pci_start(struct lanai_dev *lanai)
"(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, 0xFFFFFFFF) != 0) { if (pci_set_consistent_dma_mask(pci, DMA_32BIT_MASK) != 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;

5
drivers/block/umem.c
View File

@ -50,6 +50,7 @@
#include <linux/timer.h> #include <linux/timer.h>
#include <linux/pci.h> #include <linux/pci.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/dma-mapping.h>
#include <linux/fcntl.h> /* O_ACCMODE */ #include <linux/fcntl.h> /* O_ACCMODE */
#include <linux/hdreg.h> /* HDIO_GETGEO */ #include <linux/hdreg.h> /* HDIO_GETGEO */
@ -881,8 +882,8 @@ static int __devinit mm_pci_probe(struct pci_dev *dev, const struct pci_device_i
printk(KERN_INFO "Micro Memory(tm) controller #%d found at %02x:%02x (PCI Mem Module (Battery Backup))\n", printk(KERN_INFO "Micro Memory(tm) controller #%d found at %02x:%02x (PCI Mem Module (Battery Backup))\n",
card->card_number, dev->bus->number, dev->devfn); card->card_number, dev->bus->number, dev->devfn);
if (pci_set_dma_mask(dev, 0xffffffffffffffffLL) && if (pci_set_dma_mask(dev, DMA_64BIT_MASK) &&
pci_set_dma_mask(dev, 0xffffffffLL)) { pci_set_dma_mask(dev, DMA_32BIT_MASK)) {
printk(KERN_WARNING "MM%d: NO suitable DMA found\n",num_cards); printk(KERN_WARNING "MM%d: NO suitable DMA found\n",num_cards);
return -ENOMEM; return -ENOMEM;
} }

3
drivers/net/forcedeth.c
View File

@ -134,6 +134,7 @@
#include <linux/random.h> #include <linux/random.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/if_vlan.h> #include <linux/if_vlan.h>
#include <linux/dma-mapping.h>
#include <asm/irq.h> #include <asm/irq.h>
#include <asm/io.h> #include <asm/io.h>
@ -2932,7 +2933,7 @@ static int __devinit nv_probe(struct pci_dev *pci_dev, const struct pci_device_i
if (id->driver_data & DEV_HAS_HIGH_DMA) { if (id->driver_data & DEV_HAS_HIGH_DMA) {
/* packet format 3: supports 40-bit addressing */ /* packet format 3: supports 40-bit addressing */
np->desc_ver = DESC_VER_3; np->desc_ver = DESC_VER_3;
if (pci_set_dma_mask(pci_dev, 0x0000007fffffffffULL)) { if (pci_set_dma_mask(pci_dev, DMA_39BIT_MASK)) {
printk(KERN_INFO "forcedeth: 64-bit DMA failed, using 32-bit addressing for device %s.\n", printk(KERN_INFO "forcedeth: 64-bit DMA failed, using 32-bit addressing for device %s.\n",
pci_name(pci_dev)); pci_name(pci_dev));
} else { } else {

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

@ -44,6 +44,7 @@
#include <linux/ip.h> #include <linux/ip.h>
#include <linux/tcp.h> #include <linux/tcp.h>
#include <linux/udp.h> #include <linux/udp.h>
#include <linux/dma-mapping.h>
#ifdef CONFIG_SERIAL_8250 #ifdef CONFIG_SERIAL_8250
#include <linux/serial_core.h> #include <linux/serial_core.h>
@ -1195,17 +1196,17 @@ static int ioc3_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
int err, pci_using_dac; int err, pci_using_dac;
/* Configure DMA attributes. */ /* Configure DMA attributes. */
err = pci_set_dma_mask(pdev, 0xffffffffffffffffULL); err = pci_set_dma_mask(pdev, DMA_64BIT_MASK);
if (!err) { if (!err) {
pci_using_dac = 1; pci_using_dac = 1;
err = pci_set_consistent_dma_mask(pdev, 0xffffffffffffffffULL); err = pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK);
if (err < 0) { if (err < 0) {
printk(KERN_ERR "%s: Unable to obtain 64 bit DMA " printk(KERN_ERR "%s: Unable to obtain 64 bit DMA "
"for consistent allocations\n", pci_name(pdev)); "for consistent allocations\n", pci_name(pdev));
goto out; goto out;
} }
} else { } else {
err = pci_set_dma_mask(pdev, 0xffffffffULL); err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
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));

6
drivers/net/ns83820.c
View File

@ -1828,10 +1828,10 @@ static int __devinit ns83820_init_one(struct pci_dev *pci_dev, const struct pci_
int using_dac = 0; int using_dac = 0;
/* See if we can set the dma mask early on; failure is fatal. */ /* See if we can set the dma mask early on; failure is fatal. */
if (sizeof(dma_addr_t) == 8 && if (sizeof(dma_addr_t) == 8 &&
!pci_set_dma_mask(pci_dev, 0xffffffffffffffffULL)) { !pci_set_dma_mask(pci_dev, DMA_64BIT_MASK)) {
using_dac = 1; using_dac = 1;
} else if (!pci_set_dma_mask(pci_dev, 0xffffffff)) { } else if (!pci_set_dma_mask(pci_dev, DMA_32BIT_MASK)) {
using_dac = 0; using_dac = 0;
} else { } else {
printk(KERN_WARNING "ns83820.c: pci_set_dma_mask failed!\n"); printk(KERN_WARNING "ns83820.c: pci_set_dma_mask failed!\n");

4
drivers/net/wan/wanxl.c
View File

@ -577,8 +577,8 @@ static int __devinit wanxl_pci_init_one(struct pci_dev *pdev,
We set both dma_mask and consistent_dma_mask to 28 bits We set both dma_mask and consistent_dma_mask to 28 bits
and pray pci_alloc_consistent() will use this info. It should and pray pci_alloc_consistent() will use this info. It should
work on most platforms */ work on most platforms */
if (pci_set_consistent_dma_mask(pdev, 0x0FFFFFFF) || if (pci_set_consistent_dma_mask(pdev, DMA_28BIT_MASK) ||
pci_set_dma_mask(pdev, 0x0FFFFFFF)) { pci_set_dma_mask(pdev, DMA_28BIT_MASK)) {
printk(KERN_ERR "wanXL: No usable DMA configuration\n"); printk(KERN_ERR "wanXL: No usable DMA configuration\n");
return -EIO; return -EIO;
} }

3
drivers/net/wireless/prism54/islpci_hotplug.c
View File

@ -22,6 +22,7 @@
#include <linux/pci.h> #include <linux/pci.h>
#include <linux/delay.h> #include <linux/delay.h>
#include <linux/init.h> /* For __init, __exit */ #include <linux/init.h> /* For __init, __exit */
#include <linux/dma-mapping.h>
#include "prismcompat.h" #include "prismcompat.h"
#include "islpci_dev.h" #include "islpci_dev.h"
@ -124,7 +125,7 @@ prism54_probe(struct pci_dev *pdev, const struct pci_device_id *id)
} }
/* enable PCI DMA */ /* enable PCI DMA */
if (pci_set_dma_mask(pdev, 0xffffffff)) { if (pci_set_dma_mask(pdev, DMA_32BIT_MASK)) {
printk(KERN_ERR "%s: 32-bit PCI DMA not supported", DRV_NAME); printk(KERN_ERR "%s: 32-bit PCI DMA not supported", DRV_NAME);
goto do_pci_disable_device; goto do_pci_disable_device;
} }

7
drivers/scsi/BusLogic.c
View File

@ -42,6 +42,7 @@
#include <linux/pci.h> #include <linux/pci.h>
#include <linux/spinlock.h> #include <linux/spinlock.h>
#include <linux/jiffies.h> #include <linux/jiffies.h>
#include <linux/dma-mapping.h>
#include <scsi/scsicam.h> #include <scsi/scsicam.h>
#include <asm/dma.h> #include <asm/dma.h>
@ -677,7 +678,7 @@ static int __init BusLogic_InitializeMultiMasterProbeInfo(struct BusLogic_HostAd
if (pci_enable_device(PCI_Device)) if (pci_enable_device(PCI_Device))
continue; continue;
if (pci_set_dma_mask(PCI_Device, (u64) 0xffffffff)) if (pci_set_dma_mask(PCI_Device, DMA_32BIT_MASK ))
continue; continue;
Bus = PCI_Device->bus->number; Bus = PCI_Device->bus->number;
@ -832,7 +833,7 @@ static int __init BusLogic_InitializeMultiMasterProbeInfo(struct BusLogic_HostAd
if (pci_enable_device(PCI_Device)) if (pci_enable_device(PCI_Device))
continue; continue;
if (pci_set_dma_mask(PCI_Device, (u64) 0xffffffff)) if (pci_set_dma_mask(PCI_Device, DMA_32BIT_MASK))
continue; continue;
Bus = PCI_Device->bus->number; Bus = PCI_Device->bus->number;
@ -886,7 +887,7 @@ static int __init BusLogic_InitializeFlashPointProbeInfo(struct BusLogic_HostAda
if (pci_enable_device(PCI_Device)) if (pci_enable_device(PCI_Device))
continue; continue;
if (pci_set_dma_mask(PCI_Device, (u64) 0xffffffff)) if (pci_set_dma_mask(PCI_Device, DMA_32BIT_MASK))
continue; continue;
Bus = PCI_Device->bus->number; Bus = PCI_Device->bus->number;

3
drivers/scsi/a100u2w.c
View File

@ -89,6 +89,7 @@
#include <linux/string.h> #include <linux/string.h>
#include <linux/ioport.h> #include <linux/ioport.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/dma-mapping.h>
#include <asm/io.h> #include <asm/io.h>
#include <asm/irq.h> #include <asm/irq.h>
@ -1052,7 +1053,7 @@ static int __devinit inia100_probe_one(struct pci_dev *pdev,
if (pci_enable_device(pdev)) if (pci_enable_device(pdev))
goto out; goto out;
if (pci_set_dma_mask(pdev, 0xffffffffULL)) { if (pci_set_dma_mask(pdev, DMA_32BIT_MASK)) {
printk(KERN_WARNING "Unable to set 32bit DMA " printk(KERN_WARNING "Unable to set 32bit DMA "
"on inia100 adapter, ignoring.\n"); "on inia100 adapter, ignoring.\n");
goto out_disable_device; goto out_disable_device;

1
drivers/scsi/aacraid/aachba.c
View File

@ -32,6 +32,7 @@
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/completion.h> #include <linux/completion.h>
#include <linux/blkdev.h> #include <linux/blkdev.h>
#include <linux/dma-mapping.h>
#include <asm/semaphore.h> #include <asm/semaphore.h>
#include <asm/uaccess.h> #include <asm/uaccess.h>

5
drivers/scsi/aacraid/linit.c
View File

@ -45,6 +45,7 @@
#include <linux/pci.h> #include <linux/pci.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/spinlock.h> #include <linux/spinlock.h>
#include <linux/dma-mapping.h>
#include <linux/syscalls.h> #include <linux/syscalls.h>
#include <linux/delay.h> #include <linux/delay.h>
#include <linux/smp_lock.h> #include <linux/smp_lock.h>
@ -806,8 +807,8 @@ static int __devinit aac_probe_one(struct pci_dev *pdev,
* to driver communication memory to be allocated below 2gig * to driver communication memory to be allocated below 2gig
*/ */
if (aac_drivers[index].quirks & AAC_QUIRK_31BIT) if (aac_drivers[index].quirks & AAC_QUIRK_31BIT)
if (pci_set_dma_mask(pdev, 0x7FFFFFFFULL) || if (pci_set_dma_mask(pdev, DMA_31BIT_MASK) ||
pci_set_consistent_dma_mask(pdev, 0x7FFFFFFFULL)) pci_set_consistent_dma_mask(pdev, DMA_31BIT_MASK))
goto out; goto out;
pci_set_master(pdev); pci_set_master(pdev);

3
drivers/scsi/atp870u.c
View File

@ -28,6 +28,7 @@
#include <linux/spinlock.h> #include <linux/spinlock.h>
#include <linux/pci.h> #include <linux/pci.h>
#include <linux/blkdev.h> #include <linux/blkdev.h>
#include <linux/dma-mapping.h>
#include <asm/system.h> #include <asm/system.h>
#include <asm/io.h> #include <asm/io.h>
@ -2631,7 +2632,7 @@ static int atp870u_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
if (pci_enable_device(pdev)) if (pci_enable_device(pdev))
return -EIO; return -EIO;
if (!pci_set_dma_mask(pdev, 0xFFFFFFFFUL)) { if (!pci_set_dma_mask(pdev, DMA_32BIT_MASK)) {
printk(KERN_INFO "atp870u: use 32bit DMA mask.\n"); printk(KERN_INFO "atp870u: use 32bit DMA mask.\n");
} else { } else {
printk(KERN_ERR "atp870u: DMA mask required but not available.\n"); printk(KERN_ERR "atp870u: DMA mask required but not available.\n");

5
drivers/scsi/dpt_i2o.c
View File

@ -57,6 +57,7 @@ MODULE_DESCRIPTION("Adaptec I2O RAID Driver");
#include <linux/reboot.h> #include <linux/reboot.h>
#include <linux/spinlock.h> #include <linux/spinlock.h>
#include <linux/smp_lock.h> #include <linux/smp_lock.h>
#include <linux/dma-mapping.h>
#include <linux/timer.h> #include <linux/timer.h>
#include <linux/string.h> #include <linux/string.h>
@ -906,8 +907,8 @@ static int adpt_install_hba(struct scsi_host_template* sht, struct pci_dev* pDev
} }
pci_set_master(pDev); pci_set_master(pDev);
if (pci_set_dma_mask(pDev, 0xffffffffffffffffULL) && if (pci_set_dma_mask(pDev, DMA_64BIT_MASK) &&
pci_set_dma_mask(pDev, 0xffffffffULL)) pci_set_dma_mask(pDev, DMA_32BIT_MASK))
return -EINVAL; return -EINVAL;
base_addr0_phys = pci_resource_start(pDev,0); base_addr0_phys = pci_resource_start(pDev,0);

3
drivers/scsi/eata.c
View File

@ -490,6 +490,7 @@
#include <linux/init.h> #include <linux/init.h>
#include <linux/ctype.h> #include <linux/ctype.h>
#include <linux/spinlock.h> #include <linux/spinlock.h>
#include <linux/dma-mapping.h>
#include <asm/byteorder.h> #include <asm/byteorder.h>
#include <asm/dma.h> #include <asm/dma.h>
#include <asm/io.h> #include <asm/io.h>
@ -1426,7 +1427,7 @@ static int port_detect(unsigned long port_base, unsigned int j,
if (ha->pdev) { if (ha->pdev) {
pci_set_master(ha->pdev); pci_set_master(ha->pdev);
if (pci_set_dma_mask(ha->pdev, 0xffffffff)) if (pci_set_dma_mask(ha->pdev, DMA_32BIT_MASK))
printk("%s: warning, pci_set_dma_mask failed.\n", printk("%s: warning, pci_set_dma_mask failed.\n",
ha->board_name); ha->board_name);
} }

7
drivers/scsi/gdth.c
View File

@ -388,6 +388,7 @@
#include <linux/proc_fs.h> #include <linux/proc_fs.h>
#include <linux/time.h> #include <linux/time.h>
#include <linux/timer.h> #include <linux/timer.h>
#include <linux/dma-mapping.h>
#ifdef GDTH_RTC #ifdef GDTH_RTC
#include <linux/mc146818rtc.h> #include <linux/mc146818rtc.h>
#endif #endif
@ -4527,15 +4528,15 @@ static int __init gdth_detect(struct scsi_host_template *shtp)
if (!(ha->cache_feat & ha->raw_feat & ha->screen_feat &GDT_64BIT)|| if (!(ha->cache_feat & ha->raw_feat & ha->screen_feat &GDT_64BIT)||
/* 64-bit DMA only supported from FW >= x.43 */ /* 64-bit DMA only supported from FW >= x.43 */
(!ha->dma64_support)) { (!ha->dma64_support)) {
if (pci_set_dma_mask(pcistr[ctr].pdev, 0xffffffff)) { if (pci_set_dma_mask(pcistr[ctr].pdev, DMA_32BIT_MASK)) {
printk(KERN_WARNING "GDT-PCI %d: Unable to set 32-bit DMA\n", hanum); printk(KERN_WARNING "GDT-PCI %d: Unable to set 32-bit DMA\n", hanum);
err = TRUE; err = TRUE;
} }
} else { } else {
shp->max_cmd_len = 16; shp->max_cmd_len = 16;
if (!pci_set_dma_mask(pcistr[ctr].pdev, 0xffffffffffffffffULL)) { if (!pci_set_dma_mask(pcistr[ctr].pdev, DMA_64BIT_MASK)) {
printk("GDT-PCI %d: 64-bit DMA enabled\n", hanum); printk("GDT-PCI %d: 64-bit DMA enabled\n", hanum);
} else if (pci_set_dma_mask(pcistr[ctr].pdev, 0xffffffff)) { } else if (pci_set_dma_mask(pcistr[ctr].pdev, DMA_32BIT_MASK)) {
printk(KERN_WARNING "GDT-PCI %d: Unable to set 64/32-bit DMA\n", hanum); printk(KERN_WARNING "GDT-PCI %d: Unable to set 64/32-bit DMA\n", hanum);
err = TRUE; err = TRUE;
} }

3
drivers/scsi/initio.c
View File

@ -127,6 +127,7 @@
#include <linux/sched.h> #include <linux/sched.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/jiffies.h> #include <linux/jiffies.h>
#include <linux/dma-mapping.h>
#include <asm/io.h> #include <asm/io.h>
#include <scsi/scsi.h> #include <scsi/scsi.h>
@ -2780,7 +2781,7 @@ static int tul_NewReturnNumberOfAdapters(void)
if (((dRegValue & 0xFF00) >> 8) == 0xFF) if (((dRegValue & 0xFF00) >> 8) == 0xFF)
dRegValue = 0; dRegValue = 0;
wBIOS = (wBIOS << 8) + ((UWORD) ((dRegValue & 0xFF00) >> 8)); wBIOS = (wBIOS << 8) + ((UWORD) ((dRegValue & 0xFF00) >> 8));
if (pci_set_dma_mask(pDev, 0xffffffff)) { if (pci_set_dma_mask(pDev, DMA_32BIT_MASK)) {
printk(KERN_WARNING printk(KERN_WARNING
"i91u: Could not set 32 bit DMA mask\n"); "i91u: Could not set 32 bit DMA mask\n");
continue; continue;

5
drivers/scsi/ips.c
View File

@ -179,6 +179,7 @@
#include <linux/blkdev.h> #include <linux/blkdev.h>
#include <linux/types.h> #include <linux/types.h>
#include <linux/dma-mapping.h>
#include <scsi/sg.h> #include <scsi/sg.h>
@ -7284,10 +7285,10 @@ ips_init_phase1(struct pci_dev *pci_dev, int *indexPtr)
* are guaranteed to be < 4G. * are guaranteed to be < 4G.
*/ */
if (IPS_ENABLE_DMA64 && IPS_HAS_ENH_SGLIST(ha) && if (IPS_ENABLE_DMA64 && IPS_HAS_ENH_SGLIST(ha) &&
!pci_set_dma_mask(ha->pcidev, 0xffffffffffffffffULL)) { !pci_set_dma_mask(ha->pcidev, DMA_64BIT_MASK)) {
(ha)->flags |= IPS_HA_ENH_SG; (ha)->flags |= IPS_HA_ENH_SG;
} else { } else {
if (pci_set_dma_mask(ha->pcidev, 0xffffffffULL) != 0) { if (pci_set_dma_mask(ha->pcidev, DMA_32BIT_MASK) != 0) {
printk(KERN_WARNING "Unable to set DMA Mask\n"); printk(KERN_WARNING "Unable to set DMA Mask\n");
return ips_abort_init(ha, index); return ips_abort_init(ha, index);
} }

7
drivers/scsi/megaraid.c
View File

@ -45,6 +45,7 @@
#include <linux/interrupt.h> #include <linux/interrupt.h>
#include <linux/pci.h> #include <linux/pci.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/dma-mapping.h>
#include <scsi/scsicam.h> #include <scsi/scsicam.h>
#include "scsi.h" #include "scsi.h"
@ -2094,7 +2095,7 @@ make_local_pdev(adapter_t *adapter, struct pci_dev **pdev)
memcpy(*pdev, adapter->dev, sizeof(struct pci_dev)); memcpy(*pdev, adapter->dev, sizeof(struct pci_dev));
if( pci_set_dma_mask(*pdev, 0xffffffff) != 0 ) { if( pci_set_dma_mask(*pdev, DMA_32BIT_MASK) != 0 ) {
kfree(*pdev); kfree(*pdev);
return -1; return -1;
} }
@ -4859,10 +4860,10 @@ megaraid_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
/* Set the Mode of addressing to 64 bit if we can */ /* Set the Mode of addressing to 64 bit if we can */
if ((adapter->flag & BOARD_64BIT) && (sizeof(dma_addr_t) == 8)) { if ((adapter->flag & BOARD_64BIT) && (sizeof(dma_addr_t) == 8)) {
pci_set_dma_mask(pdev, 0xffffffffffffffffULL); pci_set_dma_mask(pdev, DMA_64BIT_MASK);
adapter->has_64bit_addr = 1; adapter->has_64bit_addr = 1;
} else { } else {
pci_set_dma_mask(pdev, 0xffffffff); pci_set_dma_mask(pdev, DMA_32BIT_MASK);
adapter->has_64bit_addr = 0; adapter->has_64bit_addr = 0;
} }

3
drivers/scsi/nsp32.c
View File

@ -38,6 +38,7 @@
#include <linux/pci.h> #include <linux/pci.h>
#include <linux/delay.h> #include <linux/delay.h>
#include <linux/ctype.h> #include <linux/ctype.h>
#include <linux/dma-mapping.h>
#include <asm/dma.h> #include <asm/dma.h>
#include <asm/system.h> #include <asm/system.h>
@ -2776,7 +2777,7 @@ static int nsp32_detect(struct scsi_host_template *sht)
/* /*
* setup DMA * setup DMA
*/ */
if (pci_set_dma_mask(PCIDEV, 0xffffffffUL) != 0) { if (pci_set_dma_mask(PCIDEV, DMA_32BIT_MASK) != 0) {
nsp32_msg (KERN_ERR, "failed to set PCI DMA mask"); nsp32_msg (KERN_ERR, "failed to set PCI DMA mask");
goto scsi_unregister; goto scsi_unregister;
} }

5
drivers/scsi/qla1280.c
View File

@ -350,6 +350,7 @@
#include <linux/pci_ids.h> #include <linux/pci_ids.h>
#include <linux/interrupt.h> #include <linux/interrupt.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/dma-mapping.h>
#include <asm/io.h> #include <asm/io.h>
#include <asm/irq.h> #include <asm/irq.h>
@ -4321,7 +4322,7 @@ qla1280_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
#ifdef QLA_64BIT_PTR #ifdef QLA_64BIT_PTR
if (pci_set_dma_mask(ha->pdev, (dma_addr_t) ~ 0ULL)) { if (pci_set_dma_mask(ha->pdev, (dma_addr_t) ~ 0ULL)) {
if (pci_set_dma_mask(ha->pdev, 0xffffffff)) { if (pci_set_dma_mask(ha->pdev, DMA_32BIT_MASK)) {
printk(KERN_WARNING "scsi(%li): Unable to set a " printk(KERN_WARNING "scsi(%li): Unable to set a "
"suitable DMA mask - aborting\n", ha->host_no); "suitable DMA mask - aborting\n", ha->host_no);
error = -ENODEV; error = -ENODEV;
@ -4331,7 +4332,7 @@ qla1280_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
dprintk(2, "scsi(%li): 64 Bit PCI Addressing Enabled\n", dprintk(2, "scsi(%li): 64 Bit PCI Addressing Enabled\n",
ha->host_no); ha->host_no);
#else #else
if (pci_set_dma_mask(ha->pdev, 0xffffffff)) { if (pci_set_dma_mask(ha->pdev, DMA_32BIT_MASK)) {
printk(KERN_WARNING "scsi(%li): Unable to set a " printk(KERN_WARNING "scsi(%li): Unable to set a "
"suitable DMA mask - aborting\n", ha->host_no); "suitable DMA mask - aborting\n", ha->host_no);
error = -ENODEV; error = -ENODEV;

5
drivers/scsi/qlogicfc.c
View File

@ -61,6 +61,7 @@
#include <linux/unistd.h> #include <linux/unistd.h>
#include <linux/spinlock.h> #include <linux/spinlock.h>
#include <linux/interrupt.h> #include <linux/interrupt.h>
#include <linux/dma-mapping.h>
#include <linux/jiffies.h> #include <linux/jiffies.h>
#include <asm/io.h> #include <asm/io.h>
#include <asm/irq.h> #include <asm/irq.h>
@ -738,8 +739,8 @@ static int isp2x00_detect(struct scsi_host_template * tmpt)
continue; continue;
/* Try to configure DMA attributes. */ /* Try to configure DMA attributes. */
if (pci_set_dma_mask(pdev, 0xffffffffffffffffULL) && if (pci_set_dma_mask(pdev, DMA_64BIT_MASK) &&
pci_set_dma_mask(pdev, 0xffffffffULL)) pci_set_dma_mask(pdev, DMA_32BIT_MASK))
continue; continue;
host = scsi_register(tmpt, sizeof(struct isp2x00_hostdata)); host = scsi_register(tmpt, sizeof(struct isp2x00_hostdata));

1
include/linux/dma-mapping.h
View File

@ -21,6 +21,7 @@ enum dma_data_direction {
#define DMA_30BIT_MASK 0x000000003fffffffULL #define DMA_30BIT_MASK 0x000000003fffffffULL
#define DMA_29BIT_MASK 0x000000001fffffffULL #define DMA_29BIT_MASK 0x000000001fffffffULL
#define DMA_28BIT_MASK 0x000000000fffffffULL #define DMA_28BIT_MASK 0x000000000fffffffULL
#define DMA_24BIT_MASK 0x0000000000ffffffULL
#include <asm/dma-mapping.h> #include <asm/dma-mapping.h>

2
sound/oss/esssolo1.c
View File

@ -2348,7 +2348,7 @@ static int __devinit solo1_probe(struct pci_dev *pcidev, const struct pci_device
/* Recording requires 24-bit DMA, so attempt to set dma mask /* Recording requires 24-bit DMA, so attempt to set dma mask
* to 24 bits first, then 32 bits (playback only) if that fails. * to 24 bits first, then 32 bits (playback only) if that fails.
*/ */
if (pci_set_dma_mask(pcidev, 0x00ffffff) && if (pci_set_dma_mask(pcidev, DMA_24BIT_MASK) &&
pci_set_dma_mask(pcidev, DMA_32BIT_MASK)) { pci_set_dma_mask(pcidev, DMA_32BIT_MASK)) {
printk(KERN_WARNING "solo1: architecture does not support 24bit or 32bit PCI busmaster DMA\n"); printk(KERN_WARNING "solo1: architecture does not support 24bit or 32bit PCI busmaster DMA\n");
return -ENODEV; return -ENODEV;

3
sound/oss/sonicvibes.c
View File

@ -116,6 +116,7 @@
#include <linux/spinlock.h> #include <linux/spinlock.h>
#include <linux/smp_lock.h> #include <linux/smp_lock.h>
#include <linux/gameport.h> #include <linux/gameport.h>
#include <linux/dma-mapping.h>
#include <linux/mutex.h> #include <linux/mutex.h>
@ -2535,7 +2536,7 @@ static int __devinit sv_probe(struct pci_dev *pcidev, const struct pci_device_id
return -ENODEV; return -ENODEV;
if (pcidev->irq == 0) if (pcidev->irq == 0)
return -ENODEV; return -ENODEV;
if (pci_set_dma_mask(pcidev, 0x00ffffff)) { if (pci_set_dma_mask(pcidev, DMA_24BIT_MASK)) {
printk(KERN_WARNING "sonicvibes: architecture does not support 24bit PCI busmaster DMA\n"); printk(KERN_WARNING "sonicvibes: architecture does not support 24bit PCI busmaster DMA\n");
return -ENODEV; return -ENODEV;
} }

1
sound/pci/ad1889.c
View File

@ -39,6 +39,7 @@
#include <linux/interrupt.h> #include <linux/interrupt.h>
#include <linux/compiler.h> #include <linux/compiler.h>
#include <linux/delay.h> #include <linux/delay.h>
#include <linux/dma-mapping.h>
#include <sound/driver.h> #include <sound/driver.h>
#include <sound/core.h> #include <sound/core.h>

5
sound/pci/ali5451/ali5451.c
View File

@ -33,6 +33,7 @@
#include <linux/pci.h> #include <linux/pci.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/moduleparam.h> #include <linux/moduleparam.h>
#include <linux/dma-mapping.h>
#include <sound/core.h> #include <sound/core.h>
#include <sound/pcm.h> #include <sound/pcm.h>
#include <sound/info.h> #include <sound/info.h>
@ -2220,8 +2221,8 @@ static int __devinit snd_ali_create(struct snd_card *card,
if ((err = pci_enable_device(pci)) < 0) if ((err = pci_enable_device(pci)) < 0)
return err; return err;
/* check, if we can restrict PCI DMA transfers to 31 bits */ /* check, if we can restrict PCI DMA transfers to 31 bits */
if (pci_set_dma_mask(pci, 0x7fffffff) < 0 || if (pci_set_dma_mask(pci, DMA_31BIT_MASK) < 0 ||
pci_set_consistent_dma_mask(pci, 0x7fffffff) < 0) { pci_set_consistent_dma_mask(pci, DMA_31BIT_MASK) < 0) {
snd_printk(KERN_ERR "architecture does not support 31bit PCI busmaster DMA\n"); snd_printk(KERN_ERR "architecture does not support 31bit PCI busmaster DMA\n");
pci_disable_device(pci); pci_disable_device(pci);
return -ENXIO; return -ENXIO;

5
sound/pci/als4000.c
View File

@ -70,6 +70,7 @@
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/gameport.h> #include <linux/gameport.h>
#include <linux/moduleparam.h> #include <linux/moduleparam.h>
#include <linux/dma-mapping.h>
#include <sound/core.h> #include <sound/core.h>
#include <sound/pcm.h> #include <sound/pcm.h>
#include <sound/rawmidi.h> #include <sound/rawmidi.h>
@ -688,8 +689,8 @@ static int __devinit snd_card_als4000_probe(struct pci_dev *pci,
return err; return err;
} }
/* check, if we can restrict PCI DMA transfers to 24 bits */ /* check, if we can restrict PCI DMA transfers to 24 bits */
if (pci_set_dma_mask(pci, 0x00ffffff) < 0 || if (pci_set_dma_mask(pci, DMA_24BIT_MASK) < 0 ||
pci_set_consistent_dma_mask(pci, 0x00ffffff) < 0) { pci_set_consistent_dma_mask(pci, DMA_24BIT_MASK) < 0) {
snd_printk(KERN_ERR "architecture does not support 24bit PCI busmaster DMA\n"); snd_printk(KERN_ERR "architecture does not support 24bit PCI busmaster DMA\n");
pci_disable_device(pci); pci_disable_device(pci);
return -ENXIO; return -ENXIO;

5
sound/pci/azt3328.c
View File

@ -104,6 +104,7 @@
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/gameport.h> #include <linux/gameport.h>
#include <linux/moduleparam.h> #include <linux/moduleparam.h>
#include <linux/dma-mapping.h>
#include <sound/core.h> #include <sound/core.h>
#include <sound/control.h> #include <sound/control.h>
#include <sound/pcm.h> #include <sound/pcm.h>
@ -1669,8 +1670,8 @@ snd_azf3328_create(struct snd_card *card,
chip->irq = -1; chip->irq = -1;
/* check if we can restrict PCI DMA transfers to 24 bits */ /* check if we can restrict PCI DMA transfers to 24 bits */
if (pci_set_dma_mask(pci, 0x00ffffff) < 0 || if (pci_set_dma_mask(pci, DMA_24BIT_MASK) < 0 ||
pci_set_consistent_dma_mask(pci, 0x00ffffff) < 0) { pci_set_consistent_dma_mask(pci, DMA_24BIT_MASK) < 0) {
snd_printk(KERN_ERR "architecture does not support 24bit PCI busmaster DMA\n"); snd_printk(KERN_ERR "architecture does not support 24bit PCI busmaster DMA\n");
err = -ENXIO; err = -ENXIO;
goto out_err; goto out_err;

1
sound/pci/emu10k1/emu10k1x.c
View File

@ -36,6 +36,7 @@
#include <linux/dma-mapping.h> #include <linux/dma-mapping.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/moduleparam.h> #include <linux/moduleparam.h>
#include <linux/dma-mapping.h>
#include <sound/core.h> #include <sound/core.h>
#include <sound/initval.h> #include <sound/initval.h>
#include <sound/pcm.h> #include <sound/pcm.h>

5
sound/pci/es1938.c
View File

@ -55,6 +55,7 @@
#include <linux/gameport.h> #include <linux/gameport.h>
#include <linux/moduleparam.h> #include <linux/moduleparam.h>
#include <linux/delay.h> #include <linux/delay.h>
#include <linux/dma-mapping.h>
#include <sound/core.h> #include <sound/core.h>
#include <sound/control.h> #include <sound/control.h>
#include <sound/pcm.h> #include <sound/pcm.h>
@ -1517,8 +1518,8 @@ static int __devinit snd_es1938_create(struct snd_card *card,
if ((err = pci_enable_device(pci)) < 0) if ((err = pci_enable_device(pci)) < 0)
return err; return err;
/* check, if we can restrict PCI DMA transfers to 24 bits */ /* check, if we can restrict PCI DMA transfers to 24 bits */
if (pci_set_dma_mask(pci, 0x00ffffff) < 0 || if (pci_set_dma_mask(pci, DMA_24BIT_MASK) < 0 ||
pci_set_consistent_dma_mask(pci, 0x00ffffff) < 0) { pci_set_consistent_dma_mask(pci, DMA_24BIT_MASK) < 0) {
snd_printk(KERN_ERR "architecture does not support 24bit PCI busmaster DMA\n"); snd_printk(KERN_ERR "architecture does not support 24bit PCI busmaster DMA\n");
pci_disable_device(pci); pci_disable_device(pci);
return -ENXIO; return -ENXIO;

1
sound/pci/es1968.c
View File

@ -104,6 +104,7 @@
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/gameport.h> #include <linux/gameport.h>
#include <linux/moduleparam.h> #include <linux/moduleparam.h>
#include <linux/dma-mapping.h>
#include <linux/mutex.h> #include <linux/mutex.h>
#include <sound/core.h> #include <sound/core.h>

2
sound/pci/ice1712/ice1712.c
View File

@ -56,7 +56,9 @@
#include <linux/dma-mapping.h> #include <linux/dma-mapping.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/moduleparam.h> #include <linux/moduleparam.h>
#include <linux/dma-mapping.h>
#include <linux/mutex.h> #include <linux/mutex.h>
#include <sound/core.h> #include <sound/core.h>
#include <sound/cs8427.h> #include <sound/cs8427.h>
#include <sound/info.h> #include <sound/info.h>

1
sound/pci/maestro3.c
View File

@ -41,6 +41,7 @@
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/vmalloc.h> #include <linux/vmalloc.h>
#include <linux/moduleparam.h> #include <linux/moduleparam.h>
#include <linux/dma-mapping.h>
#include <sound/core.h> #include <sound/core.h>
#include <sound/info.h> #include <sound/info.h>
#include <sound/control.h> #include <sound/control.h>

2
sound/pci/mixart/mixart.c
View File

@ -28,6 +28,8 @@
#include <linux/dma-mapping.h> #include <linux/dma-mapping.h>
#include <linux/moduleparam.h> #include <linux/moduleparam.h>
#include <linux/mutex.h> #include <linux/mutex.h>
#include <linux/dma-mapping.h>
#include <sound/core.h> #include <sound/core.h>
#include <sound/initval.h> #include <sound/initval.h>
#include <sound/info.h> #include <sound/info.h>

1
sound/pci/pcxhr/pcxhr.c
View File

@ -30,6 +30,7 @@
#include <linux/delay.h> #include <linux/delay.h>
#include <linux/moduleparam.h> #include <linux/moduleparam.h>
#include <linux/mutex.h> #include <linux/mutex.h>
#include <linux/dma-mapping.h>
#include <sound/core.h> #include <sound/core.h>
#include <sound/initval.h> #include <sound/initval.h>

5
sound/pci/sonicvibes.c
View File

@ -30,6 +30,7 @@
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/gameport.h> #include <linux/gameport.h>
#include <linux/moduleparam.h> #include <linux/moduleparam.h>
#include <linux/dma-mapping.h>
#include <sound/core.h> #include <sound/core.h>
#include <sound/pcm.h> #include <sound/pcm.h>
@ -1227,8 +1228,8 @@ static int __devinit snd_sonicvibes_create(struct snd_card *card,
if ((err = pci_enable_device(pci)) < 0) if ((err = pci_enable_device(pci)) < 0)
return err; return err;
/* check, if we can restrict PCI DMA transfers to 24 bits */ /* check, if we can restrict PCI DMA transfers to 24 bits */
if (pci_set_dma_mask(pci, 0x00ffffff) < 0 || if (pci_set_dma_mask(pci, DMA_24BIT_MASK) < 0 ||
pci_set_consistent_dma_mask(pci, 0x00ffffff) < 0) { pci_set_consistent_dma_mask(pci, DMA_24BIT_MASK) < 0) {
snd_printk(KERN_ERR "architecture does not support 24bit PCI busmaster DMA\n"); snd_printk(KERN_ERR "architecture does not support 24bit PCI busmaster DMA\n");
pci_disable_device(pci); pci_disable_device(pci);
return -ENXIO; return -ENXIO;

5
sound/pci/trident/trident_main.c
View File

@ -35,6 +35,7 @@
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/vmalloc.h> #include <linux/vmalloc.h>
#include <linux/gameport.h> #include <linux/gameport.h>
#include <linux/dma-mapping.h>
#include <sound/core.h> #include <sound/core.h>
#include <sound/info.h> #include <sound/info.h>
@ -3554,8 +3555,8 @@ int __devinit snd_trident_create(struct snd_card *card,
if ((err = pci_enable_device(pci)) < 0) if ((err = pci_enable_device(pci)) < 0)
return err; return err;
/* check, if we can restrict PCI DMA transfers to 30 bits */ /* check, if we can restrict PCI DMA transfers to 30 bits */
if (pci_set_dma_mask(pci, 0x3fffffff) < 0 || if (pci_set_dma_mask(pci, DMA_30BIT_MASK) < 0 ||
pci_set_consistent_dma_mask(pci, 0x3fffffff) < 0) { pci_set_consistent_dma_mask(pci, DMA_30BIT_MASK) < 0) {
snd_printk(KERN_ERR "architecture does not support 30bit PCI busmaster DMA\n"); snd_printk(KERN_ERR "architecture does not support 30bit PCI busmaster DMA\n");
pci_disable_device(pci); pci_disable_device(pci);
return -ENXIO; return -ENXIO;