Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * helper functions for SG DMA video4linux capture buffers
0004  *
0005  * The functions expect the hardware being able to scatter gather
0006  * (i.e. the buffers are not linear in physical memory, but fragmented
0007  * into PAGE_SIZE chunks).  They also assume the driver does not need
0008  * to touch the video data.
0009  *
0010  * (c) 2007 Mauro Carvalho Chehab, <mchehab@kernel.org>
0011  *
0012  * Highly based on video-buf written originally by:
0013  * (c) 2001,02 Gerd Knorr <kraxel@bytesex.org>
0014  * (c) 2006 Mauro Carvalho Chehab, <mchehab@kernel.org>
0015  * (c) 2006 Ted Walther and John Sokol
0016  */
0017 
0018 #include <linux/init.h>
0019 #include <linux/module.h>
0020 #include <linux/moduleparam.h>
0021 #include <linux/sched/mm.h>
0022 #include <linux/slab.h>
0023 #include <linux/interrupt.h>
0024 #include <linux/pgtable.h>
0025 
0026 #include <linux/dma-mapping.h>
0027 #include <linux/vmalloc.h>
0028 #include <linux/pagemap.h>
0029 #include <linux/scatterlist.h>
0030 #include <asm/page.h>
0031 
0032 #include <media/videobuf-dma-sg.h>
0033 
0034 #define MAGIC_DMABUF 0x19721112
0035 #define MAGIC_SG_MEM 0x17890714
0036 
0037 #define MAGIC_CHECK(is, should)                     \
0038     if (unlikely((is) != (should))) {               \
0039         printk(KERN_ERR "magic mismatch: %x (expected %x)\n",   \
0040                 is, should);                \
0041         BUG();                          \
0042     }
0043 
0044 static int debug;
0045 module_param(debug, int, 0644);
0046 
0047 MODULE_DESCRIPTION("helper module to manage video4linux dma sg buffers");
0048 MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@kernel.org>");
0049 MODULE_LICENSE("GPL");
0050 
0051 #define dprintk(level, fmt, arg...)                 \
0052     if (debug >= level)                     \
0053         printk(KERN_DEBUG "vbuf-sg: " fmt , ## arg)
0054 
0055 /* --------------------------------------------------------------------- */
0056 
0057 /*
0058  * Return a scatterlist for some page-aligned vmalloc()'ed memory
0059  * block (NULL on errors).  Memory for the scatterlist is allocated
0060  * using kmalloc.  The caller must free the memory.
0061  */
0062 static struct scatterlist *videobuf_vmalloc_to_sg(unsigned char *virt,
0063                           int nr_pages)
0064 {
0065     struct scatterlist *sglist;
0066     struct page *pg;
0067     int i;
0068 
0069     sglist = vzalloc(array_size(nr_pages, sizeof(*sglist)));
0070     if (NULL == sglist)
0071         return NULL;
0072     sg_init_table(sglist, nr_pages);
0073     for (i = 0; i < nr_pages; i++, virt += PAGE_SIZE) {
0074         pg = vmalloc_to_page(virt);
0075         if (NULL == pg)
0076             goto err;
0077         BUG_ON(PageHighMem(pg));
0078         sg_set_page(&sglist[i], pg, PAGE_SIZE, 0);
0079     }
0080     return sglist;
0081 
0082 err:
0083     vfree(sglist);
0084     return NULL;
0085 }
0086 
0087 /*
0088  * Return a scatterlist for a an array of userpages (NULL on errors).
0089  * Memory for the scatterlist is allocated using kmalloc.  The caller
0090  * must free the memory.
0091  */
0092 static struct scatterlist *videobuf_pages_to_sg(struct page **pages,
0093                     int nr_pages, int offset, size_t size)
0094 {
0095     struct scatterlist *sglist;
0096     int i;
0097 
0098     if (NULL == pages[0])
0099         return NULL;
0100     sglist = vmalloc(array_size(nr_pages, sizeof(*sglist)));
0101     if (NULL == sglist)
0102         return NULL;
0103     sg_init_table(sglist, nr_pages);
0104 
0105     if (PageHighMem(pages[0]))
0106         /* DMA to highmem pages might not work */
0107         goto highmem;
0108     sg_set_page(&sglist[0], pages[0],
0109             min_t(size_t, PAGE_SIZE - offset, size), offset);
0110     size -= min_t(size_t, PAGE_SIZE - offset, size);
0111     for (i = 1; i < nr_pages; i++) {
0112         if (NULL == pages[i])
0113             goto nopage;
0114         if (PageHighMem(pages[i]))
0115             goto highmem;
0116         sg_set_page(&sglist[i], pages[i], min_t(size_t, PAGE_SIZE, size), 0);
0117         size -= min_t(size_t, PAGE_SIZE, size);
0118     }
0119     return sglist;
0120 
0121 nopage:
0122     dprintk(2, "sgl: oops - no page\n");
0123     vfree(sglist);
0124     return NULL;
0125 
0126 highmem:
0127     dprintk(2, "sgl: oops - highmem page\n");
0128     vfree(sglist);
0129     return NULL;
0130 }
0131 
0132 /* --------------------------------------------------------------------- */
0133 
0134 struct videobuf_dmabuf *videobuf_to_dma(struct videobuf_buffer *buf)
0135 {
0136     struct videobuf_dma_sg_memory *mem = buf->priv;
0137     BUG_ON(!mem);
0138 
0139     MAGIC_CHECK(mem->magic, MAGIC_SG_MEM);
0140 
0141     return &mem->dma;
0142 }
0143 EXPORT_SYMBOL_GPL(videobuf_to_dma);
0144 
0145 static void videobuf_dma_init(struct videobuf_dmabuf *dma)
0146 {
0147     memset(dma, 0, sizeof(*dma));
0148     dma->magic = MAGIC_DMABUF;
0149 }
0150 
0151 static int videobuf_dma_init_user_locked(struct videobuf_dmabuf *dma,
0152             int direction, unsigned long data, unsigned long size)
0153 {
0154     unsigned long first, last;
0155     int err, rw = 0;
0156     unsigned int flags = FOLL_FORCE;
0157 
0158     dma->direction = direction;
0159     switch (dma->direction) {
0160     case DMA_FROM_DEVICE:
0161         rw = READ;
0162         break;
0163     case DMA_TO_DEVICE:
0164         rw = WRITE;
0165         break;
0166     default:
0167         BUG();
0168     }
0169 
0170     first = (data          & PAGE_MASK) >> PAGE_SHIFT;
0171     last  = ((data+size-1) & PAGE_MASK) >> PAGE_SHIFT;
0172     dma->offset = data & ~PAGE_MASK;
0173     dma->size = size;
0174     dma->nr_pages = last-first+1;
0175     dma->pages = kmalloc_array(dma->nr_pages, sizeof(struct page *),
0176                    GFP_KERNEL);
0177     if (NULL == dma->pages)
0178         return -ENOMEM;
0179 
0180     if (rw == READ)
0181         flags |= FOLL_WRITE;
0182 
0183     dprintk(1, "init user [0x%lx+0x%lx => %lu pages]\n",
0184         data, size, dma->nr_pages);
0185 
0186     err = pin_user_pages(data & PAGE_MASK, dma->nr_pages,
0187                  flags | FOLL_LONGTERM, dma->pages, NULL);
0188 
0189     if (err != dma->nr_pages) {
0190         dma->nr_pages = (err >= 0) ? err : 0;
0191         dprintk(1, "pin_user_pages: err=%d [%lu]\n", err,
0192             dma->nr_pages);
0193         return err < 0 ? err : -EINVAL;
0194     }
0195     return 0;
0196 }
0197 
0198 static int videobuf_dma_init_user(struct videobuf_dmabuf *dma, int direction,
0199                unsigned long data, unsigned long size)
0200 {
0201     int ret;
0202 
0203     mmap_read_lock(current->mm);
0204     ret = videobuf_dma_init_user_locked(dma, direction, data, size);
0205     mmap_read_unlock(current->mm);
0206 
0207     return ret;
0208 }
0209 
0210 static int videobuf_dma_init_kernel(struct videobuf_dmabuf *dma, int direction,
0211                     unsigned long nr_pages)
0212 {
0213     int i;
0214 
0215     dprintk(1, "init kernel [%lu pages]\n", nr_pages);
0216 
0217     dma->direction = direction;
0218     dma->vaddr_pages = kcalloc(nr_pages, sizeof(*dma->vaddr_pages),
0219                    GFP_KERNEL);
0220     if (!dma->vaddr_pages)
0221         return -ENOMEM;
0222 
0223     dma->dma_addr = kcalloc(nr_pages, sizeof(*dma->dma_addr), GFP_KERNEL);
0224     if (!dma->dma_addr) {
0225         kfree(dma->vaddr_pages);
0226         return -ENOMEM;
0227     }
0228     for (i = 0; i < nr_pages; i++) {
0229         void *addr;
0230 
0231         addr = dma_alloc_coherent(dma->dev, PAGE_SIZE,
0232                       &(dma->dma_addr[i]), GFP_KERNEL);
0233         if (addr == NULL)
0234             goto out_free_pages;
0235 
0236         dma->vaddr_pages[i] = virt_to_page(addr);
0237     }
0238     dma->vaddr = vmap(dma->vaddr_pages, nr_pages, VM_MAP | VM_IOREMAP,
0239               PAGE_KERNEL);
0240     if (NULL == dma->vaddr) {
0241         dprintk(1, "vmalloc_32(%lu pages) failed\n", nr_pages);
0242         goto out_free_pages;
0243     }
0244 
0245     dprintk(1, "vmalloc is at addr %p, size=%lu\n",
0246         dma->vaddr, nr_pages << PAGE_SHIFT);
0247 
0248     memset(dma->vaddr, 0, nr_pages << PAGE_SHIFT);
0249     dma->nr_pages = nr_pages;
0250 
0251     return 0;
0252 out_free_pages:
0253     while (i > 0) {
0254         void *addr;
0255 
0256         i--;
0257         addr = page_address(dma->vaddr_pages[i]);
0258         dma_free_coherent(dma->dev, PAGE_SIZE, addr, dma->dma_addr[i]);
0259     }
0260     kfree(dma->dma_addr);
0261     dma->dma_addr = NULL;
0262     kfree(dma->vaddr_pages);
0263     dma->vaddr_pages = NULL;
0264 
0265     return -ENOMEM;
0266 
0267 }
0268 
0269 static int videobuf_dma_init_overlay(struct videobuf_dmabuf *dma, int direction,
0270                   dma_addr_t addr, unsigned long nr_pages)
0271 {
0272     dprintk(1, "init overlay [%lu pages @ bus 0x%lx]\n",
0273         nr_pages, (unsigned long)addr);
0274     dma->direction = direction;
0275 
0276     if (0 == addr)
0277         return -EINVAL;
0278 
0279     dma->bus_addr = addr;
0280     dma->nr_pages = nr_pages;
0281 
0282     return 0;
0283 }
0284 
0285 static int videobuf_dma_map(struct device *dev, struct videobuf_dmabuf *dma)
0286 {
0287     MAGIC_CHECK(dma->magic, MAGIC_DMABUF);
0288     BUG_ON(0 == dma->nr_pages);
0289 
0290     if (dma->pages) {
0291         dma->sglist = videobuf_pages_to_sg(dma->pages, dma->nr_pages,
0292                            dma->offset, dma->size);
0293     }
0294     if (dma->vaddr) {
0295         dma->sglist = videobuf_vmalloc_to_sg(dma->vaddr,
0296                              dma->nr_pages);
0297     }
0298     if (dma->bus_addr) {
0299         dma->sglist = vmalloc(sizeof(*dma->sglist));
0300         if (NULL != dma->sglist) {
0301             dma->sglen = 1;
0302             sg_dma_address(&dma->sglist[0]) = dma->bus_addr
0303                             & PAGE_MASK;
0304             dma->sglist[0].offset = dma->bus_addr & ~PAGE_MASK;
0305             sg_dma_len(&dma->sglist[0]) = dma->nr_pages * PAGE_SIZE;
0306         }
0307     }
0308     if (NULL == dma->sglist) {
0309         dprintk(1, "scatterlist is NULL\n");
0310         return -ENOMEM;
0311     }
0312     if (!dma->bus_addr) {
0313         dma->sglen = dma_map_sg(dev, dma->sglist,
0314                     dma->nr_pages, dma->direction);
0315         if (0 == dma->sglen) {
0316             printk(KERN_WARNING
0317                    "%s: videobuf_map_sg failed\n", __func__);
0318             vfree(dma->sglist);
0319             dma->sglist = NULL;
0320             dma->sglen = 0;
0321             return -ENOMEM;
0322         }
0323     }
0324 
0325     return 0;
0326 }
0327 
0328 int videobuf_dma_unmap(struct device *dev, struct videobuf_dmabuf *dma)
0329 {
0330     MAGIC_CHECK(dma->magic, MAGIC_DMABUF);
0331 
0332     if (!dma->sglen)
0333         return 0;
0334 
0335     dma_unmap_sg(dev, dma->sglist, dma->nr_pages, dma->direction);
0336 
0337     vfree(dma->sglist);
0338     dma->sglist = NULL;
0339     dma->sglen = 0;
0340 
0341     return 0;
0342 }
0343 EXPORT_SYMBOL_GPL(videobuf_dma_unmap);
0344 
0345 int videobuf_dma_free(struct videobuf_dmabuf *dma)
0346 {
0347     int i;
0348     MAGIC_CHECK(dma->magic, MAGIC_DMABUF);
0349     BUG_ON(dma->sglen);
0350 
0351     if (dma->pages) {
0352         unpin_user_pages_dirty_lock(dma->pages, dma->nr_pages,
0353                         dma->direction == DMA_FROM_DEVICE);
0354         kfree(dma->pages);
0355         dma->pages = NULL;
0356     }
0357 
0358     if (dma->dma_addr) {
0359         for (i = 0; i < dma->nr_pages; i++) {
0360             void *addr;
0361 
0362             addr = page_address(dma->vaddr_pages[i]);
0363             dma_free_coherent(dma->dev, PAGE_SIZE, addr,
0364                       dma->dma_addr[i]);
0365         }
0366         kfree(dma->dma_addr);
0367         dma->dma_addr = NULL;
0368         kfree(dma->vaddr_pages);
0369         dma->vaddr_pages = NULL;
0370         vunmap(dma->vaddr);
0371         dma->vaddr = NULL;
0372     }
0373 
0374     if (dma->bus_addr)
0375         dma->bus_addr = 0;
0376     dma->direction = DMA_NONE;
0377 
0378     return 0;
0379 }
0380 EXPORT_SYMBOL_GPL(videobuf_dma_free);
0381 
0382 /* --------------------------------------------------------------------- */
0383 
0384 static void videobuf_vm_open(struct vm_area_struct *vma)
0385 {
0386     struct videobuf_mapping *map = vma->vm_private_data;
0387 
0388     dprintk(2, "vm_open %p [count=%d,vma=%08lx-%08lx]\n", map,
0389         map->count, vma->vm_start, vma->vm_end);
0390 
0391     map->count++;
0392 }
0393 
0394 static void videobuf_vm_close(struct vm_area_struct *vma)
0395 {
0396     struct videobuf_mapping *map = vma->vm_private_data;
0397     struct videobuf_queue *q = map->q;
0398     struct videobuf_dma_sg_memory *mem;
0399     int i;
0400 
0401     dprintk(2, "vm_close %p [count=%d,vma=%08lx-%08lx]\n", map,
0402         map->count, vma->vm_start, vma->vm_end);
0403 
0404     map->count--;
0405     if (0 == map->count) {
0406         dprintk(1, "munmap %p q=%p\n", map, q);
0407         videobuf_queue_lock(q);
0408         for (i = 0; i < VIDEO_MAX_FRAME; i++) {
0409             if (NULL == q->bufs[i])
0410                 continue;
0411             mem = q->bufs[i]->priv;
0412             if (!mem)
0413                 continue;
0414 
0415             MAGIC_CHECK(mem->magic, MAGIC_SG_MEM);
0416 
0417             if (q->bufs[i]->map != map)
0418                 continue;
0419             q->bufs[i]->map   = NULL;
0420             q->bufs[i]->baddr = 0;
0421             q->ops->buf_release(q, q->bufs[i]);
0422         }
0423         videobuf_queue_unlock(q);
0424         kfree(map);
0425     }
0426 }
0427 
0428 /*
0429  * Get a anonymous page for the mapping.  Make sure we can DMA to that
0430  * memory location with 32bit PCI devices (i.e. don't use highmem for
0431  * now ...).  Bounce buffers don't work very well for the data rates
0432  * video capture has.
0433  */
0434 static vm_fault_t videobuf_vm_fault(struct vm_fault *vmf)
0435 {
0436     struct vm_area_struct *vma = vmf->vma;
0437     struct page *page;
0438 
0439     dprintk(3, "fault: fault @ %08lx [vma %08lx-%08lx]\n",
0440         vmf->address, vma->vm_start, vma->vm_end);
0441 
0442     page = alloc_page(GFP_USER | __GFP_DMA32);
0443     if (!page)
0444         return VM_FAULT_OOM;
0445     clear_user_highpage(page, vmf->address);
0446     vmf->page = page;
0447 
0448     return 0;
0449 }
0450 
0451 static const struct vm_operations_struct videobuf_vm_ops = {
0452     .open   = videobuf_vm_open,
0453     .close  = videobuf_vm_close,
0454     .fault  = videobuf_vm_fault,
0455 };
0456 
0457 /* ---------------------------------------------------------------------
0458  * SG handlers for the generic methods
0459  */
0460 
0461 /* Allocated area consists on 3 parts:
0462     struct video_buffer
0463     struct <driver>_buffer (cx88_buffer, saa7134_buf, ...)
0464     struct videobuf_dma_sg_memory
0465  */
0466 
0467 static struct videobuf_buffer *__videobuf_alloc_vb(size_t size)
0468 {
0469     struct videobuf_dma_sg_memory *mem;
0470     struct videobuf_buffer *vb;
0471 
0472     vb = kzalloc(size + sizeof(*mem), GFP_KERNEL);
0473     if (!vb)
0474         return vb;
0475 
0476     mem = vb->priv = ((char *)vb) + size;
0477     mem->magic = MAGIC_SG_MEM;
0478 
0479     videobuf_dma_init(&mem->dma);
0480 
0481     dprintk(1, "%s: allocated at %p(%ld+%ld) & %p(%ld)\n",
0482         __func__, vb, (long)sizeof(*vb), (long)size - sizeof(*vb),
0483         mem, (long)sizeof(*mem));
0484 
0485     return vb;
0486 }
0487 
0488 static void *__videobuf_to_vaddr(struct videobuf_buffer *buf)
0489 {
0490     struct videobuf_dma_sg_memory *mem = buf->priv;
0491     BUG_ON(!mem);
0492 
0493     MAGIC_CHECK(mem->magic, MAGIC_SG_MEM);
0494 
0495     return mem->dma.vaddr;
0496 }
0497 
0498 static int __videobuf_iolock(struct videobuf_queue *q,
0499                  struct videobuf_buffer *vb,
0500                  struct v4l2_framebuffer *fbuf)
0501 {
0502     struct videobuf_dma_sg_memory *mem = vb->priv;
0503     unsigned long pages;
0504     dma_addr_t bus;
0505     int err;
0506 
0507     BUG_ON(!mem);
0508 
0509     MAGIC_CHECK(mem->magic, MAGIC_SG_MEM);
0510 
0511     if (!mem->dma.dev)
0512         mem->dma.dev = q->dev;
0513     else
0514         WARN_ON(mem->dma.dev != q->dev);
0515 
0516     switch (vb->memory) {
0517     case V4L2_MEMORY_MMAP:
0518     case V4L2_MEMORY_USERPTR:
0519         if (0 == vb->baddr) {
0520             /* no userspace addr -- kernel bounce buffer */
0521             pages = PAGE_ALIGN(vb->size) >> PAGE_SHIFT;
0522             err = videobuf_dma_init_kernel(&mem->dma,
0523                                DMA_FROM_DEVICE,
0524                                pages);
0525             if (0 != err)
0526                 return err;
0527         } else if (vb->memory == V4L2_MEMORY_USERPTR) {
0528             /* dma directly to userspace */
0529             err = videobuf_dma_init_user(&mem->dma,
0530                              DMA_FROM_DEVICE,
0531                              vb->baddr, vb->bsize);
0532             if (0 != err)
0533                 return err;
0534         } else {
0535             /* NOTE: HACK: videobuf_iolock on V4L2_MEMORY_MMAP
0536             buffers can only be called from videobuf_qbuf
0537             we take current->mm->mmap_lock there, to prevent
0538             locking inversion, so don't take it here */
0539 
0540             err = videobuf_dma_init_user_locked(&mem->dma,
0541                               DMA_FROM_DEVICE,
0542                               vb->baddr, vb->bsize);
0543             if (0 != err)
0544                 return err;
0545         }
0546         break;
0547     case V4L2_MEMORY_OVERLAY:
0548         if (NULL == fbuf)
0549             return -EINVAL;
0550         /* FIXME: need sanity checks for vb->boff */
0551         /*
0552          * Using a double cast to avoid compiler warnings when
0553          * building for PAE. Compiler doesn't like direct casting
0554          * of a 32 bit ptr to 64 bit integer.
0555          */
0556         bus   = (dma_addr_t)(unsigned long)fbuf->base + vb->boff;
0557         pages = PAGE_ALIGN(vb->size) >> PAGE_SHIFT;
0558         err = videobuf_dma_init_overlay(&mem->dma, DMA_FROM_DEVICE,
0559                         bus, pages);
0560         if (0 != err)
0561             return err;
0562         break;
0563     default:
0564         BUG();
0565     }
0566     err = videobuf_dma_map(q->dev, &mem->dma);
0567     if (0 != err)
0568         return err;
0569 
0570     return 0;
0571 }
0572 
0573 static int __videobuf_sync(struct videobuf_queue *q,
0574                struct videobuf_buffer *buf)
0575 {
0576     struct videobuf_dma_sg_memory *mem = buf->priv;
0577     BUG_ON(!mem || !mem->dma.sglen);
0578 
0579     MAGIC_CHECK(mem->magic, MAGIC_SG_MEM);
0580     MAGIC_CHECK(mem->dma.magic, MAGIC_DMABUF);
0581 
0582     dma_sync_sg_for_cpu(q->dev, mem->dma.sglist,
0583                 mem->dma.nr_pages, mem->dma.direction);
0584 
0585     return 0;
0586 }
0587 
0588 static int __videobuf_mmap_mapper(struct videobuf_queue *q,
0589                   struct videobuf_buffer *buf,
0590                   struct vm_area_struct *vma)
0591 {
0592     struct videobuf_dma_sg_memory *mem = buf->priv;
0593     struct videobuf_mapping *map;
0594     unsigned int first, last, size = 0, i;
0595     int retval;
0596 
0597     retval = -EINVAL;
0598 
0599     BUG_ON(!mem);
0600     MAGIC_CHECK(mem->magic, MAGIC_SG_MEM);
0601 
0602     /* look for first buffer to map */
0603     for (first = 0; first < VIDEO_MAX_FRAME; first++) {
0604         if (buf == q->bufs[first]) {
0605             size = PAGE_ALIGN(q->bufs[first]->bsize);
0606             break;
0607         }
0608     }
0609 
0610     /* paranoia, should never happen since buf is always valid. */
0611     if (!size) {
0612         dprintk(1, "mmap app bug: offset invalid [offset=0x%lx]\n",
0613                 (vma->vm_pgoff << PAGE_SHIFT));
0614         goto done;
0615     }
0616 
0617     last = first;
0618 
0619     /* create mapping + update buffer list */
0620     retval = -ENOMEM;
0621     map = kmalloc(sizeof(struct videobuf_mapping), GFP_KERNEL);
0622     if (NULL == map)
0623         goto done;
0624 
0625     size = 0;
0626     for (i = first; i <= last; i++) {
0627         if (NULL == q->bufs[i])
0628             continue;
0629         q->bufs[i]->map   = map;
0630         q->bufs[i]->baddr = vma->vm_start + size;
0631         size += PAGE_ALIGN(q->bufs[i]->bsize);
0632     }
0633 
0634     map->count    = 1;
0635     map->q        = q;
0636     vma->vm_ops   = &videobuf_vm_ops;
0637     vma->vm_flags |= VM_DONTEXPAND | VM_DONTDUMP;
0638     vma->vm_flags &= ~VM_IO; /* using shared anonymous pages */
0639     vma->vm_private_data = map;
0640     dprintk(1, "mmap %p: q=%p %08lx-%08lx pgoff %08lx bufs %d-%d\n",
0641         map, q, vma->vm_start, vma->vm_end, vma->vm_pgoff, first, last);
0642     retval = 0;
0643 
0644 done:
0645     return retval;
0646 }
0647 
0648 static struct videobuf_qtype_ops sg_ops = {
0649     .magic        = MAGIC_QTYPE_OPS,
0650 
0651     .alloc_vb     = __videobuf_alloc_vb,
0652     .iolock       = __videobuf_iolock,
0653     .sync         = __videobuf_sync,
0654     .mmap_mapper  = __videobuf_mmap_mapper,
0655     .vaddr        = __videobuf_to_vaddr,
0656 };
0657 
0658 void *videobuf_sg_alloc(size_t size)
0659 {
0660     struct videobuf_queue q;
0661 
0662     /* Required to make generic handler to call __videobuf_alloc */
0663     q.int_ops = &sg_ops;
0664 
0665     q.msize = size;
0666 
0667     return videobuf_alloc_vb(&q);
0668 }
0669 EXPORT_SYMBOL_GPL(videobuf_sg_alloc);
0670 
0671 void videobuf_queue_sg_init(struct videobuf_queue *q,
0672              const struct videobuf_queue_ops *ops,
0673              struct device *dev,
0674              spinlock_t *irqlock,
0675              enum v4l2_buf_type type,
0676              enum v4l2_field field,
0677              unsigned int msize,
0678              void *priv,
0679              struct mutex *ext_lock)
0680 {
0681     videobuf_queue_core_init(q, ops, dev, irqlock, type, field, msize,
0682                  priv, &sg_ops, ext_lock);
0683 }
0684 EXPORT_SYMBOL_GPL(videobuf_queue_sg_init);
0685
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!