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 alloced/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 200 #if 0 201 int rc; 202 /* Kernel userptr is used also by read() method. In this case, 203 there's no need to remap, since data will be copied to user 204 */ 205 if (!vb->baddr) 206 return 0; 207 208 /* FIXME: to properly support USERPTR, remap should occur. 209 The code below won't work, since mem->vma = NULL 210 */ 211 /* Try to remap memory */ 212 rc = remap_vmalloc_range(mem->vma, (void *)vb->baddr, 0); 213 if (rc < 0) { 214 printk(KERN_ERR "mmap: remap failed with error %d", rc); 215 return -ENOMEM; 216 } 217 #endif 218 219 break; 220 case V4L2_MEMORY_OVERLAY: 221 default: 222 dprintk(1, "%s memory method OVERLAY/unknown\n", __func__); 223 224 /* Currently, doesn't support V4L2_MEMORY_OVERLAY */ 225 printk(KERN_ERR "Memory method currently unsupported.\n"); 226 return -EINVAL; 227 } 228 229 return 0; 230 } 231 232 static int __videobuf_mmap_mapper(struct videobuf_queue *q, 233 struct videobuf_buffer *buf, 234 struct vm_area_struct *vma) 235 { 236 struct videobuf_vmalloc_memory *mem; 237 struct videobuf_mapping *map; 238 int retval, pages; 239 240 dprintk(1, "%s\n", __func__); 241 242 /* create mapping + update buffer list */ 243 map = kzalloc(sizeof(struct videobuf_mapping), GFP_KERNEL); 244 if (NULL == map) 245 return -ENOMEM; 246 247 buf->map = map; 248 map->q = q; 249 250 buf->baddr = vma->vm_start; 251 252 mem = buf->priv; 253 BUG_ON(!mem); 254 MAGIC_CHECK(mem->magic, MAGIC_VMAL_MEM); 255 256 pages = PAGE_ALIGN(vma->vm_end - vma->vm_start); 257 mem->vaddr = vmalloc_user(pages); 258 if (!mem->vaddr) { 259 printk(KERN_ERR "vmalloc (%d pages) failed\n", pages); 260 goto error; 261 } 262 dprintk(1, "vmalloc is at addr %p (%d pages)\n", mem->vaddr, pages); 263 264 /* Try to remap memory */ 265 retval = remap_vmalloc_range(vma, mem->vaddr, 0); 266 if (retval < 0) { 267 printk(KERN_ERR "mmap: remap failed with error %d. ", retval); 268 vfree(mem->vaddr); 269 goto error; 270 } 271 272 vma->vm_ops = &videobuf_vm_ops; 273 vma->vm_flags |= VM_DONTEXPAND | VM_DONTDUMP; 274 vma->vm_private_data = map; 275 276 dprintk(1, "mmap %p: q=%p %08lx-%08lx (%lx) pgoff %08lx buf %d\n", 277 map, q, vma->vm_start, vma->vm_end, 278 (long int)buf->bsize, 279 vma->vm_pgoff, buf->i); 280 281 videobuf_vm_open(vma); 282 283 return 0; 284 285 error: 286 mem = NULL; 287 kfree(map); 288 return -ENOMEM; 289 } 290 291 static struct videobuf_qtype_ops qops = { 292 .magic = MAGIC_QTYPE_OPS, 293 294 .alloc_vb = __videobuf_alloc_vb, 295 .iolock = __videobuf_iolock, 296 .mmap_mapper = __videobuf_mmap_mapper, 297 .vaddr = videobuf_to_vmalloc, 298 }; 299 300 void videobuf_queue_vmalloc_init(struct videobuf_queue *q, 301 const struct videobuf_queue_ops *ops, 302 struct device *dev, 303 spinlock_t *irqlock, 304 enum v4l2_buf_type type, 305 enum v4l2_field field, 306 unsigned int msize, 307 void *priv, 308 struct mutex *ext_lock) 309 { 310 videobuf_queue_core_init(q, ops, dev, irqlock, type, field, msize, 311 priv, &qops, ext_lock); 312 } 313 EXPORT_SYMBOL_GPL(videobuf_queue_vmalloc_init); 314 315 void *videobuf_to_vmalloc(struct videobuf_buffer *buf) 316 { 317 struct videobuf_vmalloc_memory *mem = buf->priv; 318 BUG_ON(!mem); 319 MAGIC_CHECK(mem->magic, MAGIC_VMAL_MEM); 320 321 return mem->vaddr; 322 } 323 EXPORT_SYMBOL_GPL(videobuf_to_vmalloc); 324 325 void videobuf_vmalloc_free(struct videobuf_buffer *buf) 326 { 327 struct videobuf_vmalloc_memory *mem = buf->priv; 328 329 /* mmapped memory can't be freed here, otherwise mmapped region 330 would be released, while still needed. In this case, the memory 331 release should happen inside videobuf_vm_close(). 332 So, it should free memory only if the memory were allocated for 333 read() operation. 334 */ 335 if ((buf->memory != V4L2_MEMORY_USERPTR) || buf->baddr) 336 return; 337 338 if (!mem) 339 return; 340 341 MAGIC_CHECK(mem->magic, MAGIC_VMAL_MEM); 342 343 vfree(mem->vaddr); 344 mem->vaddr = NULL; 345 346 return; 347 } 348 EXPORT_SYMBOL_GPL(videobuf_vmalloc_free); 349 350