Skip to content

L
linux
Commit 3b6fe58f authored by Andy Walls's avatar Andy Walls Committed by Mauro Carvalho Chehab
Browse files
Options

V4L/DVB (8082): cx18: convert to video_ioctl2() 

cx18: convert driver to use video_ioctl2().  Pushed down ioctl debug
messages and priority checks as well.  Still left serialization lock in
place for now.  #if 0'ed out sliced vbi ioctl code for now.

Patch heavily based on similar changes made to ivtv by Hans Verkuil.
Signed-off-by: default avatarAndy Walls <awalls@radix.net>
Signed-off-by: default avatarHans Verkuil <hverkuil@xs4all.nl>
Signed-off-by: default avatarMauro Carvalho Chehab <mchehab@infradead.org>
parent 1a05221b
Hide whitespace changes
Inline Side-by-side
Showing with 745 additions and 689 deletions
drivers/media/video/cx18/cx18-controls.c
View file @ 3b6fe58f
...@@ -51,8 +51,9 @@ static const u32 *ctrl_classes[] = { ...@@ -51,8 +51,9 @@ static const u32 *ctrl_classes[] = {
NULL NULL
}; };
static int cx18_queryctrl(struct cx18 *cx, struct v4l2_queryctrl *qctrl) int cx18_queryctrl(struct file *file, void *fh, struct v4l2_queryctrl *qctrl)
{ {
struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
const char *name; const char *name;
CX18_DEBUG_IOCTL("VIDIOC_QUERYCTRL(%08x)\n", qctrl->id); CX18_DEBUG_IOCTL("VIDIOC_QUERYCTRL(%08x)\n", qctrl->id);
...@@ -91,19 +92,28 @@ static int cx18_queryctrl(struct cx18 *cx, struct v4l2_queryctrl *qctrl) ...@@ -91,19 +92,28 @@ static int cx18_queryctrl(struct cx18 *cx, struct v4l2_queryctrl *qctrl)
return 0; return 0;
} }
static int cx18_querymenu(struct cx18 *cx, struct v4l2_querymenu *qmenu) int cx18_querymenu(struct file *file, void *fh, struct v4l2_querymenu *qmenu)
{ {
struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
struct v4l2_queryctrl qctrl; struct v4l2_queryctrl qctrl;
CX18_DEBUG_IOCTL("VIDIOC_QUERYMENU\n");
qctrl.id = qmenu->id; qctrl.id = qmenu->id;
cx18_queryctrl(cx, &qctrl); cx18_queryctrl(file, fh, &qctrl);
return v4l2_ctrl_query_menu(qmenu, &qctrl, cx2341x_ctrl_get_menu(qmenu->id)); return v4l2_ctrl_query_menu(qmenu, &qctrl, cx2341x_ctrl_get_menu(qmenu->id));
} }
static int cx18_s_ctrl(struct cx18 *cx, struct v4l2_control *vctrl) int cx18_s_ctrl(struct file *file, void *fh, struct v4l2_control *vctrl)
{ {
struct cx18_open_id *id = fh;
struct cx18 *cx = id->cx;
int ret;
s32 v = vctrl->value; s32 v = vctrl->value;
ret = v4l2_prio_check(&cx->prio, &id->prio);
if (ret)
return ret;
CX18_DEBUG_IOCTL("VIDIOC_S_CTRL(%08x, %x)\n", vctrl->id, v); CX18_DEBUG_IOCTL("VIDIOC_S_CTRL(%08x, %x)\n", vctrl->id, v);
switch (vctrl->id) { switch (vctrl->id) {
...@@ -129,8 +139,10 @@ static int cx18_s_ctrl(struct cx18 *cx, struct v4l2_control *vctrl) ...@@ -129,8 +139,10 @@ static int cx18_s_ctrl(struct cx18 *cx, struct v4l2_control *vctrl)
return 0; return 0;
} }
static int cx18_g_ctrl(struct cx18 *cx, struct v4l2_control *vctrl) int cx18_g_ctrl(struct file *file, void *fh, struct v4l2_control *vctrl)
{ {
struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
CX18_DEBUG_IOCTL("VIDIOC_G_CTRL(%08x)\n", vctrl->id); CX18_DEBUG_IOCTL("VIDIOC_G_CTRL(%08x)\n", vctrl->id);
switch (vctrl->id) { switch (vctrl->id) {
...@@ -194,113 +206,100 @@ static int cx18_setup_vbi_fmt(struct cx18 *cx, enum v4l2_mpeg_stream_vbi_fmt fmt ...@@ -194,113 +206,100 @@ static int cx18_setup_vbi_fmt(struct cx18 *cx, enum v4l2_mpeg_stream_vbi_fmt fmt
return 0; return 0;
} }
int cx18_control_ioctls(struct cx18 *cx, unsigned int cmd, void *arg) int cx18_g_ext_ctrls(struct file *file, void *fh, struct v4l2_ext_controls *c)
{ {
struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
struct v4l2_control ctrl; struct v4l2_control ctrl;
switch (cmd) { if (c->ctrl_class == V4L2_CTRL_CLASS_USER) {
case VIDIOC_QUERYMENU: int i;
CX18_DEBUG_IOCTL("VIDIOC_QUERYMENU\n"); int err = 0;
return cx18_querymenu(cx, arg);
for (i = 0; i < c->count; i++) {
case VIDIOC_QUERYCTRL: ctrl.id = c->controls[i].id;
return cx18_queryctrl(cx, arg); ctrl.value = c->controls[i].value;
err = cx18_g_ctrl(file, fh, &ctrl);
case VIDIOC_S_CTRL: c->controls[i].value = ctrl.value;
return cx18_s_ctrl(cx, arg); if (err) {
c->error_idx = i;
case VIDIOC_G_CTRL: break;
return cx18_g_ctrl(cx, arg);
case VIDIOC_S_EXT_CTRLS:
{
struct v4l2_ext_controls *c = arg;
if (c->ctrl_class == V4L2_CTRL_CLASS_USER) {
int i;
int err = 0;
for (i = 0; i < c->count; i++) {
ctrl.id = c->controls[i].id;
ctrl.value = c->controls[i].value;
err = cx18_s_ctrl(cx, &ctrl);
c->controls[i].value = ctrl.value;
if (err) {
c->error_idx = i;
break;
}
} }
return err;
} }
CX18_DEBUG_IOCTL("VIDIOC_S_EXT_CTRLS\n"); return err;
if (c->ctrl_class == V4L2_CTRL_CLASS_MPEG) { }
struct cx2341x_mpeg_params p = cx->params; CX18_DEBUG_IOCTL("VIDIOC_G_EXT_CTRLS\n");
int err = cx2341x_ext_ctrls(&p, atomic_read(&cx->ana_capturing), arg, cmd); if (c->ctrl_class == V4L2_CTRL_CLASS_MPEG)
return cx2341x_ext_ctrls(&cx->params, 0, c, VIDIOC_G_EXT_CTRLS);
return -EINVAL;
}
if (err) int cx18_s_ext_ctrls(struct file *file, void *fh, struct v4l2_ext_controls *c)
return err; {
struct cx18_open_id *id = fh;
struct cx18 *cx = id->cx;
int ret;
struct v4l2_control ctrl;
if (p.video_encoding != cx->params.video_encoding) { ret = v4l2_prio_check(&cx->prio, &id->prio);
int is_mpeg1 = p.video_encoding == if (ret)
V4L2_MPEG_VIDEO_ENCODING_MPEG_1; return ret;
struct v4l2_format fmt;
/* fix videodecoder resolution */ if (c->ctrl_class == V4L2_CTRL_CLASS_USER) {
fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; int i;
fmt.fmt.pix.width = cx->params.width / (is_mpeg1 ? 2 : 1); int err = 0;
fmt.fmt.pix.height = cx->params.height;
cx18_av_cmd(cx, VIDIOC_S_FMT, &fmt); for (i = 0; i < c->count; i++) {
ctrl.id = c->controls[i].id;
ctrl.value = c->controls[i].value;
err = cx18_s_ctrl(file, fh, &ctrl);
c->controls[i].value = ctrl.value;
if (err) {
c->error_idx = i;
break;
} }
err = cx2341x_update(cx, cx18_api_func, &cx->params, &p);
if (!err && cx->params.stream_vbi_fmt != p.stream_vbi_fmt)
err = cx18_setup_vbi_fmt(cx, p.stream_vbi_fmt);
cx->params = p;
cx->dualwatch_stereo_mode = p.audio_properties & 0x0300;
cx18_audio_set_audio_clock_freq(cx, p.audio_properties & 0x03);
return err;
} }
return -EINVAL; return err;
} }
CX18_DEBUG_IOCTL("VIDIOC_S_EXT_CTRLS\n");
if (c->ctrl_class == V4L2_CTRL_CLASS_MPEG) {
struct cx2341x_mpeg_params p = cx->params;
int err = cx2341x_ext_ctrls(&p, atomic_read(&cx->ana_capturing),
c, VIDIOC_S_EXT_CTRLS);
case VIDIOC_G_EXT_CTRLS: if (err)
{
struct v4l2_ext_controls *c = arg;
if (c->ctrl_class == V4L2_CTRL_CLASS_USER) {
int i;
int err = 0;
for (i = 0; i < c->count; i++) {
ctrl.id = c->controls[i].id;
ctrl.value = c->controls[i].value;
err = cx18_g_ctrl(cx, &ctrl);
c->controls[i].value = ctrl.value;
if (err) {
c->error_idx = i;
break;
}
}
return err; return err;
}
CX18_DEBUG_IOCTL("VIDIOC_G_EXT_CTRLS\n");
if (c->ctrl_class == V4L2_CTRL_CLASS_MPEG)
return cx2341x_ext_ctrls(&cx->params, 0, arg, cmd);
return -EINVAL;
}
case VIDIOC_TRY_EXT_CTRLS: if (p.video_encoding != cx->params.video_encoding) {
{ int is_mpeg1 = p.video_encoding ==
struct v4l2_ext_controls *c = arg; V4L2_MPEG_VIDEO_ENCODING_MPEG_1;
struct v4l2_format fmt;
CX18_DEBUG_IOCTL("VIDIOC_TRY_EXT_CTRLS\n");
if (c->ctrl_class == V4L2_CTRL_CLASS_MPEG) /* fix videodecoder resolution */
return cx2341x_ext_ctrls(&cx->params, fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
atomic_read(&cx->ana_capturing), arg, cmd); fmt.fmt.pix.width = cx->params.width
return -EINVAL; / (is_mpeg1 ? 2 : 1);
fmt.fmt.pix.height = cx->params.height;
cx18_av_cmd(cx, VIDIOC_S_FMT, &fmt);
}
err = cx2341x_update(cx, cx18_api_func, &cx->params, &p);
if (!err && cx->params.stream_vbi_fmt != p.stream_vbi_fmt)
err = cx18_setup_vbi_fmt(cx, p.stream_vbi_fmt);
cx->params = p;
cx->dualwatch_stereo_mode = p.audio_properties & 0x0300;
cx18_audio_set_audio_clock_freq(cx, p.audio_properties & 0x03);
return err;
} }
return -EINVAL;
}
default: int cx18_try_ext_ctrls(struct file *file, void *fh, struct v4l2_ext_controls *c)
return -EINVAL; {
} struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
return 0;
CX18_DEBUG_IOCTL("VIDIOC_TRY_EXT_CTRLS\n");
if (c->ctrl_class == V4L2_CTRL_CLASS_MPEG)
return cx2341x_ext_ctrls(&cx->params,
atomic_read(&cx->ana_capturing),
c, VIDIOC_TRY_EXT_CTRLS);
return -EINVAL;
} }
drivers/media/video/cx18/cx18-controls.h
View file @ 3b6fe58f
...@@ -21,4 +21,11 @@ ...@@ -21,4 +21,11 @@
* 02111-1307 USA * 02111-1307 USA
*/ */
int cx18_control_ioctls(struct cx18 *cx, unsigned int cmd, void *arg); int cx18_queryctrl(struct file *file, void *fh, struct v4l2_queryctrl *a);
int cx18_g_ctrl(struct file *file, void *fh, struct v4l2_control *a);
int cx18_s_ctrl(struct file *file, void *fh, struct v4l2_control *a);
int cx18_g_ext_ctrls(struct file *file, void *fh, struct v4l2_ext_controls *a);
int cx18_s_ext_ctrls(struct file *file, void *fh, struct v4l2_ext_controls *a);
int cx18_try_ext_ctrls(struct file *file, void *fh,
struct v4l2_ext_controls *a);
int cx18_querymenu(struct file *file, void *fh, struct v4l2_querymenu *a);
drivers/media/video/cx18/cx18-driver.c
View file @ 3b6fe58f
...@@ -818,6 +818,9 @@ int cx18_init_on_first_open(struct cx18 *cx) ...@@ -818,6 +818,9 @@ int cx18_init_on_first_open(struct cx18 *cx)
int video_input; int video_input;
int fw_retry_count = 3; int fw_retry_count = 3;
struct v4l2_frequency vf; struct v4l2_frequency vf;
struct cx18_open_id fh;
fh.cx = cx;
if (test_bit(CX18_F_I_FAILED, &cx->i_flags)) if (test_bit(CX18_F_I_FAILED, &cx->i_flags))
return -ENXIO; return -ENXIO;
...@@ -869,13 +872,13 @@ int cx18_init_on_first_open(struct cx18 *cx) ...@@ -869,13 +872,13 @@ int cx18_init_on_first_open(struct cx18 *cx)
video_input = cx->active_input; video_input = cx->active_input;
cx->active_input++; /* Force update of input */ cx->active_input++; /* Force update of input */
cx18_v4l2_ioctls(cx, NULL, VIDIOC_S_INPUT, &video_input); cx18_s_input(NULL, &fh, video_input);
/* Let the VIDIOC_S_STD ioctl do all the work, keeps the code /* Let the VIDIOC_S_STD ioctl do all the work, keeps the code
in one place. */ in one place. */
cx->std++; /* Force full standard initialization */ cx->std++; /* Force full standard initialization */
cx18_v4l2_ioctls(cx, NULL, VIDIOC_S_STD, &cx->tuner_std); cx18_s_std(NULL, &fh, &cx->tuner_std);
cx18_v4l2_ioctls(cx, NULL, VIDIOC_S_FREQUENCY, &vf); cx18_s_frequency(NULL, &fh, &vf);
return 0; return 0;
} }
......
drivers/media/video/cx18/cx18-ioctl.c
View file @ 3b6fe58f
...@@ -100,19 +100,6 @@ void cx18_expand_service_set(struct v4l2_sliced_vbi_format *fmt, int is_pal) ...@@ -100,19 +100,6 @@ void cx18_expand_service_set(struct v4l2_sliced_vbi_format *fmt, int is_pal)
} }
} }
static int check_service_set(struct v4l2_sliced_vbi_format *fmt, int is_pal)
{
int f, l;
u16 set = 0;
for (f = 0; f < 2; f++) {
for (l = 0; l < 24; l++) {
fmt->service_lines[f][l] = select_service_from_set(f, l, fmt->service_lines[f][l], is_pal);
set |= fmt->service_lines[f][l];
}
}
return set != 0;
}
u16 cx18_get_service_set(struct v4l2_sliced_vbi_format *fmt) u16 cx18_get_service_set(struct v4l2_sliced_vbi_format *fmt)
{ {
...@@ -126,35 +113,6 @@ u16 cx18_get_service_set(struct v4l2_sliced_vbi_format *fmt) ...@@ -126,35 +113,6 @@ u16 cx18_get_service_set(struct v4l2_sliced_vbi_format *fmt)
return set; return set;
} }
static const struct {
v4l2_std_id std;
char *name;
} enum_stds[] = {
{ V4L2_STD_PAL_BG | V4L2_STD_PAL_H, "PAL-BGH" },
{ V4L2_STD_PAL_DK, "PAL-DK" },
{ V4L2_STD_PAL_I, "PAL-I" },
{ V4L2_STD_PAL_M, "PAL-M" },
{ V4L2_STD_PAL_N, "PAL-N" },
{ V4L2_STD_PAL_Nc, "PAL-Nc" },
{ V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H, "SECAM-BGH" },
{ V4L2_STD_SECAM_DK, "SECAM-DK" },
{ V4L2_STD_SECAM_L, "SECAM-L" },
{ V4L2_STD_SECAM_LC, "SECAM-L'" },
{ V4L2_STD_NTSC_M, "NTSC-M" },
{ V4L2_STD_NTSC_M_JP, "NTSC-J" },
{ V4L2_STD_NTSC_M_KR, "NTSC-K" },
};
static const struct v4l2_standard cx18_std_60hz = {
.frameperiod = {.numerator = 1001, .denominator = 30000},
.framelines = 525,
};
static const struct v4l2_standard cx18_std_50hz = {
.frameperiod = { .numerator = 1, .denominator = 25 },
.framelines = 625,
};
static int cx18_cxc(struct cx18 *cx, unsigned int cmd, void *arg) static int cx18_cxc(struct cx18 *cx, unsigned int cmd, void *arg)
{ {
struct v4l2_register *regs = arg; struct v4l2_register *regs = arg;
...@@ -174,665 +132,702 @@ static int cx18_cxc(struct cx18 *cx, unsigned int cmd, void *arg) ...@@ -174,665 +132,702 @@ static int cx18_cxc(struct cx18 *cx, unsigned int cmd, void *arg)
return 0; return 0;
} }
static int cx18_get_fmt(struct cx18 *cx, int streamtype, struct v4l2_format *fmt) static int cx18_g_fmt_vid_cap(struct file *file, void *fh,
{ struct v4l2_format *fmt)
switch (fmt->type) { {
case V4L2_BUF_TYPE_VIDEO_CAPTURE: struct cx18_open_id *id = fh;
fmt->fmt.pix.width = cx->params.width; struct cx18 *cx = id->cx;
fmt->fmt.pix.height = cx->params.height;
fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
fmt->fmt.pix.field = V4L2_FIELD_INTERLACED;
if (streamtype == CX18_ENC_STREAM_TYPE_YUV) {
fmt->fmt.pix.pixelformat = V4L2_PIX_FMT_HM12;
/* YUV size is (Y=(h*w) + UV=(h*(w/2))) */
fmt->fmt.pix.sizeimage =
fmt->fmt.pix.height * fmt->fmt.pix.width +
fmt->fmt.pix.height * (fmt->fmt.pix.width / 2);
} else {
fmt->fmt.pix.pixelformat = V4L2_PIX_FMT_MPEG;
fmt->fmt.pix.sizeimage = 128 * 1024;
}
break;
case V4L2_BUF_TYPE_VBI_CAPTURE: CX18_DEBUG_IOCTL("VIDIOC_G_FMT: V4L2_BUF_TYPE_VIDEO_CAPTURE\n");
fmt->fmt.vbi.sampling_rate = 27000000;
fmt->fmt.vbi.offset = 248; fmt->fmt.pix.width = cx->params.width;
fmt->fmt.vbi.samples_per_line = cx->vbi.raw_decoder_line_size - 4; fmt->fmt.pix.height = cx->params.height;
fmt->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY; fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
fmt->fmt.vbi.start[0] = cx->vbi.start[0]; fmt->fmt.pix.field = V4L2_FIELD_INTERLACED;
fmt->fmt.vbi.start[1] = cx->vbi.start[1]; if (id->type == CX18_ENC_STREAM_TYPE_YUV) {
fmt->fmt.vbi.count[0] = fmt->fmt.vbi.count[1] = cx->vbi.count; fmt->fmt.pix.pixelformat = V4L2_PIX_FMT_HM12;
break; /* YUV size is (Y=(h*w) + UV=(h*(w/2))) */
fmt->fmt.pix.sizeimage =
fmt->fmt.pix.height * fmt->fmt.pix.width +
fmt->fmt.pix.height * (fmt->fmt.pix.width / 2);
} else {
fmt->fmt.pix.pixelformat = V4L2_PIX_FMT_MPEG;
fmt->fmt.pix.sizeimage = 128 * 1024;
}
return 0;
}
case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE: static int cx18_g_fmt_vbi_cap(struct file *file, void *fh,
{ struct v4l2_format *fmt)
struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced; {
struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36; CX18_DEBUG_IOCTL("VIDIOC_G_FMT: V4L2_BUF_TYPE_VBI_CAPTURE\n");
memset(vbifmt->reserved, 0, sizeof(vbifmt->reserved));
memset(vbifmt->service_lines, 0, sizeof(vbifmt->service_lines));
cx18_av_cmd(cx, VIDIOC_G_FMT, fmt); fmt->fmt.vbi.sampling_rate = 27000000;
vbifmt->service_set = cx18_get_service_set(vbifmt); fmt->fmt.vbi.offset = 248;
break; fmt->fmt.vbi.samples_per_line = cx->vbi.raw_decoder_line_size - 4;
} fmt->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY;
default: fmt->fmt.vbi.start[0] = cx->vbi.start[0];
return -EINVAL; fmt->fmt.vbi.start[1] = cx->vbi.start[1];
} fmt->fmt.vbi.count[0] = fmt->fmt.vbi.count[1] = cx->vbi.count;
return 0; return 0;
} }
static int cx18_try_or_set_fmt(struct cx18 *cx, int streamtype, static int cx18_g_fmt_sliced_vbi_cap(struct file *file, void *fh,
struct v4l2_format *fmt, int set_fmt) struct v4l2_format *fmt)
{ {
struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced; return -EINVAL;
u16 set; }
/* set window size */ static int cx18_try_fmt_vid_cap(struct file *file, void *fh,
if (fmt->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) { struct v4l2_format *fmt)
int w = fmt->fmt.pix.width; {
int h = fmt->fmt.pix.height; struct cx18_open_id *id = fh;
struct cx18 *cx = id->cx;
if (w > 720) int w = fmt->fmt.pix.width;
w = 720; int h = fmt->fmt.pix.height;
else if (w < 1)
w = 1;
if (h > (cx->is_50hz ? 576 : 480))
h = (cx->is_50hz ? 576 : 480);
else if (h < 2)
h = 2;
cx18_get_fmt(cx, streamtype, fmt);
fmt->fmt.pix.width = w;
fmt->fmt.pix.height = h;
if (!set_fmt || (cx->params.width == w && cx->params.height == h)) CX18_DEBUG_IOCTL("VIDIOC_TRY_FMT: V4L2_BUF_TYPE_VIDEO_CAPTURE\n");
return 0;
if (atomic_read(&cx->ana_capturing) > 0)
return -EBUSY;
cx->params.width = w;
cx->params.height = h;
if (w != 720 || h != (cx->is_50hz ? 576 : 480))
cx->params.video_temporal_filter = 0;
else
cx->params.video_temporal_filter = 8;
cx18_av_cmd(cx, VIDIOC_S_FMT, fmt);
return cx18_get_fmt(cx, streamtype, fmt);
}
/* set raw VBI format */ w = min(w, 720);
if (fmt->type == V4L2_BUF_TYPE_VBI_CAPTURE) { w = max(w, 1);
if (set_fmt && streamtype == CX18_ENC_STREAM_TYPE_VBI && h = min(h, cx->is_50hz ? 576 : 480);
cx->vbi.sliced_in->service_set && h = max(h, 2);
atomic_read(&cx->ana_capturing) > 0) cx18_g_fmt_vid_cap(file, fh, fmt);
return -EBUSY; fmt->fmt.pix.width = w;
if (set_fmt) { fmt->fmt.pix.height = h;
cx->vbi.sliced_in->service_set = 0; return 0;
cx18_av_cmd(cx, VIDIOC_S_FMT, &cx->vbi.in); }
}
return cx18_get_fmt(cx, streamtype, fmt);
}
/* any else but sliced VBI capture is an error */ static int cx18_try_fmt_vbi_cap(struct file *file, void *fh,
if (fmt->type != V4L2_BUF_TYPE_SLICED_VBI_CAPTURE) struct v4l2_format *fmt)
return -EINVAL; {
struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
/* TODO: implement sliced VBI, for now silently return 0 */ CX18_DEBUG_IOCTL("VIDIOC_TRY_FMT: V4L2_BUF_TYPE_VBI_CAPTURE\n");
return 0;
return cx18_g_fmt_vbi_cap(file, fh, fmt);
}
static int cx18_try_fmt_sliced_vbi_cap(struct file *file, void *fh,
struct v4l2_format *fmt)
{
return -EINVAL;
}
static int cx18_s_fmt_vid_cap(struct file *file, void *fh,
struct v4l2_format *fmt)
{
struct cx18_open_id *id = fh;
struct cx18 *cx = id->cx;
int ret;
int w = fmt->fmt.pix.width;
int h = fmt->fmt.pix.height;
ret = v4l2_prio_check(&cx->prio, &id->prio);
if (ret)
return ret;
/* set sliced VBI capture format */ CX18_DEBUG_IOCTL("VIDIOC_S_FMT: V4L2_BUF_TYPE_VIDEO_CAPTURE\n");
vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
memset(vbifmt->reserved, 0, sizeof(vbifmt->reserved));
if (vbifmt->service_set) ret = cx18_try_fmt_vid_cap(file, fh, fmt);
cx18_expand_service_set(vbifmt, cx->is_50hz); if (ret)
set = check_service_set(vbifmt, cx->is_50hz); return ret;
vbifmt->service_set = cx18_get_service_set(vbifmt);
if (!set_fmt) if (cx->params.width == w && cx->params.height == h)
return 0; return 0;
if (set == 0)
return -EINVAL; if (atomic_read(&cx->ana_capturing) > 0)
if (atomic_read(&cx->ana_capturing) > 0 && cx->vbi.sliced_in->service_set == 0)
return -EBUSY; return -EBUSY;
cx->params.width = w;
cx->params.height = h;
if (w != 720 || h != (cx->is_50hz ? 576 : 480))
cx->params.video_temporal_filter = 0;
else
cx->params.video_temporal_filter = 8;
cx18_av_cmd(cx, VIDIOC_S_FMT, fmt); cx18_av_cmd(cx, VIDIOC_S_FMT, fmt);
memcpy(cx->vbi.sliced_in, vbifmt, sizeof(*cx->vbi.sliced_in)); return cx18_g_fmt_vid_cap(file, fh, fmt);
return 0;
} }
static int cx18_debug_ioctls(struct file *filp, unsigned int cmd, void *arg) static int cx18_s_fmt_vbi_cap(struct file *file, void *fh,
struct v4l2_format *fmt)
{ {
struct cx18_open_id *id = (struct cx18_open_id *)filp->private_data; struct cx18_open_id *id = fh;
struct cx18 *cx = id->cx; struct cx18 *cx = id->cx;
struct v4l2_register *reg = arg; int ret;
switch (cmd) { ret = v4l2_prio_check(&cx->prio, &id->prio);
/* ioctls to allow direct access to the encoder registers for testing */ if (ret)
case VIDIOC_DBG_G_REGISTER: return ret;
if (v4l2_chip_match_host(reg->match_type, reg->match_chip))
return cx18_cxc(cx, cmd, arg);
if (reg->match_type == V4L2_CHIP_MATCH_I2C_DRIVER)
return cx18_i2c_id(cx, reg->match_chip, cmd, arg);
return cx18_call_i2c_client(cx, reg->match_chip, cmd, arg);
case VIDIOC_DBG_S_REGISTER:
if (v4l2_chip_match_host(reg->match_type, reg->match_chip))
return cx18_cxc(cx, cmd, arg);
if (reg->match_type == V4L2_CHIP_MATCH_I2C_DRIVER)
return cx18_i2c_id(cx, reg->match_chip, cmd, arg);
return cx18_call_i2c_client(cx, reg->match_chip, cmd, arg);
case VIDIOC_G_CHIP_IDENT: {
struct v4l2_chip_ident *chip = arg;
chip->ident = V4L2_IDENT_NONE;
chip->revision = 0;
if (reg->match_type == V4L2_CHIP_MATCH_HOST) {
if (v4l2_chip_match_host(reg->match_type, reg->match_chip)) {
struct v4l2_chip_ident *chip = arg;
chip->ident = V4L2_IDENT_CX23418;
}
return 0;
}
if (reg->match_type == V4L2_CHIP_MATCH_I2C_DRIVER)
return cx18_i2c_id(cx, reg->match_chip, cmd, arg);
if (reg->match_type == V4L2_CHIP_MATCH_I2C_ADDR)
return cx18_call_i2c_client(cx, reg->match_chip, cmd, arg);
return -EINVAL;
}
case VIDIOC_INT_S_AUDIO_ROUTING: { CX18_DEBUG_IOCTL("VIDIOC_S_FMT: V4L2_BUF_TYPE_VBI_CAPTURE\n");
struct v4l2_routing *route = arg;
cx18_audio_set_route(cx, route); if (id->type == CX18_ENC_STREAM_TYPE_VBI &&
break; cx->vbi.sliced_in->service_set &&
} atomic_read(&cx->ana_capturing) > 0)
return -EBUSY;
default: cx->vbi.sliced_in->service_set = 0;
return -EINVAL; cx18_av_cmd(cx, VIDIOC_S_FMT, &cx->vbi.in);
return cx18_g_fmt_vbi_cap(file, fh, fmt);
}
static int cx18_s_fmt_sliced_vbi_cap(struct file *file, void *fh,
struct v4l2_format *fmt)
{
return -EINVAL;
}
static int cx18_g_chip_ident(struct file *file, void *fh,
struct v4l2_chip_ident *chip)
{
struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
CX18_DEBUG_IOCTL("VIDIOC_G_CHIP_IDENT\n");
chip->ident = V4L2_IDENT_NONE;
chip->revision = 0;
if (chip->match_type == V4L2_CHIP_MATCH_HOST) {
if (v4l2_chip_match_host(chip->match_type, chip->match_chip))
chip->ident = V4L2_IDENT_CX23418;
return 0;
} }
if (chip->match_type == V4L2_CHIP_MATCH_I2C_DRIVER)
return cx18_i2c_id(cx, chip->match_chip, VIDIOC_G_CHIP_IDENT,
chip);
if (chip->match_type == V4L2_CHIP_MATCH_I2C_ADDR)
return cx18_call_i2c_client(cx, chip->match_chip,
VIDIOC_G_CHIP_IDENT, chip);
return -EINVAL;
}
static int cx18_g_register(struct file *file, void *fh,
struct v4l2_register *reg)
{
struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
CX18_DEBUG_IOCTL("VIDIOC_DBG_G_REGISTER\n");
if (v4l2_chip_match_host(reg->match_type, reg->match_chip))
return cx18_cxc(cx, VIDIOC_DBG_G_REGISTER, reg);
if (reg->match_type == V4L2_CHIP_MATCH_I2C_DRIVER)
return cx18_i2c_id(cx, reg->match_chip, VIDIOC_DBG_G_REGISTER,
reg);
return cx18_call_i2c_client(cx, reg->match_chip, VIDIOC_DBG_G_REGISTER,
reg);
}
static int cx18_s_register(struct file *file, void *fh,
struct v4l2_register *reg)
{
struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
CX18_DEBUG_IOCTL("VIDIOC_DBG_S_REGISTER\n");
if (v4l2_chip_match_host(reg->match_type, reg->match_chip))
return cx18_cxc(cx, VIDIOC_DBG_S_REGISTER, reg);
if (reg->match_type == V4L2_CHIP_MATCH_I2C_DRIVER)
return cx18_i2c_id(cx, reg->match_chip, VIDIOC_DBG_S_REGISTER,
reg);
return cx18_call_i2c_client(cx, reg->match_chip, VIDIOC_DBG_S_REGISTER,
reg);
}
static int cx18_g_priority(struct file *file, void *fh, enum v4l2_priority *p)
{
struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
CX18_DEBUG_IOCTL("VIDIOC_G_PRIORITY\n");
*p = v4l2_prio_max(&cx->prio);
return 0; return 0;
} }
int cx18_v4l2_ioctls(struct cx18 *cx, struct file *filp, unsigned cmd, void *arg) static int cx18_s_priority(struct file *file, void *fh, enum v4l2_priority prio)
{ {
struct cx18_open_id *id = NULL; struct cx18_open_id *id = fh;
struct cx18 *cx = id->cx;
if (filp) CX18_DEBUG_IOCTL("VIDIOC_S_PRIORITY\n");
id = (struct cx18_open_id *)filp->private_data;
switch (cmd) { return v4l2_prio_change(&cx->prio, &id->prio, prio);
case VIDIOC_G_PRIORITY: }
{
enum v4l2_priority *p = arg;
*p = v4l2_prio_max(&cx->prio); static int cx18_querycap(struct file *file, void *fh,
break; struct v4l2_capability *vcap)
} {
struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
case VIDIOC_S_PRIORITY: CX18_DEBUG_IOCTL("VIDIOC_QUERYCAP\n");
{
enum v4l2_priority *prio = arg;
return v4l2_prio_change(&cx->prio, &id->prio, *prio); strlcpy(vcap->driver, CX18_DRIVER_NAME, sizeof(vcap->driver));
} strlcpy(vcap->card, cx->card_name, sizeof(vcap->card));
strlcpy(vcap->bus_info, pci_name(cx->dev), sizeof(vcap->bus_info));
vcap->version = CX18_DRIVER_VERSION; /* version */
vcap->capabilities = cx->v4l2_cap; /* capabilities */
return 0;
}
case VIDIOC_QUERYCAP:{ static int cx18_enumaudio(struct file *file, void *fh, struct v4l2_audio *vin)
struct v4l2_capability *vcap = arg; {
struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
memset(vcap, 0, sizeof(*vcap)); CX18_DEBUG_IOCTL("VIDIOC_ENUMAUDIO\n");
strlcpy(vcap->driver, CX18_DRIVER_NAME, sizeof(vcap->driver));
strlcpy(vcap->card, cx->card_name, sizeof(vcap->card));
strlcpy(vcap->bus_info, pci_name(cx->dev), sizeof(vcap->bus_info));
vcap->version = CX18_DRIVER_VERSION; /* version */
vcap->capabilities = cx->v4l2_cap; /* capabilities */
/* reserved.. must set to 0! */ return cx18_get_audio_input(cx, vin->index, vin);
vcap->reserved[0] = vcap->reserved[1] = }
vcap->reserved[2] = vcap->reserved[3] = 0;
break;
}
case VIDIOC_ENUMAUDIO:{ static int cx18_g_audio(struct file *file, void *fh, struct v4l2_audio *vin)
struct v4l2_audio *vin = arg; {
struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
return cx18_get_audio_input(cx, vin->index, vin); CX18_DEBUG_IOCTL("VIDIOC_G_AUDIO\n");
}
case VIDIOC_G_AUDIO:{ vin->index = cx->audio_input;
struct v4l2_audio *vin = arg; return cx18_get_audio_input(cx, vin->index, vin);
}
vin->index = cx->audio_input; static int cx18_s_audio(struct file *file, void *fh, struct v4l2_audio *vout)
return cx18_get_audio_input(cx, vin->index, vin); {
} struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
case VIDIOC_S_AUDIO:{ CX18_DEBUG_IOCTL("VIDIOC_S_AUDIO\n");
struct v4l2_audio *vout = arg;
if (vout->index >= cx->nof_audio_inputs) if (vout->index >= cx->nof_audio_inputs)
return -EINVAL; return -EINVAL;
cx->audio_input = vout->index; cx->audio_input = vout->index;
cx18_audio_set_io(cx); cx18_audio_set_io(cx);
break; return 0;
} }
case VIDIOC_ENUMINPUT:{ static int cx18_enum_input(struct file *file, void *fh, struct v4l2_input *vin)
struct v4l2_input *vin = arg; {
struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
/* set it to defaults from our table */ CX18_DEBUG_IOCTL("VIDIOC_ENUMINPUT\n");
return cx18_get_input(cx, vin->index, vin);
}
case VIDIOC_TRY_FMT: /* set it to defaults from our table */
case VIDIOC_S_FMT: { return cx18_get_input(cx, vin->index, vin);
struct v4l2_format *fmt = arg; }
return cx18_try_or_set_fmt(cx, id->type, fmt, cmd == VIDIOC_S_FMT); static int cx18_cropcap(struct file *file, void *fh,
} struct v4l2_cropcap *cropcap)
{
struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
case VIDIOC_G_FMT: { CX18_DEBUG_IOCTL("VIDIOC_CROPCAP\n");
struct v4l2_format *fmt = arg;
int type = fmt->type;
memset(fmt, 0, sizeof(*fmt)); if (cropcap->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
fmt->type = type; return -EINVAL;
return cx18_get_fmt(cx, id->type, fmt); cropcap->bounds.top = cropcap->bounds.left = 0;
} cropcap->bounds.width = 720;
cropcap->bounds.height = cx->is_50hz ? 576 : 480;
cropcap->pixelaspect.numerator = cx->is_50hz ? 59 : 10;
cropcap->pixelaspect.denominator = cx->is_50hz ? 54 : 11;
cropcap->defrect = cropcap->bounds;
return 0;
}
case VIDIOC_CROPCAP: { static int cx18_s_crop(struct file *file, void *fh, struct v4l2_crop *crop)
struct v4l2_cropcap *cropcap = arg; {
struct cx18_open_id *id = fh;
if (cropcap->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) struct cx18 *cx = id->cx;
return -EINVAL; int ret;
cropcap->bounds.top = cropcap->bounds.left = 0;
cropcap->bounds.width = 720;
cropcap->bounds.height = cx->is_50hz ? 576 : 480;
cropcap->pixelaspect.numerator = cx->is_50hz ? 59 : 10;
cropcap->pixelaspect.denominator = cx->is_50hz ? 54 : 11;
cropcap->defrect = cropcap->bounds;
return 0;
}
case VIDIOC_S_CROP: { ret = v4l2_prio_check(&cx->prio, &id->prio);
struct v4l2_crop *crop = arg; if (ret)
return ret;
if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) CX18_DEBUG_IOCTL("VIDIOC_S_CROP\n");
return -EINVAL;
return cx18_av_cmd(cx, VIDIOC_S_CROP, arg);
}
case VIDIOC_G_CROP: { if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
struct v4l2_crop *crop = arg; return -EINVAL;
return cx18_av_cmd(cx, VIDIOC_S_CROP, crop);
}
if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) static int cx18_g_crop(struct file *file, void *fh, struct v4l2_crop *crop)
return -EINVAL; {
return cx18_av_cmd(cx, VIDIOC_G_CROP, arg); struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
}
case VIDIOC_ENUM_FMT: { CX18_DEBUG_IOCTL("VIDIOC_G_CROP\n");
static struct v4l2_fmtdesc formats[] = {
{ 0, 0, 0, if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
"HM12 (YUV 4:1:1)", V4L2_PIX_FMT_HM12, return -EINVAL;
{ 0, 0, 0, 0 } return cx18_av_cmd(cx, VIDIOC_G_CROP, crop);
}, }
{ 1, 0, V4L2_FMT_FLAG_COMPRESSED,
"MPEG", V4L2_PIX_FMT_MPEG, static int cx18_enum_fmt_vid_cap(struct file *file, void *fh,
{ 0, 0, 0, 0 } struct v4l2_fmtdesc *fmt)
} {
}; static struct v4l2_fmtdesc formats[] = {
struct v4l2_fmtdesc *fmt = arg; { 0, V4L2_BUF_TYPE_VIDEO_CAPTURE, 0,
enum v4l2_buf_type type = fmt->type; "HM12 (YUV 4:1:1)", V4L2_PIX_FMT_HM12, { 0, 0, 0, 0 }
},
switch (type) { { 1, V4L2_BUF_TYPE_VIDEO_CAPTURE, V4L2_FMT_FLAG_COMPRESSED,
case V4L2_BUF_TYPE_VIDEO_CAPTURE: "MPEG", V4L2_PIX_FMT_MPEG, { 0, 0, 0, 0 }
break;
default:
return -EINVAL;
} }
if (fmt->index > 1) };
return -EINVAL;
*fmt = formats[fmt->index]; struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
fmt->type = type;
CX18_DEBUG_IOCTL("VIDIOC_ENUM_FMT: V4L2_BUF_TYPE_VIDEO_CAPTURE\n");
if (fmt->index > 1)
return -EINVAL;
*fmt = formats[fmt->index];
return 0;
}
static int cx18_g_input(struct file *file, void *fh, unsigned int *i)
{
struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
CX18_DEBUG_IOCTL("VIDIOC_G_INPUT\n");
*i = cx->active_input;
return 0;
}
int cx18_s_input(struct file *file, void *fh, unsigned int inp)
{
struct cx18_open_id *id = fh;
struct cx18 *cx = id->cx;
int ret;
ret = v4l2_prio_check(&cx->prio, &id->prio);
if (ret)
return ret;
CX18_DEBUG_IOCTL("VIDIOC_S_INPUT\n");
if (inp < 0 || inp >= cx->nof_inputs)
return -EINVAL;
if (inp == cx->active_input) {
CX18_DEBUG_INFO("Input unchanged\n");
return 0; return 0;
} }
case VIDIOC_G_INPUT:{ CX18_DEBUG_INFO("Changing input from %d to %d\n",
*(int *)arg = cx->active_input; cx->active_input, inp);
break;
}
case VIDIOC_S_INPUT:{ cx->active_input = inp;
int inp = *(int *)arg; /* Set the audio input to whatever is appropriate for the input type. */
cx->audio_input = cx->card->video_inputs[inp].audio_index;
if (inp < 0 || inp >= cx->nof_inputs) /* prevent others from messing with the streams until
return -EINVAL; we're finished changing inputs. */
cx18_mute(cx);
cx18_video_set_io(cx);
cx18_audio_set_io(cx);
cx18_unmute(cx);
return 0;
}
if (inp == cx->active_input) { static int cx18_g_frequency(struct file *file, void *fh,
CX18_DEBUG_INFO("Input unchanged\n"); struct v4l2_frequency *vf)
break; {
} struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
CX18_DEBUG_INFO("Changing input from %d to %d\n",
cx->active_input, inp);
cx->active_input = inp; CX18_DEBUG_IOCTL("VIDIOC_G_FREQUENCY\n");
/* Set the audio input to whatever is appropriate for the
input type. */
cx->audio_input = cx->card->video_inputs[inp].audio_index;
/* prevent others from messing with the streams until if (vf->tuner != 0)
we're finished changing inputs. */ return -EINVAL;
cx18_mute(cx);
cx18_video_set_io(cx);
cx18_audio_set_io(cx);
cx18_unmute(cx);
break;
}
case VIDIOC_G_FREQUENCY:{ cx18_call_i2c_clients(cx, VIDIOC_G_FREQUENCY, vf);
struct v4l2_frequency *vf = arg; return 0;
}
if (vf->tuner != 0) int cx18_s_frequency(struct file *file, void *fh, struct v4l2_frequency *vf)
return -EINVAL; {
cx18_call_i2c_clients(cx, cmd, arg); struct cx18_open_id *id = fh;
break; struct cx18 *cx = id->cx;
} int ret;
case VIDIOC_S_FREQUENCY:{ ret = v4l2_prio_check(&cx->prio, &id->prio);
struct v4l2_frequency vf = *(struct v4l2_frequency *)arg; if (ret)
return ret;
if (vf.tuner != 0) CX18_DEBUG_IOCTL("VIDIOC_S_FREQUENCY\n");
return -EINVAL;
cx18_mute(cx); if (vf->tuner != 0)
CX18_DEBUG_INFO("v4l2 ioctl: set frequency %d\n", vf.frequency); return -EINVAL;
cx18_call_i2c_clients(cx, cmd, &vf);
cx18_unmute(cx);
break;
}
case VIDIOC_ENUMSTD:{ cx18_mute(cx);
struct v4l2_standard *vs = arg; CX18_DEBUG_INFO("v4l2 ioctl: set frequency %d\n", vf->frequency);
int idx = vs->index; cx18_call_i2c_clients(cx, VIDIOC_S_FREQUENCY, vf);
cx18_unmute(cx);
return 0;
}
if (idx < 0 || idx >= ARRAY_SIZE(enum_stds)) static int cx18_g_std(struct file *file, void *fh, v4l2_std_id *std)
return -EINVAL; {
struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
*vs = (enum_stds[idx].std & V4L2_STD_525_60) ? CX18_DEBUG_IOCTL("VIDIOC_G_STD\n");
cx18_std_60hz : cx18_std_50hz;
vs->index = idx;
vs->id = enum_stds[idx].std;
strlcpy(vs->name, enum_stds[idx].name, sizeof(vs->name));
break;
}
case VIDIOC_G_STD:{ *std = cx->std;
*(v4l2_std_id *) arg = cx->std; return 0;
break; }
}
case VIDIOC_S_STD: { int cx18_s_std(struct file *file, void *fh, v4l2_std_id *std)
v4l2_std_id std = *(v4l2_std_id *) arg; {
struct cx18_open_id *id = fh;
struct cx18 *cx = id->cx;
int ret;
if ((std & V4L2_STD_ALL) == 0) ret = v4l2_prio_check(&cx->prio, &id->prio);
return -EINVAL; if (ret)
return ret;
if (std == cx->std) CX18_DEBUG_IOCTL("VIDIOC_S_STD\n");
break;
if (test_bit(CX18_F_I_RADIO_USER, &cx->i_flags) || if ((*std & V4L2_STD_ALL) == 0)
atomic_read(&cx->ana_capturing) > 0) { return -EINVAL;
/* Switching standard would turn off the radio or mess
with already running streams, prevent that by
returning EBUSY. */
return -EBUSY;
}
cx->std = std; if (*std == cx->std)
cx->is_60hz = (std & V4L2_STD_525_60) ? 1 : 0; return 0;
cx->params.is_50hz = cx->is_50hz = !cx->is_60hz;
cx->params.width = 720; if (test_bit(CX18_F_I_RADIO_USER, &cx->i_flags) ||
cx->params.height = cx->is_50hz ? 576 : 480; atomic_read(&cx->ana_capturing) > 0) {
cx->vbi.count = cx->is_50hz ? 18 : 12; /* Switching standard would turn off the radio or mess
cx->vbi.start[0] = cx->is_50hz ? 6 : 10; with already running streams, prevent that by
cx->vbi.start[1] = cx->is_50hz ? 318 : 273; returning EBUSY. */
cx->vbi.sliced_decoder_line_size = cx->is_60hz ? 272 : 284; return -EBUSY;
CX18_DEBUG_INFO("Switching standard to %llx.\n", (unsigned long long)cx->std);
/* Tuner */
cx18_call_i2c_clients(cx, VIDIOC_S_STD, &cx->std);
break;
} }
case VIDIOC_S_TUNER: { /* Setting tuner can only set audio mode */ cx->std = *std;
struct v4l2_tuner *vt = arg; cx->is_60hz = (*std & V4L2_STD_525_60) ? 1 : 0;
cx->params.is_50hz = cx->is_50hz = !cx->is_60hz;
cx->params.width = 720;
cx->params.height = cx->is_50hz ? 576 : 480;
cx->vbi.count = cx->is_50hz ? 18 : 12;
cx->vbi.start[0] = cx->is_50hz ? 6 : 10;
cx->vbi.start[1] = cx->is_50hz ? 318 : 273;
cx->vbi.sliced_decoder_line_size = cx->is_60hz ? 272 : 284;
CX18_DEBUG_INFO("Switching standard to %llx.\n",
(unsigned long long) cx->std);
/* Tuner */
cx18_call_i2c_clients(cx, VIDIOC_S_STD, &cx->std);
return 0;
}
if (vt->index != 0) static int cx18_s_tuner(struct file *file, void *fh, struct v4l2_tuner *vt)
return -EINVAL; {
struct cx18_open_id *id = fh;
struct cx18 *cx = id->cx;
int ret;
cx18_call_i2c_clients(cx, VIDIOC_S_TUNER, vt); ret = v4l2_prio_check(&cx->prio, &id->prio);
break; if (ret)
return ret;
CX18_DEBUG_IOCTL("VIDIOC_S_TUNER\n");
if (vt->index != 0)
return -EINVAL;
/* Setting tuner can only set audio mode */
cx18_call_i2c_clients(cx, VIDIOC_S_TUNER, vt);
return 0;
}
static int cx18_g_tuner(struct file *file, void *fh, struct v4l2_tuner *vt)
{
struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
CX18_DEBUG_IOCTL("VIDIOC_G_TUNER\n");
if (vt->index != 0)
return -EINVAL;
cx18_call_i2c_clients(cx, VIDIOC_G_TUNER, vt);
if (test_bit(CX18_F_I_RADIO_USER, &cx->i_flags)) {
strlcpy(vt->name, "cx18 Radio Tuner", sizeof(vt->name));
vt->type = V4L2_TUNER_RADIO;
} else {
strlcpy(vt->name, "cx18 TV Tuner", sizeof(vt->name));
vt->type = V4L2_TUNER_ANALOG_TV;
} }
case VIDIOC_G_TUNER: { return 0;
struct v4l2_tuner *vt = arg; }
static int cx18_g_sliced_vbi_cap(struct file *file, void *fh,
struct v4l2_sliced_vbi_cap *cap)
{
return -EINVAL;
}
if (vt->index != 0) static int cx18_g_enc_index(struct file *file, void *fh,
return -EINVAL; struct v4l2_enc_idx *idx)
{
return -EINVAL;
}
memset(vt, 0, sizeof(*vt)); static int cx18_encoder_cmd(struct file *file, void *fh,
cx18_call_i2c_clients(cx, VIDIOC_G_TUNER, vt); struct v4l2_encoder_cmd *enc)
{
struct cx18_open_id *id = fh;
struct cx18 *cx = id->cx;
if (test_bit(CX18_F_I_RADIO_USER, &cx->i_flags)) { CX18_DEBUG_IOCTL("VIDIOC_ENCODER_CMD:\n");
strlcpy(vt->name, "cx18 Radio Tuner", sizeof(vt->name));
vt->type = V4L2_TUNER_RADIO; memset(&enc->raw, 0, sizeof(enc->raw));
} else {
strlcpy(vt->name, "cx18 TV Tuner", sizeof(vt->name)); switch (enc->cmd) {
vt->type = V4L2_TUNER_ANALOG_TV; case V4L2_ENC_CMD_START:
} CX18_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
enc->flags = 0;
return cx18_start_capture(id);
case V4L2_ENC_CMD_STOP:
CX18_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END;
cx18_stop_capture(id,
enc->flags & V4L2_ENC_CMD_STOP_AT_GOP_END);
break; break;
}
case VIDIOC_G_SLICED_VBI_CAP: { case V4L2_ENC_CMD_PAUSE:
struct v4l2_sliced_vbi_cap *cap = arg; CX18_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
int set = cx->is_50hz ? V4L2_SLICED_VBI_625 : V4L2_SLICED_VBI_525; enc->flags = 0;
int f, l; if (!atomic_read(&cx->ana_capturing))
enum v4l2_buf_type type = cap->type; return -EPERM;
if (test_and_set_bit(CX18_F_I_ENC_PAUSED, &cx->i_flags))
memset(cap, 0, sizeof(*cap));
cap->type = type;
if (type == V4L2_BUF_TYPE_SLICED_VBI_CAPTURE) {
for (f = 0; f < 2; f++) {
for (l = 0; l < 24; l++) {
if (valid_service_line(f, l, cx->is_50hz))
cap->service_lines[f][l] = set;
}
}
return 0; return 0;
} cx18_mute(cx);
cx18_vapi(cx, CX18_CPU_CAPTURE_PAUSE, 1, cx18_find_handle(cx));
break;
case V4L2_ENC_CMD_RESUME:
CX18_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
enc->flags = 0;
if (!atomic_read(&cx->ana_capturing))
return -EPERM;
if (!test_and_clear_bit(CX18_F_I_ENC_PAUSED, &cx->i_flags))
return 0;
cx18_vapi(cx, CX18_CPU_CAPTURE_RESUME, 1, cx18_find_handle(cx));
cx18_unmute(cx);
break;
default:
CX18_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd);
return -EINVAL; return -EINVAL;
} }
return 0;
}
case VIDIOC_ENCODER_CMD: static int cx18_try_encoder_cmd(struct file *file, void *fh,
case VIDIOC_TRY_ENCODER_CMD: { struct v4l2_encoder_cmd *enc)
struct v4l2_encoder_cmd *enc = arg; {
int try = cmd == VIDIOC_TRY_ENCODER_CMD; struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
memset(&enc->raw, 0, sizeof(enc->raw));
switch (enc->cmd) {
case V4L2_ENC_CMD_START:
enc->flags = 0;
if (try)
return 0;
return cx18_start_capture(id);
case V4L2_ENC_CMD_STOP:
enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END;
if (try)
return 0;
cx18_stop_capture(id, enc->flags & V4L2_ENC_CMD_STOP_AT_GOP_END);
return 0;
case V4L2_ENC_CMD_PAUSE: CX18_DEBUG_IOCTL("VIDIOC_TRY_ENCDOER_CMD:\n");
enc->flags = 0;
if (try) memset(&enc->raw, 0, sizeof(enc->raw));
return 0;
if (!atomic_read(&cx->ana_capturing)) switch (enc->cmd) {
return -EPERM; case V4L2_ENC_CMD_START:
if (test_and_set_bit(CX18_F_I_ENC_PAUSED, &cx->i_flags)) CX18_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
return 0; enc->flags = 0;
cx18_mute(cx);
cx18_vapi(cx, CX18_CPU_CAPTURE_PAUSE, 1, cx18_find_handle(cx));
break;
case V4L2_ENC_CMD_RESUME:
enc->flags = 0;
if (try)
return 0;
if (!atomic_read(&cx->ana_capturing))
return -EPERM;
if (!test_and_clear_bit(CX18_F_I_ENC_PAUSED, &cx->i_flags))
return 0;
cx18_vapi(cx, CX18_CPU_CAPTURE_RESUME, 1, cx18_find_handle(cx));
cx18_unmute(cx);
break;
default:
return -EINVAL;
}
break; break;
}
case VIDIOC_LOG_STATUS: case V4L2_ENC_CMD_STOP:
{ CX18_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
struct v4l2_input vidin; enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END;
struct v4l2_audio audin; break;
int i;
CX18_INFO("================= START STATUS CARD #%d =================\n", cx->num); case V4L2_ENC_CMD_PAUSE:
if (cx->hw_flags & CX18_HW_TVEEPROM) { CX18_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
struct tveeprom tv; enc->flags = 0;
break;
cx18_read_eeprom(cx, &tv); case V4L2_ENC_CMD_RESUME:
} CX18_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
cx18_call_i2c_clients(cx, VIDIOC_LOG_STATUS, NULL); enc->flags = 0;
cx18_get_input(cx, cx->active_input, &vidin);
cx18_get_audio_input(cx, cx->audio_input, &audin);
CX18_INFO("Video Input: %s\n", vidin.name);
CX18_INFO("Audio Input: %s\n", audin.name);
CX18_INFO("Tuner: %s\n",
test_bit(CX18_F_I_RADIO_USER, &cx->i_flags) ?
"Radio" : "TV");
cx2341x_log_status(&cx->params, cx->name);
CX18_INFO("Status flags: 0x%08lx\n", cx->i_flags);
for (i = 0; i < CX18_MAX_STREAMS; i++) {
struct cx18_stream *s = &cx->streams[i];
if (s->v4l2dev == NULL || s->buffers == 0)
continue;
CX18_INFO("Stream %s: status 0x%04lx, %d%% of %d KiB (%d buffers) in use\n",
s->name, s->s_flags,
(s->buffers - s->q_free.buffers) * 100 / s->buffers,
(s->buffers * s->buf_size) / 1024, s->buffers);
}
CX18_INFO("Read MPEG/VBI: %lld/%lld bytes\n",
(long long)cx->mpg_data_received,
(long long)cx->vbi_data_inserted);
CX18_INFO("================== END STATUS CARD #%d ==================\n", cx->num);
break; break;
}
default: default:
CX18_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd);
return -EINVAL; return -EINVAL;
} }
return 0; return 0;
} }
static int cx18_v4l2_do_ioctl(struct inode *inode, struct file *filp, static int cx18_log_status(struct file *file, void *fh)
unsigned int cmd, void *arg)
{ {
struct cx18_open_id *id = (struct cx18_open_id *)filp->private_data; struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
struct cx18 *cx = id->cx; struct v4l2_input vidin;
int ret; struct v4l2_audio audin;
int i;
/* check priority */ CX18_DEBUG_IOCTL("VIDIOC_LOG_STATUS\n");
switch (cmd) { CX18_INFO("================= START STATUS CARD #%d =================\n", cx->num);
case VIDIOC_S_CTRL: if (cx->hw_flags & CX18_HW_TVEEPROM) {
case VIDIOC_S_STD: struct tveeprom tv;
case VIDIOC_S_INPUT:
case VIDIOC_S_TUNER: cx18_read_eeprom(cx, &tv);
case VIDIOC_S_FREQUENCY: }
case VIDIOC_S_FMT: cx18_call_i2c_clients(cx, VIDIOC_LOG_STATUS, NULL);
case VIDIOC_S_CROP: cx18_get_input(cx, cx->active_input, &vidin);
case VIDIOC_S_EXT_CTRLS: cx18_get_audio_input(cx, cx->audio_input, &audin);
ret = v4l2_prio_check(&cx->prio, &id->prio); CX18_INFO("Video Input: %s\n", vidin.name);
if (ret) CX18_INFO("Audio Input: %s\n", audin.name);
return ret; CX18_INFO("Tuner: %s\n",
} test_bit(CX18_F_I_RADIO_USER, &cx->i_flags) ? "Radio" : "TV");
cx2341x_log_status(&cx->params, cx->name);
CX18_INFO("Status flags: 0x%08lx\n", cx->i_flags);
for (i = 0; i < CX18_MAX_STREAMS; i++) {
struct cx18_stream *s = &cx->streams[i];
if (s->v4l2dev == NULL || s->buffers == 0)
continue;
CX18_INFO("Stream %s: status 0x%04lx, %d%% of %d KiB (%d buffers) in use\n",
s->name, s->s_flags,
(s->buffers - s->q_free.buffers) * 100 / s->buffers,
(s->buffers * s->buf_size) / 1024, s->buffers);
}
CX18_INFO("Read MPEG/VBI: %lld/%lld bytes\n",
(long long)cx->mpg_data_received,
(long long)cx->vbi_data_inserted);
CX18_INFO("================== END STATUS CARD #%d ==================\n", cx->num);
return 0;
}
static int cx18_default(struct file *file, void *fh, int cmd, void *arg)
{
struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
switch (cmd) { switch (cmd) {
case VIDIOC_DBG_G_REGISTER: case VIDIOC_INT_S_AUDIO_ROUTING: {
case VIDIOC_DBG_S_REGISTER: struct v4l2_routing *route = arg;
case VIDIOC_G_CHIP_IDENT: CX18_DEBUG_IOCTL("VIDIOC_INT_S_AUDIO_ROUTING (%d, %d)\n",
case VIDIOC_INT_S_AUDIO_ROUTING: route->input, route->output);
case VIDIOC_INT_RESET: cx18_audio_set_route(cx, route);
if (cx18_debug & CX18_DBGFLG_IOCTL) { break;
printk(KERN_INFO "cx18%d ioctl: ", cx->num); }
v4l_printk_ioctl(cmd); case VIDIOC_INT_RESET: {
} u32 val = *(u32 *)arg;
return cx18_debug_ioctls(filp, cmd, arg); CX18_DEBUG_IOCTL("VIDIOC_INT_RESET (%#10x)\n", val);
/* No op right now */
case VIDIOC_G_PRIORITY: /* cx18_av_cmd(cx, cmd, arg) */
case VIDIOC_S_PRIORITY: /* cx18_call_i2c_clients(cx, cmd, arg) */
case VIDIOC_QUERYCAP: break;
case VIDIOC_ENUMINPUT: }
case VIDIOC_G_INPUT: default:
case VIDIOC_S_INPUT:
case VIDIOC_G_FMT:
case VIDIOC_S_FMT:
case VIDIOC_TRY_FMT:
case VIDIOC_ENUM_FMT:
case VIDIOC_CROPCAP:
case VIDIOC_G_CROP:
case VIDIOC_S_CROP:
case VIDIOC_G_FREQUENCY:
case VIDIOC_S_FREQUENCY:
case VIDIOC_ENUMSTD:
case VIDIOC_G_STD:
case VIDIOC_S_STD:
case VIDIOC_S_TUNER:
case VIDIOC_G_TUNER:
case VIDIOC_ENUMAUDIO:
case VIDIOC_S_AUDIO:
case VIDIOC_G_AUDIO:
case VIDIOC_G_SLICED_VBI_CAP:
case VIDIOC_LOG_STATUS:
case VIDIOC_G_ENC_INDEX:
case VIDIOC_ENCODER_CMD:
case VIDIOC_TRY_ENCODER_CMD:
if (cx18_debug & CX18_DBGFLG_IOCTL) {
printk(KERN_INFO "cx18%d ioctl: ", cx->num);
v4l_printk_ioctl(cmd);
}
return cx18_v4l2_ioctls(cx, filp, cmd, arg);
case VIDIOC_QUERYMENU:
case VIDIOC_QUERYCTRL:
case VIDIOC_S_CTRL:
case VIDIOC_G_CTRL:
case VIDIOC_S_EXT_CTRLS:
case VIDIOC_G_EXT_CTRLS:
case VIDIOC_TRY_EXT_CTRLS:
if (cx18_debug & CX18_DBGFLG_IOCTL) { if (cx18_debug & CX18_DBGFLG_IOCTL) {
printk(KERN_INFO "cx18%d ioctl: ", cx->num); printk(KERN_INFO "cx18%d ioctl: unsupported cmd: ",
cx->num);
v4l_printk_ioctl(cmd); v4l_printk_ioctl(cmd);
printk("\n");
} }
return cx18_control_ioctls(cx, cmd, arg);
case 0x00005401: /* Handle isatty() calls */
return -EINVAL; return -EINVAL;
default:
return v4l_compat_translate_ioctl(inode, filp, cmd, arg,
cx18_v4l2_do_ioctl);
} }
return 0; return 0;
} }
...@@ -845,7 +840,55 @@ int cx18_v4l2_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, ...@@ -845,7 +840,55 @@ int cx18_v4l2_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
int res; int res;
mutex_lock(&cx->serialize_lock); mutex_lock(&cx->serialize_lock);
res = video_usercopy(inode, filp, cmd, arg, cx18_v4l2_do_ioctl); res = video_ioctl2(inode, filp, cmd, arg);
mutex_unlock(&cx->serialize_lock); mutex_unlock(&cx->serialize_lock);
return res; return res;
} }
void cx18_set_funcs(struct video_device *vdev)
{
vdev->vidioc_querycap = cx18_querycap;
vdev->vidioc_g_priority = cx18_g_priority;
vdev->vidioc_s_priority = cx18_s_priority;
vdev->vidioc_s_audio = cx18_s_audio;
vdev->vidioc_g_audio = cx18_g_audio;
vdev->vidioc_enumaudio = cx18_enumaudio;
vdev->vidioc_enum_input = cx18_enum_input;
vdev->vidioc_cropcap = cx18_cropcap;
vdev->vidioc_s_crop = cx18_s_crop;
vdev->vidioc_g_crop = cx18_g_crop;
vdev->vidioc_g_input = cx18_g_input;
vdev->vidioc_s_input = cx18_s_input;
vdev->vidioc_g_frequency = cx18_g_frequency;
vdev->vidioc_s_frequency = cx18_s_frequency;
vdev->vidioc_s_tuner = cx18_s_tuner;
vdev->vidioc_g_tuner = cx18_g_tuner;
vdev->vidioc_g_enc_index = cx18_g_enc_index;
vdev->vidioc_g_std = cx18_g_std;
vdev->vidioc_s_std = cx18_s_std;
vdev->vidioc_log_status = cx18_log_status;
vdev->vidioc_enum_fmt_vid_cap = cx18_enum_fmt_vid_cap;
vdev->vidioc_encoder_cmd = cx18_encoder_cmd;
vdev->vidioc_try_encoder_cmd = cx18_try_encoder_cmd;
vdev->vidioc_g_fmt_vid_cap = cx18_g_fmt_vid_cap;
vdev->vidioc_g_fmt_vbi_cap = cx18_g_fmt_vbi_cap;
vdev->vidioc_g_fmt_sliced_vbi_cap = cx18_g_fmt_sliced_vbi_cap;
vdev->vidioc_s_fmt_vid_cap = cx18_s_fmt_vid_cap;
vdev->vidioc_s_fmt_vbi_cap = cx18_s_fmt_vbi_cap;
vdev->vidioc_s_fmt_sliced_vbi_cap = cx18_s_fmt_sliced_vbi_cap;
vdev->vidioc_try_fmt_vid_cap = cx18_try_fmt_vid_cap;
vdev->vidioc_try_fmt_vbi_cap = cx18_try_fmt_vbi_cap;
vdev->vidioc_try_fmt_sliced_vbi_cap = cx18_try_fmt_sliced_vbi_cap;
vdev->vidioc_g_sliced_vbi_cap = cx18_g_sliced_vbi_cap;
vdev->vidioc_g_chip_ident = cx18_g_chip_ident;
vdev->vidioc_g_register = cx18_g_register;
vdev->vidioc_s_register = cx18_s_register;
vdev->vidioc_default = cx18_default;
vdev->vidioc_queryctrl = cx18_queryctrl;
vdev->vidioc_querymenu = cx18_querymenu;
vdev->vidioc_g_ctrl = cx18_g_ctrl;
vdev->vidioc_s_ctrl = cx18_s_ctrl;
vdev->vidioc_g_ext_ctrls = cx18_g_ext_ctrls;
vdev->vidioc_s_ext_ctrls = cx18_s_ext_ctrls;
vdev->vidioc_try_ext_ctrls = cx18_try_ext_ctrls;
}
drivers/media/video/cx18/cx18-ioctl.h
View file @ 3b6fe58f
...@@ -24,7 +24,9 @@ ...@@ -24,7 +24,9 @@
u16 cx18_service2vbi(int type); u16 cx18_service2vbi(int type);
void cx18_expand_service_set(struct v4l2_sliced_vbi_format *fmt, int is_pal); void cx18_expand_service_set(struct v4l2_sliced_vbi_format *fmt, int is_pal);
u16 cx18_get_service_set(struct v4l2_sliced_vbi_format *fmt); u16 cx18_get_service_set(struct v4l2_sliced_vbi_format *fmt);
void cx18_set_funcs(struct video_device *vdev);
int cx18_s_std(struct file *file, void *fh, v4l2_std_id *std);
int cx18_s_frequency(struct file *file, void *fh, struct v4l2_frequency *vf);
int cx18_s_input(struct file *file, void *fh, unsigned int inp);
int cx18_v4l2_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, int cx18_v4l2_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
unsigned long arg); unsigned long arg);
int cx18_v4l2_ioctls(struct cx18 *cx, struct file *filp, unsigned cmd,
void *arg);
drivers/media/video/cx18/cx18-streams.c
View file @ 3b6fe58f
...@@ -39,6 +39,7 @@ static struct file_operations cx18_v4l2_enc_fops = { ...@@ -39,6 +39,7 @@ static struct file_operations cx18_v4l2_enc_fops = {
.owner = THIS_MODULE, .owner = THIS_MODULE,
.read = cx18_v4l2_read, .read = cx18_v4l2_read,
.open = cx18_v4l2_open, .open = cx18_v4l2_open,
/* FIXME change to video_ioctl2 if serialization lock can be removed */
.ioctl = cx18_v4l2_ioctl, .ioctl = cx18_v4l2_ioctl,
.compat_ioctl = v4l_compat_ioctl32, .compat_ioctl = v4l_compat_ioctl32,
.release = cx18_v4l2_close, .release = cx18_v4l2_close,
...@@ -196,7 +197,8 @@ static int cx18_prep_dev(struct cx18 *cx, int type) ...@@ -196,7 +197,8 @@ static int cx18_prep_dev(struct cx18 *cx, int type)
s->v4l2dev->dev = &cx->dev->dev; s->v4l2dev->dev = &cx->dev->dev;
s->v4l2dev->fops = cx18_stream_info[type].fops; s->v4l2dev->fops = cx18_stream_info[type].fops;
s->v4l2dev->release = video_device_release; s->v4l2dev->release = video_device_release;
s->v4l2dev->tvnorms = V4L2_STD_ALL;
cx18_set_funcs(s->v4l2dev);
return 0; return 0;
} }
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7