tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

Merge branch 'mm-pat-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip

Pull dma_*_writecombine rename from Ingo Molnar:
"Rename dma_*_writecombine() to dma_*_wc()

This is a tree-wide API rename, to move the dma_*() write-combining
APIs closer in name to their usual API families. (The old API names
are kept as compatibility wrappers to not introduce extra breakage.)

The patch was Coccinelle generated"

* 'mm-pat-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip:
dma, mm/pat: Rename dma_*_writecombine() to dma_*_wc()

Linus Torvalds 5ec94246 fbed0bc0

+176 -197
+6 -7
arch/arm/mach-lpc32xx/phy3250.c
··· 86 86 { 87 87 dma_addr_t dma; 88 88 89 - fb->fb.screen_base = dma_alloc_writecombine(&fb->dev->dev, 90 - PANEL_SIZE, &dma, GFP_KERNEL); 89 + fb->fb.screen_base = dma_alloc_wc(&fb->dev->dev, PANEL_SIZE, &dma, 90 + GFP_KERNEL); 91 91 if (!fb->fb.screen_base) { 92 92 printk(KERN_ERR "CLCD: unable to map framebuffer\n"); 93 93 return -ENOMEM; ··· 116 116 117 117 static int lpc32xx_clcd_mmap(struct clcd_fb *fb, struct vm_area_struct *vma) 118 118 { 119 - return dma_mmap_writecombine(&fb->dev->dev, vma, 120 - fb->fb.screen_base, fb->fb.fix.smem_start, 121 - fb->fb.fix.smem_len); 119 + return dma_mmap_wc(&fb->dev->dev, vma, fb->fb.screen_base, 120 + fb->fb.fix.smem_start, fb->fb.fix.smem_len); 122 121 } 123 122 124 123 static void lpc32xx_clcd_remove(struct clcd_fb *fb) 125 124 { 126 - dma_free_writecombine(&fb->dev->dev, fb->fb.fix.smem_len, 127 - fb->fb.screen_base, fb->fb.fix.smem_start); 125 + dma_free_wc(&fb->dev->dev, fb->fb.fix.smem_len, fb->fb.screen_base, 126 + fb->fb.fix.smem_start); 128 127 } 129 128 130 129 /*
+6 -8
arch/arm/mach-netx/fb.c
··· 42 42 43 43 fb->panel = netx_panel; 44 44 45 - fb->fb.screen_base = dma_alloc_writecombine(&fb->dev->dev, 1024*1024, 46 - &dma, GFP_KERNEL); 45 + fb->fb.screen_base = dma_alloc_wc(&fb->dev->dev, 1024 * 1024, &dma, 46 + GFP_KERNEL); 47 47 if (!fb->fb.screen_base) { 48 48 printk(KERN_ERR "CLCD: unable to map framebuffer\n"); 49 49 return -ENOMEM; ··· 57 57 58 58 int netx_clcd_mmap(struct clcd_fb *fb, struct vm_area_struct *vma) 59 59 { 60 - return dma_mmap_writecombine(&fb->dev->dev, vma, 61 - fb->fb.screen_base, 62 - fb->fb.fix.smem_start, 63 - fb->fb.fix.smem_len); 60 + return dma_mmap_wc(&fb->dev->dev, vma, fb->fb.screen_base, 61 + fb->fb.fix.smem_start, fb->fb.fix.smem_len); 64 62 } 65 63 66 64 void netx_clcd_remove(struct clcd_fb *fb) 67 65 { 68 - dma_free_writecombine(&fb->dev->dev, fb->fb.fix.smem_len, 69 - fb->fb.screen_base, fb->fb.fix.smem_start); 66 + dma_free_wc(&fb->dev->dev, fb->fb.fix.smem_len, fb->fb.screen_base, 67 + fb->fb.fix.smem_start); 70 68 } 71 69 72 70 static AMBA_AHB_DEVICE(fb, "fb", 0, 0x00104000, { NETX_IRQ_LCD }, NULL);
+6 -7
arch/arm/mach-nspire/clcd.c
··· 90 90 panel_size = ((panel->mode.xres * panel->mode.yres) * panel->bpp) / 8; 91 91 panel_size = ALIGN(panel_size, PAGE_SIZE); 92 92 93 - fb->fb.screen_base = dma_alloc_writecombine(&fb->dev->dev, 94 - panel_size, &dma, GFP_KERNEL); 93 + fb->fb.screen_base = dma_alloc_wc(&fb->dev->dev, panel_size, &dma, 94 + GFP_KERNEL); 95 95 96 96 if (!fb->fb.screen_base) { 97 97 pr_err("CLCD: unable to map framebuffer\n"); ··· 107 107 108 108 int nspire_clcd_mmap(struct clcd_fb *fb, struct vm_area_struct *vma) 109 109 { 110 - return dma_mmap_writecombine(&fb->dev->dev, vma, 111 - fb->fb.screen_base, fb->fb.fix.smem_start, 112 - fb->fb.fix.smem_len); 110 + return dma_mmap_wc(&fb->dev->dev, vma, fb->fb.screen_base, 111 + fb->fb.fix.smem_start, fb->fb.fix.smem_len); 113 112 } 114 113 115 114 void nspire_clcd_remove(struct clcd_fb *fb) 116 115 { 117 - dma_free_writecombine(&fb->dev->dev, fb->fb.fix.smem_len, 118 - fb->fb.screen_base, fb->fb.fix.smem_start); 116 + dma_free_wc(&fb->dev->dev, fb->fb.fix.smem_len, fb->fb.screen_base, 117 + fb->fb.fix.smem_start); 119 118 }
+4 -4
drivers/dma/iop-adma.c
··· 1300 1300 * note: writecombine gives slightly better performance, but 1301 1301 * requires that we explicitly flush the writes 1302 1302 */ 1303 - adev->dma_desc_pool_virt = dma_alloc_writecombine(&pdev->dev, 1304 - plat_data->pool_size, 1305 - &adev->dma_desc_pool, 1306 - GFP_KERNEL); 1303 + adev->dma_desc_pool_virt = dma_alloc_wc(&pdev->dev, 1304 + plat_data->pool_size, 1305 + &adev->dma_desc_pool, 1306 + GFP_KERNEL); 1307 1307 if (!adev->dma_desc_pool_virt) { 1308 1308 ret = -ENOMEM; 1309 1309 goto err_free_adev;
+2 -2
drivers/dma/mv_xor.c
··· 964 964 * requires that we explicitly flush the writes 965 965 */ 966 966 mv_chan->dma_desc_pool_virt = 967 - dma_alloc_writecombine(&pdev->dev, MV_XOR_POOL_SIZE, 968 - &mv_chan->dma_desc_pool, GFP_KERNEL); 967 + dma_alloc_wc(&pdev->dev, MV_XOR_POOL_SIZE, &mv_chan->dma_desc_pool, 968 + GFP_KERNEL); 969 969 if (!mv_chan->dma_desc_pool_virt) 970 970 return ERR_PTR(-ENOMEM); 971 971
+7 -7
drivers/dma/qcom_bam_dma.c
··· 502 502 return 0; 503 503 504 504 /* allocate FIFO descriptor space, but only if necessary */ 505 - bchan->fifo_virt = dma_alloc_writecombine(bdev->dev, BAM_DESC_FIFO_SIZE, 506 - &bchan->fifo_phys, GFP_KERNEL); 505 + bchan->fifo_virt = dma_alloc_wc(bdev->dev, BAM_DESC_FIFO_SIZE, 506 + &bchan->fifo_phys, GFP_KERNEL); 507 507 508 508 if (!bchan->fifo_virt) { 509 509 dev_err(bdev->dev, "Failed to allocate desc fifo\n"); ··· 538 538 bam_reset_channel(bchan); 539 539 spin_unlock_irqrestore(&bchan->vc.lock, flags); 540 540 541 - dma_free_writecombine(bdev->dev, BAM_DESC_FIFO_SIZE, bchan->fifo_virt, 542 - bchan->fifo_phys); 541 + dma_free_wc(bdev->dev, BAM_DESC_FIFO_SIZE, bchan->fifo_virt, 542 + bchan->fifo_phys); 543 543 bchan->fifo_virt = NULL; 544 544 545 545 /* mask irq for pipe/channel */ ··· 1231 1231 bam_dma_terminate_all(&bdev->channels[i].vc.chan); 1232 1232 tasklet_kill(&bdev->channels[i].vc.task); 1233 1233 1234 - dma_free_writecombine(bdev->dev, BAM_DESC_FIFO_SIZE, 1235 - bdev->channels[i].fifo_virt, 1236 - bdev->channels[i].fifo_phys); 1234 + dma_free_wc(bdev->dev, BAM_DESC_FIFO_SIZE, 1235 + bdev->channels[i].fifo_virt, 1236 + bdev->channels[i].fifo_phys); 1237 1237 } 1238 1238 1239 1239 tasklet_kill(&bdev->task);
+6 -7
drivers/gpu/drm/drm_gem_cma_helper.c
··· 109 109 if (IS_ERR(cma_obj)) 110 110 return cma_obj; 111 111 112 - cma_obj->vaddr = dma_alloc_writecombine(drm->dev, size, 113 - &cma_obj->paddr, GFP_KERNEL | __GFP_NOWARN); 112 + cma_obj->vaddr = dma_alloc_wc(drm->dev, size, &cma_obj->paddr, 113 + GFP_KERNEL | __GFP_NOWARN); 114 114 if (!cma_obj->vaddr) { 115 115 dev_err(drm->dev, "failed to allocate buffer with size %zu\n", 116 116 size); ··· 192 192 cma_obj = to_drm_gem_cma_obj(gem_obj); 193 193 194 194 if (cma_obj->vaddr) { 195 - dma_free_writecombine(gem_obj->dev->dev, cma_obj->base.size, 196 - cma_obj->vaddr, cma_obj->paddr); 195 + dma_free_wc(gem_obj->dev->dev, cma_obj->base.size, 196 + cma_obj->vaddr, cma_obj->paddr); 197 197 } else if (gem_obj->import_attach) { 198 198 drm_prime_gem_destroy(gem_obj, cma_obj->sgt); 199 199 } ··· 324 324 vma->vm_flags &= ~VM_PFNMAP; 325 325 vma->vm_pgoff = 0; 326 326 327 - ret = dma_mmap_writecombine(cma_obj->base.dev->dev, vma, 328 - cma_obj->vaddr, cma_obj->paddr, 329 - vma->vm_end - vma->vm_start); 327 + ret = dma_mmap_wc(cma_obj->base.dev->dev, vma, cma_obj->vaddr, 328 + cma_obj->paddr, vma->vm_end - vma->vm_start); 330 329 if (ret) 331 330 drm_gem_vm_close(vma); 332 331
+4 -4
drivers/gpu/drm/etnaviv/etnaviv_gpu.c
··· 1113 1113 if (!cmdbuf) 1114 1114 return NULL; 1115 1115 1116 - cmdbuf->vaddr = dma_alloc_writecombine(gpu->dev, size, &cmdbuf->paddr, 1117 - GFP_KERNEL); 1116 + cmdbuf->vaddr = dma_alloc_wc(gpu->dev, size, &cmdbuf->paddr, 1117 + GFP_KERNEL); 1118 1118 if (!cmdbuf->vaddr) { 1119 1119 kfree(cmdbuf); 1120 1120 return NULL; ··· 1128 1128 1129 1129 void etnaviv_gpu_cmdbuf_free(struct etnaviv_cmdbuf *cmdbuf) 1130 1130 { 1131 - dma_free_writecombine(cmdbuf->gpu->dev, cmdbuf->size, 1132 - cmdbuf->vaddr, cmdbuf->paddr); 1131 + dma_free_wc(cmdbuf->gpu->dev, cmdbuf->size, cmdbuf->vaddr, 1132 + cmdbuf->paddr); 1133 1133 kfree(cmdbuf); 1134 1134 } 1135 1135
+6 -7
drivers/gpu/drm/omapdrm/omap_dmm_tiler.c
··· 573 573 574 574 kfree(omap_dmm->engines); 575 575 if (omap_dmm->refill_va) 576 - dma_free_writecombine(omap_dmm->dev, 577 - REFILL_BUFFER_SIZE * omap_dmm->num_engines, 578 - omap_dmm->refill_va, 579 - omap_dmm->refill_pa); 576 + dma_free_wc(omap_dmm->dev, 577 + REFILL_BUFFER_SIZE * omap_dmm->num_engines, 578 + omap_dmm->refill_va, omap_dmm->refill_pa); 580 579 if (omap_dmm->dummy_page) 581 580 __free_page(omap_dmm->dummy_page); 582 581 ··· 700 701 omap_dmm->dummy_pa = page_to_phys(omap_dmm->dummy_page); 701 702 702 703 /* alloc refill memory */ 703 - omap_dmm->refill_va = dma_alloc_writecombine(&dev->dev, 704 - REFILL_BUFFER_SIZE * omap_dmm->num_engines, 705 - &omap_dmm->refill_pa, GFP_KERNEL); 704 + omap_dmm->refill_va = dma_alloc_wc(&dev->dev, 705 + REFILL_BUFFER_SIZE * omap_dmm->num_engines, 706 + &omap_dmm->refill_pa, GFP_KERNEL); 706 707 if (!omap_dmm->refill_va) { 707 708 dev_err(&dev->dev, "could not allocate refill memory\n"); 708 709 goto fail;
+4 -4
drivers/gpu/drm/omapdrm/omap_gem.c
··· 1330 1330 omap_gem_detach_pages(obj); 1331 1331 1332 1332 if (!is_shmem(obj)) { 1333 - dma_free_writecombine(dev->dev, obj->size, 1334 - omap_obj->vaddr, omap_obj->paddr); 1333 + dma_free_wc(dev->dev, obj->size, omap_obj->vaddr, 1334 + omap_obj->paddr); 1335 1335 } else if (omap_obj->vaddr) { 1336 1336 vunmap(omap_obj->vaddr); 1337 1337 } ··· 1395 1395 /* attempt to allocate contiguous memory if we don't 1396 1396 * have DMM for remappign discontiguous buffers 1397 1397 */ 1398 - omap_obj->vaddr = dma_alloc_writecombine(dev->dev, size, 1399 - &omap_obj->paddr, GFP_KERNEL); 1398 + omap_obj->vaddr = dma_alloc_wc(dev->dev, size, 1399 + &omap_obj->paddr, GFP_KERNEL); 1400 1400 if (!omap_obj->vaddr) { 1401 1401 kfree(omap_obj); 1402 1402
+9 -11
drivers/gpu/drm/sti/sti_cursor.c
··· 157 157 cursor->height = src_h; 158 158 159 159 if (cursor->pixmap.base) 160 - dma_free_writecombine(cursor->dev, 161 - cursor->pixmap.size, 162 - cursor->pixmap.base, 163 - cursor->pixmap.paddr); 160 + dma_free_wc(cursor->dev, cursor->pixmap.size, 161 + cursor->pixmap.base, cursor->pixmap.paddr); 164 162 165 163 cursor->pixmap.size = cursor->width * cursor->height; 166 164 167 - cursor->pixmap.base = dma_alloc_writecombine(cursor->dev, 168 - cursor->pixmap.size, 169 - &cursor->pixmap.paddr, 170 - GFP_KERNEL | GFP_DMA); 165 + cursor->pixmap.base = dma_alloc_wc(cursor->dev, 166 + cursor->pixmap.size, 167 + &cursor->pixmap.paddr, 168 + GFP_KERNEL | GFP_DMA); 171 169 if (!cursor->pixmap.base) { 172 170 DRM_ERROR("Failed to allocate memory for pixmap\n"); 173 171 return; ··· 250 252 251 253 /* Allocate clut buffer */ 252 254 size = 0x100 * sizeof(unsigned short); 253 - cursor->clut = dma_alloc_writecombine(dev, size, &cursor->clut_paddr, 254 - GFP_KERNEL | GFP_DMA); 255 + cursor->clut = dma_alloc_wc(dev, size, &cursor->clut_paddr, 256 + GFP_KERNEL | GFP_DMA); 255 257 256 258 if (!cursor->clut) { 257 259 DRM_ERROR("Failed to allocate memory for cursor clut\n"); ··· 284 286 return &cursor->plane.drm_plane; 285 287 286 288 err_plane: 287 - dma_free_writecombine(dev, size, cursor->clut, cursor->clut_paddr); 289 + dma_free_wc(dev, size, cursor->clut, cursor->clut_paddr); 288 290 err_clut: 289 291 devm_kfree(dev, cursor); 290 292 return NULL;
+1 -2
drivers/gpu/drm/sti/sti_gdp.c
··· 312 312 /* Allocate all the nodes within a single memory page */ 313 313 size = sizeof(struct sti_gdp_node) * 314 314 GDP_NODE_PER_FIELD * GDP_NODE_NB_BANK; 315 - base = dma_alloc_writecombine(gdp->dev, 316 - size, &dma_addr, GFP_KERNEL | GFP_DMA); 315 + base = dma_alloc_wc(gdp->dev, size, &dma_addr, GFP_KERNEL | GFP_DMA); 317 316 318 317 if (!base) { 319 318 DRM_ERROR("Failed to allocate memory for GDP node\n");
+3 -3
drivers/gpu/drm/sti/sti_hqvdp.c
··· 617 617 618 618 /* Allocate memory for the VDP commands */ 619 619 size = NB_VDP_CMD * sizeof(struct sti_hqvdp_cmd); 620 - hqvdp->hqvdp_cmd = dma_alloc_writecombine(hqvdp->dev, size, 621 - &hqvdp->hqvdp_cmd_paddr, 622 - GFP_KERNEL | GFP_DMA); 620 + hqvdp->hqvdp_cmd = dma_alloc_wc(hqvdp->dev, size, 621 + &hqvdp->hqvdp_cmd_paddr, 622 + GFP_KERNEL | GFP_DMA); 623 623 if (!hqvdp->hqvdp_cmd) { 624 624 DRM_ERROR("Failed to allocate memory for VDP cmd\n"); 625 625 return;
+5 -6
drivers/gpu/drm/tegra/gem.c
··· 175 175 sg_free_table(bo->sgt); 176 176 kfree(bo->sgt); 177 177 } else if (bo->vaddr) { 178 - dma_free_writecombine(drm->dev, bo->gem.size, bo->vaddr, 179 - bo->paddr); 178 + dma_free_wc(drm->dev, bo->gem.size, bo->vaddr, bo->paddr); 180 179 } 181 180 } 182 181 ··· 232 233 } else { 233 234 size_t size = bo->gem.size; 234 235 235 - bo->vaddr = dma_alloc_writecombine(drm->dev, size, &bo->paddr, 236 - GFP_KERNEL | __GFP_NOWARN); 236 + bo->vaddr = dma_alloc_wc(drm->dev, size, &bo->paddr, 237 + GFP_KERNEL | __GFP_NOWARN); 237 238 if (!bo->vaddr) { 238 239 dev_err(drm->dev, 239 240 "failed to allocate buffer of size %zu\n", ··· 471 472 vma->vm_flags &= ~VM_PFNMAP; 472 473 vma->vm_pgoff = 0; 473 474 474 - ret = dma_mmap_writecombine(gem->dev->dev, vma, bo->vaddr, 475 - bo->paddr, gem->size); 475 + ret = dma_mmap_wc(gem->dev->dev, vma, bo->vaddr, bo->paddr, 476 + gem->size); 476 477 if (ret) { 477 478 drm_gem_vm_close(vma); 478 479 return ret;
+2 -3
drivers/gpu/drm/vc4/vc4_bo.c
··· 398 398 vma->vm_flags &= ~VM_PFNMAP; 399 399 vma->vm_pgoff = 0; 400 400 401 - ret = dma_mmap_writecombine(bo->base.base.dev->dev, vma, 402 - bo->base.vaddr, bo->base.paddr, 403 - vma->vm_end - vma->vm_start); 401 + ret = dma_mmap_wc(bo->base.base.dev->dev, vma, bo->base.vaddr, 402 + bo->base.paddr, vma->vm_end - vma->vm_start); 404 403 if (ret) 405 404 drm_gem_vm_close(vma); 406 405
+4 -4
drivers/gpu/host1x/cdma.c
··· 52 52 struct host1x *host1x = cdma_to_host1x(cdma); 53 53 54 54 if (pb->phys != 0) 55 - dma_free_writecombine(host1x->dev, pb->size_bytes + 4, 56 - pb->mapped, pb->phys); 55 + dma_free_wc(host1x->dev, pb->size_bytes + 4, pb->mapped, 56 + pb->phys); 57 57 58 58 pb->mapped = NULL; 59 59 pb->phys = 0; ··· 76 76 pb->pos = 0; 77 77 78 78 /* allocate and map pushbuffer memory */ 79 - pb->mapped = dma_alloc_writecombine(host1x->dev, pb->size_bytes + 4, 80 - &pb->phys, GFP_KERNEL); 79 + pb->mapped = dma_alloc_wc(host1x->dev, pb->size_bytes + 4, &pb->phys, 80 + GFP_KERNEL); 81 81 if (!pb->mapped) 82 82 goto fail; 83 83
+4 -6
drivers/gpu/host1x/job.c
··· 467 467 size += g->words * sizeof(u32); 468 468 } 469 469 470 - job->gather_copy_mapped = dma_alloc_writecombine(dev, size, 471 - &job->gather_copy, 472 - GFP_KERNEL); 470 + job->gather_copy_mapped = dma_alloc_wc(dev, size, &job->gather_copy, 471 + GFP_KERNEL); 473 472 if (!job->gather_copy_mapped) { 474 473 job->gather_copy_mapped = NULL; 475 474 return -ENOMEM; ··· 577 578 job->num_unpins = 0; 578 579 579 580 if (job->gather_copy_size) 580 - dma_free_writecombine(job->channel->dev, job->gather_copy_size, 581 - job->gather_copy_mapped, 582 - job->gather_copy); 581 + dma_free_wc(job->channel->dev, job->gather_copy_size, 582 + job->gather_copy_mapped, job->gather_copy); 583 583 } 584 584 EXPORT_SYMBOL(host1x_job_unpin); 585 585
+5 -5
drivers/media/platform/coda/coda-bit.c
··· 1455 1455 return 0; 1456 1456 1457 1457 ctx->bitstream.size = roundup_pow_of_two(q_data->sizeimage * 2); 1458 - ctx->bitstream.vaddr = dma_alloc_writecombine( 1459 - &ctx->dev->plat_dev->dev, ctx->bitstream.size, 1460 - &ctx->bitstream.paddr, GFP_KERNEL); 1458 + ctx->bitstream.vaddr = dma_alloc_wc(&ctx->dev->plat_dev->dev, 1459 + ctx->bitstream.size, 1460 + &ctx->bitstream.paddr, GFP_KERNEL); 1461 1461 if (!ctx->bitstream.vaddr) { 1462 1462 v4l2_err(&ctx->dev->v4l2_dev, 1463 1463 "failed to allocate bitstream ringbuffer"); ··· 1474 1474 if (ctx->bitstream.vaddr == NULL) 1475 1475 return; 1476 1476 1477 - dma_free_writecombine(&ctx->dev->plat_dev->dev, ctx->bitstream.size, 1478 - ctx->bitstream.vaddr, ctx->bitstream.paddr); 1477 + dma_free_wc(&ctx->dev->plat_dev->dev, ctx->bitstream.size, 1478 + ctx->bitstream.vaddr, ctx->bitstream.paddr); 1479 1479 ctx->bitstream.vaddr = NULL; 1480 1480 kfifo_init(&ctx->bitstream_fifo, NULL, 0); 1481 1481 }
+2 -2
drivers/video/fbdev/acornfb.c
··· 1040 1040 * for the framebuffer if we are not using 1041 1041 * VRAM. 1042 1042 */ 1043 - base = dma_alloc_writecombine(current_par.dev, size, &handle, 1044 - GFP_KERNEL); 1043 + base = dma_alloc_wc(current_par.dev, size, &handle, 1044 + GFP_KERNEL); 1045 1045 if (base == NULL) { 1046 1046 printk(KERN_ERR "acornfb: unable to allocate screen " 1047 1047 "memory\n");
+6 -8
drivers/video/fbdev/amba-clcd-versatile.c
··· 154 154 { 155 155 dma_addr_t dma; 156 156 157 - fb->fb.screen_base = dma_alloc_writecombine(&fb->dev->dev, framesize, 158 - &dma, GFP_KERNEL); 157 + fb->fb.screen_base = dma_alloc_wc(&fb->dev->dev, framesize, &dma, 158 + GFP_KERNEL); 159 159 if (!fb->fb.screen_base) { 160 160 pr_err("CLCD: unable to map framebuffer\n"); 161 161 return -ENOMEM; ··· 169 169 170 170 int versatile_clcd_mmap_dma(struct clcd_fb *fb, struct vm_area_struct *vma) 171 171 { 172 - return dma_mmap_writecombine(&fb->dev->dev, vma, 173 - fb->fb.screen_base, 174 - fb->fb.fix.smem_start, 175 - fb->fb.fix.smem_len); 172 + return dma_mmap_wc(&fb->dev->dev, vma, fb->fb.screen_base, 173 + fb->fb.fix.smem_start, fb->fb.fix.smem_len); 176 174 } 177 175 178 176 void versatile_clcd_remove_dma(struct clcd_fb *fb) 179 177 { 180 - dma_free_writecombine(&fb->dev->dev, fb->fb.fix.smem_len, 181 - fb->fb.screen_base, fb->fb.fix.smem_start); 178 + dma_free_wc(&fb->dev->dev, fb->fb.fix.smem_len, fb->fb.screen_base, 179 + fb->fb.fix.smem_start); 182 180 }
+2 -2
drivers/video/fbdev/amba-clcd.c
··· 774 774 775 775 static int clcdfb_of_dma_mmap(struct clcd_fb *fb, struct vm_area_struct *vma) 776 776 { 777 - return dma_mmap_writecombine(&fb->dev->dev, vma, fb->fb.screen_base, 778 - fb->fb.fix.smem_start, fb->fb.fix.smem_len); 777 + return dma_mmap_wc(&fb->dev->dev, vma, fb->fb.screen_base, 778 + fb->fb.fix.smem_start, fb->fb.fix.smem_len); 779 779 } 780 780 781 781 static void clcdfb_of_dma_remove(struct clcd_fb *fb)
+5 -4
drivers/video/fbdev/atmel_lcdfb.c
··· 414 414 { 415 415 struct fb_info *info = sinfo->info; 416 416 417 - dma_free_writecombine(info->device, info->fix.smem_len, 418 - info->screen_base, info->fix.smem_start); 417 + dma_free_wc(info->device, info->fix.smem_len, info->screen_base, 418 + info->fix.smem_start); 419 419 } 420 420 421 421 /** ··· 435 435 * ((var->bits_per_pixel + 7) / 8)); 436 436 info->fix.smem_len = max(smem_len, sinfo->smem_len); 437 437 438 - info->screen_base = dma_alloc_writecombine(info->device, info->fix.smem_len, 439 - (dma_addr_t *)&info->fix.smem_start, GFP_KERNEL); 438 + info->screen_base = dma_alloc_wc(info->device, info->fix.smem_len, 439 + (dma_addr_t *)&info->fix.smem_start, 440 + GFP_KERNEL); 440 441 441 442 if (!info->screen_base) { 442 443 return -ENOMEM;
+3 -5
drivers/video/fbdev/ep93xx-fb.c
··· 316 316 unsigned int offset = vma->vm_pgoff << PAGE_SHIFT; 317 317 318 318 if (offset < info->fix.smem_len) { 319 - return dma_mmap_writecombine(info->dev, vma, info->screen_base, 320 - info->fix.smem_start, 321 - info->fix.smem_len); 319 + return dma_mmap_wc(info->dev, vma, info->screen_base, 320 + info->fix.smem_start, info->fix.smem_len); 322 321 } 323 322 324 323 return -EINVAL; ··· 427 428 /* Maximum 16bpp -> used memory is maximum x*y*2 bytes */ 428 429 fb_size = EP93XXFB_MAX_XRES * EP93XXFB_MAX_YRES * 2; 429 430 430 - virt_addr = dma_alloc_writecombine(info->dev, fb_size, 431 - &phys_addr, GFP_KERNEL); 431 + virt_addr = dma_alloc_wc(info->dev, fb_size, &phys_addr, GFP_KERNEL); 432 432 if (!virt_addr) 433 433 return -ENOMEM; 434 434
+4 -4
drivers/video/fbdev/gbefb.c
··· 1185 1185 } else { 1186 1186 /* try to allocate memory with the classical allocator 1187 1187 * this has high chance to fail on low memory machines */ 1188 - gbe_mem = dma_alloc_writecombine(NULL, gbe_mem_size, 1189 - &gbe_dma_addr, GFP_KERNEL); 1188 + gbe_mem = dma_alloc_wc(NULL, gbe_mem_size, &gbe_dma_addr, 1189 + GFP_KERNEL); 1190 1190 if (!gbe_mem) { 1191 1191 printk(KERN_ERR "gbefb: couldn't allocate framebuffer memory\n"); 1192 1192 ret = -ENOMEM; ··· 1238 1238 out_gbe_unmap: 1239 1239 arch_phys_wc_del(par->wc_cookie); 1240 1240 if (gbe_dma_addr) 1241 - dma_free_writecombine(NULL, gbe_mem_size, gbe_mem, gbe_mem_phys); 1241 + dma_free_wc(NULL, gbe_mem_size, gbe_mem, gbe_mem_phys); 1242 1242 out_tiles_free: 1243 1243 dma_free_coherent(NULL, GBE_TLB_SIZE * sizeof(uint16_t), 1244 1244 (void *)gbe_tiles.cpu, gbe_tiles.dma); ··· 1259 1259 gbe_turn_off(); 1260 1260 arch_phys_wc_del(par->wc_cookie); 1261 1261 if (gbe_dma_addr) 1262 - dma_free_writecombine(NULL, gbe_mem_size, gbe_mem, gbe_mem_phys); 1262 + dma_free_wc(NULL, gbe_mem_size, gbe_mem, gbe_mem_phys); 1263 1263 dma_free_coherent(NULL, GBE_TLB_SIZE * sizeof(uint16_t), 1264 1264 (void *)gbe_tiles.cpu, gbe_tiles.dma); 1265 1265 release_mem_region(GBE_BASE, sizeof(struct sgi_gbe));
+6 -6
drivers/video/fbdev/imxfb.c
··· 937 937 } 938 938 939 939 fbi->map_size = PAGE_ALIGN(info->fix.smem_len); 940 - info->screen_base = dma_alloc_writecombine(&pdev->dev, fbi->map_size, 941 - &fbi->map_dma, GFP_KERNEL); 940 + info->screen_base = dma_alloc_wc(&pdev->dev, fbi->map_size, 941 + &fbi->map_dma, GFP_KERNEL); 942 942 943 943 if (!info->screen_base) { 944 944 dev_err(&pdev->dev, "Failed to allocate video RAM: %d\n", ret); ··· 1005 1005 if (pdata && pdata->exit) 1006 1006 pdata->exit(fbi->pdev); 1007 1007 failed_platform_init: 1008 - dma_free_writecombine(&pdev->dev, fbi->map_size, info->screen_base, 1009 - fbi->map_dma); 1008 + dma_free_wc(&pdev->dev, fbi->map_size, info->screen_base, 1009 + fbi->map_dma); 1010 1010 failed_map: 1011 1011 iounmap(fbi->regs); 1012 1012 failed_ioremap: ··· 1041 1041 kfree(info->pseudo_palette); 1042 1042 framebuffer_release(info); 1043 1043 1044 - dma_free_writecombine(&pdev->dev, fbi->map_size, info->screen_base, 1045 - fbi->map_dma); 1044 + dma_free_wc(&pdev->dev, fbi->map_size, info->screen_base, 1045 + fbi->map_dma); 1046 1046 1047 1047 iounmap(fbi->regs); 1048 1048 release_mem_region(res->start, resource_size(res));
+4 -5
drivers/video/fbdev/mx3fb.c
··· 1336 1336 int retval = 0; 1337 1337 dma_addr_t addr; 1338 1338 1339 - fbi->screen_base = dma_alloc_writecombine(fbi->device, 1340 - mem_len, 1341 - &addr, GFP_DMA | GFP_KERNEL); 1339 + fbi->screen_base = dma_alloc_wc(fbi->device, mem_len, &addr, 1340 + GFP_DMA | GFP_KERNEL); 1342 1341 1343 1342 if (!fbi->screen_base) { 1344 1343 dev_err(fbi->device, "Cannot allocate %u bytes framebuffer memory\n", ··· 1377 1378 */ 1378 1379 static int mx3fb_unmap_video_memory(struct fb_info *fbi) 1379 1380 { 1380 - dma_free_writecombine(fbi->device, fbi->fix.smem_len, 1381 - fbi->screen_base, fbi->fix.smem_start); 1381 + dma_free_wc(fbi->device, fbi->fix.smem_len, fbi->screen_base, 1382 + fbi->fix.smem_start); 1382 1383 1383 1384 fbi->screen_base = NULL; 1384 1385 mutex_lock(&fbi->mm_lock);
+4 -4
drivers/video/fbdev/nuc900fb.c
··· 396 396 dev_dbg(fbi->dev, "nuc900fb_map_video_memory(fbi=%p) map_size %lu\n", 397 397 fbi, map_size); 398 398 399 - info->screen_base = dma_alloc_writecombine(fbi->dev, map_size, 400 - &map_dma, GFP_KERNEL); 399 + info->screen_base = dma_alloc_wc(fbi->dev, map_size, &map_dma, 400 + GFP_KERNEL); 401 401 402 402 if (!info->screen_base) 403 403 return -ENOMEM; ··· 411 411 static inline void nuc900fb_unmap_video_memory(struct fb_info *info) 412 412 { 413 413 struct nuc900fb_info *fbi = info->par; 414 - dma_free_writecombine(fbi->dev, PAGE_ALIGN(info->fix.smem_len), 415 - info->screen_base, info->fix.smem_start); 414 + dma_free_wc(fbi->dev, PAGE_ALIGN(info->fix.smem_len), 415 + info->screen_base, info->fix.smem_start); 416 416 } 417 417 418 418 static irqreturn_t nuc900fb_irqhandler(int irq, void *dev_id)
+8 -8
drivers/video/fbdev/omap/lcdc.c
··· 612 612 613 613 static int alloc_palette_ram(void) 614 614 { 615 - lcdc.palette_virt = dma_alloc_writecombine(lcdc.fbdev->dev, 616 - MAX_PALETTE_SIZE, &lcdc.palette_phys, GFP_KERNEL); 615 + lcdc.palette_virt = dma_alloc_wc(lcdc.fbdev->dev, MAX_PALETTE_SIZE, 616 + &lcdc.palette_phys, GFP_KERNEL); 617 617 if (lcdc.palette_virt == NULL) { 618 618 dev_err(lcdc.fbdev->dev, "failed to alloc palette memory\n"); 619 619 return -ENOMEM; ··· 625 625 626 626 static void free_palette_ram(void) 627 627 { 628 - dma_free_writecombine(lcdc.fbdev->dev, MAX_PALETTE_SIZE, 629 - lcdc.palette_virt, lcdc.palette_phys); 628 + dma_free_wc(lcdc.fbdev->dev, MAX_PALETTE_SIZE, lcdc.palette_virt, 629 + lcdc.palette_phys); 630 630 } 631 631 632 632 static int alloc_fbmem(struct omapfb_mem_region *region) ··· 642 642 if (region->size > frame_size) 643 643 frame_size = region->size; 644 644 lcdc.vram_size = frame_size; 645 - lcdc.vram_virt = dma_alloc_writecombine(lcdc.fbdev->dev, 646 - lcdc.vram_size, &lcdc.vram_phys, GFP_KERNEL); 645 + lcdc.vram_virt = dma_alloc_wc(lcdc.fbdev->dev, lcdc.vram_size, 646 + &lcdc.vram_phys, GFP_KERNEL); 647 647 if (lcdc.vram_virt == NULL) { 648 648 dev_err(lcdc.fbdev->dev, "unable to allocate FB DMA memory\n"); 649 649 return -ENOMEM; ··· 660 660 661 661 static void free_fbmem(void) 662 662 { 663 - dma_free_writecombine(lcdc.fbdev->dev, lcdc.vram_size, 664 - lcdc.vram_virt, lcdc.vram_phys); 663 + dma_free_wc(lcdc.fbdev->dev, lcdc.vram_size, lcdc.vram_virt, 664 + lcdc.vram_phys); 665 665 } 666 666 667 667 static int setup_fbmem(struct omapfb_mem_desc *req_md)
+4 -4
drivers/video/fbdev/pxa168fb.c
··· 680 680 */ 681 681 info->fix.smem_len = PAGE_ALIGN(DEFAULT_FB_SIZE); 682 682 683 - info->screen_base = dma_alloc_writecombine(fbi->dev, info->fix.smem_len, 684 - &fbi->fb_start_dma, GFP_KERNEL); 683 + info->screen_base = dma_alloc_wc(fbi->dev, info->fix.smem_len, 684 + &fbi->fb_start_dma, GFP_KERNEL); 685 685 if (info->screen_base == NULL) { 686 686 ret = -ENOMEM; 687 687 goto failed_free_info; ··· 804 804 805 805 irq = platform_get_irq(pdev, 0); 806 806 807 - dma_free_writecombine(fbi->dev, PAGE_ALIGN(info->fix.smem_len), 808 - info->screen_base, info->fix.smem_start); 807 + dma_free_wc(fbi->dev, PAGE_ALIGN(info->fix.smem_len), 808 + info->screen_base, info->fix.smem_start); 809 809 810 810 clk_disable(fbi->clk); 811 811
+2 -2
drivers/video/fbdev/pxafb.c
··· 2446 2446 2447 2447 free_pages_exact(fbi->video_mem, fbi->video_mem_size); 2448 2448 2449 - dma_free_writecombine(&dev->dev, fbi->dma_buff_size, 2450 - fbi->dma_buff, fbi->dma_buff_phys); 2449 + dma_free_wc(&dev->dev, fbi->dma_buff_size, fbi->dma_buff, 2450 + fbi->dma_buff_phys); 2451 2451 2452 2452 iounmap(fbi->mmio_base); 2453 2453
+3 -4
drivers/video/fbdev/s3c-fb.c
··· 1105 1105 1106 1106 dev_dbg(sfb->dev, "want %u bytes for window\n", size); 1107 1107 1108 - fbi->screen_base = dma_alloc_writecombine(sfb->dev, size, 1109 - &map_dma, GFP_KERNEL); 1108 + fbi->screen_base = dma_alloc_wc(sfb->dev, size, &map_dma, GFP_KERNEL); 1110 1109 if (!fbi->screen_base) 1111 1110 return -ENOMEM; 1112 1111 ··· 1130 1131 struct fb_info *fbi = win->fbinfo; 1131 1132 1132 1133 if (fbi->screen_base) 1133 - dma_free_writecombine(sfb->dev, PAGE_ALIGN(fbi->fix.smem_len), 1134 - fbi->screen_base, fbi->fix.smem_start); 1134 + dma_free_wc(sfb->dev, PAGE_ALIGN(fbi->fix.smem_len), 1135 + fbi->screen_base, fbi->fix.smem_start); 1135 1136 } 1136 1137 1137 1138 /**
+4 -4
drivers/video/fbdev/s3c2410fb.c
··· 645 645 646 646 dprintk("map_video_memory(fbi=%p) map_size %u\n", fbi, map_size); 647 647 648 - info->screen_base = dma_alloc_writecombine(fbi->dev, map_size, 649 - &map_dma, GFP_KERNEL); 648 + info->screen_base = dma_alloc_wc(fbi->dev, map_size, &map_dma, 649 + GFP_KERNEL); 650 650 651 651 if (info->screen_base) { 652 652 /* prevent initial garbage on screen */ ··· 667 667 { 668 668 struct s3c2410fb_info *fbi = info->par; 669 669 670 - dma_free_writecombine(fbi->dev, PAGE_ALIGN(info->fix.smem_len), 671 - info->screen_base, info->fix.smem_start); 670 + dma_free_wc(fbi->dev, PAGE_ALIGN(info->fix.smem_len), 671 + info->screen_base, info->fix.smem_start); 672 672 } 673 673 674 674 static inline void modify_gpio(void __iomem *reg,
+4 -4
drivers/video/fbdev/sa1100fb.c
··· 567 567 568 568 if (off < info->fix.smem_len) { 569 569 vma->vm_pgoff += 1; /* skip over the palette */ 570 - return dma_mmap_writecombine(fbi->dev, vma, fbi->map_cpu, 571 - fbi->map_dma, fbi->map_size); 570 + return dma_mmap_wc(fbi->dev, vma, fbi->map_cpu, fbi->map_dma, 571 + fbi->map_size); 572 572 } 573 573 574 574 vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot); ··· 1099 1099 * of the framebuffer. 1100 1100 */ 1101 1101 fbi->map_size = PAGE_ALIGN(fbi->fb.fix.smem_len + PAGE_SIZE); 1102 - fbi->map_cpu = dma_alloc_writecombine(fbi->dev, fbi->map_size, 1103 - &fbi->map_dma, GFP_KERNEL); 1102 + fbi->map_cpu = dma_alloc_wc(fbi->dev, fbi->map_size, &fbi->map_dma, 1103 + GFP_KERNEL); 1104 1104 1105 1105 if (fbi->map_cpu) { 1106 1106 fbi->fb.screen_base = fbi->map_cpu + PAGE_SIZE;
+17 -8
include/linux/dma-mapping.h
··· 641 641 } 642 642 #endif /* CONFIG_HAVE_GENERIC_DMA_COHERENT */ 643 643 644 - static inline void *dma_alloc_writecombine(struct device *dev, size_t size, 645 - dma_addr_t *dma_addr, gfp_t gfp) 644 + static inline void *dma_alloc_wc(struct device *dev, size_t size, 645 + dma_addr_t *dma_addr, gfp_t gfp) 646 646 { 647 647 DEFINE_DMA_ATTRS(attrs); 648 648 dma_set_attr(DMA_ATTR_WRITE_COMBINE, &attrs); 649 649 return dma_alloc_attrs(dev, size, dma_addr, gfp, &attrs); 650 650 } 651 + #ifndef dma_alloc_writecombine 652 + #define dma_alloc_writecombine dma_alloc_wc 653 + #endif 651 654 652 - static inline void dma_free_writecombine(struct device *dev, size_t size, 653 - void *cpu_addr, dma_addr_t dma_addr) 655 + static inline void dma_free_wc(struct device *dev, size_t size, 656 + void *cpu_addr, dma_addr_t dma_addr) 654 657 { 655 658 DEFINE_DMA_ATTRS(attrs); 656 659 dma_set_attr(DMA_ATTR_WRITE_COMBINE, &attrs); 657 660 return dma_free_attrs(dev, size, cpu_addr, dma_addr, &attrs); 658 661 } 662 + #ifndef dma_free_writecombine 663 + #define dma_free_writecombine dma_free_wc 664 + #endif 659 665 660 - static inline int dma_mmap_writecombine(struct device *dev, 661 - struct vm_area_struct *vma, 662 - void *cpu_addr, dma_addr_t dma_addr, 663 - size_t size) 666 + static inline int dma_mmap_wc(struct device *dev, 667 + struct vm_area_struct *vma, 668 + void *cpu_addr, dma_addr_t dma_addr, 669 + size_t size) 664 670 { 665 671 DEFINE_DMA_ATTRS(attrs); 666 672 dma_set_attr(DMA_ATTR_WRITE_COMBINE, &attrs); 667 673 return dma_mmap_attrs(dev, vma, cpu_addr, dma_addr, size, &attrs); 668 674 } 675 + #ifndef dma_mmap_writecombine 676 + #define dma_mmap_writecombine dma_mmap_wc 677 + #endif 669 678 670 679 #ifdef CONFIG_NEED_DMA_MAP_STATE 671 680 #define DEFINE_DMA_UNMAP_ADDR(ADDR_NAME) dma_addr_t ADDR_NAME
+4 -8
sound/arm/pxa2xx-pcm-lib.c
··· 141 141 struct vm_area_struct *vma) 142 142 { 143 143 struct snd_pcm_runtime *runtime = substream->runtime; 144 - return dma_mmap_writecombine(substream->pcm->card->dev, vma, 145 - runtime->dma_area, 146 - runtime->dma_addr, 147 - runtime->dma_bytes); 144 + return dma_mmap_wc(substream->pcm->card->dev, vma, runtime->dma_area, 145 + runtime->dma_addr, runtime->dma_bytes); 148 146 } 149 147 EXPORT_SYMBOL(pxa2xx_pcm_mmap); 150 148 ··· 154 156 buf->dev.type = SNDRV_DMA_TYPE_DEV; 155 157 buf->dev.dev = pcm->card->dev; 156 158 buf->private_data = NULL; 157 - buf->area = dma_alloc_writecombine(pcm->card->dev, size, 158 - &buf->addr, GFP_KERNEL); 159 + buf->area = dma_alloc_wc(pcm->card->dev, size, &buf->addr, GFP_KERNEL); 159 160 if (!buf->area) 160 161 return -ENOMEM; 161 162 buf->bytes = size; ··· 175 178 buf = &substream->dma_buffer; 176 179 if (!buf->area) 177 180 continue; 178 - dma_free_writecombine(pcm->card->dev, buf->bytes, 179 - buf->area, buf->addr); 181 + dma_free_wc(pcm->card->dev, buf->bytes, buf->area, buf->addr); 180 182 buf->area = NULL; 181 183 } 182 184 }
+4 -6
sound/soc/fsl/imx-pcm-fiq.c
··· 217 217 struct snd_pcm_runtime *runtime = substream->runtime; 218 218 int ret; 219 219 220 - ret = dma_mmap_writecombine(substream->pcm->card->dev, vma, 221 - runtime->dma_area, runtime->dma_addr, runtime->dma_bytes); 220 + ret = dma_mmap_wc(substream->pcm->card->dev, vma, runtime->dma_area, 221 + runtime->dma_addr, runtime->dma_bytes); 222 222 223 223 pr_debug("%s: ret: %d %p %pad 0x%08x\n", __func__, ret, 224 224 runtime->dma_area, ··· 247 247 buf->dev.type = SNDRV_DMA_TYPE_DEV; 248 248 buf->dev.dev = pcm->card->dev; 249 249 buf->private_data = NULL; 250 - buf->area = dma_alloc_writecombine(pcm->card->dev, size, 251 - &buf->addr, GFP_KERNEL); 250 + buf->area = dma_alloc_wc(pcm->card->dev, size, &buf->addr, GFP_KERNEL); 252 251 if (!buf->area) 253 252 return -ENOMEM; 254 253 buf->bytes = size; ··· 329 330 if (!buf->area) 330 331 continue; 331 332 332 - dma_free_writecombine(pcm->card->dev, buf->bytes, 333 - buf->area, buf->addr); 333 + dma_free_wc(pcm->card->dev, buf->bytes, buf->area, buf->addr); 334 334 buf->area = NULL; 335 335 } 336 336 }
+2 -4
sound/soc/nuc900/nuc900-pcm.c
··· 267 267 { 268 268 struct snd_pcm_runtime *runtime = substream->runtime; 269 269 270 - return dma_mmap_writecombine(substream->pcm->card->dev, vma, 271 - runtime->dma_area, 272 - runtime->dma_addr, 273 - runtime->dma_bytes); 270 + return dma_mmap_wc(substream->pcm->card->dev, vma, runtime->dma_area, 271 + runtime->dma_addr, runtime->dma_bytes); 274 272 } 275 273 276 274 static struct snd_pcm_ops nuc900_dma_ops = {
+4 -8
sound/soc/omap/omap-pcm.c
··· 156 156 { 157 157 struct snd_pcm_runtime *runtime = substream->runtime; 158 158 159 - return dma_mmap_writecombine(substream->pcm->card->dev, vma, 160 - runtime->dma_area, 161 - runtime->dma_addr, 162 - runtime->dma_bytes); 159 + return dma_mmap_wc(substream->pcm->card->dev, vma, runtime->dma_area, 160 + runtime->dma_addr, runtime->dma_bytes); 163 161 } 164 162 165 163 static struct snd_pcm_ops omap_pcm_ops = { ··· 181 183 buf->dev.type = SNDRV_DMA_TYPE_DEV; 182 184 buf->dev.dev = pcm->card->dev; 183 185 buf->private_data = NULL; 184 - buf->area = dma_alloc_writecombine(pcm->card->dev, size, 185 - &buf->addr, GFP_KERNEL); 186 + buf->area = dma_alloc_wc(pcm->card->dev, size, &buf->addr, GFP_KERNEL); 186 187 if (!buf->area) 187 188 return -ENOMEM; 188 189 ··· 204 207 if (!buf->area) 205 208 continue; 206 209 207 - dma_free_writecombine(pcm->card->dev, buf->bytes, 208 - buf->area, buf->addr); 210 + dma_free_wc(pcm->card->dev, buf->bytes, buf->area, buf->addr); 209 211 buf->area = NULL; 210 212 } 211 213 }