?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add linux-next specific files for 20110831
[linux-2.6/next.git] / drivers / media / video / ivtv / ivtv-ioctl.c
blob3e5c090af112bf12fb229bda27166e08db935d3d
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->capabilities = itv->v4l2_cap; /* capabilities */
761 return 0;
762 }
763
764 static int ivtv_enumaudio(struct file *file, void *fh, struct v4l2_audio *vin)
765 {
766 struct ivtv *itv = fh2id(fh)->itv;
767
768 return ivtv_get_audio_input(itv, vin->index, vin);
769 }
770
771 static int ivtv_g_audio(struct file *file, void *fh, struct v4l2_audio *vin)
772 {
773 struct ivtv *itv = fh2id(fh)->itv;
774
775 vin->index = itv->audio_input;
776 return ivtv_get_audio_input(itv, vin->index, vin);
777 }
778
779 static int ivtv_s_audio(struct file *file, void *fh, struct v4l2_audio *vout)
780 {
781 struct ivtv *itv = fh2id(fh)->itv;
782
783 if (vout->index >= itv->nof_audio_inputs)
784 return -EINVAL;
785
786 itv->audio_input = vout->index;
787 ivtv_audio_set_io(itv);
788
789 return 0;
790 }
791
792 static int ivtv_enumaudout(struct file *file, void *fh, struct v4l2_audioout *vin)
793 {
794 struct ivtv *itv = fh2id(fh)->itv;
795
796 /* set it to defaults from our table */
797 return ivtv_get_audio_output(itv, vin->index, vin);
798 }
799
800 static int ivtv_g_audout(struct file *file, void *fh, struct v4l2_audioout *vin)
801 {
802 struct ivtv *itv = fh2id(fh)->itv;
803
804 vin->index = 0;
805 return ivtv_get_audio_output(itv, vin->index, vin);
806 }
807
808 static int ivtv_s_audout(struct file *file, void *fh, struct v4l2_audioout *vout)
809 {
810 struct ivtv *itv = fh2id(fh)->itv;
811
812 return ivtv_get_audio_output(itv, vout->index, vout);
813 }
814
815 static int ivtv_enum_input(struct file *file, void *fh, struct v4l2_input *vin)
816 {
817 struct ivtv *itv = fh2id(fh)->itv;
818
819 /* set it to defaults from our table */
820 return ivtv_get_input(itv, vin->index, vin);
821 }
822
823 static int ivtv_enum_output(struct file *file, void *fh, struct v4l2_output *vout)
824 {
825 struct ivtv *itv = fh2id(fh)->itv;
826
827 return ivtv_get_output(itv, vout->index, vout);
828 }
829
830 static int ivtv_cropcap(struct file *file, void *fh, struct v4l2_cropcap *cropcap)
831 {
832 struct ivtv_open_id *id = fh2id(fh);
833 struct ivtv *itv = id->itv;
834 struct yuv_playback_info *yi = &itv->yuv_info;
835 int streamtype;
836
837 streamtype = id->type;
838
839 if (cropcap->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
840 return -EINVAL;
841 cropcap->bounds.top = cropcap->bounds.left = 0;
842 cropcap->bounds.width = 720;
843 if (cropcap->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
844 cropcap->bounds.height = itv->is_50hz ? 576 : 480;
845 cropcap->pixelaspect.numerator = itv->is_50hz ? 59 : 10;
846 cropcap->pixelaspect.denominator = itv->is_50hz ? 54 : 11;
847 } else if (streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
848 if (yi->track_osd) {
849 cropcap->bounds.width = yi->osd_full_w;
850 cropcap->bounds.height = yi->osd_full_h;
851 } else {
852 cropcap->bounds.width = 720;
853 cropcap->bounds.height =
854 itv->is_out_50hz ? 576 : 480;
855 }
856 cropcap->pixelaspect.numerator = itv->is_out_50hz ? 59 : 10;
857 cropcap->pixelaspect.denominator = itv->is_out_50hz ? 54 : 11;
858 } else {
859 cropcap->bounds.height = itv->is_out_50hz ? 576 : 480;
860 cropcap->pixelaspect.numerator = itv->is_out_50hz ? 59 : 10;
861 cropcap->pixelaspect.denominator = itv->is_out_50hz ? 54 : 11;
862 }
863 cropcap->defrect = cropcap->bounds;
864 return 0;
865 }
866
867 static int ivtv_s_crop(struct file *file, void *fh, struct v4l2_crop *crop)
868 {
869 struct ivtv_open_id *id = fh2id(fh);
870 struct ivtv *itv = id->itv;
871 struct yuv_playback_info *yi = &itv->yuv_info;
872 int streamtype;
873
874 streamtype = id->type;
875
876 if (crop->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
877 (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) {
878 if (streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
879 yi->main_rect = crop->c;
880 return 0;
881 } else {
882 if (!ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
883 crop->c.width, crop->c.height, crop->c.left, crop->c.top)) {
884 itv->main_rect = crop->c;
885 return 0;
886 }
887 }
888 return -EINVAL;
889 }
890 return -EINVAL;
891 }
892
893 static int ivtv_g_crop(struct file *file, void *fh, struct v4l2_crop *crop)
894 {
895 struct ivtv_open_id *id = fh2id(fh);
896 struct ivtv *itv = id->itv;
897 struct yuv_playback_info *yi = &itv->yuv_info;
898 int streamtype;
899
900 streamtype = id->type;
901
902 if (crop->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
903 (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) {
904 if (streamtype == IVTV_DEC_STREAM_TYPE_YUV)
905 crop->c = yi->main_rect;
906 else
907 crop->c = itv->main_rect;
908 return 0;
909 }
910 return -EINVAL;
911 }
912
913 static int ivtv_enum_fmt_vid_cap(struct file *file, void *fh, struct v4l2_fmtdesc *fmt)
914 {
915 static struct v4l2_fmtdesc formats[] = {
916 { 0, 0, 0,
917 "HM12 (YUV 4:2:0)", V4L2_PIX_FMT_HM12,
918 { 0, 0, 0, 0 }
919 },
920 { 1, 0, V4L2_FMT_FLAG_COMPRESSED,
921 "MPEG", V4L2_PIX_FMT_MPEG,
922 { 0, 0, 0, 0 }
923 }
924 };
925 enum v4l2_buf_type type = fmt->type;
926
927 if (fmt->index > 1)
928 return -EINVAL;
929
930 *fmt = formats[fmt->index];
931 fmt->type = type;
932 return 0;
933 }
934
935 static int ivtv_enum_fmt_vid_out(struct file *file, void *fh, struct v4l2_fmtdesc *fmt)
936 {
937 struct ivtv *itv = fh2id(fh)->itv;
938
939 static struct v4l2_fmtdesc formats[] = {
940 { 0, 0, 0,
941 "HM12 (YUV 4:2:0)", V4L2_PIX_FMT_HM12,
942 { 0, 0, 0, 0 }
943 },
944 { 1, 0, V4L2_FMT_FLAG_COMPRESSED,
945 "MPEG", V4L2_PIX_FMT_MPEG,
946 { 0, 0, 0, 0 }
947 }
948 };
949 enum v4l2_buf_type type = fmt->type;
950
951 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
952 return -EINVAL;
953
954 if (fmt->index > 1)
955 return -EINVAL;
956
957 *fmt = formats[fmt->index];
958 fmt->type = type;
959
960 return 0;
961 }
962
963 static int ivtv_g_input(struct file *file, void *fh, unsigned int *i)
964 {
965 struct ivtv *itv = fh2id(fh)->itv;
966
967 *i = itv->active_input;
968
969 return 0;
970 }
971
972 int ivtv_s_input(struct file *file, void *fh, unsigned int inp)
973 {
974 struct ivtv *itv = fh2id(fh)->itv;
975
976 if (inp < 0 || inp >= itv->nof_inputs)
977 return -EINVAL;
978
979 if (inp == itv->active_input) {
980 IVTV_DEBUG_INFO("Input unchanged\n");
981 return 0;
982 }
983
984 if (atomic_read(&itv->capturing) > 0) {
985 return -EBUSY;
986 }
987
988 IVTV_DEBUG_INFO("Changing input from %d to %d\n",
989 itv->active_input, inp);
990
991 itv->active_input = inp;
992 /* Set the audio input to whatever is appropriate for the
993 input type. */
994 itv->audio_input = itv->card->video_inputs[inp].audio_index;
995
996 /* prevent others from messing with the streams until
997 we're finished changing inputs. */
998 ivtv_mute(itv);
999 ivtv_video_set_io(itv);
1000 ivtv_audio_set_io(itv);
1001 ivtv_unmute(itv);
1002
1003 return 0;
1004 }
1005
1006 static int ivtv_g_output(struct file *file, void *fh, unsigned int *i)
1007 {
1008 struct ivtv *itv = fh2id(fh)->itv;
1009
1010 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1011 return -EINVAL;
1012
1013 *i = itv->active_output;
1014
1015 return 0;
1016 }
1017
1018 static int ivtv_s_output(struct file *file, void *fh, unsigned int outp)
1019 {
1020 struct ivtv *itv = fh2id(fh)->itv;
1021
1022 if (outp >= itv->card->nof_outputs)
1023 return -EINVAL;
1024
1025 if (outp == itv->active_output) {
1026 IVTV_DEBUG_INFO("Output unchanged\n");
1027 return 0;
1028 }
1029 IVTV_DEBUG_INFO("Changing output from %d to %d\n",
1030 itv->active_output, outp);
1031
1032 itv->active_output = outp;
1033 ivtv_call_hw(itv, IVTV_HW_SAA7127, video, s_routing,
1034 SAA7127_INPUT_TYPE_NORMAL,
1035 itv->card->video_outputs[outp].video_output, 0);
1036
1037 return 0;
1038 }
1039
1040 static int ivtv_g_frequency(struct file *file, void *fh, struct v4l2_frequency *vf)
1041 {
1042 struct ivtv *itv = fh2id(fh)->itv;
1043
1044 if (vf->tuner != 0)
1045 return -EINVAL;
1046
1047 ivtv_call_all(itv, tuner, g_frequency, vf);
1048 return 0;
1049 }
1050
1051 int ivtv_s_frequency(struct file *file, void *fh, struct v4l2_frequency *vf)
1052 {
1053 struct ivtv *itv = fh2id(fh)->itv;
1054
1055 if (vf->tuner != 0)
1056 return -EINVAL;
1057
1058 ivtv_mute(itv);
1059 IVTV_DEBUG_INFO("v4l2 ioctl: set frequency %d\n", vf->frequency);
1060 ivtv_call_all(itv, tuner, s_frequency, vf);
1061 ivtv_unmute(itv);
1062 return 0;
1063 }
1064
1065 static int ivtv_g_std(struct file *file, void *fh, v4l2_std_id *std)
1066 {
1067 struct ivtv *itv = fh2id(fh)->itv;
1068
1069 *std = itv->std;
1070 return 0;
1071 }
1072
1073 void ivtv_s_std_enc(struct ivtv *itv, v4l2_std_id *std)
1074 {
1075 itv->std = *std;
1076 itv->is_60hz = (*std & V4L2_STD_525_60) ? 1 : 0;
1077 itv->is_50hz = !itv->is_60hz;
1078 cx2341x_handler_set_50hz(&itv->cxhdl, itv->is_50hz);
1079 itv->cxhdl.width = 720;
1080 itv->cxhdl.height = itv->is_50hz ? 576 : 480;
1081 itv->vbi.count = itv->is_50hz ? 18 : 12;
1082 itv->vbi.start[0] = itv->is_50hz ? 6 : 10;
1083 itv->vbi.start[1] = itv->is_50hz ? 318 : 273;
1084
1085 if (itv->hw_flags & IVTV_HW_CX25840)
1086 itv->vbi.sliced_decoder_line_size = itv->is_60hz ? 272 : 284;
1087
1088 /* Tuner */
1089 ivtv_call_all(itv, core, s_std, itv->std);
1090 }
1091
1092 void ivtv_s_std_dec(struct ivtv *itv, v4l2_std_id *std)
1093 {
1094 struct yuv_playback_info *yi = &itv->yuv_info;
1095 DEFINE_WAIT(wait);
1096 int f;
1097
1098 /* set display standard */
1099 itv->std_out = *std;
1100 itv->is_out_60hz = (*std & V4L2_STD_525_60) ? 1 : 0;
1101 itv->is_out_50hz = !itv->is_out_60hz;
1102 ivtv_call_all(itv, video, s_std_output, itv->std_out);
1103
1104 /*
1105 * The next firmware call is time sensitive. Time it to
1106 * avoid risk of a hard lock, by trying to ensure the call
1107 * happens within the first 100 lines of the top field.
1108 * Make 4 attempts to sync to the decoder before giving up.
1109 */
1110 for (f = 0; f < 4; f++) {
1111 prepare_to_wait(&itv->vsync_waitq, &wait,
1112 TASK_UNINTERRUPTIBLE);
1113 if ((read_reg(IVTV_REG_DEC_LINE_FIELD) >> 16) < 100)
1114 break;
1115 schedule_timeout(msecs_to_jiffies(25));
1116 }
1117 finish_wait(&itv->vsync_waitq, &wait);
1118
1119 if (f == 4)
1120 IVTV_WARN("Mode change failed to sync to decoder\n");
1121
1122 ivtv_vapi(itv, CX2341X_DEC_SET_STANDARD, 1, itv->is_out_50hz);
1123 itv->main_rect.left = 0;
1124 itv->main_rect.top = 0;
1125 itv->main_rect.width = 720;
1126 itv->main_rect.height = itv->is_out_50hz ? 576 : 480;
1127 ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
1128 720, itv->main_rect.height, 0, 0);
1129 yi->main_rect = itv->main_rect;
1130 if (!itv->osd_info) {
1131 yi->osd_full_w = 720;
1132 yi->osd_full_h = itv->is_out_50hz ? 576 : 480;
1133 }
1134 }
1135
1136 int ivtv_s_std(struct file *file, void *fh, v4l2_std_id *std)
1137 {
1138 struct ivtv *itv = fh2id(fh)->itv;
1139
1140 if ((*std & V4L2_STD_ALL) == 0)
1141 return -EINVAL;
1142
1143 if (*std == itv->std)
1144 return 0;
1145
1146 if (test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ||
1147 atomic_read(&itv->capturing) > 0 ||
1148 atomic_read(&itv->decoding) > 0) {
1149 /* Switching standard would mess with already running
1150 streams, prevent that by returning EBUSY. */
1151 return -EBUSY;
1152 }
1153
1154 IVTV_DEBUG_INFO("Switching standard to %llx.\n",
1155 (unsigned long long)itv->std);
1156
1157 ivtv_s_std_enc(itv, std);
1158 if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)
1159 ivtv_s_std_dec(itv, std);
1160
1161 return 0;
1162 }
1163
1164 static int ivtv_s_tuner(struct file *file, void *fh, struct v4l2_tuner *vt)
1165 {
1166 struct ivtv_open_id *id = fh2id(fh);
1167 struct ivtv *itv = id->itv;
1168
1169 if (vt->index != 0)
1170 return -EINVAL;
1171
1172 ivtv_call_all(itv, tuner, s_tuner, vt);
1173
1174 return 0;
1175 }
1176
1177 static int ivtv_g_tuner(struct file *file, void *fh, struct v4l2_tuner *vt)
1178 {
1179 struct ivtv *itv = fh2id(fh)->itv;
1180
1181 if (vt->index != 0)
1182 return -EINVAL;
1183
1184 ivtv_call_all(itv, tuner, g_tuner, vt);
1185
1186 if (vt->type == V4L2_TUNER_RADIO)
1187 strlcpy(vt->name, "ivtv Radio Tuner", sizeof(vt->name));
1188 else
1189 strlcpy(vt->name, "ivtv TV Tuner", sizeof(vt->name));
1190 return 0;
1191 }
1192
1193 static int ivtv_g_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_sliced_vbi_cap *cap)
1194 {
1195 struct ivtv *itv = fh2id(fh)->itv;
1196 int set = itv->is_50hz ? V4L2_SLICED_VBI_625 : V4L2_SLICED_VBI_525;
1197 int f, l;
1198
1199 if (cap->type == V4L2_BUF_TYPE_SLICED_VBI_CAPTURE) {
1200 for (f = 0; f < 2; f++) {
1201 for (l = 0; l < 24; l++) {
1202 if (valid_service_line(f, l, itv->is_50hz))
1203 cap->service_lines[f][l] = set;
1204 }
1205 }
1206 return 0;
1207 }
1208 if (cap->type == V4L2_BUF_TYPE_SLICED_VBI_OUTPUT) {
1209 if (!(itv->v4l2_cap & V4L2_CAP_SLICED_VBI_OUTPUT))
1210 return -EINVAL;
1211 if (itv->is_60hz) {
1212 cap->service_lines[0][21] = V4L2_SLICED_CAPTION_525;
1213 cap->service_lines[1][21] = V4L2_SLICED_CAPTION_525;
1214 } else {
1215 cap->service_lines[0][23] = V4L2_SLICED_WSS_625;
1216 cap->service_lines[0][16] = V4L2_SLICED_VPS;
1217 }
1218 return 0;
1219 }
1220 return -EINVAL;
1221 }
1222
1223 static int ivtv_g_enc_index(struct file *file, void *fh, struct v4l2_enc_idx *idx)
1224 {
1225 struct ivtv *itv = fh2id(fh)->itv;
1226 struct v4l2_enc_idx_entry *e = idx->entry;
1227 int entries;
1228 int i;
1229
1230 entries = (itv->pgm_info_write_idx + IVTV_MAX_PGM_INDEX - itv->pgm_info_read_idx) %
1231 IVTV_MAX_PGM_INDEX;
1232 if (entries > V4L2_ENC_IDX_ENTRIES)
1233 entries = V4L2_ENC_IDX_ENTRIES;
1234 idx->entries = 0;
1235 for (i = 0; i < entries; i++) {
1236 *e = itv->pgm_info[(itv->pgm_info_read_idx + i) % IVTV_MAX_PGM_INDEX];
1237 if ((e->flags & V4L2_ENC_IDX_FRAME_MASK) <= V4L2_ENC_IDX_FRAME_B) {
1238 idx->entries++;
1239 e++;
1240 }
1241 }
1242 itv->pgm_info_read_idx = (itv->pgm_info_read_idx + idx->entries) % IVTV_MAX_PGM_INDEX;
1243 return 0;
1244 }
1245
1246 static int ivtv_encoder_cmd(struct file *file, void *fh, struct v4l2_encoder_cmd *enc)
1247 {
1248 struct ivtv_open_id *id = fh2id(fh);
1249 struct ivtv *itv = id->itv;
1250
1251
1252 switch (enc->cmd) {
1253 case V4L2_ENC_CMD_START:
1254 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
1255 enc->flags = 0;
1256 return ivtv_start_capture(id);
1257
1258 case V4L2_ENC_CMD_STOP:
1259 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
1260 enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END;
1261 ivtv_stop_capture(id, enc->flags & V4L2_ENC_CMD_STOP_AT_GOP_END);
1262 return 0;
1263
1264 case V4L2_ENC_CMD_PAUSE:
1265 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
1266 enc->flags = 0;
1267
1268 if (!atomic_read(&itv->capturing))
1269 return -EPERM;
1270 if (test_and_set_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags))
1271 return 0;
1272
1273 ivtv_mute(itv);
1274 ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 0);
1275 break;
1276
1277 case V4L2_ENC_CMD_RESUME:
1278 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
1279 enc->flags = 0;
1280
1281 if (!atomic_read(&itv->capturing))
1282 return -EPERM;
1283
1284 if (!test_and_clear_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags))
1285 return 0;
1286
1287 ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 1);
1288 ivtv_unmute(itv);
1289 break;
1290 default:
1291 IVTV_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd);
1292 return -EINVAL;
1293 }
1294
1295 return 0;
1296 }
1297
1298 static int ivtv_try_encoder_cmd(struct file *file, void *fh, struct v4l2_encoder_cmd *enc)
1299 {
1300 struct ivtv *itv = fh2id(fh)->itv;
1301
1302 switch (enc->cmd) {
1303 case V4L2_ENC_CMD_START:
1304 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
1305 enc->flags = 0;
1306 return 0;
1307
1308 case V4L2_ENC_CMD_STOP:
1309 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
1310 enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END;
1311 return 0;
1312
1313 case V4L2_ENC_CMD_PAUSE:
1314 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
1315 enc->flags = 0;
1316 return 0;
1317
1318 case V4L2_ENC_CMD_RESUME:
1319 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
1320 enc->flags = 0;
1321 return 0;
1322 default:
1323 IVTV_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd);
1324 return -EINVAL;
1325 }
1326 }
1327
1328 static int ivtv_g_fbuf(struct file *file, void *fh, struct v4l2_framebuffer *fb)
1329 {
1330 struct ivtv *itv = fh2id(fh)->itv;
1331 u32 data[CX2341X_MBOX_MAX_DATA];
1332 struct yuv_playback_info *yi = &itv->yuv_info;
1333
1334 int pixfmt;
1335 static u32 pixel_format[16] = {
1336 V4L2_PIX_FMT_PAL8, /* Uses a 256-entry RGB colormap */
1337 V4L2_PIX_FMT_RGB565,
1338 V4L2_PIX_FMT_RGB555,
1339 V4L2_PIX_FMT_RGB444,
1340 V4L2_PIX_FMT_RGB32,
1341 0,
1342 0,
1343 0,
1344 V4L2_PIX_FMT_PAL8, /* Uses a 256-entry YUV colormap */
1345 V4L2_PIX_FMT_YUV565,
1346 V4L2_PIX_FMT_YUV555,
1347 V4L2_PIX_FMT_YUV444,
1348 V4L2_PIX_FMT_YUV32,
1349 0,
1350 0,
1351 0,
1352 };
1353
1354 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1355 return -EINVAL;
1356 if (!itv->osd_video_pbase)
1357 return -EINVAL;
1358
1359 fb->capability = V4L2_FBUF_CAP_EXTERNOVERLAY | V4L2_FBUF_CAP_CHROMAKEY |
1360 V4L2_FBUF_CAP_GLOBAL_ALPHA;
1361
1362 ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0);
1363 data[0] |= (read_reg(0x2a00) >> 7) & 0x40;
1364 pixfmt = (data[0] >> 3) & 0xf;
1365
1366 fb->fmt.pixelformat = pixel_format[pixfmt];
1367 fb->fmt.width = itv->osd_rect.width;
1368 fb->fmt.height = itv->osd_rect.height;
1369 fb->fmt.field = V4L2_FIELD_INTERLACED;
1370 fb->fmt.bytesperline = fb->fmt.width;
1371 fb->fmt.colorspace = V4L2_COLORSPACE_SMPTE170M;
1372 fb->fmt.field = V4L2_FIELD_INTERLACED;
1373 fb->fmt.priv = 0;
1374 if (fb->fmt.pixelformat != V4L2_PIX_FMT_PAL8)
1375 fb->fmt.bytesperline *= 2;
1376 if (fb->fmt.pixelformat == V4L2_PIX_FMT_RGB32 ||
1377 fb->fmt.pixelformat == V4L2_PIX_FMT_YUV32)
1378 fb->fmt.bytesperline *= 2;
1379 fb->fmt.sizeimage = fb->fmt.bytesperline * fb->fmt.height;
1380 fb->base = (void *)itv->osd_video_pbase;
1381 fb->flags = 0;
1382
1383 if (itv->osd_chroma_key_state)
1384 fb->flags |= V4L2_FBUF_FLAG_CHROMAKEY;
1385
1386 if (itv->osd_global_alpha_state)
1387 fb->flags |= V4L2_FBUF_FLAG_GLOBAL_ALPHA;
1388
1389 if (yi->track_osd)
1390 fb->flags |= V4L2_FBUF_FLAG_OVERLAY;
1391
1392 pixfmt &= 7;
1393
1394 /* no local alpha for RGB565 or unknown formats */
1395 if (pixfmt == 1 || pixfmt > 4)
1396 return 0;
1397
1398 /* 16-bit formats have inverted local alpha */
1399 if (pixfmt == 2 || pixfmt == 3)
1400 fb->capability |= V4L2_FBUF_CAP_LOCAL_INV_ALPHA;
1401 else
1402 fb->capability |= V4L2_FBUF_CAP_LOCAL_ALPHA;
1403
1404 if (itv->osd_local_alpha_state) {
1405 /* 16-bit formats have inverted local alpha */
1406 if (pixfmt == 2 || pixfmt == 3)
1407 fb->flags |= V4L2_FBUF_FLAG_LOCAL_INV_ALPHA;
1408 else
1409 fb->flags |= V4L2_FBUF_FLAG_LOCAL_ALPHA;
1410 }
1411
1412 return 0;
1413 }
1414
1415 static int ivtv_s_fbuf(struct file *file, void *fh, struct v4l2_framebuffer *fb)
1416 {
1417 struct ivtv_open_id *id = fh2id(fh);
1418 struct ivtv *itv = id->itv;
1419 struct yuv_playback_info *yi = &itv->yuv_info;
1420
1421 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1422 return -EINVAL;
1423 if (!itv->osd_video_pbase)
1424 return -EINVAL;
1425
1426 itv->osd_global_alpha_state = (fb->flags & V4L2_FBUF_FLAG_GLOBAL_ALPHA) != 0;
1427 itv->osd_local_alpha_state =
1428 (fb->flags & (V4L2_FBUF_FLAG_LOCAL_ALPHA|V4L2_FBUF_FLAG_LOCAL_INV_ALPHA)) != 0;
1429 itv->osd_chroma_key_state = (fb->flags & V4L2_FBUF_FLAG_CHROMAKEY) != 0;
1430 ivtv_set_osd_alpha(itv);
1431 yi->track_osd = (fb->flags & V4L2_FBUF_FLAG_OVERLAY) != 0;
1432 return ivtv_g_fbuf(file, fh, fb);
1433 }
1434
1435 static int ivtv_overlay(struct file *file, void *fh, unsigned int on)
1436 {
1437 struct ivtv_open_id *id = fh2id(fh);
1438 struct ivtv *itv = id->itv;
1439
1440 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1441 return -EINVAL;
1442
1443 ivtv_vapi(itv, CX2341X_OSD_SET_STATE, 1, on != 0);
1444
1445 return 0;
1446 }
1447
1448 static int ivtv_subscribe_event(struct v4l2_fh *fh, struct v4l2_event_subscription *sub)
1449 {
1450 switch (sub->type) {
1451 case V4L2_EVENT_VSYNC:
1452 case V4L2_EVENT_EOS:
1453 case V4L2_EVENT_CTRL:
1454 return v4l2_event_subscribe(fh, sub, 0);
1455 default:
1456 return -EINVAL;
1457 }
1458 }
1459
1460 static int ivtv_log_status(struct file *file, void *fh)
1461 {
1462 struct ivtv *itv = fh2id(fh)->itv;
1463 u32 data[CX2341X_MBOX_MAX_DATA];
1464
1465 int has_output = itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT;
1466 struct v4l2_input vidin;
1467 struct v4l2_audio audin;
1468 int i;
1469
1470 IVTV_INFO("================= START STATUS CARD #%d =================\n",
1471 itv->instance);
1472 IVTV_INFO("Version: %s Card: %s\n", IVTV_VERSION, itv->card_name);
1473 if (itv->hw_flags & IVTV_HW_TVEEPROM) {
1474 struct tveeprom tv;
1475
1476 ivtv_read_eeprom(itv, &tv);
1477 }
1478 ivtv_call_all(itv, core, log_status);
1479 ivtv_get_input(itv, itv->active_input, &vidin);
1480 ivtv_get_audio_input(itv, itv->audio_input, &audin);
1481 IVTV_INFO("Video Input: %s\n", vidin.name);
1482 IVTV_INFO("Audio Input: %s%s\n", audin.name,
1483 (itv->dualwatch_stereo_mode & ~0x300) == 0x200 ? " (Bilingual)" : "");
1484 if (has_output) {
1485 struct v4l2_output vidout;
1486 struct v4l2_audioout audout;
1487 int mode = itv->output_mode;
1488 static const char * const output_modes[5] = {
1489 "None",
1490 "MPEG Streaming",
1491 "YUV Streaming",
1492 "YUV Frames",
1493 "Passthrough",
1494 };
1495 static const char * const audio_modes[5] = {
1496 "Stereo",
1497 "Left",
1498 "Right",
1499 "Mono",
1500 "Swapped"
1501 };
1502 static const char * const alpha_mode[4] = {
1503 "None",
1504 "Global",
1505 "Local",
1506 "Global and Local"
1507 };
1508 static const char * const pixel_format[16] = {
1509 "ARGB Indexed",
1510 "RGB 5:6:5",
1511 "ARGB 1:5:5:5",
1512 "ARGB 1:4:4:4",
1513 "ARGB 8:8:8:8",
1514 "5",
1515 "6",
1516 "7",
1517 "AYUV Indexed",
1518 "YUV 5:6:5",
1519 "AYUV 1:5:5:5",
1520 "AYUV 1:4:4:4",
1521 "AYUV 8:8:8:8",
1522 "13",
1523 "14",
1524 "15",
1525 };
1526
1527 ivtv_get_output(itv, itv->active_output, &vidout);
1528 ivtv_get_audio_output(itv, 0, &audout);
1529 IVTV_INFO("Video Output: %s\n", vidout.name);
1530 IVTV_INFO("Audio Output: %s (Stereo/Bilingual: %s/%s)\n", audout.name,
1531 audio_modes[itv->audio_stereo_mode],
1532 audio_modes[itv->audio_bilingual_mode]);
1533 if (mode < 0 || mode > OUT_PASSTHROUGH)
1534 mode = OUT_NONE;
1535 IVTV_INFO("Output Mode: %s\n", output_modes[mode]);
1536 ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0);
1537 data[0] |= (read_reg(0x2a00) >> 7) & 0x40;
1538 IVTV_INFO("Overlay: %s, Alpha: %s, Pixel Format: %s\n",
1539 data[0] & 1 ? "On" : "Off",
1540 alpha_mode[(data[0] >> 1) & 0x3],
1541 pixel_format[(data[0] >> 3) & 0xf]);
1542 }
1543 IVTV_INFO("Tuner: %s\n",
1544 test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ? "Radio" : "TV");
1545 v4l2_ctrl_handler_log_status(&itv->cxhdl.hdl, itv->v4l2_dev.name);
1546 IVTV_INFO("Status flags: 0x%08lx\n", itv->i_flags);
1547 for (i = 0; i < IVTV_MAX_STREAMS; i++) {
1548 struct ivtv_stream *s = &itv->streams[i];
1549
1550 if (s->vdev == NULL || s->buffers == 0)
1551 continue;
1552 IVTV_INFO("Stream %s: status 0x%04lx, %d%% of %d KiB (%d buffers) in use\n", s->name, s->s_flags,
1553 (s->buffers - s->q_free.buffers) * 100 / s->buffers,
1554 (s->buffers * s->buf_size) / 1024, s->buffers);
1555 }
1556
1557 IVTV_INFO("Read MPG/VBI: %lld/%lld bytes\n",
1558 (long long)itv->mpg_data_received,
1559 (long long)itv->vbi_data_inserted);
1560 IVTV_INFO("================== END STATUS CARD #%d ==================\n",
1561 itv->instance);
1562
1563 return 0;
1564 }
1565
1566 static int ivtv_decoder_ioctls(struct file *filp, unsigned int cmd, void *arg)
1567 {
1568 struct ivtv_open_id *id = fh2id(filp->private_data);
1569 struct ivtv *itv = id->itv;
1570 int nonblocking = filp->f_flags & O_NONBLOCK;
1571 struct ivtv_stream *s = &itv->streams[id->type];
1572 unsigned long iarg = (unsigned long)arg;
1573
1574 switch (cmd) {
1575 case IVTV_IOC_DMA_FRAME: {
1576 struct ivtv_dma_frame *args = arg;
1577
1578 IVTV_DEBUG_IOCTL("IVTV_IOC_DMA_FRAME\n");
1579 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1580 return -EINVAL;
1581 if (args->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
1582 return -EINVAL;
1583 if (itv->output_mode == OUT_UDMA_YUV && args->y_source == NULL)
1584 return 0;
1585 if (ivtv_start_decoding(id, id->type)) {
1586 return -EBUSY;
1587 }
1588 if (ivtv_set_output_mode(itv, OUT_UDMA_YUV) != OUT_UDMA_YUV) {
1589 ivtv_release_stream(s);
1590 return -EBUSY;
1591 }
1592 /* Mark that this file handle started the UDMA_YUV mode */
1593 id->yuv_frames = 1;
1594 if (args->y_source == NULL)
1595 return 0;
1596 return ivtv_yuv_prep_frame(itv, args);
1597 }
1598
1599 case VIDEO_GET_PTS: {
1600 u32 data[CX2341X_MBOX_MAX_DATA];
1601 u64 *pts = arg;
1602
1603 IVTV_DEBUG_IOCTL("VIDEO_GET_PTS\n");
1604 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) {
1605 *pts = s->dma_pts;
1606 break;
1607 }
1608 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1609 return -EINVAL;
1610
1611 if (test_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags)) {
1612 *pts = (u64) ((u64)itv->last_dec_timing[2] << 32) |
1613 (u64)itv->last_dec_timing[1];
1614 break;
1615 }
1616 *pts = 0;
1617 if (atomic_read(&itv->decoding)) {
1618 if (ivtv_api(itv, CX2341X_DEC_GET_TIMING_INFO, 5, data)) {
1619 IVTV_DEBUG_WARN("GET_TIMING: couldn't read clock\n");
1620 return -EIO;
1621 }
1622 memcpy(itv->last_dec_timing, data, sizeof(itv->last_dec_timing));
1623 set_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags);
1624 *pts = (u64) ((u64) data[2] << 32) | (u64) data[1];
1625 /*timing->scr = (u64) (((u64) data[4] << 32) | (u64) (data[3]));*/
1626 }
1627 break;
1628 }
1629
1630 case VIDEO_GET_FRAME_COUNT: {
1631 u32 data[CX2341X_MBOX_MAX_DATA];
1632 u64 *frame = arg;
1633
1634 IVTV_DEBUG_IOCTL("VIDEO_GET_FRAME_COUNT\n");
1635 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) {
1636 *frame = 0;
1637 break;
1638 }
1639 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1640 return -EINVAL;
1641
1642 if (test_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags)) {
1643 *frame = itv->last_dec_timing[0];
1644 break;
1645 }
1646 *frame = 0;
1647 if (atomic_read(&itv->decoding)) {
1648 if (ivtv_api(itv, CX2341X_DEC_GET_TIMING_INFO, 5, data)) {
1649 IVTV_DEBUG_WARN("GET_TIMING: couldn't read clock\n");
1650 return -EIO;
1651 }
1652 memcpy(itv->last_dec_timing, data, sizeof(itv->last_dec_timing));
1653 set_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags);
1654 *frame = data[0];
1655 }
1656 break;
1657 }
1658
1659 case VIDEO_PLAY: {
1660 struct video_command vc;
1661
1662 IVTV_DEBUG_IOCTL("VIDEO_PLAY\n");
1663 memset(&vc, 0, sizeof(vc));
1664 vc.cmd = VIDEO_CMD_PLAY;
1665 return ivtv_video_command(itv, id, &vc, 0);
1666 }
1667
1668 case VIDEO_STOP: {
1669 struct video_command vc;
1670
1671 IVTV_DEBUG_IOCTL("VIDEO_STOP\n");
1672 memset(&vc, 0, sizeof(vc));
1673 vc.cmd = VIDEO_CMD_STOP;
1674 vc.flags = VIDEO_CMD_STOP_TO_BLACK | VIDEO_CMD_STOP_IMMEDIATELY;
1675 return ivtv_video_command(itv, id, &vc, 0);
1676 }
1677
1678 case VIDEO_FREEZE: {
1679 struct video_command vc;
1680
1681 IVTV_DEBUG_IOCTL("VIDEO_FREEZE\n");
1682 memset(&vc, 0, sizeof(vc));
1683 vc.cmd = VIDEO_CMD_FREEZE;
1684 return ivtv_video_command(itv, id, &vc, 0);
1685 }
1686
1687 case VIDEO_CONTINUE: {
1688 struct video_command vc;
1689
1690 IVTV_DEBUG_IOCTL("VIDEO_CONTINUE\n");
1691 memset(&vc, 0, sizeof(vc));
1692 vc.cmd = VIDEO_CMD_CONTINUE;
1693 return ivtv_video_command(itv, id, &vc, 0);
1694 }
1695
1696 case VIDEO_COMMAND:
1697 case VIDEO_TRY_COMMAND: {
1698 struct video_command *vc = arg;
1699 int try = (cmd == VIDEO_TRY_COMMAND);
1700
1701 if (try)
1702 IVTV_DEBUG_IOCTL("VIDEO_TRY_COMMAND %d\n", vc->cmd);
1703 else
1704 IVTV_DEBUG_IOCTL("VIDEO_COMMAND %d\n", vc->cmd);
1705 return ivtv_video_command(itv, id, vc, try);
1706 }
1707
1708 case VIDEO_GET_EVENT: {
1709 struct video_event *ev = arg;
1710 DEFINE_WAIT(wait);
1711
1712 IVTV_DEBUG_IOCTL("VIDEO_GET_EVENT\n");
1713 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1714 return -EINVAL;
1715 memset(ev, 0, sizeof(*ev));
1716 set_bit(IVTV_F_I_EV_VSYNC_ENABLED, &itv->i_flags);
1717
1718 while (1) {
1719 if (test_and_clear_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags))
1720 ev->type = VIDEO_EVENT_DECODER_STOPPED;
1721 else if (test_and_clear_bit(IVTV_F_I_EV_VSYNC, &itv->i_flags)) {
1722 ev->type = VIDEO_EVENT_VSYNC;
1723 ev->u.vsync_field = test_bit(IVTV_F_I_EV_VSYNC_FIELD, &itv->i_flags) ?
1724 VIDEO_VSYNC_FIELD_ODD : VIDEO_VSYNC_FIELD_EVEN;
1725 if (itv->output_mode == OUT_UDMA_YUV &&
1726 (itv->yuv_info.lace_mode & IVTV_YUV_MODE_MASK) ==
1727 IVTV_YUV_MODE_PROGRESSIVE) {
1728 ev->u.vsync_field = VIDEO_VSYNC_FIELD_PROGRESSIVE;
1729 }
1730 }
1731 if (ev->type)
1732 return 0;
1733 if (nonblocking)
1734 return -EAGAIN;
1735 /* Wait for event. Note that serialize_lock is locked,
1736 so to allow other processes to access the driver while
1737 we are waiting unlock first and later lock again. */
1738 mutex_unlock(&itv->serialize_lock);
1739 prepare_to_wait(&itv->event_waitq, &wait, TASK_INTERRUPTIBLE);
1740 if (!test_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags) &&
1741 !test_bit(IVTV_F_I_EV_VSYNC, &itv->i_flags))
1742 schedule();
1743 finish_wait(&itv->event_waitq, &wait);
1744 mutex_lock(&itv->serialize_lock);
1745 if (signal_pending(current)) {
1746 /* return if a signal was received */
1747 IVTV_DEBUG_INFO("User stopped wait for event\n");
1748 return -EINTR;
1749 }
1750 }
1751 break;
1752 }
1753
1754 case VIDEO_SELECT_SOURCE:
1755 IVTV_DEBUG_IOCTL("VIDEO_SELECT_SOURCE\n");
1756 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1757 return -EINVAL;
1758 return ivtv_passthrough_mode(itv, iarg == VIDEO_SOURCE_DEMUX);
1759
1760 case AUDIO_SET_MUTE:
1761 IVTV_DEBUG_IOCTL("AUDIO_SET_MUTE\n");
1762 itv->speed_mute_audio = iarg;
1763 return 0;
1764
1765 case AUDIO_CHANNEL_SELECT:
1766 IVTV_DEBUG_IOCTL("AUDIO_CHANNEL_SELECT\n");
1767 if (iarg > AUDIO_STEREO_SWAPPED)
1768 return -EINVAL;
1769 itv->audio_stereo_mode = iarg;
1770 ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode);
1771 return 0;
1772
1773 case AUDIO_BILINGUAL_CHANNEL_SELECT:
1774 IVTV_DEBUG_IOCTL("AUDIO_BILINGUAL_CHANNEL_SELECT\n");
1775 if (iarg > AUDIO_STEREO_SWAPPED)
1776 return -EINVAL;
1777 itv->audio_bilingual_mode = iarg;
1778 ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode);
1779 return 0;
1780
1781 default:
1782 return -EINVAL;
1783 }
1784 return 0;
1785 }
1786
1787 static long ivtv_default(struct file *file, void *fh, bool valid_prio,
1788 int cmd, void *arg)
1789 {
1790 struct ivtv *itv = fh2id(fh)->itv;
1791
1792 if (!valid_prio) {
1793 switch (cmd) {
1794 case VIDEO_PLAY:
1795 case VIDEO_STOP:
1796 case VIDEO_FREEZE:
1797 case VIDEO_CONTINUE:
1798 case VIDEO_COMMAND:
1799 case VIDEO_SELECT_SOURCE:
1800 case AUDIO_SET_MUTE:
1801 case AUDIO_CHANNEL_SELECT:
1802 case AUDIO_BILINGUAL_CHANNEL_SELECT:
1803 return -EBUSY;
1804 }
1805 }
1806
1807 switch (cmd) {
1808 case VIDIOC_INT_RESET: {
1809 u32 val = *(u32 *)arg;
1810
1811 if ((val == 0 && itv->options.newi2c) || (val & 0x01))
1812 ivtv_reset_ir_gpio(itv);
1813 if (val & 0x02)
1814 v4l2_subdev_call(itv->sd_video, core, reset, 0);
1815 break;
1816 }
1817
1818 case IVTV_IOC_DMA_FRAME:
1819 case VIDEO_GET_PTS:
1820 case VIDEO_GET_FRAME_COUNT:
1821 case VIDEO_GET_EVENT:
1822 case VIDEO_PLAY:
1823 case VIDEO_STOP:
1824 case VIDEO_FREEZE:
1825 case VIDEO_CONTINUE:
1826 case VIDEO_COMMAND:
1827 case VIDEO_TRY_COMMAND:
1828 case VIDEO_SELECT_SOURCE:
1829 case AUDIO_SET_MUTE:
1830 case AUDIO_CHANNEL_SELECT:
1831 case AUDIO_BILINGUAL_CHANNEL_SELECT:
1832 return ivtv_decoder_ioctls(file, cmd, (void *)arg);
1833
1834 default:
1835 return -EINVAL;
1836 }
1837 return 0;
1838 }
1839
1840 static long ivtv_serialized_ioctl(struct ivtv *itv, struct file *filp,
1841 unsigned int cmd, unsigned long arg)
1842 {
1843 struct video_device *vfd = video_devdata(filp);
1844 long ret;
1845
1846 if (ivtv_debug & IVTV_DBGFLG_IOCTL)
1847 vfd->debug = V4L2_DEBUG_IOCTL | V4L2_DEBUG_IOCTL_ARG;
1848 ret = video_ioctl2(filp, cmd, arg);
1849 vfd->debug = 0;
1850 return ret;
1851 }
1852
1853 long ivtv_v4l2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
1854 {
1855 struct ivtv_open_id *id = fh2id(filp->private_data);
1856 struct ivtv *itv = id->itv;
1857 long res;
1858
1859 /* DQEVENT can block, so this should not run with the serialize lock */
1860 if (cmd == VIDIOC_DQEVENT)
1861 return ivtv_serialized_ioctl(itv, filp, cmd, arg);
1862 mutex_lock(&itv->serialize_lock);
1863 res = ivtv_serialized_ioctl(itv, filp, cmd, arg);
1864 mutex_unlock(&itv->serialize_lock);
1865 return res;
1866 }
1867
1868 static const struct v4l2_ioctl_ops ivtv_ioctl_ops = {
1869 .vidioc_querycap = ivtv_querycap,
1870 .vidioc_s_audio = ivtv_s_audio,
1871 .vidioc_g_audio = ivtv_g_audio,
1872 .vidioc_enumaudio = ivtv_enumaudio,
1873 .vidioc_s_audout = ivtv_s_audout,
1874 .vidioc_g_audout = ivtv_g_audout,
1875 .vidioc_enum_input = ivtv_enum_input,
1876 .vidioc_enum_output = ivtv_enum_output,
1877 .vidioc_enumaudout = ivtv_enumaudout,
1878 .vidioc_cropcap = ivtv_cropcap,
1879 .vidioc_s_crop = ivtv_s_crop,
1880 .vidioc_g_crop = ivtv_g_crop,
1881 .vidioc_g_input = ivtv_g_input,
1882 .vidioc_s_input = ivtv_s_input,
1883 .vidioc_g_output = ivtv_g_output,
1884 .vidioc_s_output = ivtv_s_output,
1885 .vidioc_g_frequency = ivtv_g_frequency,
1886 .vidioc_s_frequency = ivtv_s_frequency,
1887 .vidioc_s_tuner = ivtv_s_tuner,
1888 .vidioc_g_tuner = ivtv_g_tuner,
1889 .vidioc_g_enc_index = ivtv_g_enc_index,
1890 .vidioc_g_fbuf = ivtv_g_fbuf,
1891 .vidioc_s_fbuf = ivtv_s_fbuf,
1892 .vidioc_g_std = ivtv_g_std,
1893 .vidioc_s_std = ivtv_s_std,
1894 .vidioc_overlay = ivtv_overlay,
1895 .vidioc_log_status = ivtv_log_status,
1896 .vidioc_enum_fmt_vid_cap = ivtv_enum_fmt_vid_cap,
1897 .vidioc_encoder_cmd = ivtv_encoder_cmd,
1898 .vidioc_try_encoder_cmd = ivtv_try_encoder_cmd,
1899 .vidioc_enum_fmt_vid_out = ivtv_enum_fmt_vid_out,
1900 .vidioc_g_fmt_vid_cap = ivtv_g_fmt_vid_cap,
1901 .vidioc_g_fmt_vbi_cap = ivtv_g_fmt_vbi_cap,
1902 .vidioc_g_fmt_sliced_vbi_cap = ivtv_g_fmt_sliced_vbi_cap,
1903 .vidioc_g_fmt_vid_out = ivtv_g_fmt_vid_out,
1904 .vidioc_g_fmt_vid_out_overlay = ivtv_g_fmt_vid_out_overlay,
1905 .vidioc_g_fmt_sliced_vbi_out = ivtv_g_fmt_sliced_vbi_out,
1906 .vidioc_s_fmt_vid_cap = ivtv_s_fmt_vid_cap,
1907 .vidioc_s_fmt_vbi_cap = ivtv_s_fmt_vbi_cap,
1908 .vidioc_s_fmt_sliced_vbi_cap = ivtv_s_fmt_sliced_vbi_cap,
1909 .vidioc_s_fmt_vid_out = ivtv_s_fmt_vid_out,
1910 .vidioc_s_fmt_vid_out_overlay = ivtv_s_fmt_vid_out_overlay,
1911 .vidioc_s_fmt_sliced_vbi_out = ivtv_s_fmt_sliced_vbi_out,
1912 .vidioc_try_fmt_vid_cap = ivtv_try_fmt_vid_cap,
1913 .vidioc_try_fmt_vbi_cap = ivtv_try_fmt_vbi_cap,
1914 .vidioc_try_fmt_sliced_vbi_cap = ivtv_try_fmt_sliced_vbi_cap,
1915 .vidioc_try_fmt_vid_out = ivtv_try_fmt_vid_out,
1916 .vidioc_try_fmt_vid_out_overlay = ivtv_try_fmt_vid_out_overlay,
1917 .vidioc_try_fmt_sliced_vbi_out = ivtv_try_fmt_sliced_vbi_out,
1918 .vidioc_g_sliced_vbi_cap = ivtv_g_sliced_vbi_cap,
1919 .vidioc_g_chip_ident = ivtv_g_chip_ident,
1920 #ifdef CONFIG_VIDEO_ADV_DEBUG
1921 .vidioc_g_register = ivtv_g_register,
1922 .vidioc_s_register = ivtv_s_register,
1923 #endif
1924 .vidioc_default = ivtv_default,
1925 .vidioc_subscribe_event = ivtv_subscribe_event,
1926 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1927 };
1928
1929 void ivtv_set_funcs(struct video_device *vdev)
1930 {
1931 vdev->ioctl_ops = &ivtv_ioctl_ops;
1932 }
linux-next