root/drivers/media/common/videobuf2/videobuf2-memops.c

DEFINITIONS

1. vb2_create_framevec
2. vb2_destroy_framevec
3. vb2_common_vm_open
4. vb2_common_vm_close

   1 /*
   2  * videobuf2-memops.c - generic memory handling routines for videobuf2
   3  *
   4  * Copyright (C) 2010 Samsung Electronics
   5  *
   6  * Author: Pawel Osciak <pawel@osciak.com>
   7  *         Marek Szyprowski <m.szyprowski@samsung.com>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation.
  12  */
  13 
  14 #include <linux/slab.h>
  15 #include <linux/module.h>
  16 #include <linux/dma-mapping.h>
  17 #include <linux/vmalloc.h>
  18 #include <linux/mm.h>
  19 #include <linux/sched.h>
  20 #include <linux/file.h>
  21 
  22 #include <media/videobuf2-v4l2.h>
  23 #include <media/videobuf2-memops.h>
  24 
  25 /**
  26  * vb2_create_framevec() - map virtual addresses to pfns
  27  * @start:      Virtual user address where we start mapping
  28  * @length:     Length of a range to map
  29  *
  30  * This function allocates and fills in a vector with pfns corresponding to
  31  * virtual address range passed in arguments. If pfns have corresponding pages,
  32  * page references are also grabbed to pin pages in memory. The function
  33  * returns pointer to the vector on success and error pointer in case of
  34  * failure. Returned vector needs to be freed via vb2_destroy_pfnvec().
  35  */
  36 struct frame_vector *vb2_create_framevec(unsigned long start,
  37                                          unsigned long length)
  38 {
  39         int ret;
  40         unsigned long first, last;
  41         unsigned long nr;
  42         struct frame_vector *vec;
  43         unsigned int flags = FOLL_FORCE | FOLL_WRITE;
  44 
  45         first = start >> PAGE_SHIFT;
  46         last = (start + length - 1) >> PAGE_SHIFT;
  47         nr = last - first + 1;
  48         vec = frame_vector_create(nr);
  49         if (!vec)
  50                 return ERR_PTR(-ENOMEM);
  51         ret = get_vaddr_frames(start & PAGE_MASK, nr, flags, vec);
  52         if (ret < 0)
  53                 goto out_destroy;
  54         /* We accept only complete set of PFNs */
  55         if (ret != nr) {
  56                 ret = -EFAULT;
  57                 goto out_release;
  58         }
  59         return vec;
  60 out_release:
  61         put_vaddr_frames(vec);
  62 out_destroy:
  63         frame_vector_destroy(vec);
  64         return ERR_PTR(ret);
  65 }
  66 EXPORT_SYMBOL(vb2_create_framevec);
  67 
  68 /**
  69  * vb2_destroy_framevec() - release vector of mapped pfns
  70  * @vec:        vector of pfns / pages to release
  71  *
  72  * This releases references to all pages in the vector @vec (if corresponding
  73  * pfns are backed by pages) and frees the passed vector.
  74  */
  75 void vb2_destroy_framevec(struct frame_vector *vec)
  76 {
  77         put_vaddr_frames(vec);
  78         frame_vector_destroy(vec);
  79 }
  80 EXPORT_SYMBOL(vb2_destroy_framevec);
  81 
  82 /**
  83  * vb2_common_vm_open() - increase refcount of the vma
  84  * @vma:        virtual memory region for the mapping
  85  *
  86  * This function adds another user to the provided vma. It expects
  87  * struct vb2_vmarea_handler pointer in vma->vm_private_data.
  88  */
  89 static void vb2_common_vm_open(struct vm_area_struct *vma)
  90 {
  91         struct vb2_vmarea_handler *h = vma->vm_private_data;
  92 
  93         pr_debug("%s: %p, refcount: %d, vma: %08lx-%08lx\n",
  94                __func__, h, refcount_read(h->refcount), vma->vm_start,
  95                vma->vm_end);
  96 
  97         refcount_inc(h->refcount);
  98 }
  99 
 100 /**
 101  * vb2_common_vm_close() - decrease refcount of the vma
 102  * @vma:        virtual memory region for the mapping
 103  *
 104  * This function releases the user from the provided vma. It expects
 105  * struct vb2_vmarea_handler pointer in vma->vm_private_data.
 106  */
 107 static void vb2_common_vm_close(struct vm_area_struct *vma)
 108 {
 109         struct vb2_vmarea_handler *h = vma->vm_private_data;
 110 
 111         pr_debug("%s: %p, refcount: %d, vma: %08lx-%08lx\n",
 112                __func__, h, refcount_read(h->refcount), vma->vm_start,
 113                vma->vm_end);
 114 
 115         h->put(h->arg);
 116 }
 117 
 118 /*
 119  * vb2_common_vm_ops - common vm_ops used for tracking refcount of mmapped
 120  * video buffers
 121  */
 122 const struct vm_operations_struct vb2_common_vm_ops = {
 123         .open = vb2_common_vm_open,
 124         .close = vb2_common_vm_close,
 125 };
 126 EXPORT_SYMBOL_GPL(vb2_common_vm_ops);
 127 
 128 MODULE_DESCRIPTION("common memory handling routines for videobuf2");
 129 MODULE_AUTHOR("Pawel Osciak <pawel@osciak.com>");
 130 MODULE_LICENSE("GPL");