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> cx25821 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 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
29 #include "cx25821-video.h"
31 MODULE_DESCRIPTION("v4l2 driver module for cx25821 based TV cards");
32 MODULE_AUTHOR("Hiep Huynh <hiep.huynh@conexant.com>");
33 MODULE_LICENSE("GPL");
35 static unsigned int video_nr
[] = {[0 ... (CX25821_MAXBOARDS
- 1)] = UNSET
};
37 module_param_array(video_nr
, int, NULL
, 0444);
39 MODULE_PARM_DESC(video_nr
, "video device numbers");
41 static unsigned int video_debug
= VIDEO_DEBUG
;
42 module_param(video_debug
, int, 0644);
43 MODULE_PARM_DESC(video_debug
, "enable debug messages [video]");
45 static unsigned int irq_debug
;
46 module_param(irq_debug
, int, 0644);
47 MODULE_PARM_DESC(irq_debug
, "enable debug messages [IRQ handler]");
49 #define FORMAT_FLAGS_PACKED 0x01
51 static const struct cx25821_fmt formats
[] = {
53 .name
= "4:1:1, packed, Y41P",
54 .fourcc
= V4L2_PIX_FMT_Y41P
,
56 .flags
= FORMAT_FLAGS_PACKED
,
58 .name
= "4:2:2, packed, YUYV",
59 .fourcc
= V4L2_PIX_FMT_YUYV
,
61 .flags
= FORMAT_FLAGS_PACKED
,
65 static const struct cx25821_fmt
*cx25821_format_by_fourcc(unsigned int fourcc
)
69 for (i
= 0; i
< ARRAY_SIZE(formats
); i
++)
70 if (formats
[i
].fourcc
== fourcc
)
75 int cx25821_start_video_dma(struct cx25821_dev
*dev
,
76 struct cx25821_dmaqueue
*q
,
77 struct cx25821_buffer
*buf
,
78 const struct sram_channel
*channel
)
82 /* setup fifo + format */
83 cx25821_sram_channel_setup(dev
, channel
, buf
->bpl
, buf
->risc
.dma
);
86 cx_write(channel
->gpcnt_ctl
, 3);
89 cx_set(PCI_INT_MSK
, cx_read(PCI_INT_MSK
) | (1 << channel
->i
));
90 cx_set(channel
->int_msk
, 0x11);
93 cx_write(channel
->dma_ctl
, 0x11); /* FIFO and RISC enable */
95 /* make sure upstream setting if any is reversed */
96 tmp
= cx_read(VID_CH_MODE_SEL
);
97 cx_write(VID_CH_MODE_SEL
, tmp
& 0xFFFFFE00);
102 int cx25821_video_irq(struct cx25821_dev
*dev
, int chan_num
, u32 status
)
106 const struct sram_channel
*channel
= dev
->channels
[chan_num
].sram_channels
;
108 mask
= cx_read(channel
->int_msk
);
109 if (0 == (status
& mask
))
112 cx_write(channel
->int_stat
, status
);
114 /* risc op code error */
115 if (status
& (1 << 16)) {
116 pr_warn("%s, %s: video risc op code error\n",
117 dev
->name
, channel
->name
);
118 cx_clear(channel
->dma_ctl
, 0x11);
119 cx25821_sram_channel_dump(dev
, channel
);
123 if (status
& FLD_VID_DST_RISC1
) {
124 struct cx25821_dmaqueue
*dmaq
=
125 &dev
->channels
[channel
->i
].dma_vidq
;
126 struct cx25821_buffer
*buf
;
128 spin_lock(&dev
->slock
);
129 if (!list_empty(&dmaq
->active
)) {
130 buf
= list_entry(dmaq
->active
.next
,
131 struct cx25821_buffer
, queue
);
133 v4l2_get_timestamp(&buf
->vb
.v4l2_buf
.timestamp
);
134 buf
->vb
.v4l2_buf
.sequence
= dmaq
->count
++;
135 list_del(&buf
->queue
);
136 vb2_buffer_done(&buf
->vb
, VB2_BUF_STATE_DONE
);
138 spin_unlock(&dev
->slock
);
144 static int cx25821_queue_setup(struct vb2_queue
*q
, const struct v4l2_format
*fmt
,
145 unsigned int *num_buffers
, unsigned int *num_planes
,
146 unsigned int sizes
[], void *alloc_ctxs
[])
148 struct cx25821_channel
*chan
= q
->drv_priv
;
149 unsigned size
= (chan
->fmt
->depth
* chan
->width
* chan
->height
) >> 3;
151 if (fmt
&& fmt
->fmt
.pix
.sizeimage
< size
)
155 sizes
[0] = fmt
? fmt
->fmt
.pix
.sizeimage
: size
;
156 alloc_ctxs
[0] = chan
->dev
->alloc_ctx
;
160 static int cx25821_buffer_prepare(struct vb2_buffer
*vb
)
162 struct cx25821_channel
*chan
= vb
->vb2_queue
->drv_priv
;
163 struct cx25821_dev
*dev
= chan
->dev
;
164 struct cx25821_buffer
*buf
=
165 container_of(vb
, struct cx25821_buffer
, vb
);
166 struct sg_table
*sgt
= vb2_dma_sg_plane_desc(vb
, 0);
168 int bpl_local
= LINE_SIZE_D1
;
171 if (chan
->pixel_formats
== PIXEL_FRMT_411
)
172 buf
->bpl
= (chan
->fmt
->depth
* chan
->width
) >> 3;
174 buf
->bpl
= (chan
->fmt
->depth
>> 3) * chan
->width
;
176 if (vb2_plane_size(vb
, 0) < chan
->height
* buf
->bpl
)
178 vb2_set_plane_payload(vb
, 0, chan
->height
* buf
->bpl
);
179 buf
->vb
.v4l2_buf
.field
= chan
->field
;
181 if (chan
->pixel_formats
== PIXEL_FRMT_411
) {
182 bpl_local
= buf
->bpl
;
184 bpl_local
= buf
->bpl
; /* Default */
186 if (chan
->use_cif_resolution
) {
187 if (dev
->tvnorm
& V4L2_STD_625_50
)
188 bpl_local
= 352 << 1;
190 bpl_local
= chan
->cif_width
<< 1;
194 switch (chan
->field
) {
196 ret
= cx25821_risc_buffer(dev
->pci
, &buf
->risc
,
198 buf
->bpl
, 0, chan
->height
);
200 case V4L2_FIELD_BOTTOM
:
201 ret
= cx25821_risc_buffer(dev
->pci
, &buf
->risc
,
203 buf
->bpl
, 0, chan
->height
);
205 case V4L2_FIELD_INTERLACED
:
206 /* All other formats are top field first */
208 dprintk(1, "top field first\n");
210 ret
= cx25821_risc_buffer(dev
->pci
, &buf
->risc
,
211 sgt
->sgl
, line0_offset
,
212 bpl_local
, bpl_local
, bpl_local
,
215 case V4L2_FIELD_SEQ_TB
:
216 ret
= cx25821_risc_buffer(dev
->pci
, &buf
->risc
,
218 0, buf
->bpl
* (chan
->height
>> 1),
219 buf
->bpl
, 0, chan
->height
>> 1);
221 case V4L2_FIELD_SEQ_BT
:
222 ret
= cx25821_risc_buffer(dev
->pci
, &buf
->risc
,
224 buf
->bpl
* (chan
->height
>> 1), 0,
225 buf
->bpl
, 0, chan
->height
>> 1);
233 dprintk(2, "[%p/%d] buffer_prep - %dx%d %dbpp \"%s\" - dma=0x%08lx\n",
234 buf
, buf
->vb
.v4l2_buf
.index
, chan
->width
, chan
->height
,
235 chan
->fmt
->depth
, chan
->fmt
->name
,
236 (unsigned long)buf
->risc
.dma
);
241 static void cx25821_buffer_finish(struct vb2_buffer
*vb
)
243 struct cx25821_buffer
*buf
=
244 container_of(vb
, struct cx25821_buffer
, vb
);
245 struct cx25821_channel
*chan
= vb
->vb2_queue
->drv_priv
;
246 struct cx25821_dev
*dev
= chan
->dev
;
248 cx25821_free_buffer(dev
, buf
);
251 static void cx25821_buffer_queue(struct vb2_buffer
*vb
)
253 struct cx25821_buffer
*buf
=
254 container_of(vb
, struct cx25821_buffer
, vb
);
255 struct cx25821_channel
*chan
= vb
->vb2_queue
->drv_priv
;
256 struct cx25821_dev
*dev
= chan
->dev
;
257 struct cx25821_buffer
*prev
;
258 struct cx25821_dmaqueue
*q
= &dev
->channels
[chan
->id
].dma_vidq
;
260 buf
->risc
.cpu
[1] = cpu_to_le32(buf
->risc
.dma
+ 12);
261 buf
->risc
.jmp
[0] = cpu_to_le32(RISC_JUMP
| RISC_CNT_INC
);
262 buf
->risc
.jmp
[1] = cpu_to_le32(buf
->risc
.dma
+ 12);
263 buf
->risc
.jmp
[2] = cpu_to_le32(0); /* bits 63-32 */
265 if (list_empty(&q
->active
)) {
266 list_add_tail(&buf
->queue
, &q
->active
);
268 buf
->risc
.cpu
[0] |= cpu_to_le32(RISC_IRQ1
);
269 prev
= list_entry(q
->active
.prev
, struct cx25821_buffer
,
271 list_add_tail(&buf
->queue
, &q
->active
);
272 prev
->risc
.jmp
[1] = cpu_to_le32(buf
->risc
.dma
);
276 static int cx25821_start_streaming(struct vb2_queue
*q
, unsigned int count
)
278 struct cx25821_channel
*chan
= q
->drv_priv
;
279 struct cx25821_dev
*dev
= chan
->dev
;
280 struct cx25821_dmaqueue
*dmaq
= &dev
->channels
[chan
->id
].dma_vidq
;
281 struct cx25821_buffer
*buf
= list_entry(dmaq
->active
.next
,
282 struct cx25821_buffer
, queue
);
285 cx25821_start_video_dma(dev
, dmaq
, buf
, chan
->sram_channels
);
289 static void cx25821_stop_streaming(struct vb2_queue
*q
)
291 struct cx25821_channel
*chan
= q
->drv_priv
;
292 struct cx25821_dev
*dev
= chan
->dev
;
293 struct cx25821_dmaqueue
*dmaq
= &dev
->channels
[chan
->id
].dma_vidq
;
296 cx_write(chan
->sram_channels
->dma_ctl
, 0); /* FIFO and RISC disable */
297 spin_lock_irqsave(&dev
->slock
, flags
);
298 while (!list_empty(&dmaq
->active
)) {
299 struct cx25821_buffer
*buf
= list_entry(dmaq
->active
.next
,
300 struct cx25821_buffer
, queue
);
302 list_del(&buf
->queue
);
303 vb2_buffer_done(&buf
->vb
, VB2_BUF_STATE_ERROR
);
305 spin_unlock_irqrestore(&dev
->slock
, flags
);
308 static struct vb2_ops cx25821_video_qops
= {
309 .queue_setup
= cx25821_queue_setup
,
310 .buf_prepare
= cx25821_buffer_prepare
,
311 .buf_finish
= cx25821_buffer_finish
,
312 .buf_queue
= cx25821_buffer_queue
,
313 .wait_prepare
= vb2_ops_wait_prepare
,
314 .wait_finish
= vb2_ops_wait_finish
,
315 .start_streaming
= cx25821_start_streaming
,
316 .stop_streaming
= cx25821_stop_streaming
,
321 static int cx25821_vidioc_enum_fmt_vid_cap(struct file
*file
, void *priv
,
322 struct v4l2_fmtdesc
*f
)
324 if (unlikely(f
->index
>= ARRAY_SIZE(formats
)))
327 strlcpy(f
->description
, formats
[f
->index
].name
, sizeof(f
->description
));
328 f
->pixelformat
= formats
[f
->index
].fourcc
;
333 static int cx25821_vidioc_g_fmt_vid_cap(struct file
*file
, void *priv
,
334 struct v4l2_format
*f
)
336 struct cx25821_channel
*chan
= video_drvdata(file
);
338 f
->fmt
.pix
.width
= chan
->width
;
339 f
->fmt
.pix
.height
= chan
->height
;
340 f
->fmt
.pix
.field
= chan
->field
;
341 f
->fmt
.pix
.pixelformat
= chan
->fmt
->fourcc
;
342 f
->fmt
.pix
.bytesperline
= (chan
->width
* chan
->fmt
->depth
) >> 3;
343 f
->fmt
.pix
.sizeimage
= chan
->height
* f
->fmt
.pix
.bytesperline
;
344 f
->fmt
.pix
.colorspace
= V4L2_COLORSPACE_SMPTE170M
;
349 static int cx25821_vidioc_try_fmt_vid_cap(struct file
*file
, void *priv
,
350 struct v4l2_format
*f
)
352 struct cx25821_channel
*chan
= video_drvdata(file
);
353 struct cx25821_dev
*dev
= chan
->dev
;
354 const struct cx25821_fmt
*fmt
;
355 enum v4l2_field field
= f
->fmt
.pix
.field
;
359 fmt
= cx25821_format_by_fourcc(f
->fmt
.pix
.pixelformat
);
362 maxh
= (dev
->tvnorm
& V4L2_STD_625_50
) ? 576 : 480;
364 w
= f
->fmt
.pix
.width
;
365 if (field
!= V4L2_FIELD_BOTTOM
)
366 field
= V4L2_FIELD_TOP
;
369 f
->fmt
.pix
.height
= maxh
/ 4;
370 } else if (w
< 720) {
372 f
->fmt
.pix
.height
= maxh
/ 2;
375 f
->fmt
.pix
.height
= maxh
;
376 field
= V4L2_FIELD_INTERLACED
;
378 f
->fmt
.pix
.field
= field
;
379 f
->fmt
.pix
.width
= w
;
380 f
->fmt
.pix
.bytesperline
= (f
->fmt
.pix
.width
* fmt
->depth
) >> 3;
381 f
->fmt
.pix
.sizeimage
= f
->fmt
.pix
.height
* f
->fmt
.pix
.bytesperline
;
382 f
->fmt
.pix
.colorspace
= V4L2_COLORSPACE_SMPTE170M
;
387 static int vidioc_s_fmt_vid_cap(struct file
*file
, void *priv
,
388 struct v4l2_format
*f
)
390 struct cx25821_channel
*chan
= video_drvdata(file
);
391 struct cx25821_dev
*dev
= chan
->dev
;
392 int pix_format
= PIXEL_FRMT_422
;
395 err
= cx25821_vidioc_try_fmt_vid_cap(file
, priv
, f
);
400 chan
->fmt
= cx25821_format_by_fourcc(f
->fmt
.pix
.pixelformat
);
401 chan
->field
= f
->fmt
.pix
.field
;
402 chan
->width
= f
->fmt
.pix
.width
;
403 chan
->height
= f
->fmt
.pix
.height
;
405 if (f
->fmt
.pix
.pixelformat
== V4L2_PIX_FMT_Y41P
)
406 pix_format
= PIXEL_FRMT_411
;
408 pix_format
= PIXEL_FRMT_422
;
410 cx25821_set_pixel_format(dev
, SRAM_CH00
, pix_format
);
412 /* check if cif resolution */
413 if (chan
->width
== 320 || chan
->width
== 352)
414 chan
->use_cif_resolution
= 1;
416 chan
->use_cif_resolution
= 0;
418 chan
->cif_width
= chan
->width
;
419 medusa_set_resolution(dev
, chan
->width
, SRAM_CH00
);
423 static int vidioc_log_status(struct file
*file
, void *priv
)
425 struct cx25821_channel
*chan
= video_drvdata(file
);
426 struct cx25821_dev
*dev
= chan
->dev
;
427 const struct sram_channel
*sram_ch
= chan
->sram_channels
;
430 tmp
= cx_read(sram_ch
->dma_ctl
);
431 pr_info("Video input 0 is %s\n",
432 (tmp
& 0x11) ? "streaming" : "stopped");
437 static int cx25821_vidioc_querycap(struct file
*file
, void *priv
,
438 struct v4l2_capability
*cap
)
440 struct cx25821_channel
*chan
= video_drvdata(file
);
441 struct cx25821_dev
*dev
= chan
->dev
;
442 const u32 cap_input
= V4L2_CAP_VIDEO_CAPTURE
|
443 V4L2_CAP_READWRITE
| V4L2_CAP_STREAMING
;
444 const u32 cap_output
= V4L2_CAP_VIDEO_OUTPUT
| V4L2_CAP_READWRITE
;
446 strcpy(cap
->driver
, "cx25821");
447 strlcpy(cap
->card
, cx25821_boards
[dev
->board
].name
, sizeof(cap
->card
));
448 sprintf(cap
->bus_info
, "PCIe:%s", pci_name(dev
->pci
));
449 if (chan
->id
>= VID_CHANNEL_NUM
)
450 cap
->device_caps
= cap_output
;
452 cap
->device_caps
= cap_input
;
453 cap
->capabilities
= cap_input
| cap_output
| V4L2_CAP_DEVICE_CAPS
;
457 static int cx25821_vidioc_g_std(struct file
*file
, void *priv
, v4l2_std_id
*tvnorms
)
459 struct cx25821_channel
*chan
= video_drvdata(file
);
461 *tvnorms
= chan
->dev
->tvnorm
;
465 static int cx25821_vidioc_s_std(struct file
*file
, void *priv
,
468 struct cx25821_channel
*chan
= video_drvdata(file
);
469 struct cx25821_dev
*dev
= chan
->dev
;
471 if (dev
->tvnorm
== tvnorms
)
474 dev
->tvnorm
= tvnorms
;
476 chan
->height
= (dev
->tvnorm
& V4L2_STD_625_50
) ? 576 : 480;
478 medusa_set_videostandard(dev
);
483 static int cx25821_vidioc_enum_input(struct file
*file
, void *priv
,
484 struct v4l2_input
*i
)
489 i
->type
= V4L2_INPUT_TYPE_CAMERA
;
490 i
->std
= CX25821_NORMS
;
491 strcpy(i
->name
, "Composite");
495 static int cx25821_vidioc_g_input(struct file
*file
, void *priv
, unsigned int *i
)
501 static int cx25821_vidioc_s_input(struct file
*file
, void *priv
, unsigned int i
)
503 return i
? -EINVAL
: 0;
506 static int cx25821_s_ctrl(struct v4l2_ctrl
*ctrl
)
508 struct cx25821_channel
*chan
=
509 container_of(ctrl
->handler
, struct cx25821_channel
, hdl
);
510 struct cx25821_dev
*dev
= chan
->dev
;
513 case V4L2_CID_BRIGHTNESS
:
514 medusa_set_brightness(dev
, ctrl
->val
, chan
->id
);
517 medusa_set_hue(dev
, ctrl
->val
, chan
->id
);
519 case V4L2_CID_CONTRAST
:
520 medusa_set_contrast(dev
, ctrl
->val
, chan
->id
);
522 case V4L2_CID_SATURATION
:
523 medusa_set_saturation(dev
, ctrl
->val
, chan
->id
);
531 static int cx25821_vidioc_enum_output(struct file
*file
, void *priv
,
532 struct v4l2_output
*o
)
537 o
->type
= V4L2_INPUT_TYPE_CAMERA
;
538 o
->std
= CX25821_NORMS
;
539 strcpy(o
->name
, "Composite");
543 static int cx25821_vidioc_g_output(struct file
*file
, void *priv
, unsigned int *o
)
549 static int cx25821_vidioc_s_output(struct file
*file
, void *priv
, unsigned int o
)
551 return o
? -EINVAL
: 0;
554 static int cx25821_vidioc_try_fmt_vid_out(struct file
*file
, void *priv
,
555 struct v4l2_format
*f
)
557 struct cx25821_channel
*chan
= video_drvdata(file
);
558 struct cx25821_dev
*dev
= chan
->dev
;
559 const struct cx25821_fmt
*fmt
;
561 fmt
= cx25821_format_by_fourcc(f
->fmt
.pix
.pixelformat
);
564 f
->fmt
.pix
.width
= 720;
565 f
->fmt
.pix
.height
= (dev
->tvnorm
& V4L2_STD_625_50
) ? 576 : 480;
566 f
->fmt
.pix
.field
= V4L2_FIELD_INTERLACED
;
567 f
->fmt
.pix
.bytesperline
= (f
->fmt
.pix
.width
* fmt
->depth
) >> 3;
568 f
->fmt
.pix
.sizeimage
= f
->fmt
.pix
.height
* f
->fmt
.pix
.bytesperline
;
569 f
->fmt
.pix
.colorspace
= V4L2_COLORSPACE_SMPTE170M
;
573 static int vidioc_s_fmt_vid_out(struct file
*file
, void *priv
,
574 struct v4l2_format
*f
)
576 struct cx25821_channel
*chan
= video_drvdata(file
);
579 err
= cx25821_vidioc_try_fmt_vid_out(file
, priv
, f
);
584 chan
->fmt
= cx25821_format_by_fourcc(f
->fmt
.pix
.pixelformat
);
585 chan
->field
= f
->fmt
.pix
.field
;
586 chan
->width
= f
->fmt
.pix
.width
;
587 chan
->height
= f
->fmt
.pix
.height
;
588 if (f
->fmt
.pix
.pixelformat
== V4L2_PIX_FMT_Y41P
)
589 chan
->pixel_formats
= PIXEL_FRMT_411
;
591 chan
->pixel_formats
= PIXEL_FRMT_422
;
595 static const struct v4l2_ctrl_ops cx25821_ctrl_ops
= {
596 .s_ctrl
= cx25821_s_ctrl
,
599 static const struct v4l2_file_operations video_fops
= {
600 .owner
= THIS_MODULE
,
601 .open
= v4l2_fh_open
,
602 .release
= vb2_fop_release
,
603 .read
= vb2_fop_read
,
604 .poll
= vb2_fop_poll
,
605 .unlocked_ioctl
= video_ioctl2
,
606 .mmap
= vb2_fop_mmap
,
609 static const struct v4l2_ioctl_ops video_ioctl_ops
= {
610 .vidioc_querycap
= cx25821_vidioc_querycap
,
611 .vidioc_enum_fmt_vid_cap
= cx25821_vidioc_enum_fmt_vid_cap
,
612 .vidioc_g_fmt_vid_cap
= cx25821_vidioc_g_fmt_vid_cap
,
613 .vidioc_try_fmt_vid_cap
= cx25821_vidioc_try_fmt_vid_cap
,
614 .vidioc_s_fmt_vid_cap
= vidioc_s_fmt_vid_cap
,
615 .vidioc_reqbufs
= vb2_ioctl_reqbufs
,
616 .vidioc_prepare_buf
= vb2_ioctl_prepare_buf
,
617 .vidioc_create_bufs
= vb2_ioctl_create_bufs
,
618 .vidioc_querybuf
= vb2_ioctl_querybuf
,
619 .vidioc_qbuf
= vb2_ioctl_qbuf
,
620 .vidioc_dqbuf
= vb2_ioctl_dqbuf
,
621 .vidioc_streamon
= vb2_ioctl_streamon
,
622 .vidioc_streamoff
= vb2_ioctl_streamoff
,
623 .vidioc_g_std
= cx25821_vidioc_g_std
,
624 .vidioc_s_std
= cx25821_vidioc_s_std
,
625 .vidioc_enum_input
= cx25821_vidioc_enum_input
,
626 .vidioc_g_input
= cx25821_vidioc_g_input
,
627 .vidioc_s_input
= cx25821_vidioc_s_input
,
628 .vidioc_log_status
= vidioc_log_status
,
629 .vidioc_subscribe_event
= v4l2_ctrl_subscribe_event
,
630 .vidioc_unsubscribe_event
= v4l2_event_unsubscribe
,
633 static const struct video_device cx25821_video_device
= {
634 .name
= "cx25821-video",
636 .release
= video_device_release_empty
,
638 .ioctl_ops
= &video_ioctl_ops
,
639 .tvnorms
= CX25821_NORMS
,
642 static const struct v4l2_file_operations video_out_fops
= {
643 .owner
= THIS_MODULE
,
644 .open
= v4l2_fh_open
,
645 .release
= vb2_fop_release
,
646 .write
= vb2_fop_write
,
647 .poll
= vb2_fop_poll
,
648 .unlocked_ioctl
= video_ioctl2
,
649 .mmap
= vb2_fop_mmap
,
652 static const struct v4l2_ioctl_ops video_out_ioctl_ops
= {
653 .vidioc_querycap
= cx25821_vidioc_querycap
,
654 .vidioc_enum_fmt_vid_out
= cx25821_vidioc_enum_fmt_vid_cap
,
655 .vidioc_g_fmt_vid_out
= cx25821_vidioc_g_fmt_vid_cap
,
656 .vidioc_try_fmt_vid_out
= cx25821_vidioc_try_fmt_vid_out
,
657 .vidioc_s_fmt_vid_out
= vidioc_s_fmt_vid_out
,
658 .vidioc_g_std
= cx25821_vidioc_g_std
,
659 .vidioc_s_std
= cx25821_vidioc_s_std
,
660 .vidioc_enum_output
= cx25821_vidioc_enum_output
,
661 .vidioc_g_output
= cx25821_vidioc_g_output
,
662 .vidioc_s_output
= cx25821_vidioc_s_output
,
663 .vidioc_log_status
= vidioc_log_status
,
666 static const struct video_device cx25821_video_out_device
= {
667 .name
= "cx25821-video",
668 .fops
= &video_out_fops
,
669 .release
= video_device_release_empty
,
671 .ioctl_ops
= &video_out_ioctl_ops
,
672 .tvnorms
= CX25821_NORMS
,
675 void cx25821_video_unregister(struct cx25821_dev
*dev
, int chan_num
)
677 cx_clear(PCI_INT_MSK
, 1);
679 if (video_is_registered(&dev
->channels
[chan_num
].vdev
)) {
680 video_unregister_device(&dev
->channels
[chan_num
].vdev
);
681 v4l2_ctrl_handler_free(&dev
->channels
[chan_num
].hdl
);
685 int cx25821_video_register(struct cx25821_dev
*dev
)
690 /* initial device configuration */
691 dev
->tvnorm
= V4L2_STD_NTSC_M
;
693 spin_lock_init(&dev
->slock
);
695 for (i
= 0; i
< MAX_VID_CAP_CHANNEL_NUM
- 1; ++i
) {
696 struct cx25821_channel
*chan
= &dev
->channels
[i
];
697 struct video_device
*vdev
= &chan
->vdev
;
698 struct v4l2_ctrl_handler
*hdl
= &chan
->hdl
;
700 bool is_output
= i
> SRAM_CH08
;
702 if (i
== SRAM_CH08
) /* audio channel */
706 v4l2_ctrl_handler_init(hdl
, 4);
707 v4l2_ctrl_new_std(hdl
, &cx25821_ctrl_ops
,
708 V4L2_CID_BRIGHTNESS
, 0, 10000, 1, 6200);
709 v4l2_ctrl_new_std(hdl
, &cx25821_ctrl_ops
,
710 V4L2_CID_CONTRAST
, 0, 10000, 1, 5000);
711 v4l2_ctrl_new_std(hdl
, &cx25821_ctrl_ops
,
712 V4L2_CID_SATURATION
, 0, 10000, 1, 5000);
713 v4l2_ctrl_new_std(hdl
, &cx25821_ctrl_ops
,
714 V4L2_CID_HUE
, 0, 10000, 1, 5000);
719 err
= v4l2_ctrl_handler_setup(hdl
);
723 chan
->out
= &dev
->vid_out_data
[i
- SRAM_CH09
];
724 chan
->out
->chan
= chan
;
727 chan
->sram_channels
= &cx25821_sram_channels
[i
];
729 chan
->field
= V4L2_FIELD_INTERLACED
;
730 if (dev
->tvnorm
& V4L2_STD_625_50
)
735 if (chan
->pixel_formats
== PIXEL_FRMT_411
)
736 chan
->fmt
= cx25821_format_by_fourcc(V4L2_PIX_FMT_Y41P
);
738 chan
->fmt
= cx25821_format_by_fourcc(V4L2_PIX_FMT_YUYV
);
740 cx_write(chan
->sram_channels
->int_stat
, 0xffffffff);
742 INIT_LIST_HEAD(&chan
->dma_vidq
.active
);
746 q
->type
= is_output
? V4L2_BUF_TYPE_VIDEO_OUTPUT
:
747 V4L2_BUF_TYPE_VIDEO_CAPTURE
;
748 q
->io_modes
= VB2_MMAP
| VB2_USERPTR
| VB2_DMABUF
;
749 q
->io_modes
|= is_output
? VB2_WRITE
: VB2_READ
;
750 q
->gfp_flags
= GFP_DMA32
;
751 q
->min_buffers_needed
= 2;
753 q
->buf_struct_size
= sizeof(struct cx25821_buffer
);
754 q
->ops
= &cx25821_video_qops
;
755 q
->mem_ops
= &vb2_dma_sg_memops
;
756 q
->timestamp_flags
= V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC
;
757 q
->lock
= &dev
->lock
;
760 err
= vb2_queue_init(q
);
765 /* register v4l devices */
766 *vdev
= is_output
? cx25821_video_out_device
: cx25821_video_device
;
767 vdev
->v4l2_dev
= &dev
->v4l2_dev
;
769 vdev
->ctrl_handler
= hdl
;
771 vdev
->vfl_dir
= VFL_DIR_TX
;
772 vdev
->lock
= &dev
->lock
;
774 snprintf(vdev
->name
, sizeof(vdev
->name
), "%s #%d", dev
->name
, i
);
775 video_set_drvdata(vdev
, chan
);
777 err
= video_register_device(vdev
, VFL_TYPE_GRABBER
,
784 /* set PCI interrupt */
785 cx_set(PCI_INT_MSK
, 0xff);
791 cx25821_video_unregister(dev
, i
--);