2 * Driver for the Conexant CX23885 PCIe bridge
4 * Copyright (c) 2007 Steven Toth <stoth@linuxtv.org>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
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.
22 #include <linux/init.h>
23 #include <linux/list.h>
24 #include <linux/module.h>
25 #include <linux/moduleparam.h>
26 #include <linux/kmod.h>
27 #include <linux/kernel.h>
28 #include <linux/slab.h>
29 #include <linux/interrupt.h>
30 #include <linux/delay.h>
31 #include <linux/kthread.h>
32 #include <asm/div64.h>
35 #include <media/v4l2-common.h>
36 #include <media/v4l2-ioctl.h>
37 #include "cx23885-ioctl.h"
38 #include "tuner-xc2028.h"
40 MODULE_DESCRIPTION("v4l2 driver module for cx23885 based TV cards");
41 MODULE_AUTHOR("Steven Toth <stoth@linuxtv.org>");
42 MODULE_LICENSE("GPL");
44 /* ------------------------------------------------------------------ */
46 static unsigned int video_nr
[] = {[0 ... (CX23885_MAXBOARDS
- 1)] = UNSET
};
47 static unsigned int vbi_nr
[] = {[0 ... (CX23885_MAXBOARDS
- 1)] = UNSET
};
48 static unsigned int radio_nr
[] = {[0 ... (CX23885_MAXBOARDS
- 1)] = UNSET
};
50 module_param_array(video_nr
, int, NULL
, 0444);
51 module_param_array(vbi_nr
, int, NULL
, 0444);
52 module_param_array(radio_nr
, int, NULL
, 0444);
54 MODULE_PARM_DESC(video_nr
, "video device numbers");
55 MODULE_PARM_DESC(vbi_nr
, "vbi device numbers");
56 MODULE_PARM_DESC(radio_nr
, "radio device numbers");
58 static unsigned int video_debug
;
59 module_param(video_debug
, int, 0644);
60 MODULE_PARM_DESC(video_debug
, "enable debug messages [video]");
62 static unsigned int irq_debug
;
63 module_param(irq_debug
, int, 0644);
64 MODULE_PARM_DESC(irq_debug
, "enable debug messages [IRQ handler]");
66 static unsigned int vid_limit
= 16;
67 module_param(vid_limit
, int, 0644);
68 MODULE_PARM_DESC(vid_limit
, "capture memory limit in megabytes");
70 #define dprintk(level, fmt, arg...)\
71 do { if (video_debug >= level)\
72 printk(KERN_DEBUG "%s/0: " fmt, dev->name, ## arg);\
75 /* ------------------------------------------------------------------- */
78 #define FORMAT_FLAGS_PACKED 0x01
80 static struct cx23885_fmt formats
[] = {
82 .name
= "8 bpp, gray",
83 .fourcc
= V4L2_PIX_FMT_GREY
,
85 .flags
= FORMAT_FLAGS_PACKED
,
87 .name
= "15 bpp RGB, le",
88 .fourcc
= V4L2_PIX_FMT_RGB555
,
90 .flags
= FORMAT_FLAGS_PACKED
,
92 .name
= "15 bpp RGB, be",
93 .fourcc
= V4L2_PIX_FMT_RGB555X
,
95 .flags
= FORMAT_FLAGS_PACKED
,
97 .name
= "16 bpp RGB, le",
98 .fourcc
= V4L2_PIX_FMT_RGB565
,
100 .flags
= FORMAT_FLAGS_PACKED
,
102 .name
= "16 bpp RGB, be",
103 .fourcc
= V4L2_PIX_FMT_RGB565X
,
105 .flags
= FORMAT_FLAGS_PACKED
,
107 .name
= "24 bpp RGB, le",
108 .fourcc
= V4L2_PIX_FMT_BGR24
,
110 .flags
= FORMAT_FLAGS_PACKED
,
112 .name
= "32 bpp RGB, le",
113 .fourcc
= V4L2_PIX_FMT_BGR32
,
115 .flags
= FORMAT_FLAGS_PACKED
,
117 .name
= "32 bpp RGB, be",
118 .fourcc
= V4L2_PIX_FMT_RGB32
,
120 .flags
= FORMAT_FLAGS_PACKED
,
122 .name
= "4:2:2, packed, YUYV",
123 .fourcc
= V4L2_PIX_FMT_YUYV
,
125 .flags
= FORMAT_FLAGS_PACKED
,
127 .name
= "4:2:2, packed, UYVY",
128 .fourcc
= V4L2_PIX_FMT_UYVY
,
130 .flags
= FORMAT_FLAGS_PACKED
,
134 static struct cx23885_fmt
*format_by_fourcc(unsigned int fourcc
)
138 for (i
= 0; i
< ARRAY_SIZE(formats
); i
++)
139 if (formats
[i
].fourcc
== fourcc
)
142 printk(KERN_ERR
"%s(0x%08x) NOT FOUND\n", __func__
, fourcc
);
146 /* ------------------------------------------------------------------- */
148 static const struct v4l2_queryctrl no_ctl
= {
150 .flags
= V4L2_CTRL_FLAG_DISABLED
,
153 static struct cx23885_ctrl cx23885_ctls
[] = {
157 .id
= V4L2_CID_BRIGHTNESS
,
158 .name
= "Brightness",
162 .default_value
= 0x7f,
163 .type
= V4L2_CTRL_TYPE_INTEGER
,
171 .id
= V4L2_CID_CONTRAST
,
176 .default_value
= 0x3f,
177 .type
= V4L2_CTRL_TYPE_INTEGER
,
190 .default_value
= 0x7f,
191 .type
= V4L2_CTRL_TYPE_INTEGER
,
198 /* strictly, this only describes only U saturation.
199 * V saturation is handled specially through code.
202 .id
= V4L2_CID_SATURATION
,
203 .name
= "Saturation",
207 .default_value
= 0x7f,
208 .type
= V4L2_CTRL_TYPE_INTEGER
,
217 .id
= V4L2_CID_AUDIO_MUTE
,
222 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
225 .mask
= (0x1f << 24),
229 .id
= V4L2_CID_AUDIO_VOLUME
,
234 .default_value
= 0x3f,
235 .type
= V4L2_CTRL_TYPE_INTEGER
,
237 .reg
= PATH1_VOL_CTL
,
242 static const int CX23885_CTLS
= ARRAY_SIZE(cx23885_ctls
);
244 /* Must be sorted from low to high control ID! */
245 static const u32 cx23885_user_ctrls
[] = {
251 V4L2_CID_AUDIO_VOLUME
,
256 static const u32
*ctrl_classes
[] = {
261 static void cx23885_video_wakeup(struct cx23885_dev
*dev
,
262 struct cx23885_dmaqueue
*q
, u32 count
)
264 struct cx23885_buffer
*buf
;
267 for (bc
= 0;; bc
++) {
268 if (list_empty(&q
->active
))
270 buf
= list_entry(q
->active
.next
,
271 struct cx23885_buffer
, vb
.queue
);
273 /* count comes from the hw and is is 16bit wide --
274 * this trick handles wrap-arounds correctly for
275 * up to 32767 buffers in flight... */
276 if ((s16
) (count
- buf
->count
) < 0)
279 do_gettimeofday(&buf
->vb
.ts
);
280 dprintk(2, "[%p/%d] wakeup reg=%d buf=%d\n", buf
, buf
->vb
.i
,
282 buf
->vb
.state
= VIDEOBUF_DONE
;
283 list_del(&buf
->vb
.queue
);
284 wake_up(&buf
->vb
.done
);
286 if (list_empty(&q
->active
))
287 del_timer(&q
->timeout
);
289 mod_timer(&q
->timeout
, jiffies
+BUFFER_TIMEOUT
);
291 printk(KERN_ERR
"%s: %d buffers handled (should be 1)\n",
295 static int cx23885_set_tvnorm(struct cx23885_dev
*dev
, v4l2_std_id norm
)
297 dprintk(1, "%s(norm = 0x%08x) name: [%s]\n",
300 v4l2_norm_to_name(norm
));
304 call_all(dev
, core
, s_std
, norm
);
309 static struct video_device
*cx23885_vdev_init(struct cx23885_dev
*dev
,
311 struct video_device
*template,
314 struct video_device
*vfd
;
315 dprintk(1, "%s()\n", __func__
);
317 vfd
= video_device_alloc();
321 vfd
->v4l2_dev
= &dev
->v4l2_dev
;
322 vfd
->release
= video_device_release
;
323 snprintf(vfd
->name
, sizeof(vfd
->name
), "%s %s (%s)",
324 dev
->name
, type
, cx23885_boards
[dev
->board
].name
);
325 video_set_drvdata(vfd
, dev
);
329 static int cx23885_ctrl_query(struct v4l2_queryctrl
*qctrl
)
333 if (qctrl
->id
< V4L2_CID_BASE
||
334 qctrl
->id
>= V4L2_CID_LASTP1
)
336 for (i
= 0; i
< CX23885_CTLS
; i
++)
337 if (cx23885_ctls
[i
].v
.id
== qctrl
->id
)
339 if (i
== CX23885_CTLS
) {
343 *qctrl
= cx23885_ctls
[i
].v
;
347 /* ------------------------------------------------------------------- */
348 /* resource management */
350 static int res_get(struct cx23885_dev
*dev
, struct cx23885_fh
*fh
,
353 dprintk(1, "%s()\n", __func__
);
354 if (fh
->resources
& bit
)
355 /* have it already allocated */
359 mutex_lock(&dev
->lock
);
360 if (dev
->resources
& bit
) {
361 /* no, someone else uses it */
362 mutex_unlock(&dev
->lock
);
365 /* it's free, grab it */
366 fh
->resources
|= bit
;
367 dev
->resources
|= bit
;
368 dprintk(1, "res: get %d\n", bit
);
369 mutex_unlock(&dev
->lock
);
373 static int res_check(struct cx23885_fh
*fh
, unsigned int bit
)
375 return fh
->resources
& bit
;
378 static int res_locked(struct cx23885_dev
*dev
, unsigned int bit
)
380 return dev
->resources
& bit
;
383 static void res_free(struct cx23885_dev
*dev
, struct cx23885_fh
*fh
,
386 BUG_ON((fh
->resources
& bits
) != bits
);
387 dprintk(1, "%s()\n", __func__
);
389 mutex_lock(&dev
->lock
);
390 fh
->resources
&= ~bits
;
391 dev
->resources
&= ~bits
;
392 dprintk(1, "res: put %d\n", bits
);
393 mutex_unlock(&dev
->lock
);
396 static int cx23885_video_mux(struct cx23885_dev
*dev
, unsigned int input
)
398 dprintk(1, "%s() video_mux: %d [vmux=%d, gpio=0x%x,0x%x,0x%x,0x%x]\n",
400 input
, INPUT(input
)->vmux
,
401 INPUT(input
)->gpio0
, INPUT(input
)->gpio1
,
402 INPUT(input
)->gpio2
, INPUT(input
)->gpio3
);
405 if (dev
->board
== CX23885_BOARD_MYGICA_X8506
||
406 dev
->board
== CX23885_BOARD_MAGICPRO_PROHDTVE2
) {
407 /* Select Analog TV */
408 if (INPUT(input
)->type
== CX23885_VMUX_TELEVISION
)
409 cx23885_gpio_clear(dev
, GPIO_0
);
412 /* Tell the internal A/V decoder */
413 v4l2_subdev_call(dev
->sd_cx25840
, video
, s_routing
,
414 INPUT(input
)->vmux
, 0, 0);
419 /* ------------------------------------------------------------------ */
420 static int cx23885_set_scale(struct cx23885_dev
*dev
, unsigned int width
,
421 unsigned int height
, enum v4l2_field field
)
423 dprintk(1, "%s()\n", __func__
);
427 static int cx23885_start_video_dma(struct cx23885_dev
*dev
,
428 struct cx23885_dmaqueue
*q
,
429 struct cx23885_buffer
*buf
)
431 dprintk(1, "%s()\n", __func__
);
433 /* setup fifo + format */
434 cx23885_sram_channel_setup(dev
, &dev
->sram_channels
[SRAM_CH01
],
435 buf
->bpl
, buf
->risc
.dma
);
436 cx23885_set_scale(dev
, buf
->vb
.width
, buf
->vb
.height
, buf
->vb
.field
);
439 cx_write(VID_A_GPCNT_CTL
, 3);
443 cx23885_irq_add_enable(dev
, 0x01);
444 cx_set(VID_A_INT_MSK
, 0x000011);
447 cx_set(DEV_CNTRL2
, (1<<5));
448 cx_set(VID_A_DMA_CTL
, 0x11); /* FIFO and RISC enable */
454 static int cx23885_restart_video_queue(struct cx23885_dev
*dev
,
455 struct cx23885_dmaqueue
*q
)
457 struct cx23885_buffer
*buf
, *prev
;
458 struct list_head
*item
;
459 dprintk(1, "%s()\n", __func__
);
461 if (!list_empty(&q
->active
)) {
462 buf
= list_entry(q
->active
.next
, struct cx23885_buffer
,
464 dprintk(2, "restart_queue [%p/%d]: restart dma\n",
466 cx23885_start_video_dma(dev
, q
, buf
);
467 list_for_each(item
, &q
->active
) {
468 buf
= list_entry(item
, struct cx23885_buffer
,
470 buf
->count
= q
->count
++;
472 mod_timer(&q
->timeout
, jiffies
+BUFFER_TIMEOUT
);
478 if (list_empty(&q
->queued
))
480 buf
= list_entry(q
->queued
.next
, struct cx23885_buffer
,
483 list_move_tail(&buf
->vb
.queue
, &q
->active
);
484 cx23885_start_video_dma(dev
, q
, buf
);
485 buf
->vb
.state
= VIDEOBUF_ACTIVE
;
486 buf
->count
= q
->count
++;
487 mod_timer(&q
->timeout
, jiffies
+BUFFER_TIMEOUT
);
488 dprintk(2, "[%p/%d] restart_queue - first active\n",
491 } else if (prev
->vb
.width
== buf
->vb
.width
&&
492 prev
->vb
.height
== buf
->vb
.height
&&
493 prev
->fmt
== buf
->fmt
) {
494 list_move_tail(&buf
->vb
.queue
, &q
->active
);
495 buf
->vb
.state
= VIDEOBUF_ACTIVE
;
496 buf
->count
= q
->count
++;
497 prev
->risc
.jmp
[1] = cpu_to_le32(buf
->risc
.dma
);
498 prev
->risc
.jmp
[2] = cpu_to_le32(0); /* Bits 63 - 32 */
499 dprintk(2, "[%p/%d] restart_queue - move to active\n",
508 static int buffer_setup(struct videobuf_queue
*q
, unsigned int *count
,
511 struct cx23885_fh
*fh
= q
->priv_data
;
513 *size
= fh
->fmt
->depth
*fh
->width
*fh
->height
>> 3;
516 if (*size
* *count
> vid_limit
* 1024 * 1024)
517 *count
= (vid_limit
* 1024 * 1024) / *size
;
521 static int buffer_prepare(struct videobuf_queue
*q
, struct videobuf_buffer
*vb
,
522 enum v4l2_field field
)
524 struct cx23885_fh
*fh
= q
->priv_data
;
525 struct cx23885_dev
*dev
= fh
->dev
;
526 struct cx23885_buffer
*buf
=
527 container_of(vb
, struct cx23885_buffer
, vb
);
528 int rc
, init_buffer
= 0;
529 u32 line0_offset
, line1_offset
;
530 struct videobuf_dmabuf
*dma
= videobuf_to_dma(&buf
->vb
);
532 BUG_ON(NULL
== fh
->fmt
);
533 if (fh
->width
< 48 || fh
->width
> norm_maxw(dev
->tvnorm
) ||
534 fh
->height
< 32 || fh
->height
> norm_maxh(dev
->tvnorm
))
536 buf
->vb
.size
= (fh
->width
* fh
->height
* fh
->fmt
->depth
) >> 3;
537 if (0 != buf
->vb
.baddr
&& buf
->vb
.bsize
< buf
->vb
.size
)
540 if (buf
->fmt
!= fh
->fmt
||
541 buf
->vb
.width
!= fh
->width
||
542 buf
->vb
.height
!= fh
->height
||
543 buf
->vb
.field
!= field
) {
545 buf
->vb
.width
= fh
->width
;
546 buf
->vb
.height
= fh
->height
;
547 buf
->vb
.field
= field
;
551 if (VIDEOBUF_NEEDS_INIT
== buf
->vb
.state
) {
553 rc
= videobuf_iolock(q
, &buf
->vb
, NULL
);
559 buf
->bpl
= buf
->vb
.width
* buf
->fmt
->depth
>> 3;
560 switch (buf
->vb
.field
) {
562 cx23885_risc_buffer(dev
->pci
, &buf
->risc
,
563 dma
->sglist
, 0, UNSET
,
564 buf
->bpl
, 0, buf
->vb
.height
);
566 case V4L2_FIELD_BOTTOM
:
567 cx23885_risc_buffer(dev
->pci
, &buf
->risc
,
568 dma
->sglist
, UNSET
, 0,
569 buf
->bpl
, 0, buf
->vb
.height
);
571 case V4L2_FIELD_INTERLACED
:
572 if (dev
->tvnorm
& V4L2_STD_NTSC
) {
573 /* cx25840 transmits NTSC bottom field first */
574 dprintk(1, "%s() Creating NTSC risc\n",
576 line0_offset
= buf
->bpl
;
579 /* All other formats are top field first */
580 dprintk(1, "%s() Creating PAL/SECAM risc\n",
583 line1_offset
= buf
->bpl
;
585 cx23885_risc_buffer(dev
->pci
, &buf
->risc
,
586 dma
->sglist
, line0_offset
,
589 buf
->vb
.height
>> 1);
591 case V4L2_FIELD_SEQ_TB
:
592 cx23885_risc_buffer(dev
->pci
, &buf
->risc
,
594 0, buf
->bpl
* (buf
->vb
.height
>> 1),
596 buf
->vb
.height
>> 1);
598 case V4L2_FIELD_SEQ_BT
:
599 cx23885_risc_buffer(dev
->pci
, &buf
->risc
,
601 buf
->bpl
* (buf
->vb
.height
>> 1), 0,
603 buf
->vb
.height
>> 1);
609 dprintk(2, "[%p/%d] buffer_prep - %dx%d %dbpp \"%s\" - dma=0x%08lx\n",
611 fh
->width
, fh
->height
, fh
->fmt
->depth
, fh
->fmt
->name
,
612 (unsigned long)buf
->risc
.dma
);
614 buf
->vb
.state
= VIDEOBUF_PREPARED
;
618 cx23885_free_buffer(q
, buf
);
622 static void buffer_queue(struct videobuf_queue
*vq
, struct videobuf_buffer
*vb
)
624 struct cx23885_buffer
*buf
= container_of(vb
,
625 struct cx23885_buffer
, vb
);
626 struct cx23885_buffer
*prev
;
627 struct cx23885_fh
*fh
= vq
->priv_data
;
628 struct cx23885_dev
*dev
= fh
->dev
;
629 struct cx23885_dmaqueue
*q
= &dev
->vidq
;
631 /* add jump to stopper */
632 buf
->risc
.jmp
[0] = cpu_to_le32(RISC_JUMP
| RISC_IRQ1
| RISC_CNT_INC
);
633 buf
->risc
.jmp
[1] = cpu_to_le32(q
->stopper
.dma
);
634 buf
->risc
.jmp
[2] = cpu_to_le32(0); /* bits 63-32 */
636 if (!list_empty(&q
->queued
)) {
637 list_add_tail(&buf
->vb
.queue
, &q
->queued
);
638 buf
->vb
.state
= VIDEOBUF_QUEUED
;
639 dprintk(2, "[%p/%d] buffer_queue - append to queued\n",
642 } else if (list_empty(&q
->active
)) {
643 list_add_tail(&buf
->vb
.queue
, &q
->active
);
644 cx23885_start_video_dma(dev
, q
, buf
);
645 buf
->vb
.state
= VIDEOBUF_ACTIVE
;
646 buf
->count
= q
->count
++;
647 mod_timer(&q
->timeout
, jiffies
+BUFFER_TIMEOUT
);
648 dprintk(2, "[%p/%d] buffer_queue - first active\n",
652 prev
= list_entry(q
->active
.prev
, struct cx23885_buffer
,
654 if (prev
->vb
.width
== buf
->vb
.width
&&
655 prev
->vb
.height
== buf
->vb
.height
&&
656 prev
->fmt
== buf
->fmt
) {
657 list_add_tail(&buf
->vb
.queue
, &q
->active
);
658 buf
->vb
.state
= VIDEOBUF_ACTIVE
;
659 buf
->count
= q
->count
++;
660 prev
->risc
.jmp
[1] = cpu_to_le32(buf
->risc
.dma
);
661 /* 64 bit bits 63-32 */
662 prev
->risc
.jmp
[2] = cpu_to_le32(0);
663 dprintk(2, "[%p/%d] buffer_queue - append to active\n",
667 list_add_tail(&buf
->vb
.queue
, &q
->queued
);
668 buf
->vb
.state
= VIDEOBUF_QUEUED
;
669 dprintk(2, "[%p/%d] buffer_queue - first queued\n",
675 static void buffer_release(struct videobuf_queue
*q
,
676 struct videobuf_buffer
*vb
)
678 struct cx23885_buffer
*buf
= container_of(vb
,
679 struct cx23885_buffer
, vb
);
681 cx23885_free_buffer(q
, buf
);
684 static struct videobuf_queue_ops cx23885_video_qops
= {
685 .buf_setup
= buffer_setup
,
686 .buf_prepare
= buffer_prepare
,
687 .buf_queue
= buffer_queue
,
688 .buf_release
= buffer_release
,
691 static struct videobuf_queue
*get_queue(struct cx23885_fh
*fh
)
694 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
696 case V4L2_BUF_TYPE_VBI_CAPTURE
:
704 static int get_resource(struct cx23885_fh
*fh
)
707 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
708 return RESOURCE_VIDEO
;
709 case V4L2_BUF_TYPE_VBI_CAPTURE
:
717 static int video_open(struct file
*file
)
719 struct video_device
*vdev
= video_devdata(file
);
720 struct cx23885_dev
*dev
= video_drvdata(file
);
721 struct cx23885_fh
*fh
;
722 enum v4l2_buf_type type
= 0;
725 switch (vdev
->vfl_type
) {
726 case VFL_TYPE_GRABBER
:
727 type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
730 type
= V4L2_BUF_TYPE_VBI_CAPTURE
;
737 dprintk(1, "open dev=%s radio=%d type=%s\n",
738 video_device_node_name(vdev
), radio
, v4l2_type_names
[type
]);
740 /* allocate + initialize per filehandle data */
741 fh
= kzalloc(sizeof(*fh
), GFP_KERNEL
);
745 file
->private_data
= fh
;
751 fh
->fmt
= format_by_fourcc(V4L2_PIX_FMT_BGR24
);
753 videobuf_queue_sg_init(&fh
->vidq
, &cx23885_video_qops
,
754 &dev
->pci
->dev
, &dev
->slock
,
755 V4L2_BUF_TYPE_VIDEO_CAPTURE
,
756 V4L2_FIELD_INTERLACED
,
757 sizeof(struct cx23885_buffer
),
760 dprintk(1, "post videobuf_queue_init()\n");
765 static ssize_t
video_read(struct file
*file
, char __user
*data
,
766 size_t count
, loff_t
*ppos
)
768 struct cx23885_fh
*fh
= file
->private_data
;
771 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
772 if (res_locked(fh
->dev
, RESOURCE_VIDEO
))
774 return videobuf_read_one(&fh
->vidq
, data
, count
, ppos
,
775 file
->f_flags
& O_NONBLOCK
);
776 case V4L2_BUF_TYPE_VBI_CAPTURE
:
777 if (!res_get(fh
->dev
, fh
, RESOURCE_VBI
))
779 return videobuf_read_stream(&fh
->vbiq
, data
, count
, ppos
, 1,
780 file
->f_flags
& O_NONBLOCK
);
787 static unsigned int video_poll(struct file
*file
,
788 struct poll_table_struct
*wait
)
790 struct cx23885_fh
*fh
= file
->private_data
;
791 struct cx23885_buffer
*buf
;
792 unsigned int rc
= POLLERR
;
794 if (V4L2_BUF_TYPE_VBI_CAPTURE
== fh
->type
) {
795 if (!res_get(fh
->dev
, fh
, RESOURCE_VBI
))
797 return videobuf_poll_stream(file
, &fh
->vbiq
, wait
);
800 mutex_lock(&fh
->vidq
.vb_lock
);
801 if (res_check(fh
, RESOURCE_VIDEO
)) {
802 /* streaming capture */
803 if (list_empty(&fh
->vidq
.stream
))
805 buf
= list_entry(fh
->vidq
.stream
.next
,
806 struct cx23885_buffer
, vb
.stream
);
809 buf
= (struct cx23885_buffer
*)fh
->vidq
.read_buf
;
813 poll_wait(file
, &buf
->vb
.done
, wait
);
814 if (buf
->vb
.state
== VIDEOBUF_DONE
||
815 buf
->vb
.state
== VIDEOBUF_ERROR
)
816 rc
= POLLIN
|POLLRDNORM
;
820 mutex_unlock(&fh
->vidq
.vb_lock
);
824 static int video_release(struct file
*file
)
826 struct cx23885_fh
*fh
= file
->private_data
;
827 struct cx23885_dev
*dev
= fh
->dev
;
829 /* turn off overlay */
830 if (res_check(fh
, RESOURCE_OVERLAY
)) {
832 res_free(dev
, fh
, RESOURCE_OVERLAY
);
835 /* stop video capture */
836 if (res_check(fh
, RESOURCE_VIDEO
)) {
837 videobuf_queue_cancel(&fh
->vidq
);
838 res_free(dev
, fh
, RESOURCE_VIDEO
);
840 if (fh
->vidq
.read_buf
) {
841 buffer_release(&fh
->vidq
, fh
->vidq
.read_buf
);
842 kfree(fh
->vidq
.read_buf
);
845 /* stop vbi capture */
846 if (res_check(fh
, RESOURCE_VBI
)) {
847 if (fh
->vbiq
.streaming
)
848 videobuf_streamoff(&fh
->vbiq
);
849 if (fh
->vbiq
.reading
)
850 videobuf_read_stop(&fh
->vbiq
);
851 res_free(dev
, fh
, RESOURCE_VBI
);
854 videobuf_mmap_free(&fh
->vidq
);
855 file
->private_data
= NULL
;
858 /* We are not putting the tuner to sleep here on exit, because
859 * we want to use the mpeg encoder in another session to capture
860 * tuner video. Closing this will result in no video to the encoder.
866 static int video_mmap(struct file
*file
, struct vm_area_struct
*vma
)
868 struct cx23885_fh
*fh
= file
->private_data
;
870 return videobuf_mmap_mapper(get_queue(fh
), vma
);
873 /* ------------------------------------------------------------------ */
874 /* VIDEO CTRL IOCTLS */
876 static int cx23885_get_control(struct cx23885_dev
*dev
,
877 struct v4l2_control
*ctl
)
879 dprintk(1, "%s() calling cx25840(VIDIOC_G_CTRL)\n", __func__
);
880 call_all(dev
, core
, g_ctrl
, ctl
);
884 static int cx23885_set_control(struct cx23885_dev
*dev
,
885 struct v4l2_control
*ctl
)
887 dprintk(1, "%s() calling cx25840(VIDIOC_S_CTRL)"
888 " (disabled - no action)\n", __func__
);
892 static void init_controls(struct cx23885_dev
*dev
)
894 struct v4l2_control ctrl
;
897 for (i
= 0; i
< CX23885_CTLS
; i
++) {
898 ctrl
.id
= cx23885_ctls
[i
].v
.id
;
899 ctrl
.value
= cx23885_ctls
[i
].v
.default_value
;
901 cx23885_set_control(dev
, &ctrl
);
905 /* ------------------------------------------------------------------ */
908 static int vidioc_g_fmt_vid_cap(struct file
*file
, void *priv
,
909 struct v4l2_format
*f
)
911 struct cx23885_fh
*fh
= priv
;
913 f
->fmt
.pix
.width
= fh
->width
;
914 f
->fmt
.pix
.height
= fh
->height
;
915 f
->fmt
.pix
.field
= fh
->vidq
.field
;
916 f
->fmt
.pix
.pixelformat
= fh
->fmt
->fourcc
;
917 f
->fmt
.pix
.bytesperline
=
918 (f
->fmt
.pix
.width
* fh
->fmt
->depth
) >> 3;
919 f
->fmt
.pix
.sizeimage
=
920 f
->fmt
.pix
.height
* f
->fmt
.pix
.bytesperline
;
925 static int vidioc_try_fmt_vid_cap(struct file
*file
, void *priv
,
926 struct v4l2_format
*f
)
928 struct cx23885_dev
*dev
= ((struct cx23885_fh
*)priv
)->dev
;
929 struct cx23885_fmt
*fmt
;
930 enum v4l2_field field
;
931 unsigned int maxw
, maxh
;
933 fmt
= format_by_fourcc(f
->fmt
.pix
.pixelformat
);
937 field
= f
->fmt
.pix
.field
;
938 maxw
= norm_maxw(dev
->tvnorm
);
939 maxh
= norm_maxh(dev
->tvnorm
);
941 if (V4L2_FIELD_ANY
== field
) {
942 field
= (f
->fmt
.pix
.height
> maxh
/2)
943 ? V4L2_FIELD_INTERLACED
949 case V4L2_FIELD_BOTTOM
:
952 case V4L2_FIELD_INTERLACED
:
958 f
->fmt
.pix
.field
= field
;
959 v4l_bound_align_image(&f
->fmt
.pix
.width
, 48, maxw
, 2,
960 &f
->fmt
.pix
.height
, 32, maxh
, 0, 0);
961 f
->fmt
.pix
.bytesperline
=
962 (f
->fmt
.pix
.width
* fmt
->depth
) >> 3;
963 f
->fmt
.pix
.sizeimage
=
964 f
->fmt
.pix
.height
* f
->fmt
.pix
.bytesperline
;
969 static int vidioc_s_fmt_vid_cap(struct file
*file
, void *priv
,
970 struct v4l2_format
*f
)
972 struct cx23885_fh
*fh
= priv
;
973 struct cx23885_dev
*dev
= ((struct cx23885_fh
*)priv
)->dev
;
974 struct v4l2_mbus_framefmt mbus_fmt
;
977 dprintk(2, "%s()\n", __func__
);
978 err
= vidioc_try_fmt_vid_cap(file
, priv
, f
);
982 fh
->fmt
= format_by_fourcc(f
->fmt
.pix
.pixelformat
);
983 fh
->width
= f
->fmt
.pix
.width
;
984 fh
->height
= f
->fmt
.pix
.height
;
985 fh
->vidq
.field
= f
->fmt
.pix
.field
;
986 dprintk(2, "%s() width=%d height=%d field=%d\n", __func__
,
987 fh
->width
, fh
->height
, fh
->vidq
.field
);
988 v4l2_fill_mbus_format(&mbus_fmt
, &f
->fmt
.pix
, V4L2_MBUS_FMT_FIXED
);
989 call_all(dev
, video
, s_mbus_fmt
, &mbus_fmt
);
990 v4l2_fill_pix_format(&f
->fmt
.pix
, &mbus_fmt
);
994 static int vidioc_querycap(struct file
*file
, void *priv
,
995 struct v4l2_capability
*cap
)
997 struct cx23885_dev
*dev
= ((struct cx23885_fh
*)priv
)->dev
;
999 strcpy(cap
->driver
, "cx23885");
1000 strlcpy(cap
->card
, cx23885_boards
[dev
->board
].name
,
1002 sprintf(cap
->bus_info
, "PCIe:%s", pci_name(dev
->pci
));
1004 V4L2_CAP_VIDEO_CAPTURE
|
1005 V4L2_CAP_READWRITE
|
1006 V4L2_CAP_STREAMING
|
1007 V4L2_CAP_VBI_CAPTURE
;
1008 if (UNSET
!= dev
->tuner_type
)
1009 cap
->capabilities
|= V4L2_CAP_TUNER
;
1013 static int vidioc_enum_fmt_vid_cap(struct file
*file
, void *priv
,
1014 struct v4l2_fmtdesc
*f
)
1016 if (unlikely(f
->index
>= ARRAY_SIZE(formats
)))
1019 strlcpy(f
->description
, formats
[f
->index
].name
,
1020 sizeof(f
->description
));
1021 f
->pixelformat
= formats
[f
->index
].fourcc
;
1026 static int vidioc_reqbufs(struct file
*file
, void *priv
,
1027 struct v4l2_requestbuffers
*p
)
1029 struct cx23885_fh
*fh
= priv
;
1030 return videobuf_reqbufs(get_queue(fh
), p
);
1033 static int vidioc_querybuf(struct file
*file
, void *priv
,
1034 struct v4l2_buffer
*p
)
1036 struct cx23885_fh
*fh
= priv
;
1037 return videobuf_querybuf(get_queue(fh
), p
);
1040 static int vidioc_qbuf(struct file
*file
, void *priv
,
1041 struct v4l2_buffer
*p
)
1043 struct cx23885_fh
*fh
= priv
;
1044 return videobuf_qbuf(get_queue(fh
), p
);
1047 static int vidioc_dqbuf(struct file
*file
, void *priv
,
1048 struct v4l2_buffer
*p
)
1050 struct cx23885_fh
*fh
= priv
;
1051 return videobuf_dqbuf(get_queue(fh
), p
,
1052 file
->f_flags
& O_NONBLOCK
);
1055 static int vidioc_streamon(struct file
*file
, void *priv
,
1056 enum v4l2_buf_type i
)
1058 struct cx23885_fh
*fh
= priv
;
1059 struct cx23885_dev
*dev
= fh
->dev
;
1060 dprintk(1, "%s()\n", __func__
);
1062 if (unlikely(fh
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
))
1064 if (unlikely(i
!= fh
->type
))
1067 if (unlikely(!res_get(dev
, fh
, get_resource(fh
))))
1069 return videobuf_streamon(get_queue(fh
));
1072 static int vidioc_streamoff(struct file
*file
, void *priv
, enum v4l2_buf_type i
)
1074 struct cx23885_fh
*fh
= priv
;
1075 struct cx23885_dev
*dev
= fh
->dev
;
1077 dprintk(1, "%s()\n", __func__
);
1079 if (fh
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1084 res
= get_resource(fh
);
1085 err
= videobuf_streamoff(get_queue(fh
));
1088 res_free(dev
, fh
, res
);
1092 static int vidioc_s_std(struct file
*file
, void *priv
, v4l2_std_id
*tvnorms
)
1094 struct cx23885_dev
*dev
= ((struct cx23885_fh
*)priv
)->dev
;
1095 dprintk(1, "%s()\n", __func__
);
1097 mutex_lock(&dev
->lock
);
1098 cx23885_set_tvnorm(dev
, *tvnorms
);
1099 mutex_unlock(&dev
->lock
);
1104 static int cx23885_enum_input(struct cx23885_dev
*dev
, struct v4l2_input
*i
)
1106 static const char *iname
[] = {
1107 [CX23885_VMUX_COMPOSITE1
] = "Composite1",
1108 [CX23885_VMUX_COMPOSITE2
] = "Composite2",
1109 [CX23885_VMUX_COMPOSITE3
] = "Composite3",
1110 [CX23885_VMUX_COMPOSITE4
] = "Composite4",
1111 [CX23885_VMUX_SVIDEO
] = "S-Video",
1112 [CX23885_VMUX_COMPONENT
] = "Component",
1113 [CX23885_VMUX_TELEVISION
] = "Television",
1114 [CX23885_VMUX_CABLE
] = "Cable TV",
1115 [CX23885_VMUX_DVB
] = "DVB",
1116 [CX23885_VMUX_DEBUG
] = "for debug only",
1119 dprintk(1, "%s()\n", __func__
);
1125 if (0 == INPUT(n
)->type
)
1129 i
->type
= V4L2_INPUT_TYPE_CAMERA
;
1130 strcpy(i
->name
, iname
[INPUT(n
)->type
]);
1131 if ((CX23885_VMUX_TELEVISION
== INPUT(n
)->type
) ||
1132 (CX23885_VMUX_CABLE
== INPUT(n
)->type
)) {
1133 i
->type
= V4L2_INPUT_TYPE_TUNER
;
1134 i
->std
= CX23885_NORMS
;
1139 static int vidioc_enum_input(struct file
*file
, void *priv
,
1140 struct v4l2_input
*i
)
1142 struct cx23885_dev
*dev
= ((struct cx23885_fh
*)priv
)->dev
;
1143 dprintk(1, "%s()\n", __func__
);
1144 return cx23885_enum_input(dev
, i
);
1147 static int vidioc_g_input(struct file
*file
, void *priv
, unsigned int *i
)
1149 struct cx23885_dev
*dev
= ((struct cx23885_fh
*)priv
)->dev
;
1152 dprintk(1, "%s() returns %d\n", __func__
, *i
);
1156 static int vidioc_s_input(struct file
*file
, void *priv
, unsigned int i
)
1158 struct cx23885_dev
*dev
= ((struct cx23885_fh
*)priv
)->dev
;
1160 dprintk(1, "%s(%d)\n", __func__
, i
);
1163 dprintk(1, "%s() -EINVAL\n", __func__
);
1167 mutex_lock(&dev
->lock
);
1168 cx23885_video_mux(dev
, i
);
1169 mutex_unlock(&dev
->lock
);
1173 static int vidioc_log_status(struct file
*file
, void *priv
)
1175 struct cx23885_fh
*fh
= priv
;
1176 struct cx23885_dev
*dev
= fh
->dev
;
1179 "%s/0: ============ START LOG STATUS ============\n",
1181 call_all(dev
, core
, log_status
);
1183 "%s/0: ============= END LOG STATUS =============\n",
1188 static int vidioc_queryctrl(struct file
*file
, void *priv
,
1189 struct v4l2_queryctrl
*qctrl
)
1191 qctrl
->id
= v4l2_ctrl_next(ctrl_classes
, qctrl
->id
);
1192 if (unlikely(qctrl
->id
== 0))
1194 return cx23885_ctrl_query(qctrl
);
1197 static int vidioc_g_ctrl(struct file
*file
, void *priv
,
1198 struct v4l2_control
*ctl
)
1200 struct cx23885_dev
*dev
= ((struct cx23885_fh
*)priv
)->dev
;
1202 return cx23885_get_control(dev
, ctl
);
1205 static int vidioc_s_ctrl(struct file
*file
, void *priv
,
1206 struct v4l2_control
*ctl
)
1208 struct cx23885_dev
*dev
= ((struct cx23885_fh
*)priv
)->dev
;
1210 return cx23885_set_control(dev
, ctl
);
1213 static int vidioc_g_tuner(struct file
*file
, void *priv
,
1214 struct v4l2_tuner
*t
)
1216 struct cx23885_dev
*dev
= ((struct cx23885_fh
*)priv
)->dev
;
1218 if (unlikely(UNSET
== dev
->tuner_type
))
1223 strcpy(t
->name
, "Television");
1224 t
->type
= V4L2_TUNER_ANALOG_TV
;
1225 t
->capability
= V4L2_TUNER_CAP_NORM
;
1226 t
->rangehigh
= 0xffffffffUL
;
1227 t
->signal
= 0xffff ; /* LOCKED */
1231 static int vidioc_s_tuner(struct file
*file
, void *priv
,
1232 struct v4l2_tuner
*t
)
1234 struct cx23885_dev
*dev
= ((struct cx23885_fh
*)priv
)->dev
;
1236 if (UNSET
== dev
->tuner_type
)
1243 static int vidioc_g_frequency(struct file
*file
, void *priv
,
1244 struct v4l2_frequency
*f
)
1246 struct cx23885_fh
*fh
= priv
;
1247 struct cx23885_dev
*dev
= fh
->dev
;
1249 if (unlikely(UNSET
== dev
->tuner_type
))
1252 /* f->type = fh->radio ? V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV; */
1253 f
->type
= fh
->radio
? V4L2_TUNER_RADIO
: V4L2_TUNER_ANALOG_TV
;
1254 f
->frequency
= dev
->freq
;
1256 call_all(dev
, tuner
, g_frequency
, f
);
1261 static int cx23885_set_freq(struct cx23885_dev
*dev
, struct v4l2_frequency
*f
)
1263 if (unlikely(UNSET
== dev
->tuner_type
))
1265 if (unlikely(f
->tuner
!= 0))
1268 mutex_lock(&dev
->lock
);
1269 dev
->freq
= f
->frequency
;
1271 call_all(dev
, tuner
, s_frequency
, f
);
1273 /* When changing channels it is required to reset TVAUDIO */
1276 mutex_unlock(&dev
->lock
);
1281 static int vidioc_s_frequency(struct file
*file
, void *priv
,
1282 struct v4l2_frequency
*f
)
1284 struct cx23885_fh
*fh
= priv
;
1285 struct cx23885_dev
*dev
= fh
->dev
;
1287 if (unlikely(0 == fh
->radio
&& f
->type
!= V4L2_TUNER_ANALOG_TV
))
1289 if (unlikely(1 == fh
->radio
&& f
->type
!= V4L2_TUNER_RADIO
))
1293 cx23885_set_freq(dev
, f
);
1296 /* ----------------------------------------------------------- */
1298 static void cx23885_vid_timeout(unsigned long data
)
1300 struct cx23885_dev
*dev
= (struct cx23885_dev
*)data
;
1301 struct cx23885_dmaqueue
*q
= &dev
->vidq
;
1302 struct cx23885_buffer
*buf
;
1303 unsigned long flags
;
1305 cx23885_sram_channel_dump(dev
, &dev
->sram_channels
[SRAM_CH01
]);
1307 cx_clear(VID_A_DMA_CTL
, 0x11);
1309 spin_lock_irqsave(&dev
->slock
, flags
);
1310 while (!list_empty(&q
->active
)) {
1311 buf
= list_entry(q
->active
.next
,
1312 struct cx23885_buffer
, vb
.queue
);
1313 list_del(&buf
->vb
.queue
);
1314 buf
->vb
.state
= VIDEOBUF_ERROR
;
1315 wake_up(&buf
->vb
.done
);
1316 printk(KERN_ERR
"%s/0: [%p/%d] timeout - dma=0x%08lx\n",
1317 dev
->name
, buf
, buf
->vb
.i
,
1318 (unsigned long)buf
->risc
.dma
);
1320 cx23885_restart_video_queue(dev
, q
);
1321 spin_unlock_irqrestore(&dev
->slock
, flags
);
1324 int cx23885_video_irq(struct cx23885_dev
*dev
, u32 status
)
1329 mask
= cx_read(VID_A_INT_MSK
);
1330 if (0 == (status
& mask
))
1332 cx_write(VID_A_INT_STAT
, status
);
1334 dprintk(2, "%s() status = 0x%08x\n", __func__
, status
);
1335 /* risc op code error */
1336 if (status
& (1 << 16)) {
1337 printk(KERN_WARNING
"%s/0: video risc op code error\n",
1339 cx_clear(VID_A_DMA_CTL
, 0x11);
1340 cx23885_sram_channel_dump(dev
, &dev
->sram_channels
[SRAM_CH01
]);
1344 if (status
& 0x01) {
1345 spin_lock(&dev
->slock
);
1346 count
= cx_read(VID_A_GPCNT
);
1347 cx23885_video_wakeup(dev
, &dev
->vidq
, count
);
1348 spin_unlock(&dev
->slock
);
1352 if (status
& 0x10) {
1353 dprintk(2, "stopper video\n");
1354 spin_lock(&dev
->slock
);
1355 cx23885_restart_video_queue(dev
, &dev
->vidq
);
1356 spin_unlock(&dev
->slock
);
1363 /* ----------------------------------------------------------- */
1364 /* exported stuff */
1366 static const struct v4l2_file_operations video_fops
= {
1367 .owner
= THIS_MODULE
,
1369 .release
= video_release
,
1373 .ioctl
= video_ioctl2
,
1376 static const struct v4l2_ioctl_ops video_ioctl_ops
= {
1377 .vidioc_querycap
= vidioc_querycap
,
1378 .vidioc_enum_fmt_vid_cap
= vidioc_enum_fmt_vid_cap
,
1379 .vidioc_g_fmt_vid_cap
= vidioc_g_fmt_vid_cap
,
1380 .vidioc_try_fmt_vid_cap
= vidioc_try_fmt_vid_cap
,
1381 .vidioc_s_fmt_vid_cap
= vidioc_s_fmt_vid_cap
,
1382 .vidioc_g_fmt_vbi_cap
= cx23885_vbi_fmt
,
1383 .vidioc_try_fmt_vbi_cap
= cx23885_vbi_fmt
,
1384 .vidioc_s_fmt_vbi_cap
= cx23885_vbi_fmt
,
1385 .vidioc_reqbufs
= vidioc_reqbufs
,
1386 .vidioc_querybuf
= vidioc_querybuf
,
1387 .vidioc_qbuf
= vidioc_qbuf
,
1388 .vidioc_dqbuf
= vidioc_dqbuf
,
1389 .vidioc_s_std
= vidioc_s_std
,
1390 .vidioc_enum_input
= vidioc_enum_input
,
1391 .vidioc_g_input
= vidioc_g_input
,
1392 .vidioc_s_input
= vidioc_s_input
,
1393 .vidioc_log_status
= vidioc_log_status
,
1394 .vidioc_queryctrl
= vidioc_queryctrl
,
1395 .vidioc_g_ctrl
= vidioc_g_ctrl
,
1396 .vidioc_s_ctrl
= vidioc_s_ctrl
,
1397 .vidioc_streamon
= vidioc_streamon
,
1398 .vidioc_streamoff
= vidioc_streamoff
,
1399 .vidioc_g_tuner
= vidioc_g_tuner
,
1400 .vidioc_s_tuner
= vidioc_s_tuner
,
1401 .vidioc_g_frequency
= vidioc_g_frequency
,
1402 .vidioc_s_frequency
= vidioc_s_frequency
,
1403 .vidioc_g_chip_ident
= cx23885_g_chip_ident
,
1404 #ifdef CONFIG_VIDEO_ADV_DEBUG
1405 .vidioc_g_register
= cx23885_g_register
,
1406 .vidioc_s_register
= cx23885_s_register
,
1410 static struct video_device cx23885_vbi_template
;
1411 static struct video_device cx23885_video_template
= {
1412 .name
= "cx23885-video",
1413 .fops
= &video_fops
,
1414 .ioctl_ops
= &video_ioctl_ops
,
1415 .tvnorms
= CX23885_NORMS
,
1416 .current_norm
= V4L2_STD_NTSC_M
,
1419 static const struct v4l2_file_operations radio_fops
= {
1420 .owner
= THIS_MODULE
,
1422 .release
= video_release
,
1423 .ioctl
= video_ioctl2
,
1427 void cx23885_video_unregister(struct cx23885_dev
*dev
)
1429 dprintk(1, "%s()\n", __func__
);
1430 cx23885_irq_remove(dev
, 0x01);
1432 if (dev
->video_dev
) {
1433 if (video_is_registered(dev
->video_dev
))
1434 video_unregister_device(dev
->video_dev
);
1436 video_device_release(dev
->video_dev
);
1437 dev
->video_dev
= NULL
;
1439 btcx_riscmem_free(dev
->pci
, &dev
->vidq
.stopper
);
1443 int cx23885_video_register(struct cx23885_dev
*dev
)
1447 dprintk(1, "%s()\n", __func__
);
1448 spin_lock_init(&dev
->slock
);
1450 /* Initialize VBI template */
1451 memcpy(&cx23885_vbi_template
, &cx23885_video_template
,
1452 sizeof(cx23885_vbi_template
));
1453 strcpy(cx23885_vbi_template
.name
, "cx23885-vbi");
1455 dev
->tvnorm
= cx23885_video_template
.current_norm
;
1457 /* init video dma queues */
1458 INIT_LIST_HEAD(&dev
->vidq
.active
);
1459 INIT_LIST_HEAD(&dev
->vidq
.queued
);
1460 dev
->vidq
.timeout
.function
= cx23885_vid_timeout
;
1461 dev
->vidq
.timeout
.data
= (unsigned long)dev
;
1462 init_timer(&dev
->vidq
.timeout
);
1463 cx23885_risc_stopper(dev
->pci
, &dev
->vidq
.stopper
,
1464 VID_A_DMA_CTL
, 0x11, 0x00);
1466 /* Don't enable VBI yet */
1468 cx23885_irq_add_enable(dev
, 0x01);
1470 if ((TUNER_ABSENT
!= dev
->tuner_type
) &&
1471 ((dev
->tuner_bus
== 0) || (dev
->tuner_bus
== 1))) {
1472 struct v4l2_subdev
*sd
= NULL
;
1474 if (dev
->tuner_addr
)
1475 sd
= v4l2_i2c_new_subdev(&dev
->v4l2_dev
,
1476 &dev
->i2c_bus
[dev
->tuner_bus
].i2c_adap
,
1477 "tuner", dev
->tuner_addr
, NULL
);
1479 sd
= v4l2_i2c_new_subdev(&dev
->v4l2_dev
,
1480 &dev
->i2c_bus
[dev
->tuner_bus
].i2c_adap
,
1481 "tuner", 0, v4l2_i2c_tuner_addrs(ADDRS_TV
));
1483 struct tuner_setup tun_setup
;
1485 memset(&tun_setup
, 0, sizeof(tun_setup
));
1486 tun_setup
.mode_mask
= T_ANALOG_TV
;
1487 tun_setup
.type
= dev
->tuner_type
;
1488 tun_setup
.addr
= v4l2_i2c_subdev_addr(sd
);
1489 tun_setup
.tuner_callback
= cx23885_tuner_callback
;
1491 v4l2_subdev_call(sd
, tuner
, s_type_addr
, &tun_setup
);
1493 if (dev
->board
== CX23885_BOARD_LEADTEK_WINFAST_PXTV1200
) {
1494 struct xc2028_ctrl ctrl
= {
1495 .fname
= XC2028_DEFAULT_FIRMWARE
,
1498 struct v4l2_priv_tun_config cfg
= {
1499 .tuner
= dev
->tuner_type
,
1502 v4l2_subdev_call(sd
, tuner
, s_config
, &cfg
);
1508 /* register v4l devices */
1509 dev
->video_dev
= cx23885_vdev_init(dev
, dev
->pci
,
1510 &cx23885_video_template
, "video");
1511 err
= video_register_device(dev
->video_dev
, VFL_TYPE_GRABBER
,
1514 printk(KERN_INFO
"%s: can't register video device\n",
1518 printk(KERN_INFO
"%s/0: registered device %s [v4l2]\n",
1519 dev
->name
, video_device_node_name(dev
->video_dev
));
1520 /* initial device configuration */
1521 mutex_lock(&dev
->lock
);
1522 cx23885_set_tvnorm(dev
, dev
->tvnorm
);
1524 cx23885_video_mux(dev
, 0);
1525 mutex_unlock(&dev
->lock
);
1530 cx23885_video_unregister(dev
);