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 static int valid_service_line(int field
, int line
, int is_pal
)
63 return (is_pal
&& line
>= 6 && (line
!= 23 || field
== 0)) ||
64 (!is_pal
&& line
>= 10 && line
< 22);
67 static u16
select_service_from_set(int field
, int line
, u16 set
, int is_pal
)
69 u16 valid_set
= (is_pal
? V4L2_SLICED_VBI_625
: V4L2_SLICED_VBI_525
);
72 set
= set
& valid_set
;
73 if (set
== 0 || !valid_service_line(field
, line
, is_pal
))
76 if (line
== 21 && (set
& V4L2_SLICED_CAPTION_525
))
77 return V4L2_SLICED_CAPTION_525
;
79 if (line
== 16 && field
== 0 && (set
& V4L2_SLICED_VPS
))
80 return V4L2_SLICED_VPS
;
81 if (line
== 23 && field
== 0 && (set
& V4L2_SLICED_WSS_625
))
82 return V4L2_SLICED_WSS_625
;
86 for (i
= 0; i
< 32; i
++) {
93 void cx18_expand_service_set(struct v4l2_sliced_vbi_format
*fmt
, int is_pal
)
95 u16 set
= fmt
->service_set
;
99 for (f
= 0; f
< 2; f
++) {
100 for (l
= 0; l
< 24; l
++)
101 fmt
->service_lines
[f
][l
] = select_service_from_set(f
, l
, set
, is_pal
);
106 u16
cx18_get_service_set(struct v4l2_sliced_vbi_format
*fmt
)
111 for (f
= 0; f
< 2; f
++) {
112 for (l
= 0; l
< 24; l
++)
113 set
|= fmt
->service_lines
[f
][l
];
118 static int cx18_g_fmt_vid_cap(struct file
*file
, void *fh
,
119 struct v4l2_format
*fmt
)
121 struct cx18_open_id
*id
= fh
;
122 struct cx18
*cx
= id
->cx
;
123 struct v4l2_pix_format
*pixfmt
= &fmt
->fmt
.pix
;
125 pixfmt
->width
= cx
->params
.width
;
126 pixfmt
->height
= cx
->params
.height
;
127 pixfmt
->colorspace
= V4L2_COLORSPACE_SMPTE170M
;
128 pixfmt
->field
= V4L2_FIELD_INTERLACED
;
130 if (id
->type
== CX18_ENC_STREAM_TYPE_YUV
) {
131 pixfmt
->pixelformat
= V4L2_PIX_FMT_HM12
;
132 /* YUV size is (Y=(h*w) + UV=(h*(w/2))) */
134 pixfmt
->height
* pixfmt
->width
+
135 pixfmt
->height
* (pixfmt
->width
/ 2);
136 pixfmt
->bytesperline
= 720;
138 pixfmt
->pixelformat
= V4L2_PIX_FMT_MPEG
;
139 pixfmt
->sizeimage
= 128 * 1024;
140 pixfmt
->bytesperline
= 0;
145 static int cx18_g_fmt_vbi_cap(struct file
*file
, void *fh
,
146 struct v4l2_format
*fmt
)
148 struct cx18
*cx
= ((struct cx18_open_id
*)fh
)->cx
;
149 struct v4l2_vbi_format
*vbifmt
= &fmt
->fmt
.vbi
;
151 vbifmt
->sampling_rate
= 27000000;
152 vbifmt
->offset
= 248;
153 vbifmt
->samples_per_line
= cx
->vbi
.raw_decoder_line_size
- 4;
154 vbifmt
->sample_format
= V4L2_PIX_FMT_GREY
;
155 vbifmt
->start
[0] = cx
->vbi
.start
[0];
156 vbifmt
->start
[1] = cx
->vbi
.start
[1];
157 vbifmt
->count
[0] = vbifmt
->count
[1] = cx
->vbi
.count
;
159 vbifmt
->reserved
[0] = 0;
160 vbifmt
->reserved
[1] = 0;
164 static int cx18_g_fmt_sliced_vbi_cap(struct file
*file
, void *fh
,
165 struct v4l2_format
*fmt
)
170 static int cx18_try_fmt_vid_cap(struct file
*file
, void *fh
,
171 struct v4l2_format
*fmt
)
173 struct cx18_open_id
*id
= fh
;
174 struct cx18
*cx
= id
->cx
;
175 int w
= fmt
->fmt
.pix
.width
;
176 int h
= fmt
->fmt
.pix
.height
;
180 h
= min(h
, cx
->is_50hz
? 576 : 480);
182 cx18_g_fmt_vid_cap(file
, fh
, fmt
);
183 fmt
->fmt
.pix
.width
= w
;
184 fmt
->fmt
.pix
.height
= h
;
188 static int cx18_try_fmt_vbi_cap(struct file
*file
, void *fh
,
189 struct v4l2_format
*fmt
)
191 return cx18_g_fmt_vbi_cap(file
, fh
, fmt
);
194 static int cx18_try_fmt_sliced_vbi_cap(struct file
*file
, void *fh
,
195 struct v4l2_format
*fmt
)
200 static int cx18_s_fmt_vid_cap(struct file
*file
, void *fh
,
201 struct v4l2_format
*fmt
)
203 struct cx18_open_id
*id
= fh
;
204 struct cx18
*cx
= id
->cx
;
208 ret
= v4l2_prio_check(&cx
->prio
, &id
->prio
);
212 ret
= cx18_try_fmt_vid_cap(file
, fh
, fmt
);
215 w
= fmt
->fmt
.pix
.width
;
216 h
= fmt
->fmt
.pix
.height
;
218 if (cx
->params
.width
== w
&& cx
->params
.height
== h
)
221 if (atomic_read(&cx
->ana_capturing
) > 0)
224 cx
->params
.width
= w
;
225 cx
->params
.height
= h
;
226 cx18_av_cmd(cx
, VIDIOC_S_FMT
, fmt
);
227 return cx18_g_fmt_vid_cap(file
, fh
, fmt
);
230 static int cx18_s_fmt_vbi_cap(struct file
*file
, void *fh
,
231 struct v4l2_format
*fmt
)
233 struct cx18_open_id
*id
= fh
;
234 struct cx18
*cx
= id
->cx
;
237 ret
= v4l2_prio_check(&cx
->prio
, &id
->prio
);
241 if (!cx18_raw_vbi(cx
) && atomic_read(&cx
->ana_capturing
) > 0)
244 cx
->vbi
.sliced_in
->service_set
= 0;
245 cx
->vbi
.in
.type
= V4L2_BUF_TYPE_VBI_CAPTURE
;
246 cx18_av_cmd(cx
, VIDIOC_S_FMT
, fmt
);
247 return cx18_g_fmt_vbi_cap(file
, fh
, fmt
);
250 static int cx18_s_fmt_sliced_vbi_cap(struct file
*file
, void *fh
,
251 struct v4l2_format
*fmt
)
256 static int cx18_g_chip_ident(struct file
*file
, void *fh
,
257 struct v4l2_chip_ident
*chip
)
259 struct cx18
*cx
= ((struct cx18_open_id
*)fh
)->cx
;
261 chip
->ident
= V4L2_IDENT_NONE
;
263 if (chip
->match_type
== V4L2_CHIP_MATCH_HOST
) {
264 if (v4l2_chip_match_host(chip
->match_type
, chip
->match_chip
))
265 chip
->ident
= V4L2_IDENT_CX23418
;
268 if (chip
->match_type
== V4L2_CHIP_MATCH_I2C_DRIVER
)
269 return cx18_i2c_id(cx
, chip
->match_chip
, VIDIOC_G_CHIP_IDENT
,
271 if (chip
->match_type
== V4L2_CHIP_MATCH_I2C_ADDR
)
272 return cx18_call_i2c_client(cx
, chip
->match_chip
,
273 VIDIOC_G_CHIP_IDENT
, chip
);
277 #ifdef CONFIG_VIDEO_ADV_DEBUG
278 static int cx18_cxc(struct cx18
*cx
, unsigned int cmd
, void *arg
)
280 struct v4l2_register
*regs
= arg
;
283 if (!capable(CAP_SYS_ADMIN
))
285 if (regs
->reg
>= CX18_MEM_OFFSET
+ CX18_MEM_SIZE
)
288 spin_lock_irqsave(&cx18_cards_lock
, flags
);
289 if (cmd
== VIDIOC_DBG_G_REGISTER
)
290 regs
->val
= cx18_read_enc(cx
, regs
->reg
);
292 cx18_write_enc(cx
, regs
->val
, regs
->reg
);
293 spin_unlock_irqrestore(&cx18_cards_lock
, flags
);
297 static int cx18_g_register(struct file
*file
, void *fh
,
298 struct v4l2_register
*reg
)
300 struct cx18
*cx
= ((struct cx18_open_id
*)fh
)->cx
;
302 if (v4l2_chip_match_host(reg
->match_type
, reg
->match_chip
))
303 return cx18_cxc(cx
, VIDIOC_DBG_G_REGISTER
, reg
);
304 if (reg
->match_type
== V4L2_CHIP_MATCH_I2C_DRIVER
)
305 return cx18_i2c_id(cx
, reg
->match_chip
, VIDIOC_DBG_G_REGISTER
,
307 return cx18_call_i2c_client(cx
, reg
->match_chip
, VIDIOC_DBG_G_REGISTER
,
311 static int cx18_s_register(struct file
*file
, void *fh
,
312 struct v4l2_register
*reg
)
314 struct cx18
*cx
= ((struct cx18_open_id
*)fh
)->cx
;
316 if (v4l2_chip_match_host(reg
->match_type
, reg
->match_chip
))
317 return cx18_cxc(cx
, VIDIOC_DBG_S_REGISTER
, reg
);
318 if (reg
->match_type
== V4L2_CHIP_MATCH_I2C_DRIVER
)
319 return cx18_i2c_id(cx
, reg
->match_chip
, VIDIOC_DBG_S_REGISTER
,
321 return cx18_call_i2c_client(cx
, reg
->match_chip
, VIDIOC_DBG_S_REGISTER
,
326 static int cx18_g_priority(struct file
*file
, void *fh
, enum v4l2_priority
*p
)
328 struct cx18
*cx
= ((struct cx18_open_id
*)fh
)->cx
;
330 *p
= v4l2_prio_max(&cx
->prio
);
334 static int cx18_s_priority(struct file
*file
, void *fh
, enum v4l2_priority prio
)
336 struct cx18_open_id
*id
= fh
;
337 struct cx18
*cx
= id
->cx
;
339 return v4l2_prio_change(&cx
->prio
, &id
->prio
, prio
);
342 static int cx18_querycap(struct file
*file
, void *fh
,
343 struct v4l2_capability
*vcap
)
345 struct cx18
*cx
= ((struct cx18_open_id
*)fh
)->cx
;
347 strlcpy(vcap
->driver
, CX18_DRIVER_NAME
, sizeof(vcap
->driver
));
348 strlcpy(vcap
->card
, cx
->card_name
, sizeof(vcap
->card
));
349 snprintf(vcap
->bus_info
, sizeof(vcap
->bus_info
), "PCI:%s", pci_name(cx
->dev
));
350 vcap
->version
= CX18_DRIVER_VERSION
; /* version */
351 vcap
->capabilities
= cx
->v4l2_cap
; /* capabilities */
355 static int cx18_enumaudio(struct file
*file
, void *fh
, struct v4l2_audio
*vin
)
357 struct cx18
*cx
= ((struct cx18_open_id
*)fh
)->cx
;
359 return cx18_get_audio_input(cx
, vin
->index
, vin
);
362 static int cx18_g_audio(struct file
*file
, void *fh
, struct v4l2_audio
*vin
)
364 struct cx18
*cx
= ((struct cx18_open_id
*)fh
)->cx
;
366 vin
->index
= cx
->audio_input
;
367 return cx18_get_audio_input(cx
, vin
->index
, vin
);
370 static int cx18_s_audio(struct file
*file
, void *fh
, struct v4l2_audio
*vout
)
372 struct cx18
*cx
= ((struct cx18_open_id
*)fh
)->cx
;
374 if (vout
->index
>= cx
->nof_audio_inputs
)
376 cx
->audio_input
= vout
->index
;
377 cx18_audio_set_io(cx
);
381 static int cx18_enum_input(struct file
*file
, void *fh
, struct v4l2_input
*vin
)
383 struct cx18
*cx
= ((struct cx18_open_id
*)fh
)->cx
;
385 /* set it to defaults from our table */
386 return cx18_get_input(cx
, vin
->index
, vin
);
389 static int cx18_cropcap(struct file
*file
, void *fh
,
390 struct v4l2_cropcap
*cropcap
)
392 struct cx18
*cx
= ((struct cx18_open_id
*)fh
)->cx
;
394 if (cropcap
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
396 cropcap
->bounds
.top
= cropcap
->bounds
.left
= 0;
397 cropcap
->bounds
.width
= 720;
398 cropcap
->bounds
.height
= cx
->is_50hz
? 576 : 480;
399 cropcap
->pixelaspect
.numerator
= cx
->is_50hz
? 59 : 10;
400 cropcap
->pixelaspect
.denominator
= cx
->is_50hz
? 54 : 11;
401 cropcap
->defrect
= cropcap
->bounds
;
405 static int cx18_s_crop(struct file
*file
, void *fh
, struct v4l2_crop
*crop
)
407 struct cx18_open_id
*id
= fh
;
408 struct cx18
*cx
= id
->cx
;
411 ret
= v4l2_prio_check(&cx
->prio
, &id
->prio
);
415 if (crop
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
417 return cx18_av_cmd(cx
, VIDIOC_S_CROP
, crop
);
420 static int cx18_g_crop(struct file
*file
, void *fh
, struct v4l2_crop
*crop
)
422 struct cx18
*cx
= ((struct cx18_open_id
*)fh
)->cx
;
424 if (crop
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
426 return cx18_av_cmd(cx
, VIDIOC_G_CROP
, crop
);
429 static int cx18_enum_fmt_vid_cap(struct file
*file
, void *fh
,
430 struct v4l2_fmtdesc
*fmt
)
432 static struct v4l2_fmtdesc formats
[] = {
433 { 0, V4L2_BUF_TYPE_VIDEO_CAPTURE
, 0,
434 "HM12 (YUV 4:1:1)", V4L2_PIX_FMT_HM12
, { 0, 0, 0, 0 }
436 { 1, V4L2_BUF_TYPE_VIDEO_CAPTURE
, V4L2_FMT_FLAG_COMPRESSED
,
437 "MPEG", V4L2_PIX_FMT_MPEG
, { 0, 0, 0, 0 }
443 *fmt
= formats
[fmt
->index
];
447 static int cx18_g_input(struct file
*file
, void *fh
, unsigned int *i
)
449 struct cx18
*cx
= ((struct cx18_open_id
*)fh
)->cx
;
451 *i
= cx
->active_input
;
455 int cx18_s_input(struct file
*file
, void *fh
, unsigned int inp
)
457 struct cx18_open_id
*id
= fh
;
458 struct cx18
*cx
= id
->cx
;
461 ret
= v4l2_prio_check(&cx
->prio
, &id
->prio
);
465 if (inp
< 0 || inp
>= cx
->nof_inputs
)
468 if (inp
== cx
->active_input
) {
469 CX18_DEBUG_INFO("Input unchanged\n");
473 CX18_DEBUG_INFO("Changing input from %d to %d\n",
474 cx
->active_input
, inp
);
476 cx
->active_input
= inp
;
477 /* Set the audio input to whatever is appropriate for the input type. */
478 cx
->audio_input
= cx
->card
->video_inputs
[inp
].audio_index
;
480 /* prevent others from messing with the streams until
481 we're finished changing inputs. */
483 cx18_video_set_io(cx
);
484 cx18_audio_set_io(cx
);
489 static int cx18_g_frequency(struct file
*file
, void *fh
,
490 struct v4l2_frequency
*vf
)
492 struct cx18
*cx
= ((struct cx18_open_id
*)fh
)->cx
;
497 cx18_call_i2c_clients(cx
, VIDIOC_G_FREQUENCY
, vf
);
501 int cx18_s_frequency(struct file
*file
, void *fh
, struct v4l2_frequency
*vf
)
503 struct cx18_open_id
*id
= fh
;
504 struct cx18
*cx
= id
->cx
;
507 ret
= v4l2_prio_check(&cx
->prio
, &id
->prio
);
515 CX18_DEBUG_INFO("v4l2 ioctl: set frequency %d\n", vf
->frequency
);
516 cx18_call_i2c_clients(cx
, VIDIOC_S_FREQUENCY
, vf
);
521 static int cx18_g_std(struct file
*file
, void *fh
, v4l2_std_id
*std
)
523 struct cx18
*cx
= ((struct cx18_open_id
*)fh
)->cx
;
529 int cx18_s_std(struct file
*file
, void *fh
, v4l2_std_id
*std
)
531 struct cx18_open_id
*id
= fh
;
532 struct cx18
*cx
= id
->cx
;
535 ret
= v4l2_prio_check(&cx
->prio
, &id
->prio
);
539 if ((*std
& V4L2_STD_ALL
) == 0)
545 if (test_bit(CX18_F_I_RADIO_USER
, &cx
->i_flags
) ||
546 atomic_read(&cx
->ana_capturing
) > 0) {
547 /* Switching standard would turn off the radio or mess
548 with already running streams, prevent that by
554 cx
->is_60hz
= (*std
& V4L2_STD_525_60
) ? 1 : 0;
555 cx
->params
.is_50hz
= cx
->is_50hz
= !cx
->is_60hz
;
556 cx
->params
.width
= 720;
557 cx
->params
.height
= cx
->is_50hz
? 576 : 480;
558 cx
->vbi
.count
= cx
->is_50hz
? 18 : 12;
559 cx
->vbi
.start
[0] = cx
->is_50hz
? 6 : 10;
560 cx
->vbi
.start
[1] = cx
->is_50hz
? 318 : 273;
561 cx
->vbi
.sliced_decoder_line_size
= cx
->is_60hz
? 272 : 284;
562 CX18_DEBUG_INFO("Switching standard to %llx.\n",
563 (unsigned long long) cx
->std
);
566 cx18_call_i2c_clients(cx
, VIDIOC_S_STD
, &cx
->std
);
570 static int cx18_s_tuner(struct file
*file
, void *fh
, struct v4l2_tuner
*vt
)
572 struct cx18_open_id
*id
= fh
;
573 struct cx18
*cx
= id
->cx
;
576 ret
= v4l2_prio_check(&cx
->prio
, &id
->prio
);
583 /* Setting tuner can only set audio mode */
584 cx18_call_i2c_clients(cx
, VIDIOC_S_TUNER
, vt
);
589 static int cx18_g_tuner(struct file
*file
, void *fh
, struct v4l2_tuner
*vt
)
591 struct cx18
*cx
= ((struct cx18_open_id
*)fh
)->cx
;
596 cx18_call_i2c_clients(cx
, VIDIOC_G_TUNER
, vt
);
598 if (test_bit(CX18_F_I_RADIO_USER
, &cx
->i_flags
)) {
599 strlcpy(vt
->name
, "cx18 Radio Tuner", sizeof(vt
->name
));
600 vt
->type
= V4L2_TUNER_RADIO
;
602 strlcpy(vt
->name
, "cx18 TV Tuner", sizeof(vt
->name
));
603 vt
->type
= V4L2_TUNER_ANALOG_TV
;
609 static int cx18_g_sliced_vbi_cap(struct file
*file
, void *fh
,
610 struct v4l2_sliced_vbi_cap
*cap
)
615 static int cx18_g_enc_index(struct file
*file
, void *fh
,
616 struct v4l2_enc_idx
*idx
)
621 static int cx18_encoder_cmd(struct file
*file
, void *fh
,
622 struct v4l2_encoder_cmd
*enc
)
624 struct cx18_open_id
*id
= fh
;
625 struct cx18
*cx
= id
->cx
;
629 case V4L2_ENC_CMD_START
:
630 CX18_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
632 return cx18_start_capture(id
);
634 case V4L2_ENC_CMD_STOP
:
635 CX18_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
636 enc
->flags
&= V4L2_ENC_CMD_STOP_AT_GOP_END
;
637 cx18_stop_capture(id
,
638 enc
->flags
& V4L2_ENC_CMD_STOP_AT_GOP_END
);
641 case V4L2_ENC_CMD_PAUSE
:
642 CX18_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
644 if (!atomic_read(&cx
->ana_capturing
))
646 if (test_and_set_bit(CX18_F_I_ENC_PAUSED
, &cx
->i_flags
))
648 h
= cx18_find_handle(cx
);
649 if (h
== CX18_INVALID_TASK_HANDLE
) {
650 CX18_ERR("Can't find valid task handle for "
651 "V4L2_ENC_CMD_PAUSE\n");
655 cx18_vapi(cx
, CX18_CPU_CAPTURE_PAUSE
, 1, h
);
658 case V4L2_ENC_CMD_RESUME
:
659 CX18_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
661 if (!atomic_read(&cx
->ana_capturing
))
663 if (!test_and_clear_bit(CX18_F_I_ENC_PAUSED
, &cx
->i_flags
))
665 h
= cx18_find_handle(cx
);
666 if (h
== CX18_INVALID_TASK_HANDLE
) {
667 CX18_ERR("Can't find valid task handle for "
668 "V4L2_ENC_CMD_RESUME\n");
671 cx18_vapi(cx
, CX18_CPU_CAPTURE_RESUME
, 1, h
);
676 CX18_DEBUG_IOCTL("Unknown cmd %d\n", enc
->cmd
);
682 static int cx18_try_encoder_cmd(struct file
*file
, void *fh
,
683 struct v4l2_encoder_cmd
*enc
)
685 struct cx18
*cx
= ((struct cx18_open_id
*)fh
)->cx
;
688 case V4L2_ENC_CMD_START
:
689 CX18_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
693 case V4L2_ENC_CMD_STOP
:
694 CX18_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
695 enc
->flags
&= V4L2_ENC_CMD_STOP_AT_GOP_END
;
698 case V4L2_ENC_CMD_PAUSE
:
699 CX18_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
703 case V4L2_ENC_CMD_RESUME
:
704 CX18_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
709 CX18_DEBUG_IOCTL("Unknown cmd %d\n", enc
->cmd
);
715 static int cx18_log_status(struct file
*file
, void *fh
)
717 struct cx18
*cx
= ((struct cx18_open_id
*)fh
)->cx
;
718 struct v4l2_input vidin
;
719 struct v4l2_audio audin
;
722 CX18_INFO("================= START STATUS CARD #%d =================\n", cx
->num
);
723 if (cx
->hw_flags
& CX18_HW_TVEEPROM
) {
726 cx18_read_eeprom(cx
, &tv
);
728 cx18_call_i2c_clients(cx
, VIDIOC_LOG_STATUS
, NULL
);
729 cx18_get_input(cx
, cx
->active_input
, &vidin
);
730 cx18_get_audio_input(cx
, cx
->audio_input
, &audin
);
731 CX18_INFO("Video Input: %s\n", vidin
.name
);
732 CX18_INFO("Audio Input: %s\n", audin
.name
);
733 mutex_lock(&cx
->gpio_lock
);
734 CX18_INFO("GPIO: direction 0x%08x, value 0x%08x\n",
735 cx
->gpio_dir
, cx
->gpio_val
);
736 mutex_unlock(&cx
->gpio_lock
);
737 CX18_INFO("Tuner: %s\n",
738 test_bit(CX18_F_I_RADIO_USER
, &cx
->i_flags
) ? "Radio" : "TV");
739 cx2341x_log_status(&cx
->params
, cx
->name
);
740 CX18_INFO("Status flags: 0x%08lx\n", cx
->i_flags
);
741 for (i
= 0; i
< CX18_MAX_STREAMS
; i
++) {
742 struct cx18_stream
*s
= &cx
->streams
[i
];
744 if (s
->v4l2dev
== NULL
|| s
->buffers
== 0)
746 CX18_INFO("Stream %s: status 0x%04lx, %d%% of %d KiB (%d buffers) in use\n",
748 atomic_read(&s
->q_full
.buffers
) * 100 / s
->buffers
,
749 (s
->buffers
* s
->buf_size
) / 1024, s
->buffers
);
751 CX18_INFO("Read MPEG/VBI: %lld/%lld bytes\n",
752 (long long)cx
->mpg_data_received
,
753 (long long)cx
->vbi_data_inserted
);
754 CX18_INFO("================== END STATUS CARD #%d ==================\n", cx
->num
);
758 static int cx18_default(struct file
*file
, void *fh
, int cmd
, void *arg
)
760 struct cx18
*cx
= ((struct cx18_open_id
*)fh
)->cx
;
763 case VIDIOC_INT_S_AUDIO_ROUTING
: {
764 struct v4l2_routing
*route
= arg
;
766 CX18_DEBUG_IOCTL("VIDIOC_INT_S_AUDIO_ROUTING(%d, %d)\n",
767 route
->input
, route
->output
);
768 cx18_audio_set_route(cx
, route
);
772 case VIDIOC_INT_RESET
: {
773 u32 val
= *(u32
*)arg
;
775 if ((val
== 0) || (val
& 0x01))
776 cx18_reset_ir_gpio(&cx
->i2c_algo_cb_data
[0]);
786 int cx18_v4l2_ioctl(struct file
*filp
, unsigned int cmd
,
789 struct video_device
*vfd
= video_devdata(filp
);
790 struct cx18_open_id
*id
= (struct cx18_open_id
*)filp
->private_data
;
791 struct cx18
*cx
= id
->cx
;
794 mutex_lock(&cx
->serialize_lock
);
796 if (cx18_debug
& CX18_DBGFLG_IOCTL
)
797 vfd
->debug
= V4L2_DEBUG_IOCTL
| V4L2_DEBUG_IOCTL_ARG
;
798 res
= video_ioctl2(filp
, cmd
, arg
);
800 mutex_unlock(&cx
->serialize_lock
);
804 static const struct v4l2_ioctl_ops cx18_ioctl_ops
= {
805 .vidioc_querycap
= cx18_querycap
,
806 .vidioc_g_priority
= cx18_g_priority
,
807 .vidioc_s_priority
= cx18_s_priority
,
808 .vidioc_s_audio
= cx18_s_audio
,
809 .vidioc_g_audio
= cx18_g_audio
,
810 .vidioc_enumaudio
= cx18_enumaudio
,
811 .vidioc_enum_input
= cx18_enum_input
,
812 .vidioc_cropcap
= cx18_cropcap
,
813 .vidioc_s_crop
= cx18_s_crop
,
814 .vidioc_g_crop
= cx18_g_crop
,
815 .vidioc_g_input
= cx18_g_input
,
816 .vidioc_s_input
= cx18_s_input
,
817 .vidioc_g_frequency
= cx18_g_frequency
,
818 .vidioc_s_frequency
= cx18_s_frequency
,
819 .vidioc_s_tuner
= cx18_s_tuner
,
820 .vidioc_g_tuner
= cx18_g_tuner
,
821 .vidioc_g_enc_index
= cx18_g_enc_index
,
822 .vidioc_g_std
= cx18_g_std
,
823 .vidioc_s_std
= cx18_s_std
,
824 .vidioc_log_status
= cx18_log_status
,
825 .vidioc_enum_fmt_vid_cap
= cx18_enum_fmt_vid_cap
,
826 .vidioc_encoder_cmd
= cx18_encoder_cmd
,
827 .vidioc_try_encoder_cmd
= cx18_try_encoder_cmd
,
828 .vidioc_g_fmt_vid_cap
= cx18_g_fmt_vid_cap
,
829 .vidioc_g_fmt_vbi_cap
= cx18_g_fmt_vbi_cap
,
830 .vidioc_g_fmt_sliced_vbi_cap
= cx18_g_fmt_sliced_vbi_cap
,
831 .vidioc_s_fmt_vid_cap
= cx18_s_fmt_vid_cap
,
832 .vidioc_s_fmt_vbi_cap
= cx18_s_fmt_vbi_cap
,
833 .vidioc_s_fmt_sliced_vbi_cap
= cx18_s_fmt_sliced_vbi_cap
,
834 .vidioc_try_fmt_vid_cap
= cx18_try_fmt_vid_cap
,
835 .vidioc_try_fmt_vbi_cap
= cx18_try_fmt_vbi_cap
,
836 .vidioc_try_fmt_sliced_vbi_cap
= cx18_try_fmt_sliced_vbi_cap
,
837 .vidioc_g_sliced_vbi_cap
= cx18_g_sliced_vbi_cap
,
838 .vidioc_g_chip_ident
= cx18_g_chip_ident
,
839 #ifdef CONFIG_VIDEO_ADV_DEBUG
840 .vidioc_g_register
= cx18_g_register
,
841 .vidioc_s_register
= cx18_s_register
,
843 .vidioc_default
= cx18_default
,
844 .vidioc_queryctrl
= cx18_queryctrl
,
845 .vidioc_querymenu
= cx18_querymenu
,
846 .vidioc_g_ext_ctrls
= cx18_g_ext_ctrls
,
847 .vidioc_s_ext_ctrls
= cx18_s_ext_ctrls
,
848 .vidioc_try_ext_ctrls
= cx18_try_ext_ctrls
,
851 void cx18_set_funcs(struct video_device
*vdev
)
853 vdev
->ioctl_ops
= &cx18_ioctl_ops
;