Gerd Hoffmann | fbb0de7 | 2018-08-27 11:34:44 +0200 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0 |
Gerd Hoffmann | 913965c | 2018-09-11 15:42:04 +0200 | [diff] [blame] | 2 | #include <linux/cred.h> |
Gerd Hoffmann | fbb0de7 | 2018-08-27 11:34:44 +0200 | [diff] [blame] | 3 | #include <linux/device.h> |
Gerd Hoffmann | fbb0de7 | 2018-08-27 11:34:44 +0200 | [diff] [blame] | 4 | #include <linux/dma-buf.h> |
| 5 | #include <linux/highmem.h> |
Gerd Hoffmann | 913965c | 2018-09-11 15:42:04 +0200 | [diff] [blame] | 6 | #include <linux/init.h> |
| 7 | #include <linux/kernel.h> |
Gerd Hoffmann | fbb0de7 | 2018-08-27 11:34:44 +0200 | [diff] [blame] | 8 | #include <linux/memfd.h> |
Gerd Hoffmann | 913965c | 2018-09-11 15:42:04 +0200 | [diff] [blame] | 9 | #include <linux/miscdevice.h> |
| 10 | #include <linux/module.h> |
| 11 | #include <linux/shmem_fs.h> |
| 12 | #include <linux/slab.h> |
| 13 | #include <linux/udmabuf.h> |
Gerd Hoffmann | fbb0de7 | 2018-08-27 11:34:44 +0200 | [diff] [blame] | 14 | |
Gerd Hoffmann | dc4716d | 2018-09-11 15:42:10 +0200 | [diff] [blame] | 15 | static const u32 list_limit = 1024; /* udmabuf_create_list->count limit */ |
| 16 | static const size_t size_limit_mb = 64; /* total dmabuf size, in megabytes */ |
| 17 | |
Gerd Hoffmann | fbb0de7 | 2018-08-27 11:34:44 +0200 | [diff] [blame] | 18 | struct udmabuf { |
Gerd Hoffmann | b35f57c | 2018-09-11 15:42:06 +0200 | [diff] [blame] | 19 | pgoff_t pagecount; |
Gerd Hoffmann | fbb0de7 | 2018-08-27 11:34:44 +0200 | [diff] [blame] | 20 | struct page **pages; |
Gurchetan Singh | 284562e | 2019-12-02 17:36:27 -0800 | [diff] [blame] | 21 | struct sg_table *sg; |
Gurchetan Singh | c1bbed6 | 2019-12-02 17:36:25 -0800 | [diff] [blame] | 22 | struct miscdevice *device; |
Gerd Hoffmann | fbb0de7 | 2018-08-27 11:34:44 +0200 | [diff] [blame] | 23 | }; |
| 24 | |
Souptick Joarder | 300133d | 2019-01-03 15:26:34 -0800 | [diff] [blame] | 25 | static vm_fault_t udmabuf_vm_fault(struct vm_fault *vmf) |
Gerd Hoffmann | fbb0de7 | 2018-08-27 11:34:44 +0200 | [diff] [blame] | 26 | { |
| 27 | struct vm_area_struct *vma = vmf->vma; |
| 28 | struct udmabuf *ubuf = vma->vm_private_data; |
| 29 | |
Gerd Hoffmann | fbb0de7 | 2018-08-27 11:34:44 +0200 | [diff] [blame] | 30 | vmf->page = ubuf->pages[vmf->pgoff]; |
| 31 | get_page(vmf->page); |
| 32 | return 0; |
| 33 | } |
| 34 | |
| 35 | static const struct vm_operations_struct udmabuf_vm_ops = { |
| 36 | .fault = udmabuf_vm_fault, |
| 37 | }; |
| 38 | |
| 39 | static int mmap_udmabuf(struct dma_buf *buf, struct vm_area_struct *vma) |
| 40 | { |
| 41 | struct udmabuf *ubuf = buf->priv; |
| 42 | |
| 43 | if ((vma->vm_flags & (VM_SHARED | VM_MAYSHARE)) == 0) |
| 44 | return -EINVAL; |
| 45 | |
| 46 | vma->vm_ops = &udmabuf_vm_ops; |
| 47 | vma->vm_private_data = ubuf; |
| 48 | return 0; |
| 49 | } |
| 50 | |
Gurchetan Singh | 17a7ce2 | 2019-12-02 17:36:26 -0800 | [diff] [blame] | 51 | static struct sg_table *get_sg_table(struct device *dev, struct dma_buf *buf, |
| 52 | enum dma_data_direction direction) |
Gerd Hoffmann | fbb0de7 | 2018-08-27 11:34:44 +0200 | [diff] [blame] | 53 | { |
Gurchetan Singh | 17a7ce2 | 2019-12-02 17:36:26 -0800 | [diff] [blame] | 54 | struct udmabuf *ubuf = buf->priv; |
Gerd Hoffmann | fbb0de7 | 2018-08-27 11:34:44 +0200 | [diff] [blame] | 55 | struct sg_table *sg; |
Gerd Hoffmann | a3e722d | 2018-09-11 15:42:05 +0200 | [diff] [blame] | 56 | int ret; |
Gerd Hoffmann | fbb0de7 | 2018-08-27 11:34:44 +0200 | [diff] [blame] | 57 | |
| 58 | sg = kzalloc(sizeof(*sg), GFP_KERNEL); |
| 59 | if (!sg) |
Gerd Hoffmann | a3e722d | 2018-09-11 15:42:05 +0200 | [diff] [blame] | 60 | return ERR_PTR(-ENOMEM); |
| 61 | ret = sg_alloc_table_from_pages(sg, ubuf->pages, ubuf->pagecount, |
| 62 | 0, ubuf->pagecount << PAGE_SHIFT, |
| 63 | GFP_KERNEL); |
| 64 | if (ret < 0) |
| 65 | goto err; |
Gurchetan Singh | 17a7ce2 | 2019-12-02 17:36:26 -0800 | [diff] [blame] | 66 | if (!dma_map_sg(dev, sg->sgl, sg->nents, direction)) { |
Dan Carpenter | 6f19eb2 | 2018-09-14 09:56:15 +0300 | [diff] [blame] | 67 | ret = -EINVAL; |
Gerd Hoffmann | a3e722d | 2018-09-11 15:42:05 +0200 | [diff] [blame] | 68 | goto err; |
Dan Carpenter | 6f19eb2 | 2018-09-14 09:56:15 +0300 | [diff] [blame] | 69 | } |
Gerd Hoffmann | fbb0de7 | 2018-08-27 11:34:44 +0200 | [diff] [blame] | 70 | return sg; |
| 71 | |
Gerd Hoffmann | a3e722d | 2018-09-11 15:42:05 +0200 | [diff] [blame] | 72 | err: |
Gerd Hoffmann | fbb0de7 | 2018-08-27 11:34:44 +0200 | [diff] [blame] | 73 | sg_free_table(sg); |
Gerd Hoffmann | fbb0de7 | 2018-08-27 11:34:44 +0200 | [diff] [blame] | 74 | kfree(sg); |
Gerd Hoffmann | a3e722d | 2018-09-11 15:42:05 +0200 | [diff] [blame] | 75 | return ERR_PTR(ret); |
Gerd Hoffmann | fbb0de7 | 2018-08-27 11:34:44 +0200 | [diff] [blame] | 76 | } |
| 77 | |
Gurchetan Singh | 17a7ce2 | 2019-12-02 17:36:26 -0800 | [diff] [blame] | 78 | static void put_sg_table(struct device *dev, struct sg_table *sg, |
| 79 | enum dma_data_direction direction) |
| 80 | { |
| 81 | dma_unmap_sg(dev, sg->sgl, sg->nents, direction); |
| 82 | sg_free_table(sg); |
| 83 | kfree(sg); |
| 84 | } |
| 85 | |
| 86 | static struct sg_table *map_udmabuf(struct dma_buf_attachment *at, |
| 87 | enum dma_data_direction direction) |
| 88 | { |
| 89 | return get_sg_table(at->dev, at->dmabuf, direction); |
| 90 | } |
| 91 | |
Gerd Hoffmann | fbb0de7 | 2018-08-27 11:34:44 +0200 | [diff] [blame] | 92 | static void unmap_udmabuf(struct dma_buf_attachment *at, |
| 93 | struct sg_table *sg, |
| 94 | enum dma_data_direction direction) |
| 95 | { |
Gurchetan Singh | 17a7ce2 | 2019-12-02 17:36:26 -0800 | [diff] [blame] | 96 | return put_sg_table(at->dev, sg, direction); |
Gerd Hoffmann | fbb0de7 | 2018-08-27 11:34:44 +0200 | [diff] [blame] | 97 | } |
| 98 | |
| 99 | static void release_udmabuf(struct dma_buf *buf) |
| 100 | { |
| 101 | struct udmabuf *ubuf = buf->priv; |
Gurchetan Singh | 284562e | 2019-12-02 17:36:27 -0800 | [diff] [blame] | 102 | struct device *dev = ubuf->device->this_device; |
Gerd Hoffmann | fbb0de7 | 2018-08-27 11:34:44 +0200 | [diff] [blame] | 103 | pgoff_t pg; |
| 104 | |
Gurchetan Singh | 284562e | 2019-12-02 17:36:27 -0800 | [diff] [blame] | 105 | if (ubuf->sg) |
| 106 | put_sg_table(dev, ubuf->sg, DMA_BIDIRECTIONAL); |
| 107 | |
Gerd Hoffmann | fbb0de7 | 2018-08-27 11:34:44 +0200 | [diff] [blame] | 108 | for (pg = 0; pg < ubuf->pagecount; pg++) |
| 109 | put_page(ubuf->pages[pg]); |
| 110 | kfree(ubuf->pages); |
| 111 | kfree(ubuf); |
| 112 | } |
| 113 | |
Gurchetan Singh | 284562e | 2019-12-02 17:36:27 -0800 | [diff] [blame] | 114 | static int begin_cpu_udmabuf(struct dma_buf *buf, |
| 115 | enum dma_data_direction direction) |
| 116 | { |
| 117 | struct udmabuf *ubuf = buf->priv; |
| 118 | struct device *dev = ubuf->device->this_device; |
| 119 | |
| 120 | if (!ubuf->sg) { |
| 121 | ubuf->sg = get_sg_table(dev, buf, direction); |
| 122 | if (IS_ERR(ubuf->sg)) |
| 123 | return PTR_ERR(ubuf->sg); |
| 124 | } else { |
Gurchetan Singh | 1ffe095 | 2019-12-17 15:02:28 -0800 | [diff] [blame] | 125 | dma_sync_sg_for_cpu(dev, ubuf->sg->sgl, ubuf->sg->nents, |
| 126 | direction); |
Gurchetan Singh | 284562e | 2019-12-02 17:36:27 -0800 | [diff] [blame] | 127 | } |
| 128 | |
| 129 | return 0; |
| 130 | } |
| 131 | |
| 132 | static int end_cpu_udmabuf(struct dma_buf *buf, |
| 133 | enum dma_data_direction direction) |
| 134 | { |
| 135 | struct udmabuf *ubuf = buf->priv; |
| 136 | struct device *dev = ubuf->device->this_device; |
| 137 | |
| 138 | if (!ubuf->sg) |
| 139 | return -EINVAL; |
| 140 | |
Gurchetan Singh | 1ffe095 | 2019-12-17 15:02:28 -0800 | [diff] [blame] | 141 | dma_sync_sg_for_device(dev, ubuf->sg->sgl, ubuf->sg->nents, direction); |
Gurchetan Singh | 284562e | 2019-12-02 17:36:27 -0800 | [diff] [blame] | 142 | return 0; |
| 143 | } |
| 144 | |
Gerd Hoffmann | a348528 | 2018-09-11 15:42:07 +0200 | [diff] [blame] | 145 | static const struct dma_buf_ops udmabuf_ops = { |
Gurchetan Singh | bc7a71d | 2019-12-02 17:36:24 -0800 | [diff] [blame] | 146 | .cache_sgt_mapping = true, |
| 147 | .map_dma_buf = map_udmabuf, |
| 148 | .unmap_dma_buf = unmap_udmabuf, |
| 149 | .release = release_udmabuf, |
| 150 | .mmap = mmap_udmabuf, |
Gurchetan Singh | 284562e | 2019-12-02 17:36:27 -0800 | [diff] [blame] | 151 | .begin_cpu_access = begin_cpu_udmabuf, |
| 152 | .end_cpu_access = end_cpu_udmabuf, |
Gerd Hoffmann | fbb0de7 | 2018-08-27 11:34:44 +0200 | [diff] [blame] | 153 | }; |
| 154 | |
| 155 | #define SEALS_WANTED (F_SEAL_SHRINK) |
| 156 | #define SEALS_DENIED (F_SEAL_WRITE) |
| 157 | |
Gurchetan Singh | c1bbed6 | 2019-12-02 17:36:25 -0800 | [diff] [blame] | 158 | static long udmabuf_create(struct miscdevice *device, |
| 159 | struct udmabuf_create_list *head, |
| 160 | struct udmabuf_create_item *list) |
Gerd Hoffmann | fbb0de7 | 2018-08-27 11:34:44 +0200 | [diff] [blame] | 161 | { |
| 162 | DEFINE_DMA_BUF_EXPORT_INFO(exp_info); |
| 163 | struct file *memfd = NULL; |
| 164 | struct udmabuf *ubuf; |
| 165 | struct dma_buf *buf; |
Gerd Hoffmann | 0d17455 | 2018-09-11 15:42:11 +0200 | [diff] [blame] | 166 | pgoff_t pgoff, pgcnt, pgidx, pgbuf = 0, pglimit; |
Gerd Hoffmann | fbb0de7 | 2018-08-27 11:34:44 +0200 | [diff] [blame] | 167 | struct page *page; |
| 168 | int seals, ret = -EINVAL; |
| 169 | u32 i, flags; |
| 170 | |
Gerd Hoffmann | 33f3542 | 2018-09-11 15:42:15 +0200 | [diff] [blame] | 171 | ubuf = kzalloc(sizeof(*ubuf), GFP_KERNEL); |
Gerd Hoffmann | fbb0de7 | 2018-08-27 11:34:44 +0200 | [diff] [blame] | 172 | if (!ubuf) |
| 173 | return -ENOMEM; |
| 174 | |
Gerd Hoffmann | dc4716d | 2018-09-11 15:42:10 +0200 | [diff] [blame] | 175 | pglimit = (size_limit_mb * 1024 * 1024) >> PAGE_SHIFT; |
Gerd Hoffmann | fbb0de7 | 2018-08-27 11:34:44 +0200 | [diff] [blame] | 176 | for (i = 0; i < head->count; i++) { |
| 177 | if (!IS_ALIGNED(list[i].offset, PAGE_SIZE)) |
Gerd Hoffmann | 0d17455 | 2018-09-11 15:42:11 +0200 | [diff] [blame] | 178 | goto err; |
Gerd Hoffmann | fbb0de7 | 2018-08-27 11:34:44 +0200 | [diff] [blame] | 179 | if (!IS_ALIGNED(list[i].size, PAGE_SIZE)) |
Gerd Hoffmann | 0d17455 | 2018-09-11 15:42:11 +0200 | [diff] [blame] | 180 | goto err; |
Gerd Hoffmann | fbb0de7 | 2018-08-27 11:34:44 +0200 | [diff] [blame] | 181 | ubuf->pagecount += list[i].size >> PAGE_SHIFT; |
Gerd Hoffmann | dc4716d | 2018-09-11 15:42:10 +0200 | [diff] [blame] | 182 | if (ubuf->pagecount > pglimit) |
Gerd Hoffmann | 0d17455 | 2018-09-11 15:42:11 +0200 | [diff] [blame] | 183 | goto err; |
Gerd Hoffmann | fbb0de7 | 2018-08-27 11:34:44 +0200 | [diff] [blame] | 184 | } |
Gerd Hoffmann | 33f3542 | 2018-09-11 15:42:15 +0200 | [diff] [blame] | 185 | ubuf->pages = kmalloc_array(ubuf->pagecount, sizeof(*ubuf->pages), |
Gerd Hoffmann | fbb0de7 | 2018-08-27 11:34:44 +0200 | [diff] [blame] | 186 | GFP_KERNEL); |
| 187 | if (!ubuf->pages) { |
| 188 | ret = -ENOMEM; |
Gerd Hoffmann | 0d17455 | 2018-09-11 15:42:11 +0200 | [diff] [blame] | 189 | goto err; |
Gerd Hoffmann | fbb0de7 | 2018-08-27 11:34:44 +0200 | [diff] [blame] | 190 | } |
| 191 | |
| 192 | pgbuf = 0; |
| 193 | for (i = 0; i < head->count; i++) { |
Gerd Hoffmann | 7a1c67d | 2018-09-11 15:42:12 +0200 | [diff] [blame] | 194 | ret = -EBADFD; |
Gerd Hoffmann | fbb0de7 | 2018-08-27 11:34:44 +0200 | [diff] [blame] | 195 | memfd = fget(list[i].memfd); |
| 196 | if (!memfd) |
Gerd Hoffmann | 0d17455 | 2018-09-11 15:42:11 +0200 | [diff] [blame] | 197 | goto err; |
Gerd Hoffmann | fbb0de7 | 2018-08-27 11:34:44 +0200 | [diff] [blame] | 198 | if (!shmem_mapping(file_inode(memfd)->i_mapping)) |
Gerd Hoffmann | 0d17455 | 2018-09-11 15:42:11 +0200 | [diff] [blame] | 199 | goto err; |
Gerd Hoffmann | fbb0de7 | 2018-08-27 11:34:44 +0200 | [diff] [blame] | 200 | seals = memfd_fcntl(memfd, F_GET_SEALS, 0); |
Gerd Hoffmann | 7a1c67d | 2018-09-11 15:42:12 +0200 | [diff] [blame] | 201 | if (seals == -EINVAL) |
| 202 | goto err; |
| 203 | ret = -EINVAL; |
| 204 | if ((seals & SEALS_WANTED) != SEALS_WANTED || |
Gerd Hoffmann | fbb0de7 | 2018-08-27 11:34:44 +0200 | [diff] [blame] | 205 | (seals & SEALS_DENIED) != 0) |
Gerd Hoffmann | 0d17455 | 2018-09-11 15:42:11 +0200 | [diff] [blame] | 206 | goto err; |
Gerd Hoffmann | fbb0de7 | 2018-08-27 11:34:44 +0200 | [diff] [blame] | 207 | pgoff = list[i].offset >> PAGE_SHIFT; |
| 208 | pgcnt = list[i].size >> PAGE_SHIFT; |
| 209 | for (pgidx = 0; pgidx < pgcnt; pgidx++) { |
| 210 | page = shmem_read_mapping_page( |
| 211 | file_inode(memfd)->i_mapping, pgoff + pgidx); |
| 212 | if (IS_ERR(page)) { |
| 213 | ret = PTR_ERR(page); |
Gerd Hoffmann | 0d17455 | 2018-09-11 15:42:11 +0200 | [diff] [blame] | 214 | goto err; |
Gerd Hoffmann | fbb0de7 | 2018-08-27 11:34:44 +0200 | [diff] [blame] | 215 | } |
| 216 | ubuf->pages[pgbuf++] = page; |
| 217 | } |
| 218 | fput(memfd); |
Gerd Hoffmann | 0d17455 | 2018-09-11 15:42:11 +0200 | [diff] [blame] | 219 | memfd = NULL; |
Gerd Hoffmann | fbb0de7 | 2018-08-27 11:34:44 +0200 | [diff] [blame] | 220 | } |
Gerd Hoffmann | fbb0de7 | 2018-08-27 11:34:44 +0200 | [diff] [blame] | 221 | |
| 222 | exp_info.ops = &udmabuf_ops; |
| 223 | exp_info.size = ubuf->pagecount << PAGE_SHIFT; |
| 224 | exp_info.priv = ubuf; |
Gerd Hoffmann | 5c074ee | 2018-11-14 13:20:29 +0100 | [diff] [blame] | 225 | exp_info.flags = O_RDWR; |
Gerd Hoffmann | fbb0de7 | 2018-08-27 11:34:44 +0200 | [diff] [blame] | 226 | |
Gurchetan Singh | c1bbed6 | 2019-12-02 17:36:25 -0800 | [diff] [blame] | 227 | ubuf->device = device; |
Gerd Hoffmann | fbb0de7 | 2018-08-27 11:34:44 +0200 | [diff] [blame] | 228 | buf = dma_buf_export(&exp_info); |
| 229 | if (IS_ERR(buf)) { |
| 230 | ret = PTR_ERR(buf); |
Gerd Hoffmann | 0d17455 | 2018-09-11 15:42:11 +0200 | [diff] [blame] | 231 | goto err; |
Gerd Hoffmann | fbb0de7 | 2018-08-27 11:34:44 +0200 | [diff] [blame] | 232 | } |
| 233 | |
| 234 | flags = 0; |
| 235 | if (head->flags & UDMABUF_FLAGS_CLOEXEC) |
| 236 | flags |= O_CLOEXEC; |
| 237 | return dma_buf_fd(buf, flags); |
| 238 | |
Gerd Hoffmann | 0d17455 | 2018-09-11 15:42:11 +0200 | [diff] [blame] | 239 | err: |
Gerd Hoffmann | fbb0de7 | 2018-08-27 11:34:44 +0200 | [diff] [blame] | 240 | while (pgbuf > 0) |
| 241 | put_page(ubuf->pages[--pgbuf]); |
Gustavo A. R. Silva | 683a0e6 | 2018-09-04 14:07:49 -0500 | [diff] [blame] | 242 | if (memfd) |
| 243 | fput(memfd); |
Gerd Hoffmann | fbb0de7 | 2018-08-27 11:34:44 +0200 | [diff] [blame] | 244 | kfree(ubuf->pages); |
| 245 | kfree(ubuf); |
| 246 | return ret; |
| 247 | } |
| 248 | |
| 249 | static long udmabuf_ioctl_create(struct file *filp, unsigned long arg) |
| 250 | { |
| 251 | struct udmabuf_create create; |
| 252 | struct udmabuf_create_list head; |
| 253 | struct udmabuf_create_item list; |
| 254 | |
| 255 | if (copy_from_user(&create, (void __user *)arg, |
Gerd Hoffmann | 33f3542 | 2018-09-11 15:42:15 +0200 | [diff] [blame] | 256 | sizeof(create))) |
Gerd Hoffmann | fbb0de7 | 2018-08-27 11:34:44 +0200 | [diff] [blame] | 257 | return -EFAULT; |
| 258 | |
| 259 | head.flags = create.flags; |
| 260 | head.count = 1; |
| 261 | list.memfd = create.memfd; |
| 262 | list.offset = create.offset; |
| 263 | list.size = create.size; |
| 264 | |
Gurchetan Singh | c1bbed6 | 2019-12-02 17:36:25 -0800 | [diff] [blame] | 265 | return udmabuf_create(filp->private_data, &head, &list); |
Gerd Hoffmann | fbb0de7 | 2018-08-27 11:34:44 +0200 | [diff] [blame] | 266 | } |
| 267 | |
| 268 | static long udmabuf_ioctl_create_list(struct file *filp, unsigned long arg) |
| 269 | { |
| 270 | struct udmabuf_create_list head; |
| 271 | struct udmabuf_create_item *list; |
| 272 | int ret = -EINVAL; |
| 273 | u32 lsize; |
| 274 | |
| 275 | if (copy_from_user(&head, (void __user *)arg, sizeof(head))) |
| 276 | return -EFAULT; |
Gerd Hoffmann | dc4716d | 2018-09-11 15:42:10 +0200 | [diff] [blame] | 277 | if (head.count > list_limit) |
Gerd Hoffmann | fbb0de7 | 2018-08-27 11:34:44 +0200 | [diff] [blame] | 278 | return -EINVAL; |
| 279 | lsize = sizeof(struct udmabuf_create_item) * head.count; |
| 280 | list = memdup_user((void __user *)(arg + sizeof(head)), lsize); |
| 281 | if (IS_ERR(list)) |
| 282 | return PTR_ERR(list); |
| 283 | |
Gurchetan Singh | c1bbed6 | 2019-12-02 17:36:25 -0800 | [diff] [blame] | 284 | ret = udmabuf_create(filp->private_data, &head, list); |
Gerd Hoffmann | fbb0de7 | 2018-08-27 11:34:44 +0200 | [diff] [blame] | 285 | kfree(list); |
| 286 | return ret; |
| 287 | } |
| 288 | |
| 289 | static long udmabuf_ioctl(struct file *filp, unsigned int ioctl, |
| 290 | unsigned long arg) |
| 291 | { |
| 292 | long ret; |
| 293 | |
| 294 | switch (ioctl) { |
| 295 | case UDMABUF_CREATE: |
| 296 | ret = udmabuf_ioctl_create(filp, arg); |
| 297 | break; |
| 298 | case UDMABUF_CREATE_LIST: |
| 299 | ret = udmabuf_ioctl_create_list(filp, arg); |
| 300 | break; |
| 301 | default: |
Gerd Hoffmann | 52499d9c | 2018-09-11 15:42:13 +0200 | [diff] [blame] | 302 | ret = -ENOTTY; |
Gerd Hoffmann | fbb0de7 | 2018-08-27 11:34:44 +0200 | [diff] [blame] | 303 | break; |
| 304 | } |
| 305 | return ret; |
| 306 | } |
| 307 | |
| 308 | static const struct file_operations udmabuf_fops = { |
| 309 | .owner = THIS_MODULE, |
| 310 | .unlocked_ioctl = udmabuf_ioctl, |
| 311 | }; |
| 312 | |
| 313 | static struct miscdevice udmabuf_misc = { |
| 314 | .minor = MISC_DYNAMIC_MINOR, |
| 315 | .name = "udmabuf", |
| 316 | .fops = &udmabuf_fops, |
| 317 | }; |
| 318 | |
| 319 | static int __init udmabuf_dev_init(void) |
| 320 | { |
| 321 | return misc_register(&udmabuf_misc); |
| 322 | } |
| 323 | |
| 324 | static void __exit udmabuf_dev_exit(void) |
| 325 | { |
| 326 | misc_deregister(&udmabuf_misc); |
| 327 | } |
| 328 | |
| 329 | module_init(udmabuf_dev_init) |
| 330 | module_exit(udmabuf_dev_exit) |
| 331 | |
| 332 | MODULE_AUTHOR("Gerd Hoffmann <kraxel@redhat.com>"); |
| 333 | MODULE_LICENSE("GPL v2"); |