]>
Commit | Line | Data |
---|---|---|
1c1e45d1 HV |
1 | /* |
2 | * cx18 ioctl system call | |
3 | * | |
4 | * Derived from ivtv-ioctl.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-version.h" | |
26 | #include "cx18-mailbox.h" | |
27 | #include "cx18-i2c.h" | |
28 | #include "cx18-queue.h" | |
29 | #include "cx18-fileops.h" | |
30 | #include "cx18-vbi.h" | |
31 | #include "cx18-audio.h" | |
32 | #include "cx18-video.h" | |
33 | #include "cx18-streams.h" | |
34 | #include "cx18-ioctl.h" | |
35 | #include "cx18-gpio.h" | |
36 | #include "cx18-controls.h" | |
37 | #include "cx18-cards.h" | |
38 | #include "cx18-av-core.h" | |
39 | #include <media/tveeprom.h> | |
40 | #include <media/v4l2-chip-ident.h> | |
41 | #include <linux/i2c-id.h> | |
42 | ||
aed6abd6 | 43 | u16 cx18_service2vbi(int type) |
1c1e45d1 HV |
44 | { |
45 | switch (type) { | |
46 | case V4L2_SLICED_TELETEXT_B: | |
47 | return CX18_SLICED_TYPE_TELETEXT_B; | |
48 | case V4L2_SLICED_CAPTION_525: | |
49 | return CX18_SLICED_TYPE_CAPTION_525; | |
50 | case V4L2_SLICED_WSS_625: | |
51 | return CX18_SLICED_TYPE_WSS_625; | |
52 | case V4L2_SLICED_VPS: | |
53 | return CX18_SLICED_TYPE_VPS; | |
54 | default: | |
55 | return 0; | |
56 | } | |
57 | } | |
58 | ||
59 | static int valid_service_line(int field, int line, int is_pal) | |
60 | { | |
61 | return (is_pal && line >= 6 && (line != 23 || field == 0)) || | |
62 | (!is_pal && line >= 10 && line < 22); | |
63 | } | |
64 | ||
65 | static u16 select_service_from_set(int field, int line, u16 set, int is_pal) | |
66 | { | |
67 | u16 valid_set = (is_pal ? V4L2_SLICED_VBI_625 : V4L2_SLICED_VBI_525); | |
68 | int i; | |
69 | ||
70 | set = set & valid_set; | |
71 | if (set == 0 || !valid_service_line(field, line, is_pal)) | |
72 | return 0; | |
73 | if (!is_pal) { | |
74 | if (line == 21 && (set & V4L2_SLICED_CAPTION_525)) | |
75 | return V4L2_SLICED_CAPTION_525; | |
76 | } else { | |
77 | if (line == 16 && field == 0 && (set & V4L2_SLICED_VPS)) | |
78 | return V4L2_SLICED_VPS; | |
79 | if (line == 23 && field == 0 && (set & V4L2_SLICED_WSS_625)) | |
80 | return V4L2_SLICED_WSS_625; | |
81 | if (line == 23) | |
82 | return 0; | |
83 | } | |
84 | for (i = 0; i < 32; i++) { | |
85 | if ((1 << i) & set) | |
86 | return 1 << i; | |
87 | } | |
88 | return 0; | |
89 | } | |
90 | ||
aed6abd6 | 91 | void cx18_expand_service_set(struct v4l2_sliced_vbi_format *fmt, int is_pal) |
1c1e45d1 HV |
92 | { |
93 | u16 set = fmt->service_set; | |
94 | int f, l; | |
95 | ||
96 | fmt->service_set = 0; | |
97 | for (f = 0; f < 2; f++) { | |
98 | for (l = 0; l < 24; l++) | |
99 | fmt->service_lines[f][l] = select_service_from_set(f, l, set, is_pal); | |
100 | } | |
101 | } | |
102 | ||
1c1e45d1 | 103 | |
aed6abd6 | 104 | u16 cx18_get_service_set(struct v4l2_sliced_vbi_format *fmt) |
1c1e45d1 HV |
105 | { |
106 | int f, l; | |
107 | u16 set = 0; | |
108 | ||
109 | for (f = 0; f < 2; f++) { | |
110 | for (l = 0; l < 24; l++) | |
111 | set |= fmt->service_lines[f][l]; | |
112 | } | |
113 | return set; | |
114 | } | |
115 | ||
1c1e45d1 HV |
116 | static int cx18_cxc(struct cx18 *cx, unsigned int cmd, void *arg) |
117 | { | |
118 | struct v4l2_register *regs = arg; | |
119 | unsigned long flags; | |
120 | ||
121 | if (!capable(CAP_SYS_ADMIN)) | |
122 | return -EPERM; | |
123 | if (regs->reg >= CX18_MEM_OFFSET + CX18_MEM_SIZE) | |
124 | return -EINVAL; | |
125 | ||
126 | spin_lock_irqsave(&cx18_cards_lock, flags); | |
127 | if (cmd == VIDIOC_DBG_G_REGISTER) | |
128 | regs->val = read_enc(regs->reg); | |
129 | else | |
130 | write_enc(regs->val, regs->reg); | |
131 | spin_unlock_irqrestore(&cx18_cards_lock, flags); | |
132 | return 0; | |
133 | } | |
134 | ||
3b6fe58f AW |
135 | static int cx18_g_fmt_vid_cap(struct file *file, void *fh, |
136 | struct v4l2_format *fmt) | |
137 | { | |
138 | struct cx18_open_id *id = fh; | |
139 | struct cx18 *cx = id->cx; | |
1c1e45d1 | 140 | |
3b6fe58f AW |
141 | CX18_DEBUG_IOCTL("VIDIOC_G_FMT: V4L2_BUF_TYPE_VIDEO_CAPTURE\n"); |
142 | ||
143 | fmt->fmt.pix.width = cx->params.width; | |
144 | fmt->fmt.pix.height = cx->params.height; | |
145 | fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M; | |
146 | fmt->fmt.pix.field = V4L2_FIELD_INTERLACED; | |
147 | if (id->type == CX18_ENC_STREAM_TYPE_YUV) { | |
148 | fmt->fmt.pix.pixelformat = V4L2_PIX_FMT_HM12; | |
149 | /* YUV size is (Y=(h*w) + UV=(h*(w/2))) */ | |
150 | fmt->fmt.pix.sizeimage = | |
151 | fmt->fmt.pix.height * fmt->fmt.pix.width + | |
152 | fmt->fmt.pix.height * (fmt->fmt.pix.width / 2); | |
153 | } else { | |
154 | fmt->fmt.pix.pixelformat = V4L2_PIX_FMT_MPEG; | |
155 | fmt->fmt.pix.sizeimage = 128 * 1024; | |
156 | } | |
157 | return 0; | |
158 | } | |
1c1e45d1 | 159 | |
3b6fe58f AW |
160 | static int cx18_g_fmt_vbi_cap(struct file *file, void *fh, |
161 | struct v4l2_format *fmt) | |
162 | { | |
163 | struct cx18 *cx = ((struct cx18_open_id *)fh)->cx; | |
1c1e45d1 | 164 | |
3b6fe58f | 165 | CX18_DEBUG_IOCTL("VIDIOC_G_FMT: V4L2_BUF_TYPE_VBI_CAPTURE\n"); |
1c1e45d1 | 166 | |
3b6fe58f AW |
167 | fmt->fmt.vbi.sampling_rate = 27000000; |
168 | fmt->fmt.vbi.offset = 248; | |
169 | fmt->fmt.vbi.samples_per_line = cx->vbi.raw_decoder_line_size - 4; | |
170 | fmt->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY; | |
171 | fmt->fmt.vbi.start[0] = cx->vbi.start[0]; | |
172 | fmt->fmt.vbi.start[1] = cx->vbi.start[1]; | |
173 | fmt->fmt.vbi.count[0] = fmt->fmt.vbi.count[1] = cx->vbi.count; | |
1c1e45d1 HV |
174 | return 0; |
175 | } | |
176 | ||
3b6fe58f AW |
177 | static int cx18_g_fmt_sliced_vbi_cap(struct file *file, void *fh, |
178 | struct v4l2_format *fmt) | |
1c1e45d1 | 179 | { |
3b6fe58f AW |
180 | return -EINVAL; |
181 | } | |
1c1e45d1 | 182 | |
3b6fe58f AW |
183 | static int cx18_try_fmt_vid_cap(struct file *file, void *fh, |
184 | struct v4l2_format *fmt) | |
185 | { | |
186 | struct cx18_open_id *id = fh; | |
187 | struct cx18 *cx = id->cx; | |
1c1e45d1 | 188 | |
3b6fe58f AW |
189 | int w = fmt->fmt.pix.width; |
190 | int h = fmt->fmt.pix.height; | |
1c1e45d1 | 191 | |
3b6fe58f | 192 | CX18_DEBUG_IOCTL("VIDIOC_TRY_FMT: V4L2_BUF_TYPE_VIDEO_CAPTURE\n"); |
1c1e45d1 | 193 | |
3b6fe58f AW |
194 | w = min(w, 720); |
195 | w = max(w, 1); | |
196 | h = min(h, cx->is_50hz ? 576 : 480); | |
197 | h = max(h, 2); | |
198 | cx18_g_fmt_vid_cap(file, fh, fmt); | |
199 | fmt->fmt.pix.width = w; | |
200 | fmt->fmt.pix.height = h; | |
201 | return 0; | |
202 | } | |
1c1e45d1 | 203 | |
3b6fe58f AW |
204 | static int cx18_try_fmt_vbi_cap(struct file *file, void *fh, |
205 | struct v4l2_format *fmt) | |
206 | { | |
207 | struct cx18 *cx = ((struct cx18_open_id *)fh)->cx; | |
1c1e45d1 | 208 | |
3b6fe58f AW |
209 | CX18_DEBUG_IOCTL("VIDIOC_TRY_FMT: V4L2_BUF_TYPE_VBI_CAPTURE\n"); |
210 | ||
211 | return cx18_g_fmt_vbi_cap(file, fh, fmt); | |
212 | } | |
213 | ||
214 | static int cx18_try_fmt_sliced_vbi_cap(struct file *file, void *fh, | |
215 | struct v4l2_format *fmt) | |
216 | { | |
217 | return -EINVAL; | |
218 | } | |
219 | ||
220 | static int cx18_s_fmt_vid_cap(struct file *file, void *fh, | |
221 | struct v4l2_format *fmt) | |
222 | { | |
223 | struct cx18_open_id *id = fh; | |
224 | struct cx18 *cx = id->cx; | |
225 | int ret; | |
226 | int w = fmt->fmt.pix.width; | |
227 | int h = fmt->fmt.pix.height; | |
228 | ||
229 | ret = v4l2_prio_check(&cx->prio, &id->prio); | |
230 | if (ret) | |
231 | return ret; | |
1c1e45d1 | 232 | |
3b6fe58f | 233 | CX18_DEBUG_IOCTL("VIDIOC_S_FMT: V4L2_BUF_TYPE_VIDEO_CAPTURE\n"); |
1c1e45d1 | 234 | |
3b6fe58f AW |
235 | ret = cx18_try_fmt_vid_cap(file, fh, fmt); |
236 | if (ret) | |
237 | return ret; | |
1c1e45d1 | 238 | |
3b6fe58f | 239 | if (cx->params.width == w && cx->params.height == h) |
1c1e45d1 | 240 | return 0; |
3b6fe58f AW |
241 | |
242 | if (atomic_read(&cx->ana_capturing) > 0) | |
1c1e45d1 | 243 | return -EBUSY; |
3b6fe58f AW |
244 | |
245 | cx->params.width = w; | |
246 | cx->params.height = h; | |
1c1e45d1 | 247 | cx18_av_cmd(cx, VIDIOC_S_FMT, fmt); |
3b6fe58f | 248 | return cx18_g_fmt_vid_cap(file, fh, fmt); |
1c1e45d1 HV |
249 | } |
250 | ||
3b6fe58f AW |
251 | static int cx18_s_fmt_vbi_cap(struct file *file, void *fh, |
252 | struct v4l2_format *fmt) | |
1c1e45d1 | 253 | { |
3b6fe58f | 254 | struct cx18_open_id *id = fh; |
1c1e45d1 | 255 | struct cx18 *cx = id->cx; |
3b6fe58f | 256 | int ret; |
1c1e45d1 | 257 | |
3b6fe58f AW |
258 | ret = v4l2_prio_check(&cx->prio, &id->prio); |
259 | if (ret) | |
260 | return ret; | |
1c1e45d1 | 261 | |
3b6fe58f | 262 | CX18_DEBUG_IOCTL("VIDIOC_S_FMT: V4L2_BUF_TYPE_VBI_CAPTURE\n"); |
1c1e45d1 | 263 | |
3b6fe58f AW |
264 | if (id->type == CX18_ENC_STREAM_TYPE_VBI && |
265 | cx->vbi.sliced_in->service_set && | |
266 | atomic_read(&cx->ana_capturing) > 0) | |
267 | return -EBUSY; | |
1c1e45d1 | 268 | |
3b6fe58f AW |
269 | cx->vbi.sliced_in->service_set = 0; |
270 | cx18_av_cmd(cx, VIDIOC_S_FMT, &cx->vbi.in); | |
271 | return cx18_g_fmt_vbi_cap(file, fh, fmt); | |
272 | } | |
273 | ||
274 | static int cx18_s_fmt_sliced_vbi_cap(struct file *file, void *fh, | |
275 | struct v4l2_format *fmt) | |
276 | { | |
277 | return -EINVAL; | |
278 | } | |
279 | ||
280 | static int cx18_g_chip_ident(struct file *file, void *fh, | |
281 | struct v4l2_chip_ident *chip) | |
282 | { | |
283 | struct cx18 *cx = ((struct cx18_open_id *)fh)->cx; | |
284 | ||
285 | CX18_DEBUG_IOCTL("VIDIOC_G_CHIP_IDENT\n"); | |
286 | ||
287 | chip->ident = V4L2_IDENT_NONE; | |
288 | chip->revision = 0; | |
289 | if (chip->match_type == V4L2_CHIP_MATCH_HOST) { | |
290 | if (v4l2_chip_match_host(chip->match_type, chip->match_chip)) | |
291 | chip->ident = V4L2_IDENT_CX23418; | |
292 | return 0; | |
1c1e45d1 | 293 | } |
3b6fe58f AW |
294 | if (chip->match_type == V4L2_CHIP_MATCH_I2C_DRIVER) |
295 | return cx18_i2c_id(cx, chip->match_chip, VIDIOC_G_CHIP_IDENT, | |
296 | chip); | |
297 | if (chip->match_type == V4L2_CHIP_MATCH_I2C_ADDR) | |
298 | return cx18_call_i2c_client(cx, chip->match_chip, | |
299 | VIDIOC_G_CHIP_IDENT, chip); | |
300 | return -EINVAL; | |
301 | } | |
302 | ||
303 | static int cx18_g_register(struct file *file, void *fh, | |
304 | struct v4l2_register *reg) | |
305 | { | |
306 | struct cx18 *cx = ((struct cx18_open_id *)fh)->cx; | |
307 | ||
308 | CX18_DEBUG_IOCTL("VIDIOC_DBG_G_REGISTER\n"); | |
309 | ||
310 | if (v4l2_chip_match_host(reg->match_type, reg->match_chip)) | |
311 | return cx18_cxc(cx, VIDIOC_DBG_G_REGISTER, reg); | |
312 | if (reg->match_type == V4L2_CHIP_MATCH_I2C_DRIVER) | |
313 | return cx18_i2c_id(cx, reg->match_chip, VIDIOC_DBG_G_REGISTER, | |
314 | reg); | |
315 | return cx18_call_i2c_client(cx, reg->match_chip, VIDIOC_DBG_G_REGISTER, | |
316 | reg); | |
317 | } | |
318 | ||
319 | static int cx18_s_register(struct file *file, void *fh, | |
320 | struct v4l2_register *reg) | |
321 | { | |
322 | struct cx18 *cx = ((struct cx18_open_id *)fh)->cx; | |
323 | ||
324 | CX18_DEBUG_IOCTL("VIDIOC_DBG_S_REGISTER\n"); | |
325 | ||
326 | if (v4l2_chip_match_host(reg->match_type, reg->match_chip)) | |
327 | return cx18_cxc(cx, VIDIOC_DBG_S_REGISTER, reg); | |
328 | if (reg->match_type == V4L2_CHIP_MATCH_I2C_DRIVER) | |
329 | return cx18_i2c_id(cx, reg->match_chip, VIDIOC_DBG_S_REGISTER, | |
330 | reg); | |
331 | return cx18_call_i2c_client(cx, reg->match_chip, VIDIOC_DBG_S_REGISTER, | |
332 | reg); | |
333 | } | |
334 | ||
335 | static int cx18_g_priority(struct file *file, void *fh, enum v4l2_priority *p) | |
336 | { | |
337 | struct cx18 *cx = ((struct cx18_open_id *)fh)->cx; | |
338 | ||
339 | CX18_DEBUG_IOCTL("VIDIOC_G_PRIORITY\n"); | |
340 | ||
341 | *p = v4l2_prio_max(&cx->prio); | |
1c1e45d1 HV |
342 | return 0; |
343 | } | |
344 | ||
3b6fe58f | 345 | static int cx18_s_priority(struct file *file, void *fh, enum v4l2_priority prio) |
1c1e45d1 | 346 | { |
3b6fe58f AW |
347 | struct cx18_open_id *id = fh; |
348 | struct cx18 *cx = id->cx; | |
1c1e45d1 | 349 | |
3b6fe58f | 350 | CX18_DEBUG_IOCTL("VIDIOC_S_PRIORITY\n"); |
1c1e45d1 | 351 | |
3b6fe58f AW |
352 | return v4l2_prio_change(&cx->prio, &id->prio, prio); |
353 | } | |
1c1e45d1 | 354 | |
3b6fe58f AW |
355 | static int cx18_querycap(struct file *file, void *fh, |
356 | struct v4l2_capability *vcap) | |
357 | { | |
358 | struct cx18 *cx = ((struct cx18_open_id *)fh)->cx; | |
1c1e45d1 | 359 | |
3b6fe58f | 360 | CX18_DEBUG_IOCTL("VIDIOC_QUERYCAP\n"); |
1c1e45d1 | 361 | |
3b6fe58f AW |
362 | strlcpy(vcap->driver, CX18_DRIVER_NAME, sizeof(vcap->driver)); |
363 | strlcpy(vcap->card, cx->card_name, sizeof(vcap->card)); | |
364 | strlcpy(vcap->bus_info, pci_name(cx->dev), sizeof(vcap->bus_info)); | |
365 | vcap->version = CX18_DRIVER_VERSION; /* version */ | |
366 | vcap->capabilities = cx->v4l2_cap; /* capabilities */ | |
367 | return 0; | |
368 | } | |
1c1e45d1 | 369 | |
3b6fe58f AW |
370 | static int cx18_enumaudio(struct file *file, void *fh, struct v4l2_audio *vin) |
371 | { | |
372 | struct cx18 *cx = ((struct cx18_open_id *)fh)->cx; | |
1c1e45d1 | 373 | |
3b6fe58f | 374 | CX18_DEBUG_IOCTL("VIDIOC_ENUMAUDIO\n"); |
1c1e45d1 | 375 | |
3b6fe58f AW |
376 | return cx18_get_audio_input(cx, vin->index, vin); |
377 | } | |
1c1e45d1 | 378 | |
3b6fe58f AW |
379 | static int cx18_g_audio(struct file *file, void *fh, struct v4l2_audio *vin) |
380 | { | |
381 | struct cx18 *cx = ((struct cx18_open_id *)fh)->cx; | |
1c1e45d1 | 382 | |
3b6fe58f | 383 | CX18_DEBUG_IOCTL("VIDIOC_G_AUDIO\n"); |
1c1e45d1 | 384 | |
3b6fe58f AW |
385 | vin->index = cx->audio_input; |
386 | return cx18_get_audio_input(cx, vin->index, vin); | |
387 | } | |
1c1e45d1 | 388 | |
3b6fe58f AW |
389 | static int cx18_s_audio(struct file *file, void *fh, struct v4l2_audio *vout) |
390 | { | |
391 | struct cx18 *cx = ((struct cx18_open_id *)fh)->cx; | |
1c1e45d1 | 392 | |
3b6fe58f | 393 | CX18_DEBUG_IOCTL("VIDIOC_S_AUDIO\n"); |
1c1e45d1 | 394 | |
3b6fe58f AW |
395 | if (vout->index >= cx->nof_audio_inputs) |
396 | return -EINVAL; | |
397 | cx->audio_input = vout->index; | |
398 | cx18_audio_set_io(cx); | |
399 | return 0; | |
400 | } | |
1c1e45d1 | 401 | |
3b6fe58f AW |
402 | static int cx18_enum_input(struct file *file, void *fh, struct v4l2_input *vin) |
403 | { | |
404 | struct cx18 *cx = ((struct cx18_open_id *)fh)->cx; | |
1c1e45d1 | 405 | |
3b6fe58f | 406 | CX18_DEBUG_IOCTL("VIDIOC_ENUMINPUT\n"); |
1c1e45d1 | 407 | |
3b6fe58f AW |
408 | /* set it to defaults from our table */ |
409 | return cx18_get_input(cx, vin->index, vin); | |
410 | } | |
1c1e45d1 | 411 | |
3b6fe58f AW |
412 | static int cx18_cropcap(struct file *file, void *fh, |
413 | struct v4l2_cropcap *cropcap) | |
414 | { | |
415 | struct cx18 *cx = ((struct cx18_open_id *)fh)->cx; | |
1c1e45d1 | 416 | |
3b6fe58f | 417 | CX18_DEBUG_IOCTL("VIDIOC_CROPCAP\n"); |
1c1e45d1 | 418 | |
3b6fe58f AW |
419 | if (cropcap->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) |
420 | return -EINVAL; | |
421 | cropcap->bounds.top = cropcap->bounds.left = 0; | |
422 | cropcap->bounds.width = 720; | |
423 | cropcap->bounds.height = cx->is_50hz ? 576 : 480; | |
424 | cropcap->pixelaspect.numerator = cx->is_50hz ? 59 : 10; | |
425 | cropcap->pixelaspect.denominator = cx->is_50hz ? 54 : 11; | |
426 | cropcap->defrect = cropcap->bounds; | |
427 | return 0; | |
428 | } | |
1c1e45d1 | 429 | |
3b6fe58f AW |
430 | static int cx18_s_crop(struct file *file, void *fh, struct v4l2_crop *crop) |
431 | { | |
432 | struct cx18_open_id *id = fh; | |
433 | struct cx18 *cx = id->cx; | |
434 | int ret; | |
1c1e45d1 | 435 | |
3b6fe58f AW |
436 | ret = v4l2_prio_check(&cx->prio, &id->prio); |
437 | if (ret) | |
438 | return ret; | |
1c1e45d1 | 439 | |
3b6fe58f | 440 | CX18_DEBUG_IOCTL("VIDIOC_S_CROP\n"); |
1c1e45d1 | 441 | |
3b6fe58f AW |
442 | if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) |
443 | return -EINVAL; | |
444 | return cx18_av_cmd(cx, VIDIOC_S_CROP, crop); | |
445 | } | |
1c1e45d1 | 446 | |
3b6fe58f AW |
447 | static int cx18_g_crop(struct file *file, void *fh, struct v4l2_crop *crop) |
448 | { | |
449 | struct cx18 *cx = ((struct cx18_open_id *)fh)->cx; | |
1c1e45d1 | 450 | |
3b6fe58f AW |
451 | CX18_DEBUG_IOCTL("VIDIOC_G_CROP\n"); |
452 | ||
453 | if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) | |
454 | return -EINVAL; | |
455 | return cx18_av_cmd(cx, VIDIOC_G_CROP, crop); | |
456 | } | |
457 | ||
458 | static int cx18_enum_fmt_vid_cap(struct file *file, void *fh, | |
459 | struct v4l2_fmtdesc *fmt) | |
460 | { | |
461 | static struct v4l2_fmtdesc formats[] = { | |
462 | { 0, V4L2_BUF_TYPE_VIDEO_CAPTURE, 0, | |
463 | "HM12 (YUV 4:1:1)", V4L2_PIX_FMT_HM12, { 0, 0, 0, 0 } | |
464 | }, | |
465 | { 1, V4L2_BUF_TYPE_VIDEO_CAPTURE, V4L2_FMT_FLAG_COMPRESSED, | |
466 | "MPEG", V4L2_PIX_FMT_MPEG, { 0, 0, 0, 0 } | |
1c1e45d1 | 467 | } |
3b6fe58f AW |
468 | }; |
469 | ||
470 | struct cx18 *cx = ((struct cx18_open_id *)fh)->cx; | |
471 | ||
472 | CX18_DEBUG_IOCTL("VIDIOC_ENUM_FMT: V4L2_BUF_TYPE_VIDEO_CAPTURE\n"); | |
473 | ||
474 | if (fmt->index > 1) | |
475 | return -EINVAL; | |
476 | *fmt = formats[fmt->index]; | |
477 | return 0; | |
478 | } | |
479 | ||
480 | static int cx18_g_input(struct file *file, void *fh, unsigned int *i) | |
481 | { | |
482 | struct cx18 *cx = ((struct cx18_open_id *)fh)->cx; | |
483 | ||
484 | CX18_DEBUG_IOCTL("VIDIOC_G_INPUT\n"); | |
485 | ||
486 | *i = cx->active_input; | |
487 | return 0; | |
488 | } | |
489 | ||
490 | int cx18_s_input(struct file *file, void *fh, unsigned int inp) | |
491 | { | |
492 | struct cx18_open_id *id = fh; | |
493 | struct cx18 *cx = id->cx; | |
494 | int ret; | |
495 | ||
496 | ret = v4l2_prio_check(&cx->prio, &id->prio); | |
497 | if (ret) | |
498 | return ret; | |
499 | ||
500 | CX18_DEBUG_IOCTL("VIDIOC_S_INPUT\n"); | |
501 | ||
502 | if (inp < 0 || inp >= cx->nof_inputs) | |
503 | return -EINVAL; | |
504 | ||
505 | if (inp == cx->active_input) { | |
506 | CX18_DEBUG_INFO("Input unchanged\n"); | |
1c1e45d1 HV |
507 | return 0; |
508 | } | |
509 | ||
3b6fe58f AW |
510 | CX18_DEBUG_INFO("Changing input from %d to %d\n", |
511 | cx->active_input, inp); | |
1c1e45d1 | 512 | |
3b6fe58f AW |
513 | cx->active_input = inp; |
514 | /* Set the audio input to whatever is appropriate for the input type. */ | |
515 | cx->audio_input = cx->card->video_inputs[inp].audio_index; | |
1c1e45d1 | 516 | |
3b6fe58f AW |
517 | /* prevent others from messing with the streams until |
518 | we're finished changing inputs. */ | |
519 | cx18_mute(cx); | |
520 | cx18_video_set_io(cx); | |
521 | cx18_audio_set_io(cx); | |
522 | cx18_unmute(cx); | |
523 | return 0; | |
524 | } | |
1c1e45d1 | 525 | |
3b6fe58f AW |
526 | static int cx18_g_frequency(struct file *file, void *fh, |
527 | struct v4l2_frequency *vf) | |
528 | { | |
529 | struct cx18 *cx = ((struct cx18_open_id *)fh)->cx; | |
1c1e45d1 | 530 | |
3b6fe58f | 531 | CX18_DEBUG_IOCTL("VIDIOC_G_FREQUENCY\n"); |
1c1e45d1 | 532 | |
3b6fe58f AW |
533 | if (vf->tuner != 0) |
534 | return -EINVAL; | |
1c1e45d1 | 535 | |
3b6fe58f AW |
536 | cx18_call_i2c_clients(cx, VIDIOC_G_FREQUENCY, vf); |
537 | return 0; | |
538 | } | |
1c1e45d1 | 539 | |
3b6fe58f AW |
540 | int cx18_s_frequency(struct file *file, void *fh, struct v4l2_frequency *vf) |
541 | { | |
542 | struct cx18_open_id *id = fh; | |
543 | struct cx18 *cx = id->cx; | |
544 | int ret; | |
1c1e45d1 | 545 | |
3b6fe58f AW |
546 | ret = v4l2_prio_check(&cx->prio, &id->prio); |
547 | if (ret) | |
548 | return ret; | |
1c1e45d1 | 549 | |
3b6fe58f | 550 | CX18_DEBUG_IOCTL("VIDIOC_S_FREQUENCY\n"); |
1c1e45d1 | 551 | |
3b6fe58f AW |
552 | if (vf->tuner != 0) |
553 | return -EINVAL; | |
1c1e45d1 | 554 | |
3b6fe58f AW |
555 | cx18_mute(cx); |
556 | CX18_DEBUG_INFO("v4l2 ioctl: set frequency %d\n", vf->frequency); | |
557 | cx18_call_i2c_clients(cx, VIDIOC_S_FREQUENCY, vf); | |
558 | cx18_unmute(cx); | |
559 | return 0; | |
560 | } | |
1c1e45d1 | 561 | |
3b6fe58f AW |
562 | static int cx18_g_std(struct file *file, void *fh, v4l2_std_id *std) |
563 | { | |
564 | struct cx18 *cx = ((struct cx18_open_id *)fh)->cx; | |
1c1e45d1 | 565 | |
3b6fe58f | 566 | CX18_DEBUG_IOCTL("VIDIOC_G_STD\n"); |
1c1e45d1 | 567 | |
3b6fe58f AW |
568 | *std = cx->std; |
569 | return 0; | |
570 | } | |
1c1e45d1 | 571 | |
3b6fe58f AW |
572 | int cx18_s_std(struct file *file, void *fh, v4l2_std_id *std) |
573 | { | |
574 | struct cx18_open_id *id = fh; | |
575 | struct cx18 *cx = id->cx; | |
576 | int ret; | |
1c1e45d1 | 577 | |
3b6fe58f AW |
578 | ret = v4l2_prio_check(&cx->prio, &id->prio); |
579 | if (ret) | |
580 | return ret; | |
1c1e45d1 | 581 | |
3b6fe58f | 582 | CX18_DEBUG_IOCTL("VIDIOC_S_STD\n"); |
1c1e45d1 | 583 | |
3b6fe58f AW |
584 | if ((*std & V4L2_STD_ALL) == 0) |
585 | return -EINVAL; | |
1c1e45d1 | 586 | |
3b6fe58f AW |
587 | if (*std == cx->std) |
588 | return 0; | |
589 | ||
590 | if (test_bit(CX18_F_I_RADIO_USER, &cx->i_flags) || | |
591 | atomic_read(&cx->ana_capturing) > 0) { | |
592 | /* Switching standard would turn off the radio or mess | |
593 | with already running streams, prevent that by | |
594 | returning EBUSY. */ | |
595 | return -EBUSY; | |
1c1e45d1 HV |
596 | } |
597 | ||
3b6fe58f AW |
598 | cx->std = *std; |
599 | cx->is_60hz = (*std & V4L2_STD_525_60) ? 1 : 0; | |
600 | cx->params.is_50hz = cx->is_50hz = !cx->is_60hz; | |
601 | cx->params.width = 720; | |
602 | cx->params.height = cx->is_50hz ? 576 : 480; | |
603 | cx->vbi.count = cx->is_50hz ? 18 : 12; | |
604 | cx->vbi.start[0] = cx->is_50hz ? 6 : 10; | |
605 | cx->vbi.start[1] = cx->is_50hz ? 318 : 273; | |
606 | cx->vbi.sliced_decoder_line_size = cx->is_60hz ? 272 : 284; | |
607 | CX18_DEBUG_INFO("Switching standard to %llx.\n", | |
608 | (unsigned long long) cx->std); | |
609 | ||
610 | /* Tuner */ | |
611 | cx18_call_i2c_clients(cx, VIDIOC_S_STD, &cx->std); | |
612 | return 0; | |
613 | } | |
1c1e45d1 | 614 | |
3b6fe58f AW |
615 | static int cx18_s_tuner(struct file *file, void *fh, struct v4l2_tuner *vt) |
616 | { | |
617 | struct cx18_open_id *id = fh; | |
618 | struct cx18 *cx = id->cx; | |
619 | int ret; | |
1c1e45d1 | 620 | |
3b6fe58f AW |
621 | ret = v4l2_prio_check(&cx->prio, &id->prio); |
622 | if (ret) | |
623 | return ret; | |
624 | ||
625 | CX18_DEBUG_IOCTL("VIDIOC_S_TUNER\n"); | |
626 | ||
627 | if (vt->index != 0) | |
628 | return -EINVAL; | |
629 | ||
630 | /* Setting tuner can only set audio mode */ | |
631 | cx18_call_i2c_clients(cx, VIDIOC_S_TUNER, vt); | |
632 | ||
633 | return 0; | |
634 | } | |
635 | ||
636 | static int cx18_g_tuner(struct file *file, void *fh, struct v4l2_tuner *vt) | |
637 | { | |
638 | struct cx18 *cx = ((struct cx18_open_id *)fh)->cx; | |
639 | ||
640 | CX18_DEBUG_IOCTL("VIDIOC_G_TUNER\n"); | |
641 | ||
642 | if (vt->index != 0) | |
643 | return -EINVAL; | |
644 | ||
645 | cx18_call_i2c_clients(cx, VIDIOC_G_TUNER, vt); | |
646 | ||
647 | if (test_bit(CX18_F_I_RADIO_USER, &cx->i_flags)) { | |
648 | strlcpy(vt->name, "cx18 Radio Tuner", sizeof(vt->name)); | |
649 | vt->type = V4L2_TUNER_RADIO; | |
650 | } else { | |
651 | strlcpy(vt->name, "cx18 TV Tuner", sizeof(vt->name)); | |
652 | vt->type = V4L2_TUNER_ANALOG_TV; | |
1c1e45d1 HV |
653 | } |
654 | ||
3b6fe58f AW |
655 | return 0; |
656 | } | |
657 | ||
658 | static int cx18_g_sliced_vbi_cap(struct file *file, void *fh, | |
659 | struct v4l2_sliced_vbi_cap *cap) | |
660 | { | |
661 | return -EINVAL; | |
662 | } | |
1c1e45d1 | 663 | |
3b6fe58f AW |
664 | static int cx18_g_enc_index(struct file *file, void *fh, |
665 | struct v4l2_enc_idx *idx) | |
666 | { | |
667 | return -EINVAL; | |
668 | } | |
1c1e45d1 | 669 | |
3b6fe58f AW |
670 | static int cx18_encoder_cmd(struct file *file, void *fh, |
671 | struct v4l2_encoder_cmd *enc) | |
672 | { | |
673 | struct cx18_open_id *id = fh; | |
674 | struct cx18 *cx = id->cx; | |
1c1e45d1 | 675 | |
3b6fe58f AW |
676 | CX18_DEBUG_IOCTL("VIDIOC_ENCODER_CMD:\n"); |
677 | ||
3b6fe58f AW |
678 | switch (enc->cmd) { |
679 | case V4L2_ENC_CMD_START: | |
680 | CX18_DEBUG_IOCTL("V4L2_ENC_CMD_START\n"); | |
681 | enc->flags = 0; | |
682 | return cx18_start_capture(id); | |
683 | ||
684 | case V4L2_ENC_CMD_STOP: | |
685 | CX18_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n"); | |
686 | enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END; | |
687 | cx18_stop_capture(id, | |
688 | enc->flags & V4L2_ENC_CMD_STOP_AT_GOP_END); | |
1c1e45d1 | 689 | break; |
1c1e45d1 | 690 | |
3b6fe58f AW |
691 | case V4L2_ENC_CMD_PAUSE: |
692 | CX18_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n"); | |
693 | enc->flags = 0; | |
694 | if (!atomic_read(&cx->ana_capturing)) | |
695 | return -EPERM; | |
696 | if (test_and_set_bit(CX18_F_I_ENC_PAUSED, &cx->i_flags)) | |
1c1e45d1 | 697 | return 0; |
3b6fe58f AW |
698 | cx18_mute(cx); |
699 | cx18_vapi(cx, CX18_CPU_CAPTURE_PAUSE, 1, cx18_find_handle(cx)); | |
700 | break; | |
701 | ||
702 | case V4L2_ENC_CMD_RESUME: | |
703 | CX18_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n"); | |
704 | enc->flags = 0; | |
705 | if (!atomic_read(&cx->ana_capturing)) | |
706 | return -EPERM; | |
707 | if (!test_and_clear_bit(CX18_F_I_ENC_PAUSED, &cx->i_flags)) | |
708 | return 0; | |
709 | cx18_vapi(cx, CX18_CPU_CAPTURE_RESUME, 1, cx18_find_handle(cx)); | |
710 | cx18_unmute(cx); | |
711 | break; | |
712 | ||
713 | default: | |
714 | CX18_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd); | |
1c1e45d1 HV |
715 | return -EINVAL; |
716 | } | |
3b6fe58f AW |
717 | return 0; |
718 | } | |
1c1e45d1 | 719 | |
3b6fe58f AW |
720 | static int cx18_try_encoder_cmd(struct file *file, void *fh, |
721 | struct v4l2_encoder_cmd *enc) | |
722 | { | |
723 | struct cx18 *cx = ((struct cx18_open_id *)fh)->cx; | |
1c1e45d1 | 724 | |
3b6fe58f AW |
725 | CX18_DEBUG_IOCTL("VIDIOC_TRY_ENCDOER_CMD:\n"); |
726 | ||
3b6fe58f AW |
727 | switch (enc->cmd) { |
728 | case V4L2_ENC_CMD_START: | |
729 | CX18_DEBUG_IOCTL("V4L2_ENC_CMD_START\n"); | |
730 | enc->flags = 0; | |
1c1e45d1 | 731 | break; |
1c1e45d1 | 732 | |
3b6fe58f AW |
733 | case V4L2_ENC_CMD_STOP: |
734 | CX18_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n"); | |
735 | enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END; | |
736 | break; | |
1c1e45d1 | 737 | |
3b6fe58f AW |
738 | case V4L2_ENC_CMD_PAUSE: |
739 | CX18_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n"); | |
740 | enc->flags = 0; | |
741 | break; | |
1c1e45d1 | 742 | |
3b6fe58f AW |
743 | case V4L2_ENC_CMD_RESUME: |
744 | CX18_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n"); | |
745 | enc->flags = 0; | |
1c1e45d1 | 746 | break; |
1c1e45d1 HV |
747 | |
748 | default: | |
3b6fe58f | 749 | CX18_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd); |
1c1e45d1 HV |
750 | return -EINVAL; |
751 | } | |
752 | return 0; | |
753 | } | |
754 | ||
3b6fe58f | 755 | static int cx18_log_status(struct file *file, void *fh) |
1c1e45d1 | 756 | { |
3b6fe58f AW |
757 | struct cx18 *cx = ((struct cx18_open_id *)fh)->cx; |
758 | struct v4l2_input vidin; | |
759 | struct v4l2_audio audin; | |
760 | int i; | |
1c1e45d1 | 761 | |
3b6fe58f AW |
762 | CX18_DEBUG_IOCTL("VIDIOC_LOG_STATUS\n"); |
763 | CX18_INFO("================= START STATUS CARD #%d =================\n", cx->num); | |
764 | if (cx->hw_flags & CX18_HW_TVEEPROM) { | |
765 | struct tveeprom tv; | |
766 | ||
767 | cx18_read_eeprom(cx, &tv); | |
768 | } | |
769 | cx18_call_i2c_clients(cx, VIDIOC_LOG_STATUS, NULL); | |
770 | cx18_get_input(cx, cx->active_input, &vidin); | |
771 | cx18_get_audio_input(cx, cx->audio_input, &audin); | |
772 | CX18_INFO("Video Input: %s\n", vidin.name); | |
773 | CX18_INFO("Audio Input: %s\n", audin.name); | |
774 | CX18_INFO("Tuner: %s\n", | |
775 | test_bit(CX18_F_I_RADIO_USER, &cx->i_flags) ? "Radio" : "TV"); | |
776 | cx2341x_log_status(&cx->params, cx->name); | |
777 | CX18_INFO("Status flags: 0x%08lx\n", cx->i_flags); | |
778 | for (i = 0; i < CX18_MAX_STREAMS; i++) { | |
779 | struct cx18_stream *s = &cx->streams[i]; | |
780 | ||
781 | if (s->v4l2dev == NULL || s->buffers == 0) | |
782 | continue; | |
783 | CX18_INFO("Stream %s: status 0x%04lx, %d%% of %d KiB (%d buffers) in use\n", | |
784 | s->name, s->s_flags, | |
785 | (s->buffers - s->q_free.buffers) * 100 / s->buffers, | |
786 | (s->buffers * s->buf_size) / 1024, s->buffers); | |
787 | } | |
788 | CX18_INFO("Read MPEG/VBI: %lld/%lld bytes\n", | |
789 | (long long)cx->mpg_data_received, | |
790 | (long long)cx->vbi_data_inserted); | |
791 | CX18_INFO("================== END STATUS CARD #%d ==================\n", cx->num); | |
792 | return 0; | |
793 | } | |
794 | ||
795 | static int cx18_default(struct file *file, void *fh, int cmd, void *arg) | |
796 | { | |
797 | struct cx18 *cx = ((struct cx18_open_id *)fh)->cx; | |
1c1e45d1 HV |
798 | |
799 | switch (cmd) { | |
3b6fe58f AW |
800 | case VIDIOC_INT_S_AUDIO_ROUTING: { |
801 | struct v4l2_routing *route = arg; | |
802 | CX18_DEBUG_IOCTL("VIDIOC_INT_S_AUDIO_ROUTING (%d, %d)\n", | |
803 | route->input, route->output); | |
804 | cx18_audio_set_route(cx, route); | |
805 | break; | |
806 | } | |
807 | case VIDIOC_INT_RESET: { | |
808 | u32 val = *(u32 *)arg; | |
809 | CX18_DEBUG_IOCTL("VIDIOC_INT_RESET (%#10x)\n", val); | |
810 | /* No op right now */ | |
811 | /* cx18_av_cmd(cx, cmd, arg) */ | |
812 | /* cx18_call_i2c_clients(cx, cmd, arg) */ | |
813 | break; | |
814 | } | |
815 | default: | |
1c1e45d1 | 816 | if (cx18_debug & CX18_DBGFLG_IOCTL) { |
3b6fe58f AW |
817 | printk(KERN_INFO "cx18%d ioctl: unsupported cmd: ", |
818 | cx->num); | |
1c1e45d1 | 819 | v4l_printk_ioctl(cmd); |
3b6fe58f | 820 | printk("\n"); |
1c1e45d1 | 821 | } |
1c1e45d1 | 822 | return -EINVAL; |
1c1e45d1 HV |
823 | } |
824 | return 0; | |
825 | } | |
826 | ||
827 | int cx18_v4l2_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, | |
828 | unsigned long arg) | |
829 | { | |
830 | struct cx18_open_id *id = (struct cx18_open_id *)filp->private_data; | |
831 | struct cx18 *cx = id->cx; | |
832 | int res; | |
833 | ||
834 | mutex_lock(&cx->serialize_lock); | |
3b6fe58f | 835 | res = video_ioctl2(inode, filp, cmd, arg); |
1c1e45d1 HV |
836 | mutex_unlock(&cx->serialize_lock); |
837 | return res; | |
838 | } | |
3b6fe58f AW |
839 | |
840 | void cx18_set_funcs(struct video_device *vdev) | |
841 | { | |
842 | vdev->vidioc_querycap = cx18_querycap; | |
843 | vdev->vidioc_g_priority = cx18_g_priority; | |
844 | vdev->vidioc_s_priority = cx18_s_priority; | |
845 | vdev->vidioc_s_audio = cx18_s_audio; | |
846 | vdev->vidioc_g_audio = cx18_g_audio; | |
847 | vdev->vidioc_enumaudio = cx18_enumaudio; | |
848 | vdev->vidioc_enum_input = cx18_enum_input; | |
849 | vdev->vidioc_cropcap = cx18_cropcap; | |
850 | vdev->vidioc_s_crop = cx18_s_crop; | |
851 | vdev->vidioc_g_crop = cx18_g_crop; | |
852 | vdev->vidioc_g_input = cx18_g_input; | |
853 | vdev->vidioc_s_input = cx18_s_input; | |
854 | vdev->vidioc_g_frequency = cx18_g_frequency; | |
855 | vdev->vidioc_s_frequency = cx18_s_frequency; | |
856 | vdev->vidioc_s_tuner = cx18_s_tuner; | |
857 | vdev->vidioc_g_tuner = cx18_g_tuner; | |
858 | vdev->vidioc_g_enc_index = cx18_g_enc_index; | |
859 | vdev->vidioc_g_std = cx18_g_std; | |
860 | vdev->vidioc_s_std = cx18_s_std; | |
861 | vdev->vidioc_log_status = cx18_log_status; | |
862 | vdev->vidioc_enum_fmt_vid_cap = cx18_enum_fmt_vid_cap; | |
863 | vdev->vidioc_encoder_cmd = cx18_encoder_cmd; | |
864 | vdev->vidioc_try_encoder_cmd = cx18_try_encoder_cmd; | |
865 | vdev->vidioc_g_fmt_vid_cap = cx18_g_fmt_vid_cap; | |
866 | vdev->vidioc_g_fmt_vbi_cap = cx18_g_fmt_vbi_cap; | |
867 | vdev->vidioc_g_fmt_sliced_vbi_cap = cx18_g_fmt_sliced_vbi_cap; | |
868 | vdev->vidioc_s_fmt_vid_cap = cx18_s_fmt_vid_cap; | |
869 | vdev->vidioc_s_fmt_vbi_cap = cx18_s_fmt_vbi_cap; | |
870 | vdev->vidioc_s_fmt_sliced_vbi_cap = cx18_s_fmt_sliced_vbi_cap; | |
871 | vdev->vidioc_try_fmt_vid_cap = cx18_try_fmt_vid_cap; | |
872 | vdev->vidioc_try_fmt_vbi_cap = cx18_try_fmt_vbi_cap; | |
873 | vdev->vidioc_try_fmt_sliced_vbi_cap = cx18_try_fmt_sliced_vbi_cap; | |
874 | vdev->vidioc_g_sliced_vbi_cap = cx18_g_sliced_vbi_cap; | |
875 | vdev->vidioc_g_chip_ident = cx18_g_chip_ident; | |
876 | vdev->vidioc_g_register = cx18_g_register; | |
877 | vdev->vidioc_s_register = cx18_s_register; | |
878 | vdev->vidioc_default = cx18_default; | |
879 | vdev->vidioc_queryctrl = cx18_queryctrl; | |
880 | vdev->vidioc_querymenu = cx18_querymenu; | |
881 | vdev->vidioc_g_ctrl = cx18_g_ctrl; | |
882 | vdev->vidioc_s_ctrl = cx18_s_ctrl; | |
883 | vdev->vidioc_g_ext_ctrls = cx18_g_ext_ctrls; | |
884 | vdev->vidioc_s_ext_ctrls = cx18_s_ext_ctrls; | |
885 | vdev->vidioc_try_ext_ctrls = cx18_try_ext_ctrls; | |
886 | } |