3 * generic helper functions for video4linux capture buffers, to handle
4 * memory management and PCI DMA. Right now bttv + saa7134 use it.
6 * The functions expect the hardware being able to scatter gatter
7 * (i.e. the buffers are not linear in physical memory, but fragmented
8 * into PAGE_SIZE chunks). They also assume the driver does not need
9 * to touch the video data (thus it is probably not useful for USB 1.1
10 * as data often must be uncompressed by the drivers).
12 * (c) 2001-2004 Gerd Knorr <kraxel@bytesex.org> [SUSE Labs]
14 * This program is free software; you can redistribute it and/or modify
15 * it under the terms of the GNU General Public License as published by
16 * the Free Software Foundation; either version 2 of the License, or
17 * (at your option) any later version.
20 #include <linux/init.h>
21 #include <linux/module.h>
22 #include <linux/moduleparam.h>
23 #include <linux/vmalloc.h>
24 #include <linux/pagemap.h>
25 #include <linux/slab.h>
26 #include <linux/pci.h>
27 #include <linux/interrupt.h>
29 #include <asm/pgtable.h>
31 #include <media/video-buf.h>
33 #define MAGIC_DMABUF 0x19721112
34 #define MAGIC_BUFFER 0x20040302
35 #define MAGIC_CHECK(is,should) if (unlikely((is) != (should))) \
36 { printk(KERN_ERR "magic mismatch: %x (expected %x)\n",is,should); BUG(); }
39 module_param(debug
, int, 0644);
41 MODULE_DESCRIPTION("helper module to manage video4linux pci dma buffers");
42 MODULE_AUTHOR("Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]");
43 MODULE_LICENSE("GPL");
45 #define dprintk(level, fmt, arg...) if (debug >= level) \
46 printk(KERN_DEBUG "vbuf: " fmt , ## arg)
49 videobuf_vmalloc_to_sg(unsigned char *virt
, int nr_pages
)
51 struct scatterlist
*sglist
;
55 sglist
= kcalloc(nr_pages
, sizeof(struct scatterlist
), GFP_KERNEL
);
58 for (i
= 0; i
< nr_pages
; i
++, virt
+= PAGE_SIZE
) {
59 pg
= vmalloc_to_page(virt
);
65 sglist
[i
].length
= PAGE_SIZE
;
75 videobuf_pages_to_sg(struct page
**pages
, int nr_pages
, int offset
)
77 struct scatterlist
*sglist
;
82 sglist
= kcalloc(nr_pages
, sizeof(*sglist
), GFP_KERNEL
);
88 if (PageHighMem(pages
[0]))
89 /* DMA to highmem pages might not work */
91 sglist
[0].page
= pages
[0];
92 sglist
[0].offset
= offset
;
93 sglist
[0].length
= PAGE_SIZE
- offset
;
94 for (i
= 1; i
< nr_pages
; i
++) {
97 if (PageHighMem(pages
[i
]))
99 sglist
[i
].page
= pages
[i
];
100 sglist
[i
].length
= PAGE_SIZE
;
105 dprintk(2,"sgl: oops - no page\n");
110 dprintk(2,"sgl: oops - highmem page\n");
115 /* --------------------------------------------------------------------- */
117 void videobuf_dma_init(struct videobuf_dmabuf
*dma
)
119 memset(dma
,0,sizeof(*dma
));
120 dma
->magic
= MAGIC_DMABUF
;
123 int videobuf_dma_init_user(struct videobuf_dmabuf
*dma
, int direction
,
124 unsigned long data
, unsigned long size
)
126 unsigned long first
,last
;
129 dma
->direction
= direction
;
130 switch (dma
->direction
) {
131 case PCI_DMA_FROMDEVICE
: rw
= READ
; break;
132 case PCI_DMA_TODEVICE
: rw
= WRITE
; break;
136 first
= (data
& PAGE_MASK
) >> PAGE_SHIFT
;
137 last
= ((data
+size
-1) & PAGE_MASK
) >> PAGE_SHIFT
;
138 dma
->offset
= data
& ~PAGE_MASK
;
139 dma
->nr_pages
= last
-first
+1;
140 dma
->pages
= kmalloc(dma
->nr_pages
* sizeof(struct page
*),
142 if (NULL
== dma
->pages
)
144 dprintk(1,"init user [0x%lx+0x%lx => %d pages]\n",
145 data
,size
,dma
->nr_pages
);
147 down_read(¤t
->mm
->mmap_sem
);
148 err
= get_user_pages(current
,current
->mm
,
149 data
& PAGE_MASK
, dma
->nr_pages
,
150 rw
== READ
, 1, /* force */
152 up_read(¤t
->mm
->mmap_sem
);
153 if (err
!= dma
->nr_pages
) {
154 dma
->nr_pages
= (err
>= 0) ? err
: 0;
155 dprintk(1,"get_user_pages: err=%d [%d]\n",err
,dma
->nr_pages
);
156 return err
< 0 ? err
: -EINVAL
;
161 int videobuf_dma_init_kernel(struct videobuf_dmabuf
*dma
, int direction
,
164 dprintk(1,"init kernel [%d pages]\n",nr_pages
);
165 dma
->direction
= direction
;
166 dma
->vmalloc
= vmalloc_32(nr_pages
<< PAGE_SHIFT
);
167 if (NULL
== dma
->vmalloc
) {
168 dprintk(1,"vmalloc_32(%d pages) failed\n",nr_pages
);
171 memset(dma
->vmalloc
,0,nr_pages
<< PAGE_SHIFT
);
172 dma
->nr_pages
= nr_pages
;
176 int videobuf_dma_init_overlay(struct videobuf_dmabuf
*dma
, int direction
,
177 dma_addr_t addr
, int nr_pages
)
179 dprintk(1,"init overlay [%d pages @ bus 0x%lx]\n",
180 nr_pages
,(unsigned long)addr
);
181 dma
->direction
= direction
;
185 dma
->bus_addr
= addr
;
186 dma
->nr_pages
= nr_pages
;
190 int videobuf_dma_pci_map(struct pci_dev
*dev
, struct videobuf_dmabuf
*dma
)
192 MAGIC_CHECK(dma
->magic
,MAGIC_DMABUF
);
193 BUG_ON(0 == dma
->nr_pages
);
196 dma
->sglist
= videobuf_pages_to_sg(dma
->pages
, dma
->nr_pages
,
200 dma
->sglist
= videobuf_vmalloc_to_sg
201 (dma
->vmalloc
,dma
->nr_pages
);
204 dma
->sglist
= kmalloc(sizeof(struct scatterlist
), GFP_KERNEL
);
205 if (NULL
!= dma
->sglist
) {
207 sg_dma_address(&dma
->sglist
[0]) = dma
->bus_addr
& PAGE_MASK
;
208 dma
->sglist
[0].offset
= dma
->bus_addr
& ~PAGE_MASK
;
209 sg_dma_len(&dma
->sglist
[0]) = dma
->nr_pages
* PAGE_SIZE
;
212 if (NULL
== dma
->sglist
) {
213 dprintk(1,"scatterlist is NULL\n");
217 if (!dma
->bus_addr
) {
218 dma
->sglen
= pci_map_sg(dev
,dma
->sglist
,dma
->nr_pages
,
220 if (0 == dma
->sglen
) {
222 "%s: pci_map_sg failed\n",__FUNCTION__
);
232 int videobuf_dma_pci_sync(struct pci_dev
*dev
, struct videobuf_dmabuf
*dma
)
234 MAGIC_CHECK(dma
->magic
,MAGIC_DMABUF
);
238 pci_dma_sync_sg_for_cpu(dev
,dma
->sglist
,dma
->nr_pages
,dma
->direction
);
242 int videobuf_dma_pci_unmap(struct pci_dev
*dev
, struct videobuf_dmabuf
*dma
)
244 MAGIC_CHECK(dma
->magic
,MAGIC_DMABUF
);
249 pci_unmap_sg(dev
,dma
->sglist
,dma
->nr_pages
,dma
->direction
);
256 int videobuf_dma_free(struct videobuf_dmabuf
*dma
)
258 MAGIC_CHECK(dma
->magic
,MAGIC_DMABUF
);
263 for (i
=0; i
< dma
->nr_pages
; i
++)
264 page_cache_release(dma
->pages
[i
]);
275 dma
->direction
= PCI_DMA_NONE
;
279 /* --------------------------------------------------------------------- */
281 void* videobuf_alloc(unsigned int size
)
283 struct videobuf_buffer
*vb
;
285 vb
= kzalloc(size
,GFP_KERNEL
);
287 videobuf_dma_init(&vb
->dma
);
288 init_waitqueue_head(&vb
->done
);
289 vb
->magic
= MAGIC_BUFFER
;
294 int videobuf_waiton(struct videobuf_buffer
*vb
, int non_blocking
, int intr
)
297 DECLARE_WAITQUEUE(wait
, current
);
299 MAGIC_CHECK(vb
->magic
,MAGIC_BUFFER
);
300 add_wait_queue(&vb
->done
, &wait
);
301 while (vb
->state
== STATE_ACTIVE
|| vb
->state
== STATE_QUEUED
) {
306 set_current_state(intr
? TASK_INTERRUPTIBLE
307 : TASK_UNINTERRUPTIBLE
);
308 if (vb
->state
== STATE_ACTIVE
|| vb
->state
== STATE_QUEUED
)
310 set_current_state(TASK_RUNNING
);
311 if (intr
&& signal_pending(current
)) {
312 dprintk(1,"buffer waiton: -EINTR\n");
317 remove_wait_queue(&vb
->done
, &wait
);
322 videobuf_iolock(struct pci_dev
*pci
, struct videobuf_buffer
*vb
,
323 struct v4l2_framebuffer
*fbuf
)
328 MAGIC_CHECK(vb
->magic
,MAGIC_BUFFER
);
329 switch (vb
->memory
) {
330 case V4L2_MEMORY_MMAP
:
331 case V4L2_MEMORY_USERPTR
:
332 if (0 == vb
->baddr
) {
333 /* no userspace addr -- kernel bounce buffer */
334 pages
= PAGE_ALIGN(vb
->size
) >> PAGE_SHIFT
;
335 err
= videobuf_dma_init_kernel(&vb
->dma
,PCI_DMA_FROMDEVICE
,
340 /* dma directly to userspace */
341 err
= videobuf_dma_init_user(&vb
->dma
,PCI_DMA_FROMDEVICE
,
342 vb
->baddr
,vb
->bsize
);
347 case V4L2_MEMORY_OVERLAY
:
350 /* FIXME: need sanity checks for vb->boff */
351 bus
= (dma_addr_t
)fbuf
->base
+ vb
->boff
;
352 pages
= PAGE_ALIGN(vb
->size
) >> PAGE_SHIFT
;
353 err
= videobuf_dma_init_overlay(&vb
->dma
,PCI_DMA_FROMDEVICE
,
361 err
= videobuf_dma_pci_map(pci
,&vb
->dma
);
368 /* --------------------------------------------------------------------- */
370 void videobuf_queue_init(struct videobuf_queue
* q
,
371 struct videobuf_queue_ops
*ops
,
374 enum v4l2_buf_type type
,
375 enum v4l2_field field
,
379 memset(q
,0,sizeof(*q
));
380 q
->irqlock
= irqlock
;
388 init_MUTEX(&q
->lock
);
389 INIT_LIST_HEAD(&q
->stream
);
393 videobuf_queue_is_busy(struct videobuf_queue
*q
)
398 dprintk(1,"busy: streaming active\n");
402 dprintk(1,"busy: pending read #1\n");
406 dprintk(1,"busy: pending read #2\n");
409 for (i
= 0; i
< VIDEO_MAX_FRAME
; i
++) {
410 if (NULL
== q
->bufs
[i
])
412 if (q
->bufs
[i
]->map
) {
413 dprintk(1,"busy: buffer #%d mapped\n",i
);
416 if (q
->bufs
[i
]->state
== STATE_QUEUED
) {
417 dprintk(1,"busy: buffer #%d queued\n",i
);
420 if (q
->bufs
[i
]->state
== STATE_ACTIVE
) {
421 dprintk(1,"busy: buffer #%d avtive\n",i
);
429 videobuf_queue_cancel(struct videobuf_queue
*q
)
434 /* remove queued buffers from list */
435 spin_lock_irqsave(q
->irqlock
,flags
);
436 for (i
= 0; i
< VIDEO_MAX_FRAME
; i
++) {
437 if (NULL
== q
->bufs
[i
])
439 if (q
->bufs
[i
]->state
== STATE_QUEUED
) {
440 list_del(&q
->bufs
[i
]->queue
);
441 q
->bufs
[i
]->state
= STATE_ERROR
;
444 spin_unlock_irqrestore(q
->irqlock
,flags
);
446 /* free all buffers + clear queue */
447 for (i
= 0; i
< VIDEO_MAX_FRAME
; i
++) {
448 if (NULL
== q
->bufs
[i
])
450 q
->ops
->buf_release(q
,q
->bufs
[i
]);
452 INIT_LIST_HEAD(&q
->stream
);
455 /* --------------------------------------------------------------------- */
458 videobuf_next_field(struct videobuf_queue
*q
)
460 enum v4l2_field field
= q
->field
;
462 BUG_ON(V4L2_FIELD_ANY
== field
);
464 if (V4L2_FIELD_ALTERNATE
== field
) {
465 if (V4L2_FIELD_TOP
== q
->last
) {
466 field
= V4L2_FIELD_BOTTOM
;
467 q
->last
= V4L2_FIELD_BOTTOM
;
469 field
= V4L2_FIELD_TOP
;
470 q
->last
= V4L2_FIELD_TOP
;
477 videobuf_status(struct v4l2_buffer
*b
, struct videobuf_buffer
*vb
,
478 enum v4l2_buf_type type
)
480 MAGIC_CHECK(vb
->magic
,MAGIC_BUFFER
);
485 b
->memory
= vb
->memory
;
487 case V4L2_MEMORY_MMAP
:
488 b
->m
.offset
= vb
->boff
;
489 b
->length
= vb
->bsize
;
491 case V4L2_MEMORY_USERPTR
:
492 b
->m
.userptr
= vb
->baddr
;
493 b
->length
= vb
->bsize
;
495 case V4L2_MEMORY_OVERLAY
:
496 b
->m
.offset
= vb
->boff
;
502 b
->flags
|= V4L2_BUF_FLAG_MAPPED
;
508 b
->flags
|= V4L2_BUF_FLAG_QUEUED
;
512 b
->flags
|= V4L2_BUF_FLAG_DONE
;
514 case STATE_NEEDS_INIT
:
520 if (vb
->input
!= UNSET
) {
521 b
->flags
|= V4L2_BUF_FLAG_INPUT
;
522 b
->input
= vb
->input
;
525 b
->field
= vb
->field
;
526 b
->timestamp
= vb
->ts
;
527 b
->bytesused
= vb
->size
;
528 b
->sequence
= vb
->field_count
>> 1;
532 videobuf_reqbufs(struct videobuf_queue
*q
,
533 struct v4l2_requestbuffers
*req
)
535 unsigned int size
,count
;
538 if (req
->type
!= q
->type
)
542 if (req
->memory
!= V4L2_MEMORY_MMAP
&&
543 req
->memory
!= V4L2_MEMORY_USERPTR
&&
544 req
->memory
!= V4L2_MEMORY_OVERLAY
)
549 if (!list_empty(&q
->stream
))
554 if (count
> VIDEO_MAX_FRAME
)
555 count
= VIDEO_MAX_FRAME
;
557 q
->ops
->buf_setup(q
,&count
,&size
);
558 size
= PAGE_ALIGN(size
);
559 dprintk(1,"reqbufs: bufs=%d, size=0x%x [%d pages total]\n",
560 count
, size
, (count
*size
)>>PAGE_SHIFT
);
562 retval
= videobuf_mmap_setup(q
,count
,size
,req
->memory
);
574 videobuf_querybuf(struct videobuf_queue
*q
, struct v4l2_buffer
*b
)
576 if (unlikely(b
->type
!= q
->type
))
578 if (unlikely(b
->index
< 0 || b
->index
>= VIDEO_MAX_FRAME
))
580 if (unlikely(NULL
== q
->bufs
[b
->index
]))
582 videobuf_status(b
,q
->bufs
[b
->index
],q
->type
);
587 videobuf_qbuf(struct videobuf_queue
*q
,
588 struct v4l2_buffer
*b
)
590 struct videobuf_buffer
*buf
;
591 enum v4l2_field field
;
600 if (b
->type
!= q
->type
)
602 if (b
->index
< 0 || b
->index
>= VIDEO_MAX_FRAME
)
604 buf
= q
->bufs
[b
->index
];
607 MAGIC_CHECK(buf
->magic
,MAGIC_BUFFER
);
608 if (buf
->memory
!= b
->memory
)
610 if (buf
->state
== STATE_QUEUED
||
611 buf
->state
== STATE_ACTIVE
)
614 if (b
->flags
& V4L2_BUF_FLAG_INPUT
) {
615 if (b
->input
>= q
->inputs
)
617 buf
->input
= b
->input
;
623 case V4L2_MEMORY_MMAP
:
627 case V4L2_MEMORY_USERPTR
:
628 if (b
->length
< buf
->bsize
)
630 if (STATE_NEEDS_INIT
!= buf
->state
&& buf
->baddr
!= b
->m
.userptr
)
631 q
->ops
->buf_release(q
,buf
);
632 buf
->baddr
= b
->m
.userptr
;
634 case V4L2_MEMORY_OVERLAY
:
635 buf
->boff
= b
->m
.offset
;
641 field
= videobuf_next_field(q
);
642 retval
= q
->ops
->buf_prepare(q
,buf
,field
);
646 list_add_tail(&buf
->stream
,&q
->stream
);
648 spin_lock_irqsave(q
->irqlock
,flags
);
649 q
->ops
->buf_queue(q
,buf
);
650 spin_unlock_irqrestore(q
->irqlock
,flags
);
660 videobuf_dqbuf(struct videobuf_queue
*q
,
661 struct v4l2_buffer
*b
, int nonblocking
)
663 struct videobuf_buffer
*buf
;
671 if (b
->type
!= q
->type
)
673 if (list_empty(&q
->stream
))
675 buf
= list_entry(q
->stream
.next
, struct videobuf_buffer
, stream
);
676 retval
= videobuf_waiton(buf
, nonblocking
, 1);
679 switch (buf
->state
) {
684 videobuf_dma_pci_sync(q
->pci
,&buf
->dma
);
685 buf
->state
= STATE_IDLE
;
691 list_del(&buf
->stream
);
692 memset(b
,0,sizeof(*b
));
693 videobuf_status(b
,buf
,q
->type
);
700 int videobuf_streamon(struct videobuf_queue
*q
)
702 struct videobuf_buffer
*buf
;
703 struct list_head
*list
;
715 spin_lock_irqsave(q
->irqlock
,flags
);
716 list_for_each(list
,&q
->stream
) {
717 buf
= list_entry(list
, struct videobuf_buffer
, stream
);
718 if (buf
->state
== STATE_PREPARED
)
719 q
->ops
->buf_queue(q
,buf
);
721 spin_unlock_irqrestore(q
->irqlock
,flags
);
728 int videobuf_streamoff(struct videobuf_queue
*q
)
730 int retval
= -EINVAL
;
735 videobuf_queue_cancel(q
);
745 videobuf_read_zerocopy(struct videobuf_queue
*q
, char __user
*data
,
746 size_t count
, loff_t
*ppos
)
748 enum v4l2_field field
;
753 q
->read_buf
= videobuf_alloc(q
->msize
);
754 if (NULL
== q
->read_buf
)
757 q
->read_buf
->memory
= V4L2_MEMORY_USERPTR
;
758 q
->read_buf
->baddr
= (unsigned long)data
;
759 q
->read_buf
->bsize
= count
;
760 field
= videobuf_next_field(q
);
761 retval
= q
->ops
->buf_prepare(q
,q
->read_buf
,field
);
765 /* start capture & wait */
766 spin_lock_irqsave(q
->irqlock
,flags
);
767 q
->ops
->buf_queue(q
,q
->read_buf
);
768 spin_unlock_irqrestore(q
->irqlock
,flags
);
769 retval
= videobuf_waiton(q
->read_buf
,0,0);
771 videobuf_dma_pci_sync(q
->pci
,&q
->read_buf
->dma
);
772 if (STATE_ERROR
== q
->read_buf
->state
)
775 retval
= q
->read_buf
->size
;
780 q
->ops
->buf_release(q
,q
->read_buf
);
786 ssize_t
videobuf_read_one(struct videobuf_queue
*q
,
787 char __user
*data
, size_t count
, loff_t
*ppos
,
790 enum v4l2_field field
;
792 unsigned size
, nbufs
, bytes
;
798 q
->ops
->buf_setup(q
,&nbufs
,&size
);
799 if (NULL
== q
->read_buf
&&
802 retval
= videobuf_read_zerocopy(q
,data
,count
,ppos
);
803 if (retval
>= 0 || retval
== -EIO
)
806 /* fallback to kernel bounce buffer on failures */
809 if (NULL
== q
->read_buf
) {
810 /* need to capture a new frame */
812 q
->read_buf
= videobuf_alloc(q
->msize
);
813 if (NULL
== q
->read_buf
)
815 q
->read_buf
->memory
= V4L2_MEMORY_USERPTR
;
816 q
->read_buf
->bsize
= count
; /* preferred size */
817 field
= videobuf_next_field(q
);
818 retval
= q
->ops
->buf_prepare(q
,q
->read_buf
,field
);
824 spin_lock_irqsave(q
->irqlock
,flags
);
825 q
->ops
->buf_queue(q
,q
->read_buf
);
826 spin_unlock_irqrestore(q
->irqlock
,flags
);
830 /* wait until capture is done */
831 retval
= videobuf_waiton(q
->read_buf
, nonblocking
, 1);
834 videobuf_dma_pci_sync(q
->pci
,&q
->read_buf
->dma
);
836 if (STATE_ERROR
== q
->read_buf
->state
) {
837 /* catch I/O errors */
838 q
->ops
->buf_release(q
,q
->read_buf
);
845 /* copy to userspace */
847 if (bytes
> q
->read_buf
->size
- q
->read_off
)
848 bytes
= q
->read_buf
->size
- q
->read_off
;
850 if (copy_to_user(data
, q
->read_buf
->dma
.vmalloc
+q
->read_off
, bytes
))
854 q
->read_off
+= bytes
;
855 if (q
->read_off
== q
->read_buf
->size
) {
856 /* all data copied, cleanup */
857 q
->ops
->buf_release(q
,q
->read_buf
);
867 int videobuf_read_start(struct videobuf_queue
*q
)
869 enum v4l2_field field
;
871 int count
= 0, size
= 0;
874 q
->ops
->buf_setup(q
,&count
,&size
);
877 if (count
> VIDEO_MAX_FRAME
)
878 count
= VIDEO_MAX_FRAME
;
879 size
= PAGE_ALIGN(size
);
881 err
= videobuf_mmap_setup(q
, count
, size
, V4L2_MEMORY_USERPTR
);
884 for (i
= 0; i
< count
; i
++) {
885 field
= videobuf_next_field(q
);
886 err
= q
->ops
->buf_prepare(q
,q
->bufs
[i
],field
);
889 list_add_tail(&q
->bufs
[i
]->stream
, &q
->stream
);
891 spin_lock_irqsave(q
->irqlock
,flags
);
892 for (i
= 0; i
< count
; i
++)
893 q
->ops
->buf_queue(q
,q
->bufs
[i
]);
894 spin_unlock_irqrestore(q
->irqlock
,flags
);
899 void videobuf_read_stop(struct videobuf_queue
*q
)
903 videobuf_queue_cancel(q
);
904 videobuf_mmap_free(q
);
905 INIT_LIST_HEAD(&q
->stream
);
906 for (i
= 0; i
< VIDEO_MAX_FRAME
; i
++) {
907 if (NULL
== q
->bufs
[i
])
916 ssize_t
videobuf_read_stream(struct videobuf_queue
*q
,
917 char __user
*data
, size_t count
, loff_t
*ppos
,
918 int vbihack
, int nonblocking
)
920 unsigned int *fc
, bytes
;
924 dprintk(2,"%s\n",__FUNCTION__
);
930 retval
= videobuf_read_start(q
);
937 /* get / wait for data */
938 if (NULL
== q
->read_buf
) {
939 q
->read_buf
= list_entry(q
->stream
.next
,
940 struct videobuf_buffer
,
942 list_del(&q
->read_buf
->stream
);
945 err
= videobuf_waiton(q
->read_buf
, nonblocking
, 1);
952 if (q
->read_buf
->state
== STATE_DONE
) {
954 /* dirty, undocumented hack -- pass the frame counter
955 * within the last four bytes of each vbi data block.
956 * We need that one to maintain backward compatibility
957 * to all vbi decoding software out there ... */
958 fc
= (unsigned int*)q
->read_buf
->dma
.vmalloc
;
959 fc
+= (q
->read_buf
->size
>>2) -1;
960 *fc
= q
->read_buf
->field_count
>> 1;
961 dprintk(1,"vbihack: %d\n",*fc
);
966 if (bytes
> q
->read_buf
->size
- q
->read_off
)
967 bytes
= q
->read_buf
->size
- q
->read_off
;
968 if (copy_to_user(data
+ retval
,
969 q
->read_buf
->dma
.vmalloc
+ q
->read_off
,
977 q
->read_off
+= bytes
;
980 q
->read_off
= q
->read_buf
->size
;
985 /* requeue buffer when done with copying */
986 if (q
->read_off
== q
->read_buf
->size
) {
987 list_add_tail(&q
->read_buf
->stream
,
989 spin_lock_irqsave(q
->irqlock
,flags
);
990 q
->ops
->buf_queue(q
,q
->read_buf
);
991 spin_unlock_irqrestore(q
->irqlock
,flags
);
1003 unsigned int videobuf_poll_stream(struct file
*file
,
1004 struct videobuf_queue
*q
,
1007 struct videobuf_buffer
*buf
= NULL
;
1008 unsigned int rc
= 0;
1012 if (!list_empty(&q
->stream
))
1013 buf
= list_entry(q
->stream
.next
,
1014 struct videobuf_buffer
, stream
);
1017 videobuf_read_start(q
);
1020 } else if (NULL
== q
->read_buf
) {
1021 q
->read_buf
= list_entry(q
->stream
.next
,
1022 struct videobuf_buffer
,
1024 list_del(&q
->read_buf
->stream
);
1033 poll_wait(file
, &buf
->done
, wait
);
1034 if (buf
->state
== STATE_DONE
||
1035 buf
->state
== STATE_ERROR
)
1036 rc
= POLLIN
|POLLRDNORM
;
1042 /* --------------------------------------------------------------------- */
1045 videobuf_vm_open(struct vm_area_struct
*vma
)
1047 struct videobuf_mapping
*map
= vma
->vm_private_data
;
1049 dprintk(2,"vm_open %p [count=%d,vma=%08lx-%08lx]\n",map
,
1050 map
->count
,vma
->vm_start
,vma
->vm_end
);
1055 videobuf_vm_close(struct vm_area_struct
*vma
)
1057 struct videobuf_mapping
*map
= vma
->vm_private_data
;
1058 struct videobuf_queue
*q
= map
->q
;
1061 dprintk(2,"vm_close %p [count=%d,vma=%08lx-%08lx]\n",map
,
1062 map
->count
,vma
->vm_start
,vma
->vm_end
);
1065 if (0 == map
->count
) {
1066 dprintk(1,"munmap %p q=%p\n",map
,q
);
1068 for (i
= 0; i
< VIDEO_MAX_FRAME
; i
++) {
1069 if (NULL
== q
->bufs
[i
])
1073 if (q
->bufs
[i
]->map
!= map
)
1075 q
->bufs
[i
]->map
= NULL
;
1076 q
->bufs
[i
]->baddr
= 0;
1077 q
->ops
->buf_release(q
,q
->bufs
[i
]);
1086 * Get a anonymous page for the mapping. Make sure we can DMA to that
1087 * memory location with 32bit PCI devices (i.e. don't use highmem for
1088 * now ...). Bounce buffers don't work very well for the data rates
1089 * video capture has.
1092 videobuf_vm_nopage(struct vm_area_struct
*vma
, unsigned long vaddr
,
1097 dprintk(3,"nopage: fault @ %08lx [vma %08lx-%08lx]\n",
1098 vaddr
,vma
->vm_start
,vma
->vm_end
);
1099 if (vaddr
> vma
->vm_end
)
1100 return NOPAGE_SIGBUS
;
1101 page
= alloc_page(GFP_USER
);
1104 clear_user_page(page_address(page
), vaddr
, page
);
1106 *type
= VM_FAULT_MINOR
;
1110 static struct vm_operations_struct videobuf_vm_ops
=
1112 .open
= videobuf_vm_open
,
1113 .close
= videobuf_vm_close
,
1114 .nopage
= videobuf_vm_nopage
,
1117 int videobuf_mmap_setup(struct videobuf_queue
*q
,
1118 unsigned int bcount
, unsigned int bsize
,
1119 enum v4l2_memory memory
)
1124 err
= videobuf_mmap_free(q
);
1128 for (i
= 0; i
< bcount
; i
++) {
1129 q
->bufs
[i
] = videobuf_alloc(q
->msize
);
1131 q
->bufs
[i
]->input
= UNSET
;
1132 q
->bufs
[i
]->memory
= memory
;
1133 q
->bufs
[i
]->bsize
= bsize
;
1135 case V4L2_MEMORY_MMAP
:
1136 q
->bufs
[i
]->boff
= bsize
* i
;
1138 case V4L2_MEMORY_USERPTR
:
1139 case V4L2_MEMORY_OVERLAY
:
1144 dprintk(1,"mmap setup: %d buffers, %d bytes each\n",
1149 int videobuf_mmap_free(struct videobuf_queue
*q
)
1153 for (i
= 0; i
< VIDEO_MAX_FRAME
; i
++)
1154 if (q
->bufs
[i
] && q
->bufs
[i
]->map
)
1156 for (i
= 0; i
< VIDEO_MAX_FRAME
; i
++) {
1157 if (NULL
== q
->bufs
[i
])
1159 q
->ops
->buf_release(q
,q
->bufs
[i
]);
1166 int videobuf_mmap_mapper(struct videobuf_queue
*q
,
1167 struct vm_area_struct
*vma
)
1169 struct videobuf_mapping
*map
;
1170 unsigned int first
,last
,size
,i
;
1175 if (!(vma
->vm_flags
& VM_WRITE
)) {
1176 dprintk(1,"mmap app bug: PROT_WRITE please\n");
1179 if (!(vma
->vm_flags
& VM_SHARED
)) {
1180 dprintk(1,"mmap app bug: MAP_SHARED please\n");
1184 /* look for first buffer to map */
1185 for (first
= 0; first
< VIDEO_MAX_FRAME
; first
++) {
1186 if (NULL
== q
->bufs
[first
])
1188 if (V4L2_MEMORY_MMAP
!= q
->bufs
[first
]->memory
)
1190 if (q
->bufs
[first
]->boff
== (vma
->vm_pgoff
<< PAGE_SHIFT
))
1193 if (VIDEO_MAX_FRAME
== first
) {
1194 dprintk(1,"mmap app bug: offset invalid [offset=0x%lx]\n",
1195 (vma
->vm_pgoff
<< PAGE_SHIFT
));
1199 /* look for last buffer to map */
1200 for (size
= 0, last
= first
; last
< VIDEO_MAX_FRAME
; last
++) {
1201 if (NULL
== q
->bufs
[last
])
1203 if (V4L2_MEMORY_MMAP
!= q
->bufs
[last
]->memory
)
1205 if (q
->bufs
[last
]->map
) {
1209 size
+= q
->bufs
[last
]->bsize
;
1210 if (size
== (vma
->vm_end
- vma
->vm_start
))
1213 if (VIDEO_MAX_FRAME
== last
) {
1214 dprintk(1,"mmap app bug: size invalid [size=0x%lx]\n",
1215 (vma
->vm_end
- vma
->vm_start
));
1219 /* create mapping + update buffer list */
1221 map
= kmalloc(sizeof(struct videobuf_mapping
),GFP_KERNEL
);
1224 for (size
= 0, i
= first
; i
<= last
; size
+= q
->bufs
[i
++]->bsize
) {
1225 q
->bufs
[i
]->map
= map
;
1226 q
->bufs
[i
]->baddr
= vma
->vm_start
+ size
;
1229 map
->start
= vma
->vm_start
;
1230 map
->end
= vma
->vm_end
;
1232 vma
->vm_ops
= &videobuf_vm_ops
;
1233 vma
->vm_flags
|= VM_DONTEXPAND
| VM_RESERVED
;
1234 vma
->vm_flags
&= ~VM_IO
; /* using shared anonymous pages */
1235 vma
->vm_private_data
= map
;
1236 dprintk(1,"mmap %p: q=%p %08lx-%08lx pgoff %08lx bufs %d-%d\n",
1237 map
,q
,vma
->vm_start
,vma
->vm_end
,vma
->vm_pgoff
,first
,last
);
1245 /* --------------------------------------------------------------------- */
1247 EXPORT_SYMBOL_GPL(videobuf_vmalloc_to_sg
);
1249 EXPORT_SYMBOL_GPL(videobuf_dma_init
);
1250 EXPORT_SYMBOL_GPL(videobuf_dma_init_user
);
1251 EXPORT_SYMBOL_GPL(videobuf_dma_init_kernel
);
1252 EXPORT_SYMBOL_GPL(videobuf_dma_init_overlay
);
1253 EXPORT_SYMBOL_GPL(videobuf_dma_pci_map
);
1254 EXPORT_SYMBOL_GPL(videobuf_dma_pci_sync
);
1255 EXPORT_SYMBOL_GPL(videobuf_dma_pci_unmap
);
1256 EXPORT_SYMBOL_GPL(videobuf_dma_free
);
1258 EXPORT_SYMBOL_GPL(videobuf_alloc
);
1259 EXPORT_SYMBOL_GPL(videobuf_waiton
);
1260 EXPORT_SYMBOL_GPL(videobuf_iolock
);
1262 EXPORT_SYMBOL_GPL(videobuf_queue_init
);
1263 EXPORT_SYMBOL_GPL(videobuf_queue_cancel
);
1264 EXPORT_SYMBOL_GPL(videobuf_queue_is_busy
);
1266 EXPORT_SYMBOL_GPL(videobuf_next_field
);
1267 EXPORT_SYMBOL_GPL(videobuf_status
);
1268 EXPORT_SYMBOL_GPL(videobuf_reqbufs
);
1269 EXPORT_SYMBOL_GPL(videobuf_querybuf
);
1270 EXPORT_SYMBOL_GPL(videobuf_qbuf
);
1271 EXPORT_SYMBOL_GPL(videobuf_dqbuf
);
1272 EXPORT_SYMBOL_GPL(videobuf_streamon
);
1273 EXPORT_SYMBOL_GPL(videobuf_streamoff
);
1275 EXPORT_SYMBOL_GPL(videobuf_read_start
);
1276 EXPORT_SYMBOL_GPL(videobuf_read_stop
);
1277 EXPORT_SYMBOL_GPL(videobuf_read_stream
);
1278 EXPORT_SYMBOL_GPL(videobuf_read_one
);
1279 EXPORT_SYMBOL_GPL(videobuf_poll_stream
);
1281 EXPORT_SYMBOL_GPL(videobuf_mmap_setup
);
1282 EXPORT_SYMBOL_GPL(videobuf_mmap_free
);
1283 EXPORT_SYMBOL_GPL(videobuf_mmap_mapper
);