Commit | Line | Data |
---|---|---|
1c1e45d1 HV |
1 | /* |
2 | * cx18 ioctl control functions | |
3 | * | |
4 | * Derived from ivtv-controls.c | |
5 | * | |
6 | * Copyright (C) 2007 Hans Verkuil <hverkuil@xs4all.nl> | |
7 | * | |
8 | * This program is free software; you can redistribute it and/or modify | |
9 | * it under the terms of the GNU General Public License as published by | |
10 | * the Free Software Foundation; either version 2 of the License, or | |
11 | * (at your option) any later version. | |
12 | * | |
13 | * This program is distributed in the hope that it will be useful, | |
14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
16 | * GNU General Public License for more details. | |
17 | * | |
18 | * You should have received a copy of the GNU General Public License | |
19 | * along with this program; if not, write to the Free Software | |
20 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA | |
21 | * 02111-1307 USA | |
22 | */ | |
23 | ||
24 | #include "cx18-driver.h" | |
25 | #include "cx18-av-core.h" | |
26 | #include "cx18-cards.h" | |
27 | #include "cx18-ioctl.h" | |
28 | #include "cx18-audio.h" | |
29 | #include "cx18-i2c.h" | |
30 | #include "cx18-mailbox.h" | |
31 | #include "cx18-controls.h" | |
32 | ||
33 | static const u32 user_ctrls[] = { | |
34 | V4L2_CID_USER_CLASS, | |
35 | V4L2_CID_BRIGHTNESS, | |
36 | V4L2_CID_CONTRAST, | |
37 | V4L2_CID_SATURATION, | |
38 | V4L2_CID_HUE, | |
39 | V4L2_CID_AUDIO_VOLUME, | |
40 | V4L2_CID_AUDIO_BALANCE, | |
41 | V4L2_CID_AUDIO_BASS, | |
42 | V4L2_CID_AUDIO_TREBLE, | |
43 | V4L2_CID_AUDIO_MUTE, | |
44 | V4L2_CID_AUDIO_LOUDNESS, | |
45 | 0 | |
46 | }; | |
47 | ||
48 | static const u32 *ctrl_classes[] = { | |
49 | user_ctrls, | |
50 | cx2341x_mpeg_ctrls, | |
51 | NULL | |
52 | }; | |
53 | ||
54 | static int cx18_queryctrl(struct cx18 *cx, struct v4l2_queryctrl *qctrl) | |
55 | { | |
56 | const char *name; | |
57 | ||
58 | CX18_DEBUG_IOCTL("VIDIOC_QUERYCTRL(%08x)\n", qctrl->id); | |
59 | ||
60 | qctrl->id = v4l2_ctrl_next(ctrl_classes, qctrl->id); | |
61 | if (qctrl->id == 0) | |
62 | return -EINVAL; | |
63 | ||
64 | switch (qctrl->id) { | |
65 | /* Standard V4L2 controls */ | |
66 | case V4L2_CID_BRIGHTNESS: | |
67 | case V4L2_CID_HUE: | |
68 | case V4L2_CID_SATURATION: | |
69 | case V4L2_CID_CONTRAST: | |
70 | if (cx18_av_cmd(cx, VIDIOC_QUERYCTRL, qctrl)) | |
71 | qctrl->flags |= V4L2_CTRL_FLAG_DISABLED; | |
72 | return 0; | |
73 | ||
74 | case V4L2_CID_AUDIO_VOLUME: | |
75 | case V4L2_CID_AUDIO_MUTE: | |
76 | case V4L2_CID_AUDIO_BALANCE: | |
77 | case V4L2_CID_AUDIO_BASS: | |
78 | case V4L2_CID_AUDIO_TREBLE: | |
79 | case V4L2_CID_AUDIO_LOUDNESS: | |
80 | if (cx18_i2c_hw(cx, cx->card->hw_audio_ctrl, VIDIOC_QUERYCTRL, qctrl)) | |
81 | qctrl->flags |= V4L2_CTRL_FLAG_DISABLED; | |
82 | return 0; | |
83 | ||
84 | default: | |
85 | if (cx2341x_ctrl_query(&cx->params, qctrl)) | |
86 | qctrl->flags |= V4L2_CTRL_FLAG_DISABLED; | |
87 | return 0; | |
88 | } | |
89 | strncpy(qctrl->name, name, sizeof(qctrl->name) - 1); | |
90 | qctrl->name[sizeof(qctrl->name) - 1] = 0; | |
91 | return 0; | |
92 | } | |
93 | ||
94 | static int cx18_querymenu(struct cx18 *cx, struct v4l2_querymenu *qmenu) | |
95 | { | |
96 | struct v4l2_queryctrl qctrl; | |
97 | ||
98 | qctrl.id = qmenu->id; | |
99 | cx18_queryctrl(cx, &qctrl); | |
100 | return v4l2_ctrl_query_menu(qmenu, &qctrl, cx2341x_ctrl_get_menu(qmenu->id)); | |
101 | } | |
102 | ||
103 | static int cx18_s_ctrl(struct cx18 *cx, struct v4l2_control *vctrl) | |
104 | { | |
105 | s32 v = vctrl->value; | |
106 | ||
107 | CX18_DEBUG_IOCTL("VIDIOC_S_CTRL(%08x, %x)\n", vctrl->id, v); | |
108 | ||
109 | switch (vctrl->id) { | |
110 | /* Standard V4L2 controls */ | |
111 | case V4L2_CID_BRIGHTNESS: | |
112 | case V4L2_CID_HUE: | |
113 | case V4L2_CID_SATURATION: | |
114 | case V4L2_CID_CONTRAST: | |
115 | return cx18_av_cmd(cx, VIDIOC_S_CTRL, vctrl); | |
116 | ||
117 | case V4L2_CID_AUDIO_VOLUME: | |
118 | case V4L2_CID_AUDIO_MUTE: | |
119 | case V4L2_CID_AUDIO_BALANCE: | |
120 | case V4L2_CID_AUDIO_BASS: | |
121 | case V4L2_CID_AUDIO_TREBLE: | |
122 | case V4L2_CID_AUDIO_LOUDNESS: | |
123 | return cx18_i2c_hw(cx, cx->card->hw_audio_ctrl, VIDIOC_S_CTRL, vctrl); | |
124 | ||
125 | default: | |
126 | CX18_DEBUG_IOCTL("invalid control %x\n", vctrl->id); | |
127 | return -EINVAL; | |
128 | } | |
129 | return 0; | |
130 | } | |
131 | ||
132 | static int cx18_g_ctrl(struct cx18 *cx, struct v4l2_control *vctrl) | |
133 | { | |
134 | CX18_DEBUG_IOCTL("VIDIOC_G_CTRL(%08x)\n", vctrl->id); | |
135 | ||
136 | switch (vctrl->id) { | |
137 | /* Standard V4L2 controls */ | |
138 | case V4L2_CID_BRIGHTNESS: | |
139 | case V4L2_CID_HUE: | |
140 | case V4L2_CID_SATURATION: | |
141 | case V4L2_CID_CONTRAST: | |
142 | return cx18_av_cmd(cx, VIDIOC_G_CTRL, vctrl); | |
143 | ||
144 | case V4L2_CID_AUDIO_VOLUME: | |
145 | case V4L2_CID_AUDIO_MUTE: | |
146 | case V4L2_CID_AUDIO_BALANCE: | |
147 | case V4L2_CID_AUDIO_BASS: | |
148 | case V4L2_CID_AUDIO_TREBLE: | |
149 | case V4L2_CID_AUDIO_LOUDNESS: | |
150 | return cx18_i2c_hw(cx, cx->card->hw_audio_ctrl, VIDIOC_G_CTRL, vctrl); | |
151 | default: | |
152 | CX18_DEBUG_IOCTL("invalid control %x\n", vctrl->id); | |
153 | return -EINVAL; | |
154 | } | |
155 | return 0; | |
156 | } | |
157 | ||
158 | static int cx18_setup_vbi_fmt(struct cx18 *cx, enum v4l2_mpeg_stream_vbi_fmt fmt) | |
159 | { | |
160 | if (!(cx->v4l2_cap & V4L2_CAP_SLICED_VBI_CAPTURE)) | |
161 | return -EINVAL; | |
31554ae5 | 162 | if (atomic_read(&cx->ana_capturing) > 0) |
1c1e45d1 HV |
163 | return -EBUSY; |
164 | ||
165 | /* First try to allocate sliced VBI buffers if needed. */ | |
166 | if (fmt && cx->vbi.sliced_mpeg_data[0] == NULL) { | |
167 | int i; | |
168 | ||
169 | for (i = 0; i < CX18_VBI_FRAMES; i++) { | |
170 | /* Yuck, hardcoded. Needs to be a define */ | |
171 | cx->vbi.sliced_mpeg_data[i] = kmalloc(2049, GFP_KERNEL); | |
172 | if (cx->vbi.sliced_mpeg_data[i] == NULL) { | |
173 | while (--i >= 0) { | |
174 | kfree(cx->vbi.sliced_mpeg_data[i]); | |
175 | cx->vbi.sliced_mpeg_data[i] = NULL; | |
176 | } | |
177 | return -ENOMEM; | |
178 | } | |
179 | } | |
180 | } | |
181 | ||
182 | cx->vbi.insert_mpeg = fmt; | |
183 | ||
184 | if (cx->vbi.insert_mpeg == 0) | |
185 | return 0; | |
186 | /* Need sliced data for mpeg insertion */ | |
aed6abd6 | 187 | if (cx18_get_service_set(cx->vbi.sliced_in) == 0) { |
1c1e45d1 HV |
188 | if (cx->is_60hz) |
189 | cx->vbi.sliced_in->service_set = V4L2_SLICED_CAPTION_525; | |
190 | else | |
191 | cx->vbi.sliced_in->service_set = V4L2_SLICED_WSS_625; | |
aed6abd6 | 192 | cx18_expand_service_set(cx->vbi.sliced_in, cx->is_50hz); |
1c1e45d1 HV |
193 | } |
194 | return 0; | |
195 | } | |
196 | ||
197 | int cx18_control_ioctls(struct cx18 *cx, unsigned int cmd, void *arg) | |
198 | { | |
199 | struct v4l2_control ctrl; | |
200 | ||
201 | switch (cmd) { | |
202 | case VIDIOC_QUERYMENU: | |
203 | CX18_DEBUG_IOCTL("VIDIOC_QUERYMENU\n"); | |
204 | return cx18_querymenu(cx, arg); | |
205 | ||
206 | case VIDIOC_QUERYCTRL: | |
207 | return cx18_queryctrl(cx, arg); | |
208 | ||
209 | case VIDIOC_S_CTRL: | |
210 | return cx18_s_ctrl(cx, arg); | |
211 | ||
212 | case VIDIOC_G_CTRL: | |
213 | return cx18_g_ctrl(cx, arg); | |
214 | ||
215 | case VIDIOC_S_EXT_CTRLS: | |
216 | { | |
217 | struct v4l2_ext_controls *c = arg; | |
218 | ||
219 | if (c->ctrl_class == V4L2_CTRL_CLASS_USER) { | |
220 | int i; | |
221 | int err = 0; | |
222 | ||
223 | for (i = 0; i < c->count; i++) { | |
224 | ctrl.id = c->controls[i].id; | |
225 | ctrl.value = c->controls[i].value; | |
226 | err = cx18_s_ctrl(cx, &ctrl); | |
227 | c->controls[i].value = ctrl.value; | |
228 | if (err) { | |
229 | c->error_idx = i; | |
230 | break; | |
231 | } | |
232 | } | |
233 | return err; | |
234 | } | |
235 | CX18_DEBUG_IOCTL("VIDIOC_S_EXT_CTRLS\n"); | |
236 | if (c->ctrl_class == V4L2_CTRL_CLASS_MPEG) { | |
237 | struct cx2341x_mpeg_params p = cx->params; | |
31554ae5 | 238 | int err = cx2341x_ext_ctrls(&p, atomic_read(&cx->ana_capturing), arg, cmd); |
1c1e45d1 HV |
239 | |
240 | if (err) | |
241 | return err; | |
242 | ||
243 | if (p.video_encoding != cx->params.video_encoding) { | |
244 | int is_mpeg1 = p.video_encoding == | |
245 | V4L2_MPEG_VIDEO_ENCODING_MPEG_1; | |
246 | struct v4l2_format fmt; | |
247 | ||
248 | /* fix videodecoder resolution */ | |
249 | fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; | |
250 | fmt.fmt.pix.width = cx->params.width / (is_mpeg1 ? 2 : 1); | |
251 | fmt.fmt.pix.height = cx->params.height; | |
252 | cx18_av_cmd(cx, VIDIOC_S_FMT, &fmt); | |
253 | } | |
254 | err = cx2341x_update(cx, cx18_api_func, &cx->params, &p); | |
255 | if (!err && cx->params.stream_vbi_fmt != p.stream_vbi_fmt) | |
256 | err = cx18_setup_vbi_fmt(cx, p.stream_vbi_fmt); | |
257 | cx->params = p; | |
258 | cx->dualwatch_stereo_mode = p.audio_properties & 0x0300; | |
259 | cx18_audio_set_audio_clock_freq(cx, p.audio_properties & 0x03); | |
260 | return err; | |
261 | } | |
262 | return -EINVAL; | |
263 | } | |
264 | ||
265 | case VIDIOC_G_EXT_CTRLS: | |
266 | { | |
267 | struct v4l2_ext_controls *c = arg; | |
268 | ||
269 | if (c->ctrl_class == V4L2_CTRL_CLASS_USER) { | |
270 | int i; | |
271 | int err = 0; | |
272 | ||
273 | for (i = 0; i < c->count; i++) { | |
274 | ctrl.id = c->controls[i].id; | |
275 | ctrl.value = c->controls[i].value; | |
276 | err = cx18_g_ctrl(cx, &ctrl); | |
277 | c->controls[i].value = ctrl.value; | |
278 | if (err) { | |
279 | c->error_idx = i; | |
280 | break; | |
281 | } | |
282 | } | |
283 | return err; | |
284 | } | |
285 | CX18_DEBUG_IOCTL("VIDIOC_G_EXT_CTRLS\n"); | |
286 | if (c->ctrl_class == V4L2_CTRL_CLASS_MPEG) | |
287 | return cx2341x_ext_ctrls(&cx->params, 0, arg, cmd); | |
288 | return -EINVAL; | |
289 | } | |
290 | ||
291 | case VIDIOC_TRY_EXT_CTRLS: | |
292 | { | |
293 | struct v4l2_ext_controls *c = arg; | |
294 | ||
295 | CX18_DEBUG_IOCTL("VIDIOC_TRY_EXT_CTRLS\n"); | |
296 | if (c->ctrl_class == V4L2_CTRL_CLASS_MPEG) | |
297 | return cx2341x_ext_ctrls(&cx->params, | |
31554ae5 | 298 | atomic_read(&cx->ana_capturing), arg, cmd); |
1c1e45d1 HV |
299 | return -EINVAL; |
300 | } | |
301 | ||
302 | default: | |
303 | return -EINVAL; | |
304 | } | |
305 | return 0; | |
306 | } |