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