2 * cx18 ioctl system call
4 * Derived from ivtv-ioctl.c
6 * Copyright (C) 2007 Hans Verkuil <hverkuil@xs4all.nl>
7 * Copyright (C) 2008 Andy Walls <awalls@radix.net>
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
25 #include "cx18-driver.h"
27 #include "cx18-version.h"
28 #include "cx18-mailbox.h"
30 #include "cx18-queue.h"
31 #include "cx18-fileops.h"
33 #include "cx18-audio.h"
34 #include "cx18-video.h"
35 #include "cx18-streams.h"
36 #include "cx18-ioctl.h"
37 #include "cx18-gpio.h"
38 #include "cx18-controls.h"
39 #include "cx18-cards.h"
40 #include "cx18-av-core.h"
41 #include <media/tveeprom.h>
42 #include <media/v4l2-chip-ident.h>
43 #include <linux/i2c-id.h>
45 u16
cx18_service2vbi(int type
)
48 case V4L2_SLICED_TELETEXT_B
:
49 return CX18_SLICED_TYPE_TELETEXT_B
;
50 case V4L2_SLICED_CAPTION_525
:
51 return CX18_SLICED_TYPE_CAPTION_525
;
52 case V4L2_SLICED_WSS_625
:
53 return CX18_SLICED_TYPE_WSS_625
;
55 return CX18_SLICED_TYPE_VPS
;
61 /* Check if VBI services are allowed on the (field, line) for the video std */
62 static int valid_service_line(int field
, int line
, int is_pal
)
64 return (is_pal
&& line
>= 6 &&
65 ((field
== 0 && line
<= 23) || (field
== 1 && line
<= 22))) ||
66 (!is_pal
&& line
>= 10 && line
< 22);
70 * For a (field, line, std) and inbound potential set of services for that line,
71 * return the first valid service of those passed in the incoming set for that
72 * line in priority order:
73 * CC, VPS, or WSS over TELETEXT for well known lines
74 * TELETEXT, before VPS, before CC, before WSS, for other lines
76 static u16
select_service_from_set(int field
, int line
, u16 set
, int is_pal
)
78 u16 valid_set
= (is_pal
? V4L2_SLICED_VBI_625
: V4L2_SLICED_VBI_525
);
81 set
= set
& valid_set
;
82 if (set
== 0 || !valid_service_line(field
, line
, is_pal
))
85 if (line
== 21 && (set
& V4L2_SLICED_CAPTION_525
))
86 return V4L2_SLICED_CAPTION_525
;
88 if (line
== 16 && field
== 0 && (set
& V4L2_SLICED_VPS
))
89 return V4L2_SLICED_VPS
;
90 if (line
== 23 && field
== 0 && (set
& V4L2_SLICED_WSS_625
))
91 return V4L2_SLICED_WSS_625
;
95 for (i
= 0; i
< 32; i
++) {
103 * Expand the service_set of *fmt into valid service_lines for the std,
104 * and clear the passed in fmt->service_set
106 void cx18_expand_service_set(struct v4l2_sliced_vbi_format
*fmt
, int is_pal
)
108 u16 set
= fmt
->service_set
;
111 fmt
->service_set
= 0;
112 for (f
= 0; f
< 2; f
++) {
113 for (l
= 0; l
< 24; l
++)
114 fmt
->service_lines
[f
][l
] = select_service_from_set(f
, l
, set
, is_pal
);
119 * Sanitize the service_lines in *fmt per the video std, and return 1
120 * if any service_line is left as valid after santization
122 static int check_service_set(struct v4l2_sliced_vbi_format
*fmt
, int is_pal
)
127 for (f
= 0; f
< 2; f
++) {
128 for (l
= 0; l
< 24; l
++) {
129 fmt
->service_lines
[f
][l
] = select_service_from_set(f
, l
, fmt
->service_lines
[f
][l
], is_pal
);
130 set
|= fmt
->service_lines
[f
][l
];
136 /* Compute the service_set from the assumed valid service_lines of *fmt */
137 u16
cx18_get_service_set(struct v4l2_sliced_vbi_format
*fmt
)
142 for (f
= 0; f
< 2; f
++) {
143 for (l
= 0; l
< 24; l
++)
144 set
|= fmt
->service_lines
[f
][l
];
149 static int cx18_g_fmt_vid_cap(struct file
*file
, void *fh
,
150 struct v4l2_format
*fmt
)
152 struct cx18_open_id
*id
= fh
;
153 struct cx18
*cx
= id
->cx
;
154 struct v4l2_pix_format
*pixfmt
= &fmt
->fmt
.pix
;
156 pixfmt
->width
= cx
->params
.width
;
157 pixfmt
->height
= cx
->params
.height
;
158 pixfmt
->colorspace
= V4L2_COLORSPACE_SMPTE170M
;
159 pixfmt
->field
= V4L2_FIELD_INTERLACED
;
161 if (id
->type
== CX18_ENC_STREAM_TYPE_YUV
) {
162 pixfmt
->pixelformat
= V4L2_PIX_FMT_HM12
;
163 /* YUV size is (Y=(h*720) + UV=(h*(720/2))) */
164 pixfmt
->sizeimage
= pixfmt
->height
* 720 * 3 / 2;
165 pixfmt
->bytesperline
= 720;
167 pixfmt
->pixelformat
= V4L2_PIX_FMT_MPEG
;
168 pixfmt
->sizeimage
= 128 * 1024;
169 pixfmt
->bytesperline
= 0;
174 static int cx18_g_fmt_vbi_cap(struct file
*file
, void *fh
,
175 struct v4l2_format
*fmt
)
177 struct cx18
*cx
= ((struct cx18_open_id
*)fh
)->cx
;
178 struct v4l2_vbi_format
*vbifmt
= &fmt
->fmt
.vbi
;
180 vbifmt
->sampling_rate
= 27000000;
181 vbifmt
->offset
= 248; /* FIXME - slightly wrong for both 50 & 60 Hz */
182 vbifmt
->samples_per_line
= vbi_active_samples
- 4;
183 vbifmt
->sample_format
= V4L2_PIX_FMT_GREY
;
184 vbifmt
->start
[0] = cx
->vbi
.start
[0];
185 vbifmt
->start
[1] = cx
->vbi
.start
[1];
186 vbifmt
->count
[0] = vbifmt
->count
[1] = cx
->vbi
.count
;
188 vbifmt
->reserved
[0] = 0;
189 vbifmt
->reserved
[1] = 0;
193 static int cx18_g_fmt_sliced_vbi_cap(struct file
*file
, void *fh
,
194 struct v4l2_format
*fmt
)
196 struct cx18
*cx
= ((struct cx18_open_id
*)fh
)->cx
;
197 struct v4l2_sliced_vbi_format
*vbifmt
= &fmt
->fmt
.sliced
;
199 /* sane, V4L2 spec compliant, defaults */
200 vbifmt
->reserved
[0] = 0;
201 vbifmt
->reserved
[1] = 0;
202 vbifmt
->io_size
= sizeof(struct v4l2_sliced_vbi_data
) * 36;
203 memset(vbifmt
->service_lines
, 0, sizeof(vbifmt
->service_lines
));
204 vbifmt
->service_set
= 0;
207 * Fetch the configured service_lines and total service_set from the
208 * digitizer/slicer. Note, cx18_av_vbi() wipes the passed in
209 * fmt->fmt.sliced under valid calling conditions
211 if (v4l2_subdev_call(cx
->sd_av
, video
, g_fmt
, fmt
))
214 /* Ensure V4L2 spec compliant output */
215 vbifmt
->reserved
[0] = 0;
216 vbifmt
->reserved
[1] = 0;
217 vbifmt
->io_size
= sizeof(struct v4l2_sliced_vbi_data
) * 36;
218 vbifmt
->service_set
= cx18_get_service_set(vbifmt
);
222 static int cx18_try_fmt_vid_cap(struct file
*file
, void *fh
,
223 struct v4l2_format
*fmt
)
225 struct cx18_open_id
*id
= fh
;
226 struct cx18
*cx
= id
->cx
;
227 int w
= fmt
->fmt
.pix
.width
;
228 int h
= fmt
->fmt
.pix
.height
;
233 if (id
->type
== CX18_ENC_STREAM_TYPE_YUV
) {
234 /* YUV height must be a multiple of 32 */
238 h
= min(h
, cx
->is_50hz
? 576 : 480);
241 cx18_g_fmt_vid_cap(file
, fh
, fmt
);
242 fmt
->fmt
.pix
.width
= w
;
243 fmt
->fmt
.pix
.height
= h
;
247 static int cx18_try_fmt_vbi_cap(struct file
*file
, void *fh
,
248 struct v4l2_format
*fmt
)
250 return cx18_g_fmt_vbi_cap(file
, fh
, fmt
);
253 static int cx18_try_fmt_sliced_vbi_cap(struct file
*file
, void *fh
,
254 struct v4l2_format
*fmt
)
256 struct cx18
*cx
= ((struct cx18_open_id
*)fh
)->cx
;
257 struct v4l2_sliced_vbi_format
*vbifmt
= &fmt
->fmt
.sliced
;
259 vbifmt
->io_size
= sizeof(struct v4l2_sliced_vbi_data
) * 36;
260 vbifmt
->reserved
[0] = 0;
261 vbifmt
->reserved
[1] = 0;
263 /* If given a service set, expand it validly & clear passed in set */
264 if (vbifmt
->service_set
)
265 cx18_expand_service_set(vbifmt
, cx
->is_50hz
);
266 /* Sanitize the service_lines, and compute the new set if any valid */
267 if (check_service_set(vbifmt
, cx
->is_50hz
))
268 vbifmt
->service_set
= cx18_get_service_set(vbifmt
);
272 static int cx18_s_fmt_vid_cap(struct file
*file
, void *fh
,
273 struct v4l2_format
*fmt
)
275 struct cx18_open_id
*id
= fh
;
276 struct cx18
*cx
= id
->cx
;
280 ret
= v4l2_prio_check(&cx
->prio
, &id
->prio
);
284 ret
= cx18_try_fmt_vid_cap(file
, fh
, fmt
);
287 w
= fmt
->fmt
.pix
.width
;
288 h
= fmt
->fmt
.pix
.height
;
290 if (cx
->params
.width
== w
&& cx
->params
.height
== h
)
293 if (atomic_read(&cx
->ana_capturing
) > 0)
296 cx
->params
.width
= w
;
297 cx
->params
.height
= h
;
298 v4l2_subdev_call(cx
->sd_av
, video
, s_fmt
, fmt
);
299 return cx18_g_fmt_vid_cap(file
, fh
, fmt
);
302 static int cx18_s_fmt_vbi_cap(struct file
*file
, void *fh
,
303 struct v4l2_format
*fmt
)
305 struct cx18_open_id
*id
= fh
;
306 struct cx18
*cx
= id
->cx
;
309 ret
= v4l2_prio_check(&cx
->prio
, &id
->prio
);
314 * Changing the Encoder's Raw VBI parameters won't have any effect
315 * if any analog capture is ongoing
317 if (!cx18_raw_vbi(cx
) && atomic_read(&cx
->ana_capturing
) > 0)
321 * Set the digitizer registers for raw active VBI.
322 * Note cx18_av_vbi_wipes out alot of the passed in fmt under valid
325 ret
= v4l2_subdev_call(cx
->sd_av
, video
, s_fmt
, fmt
);
329 /* Store our new v4l2 (non-)sliced VBI state */
330 cx
->vbi
.sliced_in
->service_set
= 0;
331 cx
->vbi
.in
.type
= V4L2_BUF_TYPE_VBI_CAPTURE
;
333 return cx18_g_fmt_vbi_cap(file
, fh
, fmt
);
336 static int cx18_s_fmt_sliced_vbi_cap(struct file
*file
, void *fh
,
337 struct v4l2_format
*fmt
)
339 struct cx18_open_id
*id
= fh
;
340 struct cx18
*cx
= id
->cx
;
342 struct v4l2_sliced_vbi_format
*vbifmt
= &fmt
->fmt
.sliced
;
344 ret
= v4l2_prio_check(&cx
->prio
, &id
->prio
);
348 cx18_try_fmt_sliced_vbi_cap(file
, fh
, fmt
);
351 * Changing the Encoder's Raw VBI parameters won't have any effect
352 * if any analog capture is ongoing
354 if (cx18_raw_vbi(cx
) && atomic_read(&cx
->ana_capturing
) > 0)
358 * Set the service_lines requested in the digitizer/slicer registers.
359 * Note, cx18_av_vbi() wipes some "impossible" service lines in the
360 * passed in fmt->fmt.sliced under valid calling conditions
362 ret
= v4l2_subdev_call(cx
->sd_av
, video
, s_fmt
, fmt
);
365 /* Store our current v4l2 sliced VBI settings */
366 cx
->vbi
.in
.type
= V4L2_BUF_TYPE_SLICED_VBI_CAPTURE
;
367 memcpy(cx
->vbi
.sliced_in
, vbifmt
, sizeof(*cx
->vbi
.sliced_in
));
371 static int cx18_g_chip_ident(struct file
*file
, void *fh
,
372 struct v4l2_dbg_chip_ident
*chip
)
374 struct cx18
*cx
= ((struct cx18_open_id
*)fh
)->cx
;
377 chip
->ident
= V4L2_IDENT_NONE
;
379 switch (chip
->match
.type
) {
380 case V4L2_CHIP_MATCH_HOST
:
381 switch (chip
->match
.addr
) {
383 chip
->ident
= V4L2_IDENT_CX23418
;
384 chip
->revision
= cx18_read_reg(cx
, 0xC72028);
388 * The A/V decoder is always present, but in the rare
389 * case that the card doesn't have analog, we don't
390 * use it. We find it w/o using the cx->sd_av pointer
392 cx18_call_hw(cx
, CX18_HW_418_AV
,
393 core
, g_chip_ident
, chip
);
397 * Could return ident = V4L2_IDENT_UNKNOWN if we had
398 * other host chips at higher addresses, but we don't
400 err
= -EINVAL
; /* per V4L2 spec */
404 case V4L2_CHIP_MATCH_I2C_DRIVER
:
405 /* If needed, returns V4L2_IDENT_AMBIGUOUS without extra work */
406 cx18_call_all(cx
, core
, g_chip_ident
, chip
);
408 case V4L2_CHIP_MATCH_I2C_ADDR
:
410 * We could return V4L2_IDENT_UNKNOWN, but we don't do the work
411 * to look if a chip is at the address with no driver. That's a
412 * dangerous thing to do with EEPROMs anyway.
414 cx18_call_all(cx
, core
, g_chip_ident
, chip
);
423 #ifdef CONFIG_VIDEO_ADV_DEBUG
424 static int cx18_cxc(struct cx18
*cx
, unsigned int cmd
, void *arg
)
426 struct v4l2_dbg_register
*regs
= arg
;
428 if (!capable(CAP_SYS_ADMIN
))
430 if (regs
->reg
>= CX18_MEM_OFFSET
+ CX18_MEM_SIZE
)
434 if (cmd
== VIDIOC_DBG_S_REGISTER
)
435 cx18_write_enc(cx
, regs
->val
, regs
->reg
);
437 regs
->val
= cx18_read_enc(cx
, regs
->reg
);
441 static int cx18_g_register(struct file
*file
, void *fh
,
442 struct v4l2_dbg_register
*reg
)
444 struct cx18
*cx
= ((struct cx18_open_id
*)fh
)->cx
;
446 if (v4l2_chip_match_host(®
->match
))
447 return cx18_cxc(cx
, VIDIOC_DBG_G_REGISTER
, reg
);
448 /* FIXME - errors shouldn't be ignored */
449 cx18_call_all(cx
, core
, g_register
, reg
);
453 static int cx18_s_register(struct file
*file
, void *fh
,
454 struct v4l2_dbg_register
*reg
)
456 struct cx18
*cx
= ((struct cx18_open_id
*)fh
)->cx
;
458 if (v4l2_chip_match_host(®
->match
))
459 return cx18_cxc(cx
, VIDIOC_DBG_S_REGISTER
, reg
);
460 /* FIXME - errors shouldn't be ignored */
461 cx18_call_all(cx
, core
, s_register
, reg
);
466 static int cx18_g_priority(struct file
*file
, void *fh
, enum v4l2_priority
*p
)
468 struct cx18
*cx
= ((struct cx18_open_id
*)fh
)->cx
;
470 *p
= v4l2_prio_max(&cx
->prio
);
474 static int cx18_s_priority(struct file
*file
, void *fh
, enum v4l2_priority prio
)
476 struct cx18_open_id
*id
= fh
;
477 struct cx18
*cx
= id
->cx
;
479 return v4l2_prio_change(&cx
->prio
, &id
->prio
, prio
);
482 static int cx18_querycap(struct file
*file
, void *fh
,
483 struct v4l2_capability
*vcap
)
485 struct cx18
*cx
= ((struct cx18_open_id
*)fh
)->cx
;
487 strlcpy(vcap
->driver
, CX18_DRIVER_NAME
, sizeof(vcap
->driver
));
488 strlcpy(vcap
->card
, cx
->card_name
, sizeof(vcap
->card
));
489 snprintf(vcap
->bus_info
, sizeof(vcap
->bus_info
),
490 "PCI:%s", pci_name(cx
->pci_dev
));
491 vcap
->version
= CX18_DRIVER_VERSION
; /* version */
492 vcap
->capabilities
= cx
->v4l2_cap
; /* capabilities */
496 static int cx18_enumaudio(struct file
*file
, void *fh
, struct v4l2_audio
*vin
)
498 struct cx18
*cx
= ((struct cx18_open_id
*)fh
)->cx
;
500 return cx18_get_audio_input(cx
, vin
->index
, vin
);
503 static int cx18_g_audio(struct file
*file
, void *fh
, struct v4l2_audio
*vin
)
505 struct cx18
*cx
= ((struct cx18_open_id
*)fh
)->cx
;
507 vin
->index
= cx
->audio_input
;
508 return cx18_get_audio_input(cx
, vin
->index
, vin
);
511 static int cx18_s_audio(struct file
*file
, void *fh
, struct v4l2_audio
*vout
)
513 struct cx18
*cx
= ((struct cx18_open_id
*)fh
)->cx
;
515 if (vout
->index
>= cx
->nof_audio_inputs
)
517 cx
->audio_input
= vout
->index
;
518 cx18_audio_set_io(cx
);
522 static int cx18_enum_input(struct file
*file
, void *fh
, struct v4l2_input
*vin
)
524 struct cx18
*cx
= ((struct cx18_open_id
*)fh
)->cx
;
526 /* set it to defaults from our table */
527 return cx18_get_input(cx
, vin
->index
, vin
);
530 static int cx18_cropcap(struct file
*file
, void *fh
,
531 struct v4l2_cropcap
*cropcap
)
533 struct cx18
*cx
= ((struct cx18_open_id
*)fh
)->cx
;
535 if (cropcap
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
537 cropcap
->bounds
.top
= cropcap
->bounds
.left
= 0;
538 cropcap
->bounds
.width
= 720;
539 cropcap
->bounds
.height
= cx
->is_50hz
? 576 : 480;
540 cropcap
->pixelaspect
.numerator
= cx
->is_50hz
? 59 : 10;
541 cropcap
->pixelaspect
.denominator
= cx
->is_50hz
? 54 : 11;
542 cropcap
->defrect
= cropcap
->bounds
;
546 static int cx18_s_crop(struct file
*file
, void *fh
, struct v4l2_crop
*crop
)
548 struct cx18_open_id
*id
= fh
;
549 struct cx18
*cx
= id
->cx
;
552 ret
= v4l2_prio_check(&cx
->prio
, &id
->prio
);
556 if (crop
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
558 CX18_DEBUG_WARN("VIDIOC_S_CROP not implemented\n");
562 static int cx18_g_crop(struct file
*file
, void *fh
, struct v4l2_crop
*crop
)
564 struct cx18
*cx
= ((struct cx18_open_id
*)fh
)->cx
;
566 if (crop
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
568 CX18_DEBUG_WARN("VIDIOC_G_CROP not implemented\n");
572 static int cx18_enum_fmt_vid_cap(struct file
*file
, void *fh
,
573 struct v4l2_fmtdesc
*fmt
)
575 static struct v4l2_fmtdesc formats
[] = {
576 { 0, V4L2_BUF_TYPE_VIDEO_CAPTURE
, 0,
577 "HM12 (YUV 4:1:1)", V4L2_PIX_FMT_HM12
, { 0, 0, 0, 0 }
579 { 1, V4L2_BUF_TYPE_VIDEO_CAPTURE
, V4L2_FMT_FLAG_COMPRESSED
,
580 "MPEG", V4L2_PIX_FMT_MPEG
, { 0, 0, 0, 0 }
586 *fmt
= formats
[fmt
->index
];
590 static int cx18_g_input(struct file
*file
, void *fh
, unsigned int *i
)
592 struct cx18
*cx
= ((struct cx18_open_id
*)fh
)->cx
;
594 *i
= cx
->active_input
;
598 int cx18_s_input(struct file
*file
, void *fh
, unsigned int inp
)
600 struct cx18_open_id
*id
= fh
;
601 struct cx18
*cx
= id
->cx
;
604 ret
= v4l2_prio_check(&cx
->prio
, &id
->prio
);
608 if (inp
>= cx
->nof_inputs
)
611 if (inp
== cx
->active_input
) {
612 CX18_DEBUG_INFO("Input unchanged\n");
616 CX18_DEBUG_INFO("Changing input from %d to %d\n",
617 cx
->active_input
, inp
);
619 cx
->active_input
= inp
;
620 /* Set the audio input to whatever is appropriate for the input type. */
621 cx
->audio_input
= cx
->card
->video_inputs
[inp
].audio_index
;
623 /* prevent others from messing with the streams until
624 we're finished changing inputs. */
626 cx18_video_set_io(cx
);
627 cx18_audio_set_io(cx
);
632 static int cx18_g_frequency(struct file
*file
, void *fh
,
633 struct v4l2_frequency
*vf
)
635 struct cx18
*cx
= ((struct cx18_open_id
*)fh
)->cx
;
640 cx18_call_all(cx
, tuner
, g_frequency
, vf
);
644 int cx18_s_frequency(struct file
*file
, void *fh
, struct v4l2_frequency
*vf
)
646 struct cx18_open_id
*id
= fh
;
647 struct cx18
*cx
= id
->cx
;
650 ret
= v4l2_prio_check(&cx
->prio
, &id
->prio
);
658 CX18_DEBUG_INFO("v4l2 ioctl: set frequency %d\n", vf
->frequency
);
659 cx18_call_all(cx
, tuner
, s_frequency
, vf
);
664 static int cx18_g_std(struct file
*file
, void *fh
, v4l2_std_id
*std
)
666 struct cx18
*cx
= ((struct cx18_open_id
*)fh
)->cx
;
672 int cx18_s_std(struct file
*file
, void *fh
, v4l2_std_id
*std
)
674 struct cx18_open_id
*id
= fh
;
675 struct cx18
*cx
= id
->cx
;
678 ret
= v4l2_prio_check(&cx
->prio
, &id
->prio
);
682 if ((*std
& V4L2_STD_ALL
) == 0)
688 if (test_bit(CX18_F_I_RADIO_USER
, &cx
->i_flags
) ||
689 atomic_read(&cx
->ana_capturing
) > 0) {
690 /* Switching standard would turn off the radio or mess
691 with already running streams, prevent that by
697 cx
->is_60hz
= (*std
& V4L2_STD_525_60
) ? 1 : 0;
698 cx
->params
.is_50hz
= cx
->is_50hz
= !cx
->is_60hz
;
699 cx
->params
.width
= 720;
700 cx
->params
.height
= cx
->is_50hz
? 576 : 480;
701 cx
->vbi
.count
= cx
->is_50hz
? 18 : 12;
702 cx
->vbi
.start
[0] = cx
->is_50hz
? 6 : 10;
703 cx
->vbi
.start
[1] = cx
->is_50hz
? 318 : 273;
704 CX18_DEBUG_INFO("Switching standard to %llx.\n",
705 (unsigned long long) cx
->std
);
708 cx18_call_all(cx
, core
, s_std
, cx
->std
);
712 static int cx18_s_tuner(struct file
*file
, void *fh
, struct v4l2_tuner
*vt
)
714 struct cx18_open_id
*id
= fh
;
715 struct cx18
*cx
= id
->cx
;
718 ret
= v4l2_prio_check(&cx
->prio
, &id
->prio
);
725 cx18_call_all(cx
, tuner
, s_tuner
, vt
);
729 static int cx18_g_tuner(struct file
*file
, void *fh
, struct v4l2_tuner
*vt
)
731 struct cx18
*cx
= ((struct cx18_open_id
*)fh
)->cx
;
736 cx18_call_all(cx
, tuner
, g_tuner
, vt
);
738 if (test_bit(CX18_F_I_RADIO_USER
, &cx
->i_flags
)) {
739 strlcpy(vt
->name
, "cx18 Radio Tuner", sizeof(vt
->name
));
740 vt
->type
= V4L2_TUNER_RADIO
;
742 strlcpy(vt
->name
, "cx18 TV Tuner", sizeof(vt
->name
));
743 vt
->type
= V4L2_TUNER_ANALOG_TV
;
749 static int cx18_g_sliced_vbi_cap(struct file
*file
, void *fh
,
750 struct v4l2_sliced_vbi_cap
*cap
)
752 struct cx18
*cx
= ((struct cx18_open_id
*)fh
)->cx
;
753 int set
= cx
->is_50hz
? V4L2_SLICED_VBI_625
: V4L2_SLICED_VBI_525
;
756 if (cap
->type
!= V4L2_BUF_TYPE_SLICED_VBI_CAPTURE
)
759 cap
->service_set
= 0;
760 for (f
= 0; f
< 2; f
++) {
761 for (l
= 0; l
< 24; l
++) {
762 if (valid_service_line(f
, l
, cx
->is_50hz
)) {
764 * We can find all v4l2 supported vbi services
765 * for the standard, on a valid line for the std
767 cap
->service_lines
[f
][l
] = set
;
768 cap
->service_set
|= set
;
770 cap
->service_lines
[f
][l
] = 0;
773 for (f
= 0; f
< 3; f
++)
774 cap
->reserved
[f
] = 0;
778 static int cx18_g_enc_index(struct file
*file
, void *fh
,
779 struct v4l2_enc_idx
*idx
)
784 static int cx18_encoder_cmd(struct file
*file
, void *fh
,
785 struct v4l2_encoder_cmd
*enc
)
787 struct cx18_open_id
*id
= fh
;
788 struct cx18
*cx
= id
->cx
;
792 case V4L2_ENC_CMD_START
:
793 CX18_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
795 return cx18_start_capture(id
);
797 case V4L2_ENC_CMD_STOP
:
798 CX18_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
799 enc
->flags
&= V4L2_ENC_CMD_STOP_AT_GOP_END
;
800 cx18_stop_capture(id
,
801 enc
->flags
& V4L2_ENC_CMD_STOP_AT_GOP_END
);
804 case V4L2_ENC_CMD_PAUSE
:
805 CX18_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
807 if (!atomic_read(&cx
->ana_capturing
))
809 if (test_and_set_bit(CX18_F_I_ENC_PAUSED
, &cx
->i_flags
))
811 h
= cx18_find_handle(cx
);
812 if (h
== CX18_INVALID_TASK_HANDLE
) {
813 CX18_ERR("Can't find valid task handle for "
814 "V4L2_ENC_CMD_PAUSE\n");
818 cx18_vapi(cx
, CX18_CPU_CAPTURE_PAUSE
, 1, h
);
821 case V4L2_ENC_CMD_RESUME
:
822 CX18_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
824 if (!atomic_read(&cx
->ana_capturing
))
826 if (!test_and_clear_bit(CX18_F_I_ENC_PAUSED
, &cx
->i_flags
))
828 h
= cx18_find_handle(cx
);
829 if (h
== CX18_INVALID_TASK_HANDLE
) {
830 CX18_ERR("Can't find valid task handle for "
831 "V4L2_ENC_CMD_RESUME\n");
834 cx18_vapi(cx
, CX18_CPU_CAPTURE_RESUME
, 1, h
);
839 CX18_DEBUG_IOCTL("Unknown cmd %d\n", enc
->cmd
);
845 static int cx18_try_encoder_cmd(struct file
*file
, void *fh
,
846 struct v4l2_encoder_cmd
*enc
)
848 struct cx18
*cx
= ((struct cx18_open_id
*)fh
)->cx
;
851 case V4L2_ENC_CMD_START
:
852 CX18_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
856 case V4L2_ENC_CMD_STOP
:
857 CX18_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
858 enc
->flags
&= V4L2_ENC_CMD_STOP_AT_GOP_END
;
861 case V4L2_ENC_CMD_PAUSE
:
862 CX18_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
866 case V4L2_ENC_CMD_RESUME
:
867 CX18_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
872 CX18_DEBUG_IOCTL("Unknown cmd %d\n", enc
->cmd
);
878 static int cx18_log_status(struct file
*file
, void *fh
)
880 struct cx18
*cx
= ((struct cx18_open_id
*)fh
)->cx
;
881 struct v4l2_input vidin
;
882 struct v4l2_audio audin
;
885 CX18_INFO("================= START STATUS CARD #%d "
886 "=================\n", cx
->instance
);
887 CX18_INFO("Version: %s Card: %s\n", CX18_VERSION
, cx
->card_name
);
888 if (cx
->hw_flags
& CX18_HW_TVEEPROM
) {
891 cx18_read_eeprom(cx
, &tv
);
893 cx18_call_all(cx
, core
, log_status
);
894 cx18_get_input(cx
, cx
->active_input
, &vidin
);
895 cx18_get_audio_input(cx
, cx
->audio_input
, &audin
);
896 CX18_INFO("Video Input: %s\n", vidin
.name
);
897 CX18_INFO("Audio Input: %s\n", audin
.name
);
898 mutex_lock(&cx
->gpio_lock
);
899 CX18_INFO("GPIO: direction 0x%08x, value 0x%08x\n",
900 cx
->gpio_dir
, cx
->gpio_val
);
901 mutex_unlock(&cx
->gpio_lock
);
902 CX18_INFO("Tuner: %s\n",
903 test_bit(CX18_F_I_RADIO_USER
, &cx
->i_flags
) ? "Radio" : "TV");
904 cx2341x_log_status(&cx
->params
, cx
->v4l2_dev
.name
);
905 CX18_INFO("Status flags: 0x%08lx\n", cx
->i_flags
);
906 for (i
= 0; i
< CX18_MAX_STREAMS
; i
++) {
907 struct cx18_stream
*s
= &cx
->streams
[i
];
909 if (s
->video_dev
== NULL
|| s
->buffers
== 0)
911 CX18_INFO("Stream %s: status 0x%04lx, %d%% of %d KiB (%d buffers) in use\n",
913 atomic_read(&s
->q_full
.buffers
) * 100 / s
->buffers
,
914 (s
->buffers
* s
->buf_size
) / 1024, s
->buffers
);
916 CX18_INFO("Read MPEG/VBI: %lld/%lld bytes\n",
917 (long long)cx
->mpg_data_received
,
918 (long long)cx
->vbi_data_inserted
);
919 CX18_INFO("================== END STATUS CARD #%d "
920 "==================\n", cx
->instance
);
924 static long cx18_default(struct file
*file
, void *fh
, int cmd
, void *arg
)
926 struct cx18
*cx
= ((struct cx18_open_id
*)fh
)->cx
;
929 case VIDIOC_INT_RESET
: {
930 u32 val
= *(u32
*)arg
;
932 if ((val
== 0) || (val
& 0x01))
933 cx18_call_hw(cx
, CX18_HW_GPIO_RESET_CTRL
, core
, reset
,
934 (u32
) CX18_GPIO_RESET_Z8F0811
);
944 long cx18_v4l2_ioctl(struct file
*filp
, unsigned int cmd
,
947 struct video_device
*vfd
= video_devdata(filp
);
948 struct cx18_open_id
*id
= (struct cx18_open_id
*)filp
->private_data
;
949 struct cx18
*cx
= id
->cx
;
952 mutex_lock(&cx
->serialize_lock
);
954 /* FIXME - consolidate v4l2_prio_check()'s here */
956 if (cx18_debug
& CX18_DBGFLG_IOCTL
)
957 vfd
->debug
= V4L2_DEBUG_IOCTL
| V4L2_DEBUG_IOCTL_ARG
;
958 res
= video_ioctl2(filp
, cmd
, arg
);
960 mutex_unlock(&cx
->serialize_lock
);
964 static const struct v4l2_ioctl_ops cx18_ioctl_ops
= {
965 .vidioc_querycap
= cx18_querycap
,
966 .vidioc_g_priority
= cx18_g_priority
,
967 .vidioc_s_priority
= cx18_s_priority
,
968 .vidioc_s_audio
= cx18_s_audio
,
969 .vidioc_g_audio
= cx18_g_audio
,
970 .vidioc_enumaudio
= cx18_enumaudio
,
971 .vidioc_enum_input
= cx18_enum_input
,
972 .vidioc_cropcap
= cx18_cropcap
,
973 .vidioc_s_crop
= cx18_s_crop
,
974 .vidioc_g_crop
= cx18_g_crop
,
975 .vidioc_g_input
= cx18_g_input
,
976 .vidioc_s_input
= cx18_s_input
,
977 .vidioc_g_frequency
= cx18_g_frequency
,
978 .vidioc_s_frequency
= cx18_s_frequency
,
979 .vidioc_s_tuner
= cx18_s_tuner
,
980 .vidioc_g_tuner
= cx18_g_tuner
,
981 .vidioc_g_enc_index
= cx18_g_enc_index
,
982 .vidioc_g_std
= cx18_g_std
,
983 .vidioc_s_std
= cx18_s_std
,
984 .vidioc_log_status
= cx18_log_status
,
985 .vidioc_enum_fmt_vid_cap
= cx18_enum_fmt_vid_cap
,
986 .vidioc_encoder_cmd
= cx18_encoder_cmd
,
987 .vidioc_try_encoder_cmd
= cx18_try_encoder_cmd
,
988 .vidioc_g_fmt_vid_cap
= cx18_g_fmt_vid_cap
,
989 .vidioc_g_fmt_vbi_cap
= cx18_g_fmt_vbi_cap
,
990 .vidioc_g_fmt_sliced_vbi_cap
= cx18_g_fmt_sliced_vbi_cap
,
991 .vidioc_s_fmt_vid_cap
= cx18_s_fmt_vid_cap
,
992 .vidioc_s_fmt_vbi_cap
= cx18_s_fmt_vbi_cap
,
993 .vidioc_s_fmt_sliced_vbi_cap
= cx18_s_fmt_sliced_vbi_cap
,
994 .vidioc_try_fmt_vid_cap
= cx18_try_fmt_vid_cap
,
995 .vidioc_try_fmt_vbi_cap
= cx18_try_fmt_vbi_cap
,
996 .vidioc_try_fmt_sliced_vbi_cap
= cx18_try_fmt_sliced_vbi_cap
,
997 .vidioc_g_sliced_vbi_cap
= cx18_g_sliced_vbi_cap
,
998 .vidioc_g_chip_ident
= cx18_g_chip_ident
,
999 #ifdef CONFIG_VIDEO_ADV_DEBUG
1000 .vidioc_g_register
= cx18_g_register
,
1001 .vidioc_s_register
= cx18_s_register
,
1003 .vidioc_default
= cx18_default
,
1004 .vidioc_queryctrl
= cx18_queryctrl
,
1005 .vidioc_querymenu
= cx18_querymenu
,
1006 .vidioc_g_ext_ctrls
= cx18_g_ext_ctrls
,
1007 .vidioc_s_ext_ctrls
= cx18_s_ext_ctrls
,
1008 .vidioc_try_ext_ctrls
= cx18_try_ext_ctrls
,
1011 void cx18_set_funcs(struct video_device
*vdev
)
1013 vdev
->ioctl_ops
= &cx18_ioctl_ops
;