2 * Driver for the Conexant CX25821 PCIe bridge
4 * Copyright (C) 2009 Conexant Systems Inc.
5 * Authors <shu.lin@conexant.com>, <hiep.huynh@conexant.com>
6 * Based on Steven Toth <stoth@linuxtv.org> cx23885 driver
7 * Parts adapted/taken from Eduardo Moscoso Rubino
8 * Copyright (C) 2009 Eduardo Moscoso Rubino <moscoso@TopoLogica.com>
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
27 #include "cx25821-video.h"
29 MODULE_DESCRIPTION("v4l2 driver module for cx25821 based TV cards");
30 MODULE_AUTHOR("Hiep Huynh <hiep.huynh@conexant.com>");
31 MODULE_LICENSE("GPL");
33 static unsigned int video_nr
[] = {[0 ... (CX25821_MAXBOARDS
- 1)] = UNSET
};
34 static unsigned int radio_nr
[] = {[0 ... (CX25821_MAXBOARDS
- 1)] = UNSET
};
36 module_param_array(video_nr
, int, NULL
, 0444);
37 module_param_array(radio_nr
, int, NULL
, 0444);
39 MODULE_PARM_DESC(video_nr
, "video device numbers");
40 MODULE_PARM_DESC(radio_nr
, "radio device numbers");
42 static unsigned int video_debug
= VIDEO_DEBUG
;
43 module_param(video_debug
, int, 0644);
44 MODULE_PARM_DESC(video_debug
, "enable debug messages [video]");
46 static unsigned int irq_debug
;
47 module_param(irq_debug
, int, 0644);
48 MODULE_PARM_DESC(irq_debug
, "enable debug messages [IRQ handler]");
50 unsigned int vid_limit
= 16;
51 module_param(vid_limit
, int, 0644);
52 MODULE_PARM_DESC(vid_limit
, "capture memory limit in megabytes");
54 static void cx25821_init_controls(struct cx25821_dev
*dev
, int chan_num
);
56 static const struct v4l2_file_operations video_fops
;
57 static const struct v4l2_ioctl_ops video_ioctl_ops
;
59 #define FORMAT_FLAGS_PACKED 0x01
61 struct cx25821_fmt formats
[] = {
63 .name
= "8 bpp, gray",
64 .fourcc
= V4L2_PIX_FMT_GREY
,
66 .flags
= FORMAT_FLAGS_PACKED
,
68 .name
= "4:1:1, packed, Y41P",
69 .fourcc
= V4L2_PIX_FMT_Y41P
,
71 .flags
= FORMAT_FLAGS_PACKED
,
73 .name
= "4:2:2, packed, YUYV",
74 .fourcc
= V4L2_PIX_FMT_YUYV
,
76 .flags
= FORMAT_FLAGS_PACKED
,
78 .name
= "4:2:2, packed, UYVY",
79 .fourcc
= V4L2_PIX_FMT_UYVY
,
81 .flags
= FORMAT_FLAGS_PACKED
,
84 .fourcc
= V4L2_PIX_FMT_YUV420
,
86 .flags
= FORMAT_FLAGS_PACKED
,
90 int cx25821_get_format_size(void)
92 return ARRAY_SIZE(formats
);
95 struct cx25821_fmt
*format_by_fourcc(unsigned int fourcc
)
99 if (fourcc
== V4L2_PIX_FMT_Y41P
|| fourcc
== V4L2_PIX_FMT_YUV411P
) {
103 for (i
= 0; i
< ARRAY_SIZE(formats
); i
++)
104 if (formats
[i
].fourcc
== fourcc
)
107 printk(KERN_ERR
"%s(0x%08x) NOT FOUND\n", __func__
, fourcc
);
111 void cx25821_dump_video_queue(struct cx25821_dev
*dev
, struct cx25821_dmaqueue
*q
)
113 struct cx25821_buffer
*buf
;
114 struct list_head
*item
;
115 dprintk(1, "%s()\n", __func__
);
117 if (!list_empty(&q
->active
)) {
118 list_for_each(item
, &q
->active
)
119 buf
= list_entry(item
, struct cx25821_buffer
, vb
.queue
);
122 if (!list_empty(&q
->queued
)) {
123 list_for_each(item
, &q
->queued
)
124 buf
= list_entry(item
, struct cx25821_buffer
, vb
.queue
);
129 void cx25821_video_wakeup(struct cx25821_dev
*dev
, struct cx25821_dmaqueue
*q
,
132 struct cx25821_buffer
*buf
;
135 for (bc
= 0;; bc
++) {
136 if (list_empty(&q
->active
)) {
137 dprintk(1, "bc=%d (=0: active empty)\n", bc
);
142 list_entry(q
->active
.next
, struct cx25821_buffer
, vb
.queue
);
144 /* count comes from the hw and it is 16bit wide --
145 * this trick handles wrap-arounds correctly for
146 * up to 32767 buffers in flight... */
147 if ((s16
) (count
- buf
->count
) < 0) {
151 do_gettimeofday(&buf
->vb
.ts
);
152 buf
->vb
.state
= VIDEOBUF_DONE
;
153 list_del(&buf
->vb
.queue
);
154 wake_up(&buf
->vb
.done
);
157 if (list_empty(&q
->active
))
158 del_timer(&q
->timeout
);
160 mod_timer(&q
->timeout
, jiffies
+ BUFFER_TIMEOUT
);
162 printk(KERN_ERR
"%s: %d buffers handled (should be 1)\n",
167 int cx25821_set_tvnorm(struct cx25821_dev
*dev
, v4l2_std_id norm
)
169 dprintk(1, "%s(norm = 0x%08x) name: [%s]\n", __func__
,
170 (unsigned int)norm
, v4l2_norm_to_name(norm
));
174 /* Tell the internal A/V decoder */
175 cx25821_call_all(dev
, core
, s_std
, norm
);
181 struct video_device
*cx25821_vdev_init(struct cx25821_dev
*dev
,
183 struct video_device
*template,
186 struct video_device
*vfd
;
187 dprintk(1, "%s()\n", __func__
);
189 vfd
= video_device_alloc();
193 vfd
->v4l2_dev
= &dev
->v4l2_dev
;
194 vfd
->release
= video_device_release
;
195 snprintf(vfd
->name
, sizeof(vfd
->name
), "%s %s (%s)", dev
->name
, type
,
196 cx25821_boards
[dev
->board
].name
);
197 video_set_drvdata(vfd
, dev
);
202 static int cx25821_ctrl_query(struct v4l2_queryctrl *qctrl)
206 if (qctrl->id < V4L2_CID_BASE || qctrl->id >= V4L2_CID_LASTP1)
208 for (i = 0; i < CX25821_CTLS; i++)
209 if (cx25821_ctls[i].v.id == qctrl->id)
211 if (i == CX25821_CTLS) {
215 *qctrl = cx25821_ctls[i].v;
220 /* resource management */
221 int cx25821_res_get(struct cx25821_dev
*dev
, struct cx25821_fh
*fh
, unsigned int bit
)
223 dprintk(1, "%s()\n", __func__
);
224 if (fh
->resources
& bit
)
225 /* have it already allocated */
229 mutex_lock(&dev
->lock
);
230 if (dev
->channels
[fh
->channel_id
].resources
& bit
) {
231 /* no, someone else uses it */
232 mutex_unlock(&dev
->lock
);
235 /* it's free, grab it */
236 fh
->resources
|= bit
;
237 dev
->channels
[fh
->channel_id
].resources
|= bit
;
238 dprintk(1, "res: get %d\n", bit
);
239 mutex_unlock(&dev
->lock
);
243 int cx25821_res_check(struct cx25821_fh
*fh
, unsigned int bit
)
245 return fh
->resources
& bit
;
248 int cx25821_res_locked(struct cx25821_fh
*fh
, unsigned int bit
)
250 return fh
->dev
->channels
[fh
->channel_id
].resources
& bit
;
253 void cx25821_res_free(struct cx25821_dev
*dev
, struct cx25821_fh
*fh
, unsigned int bits
)
255 BUG_ON((fh
->resources
& bits
) != bits
);
256 dprintk(1, "%s()\n", __func__
);
258 mutex_lock(&dev
->lock
);
259 fh
->resources
&= ~bits
;
260 dev
->channels
[fh
->channel_id
].resources
&= ~bits
;
261 dprintk(1, "res: put %d\n", bits
);
262 mutex_unlock(&dev
->lock
);
265 int cx25821_video_mux(struct cx25821_dev
*dev
, unsigned int input
)
267 struct v4l2_routing route
;
268 memset(&route
, 0, sizeof(route
));
270 dprintk(1, "%s() video_mux: %d [vmux=%d, gpio=0x%x,0x%x,0x%x,0x%x]\n",
271 __func__
, input
, INPUT(input
)->vmux
, INPUT(input
)->gpio0
,
272 INPUT(input
)->gpio1
, INPUT(input
)->gpio2
, INPUT(input
)->gpio3
);
275 route
.input
= INPUT(input
)->vmux
;
277 /* Tell the internal A/V decoder */
278 cx25821_call_all(dev
, video
, s_routing
, INPUT(input
)->vmux
, 0, 0);
283 int cx25821_start_video_dma(struct cx25821_dev
*dev
,
284 struct cx25821_dmaqueue
*q
,
285 struct cx25821_buffer
*buf
,
286 struct sram_channel
*channel
)
290 /* setup fifo + format */
291 cx25821_sram_channel_setup(dev
, channel
, buf
->bpl
, buf
->risc
.dma
);
294 cx_write(channel
->gpcnt_ctl
, 3);
298 cx_set(PCI_INT_MSK
, cx_read(PCI_INT_MSK
) | (1 << channel
->i
));
299 cx_set(channel
->int_msk
, 0x11);
302 cx_write(channel
->dma_ctl
, 0x11); /* FIFO and RISC enable */
304 /* make sure upstream setting if any is reversed */
305 tmp
= cx_read(VID_CH_MODE_SEL
);
306 cx_write(VID_CH_MODE_SEL
, tmp
& 0xFFFFFE00);
311 int cx25821_restart_video_queue(struct cx25821_dev
*dev
,
312 struct cx25821_dmaqueue
*q
,
313 struct sram_channel
*channel
)
315 struct cx25821_buffer
*buf
, *prev
;
316 struct list_head
*item
;
318 if (!list_empty(&q
->active
)) {
320 list_entry(q
->active
.next
, struct cx25821_buffer
, vb
.queue
);
322 cx25821_start_video_dma(dev
, q
, buf
, channel
);
324 list_for_each(item
, &q
->active
) {
325 buf
= list_entry(item
, struct cx25821_buffer
, vb
.queue
);
326 buf
->count
= q
->count
++;
329 mod_timer(&q
->timeout
, jiffies
+ BUFFER_TIMEOUT
);
335 if (list_empty(&q
->queued
))
339 list_entry(q
->queued
.next
, struct cx25821_buffer
, vb
.queue
);
342 list_move_tail(&buf
->vb
.queue
, &q
->active
);
343 cx25821_start_video_dma(dev
, q
, buf
, channel
);
344 buf
->vb
.state
= VIDEOBUF_ACTIVE
;
345 buf
->count
= q
->count
++;
346 mod_timer(&q
->timeout
, jiffies
+ BUFFER_TIMEOUT
);
347 } else if (prev
->vb
.width
== buf
->vb
.width
&&
348 prev
->vb
.height
== buf
->vb
.height
&&
349 prev
->fmt
== buf
->fmt
) {
350 list_move_tail(&buf
->vb
.queue
, &q
->active
);
351 buf
->vb
.state
= VIDEOBUF_ACTIVE
;
352 buf
->count
= q
->count
++;
353 prev
->risc
.jmp
[1] = cpu_to_le32(buf
->risc
.dma
);
354 prev
->risc
.jmp
[2] = cpu_to_le32(0); /* Bits 63 - 32 */
362 void cx25821_vid_timeout(unsigned long data
)
364 struct cx25821_data
*timeout_data
= (struct cx25821_data
*)data
;
365 struct cx25821_dev
*dev
= timeout_data
->dev
;
366 struct sram_channel
*channel
= timeout_data
->channel
;
367 struct cx25821_dmaqueue
*q
= &dev
->channels
[channel
->i
].vidq
;
368 struct cx25821_buffer
*buf
;
371 /* cx25821_sram_channel_dump(dev, channel); */
372 cx_clear(channel
->dma_ctl
, 0x11);
374 spin_lock_irqsave(&dev
->slock
, flags
);
375 while (!list_empty(&q
->active
)) {
377 list_entry(q
->active
.next
, struct cx25821_buffer
, vb
.queue
);
378 list_del(&buf
->vb
.queue
);
380 buf
->vb
.state
= VIDEOBUF_ERROR
;
381 wake_up(&buf
->vb
.done
);
384 cx25821_restart_video_queue(dev
, q
, channel
);
385 spin_unlock_irqrestore(&dev
->slock
, flags
);
388 int cx25821_video_irq(struct cx25821_dev
*dev
, int chan_num
, u32 status
)
393 struct sram_channel
*channel
= dev
->channels
[chan_num
].sram_channels
;
395 mask
= cx_read(channel
->int_msk
);
396 if (0 == (status
& mask
))
399 cx_write(channel
->int_stat
, status
);
401 /* risc op code error */
402 if (status
& (1 << 16)) {
403 printk(KERN_WARNING
"%s, %s: video risc op code error\n",
404 dev
->name
, channel
->name
);
405 cx_clear(channel
->dma_ctl
, 0x11);
406 cx25821_sram_channel_dump(dev
, channel
);
410 if (status
& FLD_VID_DST_RISC1
) {
411 spin_lock(&dev
->slock
);
412 count
= cx_read(channel
->gpcnt
);
413 cx25821_video_wakeup(dev
,
414 &dev
->channels
[channel
->i
].vidq
, count
);
415 spin_unlock(&dev
->slock
);
421 dprintk(2, "stopper video\n");
422 spin_lock(&dev
->slock
);
423 cx25821_restart_video_queue(dev
,
424 &dev
->channels
[channel
->i
].vidq
,
426 spin_unlock(&dev
->slock
);
432 void cx25821_videoioctl_unregister(struct cx25821_dev
*dev
)
434 if (dev
->ioctl_dev
) {
435 if (video_is_registered(dev
->ioctl_dev
))
436 video_unregister_device(dev
->ioctl_dev
);
438 video_device_release(dev
->ioctl_dev
);
440 dev
->ioctl_dev
= NULL
;
444 void cx25821_video_unregister(struct cx25821_dev
*dev
, int chan_num
)
446 cx_clear(PCI_INT_MSK
, 1);
448 if (dev
->channels
[chan_num
].video_dev
) {
449 if (video_is_registered(dev
->channels
[chan_num
].video_dev
))
450 video_unregister_device(
451 dev
->channels
[chan_num
].video_dev
);
453 video_device_release(
454 dev
->channels
[chan_num
].video_dev
);
456 dev
->channels
[chan_num
].video_dev
= NULL
;
458 btcx_riscmem_free(dev
->pci
,
459 &dev
->channels
[chan_num
].vidq
.stopper
);
461 printk(KERN_WARNING
"device %d released!\n", chan_num
);
466 int cx25821_video_register(struct cx25821_dev
*dev
)
471 struct video_device cx25821_video_device
= {
472 .name
= "cx25821-video",
475 .ioctl_ops
= &video_ioctl_ops
,
476 .tvnorms
= CX25821_NORMS
,
477 .current_norm
= V4L2_STD_NTSC_M
,
480 spin_lock_init(&dev
->slock
);
482 for (i
= 0; i
< MAX_VID_CHANNEL_NUM
- 1; ++i
) {
483 cx25821_init_controls(dev
, i
);
485 cx25821_risc_stopper(dev
->pci
,
486 &dev
->channels
[i
].vidq
.stopper
,
487 dev
->channels
[i
].sram_channels
->dma_ctl
,
490 dev
->channels
[i
].sram_channels
= &cx25821_sram_channels
[i
];
491 dev
->channels
[i
].video_dev
= NULL
;
492 dev
->channels
[i
].resources
= 0;
494 cx_write(dev
->channels
[i
].sram_channels
->int_stat
,
497 INIT_LIST_HEAD(&dev
->channels
[i
].vidq
.active
);
498 INIT_LIST_HEAD(&dev
->channels
[i
].vidq
.queued
);
500 dev
->channels
[i
].timeout_data
.dev
= dev
;
501 dev
->channels
[i
].timeout_data
.channel
=
502 &cx25821_sram_channels
[i
];
503 dev
->channels
[i
].vidq
.timeout
.function
=
505 dev
->channels
[i
].vidq
.timeout
.data
=
506 (unsigned long)&dev
->channels
[i
].timeout_data
;
507 init_timer(&dev
->channels
[i
].vidq
.timeout
);
509 /* register v4l devices */
510 dev
->channels
[i
].video_dev
= cx25821_vdev_init(dev
,
511 dev
->pci
, &cx25821_video_device
, "video");
513 err
= video_register_device(dev
->channels
[i
].video_dev
,
514 VFL_TYPE_GRABBER
, video_nr
[dev
->nr
]);
521 /* set PCI interrupt */
522 cx_set(PCI_INT_MSK
, 0xff);
524 /* initial device configuration */
525 mutex_lock(&dev
->lock
);
527 dev
->tvnorm
= cx25821_video_device
.current_norm
;
528 cx25821_set_tvnorm(dev
, dev
->tvnorm
);
530 mutex_unlock(&dev
->lock
);
536 cx25821_video_unregister(dev
, i
);
540 int cx25821_buffer_setup(struct videobuf_queue
*q
, unsigned int *count
,
543 struct cx25821_fh
*fh
= q
->priv_data
;
545 *size
= fh
->fmt
->depth
* fh
->width
* fh
->height
>> 3;
550 if (*size
* *count
> vid_limit
* 1024 * 1024)
551 *count
= (vid_limit
* 1024 * 1024) / *size
;
556 int cx25821_buffer_prepare(struct videobuf_queue
*q
, struct videobuf_buffer
*vb
,
557 enum v4l2_field field
)
559 struct cx25821_fh
*fh
= q
->priv_data
;
560 struct cx25821_dev
*dev
= fh
->dev
;
561 struct cx25821_buffer
*buf
=
562 container_of(vb
, struct cx25821_buffer
, vb
);
563 int rc
, init_buffer
= 0;
564 u32 line0_offset
, line1_offset
;
565 struct videobuf_dmabuf
*dma
= videobuf_to_dma(&buf
->vb
);
566 int bpl_local
= LINE_SIZE_D1
;
567 int channel_opened
= fh
->channel_id
;
569 BUG_ON(NULL
== fh
->fmt
);
570 if (fh
->width
< 48 || fh
->width
> 720 ||
571 fh
->height
< 32 || fh
->height
> 576)
574 buf
->vb
.size
= (fh
->width
* fh
->height
* fh
->fmt
->depth
) >> 3;
576 if (0 != buf
->vb
.baddr
&& buf
->vb
.bsize
< buf
->vb
.size
)
579 if (buf
->fmt
!= fh
->fmt
||
580 buf
->vb
.width
!= fh
->width
||
581 buf
->vb
.height
!= fh
->height
|| buf
->vb
.field
!= field
) {
583 buf
->vb
.width
= fh
->width
;
584 buf
->vb
.height
= fh
->height
;
585 buf
->vb
.field
= field
;
589 if (VIDEOBUF_NEEDS_INIT
== buf
->vb
.state
) {
591 rc
= videobuf_iolock(q
, &buf
->vb
, NULL
);
593 printk(KERN_DEBUG
"videobuf_iolock failed!\n");
598 dprintk(1, "init_buffer=%d\n", init_buffer
);
602 channel_opened
= dev
->channel_opened
;
603 channel_opened
= (channel_opened
< 0
604 || channel_opened
> 7) ? 7 : channel_opened
;
606 if (dev
->channels
[channel_opened
]
607 .pixel_formats
== PIXEL_FRMT_411
)
608 buf
->bpl
= (buf
->fmt
->depth
* buf
->vb
.width
) >> 3;
610 buf
->bpl
= (buf
->fmt
->depth
>> 3) * (buf
->vb
.width
);
612 if (dev
->channels
[channel_opened
]
613 .pixel_formats
== PIXEL_FRMT_411
) {
614 bpl_local
= buf
->bpl
;
616 bpl_local
= buf
->bpl
; /* Default */
618 if (channel_opened
>= 0 && channel_opened
<= 7) {
619 if (dev
->channels
[channel_opened
]
620 .use_cif_resolution
) {
621 if (dev
->tvnorm
& V4L2_STD_PAL_BG
622 || dev
->tvnorm
& V4L2_STD_PAL_DK
)
623 bpl_local
= 352 << 1;
626 dev
->channels
[channel_opened
].
633 switch (buf
->vb
.field
) {
635 cx25821_risc_buffer(dev
->pci
, &buf
->risc
,
636 dma
->sglist
, 0, UNSET
,
637 buf
->bpl
, 0, buf
->vb
.height
);
639 case V4L2_FIELD_BOTTOM
:
640 cx25821_risc_buffer(dev
->pci
, &buf
->risc
,
641 dma
->sglist
, UNSET
, 0,
642 buf
->bpl
, 0, buf
->vb
.height
);
644 case V4L2_FIELD_INTERLACED
:
645 /* All other formats are top field first */
647 line1_offset
= buf
->bpl
;
648 dprintk(1, "top field first\n");
650 cx25821_risc_buffer(dev
->pci
, &buf
->risc
,
651 dma
->sglist
, line0_offset
,
652 bpl_local
, bpl_local
, bpl_local
,
653 buf
->vb
.height
>> 1);
655 case V4L2_FIELD_SEQ_TB
:
656 cx25821_risc_buffer(dev
->pci
, &buf
->risc
,
658 0, buf
->bpl
* (buf
->vb
.height
>> 1),
659 buf
->bpl
, 0, buf
->vb
.height
>> 1);
661 case V4L2_FIELD_SEQ_BT
:
662 cx25821_risc_buffer(dev
->pci
, &buf
->risc
,
664 buf
->bpl
* (buf
->vb
.height
>> 1), 0,
665 buf
->bpl
, 0, buf
->vb
.height
>> 1);
672 dprintk(2, "[%p/%d] buffer_prep - %dx%d %dbpp \"%s\" - dma=0x%08lx\n",
673 buf
, buf
->vb
.i
, fh
->width
, fh
->height
, fh
->fmt
->depth
,
674 fh
->fmt
->name
, (unsigned long)buf
->risc
.dma
);
676 buf
->vb
.state
= VIDEOBUF_PREPARED
;
681 cx25821_free_buffer(q
, buf
);
685 void cx25821_buffer_release(struct videobuf_queue
*q
, struct videobuf_buffer
*vb
)
687 struct cx25821_buffer
*buf
=
688 container_of(vb
, struct cx25821_buffer
, vb
);
690 cx25821_free_buffer(q
, buf
);
693 struct videobuf_queue
*get_queue(struct cx25821_fh
*fh
)
696 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
704 int cx25821_get_resource(struct cx25821_fh
*fh
, int resource
)
707 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
715 int cx25821_video_mmap(struct file
*file
, struct vm_area_struct
*vma
)
717 struct cx25821_fh
*fh
= file
->private_data
;
719 return videobuf_mmap_mapper(get_queue(fh
), vma
);
723 static void buffer_queue(struct videobuf_queue
*vq
, struct videobuf_buffer
*vb
)
725 struct cx25821_buffer
*buf
=
726 container_of(vb
, struct cx25821_buffer
, vb
);
727 struct cx25821_buffer
*prev
;
728 struct cx25821_fh
*fh
= vq
->priv_data
;
729 struct cx25821_dev
*dev
= fh
->dev
;
730 struct cx25821_dmaqueue
*q
= &dev
->channels
[fh
->channel_id
].vidq
;
732 /* add jump to stopper */
733 buf
->risc
.jmp
[0] = cpu_to_le32(RISC_JUMP
| RISC_IRQ1
| RISC_CNT_INC
);
734 buf
->risc
.jmp
[1] = cpu_to_le32(q
->stopper
.dma
);
735 buf
->risc
.jmp
[2] = cpu_to_le32(0); /* bits 63-32 */
737 dprintk(2, "jmp to stopper (0x%x)\n", buf
->risc
.jmp
[1]);
739 if (!list_empty(&q
->queued
)) {
740 list_add_tail(&buf
->vb
.queue
, &q
->queued
);
741 buf
->vb
.state
= VIDEOBUF_QUEUED
;
742 dprintk(2, "[%p/%d] buffer_queue - append to queued\n", buf
,
745 } else if (list_empty(&q
->active
)) {
746 list_add_tail(&buf
->vb
.queue
, &q
->active
);
747 cx25821_start_video_dma(dev
, q
, buf
,
748 dev
->channels
[fh
->channel_id
].
750 buf
->vb
.state
= VIDEOBUF_ACTIVE
;
751 buf
->count
= q
->count
++;
752 mod_timer(&q
->timeout
, jiffies
+ BUFFER_TIMEOUT
);
754 "[%p/%d] buffer_queue - first active, buf cnt = %d, \
756 buf
, buf
->vb
.i
, buf
->count
, q
->count
);
759 list_entry(q
->active
.prev
, struct cx25821_buffer
, vb
.queue
);
760 if (prev
->vb
.width
== buf
->vb
.width
761 && prev
->vb
.height
== buf
->vb
.height
762 && prev
->fmt
== buf
->fmt
) {
763 list_add_tail(&buf
->vb
.queue
, &q
->active
);
764 buf
->vb
.state
= VIDEOBUF_ACTIVE
;
765 buf
->count
= q
->count
++;
766 prev
->risc
.jmp
[1] = cpu_to_le32(buf
->risc
.dma
);
768 /* 64 bit bits 63-32 */
769 prev
->risc
.jmp
[2] = cpu_to_le32(0);
771 "[%p/%d] buffer_queue - append to active, \
773 buf
, buf
->vb
.i
, buf
->count
);
776 list_add_tail(&buf
->vb
.queue
, &q
->queued
);
777 buf
->vb
.state
= VIDEOBUF_QUEUED
;
778 dprintk(2, "[%p/%d] buffer_queue - first queued\n", buf
,
783 if (list_empty(&q
->active
))
784 dprintk(2, "active queue empty!\n");
787 static struct videobuf_queue_ops cx25821_video_qops
= {
788 .buf_setup
= cx25821_buffer_setup
,
789 .buf_prepare
= cx25821_buffer_prepare
,
790 .buf_queue
= buffer_queue
,
791 .buf_release
= cx25821_buffer_release
,
794 static int video_open(struct file
*file
)
796 struct video_device
*vdev
= video_devdata(file
);
797 struct cx25821_dev
*h
, *dev
= video_drvdata(file
);
798 struct cx25821_fh
*fh
;
799 struct list_head
*list
;
800 int minor
= video_devdata(file
)->minor
;
801 enum v4l2_buf_type type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
806 dprintk(1, "open dev=%s type=%s\n",
807 video_device_node_name(vdev
),
808 v4l2_type_names
[type
]);
810 /* allocate + initialize per filehandle data */
811 fh
= kzalloc(sizeof(*fh
), GFP_KERNEL
);
817 list_for_each(list
, &cx25821_devlist
)
819 h
= list_entry(list
, struct cx25821_dev
, devlist
);
821 for (i
= 0; i
< MAX_VID_CHANNEL_NUM
; i
++) {
822 if (h
->channels
[i
].video_dev
&&
823 h
->channels
[i
].video_dev
->minor
== minor
) {
826 type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
836 file
->private_data
= fh
;
840 fh
->channel_id
= ch_id
;
842 if (dev
->tvnorm
& V4L2_STD_PAL_BG
|| dev
->tvnorm
& V4L2_STD_PAL_DK
)
847 dev
->channel_opened
= fh
->channel_id
;
849 (dev
->channels
[ch_id
].pixel_formats
==
850 PIXEL_FRMT_411
) ? V4L2_PIX_FMT_Y41P
: V4L2_PIX_FMT_YUYV
;
851 fh
->fmt
= format_by_fourcc(pix_format
);
853 v4l2_prio_open(&dev
->channels
[ch_id
].prio
, &fh
->prio
);
855 videobuf_queue_sg_init(&fh
->vidq
, &cx25821_video_qops
,
856 &dev
->pci
->dev
, &dev
->slock
,
857 V4L2_BUF_TYPE_VIDEO_CAPTURE
,
858 V4L2_FIELD_INTERLACED
,
859 sizeof(struct cx25821_buffer
), fh
);
861 dprintk(1, "post videobuf_queue_init()\n");
867 static ssize_t
video_read(struct file
*file
, char __user
* data
, size_t count
,
870 struct cx25821_fh
*fh
= file
->private_data
;
873 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
874 if (cx25821_res_locked(fh
, RESOURCE_VIDEO0
))
877 return videobuf_read_one(&fh
->vidq
, data
, count
, ppos
,
878 file
->f_flags
& O_NONBLOCK
);
886 static unsigned int video_poll(struct file
*file
,
887 struct poll_table_struct
*wait
)
889 struct cx25821_fh
*fh
= file
->private_data
;
890 struct cx25821_buffer
*buf
;
892 if (cx25821_res_check(fh
, RESOURCE_VIDEO0
)) {
893 /* streaming capture */
894 if (list_empty(&fh
->vidq
.stream
))
896 buf
= list_entry(fh
->vidq
.stream
.next
,
897 struct cx25821_buffer
, vb
.stream
);
900 buf
= (struct cx25821_buffer
*)fh
->vidq
.read_buf
;
905 poll_wait(file
, &buf
->vb
.done
, wait
);
906 if (buf
->vb
.state
== VIDEOBUF_DONE
|| buf
->vb
.state
== VIDEOBUF_ERROR
) {
907 if (buf
->vb
.state
== VIDEOBUF_DONE
) {
908 struct cx25821_dev
*dev
= fh
->dev
;
910 if (dev
&& dev
->channels
[fh
->channel_id
]
911 .use_cif_resolution
) {
912 u8 cam_id
= *((char *)buf
->vb
.baddr
+ 3);
913 memcpy((char *)buf
->vb
.baddr
,
914 (char *)buf
->vb
.baddr
+ (fh
->width
* 2),
916 *((char *)buf
->vb
.baddr
+ 3) = cam_id
;
920 return POLLIN
| POLLRDNORM
;
926 static int video_release(struct file
*file
)
928 struct cx25821_fh
*fh
= file
->private_data
;
929 struct cx25821_dev
*dev
= fh
->dev
;
931 /* stop the risc engine and fifo */
932 cx_write(channel0
->dma_ctl
, 0); /* FIFO and RISC disable */
934 /* stop video capture */
935 if (cx25821_res_check(fh
, RESOURCE_VIDEO0
)) {
936 videobuf_queue_cancel(&fh
->vidq
);
937 cx25821_res_free(dev
, fh
, RESOURCE_VIDEO0
);
940 if (fh
->vidq
.read_buf
) {
941 cx25821_buffer_release(&fh
->vidq
, fh
->vidq
.read_buf
);
942 kfree(fh
->vidq
.read_buf
);
945 videobuf_mmap_free(&fh
->vidq
);
947 v4l2_prio_close(&dev
->channels
[fh
->channel_id
].prio
, fh
->prio
);
948 file
->private_data
= NULL
;
954 static int vidioc_streamon(struct file
*file
, void *priv
, enum v4l2_buf_type i
)
956 struct cx25821_fh
*fh
= priv
;
957 struct cx25821_dev
*dev
= fh
->dev
;
959 if (unlikely(fh
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
))
962 if (unlikely(i
!= fh
->type
))
965 if (unlikely(!cx25821_res_get(dev
, fh
,
966 cx25821_get_resource(fh
, RESOURCE_VIDEO0
))))
969 return videobuf_streamon(get_queue(fh
));
972 static int vidioc_streamoff(struct file
*file
, void *priv
, enum v4l2_buf_type i
)
974 struct cx25821_fh
*fh
= priv
;
975 struct cx25821_dev
*dev
= fh
->dev
;
978 if (fh
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
983 res
= cx25821_get_resource(fh
, RESOURCE_VIDEO0
);
984 err
= videobuf_streamoff(get_queue(fh
));
987 cx25821_res_free(dev
, fh
, res
);
991 static int vidioc_s_fmt_vid_cap(struct file
*file
, void *priv
,
992 struct v4l2_format
*f
)
994 struct cx25821_fh
*fh
= priv
;
995 struct cx25821_dev
*dev
= ((struct cx25821_fh
*)priv
)->dev
;
997 int pix_format
= PIXEL_FRMT_422
;
1000 err
= v4l2_prio_check(&dev
->channels
[fh
->channel_id
]
1006 dprintk(2, "%s()\n", __func__
);
1007 err
= cx25821_vidioc_try_fmt_vid_cap(file
, priv
, f
);
1012 fh
->fmt
= format_by_fourcc(f
->fmt
.pix
.pixelformat
);
1013 fh
->vidq
.field
= f
->fmt
.pix
.field
;
1015 /* check if width and height is valid based on set standard */
1016 if (cx25821_is_valid_width(f
->fmt
.pix
.width
, dev
->tvnorm
))
1017 fh
->width
= f
->fmt
.pix
.width
;
1019 if (cx25821_is_valid_height(f
->fmt
.pix
.height
, dev
->tvnorm
))
1020 fh
->height
= f
->fmt
.pix
.height
;
1022 if (f
->fmt
.pix
.pixelformat
== V4L2_PIX_FMT_Y41P
)
1023 pix_format
= PIXEL_FRMT_411
;
1024 else if (f
->fmt
.pix
.pixelformat
== V4L2_PIX_FMT_YUYV
)
1025 pix_format
= PIXEL_FRMT_422
;
1029 cx25821_set_pixel_format(dev
, SRAM_CH00
, pix_format
);
1031 /* check if cif resolution */
1032 if (fh
->width
== 320 || fh
->width
== 352)
1033 dev
->channels
[fh
->channel_id
].use_cif_resolution
= 1;
1035 dev
->channels
[fh
->channel_id
].use_cif_resolution
= 0;
1037 dev
->channels
[fh
->channel_id
].cif_width
= fh
->width
;
1038 medusa_set_resolution(dev
, fh
->width
, SRAM_CH00
);
1040 dprintk(2, "%s() width=%d height=%d field=%d\n", __func__
, fh
->width
,
1041 fh
->height
, fh
->vidq
.field
);
1042 cx25821_call_all(dev
, video
, s_fmt
, f
);
1047 static int vidioc_dqbuf(struct file
*file
, void *priv
, struct v4l2_buffer
*p
)
1050 struct cx25821_fh
*fh
= priv
;
1051 struct cx25821_dev
*dev
= ((struct cx25821_fh
*)priv
)->dev
;
1053 ret_val
= videobuf_dqbuf(get_queue(fh
), p
, file
->f_flags
& O_NONBLOCK
);
1055 p
->sequence
= dev
->channels
[fh
->channel_id
].vidq
.count
;
1060 static int vidioc_log_status(struct file
*file
, void *priv
)
1062 struct cx25821_dev
*dev
= ((struct cx25821_fh
*)priv
)->dev
;
1063 struct cx25821_fh
*fh
= priv
;
1066 struct sram_channel
*sram_ch
= dev
->channels
[fh
->channel_id
]
1070 snprintf(name
, sizeof(name
), "%s/2", dev
->name
);
1071 printk(KERN_INFO
"%s/2: ============ START LOG STATUS ============\n",
1073 cx25821_call_all(dev
, core
, log_status
);
1074 tmp
= cx_read(sram_ch
->dma_ctl
);
1075 printk(KERN_INFO
"Video input 0 is %s\n",
1076 (tmp
& 0x11) ? "streaming" : "stopped");
1077 printk(KERN_INFO
"%s/2: ============= END LOG STATUS =============\n",
1082 static int vidioc_s_ctrl(struct file
*file
, void *priv
,
1083 struct v4l2_control
*ctl
)
1085 struct cx25821_fh
*fh
= priv
;
1086 struct cx25821_dev
*dev
= ((struct cx25821_fh
*)priv
)->dev
;
1090 err
= v4l2_prio_check(&dev
->channels
[fh
->channel_id
]
1096 return cx25821_set_control(dev
, ctl
, fh
->channel_id
);
1100 int cx25821_vidioc_g_fmt_vid_cap(struct file
*file
, void *priv
, struct v4l2_format
*f
)
1102 struct cx25821_fh
*fh
= priv
;
1104 f
->fmt
.pix
.width
= fh
->width
;
1105 f
->fmt
.pix
.height
= fh
->height
;
1106 f
->fmt
.pix
.field
= fh
->vidq
.field
;
1107 f
->fmt
.pix
.pixelformat
= fh
->fmt
->fourcc
;
1108 f
->fmt
.pix
.bytesperline
= (f
->fmt
.pix
.width
* fh
->fmt
->depth
) >> 3;
1109 f
->fmt
.pix
.sizeimage
= f
->fmt
.pix
.height
* f
->fmt
.pix
.bytesperline
;
1114 int cx25821_vidioc_try_fmt_vid_cap(struct file
*file
, void *priv
, struct v4l2_format
*f
)
1116 struct cx25821_fmt
*fmt
;
1117 enum v4l2_field field
;
1118 unsigned int maxw
, maxh
;
1120 fmt
= format_by_fourcc(f
->fmt
.pix
.pixelformat
);
1124 field
= f
->fmt
.pix
.field
;
1128 if (V4L2_FIELD_ANY
== field
) {
1129 field
= (f
->fmt
.pix
.height
> maxh
/ 2)
1130 ? V4L2_FIELD_INTERLACED
: V4L2_FIELD_TOP
;
1134 case V4L2_FIELD_TOP
:
1135 case V4L2_FIELD_BOTTOM
:
1138 case V4L2_FIELD_INTERLACED
:
1144 f
->fmt
.pix
.field
= field
;
1145 if (f
->fmt
.pix
.height
< 32)
1146 f
->fmt
.pix
.height
= 32;
1147 if (f
->fmt
.pix
.height
> maxh
)
1148 f
->fmt
.pix
.height
= maxh
;
1149 if (f
->fmt
.pix
.width
< 48)
1150 f
->fmt
.pix
.width
= 48;
1151 if (f
->fmt
.pix
.width
> maxw
)
1152 f
->fmt
.pix
.width
= maxw
;
1153 f
->fmt
.pix
.width
&= ~0x03;
1154 f
->fmt
.pix
.bytesperline
= (f
->fmt
.pix
.width
* fmt
->depth
) >> 3;
1155 f
->fmt
.pix
.sizeimage
= f
->fmt
.pix
.height
* f
->fmt
.pix
.bytesperline
;
1160 int cx25821_vidioc_querycap(struct file
*file
, void *priv
, struct v4l2_capability
*cap
)
1162 struct cx25821_dev
*dev
= ((struct cx25821_fh
*)priv
)->dev
;
1164 strcpy(cap
->driver
, "cx25821");
1165 strlcpy(cap
->card
, cx25821_boards
[dev
->board
].name
, sizeof(cap
->card
));
1166 sprintf(cap
->bus_info
, "PCIe:%s", pci_name(dev
->pci
));
1167 cap
->version
= CX25821_VERSION_CODE
;
1169 V4L2_CAP_VIDEO_CAPTURE
| V4L2_CAP_READWRITE
| V4L2_CAP_STREAMING
;
1170 if (UNSET
!= dev
->tuner_type
)
1171 cap
->capabilities
|= V4L2_CAP_TUNER
;
1175 int cx25821_vidioc_enum_fmt_vid_cap(struct file
*file
, void *priv
,
1176 struct v4l2_fmtdesc
*f
)
1178 if (unlikely(f
->index
>= ARRAY_SIZE(formats
)))
1181 strlcpy(f
->description
, formats
[f
->index
].name
, sizeof(f
->description
));
1182 f
->pixelformat
= formats
[f
->index
].fourcc
;
1187 #ifdef CONFIG_VIDEO_V4L1_COMPAT
1188 int cx25821_vidiocgmbuf(struct file
*file
, void *priv
, struct video_mbuf
*mbuf
)
1190 struct cx25821_fh
*fh
= priv
;
1191 struct videobuf_queue
*q
;
1192 struct v4l2_requestbuffers req
;
1197 memset(&req
, 0, sizeof(req
));
1200 req
.memory
= V4L2_MEMORY_MMAP
;
1201 err
= videobuf_reqbufs(q
, &req
);
1205 mbuf
->frames
= req
.count
;
1207 for (i
= 0; i
< mbuf
->frames
; i
++) {
1208 mbuf
->offsets
[i
] = q
->bufs
[i
]->boff
;
1209 mbuf
->size
+= q
->bufs
[i
]->bsize
;
1215 int cx25821_vidioc_reqbufs(struct file
*file
, void *priv
, struct v4l2_requestbuffers
*p
)
1217 struct cx25821_fh
*fh
= priv
;
1218 return videobuf_reqbufs(get_queue(fh
), p
);
1221 int cx25821_vidioc_querybuf(struct file
*file
, void *priv
, struct v4l2_buffer
*p
)
1223 struct cx25821_fh
*fh
= priv
;
1224 return videobuf_querybuf(get_queue(fh
), p
);
1227 int cx25821_vidioc_qbuf(struct file
*file
, void *priv
, struct v4l2_buffer
*p
)
1229 struct cx25821_fh
*fh
= priv
;
1230 return videobuf_qbuf(get_queue(fh
), p
);
1233 int cx25821_vidioc_g_priority(struct file
*file
, void *f
, enum v4l2_priority
*p
)
1235 struct cx25821_dev
*dev
= ((struct cx25821_fh
*)f
)->dev
;
1236 struct cx25821_fh
*fh
= f
;
1238 *p
= v4l2_prio_max(&dev
->channels
[fh
->channel_id
].prio
);
1243 int cx25821_vidioc_s_priority(struct file
*file
, void *f
, enum v4l2_priority prio
)
1245 struct cx25821_fh
*fh
= f
;
1246 struct cx25821_dev
*dev
= ((struct cx25821_fh
*)f
)->dev
;
1248 return v4l2_prio_change(&dev
->channels
[fh
->channel_id
]
1249 .prio
, &fh
->prio
, prio
);
1253 int cx25821_vidioc_s_std(struct file
*file
, void *priv
, v4l2_std_id
* tvnorms
)
1255 struct cx25821_fh
*fh
= priv
;
1256 struct cx25821_dev
*dev
= ((struct cx25821_fh
*)priv
)->dev
;
1259 dprintk(1, "%s()\n", __func__
);
1262 err
= v4l2_prio_check(&dev
->channels
[fh
->channel_id
]
1268 if (dev
->tvnorm
== *tvnorms
) {
1272 mutex_lock(&dev
->lock
);
1273 cx25821_set_tvnorm(dev
, *tvnorms
);
1274 mutex_unlock(&dev
->lock
);
1276 medusa_set_videostandard(dev
);
1282 int cx25821_enum_input(struct cx25821_dev
*dev
, struct v4l2_input
*i
)
1284 static const char *iname
[] = {
1285 [CX25821_VMUX_COMPOSITE
] = "Composite",
1286 [CX25821_VMUX_SVIDEO
] = "S-Video",
1287 [CX25821_VMUX_DEBUG
] = "for debug only",
1290 dprintk(1, "%s()\n", __func__
);
1296 if (0 == INPUT(n
)->type
)
1299 memset(i
, 0, sizeof(*i
));
1301 i
->type
= V4L2_INPUT_TYPE_CAMERA
;
1302 strcpy(i
->name
, iname
[INPUT(n
)->type
]);
1304 i
->std
= CX25821_NORMS
;
1308 int cx25821_vidioc_enum_input(struct file
*file
, void *priv
, struct v4l2_input
*i
)
1310 struct cx25821_dev
*dev
= ((struct cx25821_fh
*)priv
)->dev
;
1311 dprintk(1, "%s()\n", __func__
);
1312 return cx25821_enum_input(dev
, i
);
1315 int cx25821_vidioc_g_input(struct file
*file
, void *priv
, unsigned int *i
)
1317 struct cx25821_dev
*dev
= ((struct cx25821_fh
*)priv
)->dev
;
1320 dprintk(1, "%s() returns %d\n", __func__
, *i
);
1324 int cx25821_vidioc_s_input(struct file
*file
, void *priv
, unsigned int i
)
1326 struct cx25821_fh
*fh
= priv
;
1327 struct cx25821_dev
*dev
= ((struct cx25821_fh
*)priv
)->dev
;
1330 dprintk(1, "%s(%d)\n", __func__
, i
);
1333 err
= v4l2_prio_check(&dev
->channels
[fh
->channel_id
]
1340 dprintk(1, "%s() -EINVAL\n", __func__
);
1344 mutex_lock(&dev
->lock
);
1345 cx25821_video_mux(dev
, i
);
1346 mutex_unlock(&dev
->lock
);
1351 int cx25821_vidioc_g_frequency(struct file
*file
, void *priv
, struct v4l2_frequency
*f
)
1353 struct cx25821_fh
*fh
= priv
;
1354 struct cx25821_dev
*dev
= fh
->dev
;
1356 f
->frequency
= dev
->freq
;
1358 cx25821_call_all(dev
, tuner
, g_frequency
, f
);
1363 int cx25821_set_freq(struct cx25821_dev
*dev
, struct v4l2_frequency
*f
)
1365 mutex_lock(&dev
->lock
);
1366 dev
->freq
= f
->frequency
;
1368 cx25821_call_all(dev
, tuner
, s_frequency
, f
);
1370 /* When changing channels it is required to reset TVAUDIO */
1373 mutex_unlock(&dev
->lock
);
1378 int cx25821_vidioc_s_frequency(struct file
*file
, void *priv
, struct v4l2_frequency
*f
)
1380 struct cx25821_fh
*fh
= priv
;
1381 struct cx25821_dev
*dev
;
1386 err
= v4l2_prio_check(&dev
->channels
[fh
->channel_id
]
1391 printk(KERN_ERR
"Invalid fh pointer!\n");
1395 return cx25821_set_freq(dev
, f
);
1399 #ifdef CONFIG_VIDEO_ADV_DEBUG
1400 int cx25821_vidioc_g_register(struct file
*file
, void *fh
,
1401 struct v4l2_dbg_register
*reg
)
1403 struct cx25821_dev
*dev
= ((struct cx25821_fh
*)fh
)->dev
;
1405 if (!v4l2_chip_match_host(®
->match
))
1408 cx25821_call_all(dev
, core
, g_register
, reg
);
1413 int cx25821_vidioc_s_register(struct file
*file
, void *fh
,
1414 struct v4l2_dbg_register
*reg
)
1416 struct cx25821_dev
*dev
= ((struct cx25821_fh
*)fh
)->dev
;
1418 if (!v4l2_chip_match_host(®
->match
))
1421 cx25821_call_all(dev
, core
, s_register
, reg
);
1429 int cx25821_vidioc_g_tuner(struct file
*file
, void *priv
, struct v4l2_tuner
*t
)
1431 struct cx25821_dev
*dev
= ((struct cx25821_fh
*)priv
)->dev
;
1433 if (unlikely(UNSET
== dev
->tuner_type
))
1438 strcpy(t
->name
, "Television");
1439 t
->type
= V4L2_TUNER_ANALOG_TV
;
1440 t
->capability
= V4L2_TUNER_CAP_NORM
;
1441 t
->rangehigh
= 0xffffffffUL
;
1443 t
->signal
= 0xffff; /* LOCKED */
1447 int cx25821_vidioc_s_tuner(struct file
*file
, void *priv
, struct v4l2_tuner
*t
)
1449 struct cx25821_dev
*dev
= ((struct cx25821_fh
*)priv
)->dev
;
1450 struct cx25821_fh
*fh
= priv
;
1454 err
= v4l2_prio_check(&dev
->channels
[fh
->channel_id
]
1460 dprintk(1, "%s()\n", __func__
);
1461 if (UNSET
== dev
->tuner_type
)
1470 /*****************************************************************************/
1471 static const struct v4l2_queryctrl no_ctl
= {
1473 .flags
= V4L2_CTRL_FLAG_DISABLED
,
1476 static struct v4l2_queryctrl cx25821_ctls
[] = {
1479 .id
= V4L2_CID_BRIGHTNESS
,
1480 .name
= "Brightness",
1484 .default_value
= 6200,
1485 .type
= V4L2_CTRL_TYPE_INTEGER
,
1487 .id
= V4L2_CID_CONTRAST
,
1492 .default_value
= 5000,
1493 .type
= V4L2_CTRL_TYPE_INTEGER
,
1495 .id
= V4L2_CID_SATURATION
,
1496 .name
= "Saturation",
1500 .default_value
= 5000,
1501 .type
= V4L2_CTRL_TYPE_INTEGER
,
1508 .default_value
= 5000,
1509 .type
= V4L2_CTRL_TYPE_INTEGER
,
1512 static const int CX25821_CTLS
= ARRAY_SIZE(cx25821_ctls
);
1514 static int cx25821_ctrl_query(struct v4l2_queryctrl
*qctrl
)
1518 if (qctrl
->id
< V4L2_CID_BASE
|| qctrl
->id
>= V4L2_CID_LASTP1
)
1520 for (i
= 0; i
< CX25821_CTLS
; i
++)
1521 if (cx25821_ctls
[i
].id
== qctrl
->id
)
1523 if (i
== CX25821_CTLS
) {
1527 *qctrl
= cx25821_ctls
[i
];
1531 int cx25821_vidioc_queryctrl(struct file
*file
, void *priv
,
1532 struct v4l2_queryctrl
*qctrl
)
1534 return cx25821_ctrl_query(qctrl
);
1537 /* ------------------------------------------------------------------ */
1538 /* VIDEO CTRL IOCTLS */
1540 static const struct v4l2_queryctrl
*ctrl_by_id(unsigned int id
)
1544 for (i
= 0; i
< CX25821_CTLS
; i
++)
1545 if (cx25821_ctls
[i
].id
== id
)
1546 return cx25821_ctls
+ i
;
1550 int cx25821_vidioc_g_ctrl(struct file
*file
, void *priv
, struct v4l2_control
*ctl
)
1552 struct cx25821_dev
*dev
= ((struct cx25821_fh
*)priv
)->dev
;
1553 struct cx25821_fh
*fh
= priv
;
1555 const struct v4l2_queryctrl
*ctrl
;
1557 ctrl
= ctrl_by_id(ctl
->id
);
1562 case V4L2_CID_BRIGHTNESS
:
1563 ctl
->value
= dev
->channels
[fh
->channel_id
].ctl_bright
;
1566 ctl
->value
= dev
->channels
[fh
->channel_id
].ctl_hue
;
1568 case V4L2_CID_CONTRAST
:
1569 ctl
->value
= dev
->channels
[fh
->channel_id
].ctl_contrast
;
1571 case V4L2_CID_SATURATION
:
1572 ctl
->value
= dev
->channels
[fh
->channel_id
].ctl_saturation
;
1578 int cx25821_set_control(struct cx25821_dev
*dev
,
1579 struct v4l2_control
*ctl
, int chan_num
)
1582 const struct v4l2_queryctrl
*ctrl
;
1586 ctrl
= ctrl_by_id(ctl
->id
);
1591 switch (ctrl
->type
) {
1592 case V4L2_CTRL_TYPE_BOOLEAN
:
1593 case V4L2_CTRL_TYPE_MENU
:
1594 case V4L2_CTRL_TYPE_INTEGER
:
1595 if (ctl
->value
< ctrl
->minimum
)
1596 ctl
->value
= ctrl
->minimum
;
1597 if (ctl
->value
> ctrl
->maximum
)
1598 ctl
->value
= ctrl
->maximum
;
1605 case V4L2_CID_BRIGHTNESS
:
1606 dev
->channels
[chan_num
].ctl_bright
= ctl
->value
;
1607 medusa_set_brightness(dev
, ctl
->value
, chan_num
);
1610 dev
->channels
[chan_num
].ctl_hue
= ctl
->value
;
1611 medusa_set_hue(dev
, ctl
->value
, chan_num
);
1613 case V4L2_CID_CONTRAST
:
1614 dev
->channels
[chan_num
].ctl_contrast
= ctl
->value
;
1615 medusa_set_contrast(dev
, ctl
->value
, chan_num
);
1617 case V4L2_CID_SATURATION
:
1618 dev
->channels
[chan_num
].ctl_saturation
= ctl
->value
;
1619 medusa_set_saturation(dev
, ctl
->value
, chan_num
);
1628 static void cx25821_init_controls(struct cx25821_dev
*dev
, int chan_num
)
1630 struct v4l2_control ctrl
;
1632 for (i
= 0; i
< CX25821_CTLS
; i
++) {
1633 ctrl
.id
= cx25821_ctls
[i
].id
;
1634 ctrl
.value
= cx25821_ctls
[i
].default_value
;
1636 cx25821_set_control(dev
, &ctrl
, chan_num
);
1640 int cx25821_vidioc_cropcap(struct file
*file
, void *priv
, struct v4l2_cropcap
*cropcap
)
1642 struct cx25821_dev
*dev
= ((struct cx25821_fh
*)priv
)->dev
;
1644 if (cropcap
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1646 cropcap
->bounds
.top
= cropcap
->bounds
.left
= 0;
1647 cropcap
->bounds
.width
= 720;
1648 cropcap
->bounds
.height
= dev
->tvnorm
== V4L2_STD_PAL_BG
? 576 : 480;
1649 cropcap
->pixelaspect
.numerator
=
1650 dev
->tvnorm
== V4L2_STD_PAL_BG
? 59 : 10;
1651 cropcap
->pixelaspect
.denominator
=
1652 dev
->tvnorm
== V4L2_STD_PAL_BG
? 54 : 11;
1653 cropcap
->defrect
= cropcap
->bounds
;
1657 int cx25821_vidioc_s_crop(struct file
*file
, void *priv
, struct v4l2_crop
*crop
)
1659 struct cx25821_dev
*dev
= ((struct cx25821_fh
*)priv
)->dev
;
1660 struct cx25821_fh
*fh
= priv
;
1664 err
= v4l2_prio_check(&dev
->channels
[fh
->channel_id
].
1669 /* cx25821_vidioc_s_crop not supported */
1673 int cx25821_vidioc_g_crop(struct file
*file
, void *priv
, struct v4l2_crop
*crop
)
1675 /* cx25821_vidioc_g_crop not supported */
1679 int cx25821_vidioc_querystd(struct file
*file
, void *priv
, v4l2_std_id
* norm
)
1681 /* medusa does not support video standard sensing of current input */
1682 *norm
= CX25821_NORMS
;
1687 int cx25821_is_valid_width(u32 width
, v4l2_std_id tvnorm
)
1689 if (tvnorm
== V4L2_STD_PAL_BG
) {
1690 if (width
== 352 || width
== 720)
1696 if (tvnorm
== V4L2_STD_NTSC_M
) {
1697 if (width
== 320 || width
== 352 || width
== 720)
1705 int cx25821_is_valid_height(u32 height
, v4l2_std_id tvnorm
)
1707 if (tvnorm
== V4L2_STD_PAL_BG
) {
1708 if (height
== 576 || height
== 288)
1714 if (tvnorm
== V4L2_STD_NTSC_M
) {
1715 if (height
== 480 || height
== 240)
1724 static long video_ioctl_upstream9(struct file
*file
, unsigned int cmd
,
1727 struct cx25821_fh
*fh
= file
->private_data
;
1728 struct cx25821_dev
*dev
= fh
->dev
;
1730 struct upstream_user_struct
*data_from_user
;
1732 data_from_user
= (struct upstream_user_struct
*)arg
;
1734 if (!data_from_user
) {
1736 ("cx25821 in %s(): Upstream data is INVALID. Returning.\n",
1741 command
= data_from_user
->command
;
1743 if (command
!= UPSTREAM_START_VIDEO
&&
1744 command
!= UPSTREAM_STOP_VIDEO
)
1747 dev
->input_filename
= data_from_user
->input_filename
;
1748 dev
->input_audiofilename
= data_from_user
->input_filename
;
1749 dev
->vid_stdname
= data_from_user
->vid_stdname
;
1750 dev
->pixel_format
= data_from_user
->pixel_format
;
1751 dev
->channel_select
= data_from_user
->channel_select
;
1752 dev
->command
= data_from_user
->command
;
1755 case UPSTREAM_START_VIDEO
:
1756 cx25821_start_upstream_video_ch1(dev
, data_from_user
);
1759 case UPSTREAM_STOP_VIDEO
:
1760 cx25821_stop_upstream_video_ch1(dev
);
1767 static long video_ioctl_upstream10(struct file
*file
, unsigned int cmd
,
1770 struct cx25821_fh
*fh
= file
->private_data
;
1771 struct cx25821_dev
*dev
= fh
->dev
;
1773 struct upstream_user_struct
*data_from_user
;
1775 data_from_user
= (struct upstream_user_struct
*)arg
;
1777 if (!data_from_user
) {
1779 ("cx25821 in %s(): Upstream data is INVALID. Returning.\n",
1784 command
= data_from_user
->command
;
1786 if (command
!= UPSTREAM_START_VIDEO
&&
1787 command
!= UPSTREAM_STOP_VIDEO
)
1790 dev
->input_filename_ch2
= data_from_user
->input_filename
;
1791 dev
->input_audiofilename
= data_from_user
->input_filename
;
1792 dev
->vid_stdname_ch2
= data_from_user
->vid_stdname
;
1793 dev
->pixel_format_ch2
= data_from_user
->pixel_format
;
1794 dev
->channel_select_ch2
= data_from_user
->channel_select
;
1795 dev
->command_ch2
= data_from_user
->command
;
1798 case UPSTREAM_START_VIDEO
:
1799 cx25821_start_upstream_video_ch2(dev
, data_from_user
);
1802 case UPSTREAM_STOP_VIDEO
:
1803 cx25821_stop_upstream_video_ch2(dev
);
1810 static long video_ioctl_upstream11(struct file
*file
, unsigned int cmd
,
1813 struct cx25821_fh
*fh
= file
->private_data
;
1814 struct cx25821_dev
*dev
= fh
->dev
;
1816 struct upstream_user_struct
*data_from_user
;
1818 data_from_user
= (struct upstream_user_struct
*)arg
;
1820 if (!data_from_user
) {
1822 ("cx25821 in %s(): Upstream data is INVALID. Returning.\n",
1827 command
= data_from_user
->command
;
1829 if (command
!= UPSTREAM_START_AUDIO
&&
1830 command
!= UPSTREAM_STOP_AUDIO
)
1833 dev
->input_filename
= data_from_user
->input_filename
;
1834 dev
->input_audiofilename
= data_from_user
->input_filename
;
1835 dev
->vid_stdname
= data_from_user
->vid_stdname
;
1836 dev
->pixel_format
= data_from_user
->pixel_format
;
1837 dev
->channel_select
= data_from_user
->channel_select
;
1838 dev
->command
= data_from_user
->command
;
1841 case UPSTREAM_START_AUDIO
:
1842 cx25821_start_upstream_audio(dev
, data_from_user
);
1845 case UPSTREAM_STOP_AUDIO
:
1846 cx25821_stop_upstream_audio(dev
);
1853 static long video_ioctl_set(struct file
*file
, unsigned int cmd
,
1856 struct cx25821_fh
*fh
= file
->private_data
;
1857 struct cx25821_dev
*dev
= fh
->dev
;
1858 struct downstream_user_struct
*data_from_user
;
1861 int selected_channel
= 0, pix_format
= 0, i
= 0;
1862 int cif_enable
= 0, cif_width
= 0;
1865 data_from_user
= (struct downstream_user_struct
*)arg
;
1867 if (!data_from_user
) {
1869 "cx25821 in %s(): User data is INVALID. Returning.\n",
1874 command
= data_from_user
->command
;
1876 if (command
!= SET_VIDEO_STD
&& command
!= SET_PIXEL_FORMAT
1877 && command
!= ENABLE_CIF_RESOLUTION
&& command
!= REG_READ
1878 && command
!= REG_WRITE
&& command
!= MEDUSA_READ
1879 && command
!= MEDUSA_WRITE
) {
1886 !strcmp(data_from_user
->vid_stdname
,
1887 "PAL") ? V4L2_STD_PAL_BG
: V4L2_STD_NTSC_M
;
1888 medusa_set_videostandard(dev
);
1891 case SET_PIXEL_FORMAT
:
1892 selected_channel
= data_from_user
->decoder_select
;
1893 pix_format
= data_from_user
->pixel_format
;
1895 if (!(selected_channel
<= 7 && selected_channel
>= 0)) {
1896 selected_channel
-= 4;
1897 selected_channel
= selected_channel
% 8;
1900 if (selected_channel
>= 0)
1901 cx25821_set_pixel_format(dev
, selected_channel
,
1906 case ENABLE_CIF_RESOLUTION
:
1907 selected_channel
= data_from_user
->decoder_select
;
1908 cif_enable
= data_from_user
->cif_resolution_enable
;
1909 cif_width
= data_from_user
->cif_width
;
1912 if (dev
->tvnorm
& V4L2_STD_PAL_BG
1913 || dev
->tvnorm
& V4L2_STD_PAL_DK
)
1916 width
= (cif_width
== 320
1917 || cif_width
== 352) ? cif_width
: 320;
1920 if (!(selected_channel
<= 7 && selected_channel
>= 0)) {
1921 selected_channel
-= 4;
1922 selected_channel
= selected_channel
% 8;
1925 if (selected_channel
<= 7 && selected_channel
>= 0) {
1926 dev
->channels
[selected_channel
].
1927 use_cif_resolution
= cif_enable
;
1928 dev
->channels
[selected_channel
].cif_width
= width
;
1930 for (i
= 0; i
< VID_CHANNEL_NUM
; i
++) {
1931 dev
->channels
[i
].use_cif_resolution
=
1933 dev
->channels
[i
].cif_width
= width
;
1937 medusa_set_resolution(dev
, width
, selected_channel
);
1940 data_from_user
->reg_data
= cx_read(data_from_user
->reg_address
);
1943 cx_write(data_from_user
->reg_address
, data_from_user
->reg_data
);
1947 cx25821_i2c_read(&dev
->i2c_bus
[0],
1948 (u16
) data_from_user
->reg_address
,
1949 &data_from_user
->reg_data
);
1952 cx25821_i2c_write(&dev
->i2c_bus
[0],
1953 (u16
) data_from_user
->reg_address
,
1954 data_from_user
->reg_data
);
1961 static long cx25821_video_ioctl(struct file
*file
,
1962 unsigned int cmd
, unsigned long arg
)
1966 struct cx25821_fh
*fh
= file
->private_data
;
1968 /* check to see if it's the video upstream */
1969 if (fh
->channel_id
== SRAM_CH09
) {
1970 ret
= video_ioctl_upstream9(file
, cmd
, arg
);
1972 } else if (fh
->channel_id
== SRAM_CH10
) {
1973 ret
= video_ioctl_upstream10(file
, cmd
, arg
);
1975 } else if (fh
->channel_id
== SRAM_CH11
) {
1976 ret
= video_ioctl_upstream11(file
, cmd
, arg
);
1977 ret
= video_ioctl_set(file
, cmd
, arg
);
1981 return video_ioctl2(file
, cmd
, arg
);
1984 /* exported stuff */
1985 static const struct v4l2_file_operations video_fops
= {
1986 .owner
= THIS_MODULE
,
1988 .release
= video_release
,
1991 .mmap
= cx25821_video_mmap
,
1992 .ioctl
= cx25821_video_ioctl
,
1995 static const struct v4l2_ioctl_ops video_ioctl_ops
= {
1996 .vidioc_querycap
= cx25821_vidioc_querycap
,
1997 .vidioc_enum_fmt_vid_cap
= cx25821_vidioc_enum_fmt_vid_cap
,
1998 .vidioc_g_fmt_vid_cap
= cx25821_vidioc_g_fmt_vid_cap
,
1999 .vidioc_try_fmt_vid_cap
= cx25821_vidioc_try_fmt_vid_cap
,
2000 .vidioc_s_fmt_vid_cap
= vidioc_s_fmt_vid_cap
,
2001 .vidioc_reqbufs
= cx25821_vidioc_reqbufs
,
2002 .vidioc_querybuf
= cx25821_vidioc_querybuf
,
2003 .vidioc_qbuf
= cx25821_vidioc_qbuf
,
2004 .vidioc_dqbuf
= vidioc_dqbuf
,
2006 .vidioc_s_std
= cx25821_vidioc_s_std
,
2007 .vidioc_querystd
= cx25821_vidioc_querystd
,
2009 .vidioc_cropcap
= cx25821_vidioc_cropcap
,
2010 .vidioc_s_crop
= cx25821_vidioc_s_crop
,
2011 .vidioc_g_crop
= cx25821_vidioc_g_crop
,
2012 .vidioc_enum_input
= cx25821_vidioc_enum_input
,
2013 .vidioc_g_input
= cx25821_vidioc_g_input
,
2014 .vidioc_s_input
= cx25821_vidioc_s_input
,
2015 .vidioc_g_ctrl
= cx25821_vidioc_g_ctrl
,
2016 .vidioc_s_ctrl
= vidioc_s_ctrl
,
2017 .vidioc_queryctrl
= cx25821_vidioc_queryctrl
,
2018 .vidioc_streamon
= vidioc_streamon
,
2019 .vidioc_streamoff
= vidioc_streamoff
,
2020 .vidioc_log_status
= vidioc_log_status
,
2021 .vidioc_g_priority
= cx25821_vidioc_g_priority
,
2022 .vidioc_s_priority
= cx25821_vidioc_s_priority
,
2023 #ifdef CONFIG_VIDEO_V4L1_COMPAT
2024 .vidiocgmbuf
= cx25821_vidiocgmbuf
,
2027 .vidioc_g_tuner
= cx25821_vidioc_g_tuner
,
2028 .vidioc_s_tuner
= cx25821_vidioc_s_tuner
,
2029 .vidioc_g_frequency
= cx25821_vidioc_g_frequency
,
2030 .vidioc_s_frequency
= cx25821_vidioc_s_frequency
,
2032 #ifdef CONFIG_VIDEO_ADV_DEBUG
2033 .vidioc_g_register
= cx25821_vidioc_g_register
,
2034 .vidioc_s_register
= cx25821_vidioc_s_register
,
2038 struct video_device cx25821_videoioctl_template
= {
2039 .name
= "cx25821-videoioctl",
2040 .fops
= &video_fops
,
2041 .ioctl_ops
= &video_ioctl_ops
,
2042 .tvnorms
= CX25821_NORMS
,
2043 .current_norm
= V4L2_STD_NTSC_M
,