1 /* 2 * videobuf2-vmalloc.c - vmalloc memory allocator for videobuf2 3 * 4 * Copyright (C) 2010 Samsung Electronics 5 * 6 * Author: Pawel Osciak <pawel@osciak.com> 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation. 11 */ 12 13 #include <linux/io.h> 14 #include <linux/module.h> 15 #include <linux/mm.h> 16 #include <linux/refcount.h> 17 #include <linux/sched.h> 18 #include <linux/slab.h> 19 #include <linux/vmalloc.h> 20 21 #include <media/videobuf2-v4l2.h> 22 #include <media/videobuf2-vmalloc.h> 23 #include <media/videobuf2-memops.h> 24 25 struct vb2_vmalloc_buf { 26 void *vaddr; 27 struct frame_vector *vec; 28 enum dma_data_direction dma_dir; 29 unsigned long size; 30 refcount_t refcount; 31 struct vb2_vmarea_handler handler; 32 struct dma_buf *dbuf; 33 }; 34 35 static void vb2_vmalloc_put(void *buf_priv); 36 37 static void *vb2_vmalloc_alloc(struct vb2_buffer *vb, struct device *dev, 38 unsigned long size) 39 { 40 struct vb2_vmalloc_buf *buf; 41 42 buf = kzalloc(sizeof(*buf), GFP_KERNEL | vb->vb2_queue->gfp_flags); 43 if (!buf) 44 return ERR_PTR(-ENOMEM); 45 46 buf->size = size; 47 buf->vaddr = vmalloc_user(buf->size); 48 if (!buf->vaddr) { 49 pr_debug("vmalloc of size %ld failed\n", buf->size); 50 kfree(buf); 51 return ERR_PTR(-ENOMEM); 52 } 53 54 buf->dma_dir = vb->vb2_queue->dma_dir; 55 buf->handler.refcount = &buf->refcount; 56 buf->handler.put = vb2_vmalloc_put; 57 buf->handler.arg = buf; 58 59 refcount_set(&buf->refcount, 1); 60 return buf; 61 } 62 63 static void vb2_vmalloc_put(void *buf_priv) 64 { 65 struct vb2_vmalloc_buf *buf = buf_priv; 66 67 if (refcount_dec_and_test(&buf->refcount)) { 68 vfree(buf->vaddr); 69 kfree(buf); 70 } 71 } 72 73 static void *vb2_vmalloc_get_userptr(struct vb2_buffer *vb, struct device *dev, 74 unsigned long vaddr, unsigned long size) 75 { 76 struct vb2_vmalloc_buf *buf; 77 struct frame_vector *vec; 78 int n_pages, offset, i; 79 int ret = -ENOMEM; 80 81 buf = kzalloc(sizeof(*buf), GFP_KERNEL); 82 if (!buf) 83 return ERR_PTR(-ENOMEM); 84 85 buf->dma_dir = vb->vb2_queue->dma_dir; 86 offset = vaddr & ~PAGE_MASK; 87 buf->size = size; 88 vec = vb2_create_framevec(vaddr, size); 89 if (IS_ERR(vec)) { 90 ret = PTR_ERR(vec); 91 goto fail_pfnvec_create; 92 } 93 buf->vec = vec; 94 n_pages = frame_vector_count(vec); 95 if (frame_vector_to_pages(vec) < 0) { 96 unsigned long *nums = frame_vector_pfns(vec); 97 98 /* 99 * We cannot get page pointers for these pfns. Check memory is 100 * physically contiguous and use direct mapping. 101 */ 102 for (i = 1; i < n_pages; i++) 103 if (nums[i-1] + 1 != nums[i]) 104 goto fail_map; 105 buf->vaddr = (__force void *) 106 ioremap(__pfn_to_phys(nums[0]), size + offset); 107 } else { 108 buf->vaddr = vm_map_ram(frame_vector_pages(vec), n_pages, -1); 109 } 110 111 if (!buf->vaddr) 112 goto fail_map; 113 buf->vaddr += offset; 114 return buf; 115 116 fail_map: 117 vb2_destroy_framevec(vec); 118 fail_pfnvec_create: 119 kfree(buf); 120 121 return ERR_PTR(ret); 122 } 123 124 static void vb2_vmalloc_put_userptr(void *buf_priv) 125 { 126 struct vb2_vmalloc_buf *buf = buf_priv; 127 unsigned long vaddr = (unsigned long)buf->vaddr & PAGE_MASK; 128 unsigned int i; 129 struct page **pages; 130 unsigned int n_pages; 131 132 if (!buf->vec->is_pfns) { 133 n_pages = frame_vector_count(buf->vec); 134 pages = frame_vector_pages(buf->vec); 135 if (vaddr) 136 vm_unmap_ram((void *)vaddr, n_pages); 137 if (buf->dma_dir == DMA_FROM_DEVICE || 138 buf->dma_dir == DMA_BIDIRECTIONAL) 139 for (i = 0; i < n_pages; i++) 140 set_page_dirty_lock(pages[i]); 141 } else { 142 iounmap((__force void __iomem *)buf->vaddr); 143 } 144 vb2_destroy_framevec(buf->vec); 145 kfree(buf); 146 } 147 148 static void *vb2_vmalloc_vaddr(struct vb2_buffer *vb, void *buf_priv) 149 { 150 struct vb2_vmalloc_buf *buf = buf_priv; 151 152 if (!buf->vaddr) { 153 pr_err("Address of an unallocated plane requested or cannot map user pointer\n"); 154 return NULL; 155 } 156 157 return buf->vaddr; 158 } 159 160 static unsigned int vb2_vmalloc_num_users(void *buf_priv) 161 { 162 struct vb2_vmalloc_buf *buf = buf_priv; 163 return refcount_read(&buf->refcount); 164 } 165 166 static int vb2_vmalloc_mmap(void *buf_priv, struct vm_area_struct *vma) 167 { 168 struct vb2_vmalloc_buf *buf = buf_priv; 169 int ret; 170 171 if (!buf) { 172 pr_err("No memory to map\n"); 173 return -EINVAL; 174 } 175 176 ret = remap_vmalloc_range(vma, buf->vaddr, 0); 177 if (ret) { 178 pr_err("Remapping vmalloc memory, error: %d\n", ret); 179 return ret; 180 } 181 182 /* 183 * Make sure that vm_areas for 2 buffers won't be merged together 184 */ 185 vma->vm_flags |= VM_DONTEXPAND; 186 187 /* 188 * Use common vm_area operations to track buffer refcount. 189 */ 190 vma->vm_private_data = &buf->handler; 191 vma->vm_ops = &vb2_common_vm_ops; 192 193 vma->vm_ops->open(vma); 194 195 return 0; 196 } 197 198 #ifdef CONFIG_HAS_DMA 199 /*********************************************/ 200 /* DMABUF ops for exporters */ 201 /*********************************************/ 202 203 struct vb2_vmalloc_attachment { 204 struct sg_table sgt; 205 enum dma_data_direction dma_dir; 206 }; 207 208 static int vb2_vmalloc_dmabuf_ops_attach(struct dma_buf *dbuf, 209 struct dma_buf_attachment *dbuf_attach) 210 { 211 struct vb2_vmalloc_attachment *attach; 212 struct vb2_vmalloc_buf *buf = dbuf->priv; 213 int num_pages = PAGE_ALIGN(buf->size) / PAGE_SIZE; 214 struct sg_table *sgt; 215 struct scatterlist *sg; 216 void *vaddr = buf->vaddr; 217 int ret; 218 int i; 219 220 attach = kzalloc(sizeof(*attach), GFP_KERNEL); 221 if (!attach) 222 return -ENOMEM; 223 224 sgt = &attach->sgt; 225 ret = sg_alloc_table(sgt, num_pages, GFP_KERNEL); 226 if (ret) { 227 kfree(attach); 228 return ret; 229 } 230 for_each_sgtable_sg(sgt, sg, i) { 231 struct page *page = vmalloc_to_page(vaddr); 232 233 if (!page) { 234 sg_free_table(sgt); 235 kfree(attach); 236 return -ENOMEM; 237 } 238 sg_set_page(sg, page, PAGE_SIZE, 0); 239 vaddr += PAGE_SIZE; 240 } 241 242 attach->dma_dir = DMA_NONE; 243 dbuf_attach->priv = attach; 244 return 0; 245 } 246 247 static void vb2_vmalloc_dmabuf_ops_detach(struct dma_buf *dbuf, 248 struct dma_buf_attachment *db_attach) 249 { 250 struct vb2_vmalloc_attachment *attach = db_attach->priv; 251 struct sg_table *sgt; 252 253 if (!attach) 254 return; 255 256 sgt = &attach->sgt; 257 258 /* release the scatterlist cache */ 259 if (attach->dma_dir != DMA_NONE) 260 dma_unmap_sgtable(db_attach->dev, sgt, attach->dma_dir, 0); 261 sg_free_table(sgt); 262 kfree(attach); 263 db_attach->priv = NULL; 264 } 265 266 static struct sg_table *vb2_vmalloc_dmabuf_ops_map( 267 struct dma_buf_attachment *db_attach, enum dma_data_direction dma_dir) 268 { 269 struct vb2_vmalloc_attachment *attach = db_attach->priv; 270 /* stealing dmabuf mutex to serialize map/unmap operations */ 271 struct mutex *lock = &db_attach->dmabuf->lock; 272 struct sg_table *sgt; 273 274 mutex_lock(lock); 275 276 sgt = &attach->sgt; 277 /* return previously mapped sg table */ 278 if (attach->dma_dir == dma_dir) { 279 mutex_unlock(lock); 280 return sgt; 281 } 282 283 /* release any previous cache */ 284 if (attach->dma_dir != DMA_NONE) { 285 dma_unmap_sgtable(db_attach->dev, sgt, attach->dma_dir, 0); 286 attach->dma_dir = DMA_NONE; 287 } 288 289 /* mapping to the client with new direction */ 290 if (dma_map_sgtable(db_attach->dev, sgt, dma_dir, 0)) { 291 pr_err("failed to map scatterlist\n"); 292 mutex_unlock(lock); 293 return ERR_PTR(-EIO); 294 } 295 296 attach->dma_dir = dma_dir; 297 298 mutex_unlock(lock); 299 300 return sgt; 301 } 302 303 static void vb2_vmalloc_dmabuf_ops_unmap(struct dma_buf_attachment *db_attach, 304 struct sg_table *sgt, enum dma_data_direction dma_dir) 305 { 306 /* nothing to be done here */ 307 } 308 309 static void vb2_vmalloc_dmabuf_ops_release(struct dma_buf *dbuf) 310 { 311 /* drop reference obtained in vb2_vmalloc_get_dmabuf */ 312 vb2_vmalloc_put(dbuf->priv); 313 } 314 315 static int vb2_vmalloc_dmabuf_ops_vmap(struct dma_buf *dbuf, 316 struct iosys_map *map) 317 { 318 struct vb2_vmalloc_buf *buf = dbuf->priv; 319 320 iosys_map_set_vaddr(map, buf->vaddr); 321 322 return 0; 323 } 324 325 static int vb2_vmalloc_dmabuf_ops_mmap(struct dma_buf *dbuf, 326 struct vm_area_struct *vma) 327 { 328 return vb2_vmalloc_mmap(dbuf->priv, vma); 329 } 330 331 static const struct dma_buf_ops vb2_vmalloc_dmabuf_ops = { 332 .attach = vb2_vmalloc_dmabuf_ops_attach, 333 .detach = vb2_vmalloc_dmabuf_ops_detach, 334 .map_dma_buf = vb2_vmalloc_dmabuf_ops_map, 335 .unmap_dma_buf = vb2_vmalloc_dmabuf_ops_unmap, 336 .vmap = vb2_vmalloc_dmabuf_ops_vmap, 337 .mmap = vb2_vmalloc_dmabuf_ops_mmap, 338 .release = vb2_vmalloc_dmabuf_ops_release, 339 }; 340 341 static struct dma_buf *vb2_vmalloc_get_dmabuf(struct vb2_buffer *vb, 342 void *buf_priv, 343 unsigned long flags) 344 { 345 struct vb2_vmalloc_buf *buf = buf_priv; 346 struct dma_buf *dbuf; 347 DEFINE_DMA_BUF_EXPORT_INFO(exp_info); 348 349 exp_info.ops = &vb2_vmalloc_dmabuf_ops; 350 exp_info.size = buf->size; 351 exp_info.flags = flags; 352 exp_info.priv = buf; 353 354 if (WARN_ON(!buf->vaddr)) 355 return NULL; 356 357 dbuf = dma_buf_export(&exp_info); 358 if (IS_ERR(dbuf)) 359 return NULL; 360 361 /* dmabuf keeps reference to vb2 buffer */ 362 refcount_inc(&buf->refcount); 363 364 return dbuf; 365 } 366 #endif /* CONFIG_HAS_DMA */ 367 368 369 /*********************************************/ 370 /* callbacks for DMABUF buffers */ 371 /*********************************************/ 372 373 static int vb2_vmalloc_map_dmabuf(void *mem_priv) 374 { 375 struct vb2_vmalloc_buf *buf = mem_priv; 376 struct iosys_map map; 377 int ret; 378 379 ret = dma_buf_vmap(buf->dbuf, &map); 380 if (ret) 381 return -EFAULT; 382 buf->vaddr = map.vaddr; 383 384 return 0; 385 } 386 387 static void vb2_vmalloc_unmap_dmabuf(void *mem_priv) 388 { 389 struct vb2_vmalloc_buf *buf = mem_priv; 390 struct iosys_map map = IOSYS_MAP_INIT_VADDR(buf->vaddr); 391 392 dma_buf_vunmap(buf->dbuf, &map); 393 buf->vaddr = NULL; 394 } 395 396 static void vb2_vmalloc_detach_dmabuf(void *mem_priv) 397 { 398 struct vb2_vmalloc_buf *buf = mem_priv; 399 struct iosys_map map = IOSYS_MAP_INIT_VADDR(buf->vaddr); 400 401 if (buf->vaddr) 402 dma_buf_vunmap(buf->dbuf, &map); 403 404 kfree(buf); 405 } 406 407 static void *vb2_vmalloc_attach_dmabuf(struct vb2_buffer *vb, 408 struct device *dev, 409 struct dma_buf *dbuf, 410 unsigned long size) 411 { 412 struct vb2_vmalloc_buf *buf; 413 414 if (dbuf->size < size) 415 return ERR_PTR(-EFAULT); 416 417 buf = kzalloc(sizeof(*buf), GFP_KERNEL); 418 if (!buf) 419 return ERR_PTR(-ENOMEM); 420 421 buf->dbuf = dbuf; 422 buf->dma_dir = vb->vb2_queue->dma_dir; 423 buf->size = size; 424 425 return buf; 426 } 427 428 429 const struct vb2_mem_ops vb2_vmalloc_memops = { 430 .alloc = vb2_vmalloc_alloc, 431 .put = vb2_vmalloc_put, 432 .get_userptr = vb2_vmalloc_get_userptr, 433 .put_userptr = vb2_vmalloc_put_userptr, 434 #ifdef CONFIG_HAS_DMA 435 .get_dmabuf = vb2_vmalloc_get_dmabuf, 436 #endif 437 .map_dmabuf = vb2_vmalloc_map_dmabuf, 438 .unmap_dmabuf = vb2_vmalloc_unmap_dmabuf, 439 .attach_dmabuf = vb2_vmalloc_attach_dmabuf, 440 .detach_dmabuf = vb2_vmalloc_detach_dmabuf, 441 .vaddr = vb2_vmalloc_vaddr, 442 .mmap = vb2_vmalloc_mmap, 443 .num_users = vb2_vmalloc_num_users, 444 }; 445 EXPORT_SYMBOL_GPL(vb2_vmalloc_memops); 446 447 MODULE_DESCRIPTION("vmalloc memory handling routines for videobuf2"); 448 MODULE_AUTHOR("Pawel Osciak <pawel@osciak.com>"); 449 MODULE_LICENSE("GPL"); 450 MODULE_IMPORT_NS(DMA_BUF); 451