1 /* 2 * helper functions for vmalloc video4linux capture buffers 3 * 4 * The functions expect the hardware being able to scatter gather 5 * (i.e. the buffers are not linear in physical memory, but fragmented 6 * into PAGE_SIZE chunks). They also assume the driver does not need 7 * to touch the video data. 8 * 9 * (c) 2007 Mauro Carvalho Chehab, <mchehab@kernel.org> 10 * 11 * This program is free software; you can redistribute it and/or modify 12 * it under the terms of the GNU General Public License as published by 13 * the Free Software Foundation; either version 2 14 */ 15 16 #include <linux/init.h> 17 #include <linux/module.h> 18 #include <linux/moduleparam.h> 19 #include <linux/slab.h> 20 #include <linux/interrupt.h> 21 22 #include <linux/pci.h> 23 #include <linux/vmalloc.h> 24 #include <linux/pagemap.h> 25 #include <asm/page.h> 26 #include <asm/pgtable.h> 27 28 #include <media/videobuf-vmalloc.h> 29 30 #define MAGIC_DMABUF 0x17760309 31 #define MAGIC_VMAL_MEM 0x18221223 32 33 #define MAGIC_CHECK(is, should) \ 34 if (unlikely((is) != (should))) { \ 35 printk(KERN_ERR "magic mismatch: %x (expected %x)\n", \ 36 is, should); \ 37 BUG(); \ 38 } 39 40 static int debug; 41 module_param(debug, int, 0644); 42 43 MODULE_DESCRIPTION("helper module to manage video4linux vmalloc buffers"); 44 MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@kernel.org>"); 45 MODULE_LICENSE("GPL"); 46 47 #define dprintk(level, fmt, arg...) \ 48 if (debug >= level) \ 49 printk(KERN_DEBUG "vbuf-vmalloc: " fmt , ## arg) 50 51 52 /***************************************************************************/ 53 54 static void videobuf_vm_open(struct vm_area_struct *vma) 55 { 56 struct videobuf_mapping *map = vma->vm_private_data; 57 58 dprintk(2, "vm_open %p [count=%u,vma=%08lx-%08lx]\n", map, 59 map->count, vma->vm_start, vma->vm_end); 60 61 map->count++; 62 } 63 64 static void videobuf_vm_close(struct vm_area_struct *vma) 65 { 66 struct videobuf_mapping *map = vma->vm_private_data; 67 struct videobuf_queue *q = map->q; 68 int i; 69 70 dprintk(2, "vm_close %p [count=%u,vma=%08lx-%08lx]\n", map, 71 map->count, vma->vm_start, vma->vm_end); 72 73 map->count--; 74 if (0 == map->count) { 75 struct videobuf_vmalloc_memory *mem; 76 77 dprintk(1, "munmap %p q=%p\n", map, q); 78 videobuf_queue_lock(q); 79 80 /* We need first to cancel streams, before unmapping */ 81 if (q->streaming) 82 videobuf_queue_cancel(q); 83 84 for (i = 0; i < VIDEO_MAX_FRAME; i++) { 85 if (NULL == q->bufs[i]) 86 continue; 87 88 if (q->bufs[i]->map != map) 89 continue; 90 91 mem = q->bufs[i]->priv; 92 if (mem) { 93 /* This callback is called only if kernel has 94 allocated memory and this memory is mmapped. 95 In this case, memory should be freed, 96 in order to do memory unmap. 97 */ 98 99 MAGIC_CHECK(mem->magic, MAGIC_VMAL_MEM); 100 101 /* vfree is not atomic - can't be 102 called with IRQ's disabled 103 */ 104 dprintk(1, "%s: buf[%d] freeing (%p)\n", 105 __func__, i, mem->vaddr); 106 107 vfree(mem->vaddr); 108 mem->vaddr = NULL; 109 } 110 111 q->bufs[i]->map = NULL; 112 q->bufs[i]->baddr = 0; 113 } 114 115 kfree(map); 116 117 videobuf_queue_unlock(q); 118 } 119 120 return; 121 } 122 123 static const struct vm_operations_struct videobuf_vm_ops = { 124 .open = videobuf_vm_open, 125 .close = videobuf_vm_close, 126 }; 127 128 /* --------------------------------------------------------------------- 129 * vmalloc handlers for the generic methods 130 */ 131 132 /* Allocated area consists on 3 parts: 133 struct video_buffer 134 struct <driver>_buffer (cx88_buffer, saa7134_buf, ...) 135 struct videobuf_dma_sg_memory 136 */ 137 138 static struct videobuf_buffer *__videobuf_alloc_vb(size_t size) 139 { 140 struct videobuf_vmalloc_memory *mem; 141 struct videobuf_buffer *vb; 142 143 vb = kzalloc(size + sizeof(*mem), GFP_KERNEL); 144 if (!vb) 145 return vb; 146 147 mem = vb->priv = ((char *)vb) + size; 148 mem->magic = MAGIC_VMAL_MEM; 149 150 dprintk(1, "%s: allocated at %p(%ld+%ld) & %p(%ld)\n", 151 __func__, vb, (long)sizeof(*vb), (long)size - sizeof(*vb), 152 mem, (long)sizeof(*mem)); 153 154 return vb; 155 } 156 157 static int __videobuf_iolock(struct videobuf_queue *q, 158 struct videobuf_buffer *vb, 159 struct v4l2_framebuffer *fbuf) 160 { 161 struct videobuf_vmalloc_memory *mem = vb->priv; 162 int pages; 163 164 BUG_ON(!mem); 165 166 MAGIC_CHECK(mem->magic, MAGIC_VMAL_MEM); 167 168 switch (vb->memory) { 169 case V4L2_MEMORY_MMAP: 170 dprintk(1, "%s memory method MMAP\n", __func__); 171 172 /* All handling should be done by __videobuf_mmap_mapper() */ 173 if (!mem->vaddr) { 174 printk(KERN_ERR "memory is not allocated/mmapped.\n"); 175 return -EINVAL; 176 } 177 break; 178 case V4L2_MEMORY_USERPTR: 179 pages = PAGE_ALIGN(vb->size); 180 181 dprintk(1, "%s memory method USERPTR\n", __func__); 182 183 if (vb->baddr) { 184 printk(KERN_ERR "USERPTR is currently not supported\n"); 185 return -EINVAL; 186 } 187 188 /* The only USERPTR currently supported is the one needed for 189 * read() method. 190 */ 191 192 mem->vaddr = vmalloc_user(pages); 193 if (!mem->vaddr) { 194 printk(KERN_ERR "vmalloc (%d pages) failed\n", pages); 195 return -ENOMEM; 196 } 197 dprintk(1, "vmalloc is at addr %p (%d pages)\n", 198 mem->vaddr, pages); 199 break; 200 case V4L2_MEMORY_OVERLAY: 201 default: 202 dprintk(1, "%s memory method OVERLAY/unknown\n", __func__); 203 204 /* Currently, doesn't support V4L2_MEMORY_OVERLAY */ 205 printk(KERN_ERR "Memory method currently unsupported.\n"); 206 return -EINVAL; 207 } 208 209 return 0; 210 } 211 212 static int __videobuf_mmap_mapper(struct videobuf_queue *q, 213 struct videobuf_buffer *buf, 214 struct vm_area_struct *vma) 215 { 216 struct videobuf_vmalloc_memory *mem; 217 struct videobuf_mapping *map; 218 int retval, pages; 219 220 dprintk(1, "%s\n", __func__); 221 222 /* create mapping + update buffer list */ 223 map = kzalloc(sizeof(struct videobuf_mapping), GFP_KERNEL); 224 if (NULL == map) 225 return -ENOMEM; 226 227 buf->map = map; 228 map->q = q; 229 230 buf->baddr = vma->vm_start; 231 232 mem = buf->priv; 233 BUG_ON(!mem); 234 MAGIC_CHECK(mem->magic, MAGIC_VMAL_MEM); 235 236 pages = PAGE_ALIGN(vma->vm_end - vma->vm_start); 237 mem->vaddr = vmalloc_user(pages); 238 if (!mem->vaddr) { 239 printk(KERN_ERR "vmalloc (%d pages) failed\n", pages); 240 goto error; 241 } 242 dprintk(1, "vmalloc is at addr %p (%d pages)\n", mem->vaddr, pages); 243 244 /* Try to remap memory */ 245 retval = remap_vmalloc_range(vma, mem->vaddr, 0); 246 if (retval < 0) { 247 printk(KERN_ERR "mmap: remap failed with error %d. ", retval); 248 vfree(mem->vaddr); 249 goto error; 250 } 251 252 vma->vm_ops = &videobuf_vm_ops; 253 vma->vm_flags |= VM_DONTEXPAND | VM_DONTDUMP; 254 vma->vm_private_data = map; 255 256 dprintk(1, "mmap %p: q=%p %08lx-%08lx (%lx) pgoff %08lx buf %d\n", 257 map, q, vma->vm_start, vma->vm_end, 258 (long int)buf->bsize, 259 vma->vm_pgoff, buf->i); 260 261 videobuf_vm_open(vma); 262 263 return 0; 264 265 error: 266 mem = NULL; 267 kfree(map); 268 return -ENOMEM; 269 } 270 271 static struct videobuf_qtype_ops qops = { 272 .magic = MAGIC_QTYPE_OPS, 273 274 .alloc_vb = __videobuf_alloc_vb, 275 .iolock = __videobuf_iolock, 276 .mmap_mapper = __videobuf_mmap_mapper, 277 .vaddr = videobuf_to_vmalloc, 278 }; 279 280 void videobuf_queue_vmalloc_init(struct videobuf_queue *q, 281 const struct videobuf_queue_ops *ops, 282 struct device *dev, 283 spinlock_t *irqlock, 284 enum v4l2_buf_type type, 285 enum v4l2_field field, 286 unsigned int msize, 287 void *priv, 288 struct mutex *ext_lock) 289 { 290 videobuf_queue_core_init(q, ops, dev, irqlock, type, field, msize, 291 priv, &qops, ext_lock); 292 } 293 EXPORT_SYMBOL_GPL(videobuf_queue_vmalloc_init); 294 295 void *videobuf_to_vmalloc(struct videobuf_buffer *buf) 296 { 297 struct videobuf_vmalloc_memory *mem = buf->priv; 298 BUG_ON(!mem); 299 MAGIC_CHECK(mem->magic, MAGIC_VMAL_MEM); 300 301 return mem->vaddr; 302 } 303 EXPORT_SYMBOL_GPL(videobuf_to_vmalloc); 304 305 void videobuf_vmalloc_free(struct videobuf_buffer *buf) 306 { 307 struct videobuf_vmalloc_memory *mem = buf->priv; 308 309 /* mmapped memory can't be freed here, otherwise mmapped region 310 would be released, while still needed. In this case, the memory 311 release should happen inside videobuf_vm_close(). 312 So, it should free memory only if the memory were allocated for 313 read() operation. 314 */ 315 if ((buf->memory != V4L2_MEMORY_USERPTR) || buf->baddr) 316 return; 317 318 if (!mem) 319 return; 320 321 MAGIC_CHECK(mem->magic, MAGIC_VMAL_MEM); 322 323 vfree(mem->vaddr); 324 mem->vaddr = NULL; 325 326 return; 327 } 328 EXPORT_SYMBOL_GPL(videobuf_vmalloc_free); 329 330