Contents of /alx-src/tags/kernel26-2.6.12-alx-r9/include/media/video-buf.h
Parent Directory | Revision Log
Revision 630 -
(show annotations)
(download)
Wed Mar 4 11:03:09 2009 UTC (15 years, 3 months ago) by niro
File MIME type: text/plain
File size: 8607 byte(s)
Wed Mar 4 11:03:09 2009 UTC (15 years, 3 months ago) by niro
File MIME type: text/plain
File size: 8607 byte(s)
Tag kernel26-2.6.12-alx-r9
1 | /* |
2 | * $Id: video-buf.h,v 1.9 2004/11/07 13:17:15 kraxel Exp $ |
3 | * |
4 | * generic helper functions for video4linux capture buffers, to handle |
5 | * memory management and PCI DMA. Right now bttv + saa7134 use it. |
6 | * |
7 | * The functions expect the hardware being able to scatter gatter |
8 | * (i.e. the buffers are not linear in physical memory, but fragmented |
9 | * into PAGE_SIZE chunks). They also assume the driver does not need |
10 | * to touch the video data (thus it is probably not useful for USB as |
11 | * data often must be uncompressed by the drivers). |
12 | * |
13 | * (c) 2001,02 Gerd Knorr <kraxel@bytesex.org> |
14 | * |
15 | * This program is free software; you can redistribute it and/or modify |
16 | * it under the terms of the GNU General Public License as published by |
17 | * the Free Software Foundation; either version 2 of the License, or |
18 | * (at your option) any later version. |
19 | */ |
20 | |
21 | #include <linux/videodev.h> |
22 | |
23 | #define UNSET (-1U) |
24 | |
25 | /* --------------------------------------------------------------------- */ |
26 | |
27 | /* |
28 | * Return a scatterlist for some page-aligned vmalloc()'ed memory |
29 | * block (NULL on errors). Memory for the scatterlist is allocated |
30 | * using kmalloc. The caller must free the memory. |
31 | */ |
32 | struct scatterlist* videobuf_vmalloc_to_sg(unsigned char *virt, int nr_pages); |
33 | |
34 | /* |
35 | * Return a scatterlist for a an array of userpages (NULL on errors). |
36 | * Memory for the scatterlist is allocated using kmalloc. The caller |
37 | * must free the memory. |
38 | */ |
39 | struct scatterlist* videobuf_pages_to_sg(struct page **pages, int nr_pages, |
40 | int offset); |
41 | |
42 | /* --------------------------------------------------------------------- */ |
43 | |
44 | /* |
45 | * A small set of helper functions to manage buffers (both userland |
46 | * and kernel) for DMA. |
47 | * |
48 | * videobuf_dma_init_*() |
49 | * creates a buffer. The userland version takes a userspace |
50 | * pointer + length. The kernel version just wants the size and |
51 | * does memory allocation too using vmalloc_32(). |
52 | * |
53 | * videobuf_dma_pci_*() |
54 | * see Documentation/DMA-mapping.txt, these functions to |
55 | * basically the same. The map function does also build a |
56 | * scatterlist for the buffer (and unmap frees it ...) |
57 | * |
58 | * videobuf_dma_free() |
59 | * no comment ... |
60 | * |
61 | */ |
62 | |
63 | struct videobuf_dmabuf { |
64 | u32 magic; |
65 | |
66 | /* for userland buffer */ |
67 | int offset; |
68 | struct page **pages; |
69 | |
70 | /* for kernel buffers */ |
71 | void *vmalloc; |
72 | |
73 | /* for overlay buffers (pci-pci dma) */ |
74 | dma_addr_t bus_addr; |
75 | |
76 | /* common */ |
77 | struct scatterlist *sglist; |
78 | int sglen; |
79 | int nr_pages; |
80 | int direction; |
81 | }; |
82 | |
83 | void videobuf_dma_init(struct videobuf_dmabuf *dma); |
84 | int videobuf_dma_init_user(struct videobuf_dmabuf *dma, int direction, |
85 | unsigned long data, unsigned long size); |
86 | int videobuf_dma_init_kernel(struct videobuf_dmabuf *dma, int direction, |
87 | int nr_pages); |
88 | int videobuf_dma_init_overlay(struct videobuf_dmabuf *dma, int direction, |
89 | dma_addr_t addr, int nr_pages); |
90 | int videobuf_dma_pci_map(struct pci_dev *dev, struct videobuf_dmabuf *dma); |
91 | int videobuf_dma_pci_sync(struct pci_dev *dev, |
92 | struct videobuf_dmabuf *dma); |
93 | int videobuf_dma_pci_unmap(struct pci_dev *dev, struct videobuf_dmabuf *dma); |
94 | int videobuf_dma_free(struct videobuf_dmabuf *dma); |
95 | |
96 | /* --------------------------------------------------------------------- */ |
97 | |
98 | /* |
99 | * A small set of helper functions to manage video4linux buffers. |
100 | * |
101 | * struct videobuf_buffer holds the data structures used by the helper |
102 | * functions, additionally some commonly used fields for v4l buffers |
103 | * (width, height, lists, waitqueue) are in there. That struct should |
104 | * be used as first element in the drivers buffer struct. |
105 | * |
106 | * about the mmap helpers (videobuf_mmap_*): |
107 | * |
108 | * The mmaper function allows to map any subset of contingous buffers. |
109 | * This includes one mmap() call for all buffers (which the original |
110 | * video4linux API uses) as well as one mmap() for every single buffer |
111 | * (which v4l2 uses). |
112 | * |
113 | * If there is a valid mapping for a buffer, buffer->baddr/bsize holds |
114 | * userspace address + size which can be feeded into the |
115 | * videobuf_dma_init_user function listed above. |
116 | * |
117 | */ |
118 | |
119 | struct videobuf_buffer; |
120 | struct videobuf_queue; |
121 | |
122 | struct videobuf_mapping { |
123 | unsigned int count; |
124 | unsigned long start; |
125 | unsigned long end; |
126 | struct videobuf_queue *q; |
127 | }; |
128 | |
129 | enum videobuf_state { |
130 | STATE_NEEDS_INIT = 0, |
131 | STATE_PREPARED = 1, |
132 | STATE_QUEUED = 2, |
133 | STATE_ACTIVE = 3, |
134 | STATE_DONE = 4, |
135 | STATE_ERROR = 5, |
136 | STATE_IDLE = 6, |
137 | }; |
138 | |
139 | struct videobuf_buffer { |
140 | unsigned int i; |
141 | u32 magic; |
142 | |
143 | /* info about the buffer */ |
144 | unsigned int width; |
145 | unsigned int height; |
146 | unsigned int bytesperline; /* use only if != 0 */ |
147 | unsigned long size; |
148 | unsigned int input; |
149 | enum v4l2_field field; |
150 | enum videobuf_state state; |
151 | struct videobuf_dmabuf dma; |
152 | struct list_head stream; /* QBUF/DQBUF list */ |
153 | |
154 | /* for mmap'ed buffers */ |
155 | enum v4l2_memory memory; |
156 | size_t boff; /* buffer offset (mmap + overlay) */ |
157 | size_t bsize; /* buffer size */ |
158 | unsigned long baddr; /* buffer addr (userland ptr!) */ |
159 | struct videobuf_mapping *map; |
160 | |
161 | /* touched by irq handler */ |
162 | struct list_head queue; |
163 | wait_queue_head_t done; |
164 | unsigned int field_count; |
165 | struct timeval ts; |
166 | }; |
167 | |
168 | struct videobuf_queue_ops { |
169 | int (*buf_setup)(struct videobuf_queue *q, |
170 | unsigned int *count, unsigned int *size); |
171 | int (*buf_prepare)(struct videobuf_queue *q, |
172 | struct videobuf_buffer *vb, |
173 | enum v4l2_field field); |
174 | void (*buf_queue)(struct videobuf_queue *q, |
175 | struct videobuf_buffer *vb); |
176 | void (*buf_release)(struct videobuf_queue *q, |
177 | struct videobuf_buffer *vb); |
178 | }; |
179 | |
180 | struct videobuf_queue { |
181 | struct semaphore lock; |
182 | spinlock_t *irqlock; |
183 | struct pci_dev *pci; |
184 | |
185 | enum v4l2_buf_type type; |
186 | unsigned int inputs; /* for V4L2_BUF_FLAG_INPUT */ |
187 | unsigned int msize; |
188 | enum v4l2_field field; |
189 | enum v4l2_field last; /* for field=V4L2_FIELD_ALTERNATE */ |
190 | struct videobuf_buffer *bufs[VIDEO_MAX_FRAME]; |
191 | struct videobuf_queue_ops *ops; |
192 | |
193 | /* capture via mmap() + ioctl(QBUF/DQBUF) */ |
194 | unsigned int streaming; |
195 | struct list_head stream; |
196 | |
197 | /* capture via read() */ |
198 | unsigned int reading; |
199 | unsigned int read_off; |
200 | struct videobuf_buffer *read_buf; |
201 | |
202 | /* driver private data */ |
203 | void *priv_data; |
204 | }; |
205 | |
206 | void* videobuf_alloc(unsigned int size); |
207 | int videobuf_waiton(struct videobuf_buffer *vb, int non_blocking, int intr); |
208 | int videobuf_iolock(struct pci_dev *pci, struct videobuf_buffer *vb, |
209 | struct v4l2_framebuffer *fbuf); |
210 | |
211 | void videobuf_queue_init(struct videobuf_queue *q, |
212 | struct videobuf_queue_ops *ops, |
213 | struct pci_dev *pci, |
214 | spinlock_t *irqlock, |
215 | enum v4l2_buf_type type, |
216 | enum v4l2_field field, |
217 | unsigned int msize, |
218 | void *priv); |
219 | int videobuf_queue_is_busy(struct videobuf_queue *q); |
220 | void videobuf_queue_cancel(struct videobuf_queue *q); |
221 | |
222 | enum v4l2_field videobuf_next_field(struct videobuf_queue *q); |
223 | void videobuf_status(struct v4l2_buffer *b, struct videobuf_buffer *vb, |
224 | enum v4l2_buf_type type); |
225 | int videobuf_reqbufs(struct videobuf_queue *q, |
226 | struct v4l2_requestbuffers *req); |
227 | int videobuf_querybuf(struct videobuf_queue *q, struct v4l2_buffer *b); |
228 | int videobuf_qbuf(struct videobuf_queue *q, |
229 | struct v4l2_buffer *b); |
230 | int videobuf_dqbuf(struct videobuf_queue *q, |
231 | struct v4l2_buffer *b, int nonblocking); |
232 | int videobuf_streamon(struct videobuf_queue *q); |
233 | int videobuf_streamoff(struct videobuf_queue *q); |
234 | |
235 | int videobuf_read_start(struct videobuf_queue *q); |
236 | void videobuf_read_stop(struct videobuf_queue *q); |
237 | ssize_t videobuf_read_stream(struct videobuf_queue *q, |
238 | char __user *data, size_t count, loff_t *ppos, |
239 | int vbihack, int nonblocking); |
240 | ssize_t videobuf_read_one(struct videobuf_queue *q, |
241 | char __user *data, size_t count, loff_t *ppos, |
242 | int nonblocking); |
243 | unsigned int videobuf_poll_stream(struct file *file, |
244 | struct videobuf_queue *q, |
245 | poll_table *wait); |
246 | |
247 | int videobuf_mmap_setup(struct videobuf_queue *q, |
248 | unsigned int bcount, unsigned int bsize, |
249 | enum v4l2_memory memory); |
250 | int videobuf_mmap_free(struct videobuf_queue *q); |
251 | int videobuf_mmap_mapper(struct videobuf_queue *q, |
252 | struct vm_area_struct *vma); |
253 | |
254 | /* --------------------------------------------------------------------- */ |
255 | |
256 | /* |
257 | * Local variables: |
258 | * c-basic-offset: 8 |
259 | * End: |
260 | */ |