1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * DMABUF CMA heap exporter 4 * 5 * Copyright (C) 2012, 2019 Linaro Ltd. 6 * Author: <benjamin.gaignard@linaro.org> for ST-Ericsson. 7 */ 8 9 #include <linux/cma.h> 10 #include <linux/device.h> 11 #include <linux/dma-buf.h> 12 #include <linux/dma-heap.h> 13 #include <linux/dma-contiguous.h> 14 #include <linux/err.h> 15 #include <linux/errno.h> 16 #include <linux/highmem.h> 17 #include <linux/module.h> 18 #include <linux/slab.h> 19 #include <linux/scatterlist.h> 20 #include <linux/sched/signal.h> 21 22 #include "heap-helpers.h" 23 24 struct cma_heap { 25 struct dma_heap *heap; 26 struct cma *cma; 27 }; 28 29 static void cma_heap_free(struct heap_helper_buffer *buffer) 30 { 31 struct cma_heap *cma_heap = dma_heap_get_drvdata(buffer->heap); 32 unsigned long nr_pages = buffer->pagecount; 33 struct page *cma_pages = buffer->priv_virt; 34 35 /* free page list */ 36 kfree(buffer->pages); 37 /* release memory */ 38 cma_release(cma_heap->cma, cma_pages, nr_pages); 39 kfree(buffer); 40 } 41 42 /* dmabuf heap CMA operations functions */ 43 static int cma_heap_allocate(struct dma_heap *heap, 44 unsigned long len, 45 unsigned long fd_flags, 46 unsigned long heap_flags) 47 { 48 struct cma_heap *cma_heap = dma_heap_get_drvdata(heap); 49 struct heap_helper_buffer *helper_buffer; 50 struct page *cma_pages; 51 size_t size = PAGE_ALIGN(len); 52 unsigned long nr_pages = size >> PAGE_SHIFT; 53 unsigned long align = get_order(size); 54 struct dma_buf *dmabuf; 55 int ret = -ENOMEM; 56 pgoff_t pg; 57 58 if (align > CONFIG_CMA_ALIGNMENT) 59 align = CONFIG_CMA_ALIGNMENT; 60 61 helper_buffer = kzalloc(sizeof(*helper_buffer), GFP_KERNEL); 62 if (!helper_buffer) 63 return -ENOMEM; 64 65 init_heap_helper_buffer(helper_buffer, cma_heap_free); 66 helper_buffer->heap = heap; 67 helper_buffer->size = len; 68 69 cma_pages = cma_alloc(cma_heap->cma, nr_pages, align, false); 70 if (!cma_pages) 71 goto free_buf; 72 73 if (PageHighMem(cma_pages)) { 74 unsigned long nr_clear_pages = nr_pages; 75 struct page *page = cma_pages; 76 77 while (nr_clear_pages > 0) { 78 void *vaddr = kmap_atomic(page); 79 80 memset(vaddr, 0, PAGE_SIZE); 81 kunmap_atomic(vaddr); 82 /* 83 * Avoid wasting time zeroing memory if the process 84 * has been killed by by SIGKILL 85 */ 86 if (fatal_signal_pending(current)) 87 goto free_cma; 88 89 page++; 90 nr_clear_pages--; 91 } 92 } else { 93 memset(page_address(cma_pages), 0, size); 94 } 95 96 helper_buffer->pagecount = nr_pages; 97 helper_buffer->pages = kmalloc_array(helper_buffer->pagecount, 98 sizeof(*helper_buffer->pages), 99 GFP_KERNEL); 100 if (!helper_buffer->pages) { 101 ret = -ENOMEM; 102 goto free_cma; 103 } 104 105 for (pg = 0; pg < helper_buffer->pagecount; pg++) 106 helper_buffer->pages[pg] = &cma_pages[pg]; 107 108 /* create the dmabuf */ 109 dmabuf = heap_helper_export_dmabuf(helper_buffer, fd_flags); 110 if (IS_ERR(dmabuf)) { 111 ret = PTR_ERR(dmabuf); 112 goto free_pages; 113 } 114 115 helper_buffer->dmabuf = dmabuf; 116 helper_buffer->priv_virt = cma_pages; 117 118 ret = dma_buf_fd(dmabuf, fd_flags); 119 if (ret < 0) { 120 dma_buf_put(dmabuf); 121 /* just return, as put will call release and that will free */ 122 return ret; 123 } 124 125 return ret; 126 127 free_pages: 128 kfree(helper_buffer->pages); 129 free_cma: 130 cma_release(cma_heap->cma, cma_pages, nr_pages); 131 free_buf: 132 kfree(helper_buffer); 133 return ret; 134 } 135 136 static const struct dma_heap_ops cma_heap_ops = { 137 .allocate = cma_heap_allocate, 138 }; 139 140 static int __add_cma_heap(struct cma *cma, void *data) 141 { 142 struct cma_heap *cma_heap; 143 struct dma_heap_export_info exp_info; 144 145 cma_heap = kzalloc(sizeof(*cma_heap), GFP_KERNEL); 146 if (!cma_heap) 147 return -ENOMEM; 148 cma_heap->cma = cma; 149 150 exp_info.name = cma_get_name(cma); 151 exp_info.ops = &cma_heap_ops; 152 exp_info.priv = cma_heap; 153 154 cma_heap->heap = dma_heap_add(&exp_info); 155 if (IS_ERR(cma_heap->heap)) { 156 int ret = PTR_ERR(cma_heap->heap); 157 158 kfree(cma_heap); 159 return ret; 160 } 161 162 return 0; 163 } 164 165 static int add_default_cma_heap(void) 166 { 167 struct cma *default_cma = dev_get_cma_area(NULL); 168 int ret = 0; 169 170 if (default_cma) 171 ret = __add_cma_heap(default_cma, NULL); 172 173 return ret; 174 } 175 module_init(add_default_cma_heap); 176 MODULE_DESCRIPTION("DMA-BUF CMA Heap"); 177 MODULE_LICENSE("GPL v2"); 178