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