?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Input: wacom - fix touch parsing on newer Bamboos
[linux-btrfs-devel.git] / drivers / media / video / ivtv / ivtv-ioctl.c
blobf9e347dae7391a4487e15ac17e9e16578f59d16e
1 /*
2 ioctl system call
3 Copyright (C) 2003-2004 Kevin Thayer <nufan_wfk at yahoo.com>
4 Copyright (C) 2005-2007 Hans Verkuil <hverkuil@xs4all.nl>
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */
20
21 #include "ivtv-driver.h"
22 #include "ivtv-version.h"
23 #include "ivtv-mailbox.h"
24 #include "ivtv-i2c.h"
25 #include "ivtv-queue.h"
26 #include "ivtv-fileops.h"
27 #include "ivtv-vbi.h"
28 #include "ivtv-routing.h"
29 #include "ivtv-streams.h"
30 #include "ivtv-yuv.h"
31 #include "ivtv-ioctl.h"
32 #include "ivtv-gpio.h"
33 #include "ivtv-controls.h"
34 #include "ivtv-cards.h"
35 #include <media/saa7127.h>
36 #include <media/tveeprom.h>
37 #include <media/v4l2-chip-ident.h>
38 #include <media/v4l2-event.h>
39 #include <linux/dvb/audio.h>
40
41 u16 ivtv_service2vbi(int type)
42 {
43 switch (type) {
44 case V4L2_SLICED_TELETEXT_B:
45 return IVTV_SLICED_TYPE_TELETEXT_B;
46 case V4L2_SLICED_CAPTION_525:
47 return IVTV_SLICED_TYPE_CAPTION_525;
48 case V4L2_SLICED_WSS_625:
49 return IVTV_SLICED_TYPE_WSS_625;
50 case V4L2_SLICED_VPS:
51 return IVTV_SLICED_TYPE_VPS;
52 default:
53 return 0;
54 }
55 }
56
57 static int valid_service_line(int field, int line, int is_pal)
58 {
59 return (is_pal && line >= 6 && (line != 23 || field == 0)) ||
60 (!is_pal && line >= 10 && line < 22);
61 }
62
63 static u16 select_service_from_set(int field, int line, u16 set, int is_pal)
64 {
65 u16 valid_set = (is_pal ? V4L2_SLICED_VBI_625 : V4L2_SLICED_VBI_525);
66 int i;
67
68 set = set & valid_set;
69 if (set == 0 || !valid_service_line(field, line, is_pal)) {
70 return 0;
71 }
72 if (!is_pal) {
73 if (line == 21 && (set & V4L2_SLICED_CAPTION_525))
74 return V4L2_SLICED_CAPTION_525;
75 }
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
91 void ivtv_expand_service_set(struct v4l2_sliced_vbi_format *fmt, int is_pal)
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 }
103
104 static void check_service_set(struct v4l2_sliced_vbi_format *fmt, int is_pal)
105 {
106 int f, l;
107
108 for (f = 0; f < 2; f++) {
109 for (l = 0; l < 24; l++) {
110 fmt->service_lines[f][l] = select_service_from_set(f, l, fmt->service_lines[f][l], is_pal);
111 }
112 }
113 }
114
115 u16 ivtv_get_service_set(struct v4l2_sliced_vbi_format *fmt)
116 {
117 int f, l;
118 u16 set = 0;
119
120 for (f = 0; f < 2; f++) {
121 for (l = 0; l < 24; l++) {
122 set |= fmt->service_lines[f][l];
123 }
124 }
125 return set;
126 }
127
128 void ivtv_set_osd_alpha(struct ivtv *itv)
129 {
130 ivtv_vapi(itv, CX2341X_OSD_SET_GLOBAL_ALPHA, 3,
131 itv->osd_global_alpha_state, itv->osd_global_alpha, !itv->osd_local_alpha_state);
132 ivtv_vapi(itv, CX2341X_OSD_SET_CHROMA_KEY, 2, itv->osd_chroma_key_state, itv->osd_chroma_key);
133 }
134
135 int ivtv_set_speed(struct ivtv *itv, int speed)
136 {
137 u32 data[CX2341X_MBOX_MAX_DATA];
138 struct ivtv_stream *s;
139 int single_step = (speed == 1 || speed == -1);
140 DEFINE_WAIT(wait);
141
142 if (speed == 0) speed = 1000;
143
144 /* No change? */
145 if (speed == itv->speed && !single_step)
146 return 0;
147
148 s = &itv->streams[IVTV_DEC_STREAM_TYPE_MPG];
149
150 if (single_step && (speed < 0) == (itv->speed < 0)) {
151 /* Single step video and no need to change direction */
152 ivtv_vapi(itv, CX2341X_DEC_STEP_VIDEO, 1, 0);
153 itv->speed = speed;
154 return 0;
155 }
156 if (single_step)
157 /* Need to change direction */
158 speed = speed < 0 ? -1000 : 1000;
159
160 data[0] = (speed > 1000 || speed < -1000) ? 0x80000000 : 0;
161 data[0] |= (speed > 1000 || speed < -1500) ? 0x40000000 : 0;
162 data[1] = (speed < 0);
163 data[2] = speed < 0 ? 3 : 7;
164 data[3] = v4l2_ctrl_g_ctrl(itv->cxhdl.video_b_frames);
165 data[4] = (speed == 1500 || speed == 500) ? itv->speed_mute_audio : 0;
166 data[5] = 0;
167 data[6] = 0;
168
169 if (speed == 1500 || speed == -1500) data[0] |= 1;
170 else if (speed == 2000 || speed == -2000) data[0] |= 2;
171 else if (speed > -1000 && speed < 0) data[0] |= (-1000 / speed);
172 else if (speed < 1000 && speed > 0) data[0] |= (1000 / speed);
173
174 /* If not decoding, just change speed setting */
175 if (atomic_read(&itv->decoding) > 0) {
176 int got_sig = 0;
177
178 /* Stop all DMA and decoding activity */
179 ivtv_vapi(itv, CX2341X_DEC_PAUSE_PLAYBACK, 1, 0);
180
181 /* Wait for any DMA to finish */
182 prepare_to_wait(&itv->dma_waitq, &wait, TASK_INTERRUPTIBLE);
183 while (test_bit(IVTV_F_I_DMA, &itv->i_flags)) {
184 got_sig = signal_pending(current);
185 if (got_sig)
186 break;
187 got_sig = 0;
188 schedule();
189 }
190 finish_wait(&itv->dma_waitq, &wait);
191 if (got_sig)
192 return -EINTR;
193
194 /* Change Speed safely */
195 ivtv_api(itv, CX2341X_DEC_SET_PLAYBACK_SPEED, 7, data);
196 IVTV_DEBUG_INFO("Setting Speed to 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n",
197 data[0], data[1], data[2], data[3], data[4], data[5], data[6]);
198 }
199 if (single_step) {
200 speed = (speed < 0) ? -1 : 1;
201 ivtv_vapi(itv, CX2341X_DEC_STEP_VIDEO, 1, 0);
202 }
203 itv->speed = speed;
204 return 0;
205 }
206
207 static int ivtv_validate_speed(int cur_speed, int new_speed)
208 {
209 int fact = new_speed < 0 ? -1 : 1;
210 int s;
211
212 if (cur_speed == 0)
213 cur_speed = 1000;
214 if (new_speed < 0)
215 new_speed = -new_speed;
216 if (cur_speed < 0)
217 cur_speed = -cur_speed;
218
219 if (cur_speed <= new_speed) {
220 if (new_speed > 1500)
221 return fact * 2000;
222 if (new_speed > 1000)
223 return fact * 1500;
224 }
225 else {
226 if (new_speed >= 2000)
227 return fact * 2000;
228 if (new_speed >= 1500)
229 return fact * 1500;
230 if (new_speed >= 1000)
231 return fact * 1000;
232 }
233 if (new_speed == 0)
234 return 1000;
235 if (new_speed == 1 || new_speed == 1000)
236 return fact * new_speed;
237
238 s = new_speed;
239 new_speed = 1000 / new_speed;
240 if (1000 / cur_speed == new_speed)
241 new_speed += (cur_speed < s) ? -1 : 1;
242 if (new_speed > 60) return 1000 / (fact * 60);
243 return 1000 / (fact * new_speed);
244 }
245
246 static int ivtv_video_command(struct ivtv *itv, struct ivtv_open_id *id,
247 struct video_command *vc, int try)
248 {
249 struct ivtv_stream *s = &itv->streams[IVTV_DEC_STREAM_TYPE_MPG];
250
251 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
252 return -EINVAL;
253
254 switch (vc->cmd) {
255 case VIDEO_CMD_PLAY: {
256 vc->flags = 0;
257 vc->play.speed = ivtv_validate_speed(itv->speed, vc->play.speed);
258 if (vc->play.speed < 0)
259 vc->play.format = VIDEO_PLAY_FMT_GOP;
260 if (try) break;
261
262 if (ivtv_set_output_mode(itv, OUT_MPG) != OUT_MPG)
263 return -EBUSY;
264 if (test_and_clear_bit(IVTV_F_I_DEC_PAUSED, &itv->i_flags)) {
265 /* forces ivtv_set_speed to be called */
266 itv->speed = 0;
267 }
268 return ivtv_start_decoding(id, vc->play.speed);
269 }
270
271 case VIDEO_CMD_STOP:
272 vc->flags &= VIDEO_CMD_STOP_IMMEDIATELY|VIDEO_CMD_STOP_TO_BLACK;
273 if (vc->flags & VIDEO_CMD_STOP_IMMEDIATELY)
274 vc->stop.pts = 0;
275 if (try) break;
276 if (atomic_read(&itv->decoding) == 0)
277 return 0;
278 if (itv->output_mode != OUT_MPG)
279 return -EBUSY;
280
281 itv->output_mode = OUT_NONE;
282 return ivtv_stop_v4l2_decode_stream(s, vc->flags, vc->stop.pts);
283
284 case VIDEO_CMD_FREEZE:
285 vc->flags &= VIDEO_CMD_FREEZE_TO_BLACK;
286 if (try) break;
287 if (itv->output_mode != OUT_MPG)
288 return -EBUSY;
289 if (atomic_read(&itv->decoding) > 0) {
290 ivtv_vapi(itv, CX2341X_DEC_PAUSE_PLAYBACK, 1,
291 (vc->flags & VIDEO_CMD_FREEZE_TO_BLACK) ? 1 : 0);
292 set_bit(IVTV_F_I_DEC_PAUSED, &itv->i_flags);
293 }
294 break;
295
296 case VIDEO_CMD_CONTINUE:
297 vc->flags = 0;
298 if (try) break;
299 if (itv->output_mode != OUT_MPG)
300 return -EBUSY;
301 if (test_and_clear_bit(IVTV_F_I_DEC_PAUSED, &itv->i_flags)) {
302 int speed = itv->speed;
303 itv->speed = 0;
304 return ivtv_start_decoding(id, speed);
305 }
306 break;
307
308 default:
309 return -EINVAL;
310 }
311 return 0;
312 }
313
314 static int ivtv_g_fmt_sliced_vbi_out(struct file *file, void *fh, struct v4l2_format *fmt)
315 {
316 struct ivtv *itv = fh2id(fh)->itv;
317 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
318
319 vbifmt->reserved[0] = 0;
320 vbifmt->reserved[1] = 0;
321 if (!(itv->v4l2_cap & V4L2_CAP_SLICED_VBI_OUTPUT))
322 return -EINVAL;
323 vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
324 if (itv->is_60hz) {
325 vbifmt->service_lines[0][21] = V4L2_SLICED_CAPTION_525;
326 vbifmt->service_lines[1][21] = V4L2_SLICED_CAPTION_525;
327 } else {
328 vbifmt->service_lines[0][23] = V4L2_SLICED_WSS_625;
329 vbifmt->service_lines[0][16] = V4L2_SLICED_VPS;
330 }
331 vbifmt->service_set = ivtv_get_service_set(vbifmt);
332 return 0;
333 }
334
335 static int ivtv_g_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
336 {
337 struct ivtv_open_id *id = fh2id(fh);
338 struct ivtv *itv = id->itv;
339 struct v4l2_pix_format *pixfmt = &fmt->fmt.pix;
340
341 pixfmt->width = itv->cxhdl.width;
342 pixfmt->height = itv->cxhdl.height;
343 pixfmt->colorspace = V4L2_COLORSPACE_SMPTE170M;
344 pixfmt->field = V4L2_FIELD_INTERLACED;
345 pixfmt->priv = 0;
346 if (id->type == IVTV_ENC_STREAM_TYPE_YUV) {
347 pixfmt->pixelformat = V4L2_PIX_FMT_HM12;
348 /* YUV size is (Y=(h*720) + UV=(h*(720/2))) */
349 pixfmt->sizeimage = pixfmt->height * 720 * 3 / 2;
350 pixfmt->bytesperline = 720;
351 } else {
352 pixfmt->pixelformat = V4L2_PIX_FMT_MPEG;
353 pixfmt->sizeimage = 128 * 1024;
354 pixfmt->bytesperline = 0;
355 }
356 return 0;
357 }
358
359 static int ivtv_g_fmt_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
360 {
361 struct ivtv *itv = fh2id(fh)->itv;
362 struct v4l2_vbi_format *vbifmt = &fmt->fmt.vbi;
363
364 vbifmt->sampling_rate = 27000000;
365 vbifmt->offset = 248;
366 vbifmt->samples_per_line = itv->vbi.raw_decoder_line_size - 4;
367 vbifmt->sample_format = V4L2_PIX_FMT_GREY;
368 vbifmt->start[0] = itv->vbi.start[0];
369 vbifmt->start[1] = itv->vbi.start[1];
370 vbifmt->count[0] = vbifmt->count[1] = itv->vbi.count;
371 vbifmt->flags = 0;
372 vbifmt->reserved[0] = 0;
373 vbifmt->reserved[1] = 0;
374 return 0;
375 }
376
377 static int ivtv_g_fmt_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
378 {
379 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
380 struct ivtv_open_id *id = fh2id(fh);
381 struct ivtv *itv = id->itv;
382
383 vbifmt->reserved[0] = 0;
384 vbifmt->reserved[1] = 0;
385 vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
386
387 if (id->type == IVTV_DEC_STREAM_TYPE_VBI) {
388 vbifmt->service_set = itv->is_50hz ? V4L2_SLICED_VBI_625 :
389 V4L2_SLICED_VBI_525;
390 ivtv_expand_service_set(vbifmt, itv->is_50hz);
391 return 0;
392 }
393
394 v4l2_subdev_call(itv->sd_video, vbi, g_sliced_fmt, vbifmt);
395 vbifmt->service_set = ivtv_get_service_set(vbifmt);
396 return 0;
397 }
398
399 static int ivtv_g_fmt_vid_out(struct file *file, void *fh, struct v4l2_format *fmt)
400 {
401 struct ivtv_open_id *id = fh2id(fh);
402 struct ivtv *itv = id->itv;
403 struct v4l2_pix_format *pixfmt = &fmt->fmt.pix;
404
405 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
406 return -EINVAL;
407 pixfmt->width = itv->main_rect.width;
408 pixfmt->height = itv->main_rect.height;
409 pixfmt->colorspace = V4L2_COLORSPACE_SMPTE170M;
410 pixfmt->field = V4L2_FIELD_INTERLACED;
411 pixfmt->priv = 0;
412 if (id->type == IVTV_DEC_STREAM_TYPE_YUV) {
413 switch (itv->yuv_info.lace_mode & IVTV_YUV_MODE_MASK) {
414 case IVTV_YUV_MODE_INTERLACED:
415 pixfmt->field = (itv->yuv_info.lace_mode & IVTV_YUV_SYNC_MASK) ?
416 V4L2_FIELD_INTERLACED_BT : V4L2_FIELD_INTERLACED_TB;
417 break;
418 case IVTV_YUV_MODE_PROGRESSIVE:
419 pixfmt->field = V4L2_FIELD_NONE;
420 break;
421 default:
422 pixfmt->field = V4L2_FIELD_ANY;
423 break;
424 }
425 pixfmt->pixelformat = V4L2_PIX_FMT_HM12;
426 pixfmt->bytesperline = 720;
427 pixfmt->width = itv->yuv_info.v4l2_src_w;
428 pixfmt->height = itv->yuv_info.v4l2_src_h;
429 /* YUV size is (Y=(h*w) + UV=(h*(w/2))) */
430 pixfmt->sizeimage =
431 1080 * ((pixfmt->height + 31) & ~31);
432 } else {
433 pixfmt->pixelformat = V4L2_PIX_FMT_MPEG;
434 pixfmt->sizeimage = 128 * 1024;
435 pixfmt->bytesperline = 0;
436 }
437 return 0;
438 }
439
440 static int ivtv_g_fmt_vid_out_overlay(struct file *file, void *fh, struct v4l2_format *fmt)
441 {
442 struct ivtv *itv = fh2id(fh)->itv;
443 struct v4l2_window *winfmt = &fmt->fmt.win;
444
445 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
446 return -EINVAL;
447 winfmt->chromakey = itv->osd_chroma_key;
448 winfmt->global_alpha = itv->osd_global_alpha;
449 winfmt->field = V4L2_FIELD_INTERLACED;
450 winfmt->clips = NULL;
451 winfmt->clipcount = 0;
452 winfmt->bitmap = NULL;
453 winfmt->w.top = winfmt->w.left = 0;
454 winfmt->w.width = itv->osd_rect.width;
455 winfmt->w.height = itv->osd_rect.height;
456 return 0;
457 }
458
459 static int ivtv_try_fmt_sliced_vbi_out(struct file *file, void *fh, struct v4l2_format *fmt)
460 {
461 return ivtv_g_fmt_sliced_vbi_out(file, fh, fmt);
462 }
463
464 static int ivtv_try_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
465 {
466 struct ivtv_open_id *id = fh2id(fh);
467 struct ivtv *itv = id->itv;
468 int w = fmt->fmt.pix.width;
469 int h = fmt->fmt.pix.height;
470 int min_h = 2;
471
472 w = min(w, 720);
473 w = max(w, 2);
474 if (id->type == IVTV_ENC_STREAM_TYPE_YUV) {
475 /* YUV height must be a multiple of 32 */
476 h &= ~0x1f;
477 min_h = 32;
478 }
479 h = min(h, itv->is_50hz ? 576 : 480);
480 h = max(h, min_h);
481 ivtv_g_fmt_vid_cap(file, fh, fmt);
482 fmt->fmt.pix.width = w;
483 fmt->fmt.pix.height = h;
484 return 0;
485 }
486
487 static int ivtv_try_fmt_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
488 {
489 return ivtv_g_fmt_vbi_cap(file, fh, fmt);
490 }
491
492 static int ivtv_try_fmt_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
493 {
494 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
495 struct ivtv_open_id *id = fh2id(fh);
496 struct ivtv *itv = id->itv;
497
498 if (id->type == IVTV_DEC_STREAM_TYPE_VBI)
499 return ivtv_g_fmt_sliced_vbi_cap(file, fh, fmt);
500
501 /* set sliced VBI capture format */
502 vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
503 vbifmt->reserved[0] = 0;
504 vbifmt->reserved[1] = 0;
505
506 if (vbifmt->service_set)
507 ivtv_expand_service_set(vbifmt, itv->is_50hz);
508 check_service_set(vbifmt, itv->is_50hz);
509 vbifmt->service_set = ivtv_get_service_set(vbifmt);
510 return 0;
511 }
512
513 static int ivtv_try_fmt_vid_out(struct file *file, void *fh, struct v4l2_format *fmt)
514 {
515 struct ivtv_open_id *id = fh2id(fh);
516 s32 w = fmt->fmt.pix.width;
517 s32 h = fmt->fmt.pix.height;
518 int field = fmt->fmt.pix.field;
519 int ret = ivtv_g_fmt_vid_out(file, fh, fmt);
520
521 w = min(w, 720);
522 w = max(w, 2);
523 /* Why can the height be 576 even when the output is NTSC?
524
525 Internally the buffers of the PVR350 are always set to 720x576. The
526 decoded video frame will always be placed in the top left corner of
527 this buffer. For any video which is not 720x576, the buffer will
528 then be cropped to remove the unused right and lower areas, with
529 the remaining image being scaled by the hardware to fit the display
530 area. The video can be scaled both up and down, so a 720x480 video
531 can be displayed full-screen on PAL and a 720x576 video can be
532 displayed without cropping on NTSC.
533
534 Note that the scaling only occurs on the video stream, the osd
535 resolution is locked to the broadcast standard and not scaled.
536
537 Thanks to Ian Armstrong for this explanation. */
538 h = min(h, 576);
539 h = max(h, 2);
540 if (id->type == IVTV_DEC_STREAM_TYPE_YUV)
541 fmt->fmt.pix.field = field;
542 fmt->fmt.pix.width = w;
543 fmt->fmt.pix.height = h;
544 return ret;
545 }
546
547 static int ivtv_try_fmt_vid_out_overlay(struct file *file, void *fh, struct v4l2_format *fmt)
548 {
549 struct ivtv *itv = fh2id(fh)->itv;
550 u32 chromakey = fmt->fmt.win.chromakey;
551 u8 global_alpha = fmt->fmt.win.global_alpha;
552
553 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
554 return -EINVAL;
555 ivtv_g_fmt_vid_out_overlay(file, fh, fmt);
556 fmt->fmt.win.chromakey = chromakey;
557 fmt->fmt.win.global_alpha = global_alpha;
558 return 0;
559 }
560
561 static int ivtv_s_fmt_sliced_vbi_out(struct file *file, void *fh, struct v4l2_format *fmt)
562 {
563 return ivtv_g_fmt_sliced_vbi_out(file, fh, fmt);
564 }
565
566 static int ivtv_s_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
567 {
568 struct ivtv_open_id *id = fh2id(fh);
569 struct ivtv *itv = id->itv;
570 struct v4l2_mbus_framefmt mbus_fmt;
571 int ret = ivtv_try_fmt_vid_cap(file, fh, fmt);
572 int w = fmt->fmt.pix.width;
573 int h = fmt->fmt.pix.height;
574
575 if (ret)
576 return ret;
577
578 if (itv->cxhdl.width == w && itv->cxhdl.height == h)
579 return 0;
580
581 if (atomic_read(&itv->capturing) > 0)
582 return -EBUSY;
583
584 itv->cxhdl.width = w;
585 itv->cxhdl.height = h;
586 if (v4l2_ctrl_g_ctrl(itv->cxhdl.video_encoding) == V4L2_MPEG_VIDEO_ENCODING_MPEG_1)
587 fmt->fmt.pix.width /= 2;
588 mbus_fmt.width = fmt->fmt.pix.width;
589 mbus_fmt.height = h;
590 mbus_fmt.code = V4L2_MBUS_FMT_FIXED;
591 v4l2_subdev_call(itv->sd_video, video, s_mbus_fmt, &mbus_fmt);
592 return ivtv_g_fmt_vid_cap(file, fh, fmt);
593 }
594
595 static int ivtv_s_fmt_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
596 {
597 struct ivtv *itv = fh2id(fh)->itv;
598
599 if (!ivtv_raw_vbi(itv) && atomic_read(&itv->capturing) > 0)
600 return -EBUSY;
601 itv->vbi.sliced_in->service_set = 0;
602 itv->vbi.in.type = V4L2_BUF_TYPE_VBI_CAPTURE;
603 v4l2_subdev_call(itv->sd_video, vbi, s_raw_fmt, &fmt->fmt.vbi);
604 return ivtv_g_fmt_vbi_cap(file, fh, fmt);
605 }
606
607 static int ivtv_s_fmt_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
608 {
609 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
610 struct ivtv_open_id *id = fh2id(fh);
611 struct ivtv *itv = id->itv;
612 int ret = ivtv_try_fmt_sliced_vbi_cap(file, fh, fmt);
613
614 if (ret || id->type == IVTV_DEC_STREAM_TYPE_VBI)
615 return ret;
616
617 check_service_set(vbifmt, itv->is_50hz);
618 if (ivtv_raw_vbi(itv) && atomic_read(&itv->capturing) > 0)
619 return -EBUSY;
620 itv->vbi.in.type = V4L2_BUF_TYPE_SLICED_VBI_CAPTURE;
621 v4l2_subdev_call(itv->sd_video, vbi, s_sliced_fmt, vbifmt);
622 memcpy(itv->vbi.sliced_in, vbifmt, sizeof(*itv->vbi.sliced_in));
623 return 0;
624 }
625
626 static int ivtv_s_fmt_vid_out(struct file *file, void *fh, struct v4l2_format *fmt)
627 {
628 struct ivtv_open_id *id = fh2id(fh);
629 struct ivtv *itv = id->itv;
630 struct yuv_playback_info *yi = &itv->yuv_info;
631 int ret = ivtv_try_fmt_vid_out(file, fh, fmt);
632
633 if (ret)
634 return ret;
635
636 if (id->type != IVTV_DEC_STREAM_TYPE_YUV)
637 return 0;
638
639 /* Return now if we already have some frame data */
640 if (yi->stream_size)
641 return -EBUSY;
642
643 yi->v4l2_src_w = fmt->fmt.pix.width;
644 yi->v4l2_src_h = fmt->fmt.pix.height;
645
646 switch (fmt->fmt.pix.field) {
647 case V4L2_FIELD_NONE:
648 yi->lace_mode = IVTV_YUV_MODE_PROGRESSIVE;
649 break;
650 case V4L2_FIELD_ANY:
651 yi->lace_mode = IVTV_YUV_MODE_AUTO;
652 break;
653 case V4L2_FIELD_INTERLACED_BT:
654 yi->lace_mode =
655 IVTV_YUV_MODE_INTERLACED|IVTV_YUV_SYNC_ODD;
656 break;
657 case V4L2_FIELD_INTERLACED_TB:
658 default:
659 yi->lace_mode = IVTV_YUV_MODE_INTERLACED;
660 break;
661 }
662 yi->lace_sync_field = (yi->lace_mode & IVTV_YUV_SYNC_MASK) == IVTV_YUV_SYNC_EVEN ? 0 : 1;
663
664 if (test_bit(IVTV_F_I_DEC_YUV, &itv->i_flags))
665 itv->dma_data_req_size =
666 1080 * ((yi->v4l2_src_h + 31) & ~31);
667
668 return 0;
669 }
670
671 static int ivtv_s_fmt_vid_out_overlay(struct file *file, void *fh, struct v4l2_format *fmt)
672 {
673 struct ivtv *itv = fh2id(fh)->itv;
674 int ret = ivtv_try_fmt_vid_out_overlay(file, fh, fmt);
675
676 if (ret == 0) {
677 itv->osd_chroma_key = fmt->fmt.win.chromakey;
678 itv->osd_global_alpha = fmt->fmt.win.global_alpha;
679 ivtv_set_osd_alpha(itv);
680 }
681 return ret;
682 }
683
684 static int ivtv_g_chip_ident(struct file *file, void *fh, struct v4l2_dbg_chip_ident *chip)
685 {
686 struct ivtv *itv = fh2id(fh)->itv;
687
688 chip->ident = V4L2_IDENT_NONE;
689 chip->revision = 0;
690 if (chip->match.type == V4L2_CHIP_MATCH_HOST) {
691 if (v4l2_chip_match_host(&chip->match))
692 chip->ident = itv->has_cx23415 ? V4L2_IDENT_CX23415 : V4L2_IDENT_CX23416;
693 return 0;
694 }
695 if (chip->match.type != V4L2_CHIP_MATCH_I2C_DRIVER &&
696 chip->match.type != V4L2_CHIP_MATCH_I2C_ADDR)
697 return -EINVAL;
698 /* TODO: is this correct? */
699 return ivtv_call_all_err(itv, core, g_chip_ident, chip);
700 }
701
702 #ifdef CONFIG_VIDEO_ADV_DEBUG
703 static int ivtv_itvc(struct ivtv *itv, unsigned int cmd, void *arg)
704 {
705 struct v4l2_dbg_register *regs = arg;
706 volatile u8 __iomem *reg_start;
707
708 if (!capable(CAP_SYS_ADMIN))
709 return -EPERM;
710 if (regs->reg >= IVTV_REG_OFFSET && regs->reg < IVTV_REG_OFFSET + IVTV_REG_SIZE)
711 reg_start = itv->reg_mem - IVTV_REG_OFFSET;
712 else if (itv->has_cx23415 && regs->reg >= IVTV_DECODER_OFFSET &&
713 regs->reg < IVTV_DECODER_OFFSET + IVTV_DECODER_SIZE)
714 reg_start = itv->dec_mem - IVTV_DECODER_OFFSET;
715 else if (regs->reg < IVTV_ENCODER_SIZE)
716 reg_start = itv->enc_mem;
717 else
718 return -EINVAL;
719
720 regs->size = 4;
721 if (cmd == VIDIOC_DBG_G_REGISTER)
722 regs->val = readl(regs->reg + reg_start);
723 else
724 writel(regs->val, regs->reg + reg_start);
725 return 0;
726 }
727
728 static int ivtv_g_register(struct file *file, void *fh, struct v4l2_dbg_register *reg)
729 {
730 struct ivtv *itv = fh2id(fh)->itv;
731
732 if (v4l2_chip_match_host(&reg->match))
733 return ivtv_itvc(itv, VIDIOC_DBG_G_REGISTER, reg);
734 /* TODO: subdev errors should not be ignored, this should become a
735 subdev helper function. */
736 ivtv_call_all(itv, core, g_register, reg);
737 return 0;
738 }
739
740 static int ivtv_s_register(struct file *file, void *fh, struct v4l2_dbg_register *reg)
741 {
742 struct ivtv *itv = fh2id(fh)->itv;
743
744 if (v4l2_chip_match_host(&reg->match))
745 return ivtv_itvc(itv, VIDIOC_DBG_S_REGISTER, reg);
746 /* TODO: subdev errors should not be ignored, this should become a
747 subdev helper function. */
748 ivtv_call_all(itv, core, s_register, reg);
749 return 0;
750 }
751 #endif
752
753 static int ivtv_querycap(struct file *file, void *fh, struct v4l2_capability *vcap)
754 {
755 struct ivtv *itv = fh2id(fh)->itv;
756
757 strlcpy(vcap->driver, IVTV_DRIVER_NAME, sizeof(vcap->driver));
758 strlcpy(vcap->card, itv->card_name, sizeof(vcap->card));
759 snprintf(vcap->bus_info, sizeof(vcap->bus_info), "PCI:%s", pci_name(itv->pdev));
760 vcap->version = IVTV_DRIVER_VERSION; /* version */
761 vcap->capabilities = itv->v4l2_cap; /* capabilities */
762 return 0;
763 }
764
765 static int ivtv_enumaudio(struct file *file, void *fh, struct v4l2_audio *vin)
766 {
767 struct ivtv *itv = fh2id(fh)->itv;
768
769 return ivtv_get_audio_input(itv, vin->index, vin);
770 }
771
772 static int ivtv_g_audio(struct file *file, void *fh, struct v4l2_audio *vin)
773 {
774 struct ivtv *itv = fh2id(fh)->itv;
775
776 vin->index = itv->audio_input;
777 return ivtv_get_audio_input(itv, vin->index, vin);
778 }
779
780 static int ivtv_s_audio(struct file *file, void *fh, struct v4l2_audio *vout)
781 {
782 struct ivtv *itv = fh2id(fh)->itv;
783
784 if (vout->index >= itv->nof_audio_inputs)
785 return -EINVAL;
786
787 itv->audio_input = vout->index;
788 ivtv_audio_set_io(itv);
789
790 return 0;
791 }
792
793 static int ivtv_enumaudout(struct file *file, void *fh, struct v4l2_audioout *vin)
794 {
795 struct ivtv *itv = fh2id(fh)->itv;
796
797 /* set it to defaults from our table */
798 return ivtv_get_audio_output(itv, vin->index, vin);
799 }
800
801 static int ivtv_g_audout(struct file *file, void *fh, struct v4l2_audioout *vin)
802 {
803 struct ivtv *itv = fh2id(fh)->itv;
804
805 vin->index = 0;
806 return ivtv_get_audio_output(itv, vin->index, vin);
807 }
808
809 static int ivtv_s_audout(struct file *file, void *fh, struct v4l2_audioout *vout)
810 {
811 struct ivtv *itv = fh2id(fh)->itv;
812
813 return ivtv_get_audio_output(itv, vout->index, vout);
814 }
815
816 static int ivtv_enum_input(struct file *file, void *fh, struct v4l2_input *vin)
817 {
818 struct ivtv *itv = fh2id(fh)->itv;
819
820 /* set it to defaults from our table */
821 return ivtv_get_input(itv, vin->index, vin);
822 }
823
824 static int ivtv_enum_output(struct file *file, void *fh, struct v4l2_output *vout)
825 {
826 struct ivtv *itv = fh2id(fh)->itv;
827
828 return ivtv_get_output(itv, vout->index, vout);
829 }
830
831 static int ivtv_cropcap(struct file *file, void *fh, struct v4l2_cropcap *cropcap)
832 {
833 struct ivtv_open_id *id = fh2id(fh);
834 struct ivtv *itv = id->itv;
835 struct yuv_playback_info *yi = &itv->yuv_info;
836 int streamtype;
837
838 streamtype = id->type;
839
840 if (cropcap->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
841 return -EINVAL;
842 cropcap->bounds.top = cropcap->bounds.left = 0;
843 cropcap->bounds.width = 720;
844 if (cropcap->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
845 cropcap->bounds.height = itv->is_50hz ? 576 : 480;
846 cropcap->pixelaspect.numerator = itv->is_50hz ? 59 : 10;
847 cropcap->pixelaspect.denominator = itv->is_50hz ? 54 : 11;
848 } else if (streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
849 if (yi->track_osd) {
850 cropcap->bounds.width = yi->osd_full_w;
851 cropcap->bounds.height = yi->osd_full_h;
852 } else {
853 cropcap->bounds.width = 720;
854 cropcap->bounds.height =
855 itv->is_out_50hz ? 576 : 480;
856 }
857 cropcap->pixelaspect.numerator = itv->is_out_50hz ? 59 : 10;
858 cropcap->pixelaspect.denominator = itv->is_out_50hz ? 54 : 11;
859 } else {
860 cropcap->bounds.height = itv->is_out_50hz ? 576 : 480;
861 cropcap->pixelaspect.numerator = itv->is_out_50hz ? 59 : 10;
862 cropcap->pixelaspect.denominator = itv->is_out_50hz ? 54 : 11;
863 }
864 cropcap->defrect = cropcap->bounds;
865 return 0;
866 }
867
868 static int ivtv_s_crop(struct file *file, void *fh, struct v4l2_crop *crop)
869 {
870 struct ivtv_open_id *id = fh2id(fh);
871 struct ivtv *itv = id->itv;
872 struct yuv_playback_info *yi = &itv->yuv_info;
873 int streamtype;
874
875 streamtype = id->type;
876
877 if (crop->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
878 (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) {
879 if (streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
880 yi->main_rect = crop->c;
881 return 0;
882 } else {
883 if (!ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
884 crop->c.width, crop->c.height, crop->c.left, crop->c.top)) {
885 itv->main_rect = crop->c;
886 return 0;
887 }
888 }
889 return -EINVAL;
890 }
891 return -EINVAL;
892 }
893
894 static int ivtv_g_crop(struct file *file, void *fh, struct v4l2_crop *crop)
895 {
896 struct ivtv_open_id *id = fh2id(fh);
897 struct ivtv *itv = id->itv;
898 struct yuv_playback_info *yi = &itv->yuv_info;
899 int streamtype;
900
901 streamtype = id->type;
902
903 if (crop->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
904 (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) {
905 if (streamtype == IVTV_DEC_STREAM_TYPE_YUV)
906 crop->c = yi->main_rect;
907 else
908 crop->c = itv->main_rect;
909 return 0;
910 }
911 return -EINVAL;
912 }
913
914 static int ivtv_enum_fmt_vid_cap(struct file *file, void *fh, struct v4l2_fmtdesc *fmt)
915 {
916 static struct v4l2_fmtdesc formats[] = {
917 { 0, 0, 0,
918 "HM12 (YUV 4:2:0)", V4L2_PIX_FMT_HM12,
919 { 0, 0, 0, 0 }
920 },
921 { 1, 0, V4L2_FMT_FLAG_COMPRESSED,
922 "MPEG", V4L2_PIX_FMT_MPEG,
923 { 0, 0, 0, 0 }
924 }
925 };
926 enum v4l2_buf_type type = fmt->type;
927
928 if (fmt->index > 1)
929 return -EINVAL;
930
931 *fmt = formats[fmt->index];
932 fmt->type = type;
933 return 0;
934 }
935
936 static int ivtv_enum_fmt_vid_out(struct file *file, void *fh, struct v4l2_fmtdesc *fmt)
937 {
938 struct ivtv *itv = fh2id(fh)->itv;
939
940 static struct v4l2_fmtdesc formats[] = {
941 { 0, 0, 0,
942 "HM12 (YUV 4:2:0)", V4L2_PIX_FMT_HM12,
943 { 0, 0, 0, 0 }
944 },
945 { 1, 0, V4L2_FMT_FLAG_COMPRESSED,
946 "MPEG", V4L2_PIX_FMT_MPEG,
947 { 0, 0, 0, 0 }
948 }
949 };
950 enum v4l2_buf_type type = fmt->type;
951
952 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
953 return -EINVAL;
954
955 if (fmt->index > 1)
956 return -EINVAL;
957
958 *fmt = formats[fmt->index];
959 fmt->type = type;
960
961 return 0;
962 }
963
964 static int ivtv_g_input(struct file *file, void *fh, unsigned int *i)
965 {
966 struct ivtv *itv = fh2id(fh)->itv;
967
968 *i = itv->active_input;
969
970 return 0;
971 }
972
973 int ivtv_s_input(struct file *file, void *fh, unsigned int inp)
974 {
975 struct ivtv *itv = fh2id(fh)->itv;
976
977 if (inp < 0 || inp >= itv->nof_inputs)
978 return -EINVAL;
979
980 if (inp == itv->active_input) {
981 IVTV_DEBUG_INFO("Input unchanged\n");
982 return 0;
983 }
984
985 if (atomic_read(&itv->capturing) > 0) {
986 return -EBUSY;
987 }
988
989 IVTV_DEBUG_INFO("Changing input from %d to %d\n",
990 itv->active_input, inp);
991
992 itv->active_input = inp;
993 /* Set the audio input to whatever is appropriate for the
994 input type. */
995 itv->audio_input = itv->card->video_inputs[inp].audio_index;
996
997 /* prevent others from messing with the streams until
998 we're finished changing inputs. */
999 ivtv_mute(itv);
1000 ivtv_video_set_io(itv);
1001 ivtv_audio_set_io(itv);
1002 ivtv_unmute(itv);
1003
1004 return 0;
1005 }
1006
1007 static int ivtv_g_output(struct file *file, void *fh, unsigned int *i)
1008 {
1009 struct ivtv *itv = fh2id(fh)->itv;
1010
1011 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1012 return -EINVAL;
1013
1014 *i = itv->active_output;
1015
1016 return 0;
1017 }
1018
1019 static int ivtv_s_output(struct file *file, void *fh, unsigned int outp)
1020 {
1021 struct ivtv *itv = fh2id(fh)->itv;
1022
1023 if (outp >= itv->card->nof_outputs)
1024 return -EINVAL;
1025
1026 if (outp == itv->active_output) {
1027 IVTV_DEBUG_INFO("Output unchanged\n");
1028 return 0;
1029 }
1030 IVTV_DEBUG_INFO("Changing output from %d to %d\n",
1031 itv->active_output, outp);
1032
1033 itv->active_output = outp;
1034 ivtv_call_hw(itv, IVTV_HW_SAA7127, video, s_routing,
1035 SAA7127_INPUT_TYPE_NORMAL,
1036 itv->card->video_outputs[outp].video_output, 0);
1037
1038 return 0;
1039 }
1040
1041 static int ivtv_g_frequency(struct file *file, void *fh, struct v4l2_frequency *vf)
1042 {
1043 struct ivtv *itv = fh2id(fh)->itv;
1044
1045 if (vf->tuner != 0)
1046 return -EINVAL;
1047
1048 ivtv_call_all(itv, tuner, g_frequency, vf);
1049 return 0;
1050 }
1051
1052 int ivtv_s_frequency(struct file *file, void *fh, struct v4l2_frequency *vf)
1053 {
1054 struct ivtv *itv = fh2id(fh)->itv;
1055
1056 if (vf->tuner != 0)
1057 return -EINVAL;
1058
1059 ivtv_mute(itv);
1060 IVTV_DEBUG_INFO("v4l2 ioctl: set frequency %d\n", vf->frequency);
1061 ivtv_call_all(itv, tuner, s_frequency, vf);
1062 ivtv_unmute(itv);
1063 return 0;
1064 }
1065
1066 static int ivtv_g_std(struct file *file, void *fh, v4l2_std_id *std)
1067 {
1068 struct ivtv *itv = fh2id(fh)->itv;
1069
1070 *std = itv->std;
1071 return 0;
1072 }
1073
1074 void ivtv_s_std_enc(struct ivtv *itv, v4l2_std_id *std)
1075 {
1076 itv->std = *std;
1077 itv->is_60hz = (*std & V4L2_STD_525_60) ? 1 : 0;
1078 itv->is_50hz = !itv->is_60hz;
1079 cx2341x_handler_set_50hz(&itv->cxhdl, itv->is_50hz);
1080 itv->cxhdl.width = 720;
1081 itv->cxhdl.height = itv->is_50hz ? 576 : 480;
1082 itv->vbi.count = itv->is_50hz ? 18 : 12;
1083 itv->vbi.start[0] = itv->is_50hz ? 6 : 10;
1084 itv->vbi.start[1] = itv->is_50hz ? 318 : 273;
1085
1086 if (itv->hw_flags & IVTV_HW_CX25840)
1087 itv->vbi.sliced_decoder_line_size = itv->is_60hz ? 272 : 284;
1088
1089 /* Tuner */
1090 ivtv_call_all(itv, core, s_std, itv->std);
1091 }
1092
1093 void ivtv_s_std_dec(struct ivtv *itv, v4l2_std_id *std)
1094 {
1095 struct yuv_playback_info *yi = &itv->yuv_info;
1096 DEFINE_WAIT(wait);
1097 int f;
1098
1099 /* set display standard */
1100 itv->std_out = *std;
1101 itv->is_out_60hz = (*std & V4L2_STD_525_60) ? 1 : 0;
1102 itv->is_out_50hz = !itv->is_out_60hz;
1103 ivtv_call_all(itv, video, s_std_output, itv->std_out);
1104
1105 /*
1106 * The next firmware call is time sensitive. Time it to
1107 * avoid risk of a hard lock, by trying to ensure the call
1108 * happens within the first 100 lines of the top field.
1109 * Make 4 attempts to sync to the decoder before giving up.
1110 */
1111 for (f = 0; f < 4; f++) {
1112 prepare_to_wait(&itv->vsync_waitq, &wait,
1113 TASK_UNINTERRUPTIBLE);
1114 if ((read_reg(IVTV_REG_DEC_LINE_FIELD) >> 16) < 100)
1115 break;
1116 schedule_timeout(msecs_to_jiffies(25));
1117 }
1118 finish_wait(&itv->vsync_waitq, &wait);
1119
1120 if (f == 4)
1121 IVTV_WARN("Mode change failed to sync to decoder\n");
1122
1123 ivtv_vapi(itv, CX2341X_DEC_SET_STANDARD, 1, itv->is_out_50hz);
1124 itv->main_rect.left = 0;
1125 itv->main_rect.top = 0;
1126 itv->main_rect.width = 720;
1127 itv->main_rect.height = itv->is_out_50hz ? 576 : 480;
1128 ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
1129 720, itv->main_rect.height, 0, 0);
1130 yi->main_rect = itv->main_rect;
1131 if (!itv->osd_info) {
1132 yi->osd_full_w = 720;
1133 yi->osd_full_h = itv->is_out_50hz ? 576 : 480;
1134 }
1135 }
1136
1137 int ivtv_s_std(struct file *file, void *fh, v4l2_std_id *std)
1138 {
1139 struct ivtv *itv = fh2id(fh)->itv;
1140
1141 if ((*std & V4L2_STD_ALL) == 0)
1142 return -EINVAL;
1143
1144 if (*std == itv->std)
1145 return 0;
1146
1147 if (test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ||
1148 atomic_read(&itv->capturing) > 0 ||
1149 atomic_read(&itv->decoding) > 0) {
1150 /* Switching standard would mess with already running
1151 streams, prevent that by returning EBUSY. */
1152 return -EBUSY;
1153 }
1154
1155 IVTV_DEBUG_INFO("Switching standard to %llx.\n",
1156 (unsigned long long)itv->std);
1157
1158 ivtv_s_std_enc(itv, std);
1159 if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)
1160 ivtv_s_std_dec(itv, std);
1161
1162 return 0;
1163 }
1164
1165 static int ivtv_s_tuner(struct file *file, void *fh, struct v4l2_tuner *vt)
1166 {
1167 struct ivtv_open_id *id = fh2id(fh);
1168 struct ivtv *itv = id->itv;
1169
1170 if (vt->index != 0)
1171 return -EINVAL;
1172
1173 ivtv_call_all(itv, tuner, s_tuner, vt);
1174
1175 return 0;
1176 }
1177
1178 static int ivtv_g_tuner(struct file *file, void *fh, struct v4l2_tuner *vt)
1179 {
1180 struct ivtv *itv = fh2id(fh)->itv;
1181
1182 if (vt->index != 0)
1183 return -EINVAL;
1184
1185 ivtv_call_all(itv, tuner, g_tuner, vt);
1186
1187 if (test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags)) {
1188 strlcpy(vt->name, "ivtv Radio Tuner", sizeof(vt->name));
1189 vt->type = V4L2_TUNER_RADIO;
1190 } else {
1191 strlcpy(vt->name, "ivtv TV Tuner", sizeof(vt->name));
1192 vt->type = V4L2_TUNER_ANALOG_TV;
1193 }
1194
1195 return 0;
1196 }
1197
1198 static int ivtv_g_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_sliced_vbi_cap *cap)
1199 {
1200 struct ivtv *itv = fh2id(fh)->itv;
1201 int set = itv->is_50hz ? V4L2_SLICED_VBI_625 : V4L2_SLICED_VBI_525;
1202 int f, l;
1203
1204 if (cap->type == V4L2_BUF_TYPE_SLICED_VBI_CAPTURE) {
1205 for (f = 0; f < 2; f++) {
1206 for (l = 0; l < 24; l++) {
1207 if (valid_service_line(f, l, itv->is_50hz))
1208 cap->service_lines[f][l] = set;
1209 }
1210 }
1211 return 0;
1212 }
1213 if (cap->type == V4L2_BUF_TYPE_SLICED_VBI_OUTPUT) {
1214 if (!(itv->v4l2_cap & V4L2_CAP_SLICED_VBI_OUTPUT))
1215 return -EINVAL;
1216 if (itv->is_60hz) {
1217 cap->service_lines[0][21] = V4L2_SLICED_CAPTION_525;
1218 cap->service_lines[1][21] = V4L2_SLICED_CAPTION_525;
1219 } else {
1220 cap->service_lines[0][23] = V4L2_SLICED_WSS_625;
1221 cap->service_lines[0][16] = V4L2_SLICED_VPS;
1222 }
1223 return 0;
1224 }
1225 return -EINVAL;
1226 }
1227
1228 static int ivtv_g_enc_index(struct file *file, void *fh, struct v4l2_enc_idx *idx)
1229 {
1230 struct ivtv *itv = fh2id(fh)->itv;
1231 struct v4l2_enc_idx_entry *e = idx->entry;
1232 int entries;
1233 int i;
1234
1235 entries = (itv->pgm_info_write_idx + IVTV_MAX_PGM_INDEX - itv->pgm_info_read_idx) %
1236 IVTV_MAX_PGM_INDEX;
1237 if (entries > V4L2_ENC_IDX_ENTRIES)
1238 entries = V4L2_ENC_IDX_ENTRIES;
1239 idx->entries = 0;
1240 for (i = 0; i < entries; i++) {
1241 *e = itv->pgm_info[(itv->pgm_info_read_idx + i) % IVTV_MAX_PGM_INDEX];
1242 if ((e->flags & V4L2_ENC_IDX_FRAME_MASK) <= V4L2_ENC_IDX_FRAME_B) {
1243 idx->entries++;
1244 e++;
1245 }
1246 }
1247 itv->pgm_info_read_idx = (itv->pgm_info_read_idx + idx->entries) % IVTV_MAX_PGM_INDEX;
1248 return 0;
1249 }
1250
1251 static int ivtv_encoder_cmd(struct file *file, void *fh, struct v4l2_encoder_cmd *enc)
1252 {
1253 struct ivtv_open_id *id = fh2id(fh);
1254 struct ivtv *itv = id->itv;
1255
1256
1257 switch (enc->cmd) {
1258 case V4L2_ENC_CMD_START:
1259 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
1260 enc->flags = 0;
1261 return ivtv_start_capture(id);
1262
1263 case V4L2_ENC_CMD_STOP:
1264 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
1265 enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END;
1266 ivtv_stop_capture(id, enc->flags & V4L2_ENC_CMD_STOP_AT_GOP_END);
1267 return 0;
1268
1269 case V4L2_ENC_CMD_PAUSE:
1270 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
1271 enc->flags = 0;
1272
1273 if (!atomic_read(&itv->capturing))
1274 return -EPERM;
1275 if (test_and_set_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags))
1276 return 0;
1277
1278 ivtv_mute(itv);
1279 ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 0);
1280 break;
1281
1282 case V4L2_ENC_CMD_RESUME:
1283 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
1284 enc->flags = 0;
1285
1286 if (!atomic_read(&itv->capturing))
1287 return -EPERM;
1288
1289 if (!test_and_clear_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags))
1290 return 0;
1291
1292 ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 1);
1293 ivtv_unmute(itv);
1294 break;
1295 default:
1296 IVTV_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd);
1297 return -EINVAL;
1298 }
1299
1300 return 0;
1301 }
1302
1303 static int ivtv_try_encoder_cmd(struct file *file, void *fh, struct v4l2_encoder_cmd *enc)
1304 {
1305 struct ivtv *itv = fh2id(fh)->itv;
1306
1307 switch (enc->cmd) {
1308 case V4L2_ENC_CMD_START:
1309 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
1310 enc->flags = 0;
1311 return 0;
1312
1313 case V4L2_ENC_CMD_STOP:
1314 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
1315 enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END;
1316 return 0;
1317
1318 case V4L2_ENC_CMD_PAUSE:
1319 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
1320 enc->flags = 0;
1321 return 0;
1322
1323 case V4L2_ENC_CMD_RESUME:
1324 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
1325 enc->flags = 0;
1326 return 0;
1327 default:
1328 IVTV_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd);
1329 return -EINVAL;
1330 }
1331 }
1332
1333 static int ivtv_g_fbuf(struct file *file, void *fh, struct v4l2_framebuffer *fb)
1334 {
1335 struct ivtv *itv = fh2id(fh)->itv;
1336 u32 data[CX2341X_MBOX_MAX_DATA];
1337 struct yuv_playback_info *yi = &itv->yuv_info;
1338
1339 int pixfmt;
1340 static u32 pixel_format[16] = {
1341 V4L2_PIX_FMT_PAL8, /* Uses a 256-entry RGB colormap */
1342 V4L2_PIX_FMT_RGB565,
1343 V4L2_PIX_FMT_RGB555,
1344 V4L2_PIX_FMT_RGB444,
1345 V4L2_PIX_FMT_RGB32,
1346 0,
1347 0,
1348 0,
1349 V4L2_PIX_FMT_PAL8, /* Uses a 256-entry YUV colormap */
1350 V4L2_PIX_FMT_YUV565,
1351 V4L2_PIX_FMT_YUV555,
1352 V4L2_PIX_FMT_YUV444,
1353 V4L2_PIX_FMT_YUV32,
1354 0,
1355 0,
1356 0,
1357 };
1358
1359 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1360 return -EINVAL;
1361 if (!itv->osd_video_pbase)
1362 return -EINVAL;
1363
1364 fb->capability = V4L2_FBUF_CAP_EXTERNOVERLAY | V4L2_FBUF_CAP_CHROMAKEY |
1365 V4L2_FBUF_CAP_GLOBAL_ALPHA;
1366
1367 ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0);
1368 data[0] |= (read_reg(0x2a00) >> 7) & 0x40;
1369 pixfmt = (data[0] >> 3) & 0xf;
1370
1371 fb->fmt.pixelformat = pixel_format[pixfmt];
1372 fb->fmt.width = itv->osd_rect.width;
1373 fb->fmt.height = itv->osd_rect.height;
1374 fb->fmt.field = V4L2_FIELD_INTERLACED;
1375 fb->fmt.bytesperline = fb->fmt.width;
1376 fb->fmt.colorspace = V4L2_COLORSPACE_SMPTE170M;
1377 fb->fmt.field = V4L2_FIELD_INTERLACED;
1378 fb->fmt.priv = 0;
1379 if (fb->fmt.pixelformat != V4L2_PIX_FMT_PAL8)
1380 fb->fmt.bytesperline *= 2;
1381 if (fb->fmt.pixelformat == V4L2_PIX_FMT_RGB32 ||
1382 fb->fmt.pixelformat == V4L2_PIX_FMT_YUV32)
1383 fb->fmt.bytesperline *= 2;
1384 fb->fmt.sizeimage = fb->fmt.bytesperline * fb->fmt.height;
1385 fb->base = (void *)itv->osd_video_pbase;
1386 fb->flags = 0;
1387
1388 if (itv->osd_chroma_key_state)
1389 fb->flags |= V4L2_FBUF_FLAG_CHROMAKEY;
1390
1391 if (itv->osd_global_alpha_state)
1392 fb->flags |= V4L2_FBUF_FLAG_GLOBAL_ALPHA;
1393
1394 if (yi->track_osd)
1395 fb->flags |= V4L2_FBUF_FLAG_OVERLAY;
1396
1397 pixfmt &= 7;
1398
1399 /* no local alpha for RGB565 or unknown formats */
1400 if (pixfmt == 1 || pixfmt > 4)
1401 return 0;
1402
1403 /* 16-bit formats have inverted local alpha */
1404 if (pixfmt == 2 || pixfmt == 3)
1405 fb->capability |= V4L2_FBUF_CAP_LOCAL_INV_ALPHA;
1406 else
1407 fb->capability |= V4L2_FBUF_CAP_LOCAL_ALPHA;
1408
1409 if (itv->osd_local_alpha_state) {
1410 /* 16-bit formats have inverted local alpha */
1411 if (pixfmt == 2 || pixfmt == 3)
1412 fb->flags |= V4L2_FBUF_FLAG_LOCAL_INV_ALPHA;
1413 else
1414 fb->flags |= V4L2_FBUF_FLAG_LOCAL_ALPHA;
1415 }
1416
1417 return 0;
1418 }
1419
1420 static int ivtv_s_fbuf(struct file *file, void *fh, struct v4l2_framebuffer *fb)
1421 {
1422 struct ivtv_open_id *id = fh2id(fh);
1423 struct ivtv *itv = id->itv;
1424 struct yuv_playback_info *yi = &itv->yuv_info;
1425
1426 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1427 return -EINVAL;
1428 if (!itv->osd_video_pbase)
1429 return -EINVAL;
1430
1431 itv->osd_global_alpha_state = (fb->flags & V4L2_FBUF_FLAG_GLOBAL_ALPHA) != 0;
1432 itv->osd_local_alpha_state =
1433 (fb->flags & (V4L2_FBUF_FLAG_LOCAL_ALPHA|V4L2_FBUF_FLAG_LOCAL_INV_ALPHA)) != 0;
1434 itv->osd_chroma_key_state = (fb->flags & V4L2_FBUF_FLAG_CHROMAKEY) != 0;
1435 ivtv_set_osd_alpha(itv);
1436 yi->track_osd = (fb->flags & V4L2_FBUF_FLAG_OVERLAY) != 0;
1437 return ivtv_g_fbuf(file, fh, fb);
1438 }
1439
1440 static int ivtv_overlay(struct file *file, void *fh, unsigned int on)
1441 {
1442 struct ivtv_open_id *id = fh2id(fh);
1443 struct ivtv *itv = id->itv;
1444
1445 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1446 return -EINVAL;
1447
1448 ivtv_vapi(itv, CX2341X_OSD_SET_STATE, 1, on != 0);
1449
1450 return 0;
1451 }
1452
1453 static int ivtv_subscribe_event(struct v4l2_fh *fh, struct v4l2_event_subscription *sub)
1454 {
1455 switch (sub->type) {
1456 case V4L2_EVENT_VSYNC:
1457 case V4L2_EVENT_EOS:
1458 break;
1459 default:
1460 return -EINVAL;
1461 }
1462 return v4l2_event_subscribe(fh, sub);
1463 }
1464
1465 static int ivtv_log_status(struct file *file, void *fh)
1466 {
1467 struct ivtv *itv = fh2id(fh)->itv;
1468 u32 data[CX2341X_MBOX_MAX_DATA];
1469
1470 int has_output = itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT;
1471 struct v4l2_input vidin;
1472 struct v4l2_audio audin;
1473 int i;
1474
1475 IVTV_INFO("================= START STATUS CARD #%d =================\n",
1476 itv->instance);
1477 IVTV_INFO("Version: %s Card: %s\n", IVTV_VERSION, itv->card_name);
1478 if (itv->hw_flags & IVTV_HW_TVEEPROM) {
1479 struct tveeprom tv;
1480
1481 ivtv_read_eeprom(itv, &tv);
1482 }
1483 ivtv_call_all(itv, core, log_status);
1484 ivtv_get_input(itv, itv->active_input, &vidin);
1485 ivtv_get_audio_input(itv, itv->audio_input, &audin);
1486 IVTV_INFO("Video Input: %s\n", vidin.name);
1487 IVTV_INFO("Audio Input: %s%s\n", audin.name,
1488 (itv->dualwatch_stereo_mode & ~0x300) == 0x200 ? " (Bilingual)" : "");
1489 if (has_output) {
1490 struct v4l2_output vidout;
1491 struct v4l2_audioout audout;
1492 int mode = itv->output_mode;
1493 static const char * const output_modes[5] = {
1494 "None",
1495 "MPEG Streaming",
1496 "YUV Streaming",
1497 "YUV Frames",
1498 "Passthrough",
1499 };
1500 static const char * const audio_modes[5] = {
1501 "Stereo",
1502 "Left",
1503 "Right",
1504 "Mono",
1505 "Swapped"
1506 };
1507 static const char * const alpha_mode[4] = {
1508 "None",
1509 "Global",
1510 "Local",
1511 "Global and Local"
1512 };
1513 static const char * const pixel_format[16] = {
1514 "ARGB Indexed",
1515 "RGB 5:6:5",
1516 "ARGB 1:5:5:5",
1517 "ARGB 1:4:4:4",
1518 "ARGB 8:8:8:8",
1519 "5",
1520 "6",
1521 "7",
1522 "AYUV Indexed",
1523 "YUV 5:6:5",
1524 "AYUV 1:5:5:5",
1525 "AYUV 1:4:4:4",
1526 "AYUV 8:8:8:8",
1527 "13",
1528 "14",
1529 "15",
1530 };
1531
1532 ivtv_get_output(itv, itv->active_output, &vidout);
1533 ivtv_get_audio_output(itv, 0, &audout);
1534 IVTV_INFO("Video Output: %s\n", vidout.name);
1535 IVTV_INFO("Audio Output: %s (Stereo/Bilingual: %s/%s)\n", audout.name,
1536 audio_modes[itv->audio_stereo_mode],
1537 audio_modes[itv->audio_bilingual_mode]);
1538 if (mode < 0 || mode > OUT_PASSTHROUGH)
1539 mode = OUT_NONE;
1540 IVTV_INFO("Output Mode: %s\n", output_modes[mode]);
1541 ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0);
1542 data[0] |= (read_reg(0x2a00) >> 7) & 0x40;
1543 IVTV_INFO("Overlay: %s, Alpha: %s, Pixel Format: %s\n",
1544 data[0] & 1 ? "On" : "Off",
1545 alpha_mode[(data[0] >> 1) & 0x3],
1546 pixel_format[(data[0] >> 3) & 0xf]);
1547 }
1548 IVTV_INFO("Tuner: %s\n",
1549 test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ? "Radio" : "TV");
1550 v4l2_ctrl_handler_log_status(&itv->cxhdl.hdl, itv->v4l2_dev.name);
1551 IVTV_INFO("Status flags: 0x%08lx\n", itv->i_flags);
1552 for (i = 0; i < IVTV_MAX_STREAMS; i++) {
1553 struct ivtv_stream *s = &itv->streams[i];
1554
1555 if (s->vdev == NULL || s->buffers == 0)
1556 continue;
1557 IVTV_INFO("Stream %s: status 0x%04lx, %d%% of %d KiB (%d buffers) in use\n", s->name, s->s_flags,
1558 (s->buffers - s->q_free.buffers) * 100 / s->buffers,
1559 (s->buffers * s->buf_size) / 1024, s->buffers);
1560 }
1561
1562 IVTV_INFO("Read MPG/VBI: %lld/%lld bytes\n",
1563 (long long)itv->mpg_data_received,
1564 (long long)itv->vbi_data_inserted);
1565 IVTV_INFO("================== END STATUS CARD #%d ==================\n",
1566 itv->instance);
1567
1568 return 0;
1569 }
1570
1571 static int ivtv_decoder_ioctls(struct file *filp, unsigned int cmd, void *arg)
1572 {
1573 struct ivtv_open_id *id = fh2id(filp->private_data);
1574 struct ivtv *itv = id->itv;
1575 int nonblocking = filp->f_flags & O_NONBLOCK;
1576 struct ivtv_stream *s = &itv->streams[id->type];
1577 unsigned long iarg = (unsigned long)arg;
1578
1579 switch (cmd) {
1580 case IVTV_IOC_DMA_FRAME: {
1581 struct ivtv_dma_frame *args = arg;
1582
1583 IVTV_DEBUG_IOCTL("IVTV_IOC_DMA_FRAME\n");
1584 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1585 return -EINVAL;
1586 if (args->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
1587 return -EINVAL;
1588 if (itv->output_mode == OUT_UDMA_YUV && args->y_source == NULL)
1589 return 0;
1590 if (ivtv_start_decoding(id, id->type)) {
1591 return -EBUSY;
1592 }
1593 if (ivtv_set_output_mode(itv, OUT_UDMA_YUV) != OUT_UDMA_YUV) {
1594 ivtv_release_stream(s);
1595 return -EBUSY;
1596 }
1597 /* Mark that this file handle started the UDMA_YUV mode */
1598 id->yuv_frames = 1;
1599 if (args->y_source == NULL)
1600 return 0;
1601 return ivtv_yuv_prep_frame(itv, args);
1602 }
1603
1604 case VIDEO_GET_PTS: {
1605 u32 data[CX2341X_MBOX_MAX_DATA];
1606 u64 *pts = arg;
1607
1608 IVTV_DEBUG_IOCTL("VIDEO_GET_PTS\n");
1609 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) {
1610 *pts = s->dma_pts;
1611 break;
1612 }
1613 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1614 return -EINVAL;
1615
1616 if (test_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags)) {
1617 *pts = (u64) ((u64)itv->last_dec_timing[2] << 32) |
1618 (u64)itv->last_dec_timing[1];
1619 break;
1620 }
1621 *pts = 0;
1622 if (atomic_read(&itv->decoding)) {
1623 if (ivtv_api(itv, CX2341X_DEC_GET_TIMING_INFO, 5, data)) {
1624 IVTV_DEBUG_WARN("GET_TIMING: couldn't read clock\n");
1625 return -EIO;
1626 }
1627 memcpy(itv->last_dec_timing, data, sizeof(itv->last_dec_timing));
1628 set_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags);
1629 *pts = (u64) ((u64) data[2] << 32) | (u64) data[1];
1630 /*timing->scr = (u64) (((u64) data[4] << 32) | (u64) (data[3]));*/
1631 }
1632 break;
1633 }
1634
1635 case VIDEO_GET_FRAME_COUNT: {
1636 u32 data[CX2341X_MBOX_MAX_DATA];
1637 u64 *frame = arg;
1638
1639 IVTV_DEBUG_IOCTL("VIDEO_GET_FRAME_COUNT\n");
1640 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) {
1641 *frame = 0;
1642 break;
1643 }
1644 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1645 return -EINVAL;
1646
1647 if (test_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags)) {
1648 *frame = itv->last_dec_timing[0];
1649 break;
1650 }
1651 *frame = 0;
1652 if (atomic_read(&itv->decoding)) {
1653 if (ivtv_api(itv, CX2341X_DEC_GET_TIMING_INFO, 5, data)) {
1654 IVTV_DEBUG_WARN("GET_TIMING: couldn't read clock\n");
1655 return -EIO;
1656 }
1657 memcpy(itv->last_dec_timing, data, sizeof(itv->last_dec_timing));
1658 set_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags);
1659 *frame = data[0];
1660 }
1661 break;
1662 }
1663
1664 case VIDEO_PLAY: {
1665 struct video_command vc;
1666
1667 IVTV_DEBUG_IOCTL("VIDEO_PLAY\n");
1668 memset(&vc, 0, sizeof(vc));
1669 vc.cmd = VIDEO_CMD_PLAY;
1670 return ivtv_video_command(itv, id, &vc, 0);
1671 }
1672
1673 case VIDEO_STOP: {
1674 struct video_command vc;
1675
1676 IVTV_DEBUG_IOCTL("VIDEO_STOP\n");
1677 memset(&vc, 0, sizeof(vc));
1678 vc.cmd = VIDEO_CMD_STOP;
1679 vc.flags = VIDEO_CMD_STOP_TO_BLACK | VIDEO_CMD_STOP_IMMEDIATELY;
1680 return ivtv_video_command(itv, id, &vc, 0);
1681 }
1682
1683 case VIDEO_FREEZE: {
1684 struct video_command vc;
1685
1686 IVTV_DEBUG_IOCTL("VIDEO_FREEZE\n");
1687 memset(&vc, 0, sizeof(vc));
1688 vc.cmd = VIDEO_CMD_FREEZE;
1689 return ivtv_video_command(itv, id, &vc, 0);
1690 }
1691
1692 case VIDEO_CONTINUE: {
1693 struct video_command vc;
1694
1695 IVTV_DEBUG_IOCTL("VIDEO_CONTINUE\n");
1696 memset(&vc, 0, sizeof(vc));
1697 vc.cmd = VIDEO_CMD_CONTINUE;
1698 return ivtv_video_command(itv, id, &vc, 0);
1699 }
1700
1701 case VIDEO_COMMAND:
1702 case VIDEO_TRY_COMMAND: {
1703 struct video_command *vc = arg;
1704 int try = (cmd == VIDEO_TRY_COMMAND);
1705
1706 if (try)
1707 IVTV_DEBUG_IOCTL("VIDEO_TRY_COMMAND %d\n", vc->cmd);
1708 else
1709 IVTV_DEBUG_IOCTL("VIDEO_COMMAND %d\n", vc->cmd);
1710 return ivtv_video_command(itv, id, vc, try);
1711 }
1712
1713 case VIDEO_GET_EVENT: {
1714 struct video_event *ev = arg;
1715 DEFINE_WAIT(wait);
1716
1717 IVTV_DEBUG_IOCTL("VIDEO_GET_EVENT\n");
1718 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1719 return -EINVAL;
1720 memset(ev, 0, sizeof(*ev));
1721 set_bit(IVTV_F_I_EV_VSYNC_ENABLED, &itv->i_flags);
1722
1723 while (1) {
1724 if (test_and_clear_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags))
1725 ev->type = VIDEO_EVENT_DECODER_STOPPED;
1726 else if (test_and_clear_bit(IVTV_F_I_EV_VSYNC, &itv->i_flags)) {
1727 ev->type = VIDEO_EVENT_VSYNC;
1728 ev->u.vsync_field = test_bit(IVTV_F_I_EV_VSYNC_FIELD, &itv->i_flags) ?
1729 VIDEO_VSYNC_FIELD_ODD : VIDEO_VSYNC_FIELD_EVEN;
1730 if (itv->output_mode == OUT_UDMA_YUV &&
1731 (itv->yuv_info.lace_mode & IVTV_YUV_MODE_MASK) ==
1732 IVTV_YUV_MODE_PROGRESSIVE) {
1733 ev->u.vsync_field = VIDEO_VSYNC_FIELD_PROGRESSIVE;
1734 }
1735 }
1736 if (ev->type)
1737 return 0;
1738 if (nonblocking)
1739 return -EAGAIN;
1740 /* Wait for event. Note that serialize_lock is locked,
1741 so to allow other processes to access the driver while
1742 we are waiting unlock first and later lock again. */
1743 mutex_unlock(&itv->serialize_lock);
1744 prepare_to_wait(&itv->event_waitq, &wait, TASK_INTERRUPTIBLE);
1745 if (!test_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags) &&
1746 !test_bit(IVTV_F_I_EV_VSYNC, &itv->i_flags))
1747 schedule();
1748 finish_wait(&itv->event_waitq, &wait);
1749 mutex_lock(&itv->serialize_lock);
1750 if (signal_pending(current)) {
1751 /* return if a signal was received */
1752 IVTV_DEBUG_INFO("User stopped wait for event\n");
1753 return -EINTR;
1754 }
1755 }
1756 break;
1757 }
1758
1759 case VIDEO_SELECT_SOURCE:
1760 IVTV_DEBUG_IOCTL("VIDEO_SELECT_SOURCE\n");
1761 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1762 return -EINVAL;
1763 return ivtv_passthrough_mode(itv, iarg == VIDEO_SOURCE_DEMUX);
1764
1765 case AUDIO_SET_MUTE:
1766 IVTV_DEBUG_IOCTL("AUDIO_SET_MUTE\n");
1767 itv->speed_mute_audio = iarg;
1768 return 0;
1769
1770 case AUDIO_CHANNEL_SELECT:
1771 IVTV_DEBUG_IOCTL("AUDIO_CHANNEL_SELECT\n");
1772 if (iarg > AUDIO_STEREO_SWAPPED)
1773 return -EINVAL;
1774 itv->audio_stereo_mode = iarg;
1775 ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode);
1776 return 0;
1777
1778 case AUDIO_BILINGUAL_CHANNEL_SELECT:
1779 IVTV_DEBUG_IOCTL("AUDIO_BILINGUAL_CHANNEL_SELECT\n");
1780 if (iarg > AUDIO_STEREO_SWAPPED)
1781 return -EINVAL;
1782 itv->audio_bilingual_mode = iarg;
1783 ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode);
1784 return 0;
1785
1786 default:
1787 return -EINVAL;
1788 }
1789 return 0;
1790 }
1791
1792 static long ivtv_default(struct file *file, void *fh, bool valid_prio,
1793 int cmd, void *arg)
1794 {
1795 struct ivtv *itv = fh2id(fh)->itv;
1796
1797 if (!valid_prio) {
1798 switch (cmd) {
1799 case VIDEO_PLAY:
1800 case VIDEO_STOP:
1801 case VIDEO_FREEZE:
1802 case VIDEO_CONTINUE:
1803 case VIDEO_COMMAND:
1804 case VIDEO_SELECT_SOURCE:
1805 case AUDIO_SET_MUTE:
1806 case AUDIO_CHANNEL_SELECT:
1807 case AUDIO_BILINGUAL_CHANNEL_SELECT:
1808 return -EBUSY;
1809 }
1810 }
1811
1812 switch (cmd) {
1813 case VIDIOC_INT_RESET: {
1814 u32 val = *(u32 *)arg;
1815
1816 if ((val == 0 && itv->options.newi2c) || (val & 0x01))
1817 ivtv_reset_ir_gpio(itv);
1818 if (val & 0x02)
1819 v4l2_subdev_call(itv->sd_video, core, reset, 0);
1820 break;
1821 }
1822
1823 case IVTV_IOC_DMA_FRAME:
1824 case VIDEO_GET_PTS:
1825 case VIDEO_GET_FRAME_COUNT:
1826 case VIDEO_GET_EVENT:
1827 case VIDEO_PLAY:
1828 case VIDEO_STOP:
1829 case VIDEO_FREEZE:
1830 case VIDEO_CONTINUE:
1831 case VIDEO_COMMAND:
1832 case VIDEO_TRY_COMMAND:
1833 case VIDEO_SELECT_SOURCE:
1834 case AUDIO_SET_MUTE:
1835 case AUDIO_CHANNEL_SELECT:
1836 case AUDIO_BILINGUAL_CHANNEL_SELECT:
1837 return ivtv_decoder_ioctls(file, cmd, (void *)arg);
1838
1839 default:
1840 return -EINVAL;
1841 }
1842 return 0;
1843 }
1844
1845 static long ivtv_serialized_ioctl(struct ivtv *itv, struct file *filp,
1846 unsigned int cmd, unsigned long arg)
1847 {
1848 struct video_device *vfd = video_devdata(filp);
1849 long ret;
1850
1851 if (ivtv_debug & IVTV_DBGFLG_IOCTL)
1852 vfd->debug = V4L2_DEBUG_IOCTL | V4L2_DEBUG_IOCTL_ARG;
1853 ret = video_ioctl2(filp, cmd, arg);
1854 vfd->debug = 0;
1855 return ret;
1856 }
1857
1858 long ivtv_v4l2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
1859 {
1860 struct ivtv_open_id *id = fh2id(filp->private_data);
1861 struct ivtv *itv = id->itv;
1862 long res;
1863
1864 /* DQEVENT can block, so this should not run with the serialize lock */
1865 if (cmd == VIDIOC_DQEVENT)
1866 return ivtv_serialized_ioctl(itv, filp, cmd, arg);
1867 mutex_lock(&itv->serialize_lock);
1868 res = ivtv_serialized_ioctl(itv, filp, cmd, arg);
1869 mutex_unlock(&itv->serialize_lock);
1870 return res;
1871 }
1872
1873 static const struct v4l2_ioctl_ops ivtv_ioctl_ops = {
1874 .vidioc_querycap = ivtv_querycap,
1875 .vidioc_s_audio = ivtv_s_audio,
1876 .vidioc_g_audio = ivtv_g_audio,
1877 .vidioc_enumaudio = ivtv_enumaudio,
1878 .vidioc_s_audout = ivtv_s_audout,
1879 .vidioc_g_audout = ivtv_g_audout,
1880 .vidioc_enum_input = ivtv_enum_input,
1881 .vidioc_enum_output = ivtv_enum_output,
1882 .vidioc_enumaudout = ivtv_enumaudout,
1883 .vidioc_cropcap = ivtv_cropcap,
1884 .vidioc_s_crop = ivtv_s_crop,
1885 .vidioc_g_crop = ivtv_g_crop,
1886 .vidioc_g_input = ivtv_g_input,
1887 .vidioc_s_input = ivtv_s_input,
1888 .vidioc_g_output = ivtv_g_output,
1889 .vidioc_s_output = ivtv_s_output,
1890 .vidioc_g_frequency = ivtv_g_frequency,
1891 .vidioc_s_frequency = ivtv_s_frequency,
1892 .vidioc_s_tuner = ivtv_s_tuner,
1893 .vidioc_g_tuner = ivtv_g_tuner,
1894 .vidioc_g_enc_index = ivtv_g_enc_index,
1895 .vidioc_g_fbuf = ivtv_g_fbuf,
1896 .vidioc_s_fbuf = ivtv_s_fbuf,
1897 .vidioc_g_std = ivtv_g_std,
1898 .vidioc_s_std = ivtv_s_std,
1899 .vidioc_overlay = ivtv_overlay,
1900 .vidioc_log_status = ivtv_log_status,
1901 .vidioc_enum_fmt_vid_cap = ivtv_enum_fmt_vid_cap,
1902 .vidioc_encoder_cmd = ivtv_encoder_cmd,
1903 .vidioc_try_encoder_cmd = ivtv_try_encoder_cmd,
1904 .vidioc_enum_fmt_vid_out = ivtv_enum_fmt_vid_out,
1905 .vidioc_g_fmt_vid_cap = ivtv_g_fmt_vid_cap,
1906 .vidioc_g_fmt_vbi_cap = ivtv_g_fmt_vbi_cap,
1907 .vidioc_g_fmt_sliced_vbi_cap = ivtv_g_fmt_sliced_vbi_cap,
1908 .vidioc_g_fmt_vid_out = ivtv_g_fmt_vid_out,
1909 .vidioc_g_fmt_vid_out_overlay = ivtv_g_fmt_vid_out_overlay,
1910 .vidioc_g_fmt_sliced_vbi_out = ivtv_g_fmt_sliced_vbi_out,
1911 .vidioc_s_fmt_vid_cap = ivtv_s_fmt_vid_cap,
1912 .vidioc_s_fmt_vbi_cap = ivtv_s_fmt_vbi_cap,
1913 .vidioc_s_fmt_sliced_vbi_cap = ivtv_s_fmt_sliced_vbi_cap,
1914 .vidioc_s_fmt_vid_out = ivtv_s_fmt_vid_out,
1915 .vidioc_s_fmt_vid_out_overlay = ivtv_s_fmt_vid_out_overlay,
1916 .vidioc_s_fmt_sliced_vbi_out = ivtv_s_fmt_sliced_vbi_out,
1917 .vidioc_try_fmt_vid_cap = ivtv_try_fmt_vid_cap,
1918 .vidioc_try_fmt_vbi_cap = ivtv_try_fmt_vbi_cap,
1919 .vidioc_try_fmt_sliced_vbi_cap = ivtv_try_fmt_sliced_vbi_cap,
1920 .vidioc_try_fmt_vid_out = ivtv_try_fmt_vid_out,
1921 .vidioc_try_fmt_vid_out_overlay = ivtv_try_fmt_vid_out_overlay,
1922 .vidioc_try_fmt_sliced_vbi_out = ivtv_try_fmt_sliced_vbi_out,
1923 .vidioc_g_sliced_vbi_cap = ivtv_g_sliced_vbi_cap,
1924 .vidioc_g_chip_ident = ivtv_g_chip_ident,
1925 #ifdef CONFIG_VIDEO_ADV_DEBUG
1926 .vidioc_g_register = ivtv_g_register,
1927 .vidioc_s_register = ivtv_s_register,
1928 #endif
1929 .vidioc_default = ivtv_default,
1930 .vidioc_subscribe_event = ivtv_subscribe_event,
1931 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1932 };
1933
1934 void ivtv_set_funcs(struct video_device *vdev)
1935 {
1936 vdev->ioctl_ops = &ivtv_ioctl_ops;
1937 }
Linux Btrfs Development