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

21 files changed, 55 insertions, 37 deletions

diff --git a/drivers/atm/lanai.c b/drivers/atm/lanai.c
index 69f4c7ce9a63..cac09e353be8 100644
--- a/drivers/atm/lanai.c
+++ b/drivers/atm/lanai.c
@@ -1972,7 +1972,7 @@ static int __devinit lanai_pci_start(struct lanai_dev *lanai)
                     "(itf %d): No suitable DMA available.\n", lanai->number);
                 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
                     "(itf %d): No suitable DMA available.\n", lanai->number);
                 return -EBUSY;
diff --git a/drivers/block/umem.c b/drivers/block/umem.c
index c16e66b9c7a7..f7d4c65a7b8c 100644
--- a/drivers/block/umem.c
+++ b/drivers/block/umem.c
@@ -50,6 +50,7 @@
 #include <linux/timer.h>
 #include <linux/pci.h>
 #include <linux/slab.h>
+#include <linux/dma-mapping.h>
 
 #include <linux/fcntl.h>        /* O_ACCMODE */
 #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",
                card->card_number, dev->bus->number, dev->devfn);
 
-        if (pci_set_dma_mask(dev, 0xffffffffffffffffLL) &&
-            pci_set_dma_mask(dev, 0xffffffffLL)) {
+        if (pci_set_dma_mask(dev, DMA_64BIT_MASK) &&
+            pci_set_dma_mask(dev, DMA_32BIT_MASK)) {
                 printk(KERN_WARNING "MM%d: NO suitable DMA found\n",num_cards);
                 return  -ENOMEM;
         }
diff --git a/drivers/net/forcedeth.c b/drivers/net/forcedeth.c
index e7fc28b07e5a..7627a75f4f7c 100644
--- a/drivers/net/forcedeth.c
+++ b/drivers/net/forcedeth.c
@@ -134,6 +134,7 @@
 #include <linux/random.h>
 #include <linux/init.h>
 #include <linux/if_vlan.h>
+#include <linux/dma-mapping.h>
 
 #include <asm/irq.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) {
                 /* packet format 3: supports 40-bit addressing */
                 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",
                                         pci_name(pci_dev));
                 } else {
diff --git a/drivers/net/ioc3-eth.c b/drivers/net/ioc3-eth.c
index 9b8295ee06ef..ae71ed57c12d 100644
--- a/drivers/net/ioc3-eth.c
+++ b/drivers/net/ioc3-eth.c
@@ -44,6 +44,7 @@
 #include <linux/ip.h>
 #include <linux/tcp.h>
 #include <linux/udp.h>
+#include <linux/dma-mapping.h>
 
 #ifdef CONFIG_SERIAL_8250
 #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;
 
         /* Configure DMA attributes. */
-        err = pci_set_dma_mask(pdev, 0xffffffffffffffffULL);
+        err = pci_set_dma_mask(pdev, DMA_64BIT_MASK);
         if (!err) {
                 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) {
                         printk(KERN_ERR "%s: Unable to obtain 64 bit DMA "
                                "for consistent allocations\n", pci_name(pdev));
                         goto out;
                 }
         } else {
-                err = pci_set_dma_mask(pdev, 0xffffffffULL);
+                err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
                 if (err) {
                         printk(KERN_ERR "%s: No usable DMA configuration, "
                                "aborting.\n", pci_name(pdev));
diff --git a/drivers/net/ns83820.c b/drivers/net/ns83820.c
index 0fede50abd3e..8e9b1a537dee 100644
--- a/drivers/net/ns83820.c
+++ b/drivers/net/ns83820.c
@@ -1828,10 +1828,10 @@ static int __devinit ns83820_init_one(struct pci_dev *pci_dev, const struct pci_
         int using_dac = 0;
 
         /* See if we can set the dma mask early on; failure is fatal. */
-        if (sizeof(dma_addr_t) == 8 && 
-                !pci_set_dma_mask(pci_dev, 0xffffffffffffffffULL)) {
+        if (sizeof(dma_addr_t) == 8 &&
+                !pci_set_dma_mask(pci_dev, DMA_64BIT_MASK)) {
                 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;
         } else {
                 printk(KERN_WARNING "ns83820.c: pci_set_dma_mask failed!\n");
diff --git a/drivers/net/wan/wanxl.c b/drivers/net/wan/wanxl.c
index 9d3b51c3ef54..29a756dd979b 100644
--- a/drivers/net/wan/wanxl.c
+++ b/drivers/net/wan/wanxl.c
@@ -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
            and pray pci_alloc_consistent() will use this info. It should
            work on most platforms */
-        if (pci_set_consistent_dma_mask(pdev, 0x0FFFFFFF) ||
-            pci_set_dma_mask(pdev, 0x0FFFFFFF)) {
+        if (pci_set_consistent_dma_mask(pdev, DMA_28BIT_MASK) ||
+            pci_set_dma_mask(pdev, DMA_28BIT_MASK)) {
                 printk(KERN_ERR "wanXL: No usable DMA configuration\n");
                 return -EIO;
         }
diff --git a/drivers/net/wireless/prism54/islpci_hotplug.c b/drivers/net/wireless/prism54/islpci_hotplug.c
index b41d666fea3c..bfa0cc319a09 100644
--- a/drivers/net/wireless/prism54/islpci_hotplug.c
+++ b/drivers/net/wireless/prism54/islpci_hotplug.c
@@ -22,6 +22,7 @@
 #include <linux/pci.h>
 #include <linux/delay.h>
 #include <linux/init.h> /* For __init, __exit */
+#include <linux/dma-mapping.h>
 
 #include "prismcompat.h"
 #include "islpci_dev.h"
@@ -124,7 +125,7 @@ prism54_probe(struct pci_dev *pdev, const struct pci_device_id *id)
         }
 
         /* 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);
                 goto do_pci_disable_device;
         }
diff --git a/drivers/scsi/BusLogic.c b/drivers/scsi/BusLogic.c
index 5bf83cbca868..bde3d5834ade 100644
--- a/drivers/scsi/BusLogic.c
+++ b/drivers/scsi/BusLogic.c
@@ -42,6 +42,7 @@
 #include <linux/pci.h>
 #include <linux/spinlock.h>
 #include <linux/jiffies.h>
+#include <linux/dma-mapping.h>
 #include <scsi/scsicam.h>
 
 #include <asm/dma.h>
@@ -677,7 +678,7 @@ static int __init BusLogic_InitializeMultiMasterProbeInfo(struct BusLogic_HostAd
                 if (pci_enable_device(PCI_Device))
                         continue;
 
-                if (pci_set_dma_mask(PCI_Device, (u64) 0xffffffff))
+                if (pci_set_dma_mask(PCI_Device, DMA_32BIT_MASK ))
                         continue;
 
                 Bus = PCI_Device->bus->number;
@@ -832,7 +833,7 @@ static int __init BusLogic_InitializeMultiMasterProbeInfo(struct BusLogic_HostAd
                 if (pci_enable_device(PCI_Device))
                         continue;
 
-                if (pci_set_dma_mask(PCI_Device, (u64) 0xffffffff))
+                if (pci_set_dma_mask(PCI_Device, DMA_32BIT_MASK))
                         continue;
 
                 Bus = PCI_Device->bus->number;
@@ -886,7 +887,7 @@ static int __init BusLogic_InitializeFlashPointProbeInfo(struct BusLogic_HostAda
                 if (pci_enable_device(PCI_Device))
                         continue;
 
-                if (pci_set_dma_mask(PCI_Device, (u64) 0xffffffff))
+                if (pci_set_dma_mask(PCI_Device, DMA_32BIT_MASK))
                         continue;
 
                 Bus = PCI_Device->bus->number;
diff --git a/drivers/scsi/a100u2w.c b/drivers/scsi/a100u2w.c
index 9f45ae1745da..3dce21c78737 100644
--- a/drivers/scsi/a100u2w.c
+++ b/drivers/scsi/a100u2w.c
@@ -89,6 +89,7 @@
 #include <linux/string.h>
 #include <linux/ioport.h>
 #include <linux/slab.h>
+#include <linux/dma-mapping.h>
 
 #include <asm/io.h>
 #include <asm/irq.h>
@@ -1052,7 +1053,7 @@ static int __devinit inia100_probe_one(struct pci_dev *pdev,
 
         if (pci_enable_device(pdev))
                 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 "
                                     "on inia100 adapter, ignoring.\n");
                 goto out_disable_device;
diff --git a/drivers/scsi/aacraid/aachba.c b/drivers/scsi/aacraid/aachba.c
index a16f8ded8f1d..8df4a0ea3761 100644
--- a/drivers/scsi/aacraid/aachba.c
+++ b/drivers/scsi/aacraid/aachba.c
@@ -32,6 +32,7 @@
 #include <linux/slab.h>
 #include <linux/completion.h>
 #include <linux/blkdev.h>
+#include <linux/dma-mapping.h>
 #include <asm/semaphore.h>
 #include <asm/uaccess.h>
 
diff --git a/drivers/scsi/aacraid/linit.c b/drivers/scsi/aacraid/linit.c
index c2596335549d..720330778648 100644
--- a/drivers/scsi/aacraid/linit.c
+++ b/drivers/scsi/aacraid/linit.c
@@ -45,6 +45,7 @@
 #include <linux/pci.h>
 #include <linux/slab.h>
 #include <linux/spinlock.h>
+#include <linux/dma-mapping.h>
 #include <linux/syscalls.h>
 #include <linux/delay.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
          */
         if (aac_drivers[index].quirks & AAC_QUIRK_31BIT) 
-                if (pci_set_dma_mask(pdev, 0x7FFFFFFFULL) ||
-                                pci_set_consistent_dma_mask(pdev, 0x7FFFFFFFULL))
+                if (pci_set_dma_mask(pdev, DMA_31BIT_MASK) ||
+                                pci_set_consistent_dma_mask(pdev, DMA_31BIT_MASK))
                         goto out;
         
         pci_set_master(pdev);
diff --git a/drivers/scsi/atp870u.c b/drivers/scsi/atp870u.c
index 5227a779c05c..a198d86667e9 100644
--- a/drivers/scsi/atp870u.c
+++ b/drivers/scsi/atp870u.c
@@ -28,6 +28,7 @@
 #include <linux/spinlock.h>
 #include <linux/pci.h>
 #include <linux/blkdev.h>
+#include <linux/dma-mapping.h>
 #include <asm/system.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))
                 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");
         } else {
                 printk(KERN_ERR "atp870u: DMA mask required but not available.\n");
diff --git a/drivers/scsi/dpt_i2o.c b/drivers/scsi/dpt_i2o.c
index 6e6b293dcb28..b1b704a42efd 100644
--- a/drivers/scsi/dpt_i2o.c
+++ b/drivers/scsi/dpt_i2o.c
@@ -57,6 +57,7 @@ MODULE_DESCRIPTION("Adaptec I2O RAID Driver");
 #include <linux/reboot.h>
 #include <linux/spinlock.h>
 #include <linux/smp_lock.h>
+#include <linux/dma-mapping.h>
 
 #include <linux/timer.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);
-        if (pci_set_dma_mask(pDev, 0xffffffffffffffffULL) &&
-            pci_set_dma_mask(pDev, 0xffffffffULL))
+        if (pci_set_dma_mask(pDev, DMA_64BIT_MASK) &&
+            pci_set_dma_mask(pDev, DMA_32BIT_MASK))
                 return -EINVAL;
 
         base_addr0_phys = pci_resource_start(pDev,0);
diff --git a/drivers/scsi/eata.c b/drivers/scsi/eata.c
index b3f9de8f7595..059eeee4b554 100644
--- a/drivers/scsi/eata.c
+++ b/drivers/scsi/eata.c
@@ -490,6 +490,7 @@
 #include <linux/init.h>
 #include <linux/ctype.h>
 #include <linux/spinlock.h>
+#include <linux/dma-mapping.h>
 #include <asm/byteorder.h>
 #include <asm/dma.h>
 #include <asm/io.h>
@@ -1426,7 +1427,7 @@ static int port_detect(unsigned long port_base, unsigned int j,
 
         if (ha->pdev) {
                 pci_set_master(ha->pdev);
-                if (pci_set_dma_mask(ha->pdev, 0xffffffff))
+                if (pci_set_dma_mask(ha->pdev, DMA_32BIT_MASK))
                         printk("%s: warning, pci_set_dma_mask failed.\n",
                                ha->board_name);
         }
diff --git a/drivers/scsi/gdth.c b/drivers/scsi/gdth.c
index 7f7013e80a88..d5740bbdef3e 100644
--- a/drivers/scsi/gdth.c
+++ b/drivers/scsi/gdth.c
@@ -388,6 +388,7 @@
 #include <linux/proc_fs.h>
 #include <linux/time.h>
 #include <linux/timer.h>
+#include <linux/dma-mapping.h>
 #ifdef GDTH_RTC
 #include <linux/mc146818rtc.h>
 #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)||
                 /* 64-bit DMA only supported from FW >= x.43 */
                 (!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);
                     err = TRUE;
                 }
             } else {
                 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);
-                } 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);
                     err = TRUE;
                 }
diff --git a/drivers/scsi/initio.c b/drivers/scsi/initio.c
index ea6f3c0e05d9..0cc7f65b584f 100644
--- a/drivers/scsi/initio.c
+++ b/drivers/scsi/initio.c
@@ -127,6 +127,7 @@
 #include <linux/sched.h>
 #include <linux/slab.h>
 #include <linux/jiffies.h>
+#include <linux/dma-mapping.h>
 #include <asm/io.h>
 
 #include <scsi/scsi.h>
@@ -2780,7 +2781,7 @@ static int tul_NewReturnNumberOfAdapters(void)
                         if (((dRegValue & 0xFF00) >> 8) == 0xFF)
                                 dRegValue = 0;
                         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 
                                        "i91u: Could not set 32 bit DMA mask\n");
                                 continue;
diff --git a/drivers/scsi/ips.c b/drivers/scsi/ips.c
index 481708d527ae..a4c0b04cfdbd 100644
--- a/drivers/scsi/ips.c
+++ b/drivers/scsi/ips.c
@@ -179,6 +179,7 @@
 
 #include <linux/blkdev.h>
 #include <linux/types.h>
+#include <linux/dma-mapping.h>
 
 #include <scsi/sg.h>
 
@@ -7284,10 +7285,10 @@ ips_init_phase1(struct pci_dev *pci_dev, int *indexPtr)
          * are guaranteed to be < 4G.
          */
         if (IPS_ENABLE_DMA64 && IPS_HAS_ENH_SGLIST(ha) &&
-            !pci_set_dma_mask(ha->pcidev, 0xffffffffffffffffULL)) {
+            !pci_set_dma_mask(ha->pcidev, DMA_64BIT_MASK)) {
                 (ha)->flags |= IPS_HA_ENH_SG;
         } 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");
                         return ips_abort_init(ha, index);
                 }
diff --git a/drivers/scsi/megaraid.c b/drivers/scsi/megaraid.c
index 7144674bc8e6..80b68a2481b3 100644
--- a/drivers/scsi/megaraid.c
+++ b/drivers/scsi/megaraid.c
@@ -45,6 +45,7 @@
 #include <linux/interrupt.h>
 #include <linux/pci.h>
 #include <linux/init.h>
+#include <linux/dma-mapping.h>
 #include <scsi/scsicam.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));
 
-        if( pci_set_dma_mask(*pdev, 0xffffffff) != 0 ) {
+        if( pci_set_dma_mask(*pdev, DMA_32BIT_MASK) != 0 ) {
                 kfree(*pdev);
                 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 */
         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;
         } else  {
-                pci_set_dma_mask(pdev, 0xffffffff);
+                pci_set_dma_mask(pdev, DMA_32BIT_MASK);
                 adapter->has_64bit_addr = 0;
         }
                 
diff --git a/drivers/scsi/nsp32.c b/drivers/scsi/nsp32.c
index a279ebb61447..30ee0ef4b459 100644
--- a/drivers/scsi/nsp32.c
+++ b/drivers/scsi/nsp32.c
@@ -38,6 +38,7 @@
 #include <linux/pci.h>
 #include <linux/delay.h>
 #include <linux/ctype.h>
+#include <linux/dma-mapping.h>
 
 #include <asm/dma.h>
 #include <asm/system.h>
@@ -2776,7 +2777,7 @@ static int nsp32_detect(struct scsi_host_template *sht)
         /*
          * 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");
                 goto scsi_unregister;
         }
diff --git a/drivers/scsi/qla1280.c b/drivers/scsi/qla1280.c
index e0230249fa0f..5a48e55f9418 100644
--- a/drivers/scsi/qla1280.c
+++ b/drivers/scsi/qla1280.c
@@ -350,6 +350,7 @@
 #include <linux/pci_ids.h>
 #include <linux/interrupt.h>
 #include <linux/init.h>
+#include <linux/dma-mapping.h>
 
 #include <asm/io.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
         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 "
                                "suitable DMA mask - aborting\n", ha->host_no);
                         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",
                         ha->host_no);
 #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 "
                        "suitable DMA mask - aborting\n", ha->host_no);
                 error = -ENODEV;
diff --git a/drivers/scsi/qlogicfc.c b/drivers/scsi/qlogicfc.c
index 5b15998c71a6..52b224a5d6fd 100644
--- a/drivers/scsi/qlogicfc.c
+++ b/drivers/scsi/qlogicfc.c
@@ -61,6 +61,7 @@
 #include <linux/unistd.h>
 #include <linux/spinlock.h>
 #include <linux/interrupt.h>
+#include <linux/dma-mapping.h>
 #include <linux/jiffies.h>
 #include <asm/io.h>
 #include <asm/irq.h>
@@ -738,8 +739,8 @@ static int isp2x00_detect(struct scsi_host_template * tmpt)
                                 continue;
 
                         /* Try to configure DMA attributes. */
-                        if (pci_set_dma_mask(pdev, 0xffffffffffffffffULL) &&
-                            pci_set_dma_mask(pdev, 0xffffffffULL))
+                        if (pci_set_dma_mask(pdev, DMA_64BIT_MASK) &&
+                            pci_set_dma_mask(pdev, DMA_32BIT_MASK))
                                         continue;
 
                         host = scsi_register(tmpt, sizeof(struct isp2x00_hostdata));