2 cx231xx-video.c - driver for Conexant Cx23100/101/102
3 USB video capture devices
5 Copyright (C) 2008 <srinivasa.deevi at conexant dot com>
7 Based on cx23885 driver
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 #include <linux/init.h>
26 #include <linux/list.h>
27 #include <linux/module.h>
28 #include <linux/kernel.h>
29 #include <linux/bitmap.h>
30 #include <linux/usb.h>
31 #include <linux/i2c.h>
33 #include <linux/mutex.h>
34 #include <linux/slab.h>
36 #include <media/v4l2-common.h>
37 #include <media/v4l2-ioctl.h>
38 #include <media/v4l2-event.h>
39 #include <media/msp3400.h>
40 #include <media/tuner.h>
42 #include "dvb_frontend.h"
45 #include "cx231xx-vbi.h"
47 #define CX231XX_VERSION "0.0.2"
49 #define DRIVER_AUTHOR "Srinivasa Deevi <srinivasa.deevi@conexant.com>"
50 #define DRIVER_DESC "Conexant cx231xx based USB video device driver"
52 #define cx231xx_videodbg(fmt, arg...) do {\
54 printk(KERN_INFO "%s %s :"fmt, \
55 dev->name, __func__ , ##arg); } while (0)
57 static unsigned int isoc_debug
;
58 module_param(isoc_debug
, int, 0644);
59 MODULE_PARM_DESC(isoc_debug
, "enable debug messages [isoc transfers]");
61 #define cx231xx_isocdbg(fmt, arg...) \
64 printk(KERN_INFO "%s %s :"fmt, \
65 dev->name, __func__ , ##arg); \
69 MODULE_AUTHOR(DRIVER_AUTHOR
);
70 MODULE_DESCRIPTION(DRIVER_DESC
);
71 MODULE_LICENSE("GPL");
72 MODULE_VERSION(CX231XX_VERSION
);
74 static unsigned int card
[] = {[0 ... (CX231XX_MAXBOARDS
- 1)] = UNSET
};
75 static unsigned int video_nr
[] = {[0 ... (CX231XX_MAXBOARDS
- 1)] = UNSET
};
76 static unsigned int vbi_nr
[] = {[0 ... (CX231XX_MAXBOARDS
- 1)] = UNSET
};
77 static unsigned int radio_nr
[] = {[0 ... (CX231XX_MAXBOARDS
- 1)] = UNSET
};
79 module_param_array(card
, int, NULL
, 0444);
80 module_param_array(video_nr
, int, NULL
, 0444);
81 module_param_array(vbi_nr
, int, NULL
, 0444);
82 module_param_array(radio_nr
, int, NULL
, 0444);
84 MODULE_PARM_DESC(card
, "card type");
85 MODULE_PARM_DESC(video_nr
, "video device numbers");
86 MODULE_PARM_DESC(vbi_nr
, "vbi device numbers");
87 MODULE_PARM_DESC(radio_nr
, "radio device numbers");
89 static unsigned int video_debug
;
90 module_param(video_debug
, int, 0644);
91 MODULE_PARM_DESC(video_debug
, "enable debug messages [video]");
93 /* supported video standards */
94 static struct cx231xx_fmt format
[] = {
96 .name
= "16bpp YUY2, 4:2:2, packed",
97 .fourcc
= V4L2_PIX_FMT_YUYV
,
104 /* ------------------------------------------------------------------
105 Video buffer and parser functions
106 ------------------------------------------------------------------*/
109 * Announces that a buffer were filled and request the next
111 static inline void buffer_filled(struct cx231xx
*dev
,
112 struct cx231xx_dmaqueue
*dma_q
,
113 struct cx231xx_buffer
*buf
)
115 /* Advice that buffer was filled */
116 cx231xx_isocdbg("[%p/%d] wakeup\n", buf
, buf
->vb
.i
);
117 buf
->vb
.state
= VIDEOBUF_DONE
;
118 buf
->vb
.field_count
++;
119 v4l2_get_timestamp(&buf
->vb
.ts
);
122 dev
->video_mode
.isoc_ctl
.buf
= NULL
;
124 dev
->video_mode
.bulk_ctl
.buf
= NULL
;
126 list_del(&buf
->vb
.queue
);
127 wake_up(&buf
->vb
.done
);
130 static inline void print_err_status(struct cx231xx
*dev
, int packet
, int status
)
132 char *errmsg
= "Unknown";
136 errmsg
= "unlinked synchronuously";
139 errmsg
= "unlinked asynchronuously";
142 errmsg
= "Buffer error (overrun)";
145 errmsg
= "Stalled (device not responding)";
148 errmsg
= "Babble (bad cable?)";
151 errmsg
= "Bit-stuff error (bad cable?)";
154 errmsg
= "CRC/Timeout (could be anything)";
157 errmsg
= "Device does not respond";
161 cx231xx_isocdbg("URB status %d [%s].\n", status
, errmsg
);
163 cx231xx_isocdbg("URB packet %d, status %d [%s].\n",
164 packet
, status
, errmsg
);
169 * video-buf generic routine to get the next available buffer
171 static inline void get_next_buf(struct cx231xx_dmaqueue
*dma_q
,
172 struct cx231xx_buffer
**buf
)
174 struct cx231xx_video_mode
*vmode
=
175 container_of(dma_q
, struct cx231xx_video_mode
, vidq
);
176 struct cx231xx
*dev
= container_of(vmode
, struct cx231xx
, video_mode
);
180 if (list_empty(&dma_q
->active
)) {
181 cx231xx_isocdbg("No active queue to serve\n");
183 dev
->video_mode
.isoc_ctl
.buf
= NULL
;
185 dev
->video_mode
.bulk_ctl
.buf
= NULL
;
190 /* Get the next buffer */
191 *buf
= list_entry(dma_q
->active
.next
, struct cx231xx_buffer
, vb
.queue
);
193 /* Cleans up buffer - Useful for testing for frame/URB loss */
194 outp
= videobuf_to_vmalloc(&(*buf
)->vb
);
195 memset(outp
, 0, (*buf
)->vb
.size
);
198 dev
->video_mode
.isoc_ctl
.buf
= *buf
;
200 dev
->video_mode
.bulk_ctl
.buf
= *buf
;
206 * Controls the isoc copy of each urb packet
208 static inline int cx231xx_isoc_copy(struct cx231xx
*dev
, struct urb
*urb
)
210 struct cx231xx_dmaqueue
*dma_q
= urb
->context
;
212 unsigned char *p_buffer
;
213 u32 bytes_parsed
= 0, buffer_size
= 0;
219 if (dev
->state
& DEV_DISCONNECTED
)
222 if (urb
->status
< 0) {
223 print_err_status(dev
, -1, urb
->status
);
224 if (urb
->status
== -ENOENT
)
228 for (i
= 0; i
< urb
->number_of_packets
; i
++) {
229 int status
= urb
->iso_frame_desc
[i
].status
;
232 print_err_status(dev
, i
, status
);
233 if (urb
->iso_frame_desc
[i
].status
!= -EPROTO
)
237 if (urb
->iso_frame_desc
[i
].actual_length
<= 0) {
238 /* cx231xx_isocdbg("packet %d is empty",i); - spammy */
241 if (urb
->iso_frame_desc
[i
].actual_length
>
242 dev
->video_mode
.max_pkt_size
) {
243 cx231xx_isocdbg("packet bigger than packet size");
247 /* get buffer pointer and length */
248 p_buffer
= urb
->transfer_buffer
+ urb
->iso_frame_desc
[i
].offset
;
249 buffer_size
= urb
->iso_frame_desc
[i
].actual_length
;
252 if (dma_q
->is_partial_line
) {
253 /* Handle the case of a partial line */
254 sav_eav
= dma_q
->last_sav
;
256 /* Check for a SAV/EAV overlapping
257 the buffer boundary */
259 cx231xx_find_boundary_SAV_EAV(p_buffer
,
265 /* Get the first line if we have some portion of an SAV/EAV from
266 the last buffer or a partial line */
268 bytes_parsed
+= cx231xx_get_video_line(dev
, dma_q
,
269 sav_eav
, /* SAV/EAV */
270 p_buffer
+ bytes_parsed
, /* p_buffer */
271 buffer_size
- bytes_parsed
);/* buf size */
274 /* Now parse data that is completely in this buffer */
275 /* dma_q->is_partial_line = 0; */
277 while (bytes_parsed
< buffer_size
) {
280 sav_eav
= cx231xx_find_next_SAV_EAV(
281 p_buffer
+ bytes_parsed
, /* p_buffer */
282 buffer_size
- bytes_parsed
, /* buf size */
283 &bytes_used
);/* bytes used to get SAV/EAV */
285 bytes_parsed
+= bytes_used
;
288 if (sav_eav
&& (bytes_parsed
< buffer_size
)) {
289 bytes_parsed
+= cx231xx_get_video_line(dev
,
290 dma_q
, sav_eav
, /* SAV/EAV */
291 p_buffer
+ bytes_parsed
,/* p_buffer */
292 buffer_size
- bytes_parsed
);/*buf size*/
296 /* Save the last four bytes of the buffer so we can check the
297 buffer boundary condition next time */
298 memcpy(dma_q
->partial_buf
, p_buffer
+ buffer_size
- 4, 4);
305 static inline int cx231xx_bulk_copy(struct cx231xx
*dev
, struct urb
*urb
)
307 struct cx231xx_dmaqueue
*dma_q
= urb
->context
;
308 unsigned char *p_buffer
;
309 u32 bytes_parsed
= 0, buffer_size
= 0;
315 if (dev
->state
& DEV_DISCONNECTED
)
318 if (urb
->status
< 0) {
319 print_err_status(dev
, -1, urb
->status
);
320 if (urb
->status
== -ENOENT
)
326 /* get buffer pointer and length */
327 p_buffer
= urb
->transfer_buffer
;
328 buffer_size
= urb
->actual_length
;
331 if (dma_q
->is_partial_line
) {
332 /* Handle the case of a partial line */
333 sav_eav
= dma_q
->last_sav
;
335 /* Check for a SAV/EAV overlapping
336 the buffer boundary */
338 cx231xx_find_boundary_SAV_EAV(p_buffer
,
344 /* Get the first line if we have some portion of an SAV/EAV from
345 the last buffer or a partial line */
347 bytes_parsed
+= cx231xx_get_video_line(dev
, dma_q
,
348 sav_eav
, /* SAV/EAV */
349 p_buffer
+ bytes_parsed
, /* p_buffer */
350 buffer_size
- bytes_parsed
);/* buf size */
353 /* Now parse data that is completely in this buffer */
354 /* dma_q->is_partial_line = 0; */
356 while (bytes_parsed
< buffer_size
) {
359 sav_eav
= cx231xx_find_next_SAV_EAV(
360 p_buffer
+ bytes_parsed
, /* p_buffer */
361 buffer_size
- bytes_parsed
, /* buf size */
362 &bytes_used
);/* bytes used to get SAV/EAV */
364 bytes_parsed
+= bytes_used
;
367 if (sav_eav
&& (bytes_parsed
< buffer_size
)) {
368 bytes_parsed
+= cx231xx_get_video_line(dev
,
369 dma_q
, sav_eav
, /* SAV/EAV */
370 p_buffer
+ bytes_parsed
,/* p_buffer */
371 buffer_size
- bytes_parsed
);/*buf size*/
375 /* Save the last four bytes of the buffer so we can check the
376 buffer boundary condition next time */
377 memcpy(dma_q
->partial_buf
, p_buffer
+ buffer_size
- 4, 4);
385 u8
cx231xx_find_boundary_SAV_EAV(u8
*p_buffer
, u8
*partial_buf
,
389 u8 boundary_bytes
[8];
394 /* Create an array of the last 4 bytes of the last buffer and the first
395 4 bytes of the current buffer. */
397 memcpy(boundary_bytes
, partial_buf
, 4);
398 memcpy(boundary_bytes
+ 4, p_buffer
, 4);
400 /* Check for the SAV/EAV in the boundary buffer */
401 sav_eav
= cx231xx_find_next_SAV_EAV((u8
*)&boundary_bytes
, 8,
405 /* found a boundary SAV/EAV. Updates the bytes used to reflect
406 only those used in the new buffer */
407 *p_bytes_used
= bytes_used
- 4;
413 u8
cx231xx_find_next_SAV_EAV(u8
*p_buffer
, u32 buffer_size
, u32
*p_bytes_used
)
419 * Don't search if the buffer size is less than 4. It causes a page
420 * fault since buffer_size - 4 evaluates to a large number in that
423 if (buffer_size
< 4) {
424 *p_bytes_used
= buffer_size
;
428 for (i
= 0; i
< (buffer_size
- 3); i
++) {
430 if ((p_buffer
[i
] == 0xFF) &&
431 (p_buffer
[i
+ 1] == 0x00) && (p_buffer
[i
+ 2] == 0x00)) {
433 *p_bytes_used
= i
+ 4;
434 sav_eav
= p_buffer
[i
+ 3];
439 *p_bytes_used
= buffer_size
;
443 u32
cx231xx_get_video_line(struct cx231xx
*dev
,
444 struct cx231xx_dmaqueue
*dma_q
, u8 sav_eav
,
445 u8
*p_buffer
, u32 buffer_size
)
447 u32 bytes_copied
= 0;
448 int current_field
= -1;
451 case SAV_ACTIVE_VIDEO_FIELD1
:
452 /* looking for skipped line which occurred in PAL 720x480 mode.
453 In this case, there will be no active data contained
454 between the SAV and EAV */
455 if ((buffer_size
> 3) && (p_buffer
[0] == 0xFF) &&
456 (p_buffer
[1] == 0x00) && (p_buffer
[2] == 0x00) &&
457 ((p_buffer
[3] == EAV_ACTIVE_VIDEO_FIELD1
) ||
458 (p_buffer
[3] == EAV_ACTIVE_VIDEO_FIELD2
) ||
459 (p_buffer
[3] == EAV_VBLANK_FIELD1
) ||
460 (p_buffer
[3] == EAV_VBLANK_FIELD2
)))
465 case SAV_ACTIVE_VIDEO_FIELD2
:
466 /* looking for skipped line which occurred in PAL 720x480 mode.
467 In this case, there will be no active data contained between
469 if ((buffer_size
> 3) && (p_buffer
[0] == 0xFF) &&
470 (p_buffer
[1] == 0x00) && (p_buffer
[2] == 0x00) &&
471 ((p_buffer
[3] == EAV_ACTIVE_VIDEO_FIELD1
) ||
472 (p_buffer
[3] == EAV_ACTIVE_VIDEO_FIELD2
) ||
473 (p_buffer
[3] == EAV_VBLANK_FIELD1
) ||
474 (p_buffer
[3] == EAV_VBLANK_FIELD2
)))
480 dma_q
->last_sav
= sav_eav
;
482 bytes_copied
= cx231xx_copy_video_line(dev
, dma_q
, p_buffer
,
483 buffer_size
, current_field
);
488 u32
cx231xx_copy_video_line(struct cx231xx
*dev
,
489 struct cx231xx_dmaqueue
*dma_q
, u8
*p_line
,
490 u32 length
, int field_number
)
493 struct cx231xx_buffer
*buf
;
494 u32 _line_size
= dev
->width
* 2;
496 if (dma_q
->current_field
!= field_number
)
497 cx231xx_reset_video_buffer(dev
, dma_q
);
499 /* get the buffer pointer */
501 buf
= dev
->video_mode
.isoc_ctl
.buf
;
503 buf
= dev
->video_mode
.bulk_ctl
.buf
;
505 /* Remember the field number for next time */
506 dma_q
->current_field
= field_number
;
508 bytes_to_copy
= dma_q
->bytes_left_in_line
;
509 if (bytes_to_copy
> length
)
510 bytes_to_copy
= length
;
512 if (dma_q
->lines_completed
>= dma_q
->lines_per_field
) {
513 dma_q
->bytes_left_in_line
-= bytes_to_copy
;
514 dma_q
->is_partial_line
= (dma_q
->bytes_left_in_line
== 0) ?
519 dma_q
->is_partial_line
= 1;
521 /* If we don't have a buffer, just return the number of bytes we would
522 have copied if we had a buffer. */
524 dma_q
->bytes_left_in_line
-= bytes_to_copy
;
525 dma_q
->is_partial_line
= (dma_q
->bytes_left_in_line
== 0)
527 return bytes_to_copy
;
530 /* copy the data to video buffer */
531 cx231xx_do_copy(dev
, dma_q
, p_line
, bytes_to_copy
);
533 dma_q
->pos
+= bytes_to_copy
;
534 dma_q
->bytes_left_in_line
-= bytes_to_copy
;
536 if (dma_q
->bytes_left_in_line
== 0) {
537 dma_q
->bytes_left_in_line
= _line_size
;
538 dma_q
->lines_completed
++;
539 dma_q
->is_partial_line
= 0;
541 if (cx231xx_is_buffer_done(dev
, dma_q
) && buf
) {
542 buffer_filled(dev
, dma_q
, buf
);
546 dma_q
->lines_completed
= 0;
550 return bytes_to_copy
;
553 void cx231xx_reset_video_buffer(struct cx231xx
*dev
,
554 struct cx231xx_dmaqueue
*dma_q
)
556 struct cx231xx_buffer
*buf
;
558 /* handle the switch from field 1 to field 2 */
559 if (dma_q
->current_field
== 1) {
560 if (dma_q
->lines_completed
>= dma_q
->lines_per_field
)
561 dma_q
->field1_done
= 1;
563 dma_q
->field1_done
= 0;
567 buf
= dev
->video_mode
.isoc_ctl
.buf
;
569 buf
= dev
->video_mode
.bulk_ctl
.buf
;
572 /* first try to get the buffer */
573 get_next_buf(dma_q
, &buf
);
576 dma_q
->field1_done
= 0;
577 dma_q
->current_field
= -1;
580 /* reset the counters */
581 dma_q
->bytes_left_in_line
= dev
->width
<< 1;
582 dma_q
->lines_completed
= 0;
585 int cx231xx_do_copy(struct cx231xx
*dev
, struct cx231xx_dmaqueue
*dma_q
,
586 u8
*p_buffer
, u32 bytes_to_copy
)
588 u8
*p_out_buffer
= NULL
;
589 u32 current_line_bytes_copied
= 0;
590 struct cx231xx_buffer
*buf
;
591 u32 _line_size
= dev
->width
<< 1;
596 buf
= dev
->video_mode
.isoc_ctl
.buf
;
598 buf
= dev
->video_mode
.bulk_ctl
.buf
;
603 p_out_buffer
= videobuf_to_vmalloc(&buf
->vb
);
605 current_line_bytes_copied
= _line_size
- dma_q
->bytes_left_in_line
;
607 /* Offset field 2 one line from the top of the buffer */
608 offset
= (dma_q
->current_field
== 1) ? 0 : _line_size
;
610 /* Offset for field 2 */
611 startwrite
= p_out_buffer
+ offset
;
613 /* lines already completed in the current field */
614 startwrite
+= (dma_q
->lines_completed
* _line_size
* 2);
616 /* bytes already completed in the current line */
617 startwrite
+= current_line_bytes_copied
;
619 lencopy
= dma_q
->bytes_left_in_line
> bytes_to_copy
?
620 bytes_to_copy
: dma_q
->bytes_left_in_line
;
622 if ((u8
*)(startwrite
+ lencopy
) > (u8
*)(p_out_buffer
+ buf
->vb
.size
))
625 /* The below copies the UYVY data straight into video buffer */
626 cx231xx_swab((u16
*) p_buffer
, (u16
*) startwrite
, (u16
) lencopy
);
631 void cx231xx_swab(u16
*from
, u16
*to
, u16 len
)
638 for (i
= 0; i
< len
/ 2; i
++)
639 to
[i
] = (from
[i
] << 8) | (from
[i
] >> 8);
642 u8
cx231xx_is_buffer_done(struct cx231xx
*dev
, struct cx231xx_dmaqueue
*dma_q
)
644 u8 buffer_complete
= 0;
646 /* Dual field stream */
647 buffer_complete
= ((dma_q
->current_field
== 2) &&
648 (dma_q
->lines_completed
>= dma_q
->lines_per_field
) &&
651 return buffer_complete
;
654 /* ------------------------------------------------------------------
656 ------------------------------------------------------------------*/
659 buffer_setup(struct videobuf_queue
*vq
, unsigned int *count
, unsigned int *size
)
661 struct cx231xx_fh
*fh
= vq
->priv_data
;
662 struct cx231xx
*dev
= fh
->dev
;
664 *size
= (fh
->dev
->width
* fh
->dev
->height
* dev
->format
->depth
+ 7)>>3;
666 *count
= CX231XX_DEF_BUF
;
668 if (*count
< CX231XX_MIN_BUF
)
669 *count
= CX231XX_MIN_BUF
;
674 /* This is called *without* dev->slock held; please keep it that way */
675 static void free_buffer(struct videobuf_queue
*vq
, struct cx231xx_buffer
*buf
)
677 struct cx231xx_fh
*fh
= vq
->priv_data
;
678 struct cx231xx
*dev
= fh
->dev
;
679 unsigned long flags
= 0;
684 /* We used to wait for the buffer to finish here, but this didn't work
685 because, as we were keeping the state as VIDEOBUF_QUEUED,
686 videobuf_queue_cancel marked it as finished for us.
687 (Also, it could wedge forever if the hardware was misconfigured.)
689 This should be safe; by the time we get here, the buffer isn't
690 queued anymore. If we ever start marking the buffers as
691 VIDEOBUF_ACTIVE, it won't be, though.
693 spin_lock_irqsave(&dev
->video_mode
.slock
, flags
);
695 if (dev
->video_mode
.isoc_ctl
.buf
== buf
)
696 dev
->video_mode
.isoc_ctl
.buf
= NULL
;
698 if (dev
->video_mode
.bulk_ctl
.buf
== buf
)
699 dev
->video_mode
.bulk_ctl
.buf
= NULL
;
701 spin_unlock_irqrestore(&dev
->video_mode
.slock
, flags
);
703 videobuf_vmalloc_free(&buf
->vb
);
704 buf
->vb
.state
= VIDEOBUF_NEEDS_INIT
;
708 buffer_prepare(struct videobuf_queue
*vq
, struct videobuf_buffer
*vb
,
709 enum v4l2_field field
)
711 struct cx231xx_fh
*fh
= vq
->priv_data
;
712 struct cx231xx_buffer
*buf
=
713 container_of(vb
, struct cx231xx_buffer
, vb
);
714 struct cx231xx
*dev
= fh
->dev
;
715 int rc
= 0, urb_init
= 0;
717 /* The only currently supported format is 16 bits/pixel */
718 buf
->vb
.size
= (fh
->dev
->width
* fh
->dev
->height
* dev
->format
->depth
720 if (0 != buf
->vb
.baddr
&& buf
->vb
.bsize
< buf
->vb
.size
)
723 buf
->vb
.width
= dev
->width
;
724 buf
->vb
.height
= dev
->height
;
725 buf
->vb
.field
= field
;
727 if (VIDEOBUF_NEEDS_INIT
== buf
->vb
.state
) {
728 rc
= videobuf_iolock(vq
, &buf
->vb
, NULL
);
734 if (!dev
->video_mode
.isoc_ctl
.num_bufs
)
737 if (!dev
->video_mode
.bulk_ctl
.num_bufs
)
740 /*cx231xx_info("urb_init=%d dev->video_mode.max_pkt_size=%d\n",
741 urb_init, dev->video_mode.max_pkt_size);*/
745 rc
= cx231xx_init_isoc(dev
, CX231XX_NUM_PACKETS
,
747 dev
->video_mode
.max_pkt_size
,
750 rc
= cx231xx_init_bulk(dev
, CX231XX_NUM_PACKETS
,
752 dev
->video_mode
.max_pkt_size
,
758 buf
->vb
.state
= VIDEOBUF_PREPARED
;
762 free_buffer(vq
, buf
);
766 static void buffer_queue(struct videobuf_queue
*vq
, struct videobuf_buffer
*vb
)
768 struct cx231xx_buffer
*buf
=
769 container_of(vb
, struct cx231xx_buffer
, vb
);
770 struct cx231xx_fh
*fh
= vq
->priv_data
;
771 struct cx231xx
*dev
= fh
->dev
;
772 struct cx231xx_dmaqueue
*vidq
= &dev
->video_mode
.vidq
;
774 buf
->vb
.state
= VIDEOBUF_QUEUED
;
775 list_add_tail(&buf
->vb
.queue
, &vidq
->active
);
779 static void buffer_release(struct videobuf_queue
*vq
,
780 struct videobuf_buffer
*vb
)
782 struct cx231xx_buffer
*buf
=
783 container_of(vb
, struct cx231xx_buffer
, vb
);
784 struct cx231xx_fh
*fh
= vq
->priv_data
;
785 struct cx231xx
*dev
= (struct cx231xx
*)fh
->dev
;
787 cx231xx_isocdbg("cx231xx: called buffer_release\n");
789 free_buffer(vq
, buf
);
792 static struct videobuf_queue_ops cx231xx_video_qops
= {
793 .buf_setup
= buffer_setup
,
794 .buf_prepare
= buffer_prepare
,
795 .buf_queue
= buffer_queue
,
796 .buf_release
= buffer_release
,
799 /********************* v4l2 interface **************************************/
801 void video_mux(struct cx231xx
*dev
, int index
)
803 dev
->video_input
= index
;
804 dev
->ctl_ainput
= INPUT(index
)->amux
;
806 cx231xx_set_video_input_mux(dev
, index
);
808 cx25840_call(dev
, video
, s_routing
, INPUT(index
)->vmux
, 0, 0);
810 cx231xx_set_audio_input(dev
, dev
->ctl_ainput
);
812 cx231xx_info("video_mux : %d\n", index
);
814 /* do mode control overrides if required */
815 cx231xx_do_mode_ctrl_overrides(dev
);
818 /* Usage lock check functions */
819 static int res_get(struct cx231xx_fh
*fh
)
821 struct cx231xx
*dev
= fh
->dev
;
824 /* This instance already has stream_on */
828 if (fh
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
) {
832 } else if (fh
->type
== V4L2_BUF_TYPE_VBI_CAPTURE
) {
833 if (dev
->vbi_stream_on
)
835 dev
->vbi_stream_on
= 1;
844 static int res_check(struct cx231xx_fh
*fh
)
846 return fh
->stream_on
;
849 static void res_free(struct cx231xx_fh
*fh
)
851 struct cx231xx
*dev
= fh
->dev
;
855 if (fh
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
)
857 if (fh
->type
== V4L2_BUF_TYPE_VBI_CAPTURE
)
858 dev
->vbi_stream_on
= 0;
861 static int check_dev(struct cx231xx
*dev
)
863 if (dev
->state
& DEV_DISCONNECTED
) {
864 cx231xx_errdev("v4l2 ioctl: device not present\n");
870 /* ------------------------------------------------------------------
871 IOCTL vidioc handling
872 ------------------------------------------------------------------*/
874 static int vidioc_g_fmt_vid_cap(struct file
*file
, void *priv
,
875 struct v4l2_format
*f
)
877 struct cx231xx_fh
*fh
= priv
;
878 struct cx231xx
*dev
= fh
->dev
;
880 f
->fmt
.pix
.width
= dev
->width
;
881 f
->fmt
.pix
.height
= dev
->height
;
882 f
->fmt
.pix
.pixelformat
= dev
->format
->fourcc
;
883 f
->fmt
.pix
.bytesperline
= (dev
->width
* dev
->format
->depth
+ 7) >> 3;
884 f
->fmt
.pix
.sizeimage
= f
->fmt
.pix
.bytesperline
* dev
->height
;
885 f
->fmt
.pix
.colorspace
= V4L2_COLORSPACE_SMPTE170M
;
887 f
->fmt
.pix
.field
= V4L2_FIELD_INTERLACED
;
892 static struct cx231xx_fmt
*format_by_fourcc(unsigned int fourcc
)
896 for (i
= 0; i
< ARRAY_SIZE(format
); i
++)
897 if (format
[i
].fourcc
== fourcc
)
903 static int vidioc_try_fmt_vid_cap(struct file
*file
, void *priv
,
904 struct v4l2_format
*f
)
906 struct cx231xx_fh
*fh
= priv
;
907 struct cx231xx
*dev
= fh
->dev
;
908 unsigned int width
= f
->fmt
.pix
.width
;
909 unsigned int height
= f
->fmt
.pix
.height
;
910 unsigned int maxw
= norm_maxw(dev
);
911 unsigned int maxh
= norm_maxh(dev
);
912 struct cx231xx_fmt
*fmt
;
914 fmt
= format_by_fourcc(f
->fmt
.pix
.pixelformat
);
916 cx231xx_videodbg("Fourcc format (%08x) invalid.\n",
917 f
->fmt
.pix
.pixelformat
);
921 /* width must even because of the YUYV format
922 height must be even because of interlacing */
923 v4l_bound_align_image(&width
, 48, maxw
, 1, &height
, 32, maxh
, 1, 0);
925 f
->fmt
.pix
.width
= width
;
926 f
->fmt
.pix
.height
= height
;
927 f
->fmt
.pix
.pixelformat
= fmt
->fourcc
;
928 f
->fmt
.pix
.bytesperline
= (width
* fmt
->depth
+ 7) >> 3;
929 f
->fmt
.pix
.sizeimage
= f
->fmt
.pix
.bytesperline
* height
;
930 f
->fmt
.pix
.colorspace
= V4L2_COLORSPACE_SMPTE170M
;
931 f
->fmt
.pix
.field
= V4L2_FIELD_INTERLACED
;
936 static int vidioc_s_fmt_vid_cap(struct file
*file
, void *priv
,
937 struct v4l2_format
*f
)
939 struct cx231xx_fh
*fh
= priv
;
940 struct cx231xx
*dev
= fh
->dev
;
942 struct cx231xx_fmt
*fmt
;
943 struct v4l2_mbus_framefmt mbus_fmt
;
949 vidioc_try_fmt_vid_cap(file
, priv
, f
);
951 fmt
= format_by_fourcc(f
->fmt
.pix
.pixelformat
);
955 if (videobuf_queue_is_busy(&fh
->vb_vidq
)) {
956 cx231xx_errdev("%s queue busy\n", __func__
);
960 if (dev
->stream_on
&& !fh
->stream_on
) {
961 cx231xx_errdev("%s device in use by another fh\n", __func__
);
965 /* set new image size */
966 dev
->width
= f
->fmt
.pix
.width
;
967 dev
->height
= f
->fmt
.pix
.height
;
970 v4l2_fill_mbus_format(&mbus_fmt
, &f
->fmt
.pix
, V4L2_MBUS_FMT_FIXED
);
971 call_all(dev
, video
, s_mbus_fmt
, &mbus_fmt
);
972 v4l2_fill_pix_format(&f
->fmt
.pix
, &mbus_fmt
);
977 static int vidioc_g_std(struct file
*file
, void *priv
, v4l2_std_id
*id
)
979 struct cx231xx_fh
*fh
= priv
;
980 struct cx231xx
*dev
= fh
->dev
;
986 static int vidioc_s_std(struct file
*file
, void *priv
, v4l2_std_id norm
)
988 struct cx231xx_fh
*fh
= priv
;
989 struct cx231xx
*dev
= fh
->dev
;
990 struct v4l2_mbus_framefmt mbus_fmt
;
997 if (dev
->norm
== norm
)
1000 if (videobuf_queue_is_busy(&fh
->vb_vidq
))
1005 /* Adjusts width/height, if needed */
1007 dev
->height
= (dev
->norm
& V4L2_STD_625_50
) ? 576 : 480;
1009 call_all(dev
, video
, s_std
, dev
->norm
);
1011 /* We need to reset basic properties in the decoder related to
1012 resolution (since a standard change effects things like the number
1013 of lines in VACT, etc) */
1014 memset(&mbus_fmt
, 0, sizeof(mbus_fmt
));
1015 mbus_fmt
.code
= V4L2_MBUS_FMT_FIXED
;
1016 mbus_fmt
.width
= dev
->width
;
1017 mbus_fmt
.height
= dev
->height
;
1018 call_all(dev
, video
, s_mbus_fmt
, &mbus_fmt
);
1020 /* do mode control overrides */
1021 cx231xx_do_mode_ctrl_overrides(dev
);
1026 static const char *iname
[] = {
1027 [CX231XX_VMUX_COMPOSITE1
] = "Composite1",
1028 [CX231XX_VMUX_SVIDEO
] = "S-Video",
1029 [CX231XX_VMUX_TELEVISION
] = "Television",
1030 [CX231XX_VMUX_CABLE
] = "Cable TV",
1031 [CX231XX_VMUX_DVB
] = "DVB",
1032 [CX231XX_VMUX_DEBUG
] = "for debug only",
1035 int cx231xx_enum_input(struct file
*file
, void *priv
,
1036 struct v4l2_input
*i
)
1038 struct cx231xx_fh
*fh
= priv
;
1039 struct cx231xx
*dev
= fh
->dev
;
1041 unsigned int ret
, n
;
1044 if (n
>= MAX_CX231XX_INPUT
)
1046 if (0 == INPUT(n
)->type
)
1050 i
->type
= V4L2_INPUT_TYPE_CAMERA
;
1052 strcpy(i
->name
, iname
[INPUT(n
)->type
]);
1054 if ((CX231XX_VMUX_TELEVISION
== INPUT(n
)->type
) ||
1055 (CX231XX_VMUX_CABLE
== INPUT(n
)->type
))
1056 i
->type
= V4L2_INPUT_TYPE_TUNER
;
1058 i
->std
= dev
->vdev
->tvnorms
;
1060 /* If they are asking about the active input, read signal status */
1061 if (n
== dev
->video_input
) {
1062 ret
= cx231xx_read_i2c_data(dev
, VID_BLK_I2C_ADDRESS
,
1063 GEN_STAT
, 2, &gen_stat
, 4);
1065 if ((gen_stat
& FLD_VPRES
) == 0x00)
1066 i
->status
|= V4L2_IN_ST_NO_SIGNAL
;
1067 if ((gen_stat
& FLD_HLOCK
) == 0x00)
1068 i
->status
|= V4L2_IN_ST_NO_H_LOCK
;
1075 int cx231xx_g_input(struct file
*file
, void *priv
, unsigned int *i
)
1077 struct cx231xx_fh
*fh
= priv
;
1078 struct cx231xx
*dev
= fh
->dev
;
1080 *i
= dev
->video_input
;
1085 int cx231xx_s_input(struct file
*file
, void *priv
, unsigned int i
)
1087 struct cx231xx_fh
*fh
= priv
;
1088 struct cx231xx
*dev
= fh
->dev
;
1092 rc
= check_dev(dev
);
1096 if (i
>= MAX_CX231XX_INPUT
)
1098 if (0 == INPUT(i
)->type
)
1103 if (INPUT(i
)->type
== CX231XX_VMUX_TELEVISION
||
1104 INPUT(i
)->type
== CX231XX_VMUX_CABLE
) {
1105 /* There's a tuner, so reset the standard and put it on the
1106 last known frequency (since it was probably powered down
1108 call_all(dev
, video
, s_std
, dev
->norm
);
1114 int cx231xx_g_tuner(struct file
*file
, void *priv
, struct v4l2_tuner
*t
)
1116 struct cx231xx_fh
*fh
= priv
;
1117 struct cx231xx
*dev
= fh
->dev
;
1120 rc
= check_dev(dev
);
1127 strcpy(t
->name
, "Tuner");
1129 t
->type
= V4L2_TUNER_ANALOG_TV
;
1130 t
->capability
= V4L2_TUNER_CAP_NORM
;
1131 t
->rangehigh
= 0xffffffffUL
;
1132 t
->signal
= 0xffff; /* LOCKED */
1133 call_all(dev
, tuner
, g_tuner
, t
);
1138 int cx231xx_s_tuner(struct file
*file
, void *priv
, const struct v4l2_tuner
*t
)
1140 struct cx231xx_fh
*fh
= priv
;
1141 struct cx231xx
*dev
= fh
->dev
;
1144 rc
= check_dev(dev
);
1151 call_all(dev
, tuner
, s_tuner
, t
);
1156 int cx231xx_g_frequency(struct file
*file
, void *priv
,
1157 struct v4l2_frequency
*f
)
1159 struct cx231xx_fh
*fh
= priv
;
1160 struct cx231xx
*dev
= fh
->dev
;
1165 f
->frequency
= dev
->ctl_freq
;
1170 int cx231xx_s_frequency(struct file
*file
, void *priv
,
1171 const struct v4l2_frequency
*f
)
1173 struct cx231xx_fh
*fh
= priv
;
1174 struct cx231xx
*dev
= fh
->dev
;
1175 struct v4l2_frequency new_freq
= *f
;
1177 u32 if_frequency
= 5400000;
1179 cx231xx_info("Enter vidioc_s_frequency()f->frequency=%d;f->type=%d\n",
1180 f
->frequency
, f
->type
);
1181 /*cx231xx_info("f->type: 1-radio 2-analogTV 3-digitalTV\n");*/
1183 rc
= check_dev(dev
);
1190 /* set pre channel change settings in DIF first */
1191 rc
= cx231xx_tuner_pre_channel_change(dev
);
1193 call_all(dev
, tuner
, s_frequency
, f
);
1194 call_all(dev
, tuner
, g_frequency
, &new_freq
);
1195 dev
->ctl_freq
= new_freq
.frequency
;
1197 /* set post channel change settings in DIF first */
1198 rc
= cx231xx_tuner_post_channel_change(dev
);
1200 if (dev
->tuner_type
== TUNER_NXP_TDA18271
) {
1201 if (dev
->norm
& (V4L2_STD_MN
| V4L2_STD_NTSC_443
))
1202 if_frequency
= 5400000; /*5.4MHz */
1203 else if (dev
->norm
& V4L2_STD_B
)
1204 if_frequency
= 6000000; /*6.0MHz */
1205 else if (dev
->norm
& (V4L2_STD_PAL_DK
| V4L2_STD_SECAM_DK
))
1206 if_frequency
= 6900000; /*6.9MHz */
1207 else if (dev
->norm
& V4L2_STD_GH
)
1208 if_frequency
= 7100000; /*7.1MHz */
1209 else if (dev
->norm
& V4L2_STD_PAL_I
)
1210 if_frequency
= 7250000; /*7.25MHz */
1211 else if (dev
->norm
& V4L2_STD_SECAM_L
)
1212 if_frequency
= 6900000; /*6.9MHz */
1213 else if (dev
->norm
& V4L2_STD_SECAM_LC
)
1214 if_frequency
= 1250000; /*1.25MHz */
1216 cx231xx_info("if_frequency is set to %d\n", if_frequency
);
1217 cx231xx_set_Colibri_For_LowIF(dev
, if_frequency
, 1, 1);
1219 update_HH_register_after_set_DIF(dev
);
1222 cx231xx_info("Set New FREQUENCY to %d\n", f
->frequency
);
1227 #ifdef CONFIG_VIDEO_ADV_DEBUG
1229 int cx231xx_g_chip_info(struct file
*file
, void *fh
,
1230 struct v4l2_dbg_chip_info
*chip
)
1232 switch (chip
->match
.addr
) {
1233 case 0: /* Cx231xx - internal registers */
1235 case 1: /* AFE - read byte */
1236 strlcpy(chip
->name
, "AFE (byte)", sizeof(chip
->name
));
1238 case 2: /* Video Block - read byte */
1239 strlcpy(chip
->name
, "Video (byte)", sizeof(chip
->name
));
1241 case 3: /* I2S block - read byte */
1242 strlcpy(chip
->name
, "I2S (byte)", sizeof(chip
->name
));
1244 case 4: /* AFE - read dword */
1245 strlcpy(chip
->name
, "AFE (dword)", sizeof(chip
->name
));
1247 case 5: /* Video Block - read dword */
1248 strlcpy(chip
->name
, "Video (dword)", sizeof(chip
->name
));
1250 case 6: /* I2S Block - read dword */
1251 strlcpy(chip
->name
, "I2S (dword)", sizeof(chip
->name
));
1257 int cx231xx_g_register(struct file
*file
, void *priv
,
1258 struct v4l2_dbg_register
*reg
)
1260 struct cx231xx_fh
*fh
= priv
;
1261 struct cx231xx
*dev
= fh
->dev
;
1263 u8 value
[4] = { 0, 0, 0, 0 };
1266 switch (reg
->match
.addr
) {
1267 case 0: /* Cx231xx - internal registers */
1268 ret
= cx231xx_read_ctrl_reg(dev
, VRT_GET_REGISTER
,
1269 (u16
)reg
->reg
, value
, 4);
1270 reg
->val
= value
[0] | value
[1] << 8 |
1271 value
[2] << 16 | value
[3] << 24;
1274 case 1: /* AFE - read byte */
1275 ret
= cx231xx_read_i2c_data(dev
, AFE_DEVICE_ADDRESS
,
1276 (u16
)reg
->reg
, 2, &data
, 1);
1280 case 2: /* Video Block - read byte */
1281 ret
= cx231xx_read_i2c_data(dev
, VID_BLK_I2C_ADDRESS
,
1282 (u16
)reg
->reg
, 2, &data
, 1);
1286 case 3: /* I2S block - read byte */
1287 ret
= cx231xx_read_i2c_data(dev
, I2S_BLK_DEVICE_ADDRESS
,
1288 (u16
)reg
->reg
, 1, &data
, 1);
1292 case 4: /* AFE - read dword */
1293 ret
= cx231xx_read_i2c_data(dev
, AFE_DEVICE_ADDRESS
,
1294 (u16
)reg
->reg
, 2, &data
, 4);
1298 case 5: /* Video Block - read dword */
1299 ret
= cx231xx_read_i2c_data(dev
, VID_BLK_I2C_ADDRESS
,
1300 (u16
)reg
->reg
, 2, &data
, 4);
1304 case 6: /* I2S Block - read dword */
1305 ret
= cx231xx_read_i2c_data(dev
, I2S_BLK_DEVICE_ADDRESS
,
1306 (u16
)reg
->reg
, 1, &data
, 4);
1313 return ret
< 0 ? ret
: 0;
1316 int cx231xx_s_register(struct file
*file
, void *priv
,
1317 const struct v4l2_dbg_register
*reg
)
1319 struct cx231xx_fh
*fh
= priv
;
1320 struct cx231xx
*dev
= fh
->dev
;
1322 u8 data
[4] = { 0, 0, 0, 0 };
1324 switch (reg
->match
.addr
) {
1325 case 0: /* cx231xx internal registers */
1326 data
[0] = (u8
) reg
->val
;
1327 data
[1] = (u8
) (reg
->val
>> 8);
1328 data
[2] = (u8
) (reg
->val
>> 16);
1329 data
[3] = (u8
) (reg
->val
>> 24);
1330 ret
= cx231xx_write_ctrl_reg(dev
, VRT_SET_REGISTER
,
1331 (u16
)reg
->reg
, data
, 4);
1333 case 1: /* AFE - write byte */
1334 ret
= cx231xx_write_i2c_data(dev
, AFE_DEVICE_ADDRESS
,
1335 (u16
)reg
->reg
, 2, reg
->val
, 1);
1337 case 2: /* Video Block - write byte */
1338 ret
= cx231xx_write_i2c_data(dev
, VID_BLK_I2C_ADDRESS
,
1339 (u16
)reg
->reg
, 2, reg
->val
, 1);
1341 case 3: /* I2S block - write byte */
1342 ret
= cx231xx_write_i2c_data(dev
, I2S_BLK_DEVICE_ADDRESS
,
1343 (u16
)reg
->reg
, 1, reg
->val
, 1);
1345 case 4: /* AFE - write dword */
1346 ret
= cx231xx_write_i2c_data(dev
, AFE_DEVICE_ADDRESS
,
1347 (u16
)reg
->reg
, 2, reg
->val
, 4);
1349 case 5: /* Video Block - write dword */
1350 ret
= cx231xx_write_i2c_data(dev
, VID_BLK_I2C_ADDRESS
,
1351 (u16
)reg
->reg
, 2, reg
->val
, 4);
1353 case 6: /* I2S block - write dword */
1354 ret
= cx231xx_write_i2c_data(dev
, I2S_BLK_DEVICE_ADDRESS
,
1355 (u16
)reg
->reg
, 1, reg
->val
, 4);
1360 return ret
< 0 ? ret
: 0;
1364 static int vidioc_cropcap(struct file
*file
, void *priv
,
1365 struct v4l2_cropcap
*cc
)
1367 struct cx231xx_fh
*fh
= priv
;
1368 struct cx231xx
*dev
= fh
->dev
;
1370 if (cc
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1373 cc
->bounds
.left
= 0;
1375 cc
->bounds
.width
= dev
->width
;
1376 cc
->bounds
.height
= dev
->height
;
1377 cc
->defrect
= cc
->bounds
;
1378 cc
->pixelaspect
.numerator
= 54; /* 4:3 FIXME: remove magic numbers */
1379 cc
->pixelaspect
.denominator
= 59;
1384 static int vidioc_streamon(struct file
*file
, void *priv
,
1385 enum v4l2_buf_type type
)
1387 struct cx231xx_fh
*fh
= priv
;
1388 struct cx231xx
*dev
= fh
->dev
;
1391 rc
= check_dev(dev
);
1397 if (likely(rc
>= 0))
1398 rc
= videobuf_streamon(&fh
->vb_vidq
);
1400 call_all(dev
, video
, s_stream
, 1);
1405 static int vidioc_streamoff(struct file
*file
, void *priv
,
1406 enum v4l2_buf_type type
)
1408 struct cx231xx_fh
*fh
= priv
;
1409 struct cx231xx
*dev
= fh
->dev
;
1412 rc
= check_dev(dev
);
1416 if (type
!= fh
->type
)
1419 cx25840_call(dev
, video
, s_stream
, 0);
1421 videobuf_streamoff(&fh
->vb_vidq
);
1427 int cx231xx_querycap(struct file
*file
, void *priv
,
1428 struct v4l2_capability
*cap
)
1430 struct video_device
*vdev
= video_devdata(file
);
1431 struct cx231xx_fh
*fh
= priv
;
1432 struct cx231xx
*dev
= fh
->dev
;
1434 strlcpy(cap
->driver
, "cx231xx", sizeof(cap
->driver
));
1435 strlcpy(cap
->card
, cx231xx_boards
[dev
->model
].name
, sizeof(cap
->card
));
1436 usb_make_path(dev
->udev
, cap
->bus_info
, sizeof(cap
->bus_info
));
1438 if (vdev
->vfl_type
== VFL_TYPE_RADIO
)
1439 cap
->device_caps
= V4L2_CAP_RADIO
;
1441 cap
->device_caps
= V4L2_CAP_READWRITE
| V4L2_CAP_STREAMING
;
1442 if (vdev
->vfl_type
== VFL_TYPE_VBI
)
1443 cap
->device_caps
|= V4L2_CAP_VBI_CAPTURE
;
1445 cap
->device_caps
|= V4L2_CAP_VIDEO_CAPTURE
;
1447 if (dev
->tuner_type
!= TUNER_ABSENT
)
1448 cap
->device_caps
|= V4L2_CAP_TUNER
;
1449 cap
->capabilities
= cap
->device_caps
| V4L2_CAP_READWRITE
|
1450 V4L2_CAP_VBI_CAPTURE
| V4L2_CAP_VIDEO_CAPTURE
|
1451 V4L2_CAP_STREAMING
| V4L2_CAP_DEVICE_CAPS
;
1453 cap
->capabilities
|= V4L2_CAP_RADIO
;
1458 static int vidioc_enum_fmt_vid_cap(struct file
*file
, void *priv
,
1459 struct v4l2_fmtdesc
*f
)
1461 if (unlikely(f
->index
>= ARRAY_SIZE(format
)))
1464 strlcpy(f
->description
, format
[f
->index
].name
, sizeof(f
->description
));
1465 f
->pixelformat
= format
[f
->index
].fourcc
;
1470 /* RAW VBI ioctls */
1472 static int vidioc_g_fmt_vbi_cap(struct file
*file
, void *priv
,
1473 struct v4l2_format
*f
)
1475 struct cx231xx_fh
*fh
= priv
;
1476 struct cx231xx
*dev
= fh
->dev
;
1478 f
->fmt
.vbi
.sampling_rate
= 6750000 * 4;
1479 f
->fmt
.vbi
.samples_per_line
= VBI_LINE_LENGTH
;
1480 f
->fmt
.vbi
.sample_format
= V4L2_PIX_FMT_GREY
;
1481 f
->fmt
.vbi
.offset
= 0;
1482 f
->fmt
.vbi
.start
[0] = (dev
->norm
& V4L2_STD_625_50
) ?
1483 PAL_VBI_START_LINE
: NTSC_VBI_START_LINE
;
1484 f
->fmt
.vbi
.count
[0] = (dev
->norm
& V4L2_STD_625_50
) ?
1485 PAL_VBI_LINES
: NTSC_VBI_LINES
;
1486 f
->fmt
.vbi
.start
[1] = (dev
->norm
& V4L2_STD_625_50
) ?
1487 PAL_VBI_START_LINE
+ 312 : NTSC_VBI_START_LINE
+ 263;
1488 f
->fmt
.vbi
.count
[1] = f
->fmt
.vbi
.count
[0];
1489 memset(f
->fmt
.vbi
.reserved
, 0, sizeof(f
->fmt
.vbi
.reserved
));
1495 static int vidioc_try_fmt_vbi_cap(struct file
*file
, void *priv
,
1496 struct v4l2_format
*f
)
1498 struct cx231xx_fh
*fh
= priv
;
1499 struct cx231xx
*dev
= fh
->dev
;
1501 f
->fmt
.vbi
.sampling_rate
= 6750000 * 4;
1502 f
->fmt
.vbi
.samples_per_line
= VBI_LINE_LENGTH
;
1503 f
->fmt
.vbi
.sample_format
= V4L2_PIX_FMT_GREY
;
1504 f
->fmt
.vbi
.offset
= 0;
1505 f
->fmt
.vbi
.flags
= 0;
1506 f
->fmt
.vbi
.start
[0] = (dev
->norm
& V4L2_STD_625_50
) ?
1507 PAL_VBI_START_LINE
: NTSC_VBI_START_LINE
;
1508 f
->fmt
.vbi
.count
[0] = (dev
->norm
& V4L2_STD_625_50
) ?
1509 PAL_VBI_LINES
: NTSC_VBI_LINES
;
1510 f
->fmt
.vbi
.start
[1] = (dev
->norm
& V4L2_STD_625_50
) ?
1511 PAL_VBI_START_LINE
+ 312 : NTSC_VBI_START_LINE
+ 263;
1512 f
->fmt
.vbi
.count
[1] = f
->fmt
.vbi
.count
[0];
1513 memset(f
->fmt
.vbi
.reserved
, 0, sizeof(f
->fmt
.vbi
.reserved
));
1519 static int vidioc_s_fmt_vbi_cap(struct file
*file
, void *priv
,
1520 struct v4l2_format
*f
)
1522 struct cx231xx_fh
*fh
= priv
;
1523 struct cx231xx
*dev
= fh
->dev
;
1525 if (dev
->vbi_stream_on
&& !fh
->stream_on
) {
1526 cx231xx_errdev("%s device in use by another fh\n", __func__
);
1529 return vidioc_try_fmt_vbi_cap(file
, priv
, f
);
1532 static int vidioc_reqbufs(struct file
*file
, void *priv
,
1533 struct v4l2_requestbuffers
*rb
)
1535 struct cx231xx_fh
*fh
= priv
;
1536 struct cx231xx
*dev
= fh
->dev
;
1539 rc
= check_dev(dev
);
1543 return videobuf_reqbufs(&fh
->vb_vidq
, rb
);
1546 static int vidioc_querybuf(struct file
*file
, void *priv
, struct v4l2_buffer
*b
)
1548 struct cx231xx_fh
*fh
= priv
;
1549 struct cx231xx
*dev
= fh
->dev
;
1552 rc
= check_dev(dev
);
1556 return videobuf_querybuf(&fh
->vb_vidq
, b
);
1559 static int vidioc_qbuf(struct file
*file
, void *priv
, struct v4l2_buffer
*b
)
1561 struct cx231xx_fh
*fh
= priv
;
1562 struct cx231xx
*dev
= fh
->dev
;
1565 rc
= check_dev(dev
);
1569 return videobuf_qbuf(&fh
->vb_vidq
, b
);
1572 static int vidioc_dqbuf(struct file
*file
, void *priv
, struct v4l2_buffer
*b
)
1574 struct cx231xx_fh
*fh
= priv
;
1575 struct cx231xx
*dev
= fh
->dev
;
1578 rc
= check_dev(dev
);
1582 return videobuf_dqbuf(&fh
->vb_vidq
, b
, file
->f_flags
& O_NONBLOCK
);
1585 /* ----------------------------------------------------------- */
1586 /* RADIO ESPECIFIC IOCTLS */
1587 /* ----------------------------------------------------------- */
1589 static int radio_g_tuner(struct file
*file
, void *priv
, struct v4l2_tuner
*t
)
1591 struct cx231xx
*dev
= ((struct cx231xx_fh
*)priv
)->dev
;
1596 strcpy(t
->name
, "Radio");
1598 call_all(dev
, tuner
, g_tuner
, t
);
1602 static int radio_s_tuner(struct file
*file
, void *priv
, const struct v4l2_tuner
*t
)
1604 struct cx231xx
*dev
= ((struct cx231xx_fh
*)priv
)->dev
;
1609 call_all(dev
, tuner
, s_tuner
, t
);
1615 * cx231xx_v4l2_open()
1616 * inits the device and starts isoc transfer
1618 static int cx231xx_v4l2_open(struct file
*filp
)
1621 struct video_device
*vdev
= video_devdata(filp
);
1622 struct cx231xx
*dev
= video_drvdata(filp
);
1623 struct cx231xx_fh
*fh
;
1624 enum v4l2_buf_type fh_type
= 0;
1626 switch (vdev
->vfl_type
) {
1627 case VFL_TYPE_GRABBER
:
1628 fh_type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
1631 fh_type
= V4L2_BUF_TYPE_VBI_CAPTURE
;
1633 case VFL_TYPE_RADIO
:
1638 cx231xx_videodbg("open dev=%s type=%s users=%d\n",
1639 video_device_node_name(vdev
), v4l2_type_names
[fh_type
],
1643 errCode
= cx231xx_set_mode(dev
, CX231XX_ANALOG_MODE
);
1646 ("Device locked on digital mode. Can't open analog\n");
1651 fh
= kzalloc(sizeof(struct cx231xx_fh
), GFP_KERNEL
);
1653 cx231xx_errdev("cx231xx-video.c: Out of memory?!\n");
1656 if (mutex_lock_interruptible(&dev
->lock
)) {
1658 return -ERESTARTSYS
;
1662 filp
->private_data
= fh
;
1663 v4l2_fh_init(&fh
->fh
, vdev
);
1665 if (fh
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
&& dev
->users
== 0) {
1666 /* Power up in Analog TV mode */
1667 if (dev
->board
.external_av
)
1668 cx231xx_set_power_mode(dev
,
1669 POLARIS_AVMODE_ENXTERNAL_AV
);
1671 cx231xx_set_power_mode(dev
, POLARIS_AVMODE_ANALOGT_TV
);
1674 cx231xx_set_mode(dev
, CX231XX_ANALOG_MODE
);
1677 /* set video alternate setting */
1678 cx231xx_set_video_alternate(dev
);
1680 /* Needed, since GPIO might have disabled power of
1682 cx231xx_config_i2c(dev
);
1684 /* device needs to be initialized before isoc transfer */
1685 dev
->video_input
= dev
->video_input
> 2 ? 2 : dev
->video_input
;
1689 cx231xx_videodbg("video_open: setting radio device\n");
1691 /* cx231xx_start_radio(dev); */
1693 call_all(dev
, tuner
, s_radio
);
1698 if (fh
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1699 videobuf_queue_vmalloc_init(&fh
->vb_vidq
, &cx231xx_video_qops
,
1700 NULL
, &dev
->video_mode
.slock
,
1701 fh
->type
, V4L2_FIELD_INTERLACED
,
1702 sizeof(struct cx231xx_buffer
),
1704 if (fh
->type
== V4L2_BUF_TYPE_VBI_CAPTURE
) {
1705 /* Set the required alternate setting VBI interface works in
1707 cx231xx_set_alt_setting(dev
, INDEX_VANC
, 0);
1709 videobuf_queue_vmalloc_init(&fh
->vb_vidq
, &cx231xx_vbi_qops
,
1710 NULL
, &dev
->vbi_mode
.slock
,
1711 fh
->type
, V4L2_FIELD_SEQ_TB
,
1712 sizeof(struct cx231xx_buffer
),
1715 mutex_unlock(&dev
->lock
);
1716 v4l2_fh_add(&fh
->fh
);
1722 * cx231xx_realease_resources()
1723 * unregisters the v4l2,i2c and usb devices
1724 * called when the device gets disconected or at module unload
1726 void cx231xx_release_analog_resources(struct cx231xx
*dev
)
1729 /*FIXME: I2C IR should be disconnected */
1731 if (dev
->radio_dev
) {
1732 if (video_is_registered(dev
->radio_dev
))
1733 video_unregister_device(dev
->radio_dev
);
1735 video_device_release(dev
->radio_dev
);
1736 dev
->radio_dev
= NULL
;
1739 cx231xx_info("V4L2 device %s deregistered\n",
1740 video_device_node_name(dev
->vbi_dev
));
1741 if (video_is_registered(dev
->vbi_dev
))
1742 video_unregister_device(dev
->vbi_dev
);
1744 video_device_release(dev
->vbi_dev
);
1745 dev
->vbi_dev
= NULL
;
1748 cx231xx_info("V4L2 device %s deregistered\n",
1749 video_device_node_name(dev
->vdev
));
1751 if (dev
->board
.has_417
)
1752 cx231xx_417_unregister(dev
);
1754 if (video_is_registered(dev
->vdev
))
1755 video_unregister_device(dev
->vdev
);
1757 video_device_release(dev
->vdev
);
1760 v4l2_ctrl_handler_free(&dev
->ctrl_handler
);
1761 v4l2_ctrl_handler_free(&dev
->radio_ctrl_handler
);
1766 * stops streaming and deallocates all resources allocated by the v4l2
1769 static int cx231xx_close(struct file
*filp
)
1771 struct cx231xx_fh
*fh
= filp
->private_data
;
1772 struct cx231xx
*dev
= fh
->dev
;
1774 cx231xx_videodbg("users=%d\n", dev
->users
);
1776 cx231xx_videodbg("users=%d\n", dev
->users
);
1781 * To workaround error number=-71 on EP0 for VideoGrabber,
1782 * need exclude following.
1783 * FIXME: It is probably safe to remove most of these, as we're
1784 * now avoiding the alternate setting for INDEX_VANC
1786 if (!dev
->board
.no_alt_vanc
)
1787 if (fh
->type
== V4L2_BUF_TYPE_VBI_CAPTURE
) {
1788 videobuf_stop(&fh
->vb_vidq
);
1789 videobuf_mmap_free(&fh
->vb_vidq
);
1791 /* the device is already disconnect,
1792 free the remaining resources */
1793 if (dev
->state
& DEV_DISCONNECTED
) {
1794 if (atomic_read(&dev
->devlist_count
) > 0) {
1795 cx231xx_release_resources(dev
);
1802 /* do this before setting alternate! */
1803 cx231xx_uninit_vbi_isoc(dev
);
1805 /* set alternate 0 */
1806 if (!dev
->vbi_or_sliced_cc_mode
)
1807 cx231xx_set_alt_setting(dev
, INDEX_VANC
, 0);
1809 cx231xx_set_alt_setting(dev
, INDEX_HANC
, 0);
1811 v4l2_fh_del(&fh
->fh
);
1812 v4l2_fh_exit(&fh
->fh
);
1815 wake_up_interruptible_nr(&dev
->open
, 1);
1819 v4l2_fh_del(&fh
->fh
);
1822 videobuf_stop(&fh
->vb_vidq
);
1823 videobuf_mmap_free(&fh
->vb_vidq
);
1825 /* the device is already disconnect,
1826 free the remaining resources */
1827 if (dev
->state
& DEV_DISCONNECTED
) {
1828 cx231xx_release_resources(dev
);
1833 /* Save some power by putting tuner to sleep */
1834 call_all(dev
, core
, s_power
, 0);
1836 /* do this before setting alternate! */
1838 cx231xx_uninit_isoc(dev
);
1840 cx231xx_uninit_bulk(dev
);
1841 cx231xx_set_mode(dev
, CX231XX_SUSPEND
);
1843 /* set alternate 0 */
1844 cx231xx_set_alt_setting(dev
, INDEX_VIDEO
, 0);
1846 v4l2_fh_exit(&fh
->fh
);
1848 wake_up_interruptible_nr(&dev
->open
, 1);
1852 static int cx231xx_v4l2_close(struct file
*filp
)
1854 struct cx231xx_fh
*fh
= filp
->private_data
;
1855 struct cx231xx
*dev
= fh
->dev
;
1858 mutex_lock(&dev
->lock
);
1859 rc
= cx231xx_close(filp
);
1860 mutex_unlock(&dev
->lock
);
1865 * cx231xx_v4l2_read()
1866 * will allocate buffers when called for the first time
1869 cx231xx_v4l2_read(struct file
*filp
, char __user
*buf
, size_t count
,
1872 struct cx231xx_fh
*fh
= filp
->private_data
;
1873 struct cx231xx
*dev
= fh
->dev
;
1876 rc
= check_dev(dev
);
1880 if ((fh
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
) ||
1881 (fh
->type
== V4L2_BUF_TYPE_VBI_CAPTURE
)) {
1884 if (unlikely(rc
< 0))
1887 if (mutex_lock_interruptible(&dev
->lock
))
1888 return -ERESTARTSYS
;
1889 rc
= videobuf_read_stream(&fh
->vb_vidq
, buf
, count
, pos
, 0,
1890 filp
->f_flags
& O_NONBLOCK
);
1891 mutex_unlock(&dev
->lock
);
1898 * cx231xx_v4l2_poll()
1899 * will allocate buffers when called for the first time
1901 static unsigned int cx231xx_v4l2_poll(struct file
*filp
, poll_table
*wait
)
1903 unsigned long req_events
= poll_requested_events(wait
);
1904 struct cx231xx_fh
*fh
= filp
->private_data
;
1905 struct cx231xx
*dev
= fh
->dev
;
1909 rc
= check_dev(dev
);
1915 if (unlikely(rc
< 0))
1918 if (v4l2_event_pending(&fh
->fh
))
1921 poll_wait(filp
, &fh
->fh
.wait
, wait
);
1923 if (!(req_events
& (POLLIN
| POLLRDNORM
)))
1926 if ((V4L2_BUF_TYPE_VIDEO_CAPTURE
== fh
->type
) ||
1927 (V4L2_BUF_TYPE_VBI_CAPTURE
== fh
->type
)) {
1928 mutex_lock(&dev
->lock
);
1929 res
|= videobuf_poll_stream(filp
, &fh
->vb_vidq
, wait
);
1930 mutex_unlock(&dev
->lock
);
1933 return res
| POLLERR
;
1937 * cx231xx_v4l2_mmap()
1939 static int cx231xx_v4l2_mmap(struct file
*filp
, struct vm_area_struct
*vma
)
1941 struct cx231xx_fh
*fh
= filp
->private_data
;
1942 struct cx231xx
*dev
= fh
->dev
;
1945 rc
= check_dev(dev
);
1951 if (unlikely(rc
< 0))
1954 if (mutex_lock_interruptible(&dev
->lock
))
1955 return -ERESTARTSYS
;
1956 rc
= videobuf_mmap_mapper(&fh
->vb_vidq
, vma
);
1957 mutex_unlock(&dev
->lock
);
1959 cx231xx_videodbg("vma start=0x%08lx, size=%ld, ret=%d\n",
1960 (unsigned long)vma
->vm_start
,
1961 (unsigned long)vma
->vm_end
-
1962 (unsigned long)vma
->vm_start
, rc
);
1967 static const struct v4l2_file_operations cx231xx_v4l_fops
= {
1968 .owner
= THIS_MODULE
,
1969 .open
= cx231xx_v4l2_open
,
1970 .release
= cx231xx_v4l2_close
,
1971 .read
= cx231xx_v4l2_read
,
1972 .poll
= cx231xx_v4l2_poll
,
1973 .mmap
= cx231xx_v4l2_mmap
,
1974 .unlocked_ioctl
= video_ioctl2
,
1977 static const struct v4l2_ioctl_ops video_ioctl_ops
= {
1978 .vidioc_querycap
= cx231xx_querycap
,
1979 .vidioc_enum_fmt_vid_cap
= vidioc_enum_fmt_vid_cap
,
1980 .vidioc_g_fmt_vid_cap
= vidioc_g_fmt_vid_cap
,
1981 .vidioc_try_fmt_vid_cap
= vidioc_try_fmt_vid_cap
,
1982 .vidioc_s_fmt_vid_cap
= vidioc_s_fmt_vid_cap
,
1983 .vidioc_g_fmt_vbi_cap
= vidioc_g_fmt_vbi_cap
,
1984 .vidioc_try_fmt_vbi_cap
= vidioc_try_fmt_vbi_cap
,
1985 .vidioc_s_fmt_vbi_cap
= vidioc_s_fmt_vbi_cap
,
1986 .vidioc_cropcap
= vidioc_cropcap
,
1987 .vidioc_reqbufs
= vidioc_reqbufs
,
1988 .vidioc_querybuf
= vidioc_querybuf
,
1989 .vidioc_qbuf
= vidioc_qbuf
,
1990 .vidioc_dqbuf
= vidioc_dqbuf
,
1991 .vidioc_s_std
= vidioc_s_std
,
1992 .vidioc_g_std
= vidioc_g_std
,
1993 .vidioc_enum_input
= cx231xx_enum_input
,
1994 .vidioc_g_input
= cx231xx_g_input
,
1995 .vidioc_s_input
= cx231xx_s_input
,
1996 .vidioc_streamon
= vidioc_streamon
,
1997 .vidioc_streamoff
= vidioc_streamoff
,
1998 .vidioc_g_tuner
= cx231xx_g_tuner
,
1999 .vidioc_s_tuner
= cx231xx_s_tuner
,
2000 .vidioc_g_frequency
= cx231xx_g_frequency
,
2001 .vidioc_s_frequency
= cx231xx_s_frequency
,
2002 #ifdef CONFIG_VIDEO_ADV_DEBUG
2003 .vidioc_g_chip_info
= cx231xx_g_chip_info
,
2004 .vidioc_g_register
= cx231xx_g_register
,
2005 .vidioc_s_register
= cx231xx_s_register
,
2007 .vidioc_subscribe_event
= v4l2_ctrl_subscribe_event
,
2008 .vidioc_unsubscribe_event
= v4l2_event_unsubscribe
,
2011 static struct video_device cx231xx_vbi_template
;
2013 static const struct video_device cx231xx_video_template
= {
2014 .fops
= &cx231xx_v4l_fops
,
2015 .release
= video_device_release
,
2016 .ioctl_ops
= &video_ioctl_ops
,
2017 .tvnorms
= V4L2_STD_ALL
,
2020 static const struct v4l2_file_operations radio_fops
= {
2021 .owner
= THIS_MODULE
,
2022 .open
= cx231xx_v4l2_open
,
2023 .release
= cx231xx_v4l2_close
,
2024 .poll
= v4l2_ctrl_poll
,
2025 .unlocked_ioctl
= video_ioctl2
,
2028 static const struct v4l2_ioctl_ops radio_ioctl_ops
= {
2029 .vidioc_querycap
= cx231xx_querycap
,
2030 .vidioc_g_tuner
= radio_g_tuner
,
2031 .vidioc_s_tuner
= radio_s_tuner
,
2032 .vidioc_g_frequency
= cx231xx_g_frequency
,
2033 .vidioc_s_frequency
= cx231xx_s_frequency
,
2034 #ifdef CONFIG_VIDEO_ADV_DEBUG
2035 .vidioc_g_chip_info
= cx231xx_g_chip_info
,
2036 .vidioc_g_register
= cx231xx_g_register
,
2037 .vidioc_s_register
= cx231xx_s_register
,
2039 .vidioc_subscribe_event
= v4l2_ctrl_subscribe_event
,
2040 .vidioc_unsubscribe_event
= v4l2_event_unsubscribe
,
2043 static struct video_device cx231xx_radio_template
= {
2044 .name
= "cx231xx-radio",
2045 .fops
= &radio_fops
,
2046 .ioctl_ops
= &radio_ioctl_ops
,
2049 /******************************** usb interface ******************************/
2051 static struct video_device
*cx231xx_vdev_init(struct cx231xx
*dev
,
2052 const struct video_device
2053 *template, const char *type_name
)
2055 struct video_device
*vfd
;
2057 vfd
= video_device_alloc();
2062 vfd
->v4l2_dev
= &dev
->v4l2_dev
;
2063 vfd
->release
= video_device_release
;
2064 vfd
->debug
= video_debug
;
2065 vfd
->lock
= &dev
->lock
;
2067 snprintf(vfd
->name
, sizeof(vfd
->name
), "%s %s", dev
->name
, type_name
);
2069 video_set_drvdata(vfd
, dev
);
2070 if (dev
->tuner_type
== TUNER_ABSENT
) {
2071 v4l2_disable_ioctl(vfd
, VIDIOC_G_FREQUENCY
);
2072 v4l2_disable_ioctl(vfd
, VIDIOC_S_FREQUENCY
);
2073 v4l2_disable_ioctl(vfd
, VIDIOC_G_TUNER
);
2074 v4l2_disable_ioctl(vfd
, VIDIOC_S_TUNER
);
2079 int cx231xx_register_analog_devices(struct cx231xx
*dev
)
2083 cx231xx_info("%s: v4l2 driver version %s\n",
2084 dev
->name
, CX231XX_VERSION
);
2086 /* set default norm */
2087 dev
->norm
= V4L2_STD_PAL
;
2088 dev
->width
= norm_maxw(dev
);
2089 dev
->height
= norm_maxh(dev
);
2090 dev
->interlaced
= 0;
2092 /* Analog specific initialization */
2093 dev
->format
= &format
[0];
2095 /* Set the initial input */
2096 video_mux(dev
, dev
->video_input
);
2098 call_all(dev
, video
, s_std
, dev
->norm
);
2100 v4l2_ctrl_handler_init(&dev
->ctrl_handler
, 10);
2101 v4l2_ctrl_handler_init(&dev
->radio_ctrl_handler
, 5);
2103 if (dev
->sd_cx25840
) {
2104 v4l2_ctrl_add_handler(&dev
->ctrl_handler
,
2105 dev
->sd_cx25840
->ctrl_handler
, NULL
);
2106 v4l2_ctrl_add_handler(&dev
->radio_ctrl_handler
,
2107 dev
->sd_cx25840
->ctrl_handler
,
2108 v4l2_ctrl_radio_filter
);
2111 if (dev
->ctrl_handler
.error
)
2112 return dev
->ctrl_handler
.error
;
2113 if (dev
->radio_ctrl_handler
.error
)
2114 return dev
->radio_ctrl_handler
.error
;
2116 /* enable vbi capturing */
2117 /* write code here... */
2119 /* allocate and fill video video_device struct */
2120 dev
->vdev
= cx231xx_vdev_init(dev
, &cx231xx_video_template
, "video");
2122 cx231xx_errdev("cannot allocate video_device.\n");
2126 dev
->vdev
->ctrl_handler
= &dev
->ctrl_handler
;
2127 /* register v4l2 video video_device */
2128 ret
= video_register_device(dev
->vdev
, VFL_TYPE_GRABBER
,
2129 video_nr
[dev
->devno
]);
2131 cx231xx_errdev("unable to register video device (error=%i).\n",
2136 cx231xx_info("%s/0: registered device %s [v4l2]\n",
2137 dev
->name
, video_device_node_name(dev
->vdev
));
2139 /* Initialize VBI template */
2140 cx231xx_vbi_template
= cx231xx_video_template
;
2141 strcpy(cx231xx_vbi_template
.name
, "cx231xx-vbi");
2143 /* Allocate and fill vbi video_device struct */
2144 dev
->vbi_dev
= cx231xx_vdev_init(dev
, &cx231xx_vbi_template
, "vbi");
2146 if (!dev
->vbi_dev
) {
2147 cx231xx_errdev("cannot allocate video_device.\n");
2150 dev
->vbi_dev
->ctrl_handler
= &dev
->ctrl_handler
;
2151 /* register v4l2 vbi video_device */
2152 ret
= video_register_device(dev
->vbi_dev
, VFL_TYPE_VBI
,
2153 vbi_nr
[dev
->devno
]);
2155 cx231xx_errdev("unable to register vbi device\n");
2159 cx231xx_info("%s/0: registered device %s\n",
2160 dev
->name
, video_device_node_name(dev
->vbi_dev
));
2162 if (cx231xx_boards
[dev
->model
].radio
.type
== CX231XX_RADIO
) {
2163 dev
->radio_dev
= cx231xx_vdev_init(dev
, &cx231xx_radio_template
,
2165 if (!dev
->radio_dev
) {
2166 cx231xx_errdev("cannot allocate video_device.\n");
2169 dev
->radio_dev
->ctrl_handler
= &dev
->radio_ctrl_handler
;
2170 ret
= video_register_device(dev
->radio_dev
, VFL_TYPE_RADIO
,
2171 radio_nr
[dev
->devno
]);
2173 cx231xx_errdev("can't register radio device\n");
2176 cx231xx_info("Registered radio device as %s\n",
2177 video_device_node_name(dev
->radio_dev
));
2180 cx231xx_info("V4L2 device registered as %s and %s\n",
2181 video_device_node_name(dev
->vdev
),
2182 video_device_node_name(dev
->vbi_dev
));