dma, mm/pat: Rename dma_*_writecombine() to dma_*_wc()

Rename dma_*_writecombine() to dma_*_wc(), so that the naming
is coherent across the various write-combining APIs. Keep the
old names for compatibility for a while, these can be removed
at a later time. A guard is left to enable backporting of the
rename, and later remove of the old mapping defines seemlessly.

Build tested successfully with allmodconfig.

The following Coccinelle SmPL patch was used for this simple
transformation:

@ rename_dma_alloc_writecombine @
expression dev, size, dma_addr, gfp;
@@

-dma_alloc_writecombine(dev, size, dma_addr, gfp)
+dma_alloc_wc(dev, size, dma_addr, gfp)

@ rename_dma_free_writecombine @
expression dev, size, cpu_addr, dma_addr;
@@

-dma_free_writecombine(dev, size, cpu_addr, dma_addr)
+dma_free_wc(dev, size, cpu_addr, dma_addr)

@ rename_dma_mmap_writecombine @
expression dev, vma, cpu_addr, dma_addr, size;
@@

-dma_mmap_writecombine(dev, vma, cpu_addr, dma_addr, size)
+dma_mmap_wc(dev, vma, cpu_addr, dma_addr, size)

We also keep the old names as compatibility helpers, and
guard against their definition to make backporting easier.

Generated-by: Coccinelle SmPL
Suggested-by: Ingo Molnar <mingo@kernel.org>
Signed-off-by: Luis R. Rodriguez <mcgrof@suse.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: airlied@linux.ie
Cc: akpm@linux-foundation.org
Cc: benh@kernel.crashing.org
Cc: bhelgaas@google.com
Cc: bp@suse.de
Cc: dan.j.williams@intel.com
Cc: daniel.vetter@ffwll.ch
Cc: dhowells@redhat.com
Cc: julia.lawall@lip6.fr
Cc: konrad.wilk@oracle.com
Cc: linux-fbdev@vger.kernel.org
Cc: linux-pci@vger.kernel.org
Cc: luto@amacapital.net
Cc: mst@redhat.com
Cc: tomi.valkeinen@ti.com
Cc: toshi.kani@hp.com
Cc: vinod.koul@intel.com
Cc: xen-devel@lists.xensource.com
Link: http://lkml.kernel.org/r/1453516462-4844-1-git-send-email-mcgrof@do-not-panic.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>

15 files changed, 61 insertions, 66 deletions

diff --git a/drivers/video/fbdev/acornfb.c b/drivers/video/fbdev/acornfb.c
index a305caea58ee..fb75b7e5a19a 100644
--- a/drivers/video/fbdev/acornfb.c
+++ b/drivers/video/fbdev/acornfb.c
@@ -1040,8 +1040,8 @@ static int acornfb_probe(struct platform_device *dev)
                  * for the framebuffer if we are not using
                  * VRAM.
                  */
-                base = dma_alloc_writecombine(current_par.dev, size, &handle,
-                                              GFP_KERNEL);
+                base = dma_alloc_wc(current_par.dev, size, &handle,
+                                    GFP_KERNEL);
                 if (base == NULL) {
                         printk(KERN_ERR "acornfb: unable to allocate screen "
                                "memory\n");
diff --git a/drivers/video/fbdev/amba-clcd-versatile.c b/drivers/video/fbdev/amba-clcd-versatile.c
index 7a8afcd4573e..a8a22daa3f9d 100644
--- a/drivers/video/fbdev/amba-clcd-versatile.c
+++ b/drivers/video/fbdev/amba-clcd-versatile.c
@@ -154,8 +154,8 @@ int versatile_clcd_setup_dma(struct clcd_fb *fb, unsigned long framesize)
 {
         dma_addr_t dma;
 
-        fb->fb.screen_base = dma_alloc_writecombine(&fb->dev->dev, framesize,
-                                                    &dma, GFP_KERNEL);
+        fb->fb.screen_base = dma_alloc_wc(&fb->dev->dev, framesize, &dma,
+                                          GFP_KERNEL);
         if (!fb->fb.screen_base) {
                 pr_err("CLCD: unable to map framebuffer\n");
                 return -ENOMEM;
@@ -169,14 +169,12 @@ int versatile_clcd_setup_dma(struct clcd_fb *fb, unsigned long framesize)
 
 int versatile_clcd_mmap_dma(struct clcd_fb *fb, struct vm_area_struct *vma)
 {
-        return dma_mmap_writecombine(&fb->dev->dev, vma,
-                                     fb->fb.screen_base,
-                                     fb->fb.fix.smem_start,
-                                     fb->fb.fix.smem_len);
+        return dma_mmap_wc(&fb->dev->dev, vma, fb->fb.screen_base,
+                           fb->fb.fix.smem_start, fb->fb.fix.smem_len);
 }
 
 void versatile_clcd_remove_dma(struct clcd_fb *fb)
 {
-        dma_free_writecombine(&fb->dev->dev, fb->fb.fix.smem_len,
-                              fb->fb.screen_base, fb->fb.fix.smem_start);
+        dma_free_wc(&fb->dev->dev, fb->fb.fix.smem_len, fb->fb.screen_base,
+                    fb->fb.fix.smem_start);
 }
diff --git a/drivers/video/fbdev/amba-clcd.c b/drivers/video/fbdev/amba-clcd.c
index 9362424c2340..fe274b5851c7 100644
--- a/drivers/video/fbdev/amba-clcd.c
+++ b/drivers/video/fbdev/amba-clcd.c
@@ -774,8 +774,8 @@ static int clcdfb_of_dma_setup(struct clcd_fb *fb)
 
 static int clcdfb_of_dma_mmap(struct clcd_fb *fb, struct vm_area_struct *vma)
 {
-        return dma_mmap_writecombine(&fb->dev->dev, vma, fb->fb.screen_base,
-                        fb->fb.fix.smem_start, fb->fb.fix.smem_len);
+        return dma_mmap_wc(&fb->dev->dev, vma, fb->fb.screen_base,
+                           fb->fb.fix.smem_start, fb->fb.fix.smem_len);
 }
 
 static void clcdfb_of_dma_remove(struct clcd_fb *fb)
diff --git a/drivers/video/fbdev/atmel_lcdfb.c b/drivers/video/fbdev/atmel_lcdfb.c
index 19eb42b57d87..56c60e67316a 100644
--- a/drivers/video/fbdev/atmel_lcdfb.c
+++ b/drivers/video/fbdev/atmel_lcdfb.c
@@ -414,8 +414,8 @@ static inline void atmel_lcdfb_free_video_memory(struct atmel_lcdfb_info *sinfo)
 {
         struct fb_info *info = sinfo->info;
 
-        dma_free_writecombine(info->device, info->fix.smem_len,
-                                info->screen_base, info->fix.smem_start);
+        dma_free_wc(info->device, info->fix.smem_len, info->screen_base,
+                    info->fix.smem_start);
 }
 
 /**
@@ -435,8 +435,9 @@ static int atmel_lcdfb_alloc_video_memory(struct atmel_lcdfb_info *sinfo)
                     * ((var->bits_per_pixel + 7) / 8));
         info->fix.smem_len = max(smem_len, sinfo->smem_len);
 
-        info->screen_base = dma_alloc_writecombine(info->device, info->fix.smem_len,
-                                        (dma_addr_t *)&info->fix.smem_start, GFP_KERNEL);
+        info->screen_base = dma_alloc_wc(info->device, info->fix.smem_len,
+                                         (dma_addr_t *)&info->fix.smem_start,
+                                         GFP_KERNEL);
 
         if (!info->screen_base) {
                 return -ENOMEM;
diff --git a/drivers/video/fbdev/ep93xx-fb.c b/drivers/video/fbdev/ep93xx-fb.c
index 5b1081030cbb..75f0db25d19f 100644
--- a/drivers/video/fbdev/ep93xx-fb.c
+++ b/drivers/video/fbdev/ep93xx-fb.c
@@ -316,9 +316,8 @@ static int ep93xxfb_mmap(struct fb_info *info, struct vm_area_struct *vma)
         unsigned int offset = vma->vm_pgoff << PAGE_SHIFT;
 
         if (offset < info->fix.smem_len) {
-                return dma_mmap_writecombine(info->dev, vma, info->screen_base,
-                                             info->fix.smem_start,
-                                             info->fix.smem_len);
+                return dma_mmap_wc(info->dev, vma, info->screen_base,
+                                   info->fix.smem_start, info->fix.smem_len);
         }
 
         return -EINVAL;
@@ -428,8 +427,7 @@ static int ep93xxfb_alloc_videomem(struct fb_info *info)
         /* Maximum 16bpp -> used memory is maximum x*y*2 bytes */
         fb_size = EP93XXFB_MAX_XRES * EP93XXFB_MAX_YRES * 2;
 
-        virt_addr = dma_alloc_writecombine(info->dev, fb_size,
-                                           &phys_addr, GFP_KERNEL);
+        virt_addr = dma_alloc_wc(info->dev, fb_size, &phys_addr, GFP_KERNEL);
         if (!virt_addr)
                 return -ENOMEM;
 
diff --git a/drivers/video/fbdev/gbefb.c b/drivers/video/fbdev/gbefb.c
index b63d55f481fa..1a242b1338e9 100644
--- a/drivers/video/fbdev/gbefb.c
+++ b/drivers/video/fbdev/gbefb.c
@@ -1185,8 +1185,8 @@ static int gbefb_probe(struct platform_device *p_dev)
         } else {
                 /* try to allocate memory with the classical allocator
                  * this has high chance to fail on low memory machines */
-                gbe_mem = dma_alloc_writecombine(NULL, gbe_mem_size,
-                                                 &gbe_dma_addr, GFP_KERNEL);
+                gbe_mem = dma_alloc_wc(NULL, gbe_mem_size, &gbe_dma_addr,
+                                       GFP_KERNEL);
                 if (!gbe_mem) {
                         printk(KERN_ERR "gbefb: couldn't allocate framebuffer memory\n");
                         ret = -ENOMEM;
@@ -1238,7 +1238,7 @@ static int gbefb_probe(struct platform_device *p_dev)
 out_gbe_unmap:
         arch_phys_wc_del(par->wc_cookie);
         if (gbe_dma_addr)
-                dma_free_writecombine(NULL, gbe_mem_size, gbe_mem, gbe_mem_phys);
+                dma_free_wc(NULL, gbe_mem_size, gbe_mem, gbe_mem_phys);
 out_tiles_free:
         dma_free_coherent(NULL, GBE_TLB_SIZE * sizeof(uint16_t),
                           (void *)gbe_tiles.cpu, gbe_tiles.dma);
@@ -1259,7 +1259,7 @@ static int gbefb_remove(struct platform_device* p_dev)
         gbe_turn_off();
         arch_phys_wc_del(par->wc_cookie);
         if (gbe_dma_addr)
-                dma_free_writecombine(NULL, gbe_mem_size, gbe_mem, gbe_mem_phys);
+                dma_free_wc(NULL, gbe_mem_size, gbe_mem, gbe_mem_phys);
         dma_free_coherent(NULL, GBE_TLB_SIZE * sizeof(uint16_t),
                           (void *)gbe_tiles.cpu, gbe_tiles.dma);
         release_mem_region(GBE_BASE, sizeof(struct sgi_gbe));
diff --git a/drivers/video/fbdev/imxfb.c b/drivers/video/fbdev/imxfb.c
index bb2f1e866020..76b6a7784b06 100644
--- a/drivers/video/fbdev/imxfb.c
+++ b/drivers/video/fbdev/imxfb.c
@@ -937,8 +937,8 @@ static int imxfb_probe(struct platform_device *pdev)
         }
 
         fbi->map_size = PAGE_ALIGN(info->fix.smem_len);
-        info->screen_base = dma_alloc_writecombine(&pdev->dev, fbi->map_size,
-                                                   &fbi->map_dma, GFP_KERNEL);
+        info->screen_base = dma_alloc_wc(&pdev->dev, fbi->map_size,
+                                         &fbi->map_dma, GFP_KERNEL);
 
         if (!info->screen_base) {
                 dev_err(&pdev->dev, "Failed to allocate video RAM: %d\n", ret);
@@ -1005,8 +1005,8 @@ failed_cmap:
         if (pdata && pdata->exit)
                 pdata->exit(fbi->pdev);
 failed_platform_init:
-        dma_free_writecombine(&pdev->dev, fbi->map_size, info->screen_base,
-                              fbi->map_dma);
+        dma_free_wc(&pdev->dev, fbi->map_size, info->screen_base,
+                    fbi->map_dma);
 failed_map:
         iounmap(fbi->regs);
 failed_ioremap:
@@ -1041,8 +1041,8 @@ static int imxfb_remove(struct platform_device *pdev)
         kfree(info->pseudo_palette);
         framebuffer_release(info);
 
-        dma_free_writecombine(&pdev->dev, fbi->map_size, info->screen_base,
-                              fbi->map_dma);
+        dma_free_wc(&pdev->dev, fbi->map_size, info->screen_base,
+                    fbi->map_dma);
 
         iounmap(fbi->regs);
         release_mem_region(res->start, resource_size(res));
diff --git a/drivers/video/fbdev/mx3fb.c b/drivers/video/fbdev/mx3fb.c
index 7947634ee6b0..f91b1db262b0 100644
--- a/drivers/video/fbdev/mx3fb.c
+++ b/drivers/video/fbdev/mx3fb.c
@@ -1336,9 +1336,8 @@ static int mx3fb_map_video_memory(struct fb_info *fbi, unsigned int mem_len,
         int retval = 0;
         dma_addr_t addr;
 
-        fbi->screen_base = dma_alloc_writecombine(fbi->device,
-                                                  mem_len,
-                                                  &addr, GFP_DMA | GFP_KERNEL);
+        fbi->screen_base = dma_alloc_wc(fbi->device, mem_len, &addr,
+                                        GFP_DMA | GFP_KERNEL);
 
         if (!fbi->screen_base) {
                 dev_err(fbi->device, "Cannot allocate %u bytes framebuffer memory\n",
@@ -1378,8 +1377,8 @@ err0:
  */
 static int mx3fb_unmap_video_memory(struct fb_info *fbi)
 {
-        dma_free_writecombine(fbi->device, fbi->fix.smem_len,
-                              fbi->screen_base, fbi->fix.smem_start);
+        dma_free_wc(fbi->device, fbi->fix.smem_len, fbi->screen_base,
+                    fbi->fix.smem_start);
 
         fbi->screen_base = NULL;
         mutex_lock(&fbi->mm_lock);
diff --git a/drivers/video/fbdev/nuc900fb.c b/drivers/video/fbdev/nuc900fb.c
index 389fa2cbb713..6680edae4696 100644
--- a/drivers/video/fbdev/nuc900fb.c
+++ b/drivers/video/fbdev/nuc900fb.c
@@ -396,8 +396,8 @@ static int nuc900fb_map_video_memory(struct fb_info *info)
         dev_dbg(fbi->dev, "nuc900fb_map_video_memory(fbi=%p) map_size %lu\n",
                 fbi, map_size);
 
-        info->screen_base = dma_alloc_writecombine(fbi->dev, map_size,
-                                                        &map_dma, GFP_KERNEL);
+        info->screen_base = dma_alloc_wc(fbi->dev, map_size, &map_dma,
+                                         GFP_KERNEL);
 
         if (!info->screen_base)
                 return -ENOMEM;
@@ -411,8 +411,8 @@ static int nuc900fb_map_video_memory(struct fb_info *info)
 static inline void nuc900fb_unmap_video_memory(struct fb_info *info)
 {
         struct nuc900fb_info *fbi = info->par;
-        dma_free_writecombine(fbi->dev, PAGE_ALIGN(info->fix.smem_len),
-                              info->screen_base, info->fix.smem_start);
+        dma_free_wc(fbi->dev, PAGE_ALIGN(info->fix.smem_len),
+                    info->screen_base, info->fix.smem_start);
 }
 
 static irqreturn_t nuc900fb_irqhandler(int irq, void *dev_id)
diff --git a/drivers/video/fbdev/omap/lcdc.c b/drivers/video/fbdev/omap/lcdc.c
index 6efa2591eaa8..e3d9b9ea5498 100644
--- a/drivers/video/fbdev/omap/lcdc.c
+++ b/drivers/video/fbdev/omap/lcdc.c
@@ -612,8 +612,8 @@ static void lcdc_dma_handler(u16 status, void *data)
 
 static int alloc_palette_ram(void)
 {
-        lcdc.palette_virt = dma_alloc_writecombine(lcdc.fbdev->dev,
-                MAX_PALETTE_SIZE, &lcdc.palette_phys, GFP_KERNEL);
+        lcdc.palette_virt = dma_alloc_wc(lcdc.fbdev->dev, MAX_PALETTE_SIZE,
+                                         &lcdc.palette_phys, GFP_KERNEL);
         if (lcdc.palette_virt == NULL) {
                 dev_err(lcdc.fbdev->dev, "failed to alloc palette memory\n");
                 return -ENOMEM;
@@ -625,8 +625,8 @@ static int alloc_palette_ram(void)
 
 static void free_palette_ram(void)
 {
-        dma_free_writecombine(lcdc.fbdev->dev, MAX_PALETTE_SIZE,
-                        lcdc.palette_virt, lcdc.palette_phys);
+        dma_free_wc(lcdc.fbdev->dev, MAX_PALETTE_SIZE, lcdc.palette_virt,
+                    lcdc.palette_phys);
 }
 
 static int alloc_fbmem(struct omapfb_mem_region *region)
@@ -642,8 +642,8 @@ static int alloc_fbmem(struct omapfb_mem_region *region)
         if (region->size > frame_size)
                 frame_size = region->size;
         lcdc.vram_size = frame_size;
-        lcdc.vram_virt = dma_alloc_writecombine(lcdc.fbdev->dev,
-                        lcdc.vram_size, &lcdc.vram_phys, GFP_KERNEL);
+        lcdc.vram_virt = dma_alloc_wc(lcdc.fbdev->dev, lcdc.vram_size,
+                                      &lcdc.vram_phys, GFP_KERNEL);
         if (lcdc.vram_virt == NULL) {
                 dev_err(lcdc.fbdev->dev, "unable to allocate FB DMA memory\n");
                 return -ENOMEM;
@@ -660,8 +660,8 @@ static int alloc_fbmem(struct omapfb_mem_region *region)
 
 static void free_fbmem(void)
 {
-        dma_free_writecombine(lcdc.fbdev->dev, lcdc.vram_size,
-                              lcdc.vram_virt, lcdc.vram_phys);
+        dma_free_wc(lcdc.fbdev->dev, lcdc.vram_size, lcdc.vram_virt,
+                    lcdc.vram_phys);
 }
 
 static int setup_fbmem(struct omapfb_mem_desc *req_md)
diff --git a/drivers/video/fbdev/pxa168fb.c b/drivers/video/fbdev/pxa168fb.c
index efb57c059997..def3a501acd6 100644
--- a/drivers/video/fbdev/pxa168fb.c
+++ b/drivers/video/fbdev/pxa168fb.c
@@ -680,8 +680,8 @@ static int pxa168fb_probe(struct platform_device *pdev)
          */
         info->fix.smem_len = PAGE_ALIGN(DEFAULT_FB_SIZE);
 
-        info->screen_base = dma_alloc_writecombine(fbi->dev, info->fix.smem_len,
-                                                &fbi->fb_start_dma, GFP_KERNEL);
+        info->screen_base = dma_alloc_wc(fbi->dev, info->fix.smem_len,
+                                         &fbi->fb_start_dma, GFP_KERNEL);
         if (info->screen_base == NULL) {
                 ret = -ENOMEM;
                 goto failed_free_info;
@@ -804,8 +804,8 @@ static int pxa168fb_remove(struct platform_device *pdev)
 
         irq = platform_get_irq(pdev, 0);
 
-        dma_free_writecombine(fbi->dev, PAGE_ALIGN(info->fix.smem_len),
-                                info->screen_base, info->fix.smem_start);
+        dma_free_wc(fbi->dev, PAGE_ALIGN(info->fix.smem_len),
+                    info->screen_base, info->fix.smem_start);
 
         clk_disable(fbi->clk);
 
diff --git a/drivers/video/fbdev/pxafb.c b/drivers/video/fbdev/pxafb.c
index 33b2bb315a2a..2c0487f4f805 100644
--- a/drivers/video/fbdev/pxafb.c
+++ b/drivers/video/fbdev/pxafb.c
@@ -2446,8 +2446,8 @@ static int pxafb_remove(struct platform_device *dev)
 
         free_pages_exact(fbi->video_mem, fbi->video_mem_size);
 
-        dma_free_writecombine(&dev->dev, fbi->dma_buff_size,
-                        fbi->dma_buff, fbi->dma_buff_phys);
+        dma_free_wc(&dev->dev, fbi->dma_buff_size, fbi->dma_buff,
+                    fbi->dma_buff_phys);
 
         iounmap(fbi->mmio_base);
 
diff --git a/drivers/video/fbdev/s3c-fb.c b/drivers/video/fbdev/s3c-fb.c
index f72dd12456f9..5f4f696c2ecf 100644
--- a/drivers/video/fbdev/s3c-fb.c
+++ b/drivers/video/fbdev/s3c-fb.c
@@ -1105,8 +1105,7 @@ static int s3c_fb_alloc_memory(struct s3c_fb *sfb, struct s3c_fb_win *win)
 
         dev_dbg(sfb->dev, "want %u bytes for window\n", size);
 
-        fbi->screen_base = dma_alloc_writecombine(sfb->dev, size,
-                                                  &map_dma, GFP_KERNEL);
+        fbi->screen_base = dma_alloc_wc(sfb->dev, size, &map_dma, GFP_KERNEL);
         if (!fbi->screen_base)
                 return -ENOMEM;
 
@@ -1131,8 +1130,8 @@ static void s3c_fb_free_memory(struct s3c_fb *sfb, struct s3c_fb_win *win)
         struct fb_info *fbi = win->fbinfo;
 
         if (fbi->screen_base)
-                dma_free_writecombine(sfb->dev, PAGE_ALIGN(fbi->fix.smem_len),
-                              fbi->screen_base, fbi->fix.smem_start);
+                dma_free_wc(sfb->dev, PAGE_ALIGN(fbi->fix.smem_len),
+                            fbi->screen_base, fbi->fix.smem_start);
 }
 
 /**
diff --git a/drivers/video/fbdev/s3c2410fb.c b/drivers/video/fbdev/s3c2410fb.c
index d6704add1601..0dd86be36afb 100644
--- a/drivers/video/fbdev/s3c2410fb.c
+++ b/drivers/video/fbdev/s3c2410fb.c
@@ -645,8 +645,8 @@ static int s3c2410fb_map_video_memory(struct fb_info *info)
 
         dprintk("map_video_memory(fbi=%p) map_size %u\n", fbi, map_size);
 
-        info->screen_base = dma_alloc_writecombine(fbi->dev, map_size,
-                                                   &map_dma, GFP_KERNEL);
+        info->screen_base = dma_alloc_wc(fbi->dev, map_size, &map_dma,
+                                         GFP_KERNEL);
 
         if (info->screen_base) {
                 /* prevent initial garbage on screen */
@@ -667,8 +667,8 @@ static inline void s3c2410fb_unmap_video_memory(struct fb_info *info)
 {
         struct s3c2410fb_info *fbi = info->par;
 
-        dma_free_writecombine(fbi->dev, PAGE_ALIGN(info->fix.smem_len),
-                              info->screen_base, info->fix.smem_start);
+        dma_free_wc(fbi->dev, PAGE_ALIGN(info->fix.smem_len),
+                    info->screen_base, info->fix.smem_start);
 }
 
 static inline void modify_gpio(void __iomem *reg,
diff --git a/drivers/video/fbdev/sa1100fb.c b/drivers/video/fbdev/sa1100fb.c
index dcf774c15889..fc2aaa5aca23 100644
--- a/drivers/video/fbdev/sa1100fb.c
+++ b/drivers/video/fbdev/sa1100fb.c
@@ -567,8 +567,8 @@ static int sa1100fb_mmap(struct fb_info *info,
 
         if (off < info->fix.smem_len) {
                 vma->vm_pgoff += 1; /* skip over the palette */
-                return dma_mmap_writecombine(fbi->dev, vma, fbi->map_cpu,
-                                             fbi->map_dma, fbi->map_size);
+                return dma_mmap_wc(fbi->dev, vma, fbi->map_cpu, fbi->map_dma,
+                                   fbi->map_size);
         }
 
         vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
@@ -1099,8 +1099,8 @@ static int sa1100fb_map_video_memory(struct sa1100fb_info *fbi)
          * of the framebuffer.
          */
         fbi->map_size = PAGE_ALIGN(fbi->fb.fix.smem_len + PAGE_SIZE);
-        fbi->map_cpu = dma_alloc_writecombine(fbi->dev, fbi->map_size,
-                                              &fbi->map_dma, GFP_KERNEL);
+        fbi->map_cpu = dma_alloc_wc(fbi->dev, fbi->map_size, &fbi->map_dma,
+                                    GFP_KERNEL);
 
         if (fbi->map_cpu) {
                 fbi->fb.screen_base = fbi->map_cpu + PAGE_SIZE;