]>
Commit | Line | Data |
---|---|---|
e0d3bafd SD |
1 | /* |
2 | cx231xx_vbi.c - driver for Conexant Cx23100/101/102 USB video capture devices | |
3 | ||
4 | Copyright (C) 2008 <srinivasa.deevi at conexant dot com> | |
84b5dbf3 | 5 | Based on cx88 driver |
e0d3bafd SD |
6 | |
7 | This program is free software; you can redistribute it and/or modify | |
8 | it under the terms of the GNU General Public License as published by | |
9 | the Free Software Foundation; either version 2 of the License, or | |
10 | (at your option) any later version. | |
11 | ||
12 | This program is distributed in the hope that it will be useful, | |
13 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 | GNU General Public License for more details. | |
16 | ||
17 | You should have received a copy of the GNU General Public License | |
18 | along with this program; if not, write to the Free Software | |
19 | Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | |
20 | */ | |
21 | ||
22 | #include <linux/init.h> | |
23 | #include <linux/list.h> | |
24 | #include <linux/module.h> | |
25 | #include <linux/kernel.h> | |
26 | #include <linux/bitmap.h> | |
27 | #include <linux/usb.h> | |
28 | #include <linux/i2c.h> | |
e0d3bafd SD |
29 | #include <linux/mm.h> |
30 | #include <linux/mutex.h> | |
5a0e3ad6 | 31 | #include <linux/slab.h> |
e0d3bafd SD |
32 | |
33 | #include <media/v4l2-common.h> | |
34 | #include <media/v4l2-ioctl.h> | |
35 | #include <media/v4l2-chip-ident.h> | |
36 | #include <media/msp3400.h> | |
37 | #include <media/tuner.h> | |
38 | ||
39 | #include "cx231xx.h" | |
40 | #include "cx231xx-vbi.h" | |
41 | ||
84b5dbf3 | 42 | static inline void print_err_status(struct cx231xx *dev, int packet, int status) |
e0d3bafd SD |
43 | { |
44 | char *errmsg = "Unknown"; | |
45 | ||
46 | switch (status) { | |
47 | case -ENOENT: | |
48 | errmsg = "unlinked synchronuously"; | |
49 | break; | |
50 | case -ECONNRESET: | |
51 | errmsg = "unlinked asynchronuously"; | |
52 | break; | |
53 | case -ENOSR: | |
54 | errmsg = "Buffer error (overrun)"; | |
55 | break; | |
56 | case -EPIPE: | |
57 | errmsg = "Stalled (device not responding)"; | |
58 | break; | |
59 | case -EOVERFLOW: | |
60 | errmsg = "Babble (bad cable?)"; | |
61 | break; | |
62 | case -EPROTO: | |
63 | errmsg = "Bit-stuff error (bad cable?)"; | |
64 | break; | |
65 | case -EILSEQ: | |
66 | errmsg = "CRC/Timeout (could be anything)"; | |
67 | break; | |
68 | case -ETIME: | |
69 | errmsg = "Device does not respond"; | |
70 | break; | |
71 | } | |
72 | if (packet < 0) { | |
84b5dbf3 MCC |
73 | cx231xx_err(DRIVER_NAME "URB status %d [%s].\n", status, |
74 | errmsg); | |
e0d3bafd SD |
75 | } else { |
76 | cx231xx_err(DRIVER_NAME "URB packet %d, status %d [%s].\n", | |
84b5dbf3 | 77 | packet, status, errmsg); |
e0d3bafd SD |
78 | } |
79 | } | |
80 | ||
81 | /* | |
82 | * Controls the isoc copy of each urb packet | |
83 | */ | |
84 | static inline int cx231xx_isoc_vbi_copy(struct cx231xx *dev, struct urb *urb) | |
85 | { | |
84b5dbf3 MCC |
86 | struct cx231xx_buffer *buf; |
87 | struct cx231xx_dmaqueue *dma_q = urb->context; | |
88 | int rc = 1; | |
e0d3bafd | 89 | unsigned char *p_buffer; |
84b5dbf3 MCC |
90 | u32 bytes_parsed = 0, buffer_size = 0; |
91 | u8 sav_eav = 0; | |
e0d3bafd SD |
92 | |
93 | if (!dev) | |
94 | return 0; | |
95 | ||
96 | if ((dev->state & DEV_DISCONNECTED) || (dev->state & DEV_MISCONFIGURED)) | |
97 | return 0; | |
98 | ||
99 | if (urb->status < 0) { | |
100 | print_err_status(dev, -1, urb->status); | |
101 | if (urb->status == -ENOENT) | |
102 | return 0; | |
103 | } | |
104 | ||
64fbf444 | 105 | buf = dev->vbi_mode.bulk_ctl.buf; |
e0d3bafd | 106 | |
84b5dbf3 MCC |
107 | /* get buffer pointer and length */ |
108 | p_buffer = urb->transfer_buffer; | |
109 | buffer_size = urb->actual_length; | |
110 | ||
111 | if (buffer_size > 0) { | |
84b5dbf3 MCC |
112 | bytes_parsed = 0; |
113 | ||
114 | if (dma_q->is_partial_line) { | |
cde4362f MCC |
115 | /* Handle the case where we were working on a partial |
116 | line */ | |
84b5dbf3 MCC |
117 | sav_eav = dma_q->last_sav; |
118 | } else { | |
cde4362f MCC |
119 | /* Check for a SAV/EAV overlapping the |
120 | buffer boundary */ | |
121 | ||
122 | sav_eav = cx231xx_find_boundary_SAV_EAV(p_buffer, | |
84b5dbf3 MCC |
123 | dma_q->partial_buf, |
124 | &bytes_parsed); | |
125 | } | |
126 | ||
127 | sav_eav &= 0xF0; | |
cde4362f MCC |
128 | /* Get the first line if we have some portion of an SAV/EAV from |
129 | the last buffer or a partial line */ | |
84b5dbf3 | 130 | if (sav_eav) { |
cde4362f MCC |
131 | bytes_parsed += cx231xx_get_vbi_line(dev, dma_q, |
132 | sav_eav, /* SAV/EAV */ | |
133 | p_buffer + bytes_parsed, /* p_buffer */ | |
134 | buffer_size - bytes_parsed); /* buffer size */ | |
84b5dbf3 MCC |
135 | } |
136 | ||
137 | /* Now parse data that is completely in this buffer */ | |
138 | dma_q->is_partial_line = 0; | |
139 | ||
140 | while (bytes_parsed < buffer_size) { | |
141 | u32 bytes_used = 0; | |
142 | ||
b9255176 SD |
143 | sav_eav = cx231xx_find_next_SAV_EAV( |
144 | p_buffer + bytes_parsed, /* p_buffer */ | |
145 | buffer_size - bytes_parsed, /* buffer size */ | |
146 | &bytes_used); /* bytes used to get SAV/EAV */ | |
84b5dbf3 MCC |
147 | |
148 | bytes_parsed += bytes_used; | |
149 | ||
150 | sav_eav &= 0xF0; | |
151 | if (sav_eav && (bytes_parsed < buffer_size)) { | |
cde4362f | 152 | bytes_parsed += cx231xx_get_vbi_line(dev, |
b9255176 SD |
153 | dma_q, sav_eav, /* SAV/EAV */ |
154 | p_buffer+bytes_parsed, /* p_buffer */ | |
155 | buffer_size-bytes_parsed);/*buf size*/ | |
84b5dbf3 MCC |
156 | } |
157 | } | |
158 | ||
b9255176 SD |
159 | /* Save the last four bytes of the buffer so we can |
160 | check the buffer boundary condition next time */ | |
84b5dbf3 MCC |
161 | memcpy(dma_q->partial_buf, p_buffer + buffer_size - 4, 4); |
162 | bytes_parsed = 0; | |
e0d3bafd SD |
163 | } |
164 | ||
165 | return rc; | |
166 | } | |
167 | ||
168 | /* ------------------------------------------------------------------ | |
169 | Vbi buf operations | |
170 | ------------------------------------------------------------------*/ | |
171 | ||
172 | static int | |
84b5dbf3 MCC |
173 | vbi_buffer_setup(struct videobuf_queue *vq, unsigned int *count, |
174 | unsigned int *size) | |
e0d3bafd SD |
175 | { |
176 | struct cx231xx_fh *fh = vq->priv_data; | |
84b5dbf3 MCC |
177 | struct cx231xx *dev = fh->dev; |
178 | u32 height = 0; | |
e0d3bafd SD |
179 | |
180 | height = ((dev->norm & V4L2_STD_625_50) ? | |
84b5dbf3 | 181 | PAL_VBI_LINES : NTSC_VBI_LINES); |
e0d3bafd | 182 | |
99d35a0e | 183 | *size = (dev->width * height * 2 * 2); |
e0d3bafd SD |
184 | if (0 == *count) |
185 | *count = CX231XX_DEF_VBI_BUF; | |
186 | ||
187 | if (*count < CX231XX_MIN_BUF) | |
188 | *count = CX231XX_MIN_BUF; | |
189 | ||
e0d3bafd SD |
190 | return 0; |
191 | } | |
192 | ||
193 | /* This is called *without* dev->slock held; please keep it that way */ | |
194 | static void free_buffer(struct videobuf_queue *vq, struct cx231xx_buffer *buf) | |
195 | { | |
84b5dbf3 MCC |
196 | struct cx231xx_fh *fh = vq->priv_data; |
197 | struct cx231xx *dev = fh->dev; | |
e0d3bafd SD |
198 | unsigned long flags = 0; |
199 | if (in_interrupt()) | |
200 | BUG(); | |
201 | ||
202 | /* We used to wait for the buffer to finish here, but this didn't work | |
203 | because, as we were keeping the state as VIDEOBUF_QUEUED, | |
204 | videobuf_queue_cancel marked it as finished for us. | |
205 | (Also, it could wedge forever if the hardware was misconfigured.) | |
206 | ||
207 | This should be safe; by the time we get here, the buffer isn't | |
208 | queued anymore. If we ever start marking the buffers as | |
209 | VIDEOBUF_ACTIVE, it won't be, though. | |
84b5dbf3 | 210 | */ |
e0d3bafd | 211 | spin_lock_irqsave(&dev->vbi_mode.slock, flags); |
64fbf444 PB |
212 | if (dev->vbi_mode.bulk_ctl.buf == buf) |
213 | dev->vbi_mode.bulk_ctl.buf = NULL; | |
e0d3bafd SD |
214 | spin_unlock_irqrestore(&dev->vbi_mode.slock, flags); |
215 | ||
216 | videobuf_vmalloc_free(&buf->vb); | |
217 | buf->vb.state = VIDEOBUF_NEEDS_INIT; | |
218 | } | |
219 | ||
220 | static int | |
221 | vbi_buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb, | |
84b5dbf3 | 222 | enum v4l2_field field) |
e0d3bafd | 223 | { |
84b5dbf3 MCC |
224 | struct cx231xx_fh *fh = vq->priv_data; |
225 | struct cx231xx_buffer *buf = | |
226 | container_of(vb, struct cx231xx_buffer, vb); | |
227 | struct cx231xx *dev = fh->dev; | |
228 | int rc = 0, urb_init = 0; | |
229 | u32 height = 0; | |
e0d3bafd SD |
230 | |
231 | height = ((dev->norm & V4L2_STD_625_50) ? | |
84b5dbf3 | 232 | PAL_VBI_LINES : NTSC_VBI_LINES); |
99d35a0e | 233 | buf->vb.size = ((dev->width << 1) * height * 2); |
e0d3bafd | 234 | |
84b5dbf3 | 235 | if (0 != buf->vb.baddr && buf->vb.bsize < buf->vb.size) |
e0d3bafd SD |
236 | return -EINVAL; |
237 | ||
84b5dbf3 | 238 | buf->vb.width = dev->width; |
e0d3bafd | 239 | buf->vb.height = height; |
84b5dbf3 MCC |
240 | buf->vb.field = field; |
241 | buf->vb.field = V4L2_FIELD_SEQ_TB; | |
e0d3bafd SD |
242 | |
243 | if (VIDEOBUF_NEEDS_INIT == buf->vb.state) { | |
244 | rc = videobuf_iolock(vq, &buf->vb, NULL); | |
245 | if (rc < 0) | |
246 | goto fail; | |
247 | } | |
248 | ||
64fbf444 | 249 | if (!dev->vbi_mode.bulk_ctl.num_bufs) |
e0d3bafd SD |
250 | urb_init = 1; |
251 | ||
252 | if (urb_init) { | |
253 | rc = cx231xx_init_vbi_isoc(dev, CX231XX_NUM_VBI_PACKETS, | |
84b5dbf3 MCC |
254 | CX231XX_NUM_VBI_BUFS, |
255 | dev->vbi_mode.alt_max_pkt_size[0], | |
256 | cx231xx_isoc_vbi_copy); | |
e0d3bafd SD |
257 | if (rc < 0) |
258 | goto fail; | |
259 | } | |
260 | ||
261 | buf->vb.state = VIDEOBUF_PREPARED; | |
262 | return 0; | |
263 | ||
cde4362f | 264 | fail: |
e0d3bafd SD |
265 | free_buffer(vq, buf); |
266 | return rc; | |
267 | } | |
268 | ||
269 | static void | |
270 | vbi_buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb) | |
271 | { | |
84b5dbf3 MCC |
272 | struct cx231xx_buffer *buf = |
273 | container_of(vb, struct cx231xx_buffer, vb); | |
274 | struct cx231xx_fh *fh = vq->priv_data; | |
275 | struct cx231xx *dev = fh->dev; | |
276 | struct cx231xx_dmaqueue *vidq = &dev->vbi_mode.vidq; | |
e0d3bafd SD |
277 | |
278 | buf->vb.state = VIDEOBUF_QUEUED; | |
279 | list_add_tail(&buf->vb.queue, &vidq->active); | |
280 | ||
281 | } | |
282 | ||
283 | static void vbi_buffer_release(struct videobuf_queue *vq, | |
84b5dbf3 | 284 | struct videobuf_buffer *vb) |
e0d3bafd | 285 | { |
84b5dbf3 MCC |
286 | struct cx231xx_buffer *buf = |
287 | container_of(vb, struct cx231xx_buffer, vb); | |
e0d3bafd | 288 | |
e0d3bafd SD |
289 | |
290 | free_buffer(vq, buf); | |
291 | } | |
292 | ||
e0d3bafd | 293 | struct videobuf_queue_ops cx231xx_vbi_qops = { |
cde4362f | 294 | .buf_setup = vbi_buffer_setup, |
84b5dbf3 | 295 | .buf_prepare = vbi_buffer_prepare, |
cde4362f | 296 | .buf_queue = vbi_buffer_queue, |
84b5dbf3 | 297 | .buf_release = vbi_buffer_release, |
e0d3bafd SD |
298 | }; |
299 | ||
e0d3bafd SD |
300 | /* ------------------------------------------------------------------ |
301 | URB control | |
302 | ------------------------------------------------------------------*/ | |
303 | ||
304 | /* | |
305 | * IRQ callback, called by URB callback | |
306 | */ | |
307 | static void cx231xx_irq_vbi_callback(struct urb *urb) | |
308 | { | |
84b5dbf3 MCC |
309 | struct cx231xx_dmaqueue *dma_q = urb->context; |
310 | struct cx231xx_video_mode *vmode = | |
311 | container_of(dma_q, struct cx231xx_video_mode, vidq); | |
312 | struct cx231xx *dev = container_of(vmode, struct cx231xx, vbi_mode); | |
e0d3bafd SD |
313 | int rc; |
314 | ||
84b5dbf3 MCC |
315 | switch (urb->status) { |
316 | case 0: /* success */ | |
317 | case -ETIMEDOUT: /* NAK */ | |
318 | break; | |
319 | case -ECONNRESET: /* kill */ | |
320 | case -ENOENT: | |
321 | case -ESHUTDOWN: | |
322 | return; | |
323 | default: /* error */ | |
324 | cx231xx_err(DRIVER_NAME "urb completition error %d.\n", | |
325 | urb->status); | |
326 | break; | |
e0d3bafd SD |
327 | } |
328 | ||
329 | /* Copy data from URB */ | |
330 | spin_lock(&dev->vbi_mode.slock); | |
64fbf444 | 331 | rc = dev->vbi_mode.bulk_ctl.bulk_copy(dev, urb); |
e0d3bafd SD |
332 | spin_unlock(&dev->vbi_mode.slock); |
333 | ||
334 | /* Reset status */ | |
335 | urb->status = 0; | |
336 | ||
337 | urb->status = usb_submit_urb(urb, GFP_ATOMIC); | |
338 | if (urb->status) { | |
339 | cx231xx_err(DRIVER_NAME "urb resubmit failed (error=%i)\n", | |
84b5dbf3 | 340 | urb->status); |
e0d3bafd SD |
341 | } |
342 | } | |
343 | ||
344 | /* | |
345 | * Stop and Deallocate URBs | |
346 | */ | |
347 | void cx231xx_uninit_vbi_isoc(struct cx231xx *dev) | |
348 | { | |
349 | struct urb *urb; | |
350 | int i; | |
351 | ||
84b5dbf3 | 352 | cx231xx_info(DRIVER_NAME "cx231xx: called cx231xx_uninit_vbi_isoc\n"); |
e0d3bafd | 353 | |
64fbf444 PB |
354 | dev->vbi_mode.bulk_ctl.nfields = -1; |
355 | for (i = 0; i < dev->vbi_mode.bulk_ctl.num_bufs; i++) { | |
356 | urb = dev->vbi_mode.bulk_ctl.urb[i]; | |
e0d3bafd | 357 | if (urb) { |
84b5dbf3 MCC |
358 | if (!irqs_disabled()) |
359 | usb_kill_urb(urb); | |
360 | else | |
361 | usb_unlink_urb(urb); | |
e0d3bafd | 362 | |
64fbf444 | 363 | if (dev->vbi_mode.bulk_ctl.transfer_buffer[i]) { |
e0d3bafd | 364 | |
64fbf444 | 365 | kfree(dev->vbi_mode.bulk_ctl. |
84b5dbf3 | 366 | transfer_buffer[i]); |
64fbf444 | 367 | dev->vbi_mode.bulk_ctl.transfer_buffer[i] = |
84b5dbf3 | 368 | NULL; |
e0d3bafd SD |
369 | } |
370 | usb_free_urb(urb); | |
64fbf444 | 371 | dev->vbi_mode.bulk_ctl.urb[i] = NULL; |
e0d3bafd | 372 | } |
64fbf444 | 373 | dev->vbi_mode.bulk_ctl.transfer_buffer[i] = NULL; |
e0d3bafd SD |
374 | } |
375 | ||
64fbf444 PB |
376 | kfree(dev->vbi_mode.bulk_ctl.urb); |
377 | kfree(dev->vbi_mode.bulk_ctl.transfer_buffer); | |
e0d3bafd | 378 | |
64fbf444 PB |
379 | dev->vbi_mode.bulk_ctl.urb = NULL; |
380 | dev->vbi_mode.bulk_ctl.transfer_buffer = NULL; | |
381 | dev->vbi_mode.bulk_ctl.num_bufs = 0; | |
e0d3bafd SD |
382 | |
383 | cx231xx_capture_start(dev, 0, Vbi); | |
384 | } | |
385 | EXPORT_SYMBOL_GPL(cx231xx_uninit_vbi_isoc); | |
386 | ||
387 | /* | |
388 | * Allocate URBs and start IRQ | |
389 | */ | |
390 | int cx231xx_init_vbi_isoc(struct cx231xx *dev, int max_packets, | |
84b5dbf3 | 391 | int num_bufs, int max_pkt_size, |
64fbf444 | 392 | int (*bulk_copy) (struct cx231xx *dev, |
cde4362f | 393 | struct urb *urb)) |
e0d3bafd SD |
394 | { |
395 | struct cx231xx_dmaqueue *dma_q = &dev->vbi_mode.vidq; | |
396 | int i; | |
397 | int sb_size, pipe; | |
398 | struct urb *urb; | |
399 | int rc; | |
400 | ||
401 | cx231xx_info(DRIVER_NAME "cx231xx: called cx231xx_prepare_isoc\n"); | |
402 | ||
403 | /* De-allocates all pending stuff */ | |
404 | cx231xx_uninit_vbi_isoc(dev); | |
405 | ||
84b5dbf3 MCC |
406 | /* clear if any halt */ |
407 | usb_clear_halt(dev->udev, | |
408 | usb_rcvbulkpipe(dev->udev, | |
409 | dev->vbi_mode.end_point_addr)); | |
e0d3bafd | 410 | |
64fbf444 PB |
411 | dev->vbi_mode.bulk_ctl.bulk_copy = bulk_copy; |
412 | dev->vbi_mode.bulk_ctl.num_bufs = num_bufs; | |
84b5dbf3 MCC |
413 | dma_q->pos = 0; |
414 | dma_q->is_partial_line = 0; | |
415 | dma_q->last_sav = 0; | |
416 | dma_q->current_field = -1; | |
417 | dma_q->bytes_left_in_line = dev->width << 1; | |
418 | dma_q->lines_per_field = ((dev->norm & V4L2_STD_625_50) ? | |
419 | PAL_VBI_LINES : NTSC_VBI_LINES); | |
420 | dma_q->lines_completed = 0; | |
421 | for (i = 0; i < 8; i++) | |
422 | dma_q->partial_buf[i] = 0; | |
423 | ||
64fbf444 | 424 | dev->vbi_mode.bulk_ctl.urb = kzalloc(sizeof(void *) * num_bufs, |
cde4362f | 425 | GFP_KERNEL); |
64fbf444 | 426 | if (!dev->vbi_mode.bulk_ctl.urb) { |
e0d3bafd SD |
427 | cx231xx_errdev("cannot alloc memory for usb buffers\n"); |
428 | return -ENOMEM; | |
429 | } | |
430 | ||
64fbf444 | 431 | dev->vbi_mode.bulk_ctl.transfer_buffer = |
84b5dbf3 | 432 | kzalloc(sizeof(void *) * num_bufs, GFP_KERNEL); |
64fbf444 | 433 | if (!dev->vbi_mode.bulk_ctl.transfer_buffer) { |
e0d3bafd | 434 | cx231xx_errdev("cannot allocate memory for usbtransfer\n"); |
64fbf444 | 435 | kfree(dev->vbi_mode.bulk_ctl.urb); |
e0d3bafd SD |
436 | return -ENOMEM; |
437 | } | |
438 | ||
64fbf444 PB |
439 | dev->vbi_mode.bulk_ctl.max_pkt_size = max_pkt_size; |
440 | dev->vbi_mode.bulk_ctl.buf = NULL; | |
e0d3bafd | 441 | |
64fbf444 | 442 | sb_size = max_packets * dev->vbi_mode.bulk_ctl.max_pkt_size; |
e0d3bafd SD |
443 | |
444 | /* allocate urbs and transfer buffers */ | |
64fbf444 | 445 | for (i = 0; i < dev->vbi_mode.bulk_ctl.num_bufs; i++) { |
e0d3bafd SD |
446 | |
447 | urb = usb_alloc_urb(0, GFP_KERNEL); | |
448 | if (!urb) { | |
84b5dbf3 | 449 | cx231xx_err(DRIVER_NAME |
64fbf444 | 450 | ": cannot alloc bulk_ctl.urb %i\n", i); |
e0d3bafd SD |
451 | cx231xx_uninit_vbi_isoc(dev); |
452 | return -ENOMEM; | |
453 | } | |
64fbf444 | 454 | dev->vbi_mode.bulk_ctl.urb[i] = urb; |
84b5dbf3 | 455 | urb->transfer_flags = 0; |
e0d3bafd | 456 | |
64fbf444 | 457 | dev->vbi_mode.bulk_ctl.transfer_buffer[i] = |
84b5dbf3 | 458 | kzalloc(sb_size, GFP_KERNEL); |
64fbf444 | 459 | if (!dev->vbi_mode.bulk_ctl.transfer_buffer[i]) { |
84b5dbf3 MCC |
460 | cx231xx_err(DRIVER_NAME |
461 | ": unable to allocate %i bytes for transfer" | |
462 | " buffer %i%s\n", sb_size, i, | |
cde4362f | 463 | in_interrupt() ? " while in int" : ""); |
e0d3bafd SD |
464 | cx231xx_uninit_vbi_isoc(dev); |
465 | return -ENOMEM; | |
466 | } | |
467 | ||
468 | pipe = usb_rcvbulkpipe(dev->udev, dev->vbi_mode.end_point_addr); | |
84b5dbf3 | 469 | usb_fill_bulk_urb(urb, dev->udev, pipe, |
64fbf444 | 470 | dev->vbi_mode.bulk_ctl.transfer_buffer[i], |
84b5dbf3 | 471 | sb_size, cx231xx_irq_vbi_callback, dma_q); |
e0d3bafd SD |
472 | } |
473 | ||
474 | init_waitqueue_head(&dma_q->wq); | |
475 | ||
476 | /* submit urbs and enables IRQ */ | |
64fbf444 PB |
477 | for (i = 0; i < dev->vbi_mode.bulk_ctl.num_bufs; i++) { |
478 | rc = usb_submit_urb(dev->vbi_mode.bulk_ctl.urb[i], GFP_ATOMIC); | |
e0d3bafd | 479 | if (rc) { |
84b5dbf3 MCC |
480 | cx231xx_err(DRIVER_NAME |
481 | ": submit of urb %i failed (error=%i)\n", i, | |
482 | rc); | |
e0d3bafd SD |
483 | cx231xx_uninit_vbi_isoc(dev); |
484 | return rc; | |
485 | } | |
486 | } | |
487 | ||
84b5dbf3 | 488 | cx231xx_capture_start(dev, 1, Vbi); |
e0d3bafd SD |
489 | |
490 | return 0; | |
491 | } | |
84b5dbf3 | 492 | EXPORT_SYMBOL_GPL(cx231xx_init_vbi_isoc); |
e0d3bafd | 493 | |
cde4362f MCC |
494 | u32 cx231xx_get_vbi_line(struct cx231xx *dev, struct cx231xx_dmaqueue *dma_q, |
495 | u8 sav_eav, u8 *p_buffer, u32 buffer_size) | |
e0d3bafd | 496 | { |
84b5dbf3 MCC |
497 | u32 bytes_copied = 0; |
498 | int current_field = -1; | |
e0d3bafd | 499 | |
84b5dbf3 | 500 | switch (sav_eav) { |
e0d3bafd | 501 | |
84b5dbf3 MCC |
502 | case SAV_VBI_FIELD1: |
503 | current_field = 1; | |
504 | break; | |
e0d3bafd | 505 | |
84b5dbf3 MCC |
506 | case SAV_VBI_FIELD2: |
507 | current_field = 2; | |
508 | break; | |
509 | default: | |
510 | break; | |
511 | } | |
e0d3bafd | 512 | |
84b5dbf3 MCC |
513 | if (current_field < 0) |
514 | return bytes_copied; | |
e0d3bafd | 515 | |
84b5dbf3 | 516 | dma_q->last_sav = sav_eav; |
e0d3bafd | 517 | |
84b5dbf3 MCC |
518 | bytes_copied = |
519 | cx231xx_copy_vbi_line(dev, dma_q, p_buffer, buffer_size, | |
520 | current_field); | |
e0d3bafd | 521 | |
84b5dbf3 | 522 | return bytes_copied; |
e0d3bafd SD |
523 | } |
524 | ||
525 | /* | |
526 | * Announces that a buffer were filled and request the next | |
527 | */ | |
528 | static inline void vbi_buffer_filled(struct cx231xx *dev, | |
84b5dbf3 MCC |
529 | struct cx231xx_dmaqueue *dma_q, |
530 | struct cx231xx_buffer *buf) | |
e0d3bafd SD |
531 | { |
532 | /* Advice that buffer was filled */ | |
533 | /* cx231xx_info(DRIVER_NAME "[%p/%d] wakeup\n", buf, buf->vb.i); */ | |
534 | ||
535 | buf->vb.state = VIDEOBUF_DONE; | |
536 | buf->vb.field_count++; | |
537 | do_gettimeofday(&buf->vb.ts); | |
538 | ||
64fbf444 | 539 | dev->vbi_mode.bulk_ctl.buf = NULL; |
e0d3bafd SD |
540 | |
541 | list_del(&buf->vb.queue); | |
542 | wake_up(&buf->vb.done); | |
543 | } | |
544 | ||
84b5dbf3 | 545 | u32 cx231xx_copy_vbi_line(struct cx231xx *dev, struct cx231xx_dmaqueue *dma_q, |
cde4362f | 546 | u8 *p_line, u32 length, int field_number) |
e0d3bafd | 547 | { |
84b5dbf3 MCC |
548 | u32 bytes_to_copy; |
549 | struct cx231xx_buffer *buf; | |
550 | u32 _line_size = dev->width * 2; | |
e0d3bafd | 551 | |
99d35a0e DH |
552 | if (dma_q->current_field == -1) { |
553 | /* Just starting up */ | |
84b5dbf3 | 554 | cx231xx_reset_vbi_buffer(dev, dma_q); |
99d35a0e DH |
555 | } |
556 | ||
557 | if (dma_q->current_field != field_number) | |
558 | dma_q->lines_completed = 0; | |
e0d3bafd | 559 | |
84b5dbf3 | 560 | /* get the buffer pointer */ |
64fbf444 | 561 | buf = dev->vbi_mode.bulk_ctl.buf; |
e0d3bafd | 562 | |
84b5dbf3 MCC |
563 | /* Remember the field number for next time */ |
564 | dma_q->current_field = field_number; | |
e0d3bafd | 565 | |
84b5dbf3 MCC |
566 | bytes_to_copy = dma_q->bytes_left_in_line; |
567 | if (bytes_to_copy > length) | |
568 | bytes_to_copy = length; | |
e0d3bafd | 569 | |
84b5dbf3 MCC |
570 | if (dma_q->lines_completed >= dma_q->lines_per_field) { |
571 | dma_q->bytes_left_in_line -= bytes_to_copy; | |
572 | dma_q->is_partial_line = | |
573 | (dma_q->bytes_left_in_line == 0) ? 0 : 1; | |
574 | return 0; | |
575 | } | |
e0d3bafd | 576 | |
84b5dbf3 | 577 | dma_q->is_partial_line = 1; |
e0d3bafd | 578 | |
84b5dbf3 MCC |
579 | /* If we don't have a buffer, just return the number of bytes we would |
580 | have copied if we had a buffer. */ | |
581 | if (!buf) { | |
582 | dma_q->bytes_left_in_line -= bytes_to_copy; | |
583 | dma_q->is_partial_line = | |
584 | (dma_q->bytes_left_in_line == 0) ? 0 : 1; | |
585 | return bytes_to_copy; | |
586 | } | |
e0d3bafd | 587 | |
84b5dbf3 MCC |
588 | /* copy the data to video buffer */ |
589 | cx231xx_do_vbi_copy(dev, dma_q, p_line, bytes_to_copy); | |
e0d3bafd | 590 | |
84b5dbf3 MCC |
591 | dma_q->pos += bytes_to_copy; |
592 | dma_q->bytes_left_in_line -= bytes_to_copy; | |
e0d3bafd | 593 | |
84b5dbf3 | 594 | if (dma_q->bytes_left_in_line == 0) { |
e0d3bafd | 595 | |
84b5dbf3 MCC |
596 | dma_q->bytes_left_in_line = _line_size; |
597 | dma_q->lines_completed++; | |
598 | dma_q->is_partial_line = 0; | |
e0d3bafd | 599 | |
84b5dbf3 | 600 | if (cx231xx_is_vbi_buffer_done(dev, dma_q) && buf) { |
e0d3bafd | 601 | |
84b5dbf3 | 602 | vbi_buffer_filled(dev, dma_q, buf); |
e0d3bafd | 603 | |
84b5dbf3 | 604 | dma_q->pos = 0; |
84b5dbf3 | 605 | dma_q->lines_completed = 0; |
99d35a0e | 606 | cx231xx_reset_vbi_buffer(dev, dma_q); |
84b5dbf3 MCC |
607 | } |
608 | } | |
e0d3bafd | 609 | |
84b5dbf3 | 610 | return bytes_to_copy; |
e0d3bafd SD |
611 | } |
612 | ||
613 | /* | |
614 | * video-buf generic routine to get the next available buffer | |
615 | */ | |
616 | static inline void get_next_vbi_buf(struct cx231xx_dmaqueue *dma_q, | |
84b5dbf3 | 617 | struct cx231xx_buffer **buf) |
e0d3bafd | 618 | { |
84b5dbf3 MCC |
619 | struct cx231xx_video_mode *vmode = |
620 | container_of(dma_q, struct cx231xx_video_mode, vidq); | |
621 | struct cx231xx *dev = container_of(vmode, struct cx231xx, vbi_mode); | |
e0d3bafd SD |
622 | char *outp; |
623 | ||
624 | if (list_empty(&dma_q->active)) { | |
84b5dbf3 | 625 | cx231xx_err(DRIVER_NAME ": No active queue to serve\n"); |
64fbf444 | 626 | dev->vbi_mode.bulk_ctl.buf = NULL; |
e0d3bafd SD |
627 | *buf = NULL; |
628 | return; | |
629 | } | |
630 | ||
631 | /* Get the next buffer */ | |
632 | *buf = list_entry(dma_q->active.next, struct cx231xx_buffer, vb.queue); | |
633 | ||
25985edc | 634 | /* Cleans up buffer - Useful for testing for frame/URB loss */ |
e0d3bafd SD |
635 | outp = videobuf_to_vmalloc(&(*buf)->vb); |
636 | memset(outp, 0, (*buf)->vb.size); | |
637 | ||
64fbf444 | 638 | dev->vbi_mode.bulk_ctl.buf = *buf; |
e0d3bafd SD |
639 | |
640 | return; | |
641 | } | |
642 | ||
84b5dbf3 MCC |
643 | void cx231xx_reset_vbi_buffer(struct cx231xx *dev, |
644 | struct cx231xx_dmaqueue *dma_q) | |
e0d3bafd | 645 | { |
84b5dbf3 | 646 | struct cx231xx_buffer *buf; |
e0d3bafd | 647 | |
64fbf444 | 648 | buf = dev->vbi_mode.bulk_ctl.buf; |
e0d3bafd | 649 | |
84b5dbf3 | 650 | if (buf == NULL) { |
84b5dbf3 MCC |
651 | /* first try to get the buffer */ |
652 | get_next_vbi_buf(dma_q, &buf); | |
e0d3bafd | 653 | |
84b5dbf3 MCC |
654 | dma_q->pos = 0; |
655 | dma_q->current_field = -1; | |
656 | } | |
e0d3bafd | 657 | |
84b5dbf3 MCC |
658 | dma_q->bytes_left_in_line = dev->width << 1; |
659 | dma_q->lines_completed = 0; | |
e0d3bafd SD |
660 | } |
661 | ||
662 | int cx231xx_do_vbi_copy(struct cx231xx *dev, struct cx231xx_dmaqueue *dma_q, | |
cde4362f | 663 | u8 *p_buffer, u32 bytes_to_copy) |
e0d3bafd | 664 | { |
84b5dbf3 MCC |
665 | u8 *p_out_buffer = NULL; |
666 | u32 current_line_bytes_copied = 0; | |
667 | struct cx231xx_buffer *buf; | |
668 | u32 _line_size = dev->width << 1; | |
669 | void *startwrite; | |
670 | int offset, lencopy; | |
e0d3bafd | 671 | |
64fbf444 | 672 | buf = dev->vbi_mode.bulk_ctl.buf; |
e0d3bafd | 673 | |
cde4362f MCC |
674 | if (buf == NULL) |
675 | return -EINVAL; | |
e0d3bafd SD |
676 | |
677 | p_out_buffer = videobuf_to_vmalloc(&buf->vb); | |
678 | ||
84b5dbf3 MCC |
679 | if (dma_q->bytes_left_in_line != _line_size) { |
680 | current_line_bytes_copied = | |
681 | _line_size - dma_q->bytes_left_in_line; | |
682 | } | |
e0d3bafd | 683 | |
cde4362f MCC |
684 | offset = (dma_q->lines_completed * _line_size) + |
685 | current_line_bytes_copied; | |
e0d3bafd | 686 | |
99d35a0e DH |
687 | if (dma_q->current_field == 2) { |
688 | /* Populate the second half of the frame */ | |
689 | offset += (dev->width * 2 * dma_q->lines_per_field); | |
690 | } | |
691 | ||
84b5dbf3 | 692 | /* prepare destination address */ |
e0d3bafd SD |
693 | startwrite = p_out_buffer + offset; |
694 | ||
cde4362f MCC |
695 | lencopy = dma_q->bytes_left_in_line > bytes_to_copy ? |
696 | bytes_to_copy : dma_q->bytes_left_in_line; | |
e0d3bafd | 697 | |
84b5dbf3 | 698 | memcpy(startwrite, p_buffer, lencopy); |
e0d3bafd | 699 | |
84b5dbf3 | 700 | return 0; |
e0d3bafd SD |
701 | } |
702 | ||
cde4362f MCC |
703 | u8 cx231xx_is_vbi_buffer_done(struct cx231xx *dev, |
704 | struct cx231xx_dmaqueue *dma_q) | |
e0d3bafd | 705 | { |
84b5dbf3 | 706 | u32 height = 0; |
e0d3bafd SD |
707 | |
708 | height = ((dev->norm & V4L2_STD_625_50) ? | |
84b5dbf3 | 709 | PAL_VBI_LINES : NTSC_VBI_LINES); |
99d35a0e DH |
710 | if (dma_q->lines_completed == height && dma_q->current_field == 2) |
711 | return 1; | |
712 | else | |
713 | return 0; | |
e0d3bafd | 714 | } |