SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/media/video/videobuf-vmalloc.c

   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@infradead.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@infradead.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                 mutex_lock(&q->vb_lock);
  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->vmalloc);
 106
 107                                 vfree(mem->vmalloc);
 108                                 mem->vmalloc = NULL;
 109                         }
 110
 111                         q->bufs[i]->map   = NULL;
 112                         q->bufs[i]->baddr = 0;
 113                 }
 114
 115                 kfree(map);
 116
 117                 mutex_unlock(&q->vb_lock);
 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 void *__videobuf_alloc(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->vmalloc) {
 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->vmalloc = vmalloc_user(pages);
 193                 if (!mem->vmalloc) {
 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->vmalloc, 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_sync(struct videobuf_queue *q,
 233                            struct videobuf_buffer *buf)
 234 {
 235         return 0;
 236 }
 237
 238 static int __videobuf_mmap_free(struct videobuf_queue *q)
 239 {
 240         unsigned int i;
 241
 242         dprintk(1, "%s\n", __func__);
 243         for (i = 0; i < VIDEO_MAX_FRAME; i++) {
 244                 if (q->bufs[i]) {
 245                         if (q->bufs[i]->map)
 246                                 return -EBUSY;
 247                 }
 248         }
 249
 250         return 0;
 251 }
 252
 253 static int __videobuf_mmap_mapper(struct videobuf_queue *q,
 254                          struct vm_area_struct *vma)
 255 {
 256         struct videobuf_vmalloc_memory *mem;
 257         struct videobuf_mapping *map;
 258         unsigned int first;
 259         int retval, pages;
 260         unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
 261
 262         dprintk(1, "%s\n", __func__);
 263         if (!(vma->vm_flags & VM_WRITE) || !(vma->vm_flags & VM_SHARED))
 264                 return -EINVAL;
 265
 266         /* look for first buffer to map */
 267         for (first = 0; first < VIDEO_MAX_FRAME; first++) {
 268                 if (NULL == q->bufs[first])
 269                         continue;
 270
 271                 if (V4L2_MEMORY_MMAP != q->bufs[first]->memory)
 272                         continue;
 273                 if (q->bufs[first]->boff == offset)
 274                         break;
 275         }
 276         if (VIDEO_MAX_FRAME == first) {
 277                 dprintk(1, "mmap app bug: offset invalid [offset=0x%lx]\n",
 278                         (vma->vm_pgoff << PAGE_SHIFT));
 279                 return -EINVAL;
 280         }
 281
 282         /* create mapping + update buffer list */
 283         map = kzalloc(sizeof(struct videobuf_mapping), GFP_KERNEL);
 284         if (NULL == map)
 285                 return -ENOMEM;
 286
 287         q->bufs[first]->map = map;
 288         map->start = vma->vm_start;
 289         map->end   = vma->vm_end;
 290         map->q     = q;
 291
 292         q->bufs[first]->baddr = vma->vm_start;
 293
 294         mem = q->bufs[first]->priv;
 295         BUG_ON(!mem);
 296         MAGIC_CHECK(mem->magic, MAGIC_VMAL_MEM);
 297
 298         pages = PAGE_ALIGN(vma->vm_end - vma->vm_start);
 299         mem->vmalloc = vmalloc_user(pages);
 300         if (!mem->vmalloc) {
 301                 printk(KERN_ERR "vmalloc (%d pages) failed\n", pages);
 302                 goto error;
 303         }
 304         dprintk(1, "vmalloc is at addr %p (%d pages)\n", mem->vmalloc, pages);
 305
 306         /* Try to remap memory */
 307         retval = remap_vmalloc_range(vma, mem->vmalloc, 0);
 308         if (retval < 0) {
 309                 printk(KERN_ERR "mmap: remap failed with error %d. ", retval);
 310                 vfree(mem->vmalloc);
 311                 goto error;
 312         }
 313
 314         vma->vm_ops          = &videobuf_vm_ops;
 315         vma->vm_flags       |= VM_DONTEXPAND | VM_RESERVED;
 316         vma->vm_private_data = map;
 317
 318         dprintk(1, "mmap %p: q=%p %08lx-%08lx (%lx) pgoff %08lx buf %d\n",
 319                 map, q, vma->vm_start, vma->vm_end,
 320                 (long int) q->bufs[first]->bsize,
 321                 vma->vm_pgoff, first);
 322
 323         videobuf_vm_open(vma);
 324
 325         return 0;
 326
 327 error:
 328         mem = NULL;
 329         kfree(map);
 330         return -ENOMEM;
 331 }
 332
 333 static int __videobuf_copy_to_user(struct videobuf_queue *q,
 334                                    char __user *data, size_t count,
 335                                    int nonblocking)
 336 {
 337         struct videobuf_vmalloc_memory *mem = q->read_buf->priv;
 338         BUG_ON(!mem);
 339         MAGIC_CHECK(mem->magic, MAGIC_VMAL_MEM);
 340
 341         BUG_ON(!mem->vmalloc);
 342
 343         /* copy to userspace */
 344         if (count > q->read_buf->size - q->read_off)
 345                 count = q->read_buf->size - q->read_off;
 346
 347         if (copy_to_user(data, mem->vmalloc+q->read_off, count))
 348                 return -EFAULT;
 349
 350         return count;
 351 }
 352
 353 static int __videobuf_copy_stream(struct videobuf_queue *q,
 354                                   char __user *data, size_t count, size_t pos,
 355                                   int vbihack, int nonblocking)
 356 {
 357         unsigned int *fc;
 358         struct videobuf_vmalloc_memory *mem = q->read_buf->priv;
 359         BUG_ON(!mem);
 360         MAGIC_CHECK(mem->magic, MAGIC_VMAL_MEM);
 361
 362         if (vbihack) {
 363                 /* dirty, undocumented hack -- pass the frame counter
 364                         * within the last four bytes of each vbi data block.
 365                         * We need that one to maintain backward compatibility
 366                         * to all vbi decoding software out there ... */
 367                 fc  = (unsigned int *)mem->vmalloc;
 368                 fc += (q->read_buf->size >> 2) - 1;
 369                 *fc = q->read_buf->field_count >> 1;
 370                 dprintk(1, "vbihack: %d\n", *fc);
 371         }
 372
 373         /* copy stuff using the common method */
 374         count = __videobuf_copy_to_user(q, data, count, nonblocking);
 375
 376         if ((count == -EFAULT) && (0 == pos))
 377                 return -EFAULT;
 378
 379         return count;
 380 }
 381
 382 static struct videobuf_qtype_ops qops = {
 383         .magic        = MAGIC_QTYPE_OPS,
 384
 385         .alloc        = __videobuf_alloc,
 386         .iolock       = __videobuf_iolock,
 387         .sync         = __videobuf_sync,
 388         .mmap_free    = __videobuf_mmap_free,
 389         .mmap_mapper  = __videobuf_mmap_mapper,
 390         .video_copy_to_user = __videobuf_copy_to_user,
 391         .copy_stream  = __videobuf_copy_stream,
 392         .vmalloc      = videobuf_to_vmalloc,
 393 };
 394
 395 void videobuf_queue_vmalloc_init(struct videobuf_queue *q,
 396                          const struct videobuf_queue_ops *ops,
 397                          struct device *dev,
 398                          spinlock_t *irqlock,
 399                          enum v4l2_buf_type type,
 400                          enum v4l2_field field,
 401                          unsigned int msize,
 402                          void *priv)
 403 {
 404         videobuf_queue_core_init(q, ops, dev, irqlock, type, field, msize,
 405                                  priv, &qops);
 406 }
 407 EXPORT_SYMBOL_GPL(videobuf_queue_vmalloc_init);
 408
 409 void *videobuf_to_vmalloc(struct videobuf_buffer *buf)
 410 {
 411         struct videobuf_vmalloc_memory *mem = buf->priv;
 412         BUG_ON(!mem);
 413         MAGIC_CHECK(mem->magic, MAGIC_VMAL_MEM);
 414
 415         return mem->vmalloc;
 416 }
 417 EXPORT_SYMBOL_GPL(videobuf_to_vmalloc);
 418
 419 void videobuf_vmalloc_free(struct videobuf_buffer *buf)
 420 {
 421         struct videobuf_vmalloc_memory *mem = buf->priv;
 422
 423         /* mmapped memory can't be freed here, otherwise mmapped region
 424            would be released, while still needed. In this case, the memory
 425            release should happen inside videobuf_vm_close().
 426            So, it should free memory only if the memory were allocated for
 427            read() operation.
 428          */
 429         if ((buf->memory != V4L2_MEMORY_USERPTR) || buf->baddr)
 430                 return;
 431
 432         if (!mem)
 433                 return;
 434
 435         MAGIC_CHECK(mem->magic, MAGIC_VMAL_MEM);
 436
 437         vfree(mem->vmalloc);
 438         mem->vmalloc = NULL;
 439
 440         return;
 441 }
 442 EXPORT_SYMBOL_GPL(videobuf_vmalloc_free);
 443