?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
FRV: Use generic show_interrupts()
[cris-mirror.git] / drivers / media / video / ivtv / ivtv-ioctl.c
blob1689783cd19aa81261147b35870a485eb16736aa
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 int ivtv_s_std(struct file *file, void *fh, v4l2_std_id *std)
1075 {
1076 DEFINE_WAIT(wait);
1077 struct ivtv *itv = fh2id(fh)->itv;
1078 struct yuv_playback_info *yi = &itv->yuv_info;
1079 int f;
1080
1081 if ((*std & V4L2_STD_ALL) == 0)
1082 return -EINVAL;
1083
1084 if (*std == itv->std)
1085 return 0;
1086
1087 if (test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ||
1088 atomic_read(&itv->capturing) > 0 ||
1089 atomic_read(&itv->decoding) > 0) {
1090 /* Switching standard would turn off the radio or mess
1091 with already running streams, prevent that by
1092 returning EBUSY. */
1093 return -EBUSY;
1094 }
1095
1096 itv->std = *std;
1097 itv->is_60hz = (*std & V4L2_STD_525_60) ? 1 : 0;
1098 itv->is_50hz = !itv->is_60hz;
1099 cx2341x_handler_set_50hz(&itv->cxhdl, itv->is_50hz);
1100 itv->cxhdl.width = 720;
1101 itv->cxhdl.height = itv->is_50hz ? 576 : 480;
1102 itv->vbi.count = itv->is_50hz ? 18 : 12;
1103 itv->vbi.start[0] = itv->is_50hz ? 6 : 10;
1104 itv->vbi.start[1] = itv->is_50hz ? 318 : 273;
1105
1106 if (itv->hw_flags & IVTV_HW_CX25840)
1107 itv->vbi.sliced_decoder_line_size = itv->is_60hz ? 272 : 284;
1108
1109 IVTV_DEBUG_INFO("Switching standard to %llx.\n", (unsigned long long)itv->std);
1110
1111 /* Tuner */
1112 ivtv_call_all(itv, core, s_std, itv->std);
1113
1114 if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT) {
1115 /* set display standard */
1116 itv->std_out = *std;
1117 itv->is_out_60hz = itv->is_60hz;
1118 itv->is_out_50hz = itv->is_50hz;
1119 ivtv_call_all(itv, video, s_std_output, itv->std_out);
1120
1121 /*
1122 * The next firmware call is time sensitive. Time it to
1123 * avoid risk of a hard lock, by trying to ensure the call
1124 * happens within the first 100 lines of the top field.
1125 * Make 4 attempts to sync to the decoder before giving up.
1126 */
1127 for (f = 0; f < 4; f++) {
1128 prepare_to_wait(&itv->vsync_waitq, &wait,
1129 TASK_UNINTERRUPTIBLE);
1130 if ((read_reg(IVTV_REG_DEC_LINE_FIELD) >> 16) < 100)
1131 break;
1132 schedule_timeout(msecs_to_jiffies(25));
1133 }
1134 finish_wait(&itv->vsync_waitq, &wait);
1135
1136 if (f == 4)
1137 IVTV_WARN("Mode change failed to sync to decoder\n");
1138
1139 ivtv_vapi(itv, CX2341X_DEC_SET_STANDARD, 1, itv->is_out_50hz);
1140 itv->main_rect.left = itv->main_rect.top = 0;
1141 itv->main_rect.width = 720;
1142 itv->main_rect.height = itv->cxhdl.height;
1143 ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
1144 720, itv->main_rect.height, 0, 0);
1145 yi->main_rect = itv->main_rect;
1146 if (!itv->osd_info) {
1147 yi->osd_full_w = 720;
1148 yi->osd_full_h = itv->is_out_50hz ? 576 : 480;
1149 }
1150 }
1151 return 0;
1152 }
1153
1154 static int ivtv_s_tuner(struct file *file, void *fh, struct v4l2_tuner *vt)
1155 {
1156 struct ivtv_open_id *id = fh2id(fh);
1157 struct ivtv *itv = id->itv;
1158
1159 if (vt->index != 0)
1160 return -EINVAL;
1161
1162 ivtv_call_all(itv, tuner, s_tuner, vt);
1163
1164 return 0;
1165 }
1166
1167 static int ivtv_g_tuner(struct file *file, void *fh, struct v4l2_tuner *vt)
1168 {
1169 struct ivtv *itv = fh2id(fh)->itv;
1170
1171 if (vt->index != 0)
1172 return -EINVAL;
1173
1174 ivtv_call_all(itv, tuner, g_tuner, vt);
1175
1176 if (test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags)) {
1177 strlcpy(vt->name, "ivtv Radio Tuner", sizeof(vt->name));
1178 vt->type = V4L2_TUNER_RADIO;
1179 } else {
1180 strlcpy(vt->name, "ivtv TV Tuner", sizeof(vt->name));
1181 vt->type = V4L2_TUNER_ANALOG_TV;
1182 }
1183
1184 return 0;
1185 }
1186
1187 static int ivtv_g_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_sliced_vbi_cap *cap)
1188 {
1189 struct ivtv *itv = fh2id(fh)->itv;
1190 int set = itv->is_50hz ? V4L2_SLICED_VBI_625 : V4L2_SLICED_VBI_525;
1191 int f, l;
1192
1193 if (cap->type == V4L2_BUF_TYPE_SLICED_VBI_CAPTURE) {
1194 for (f = 0; f < 2; f++) {
1195 for (l = 0; l < 24; l++) {
1196 if (valid_service_line(f, l, itv->is_50hz))
1197 cap->service_lines[f][l] = set;
1198 }
1199 }
1200 return 0;
1201 }
1202 if (cap->type == V4L2_BUF_TYPE_SLICED_VBI_OUTPUT) {
1203 if (!(itv->v4l2_cap & V4L2_CAP_SLICED_VBI_OUTPUT))
1204 return -EINVAL;
1205 if (itv->is_60hz) {
1206 cap->service_lines[0][21] = V4L2_SLICED_CAPTION_525;
1207 cap->service_lines[1][21] = V4L2_SLICED_CAPTION_525;
1208 } else {
1209 cap->service_lines[0][23] = V4L2_SLICED_WSS_625;
1210 cap->service_lines[0][16] = V4L2_SLICED_VPS;
1211 }
1212 return 0;
1213 }
1214 return -EINVAL;
1215 }
1216
1217 static int ivtv_g_enc_index(struct file *file, void *fh, struct v4l2_enc_idx *idx)
1218 {
1219 struct ivtv *itv = fh2id(fh)->itv;
1220 struct v4l2_enc_idx_entry *e = idx->entry;
1221 int entries;
1222 int i;
1223
1224 entries = (itv->pgm_info_write_idx + IVTV_MAX_PGM_INDEX - itv->pgm_info_read_idx) %
1225 IVTV_MAX_PGM_INDEX;
1226 if (entries > V4L2_ENC_IDX_ENTRIES)
1227 entries = V4L2_ENC_IDX_ENTRIES;
1228 idx->entries = 0;
1229 for (i = 0; i < entries; i++) {
1230 *e = itv->pgm_info[(itv->pgm_info_read_idx + i) % IVTV_MAX_PGM_INDEX];
1231 if ((e->flags & V4L2_ENC_IDX_FRAME_MASK) <= V4L2_ENC_IDX_FRAME_B) {
1232 idx->entries++;
1233 e++;
1234 }
1235 }
1236 itv->pgm_info_read_idx = (itv->pgm_info_read_idx + idx->entries) % IVTV_MAX_PGM_INDEX;
1237 return 0;
1238 }
1239
1240 static int ivtv_encoder_cmd(struct file *file, void *fh, struct v4l2_encoder_cmd *enc)
1241 {
1242 struct ivtv_open_id *id = fh2id(fh);
1243 struct ivtv *itv = id->itv;
1244
1245
1246 switch (enc->cmd) {
1247 case V4L2_ENC_CMD_START:
1248 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
1249 enc->flags = 0;
1250 return ivtv_start_capture(id);
1251
1252 case V4L2_ENC_CMD_STOP:
1253 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
1254 enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END;
1255 ivtv_stop_capture(id, enc->flags & V4L2_ENC_CMD_STOP_AT_GOP_END);
1256 return 0;
1257
1258 case V4L2_ENC_CMD_PAUSE:
1259 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
1260 enc->flags = 0;
1261
1262 if (!atomic_read(&itv->capturing))
1263 return -EPERM;
1264 if (test_and_set_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags))
1265 return 0;
1266
1267 ivtv_mute(itv);
1268 ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 0);
1269 break;
1270
1271 case V4L2_ENC_CMD_RESUME:
1272 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
1273 enc->flags = 0;
1274
1275 if (!atomic_read(&itv->capturing))
1276 return -EPERM;
1277
1278 if (!test_and_clear_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags))
1279 return 0;
1280
1281 ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 1);
1282 ivtv_unmute(itv);
1283 break;
1284 default:
1285 IVTV_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd);
1286 return -EINVAL;
1287 }
1288
1289 return 0;
1290 }
1291
1292 static int ivtv_try_encoder_cmd(struct file *file, void *fh, struct v4l2_encoder_cmd *enc)
1293 {
1294 struct ivtv *itv = fh2id(fh)->itv;
1295
1296 switch (enc->cmd) {
1297 case V4L2_ENC_CMD_START:
1298 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
1299 enc->flags = 0;
1300 return 0;
1301
1302 case V4L2_ENC_CMD_STOP:
1303 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
1304 enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END;
1305 return 0;
1306
1307 case V4L2_ENC_CMD_PAUSE:
1308 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
1309 enc->flags = 0;
1310 return 0;
1311
1312 case V4L2_ENC_CMD_RESUME:
1313 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
1314 enc->flags = 0;
1315 return 0;
1316 default:
1317 IVTV_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd);
1318 return -EINVAL;
1319 }
1320 }
1321
1322 static int ivtv_g_fbuf(struct file *file, void *fh, struct v4l2_framebuffer *fb)
1323 {
1324 struct ivtv *itv = fh2id(fh)->itv;
1325 u32 data[CX2341X_MBOX_MAX_DATA];
1326 struct yuv_playback_info *yi = &itv->yuv_info;
1327
1328 int pixfmt;
1329 static u32 pixel_format[16] = {
1330 V4L2_PIX_FMT_PAL8, /* Uses a 256-entry RGB colormap */
1331 V4L2_PIX_FMT_RGB565,
1332 V4L2_PIX_FMT_RGB555,
1333 V4L2_PIX_FMT_RGB444,
1334 V4L2_PIX_FMT_RGB32,
1335 0,
1336 0,
1337 0,
1338 V4L2_PIX_FMT_PAL8, /* Uses a 256-entry YUV colormap */
1339 V4L2_PIX_FMT_YUV565,
1340 V4L2_PIX_FMT_YUV555,
1341 V4L2_PIX_FMT_YUV444,
1342 V4L2_PIX_FMT_YUV32,
1343 0,
1344 0,
1345 0,
1346 };
1347
1348 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1349 return -EINVAL;
1350 if (!itv->osd_video_pbase)
1351 return -EINVAL;
1352
1353 fb->capability = V4L2_FBUF_CAP_EXTERNOVERLAY | V4L2_FBUF_CAP_CHROMAKEY |
1354 V4L2_FBUF_CAP_GLOBAL_ALPHA;
1355
1356 ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0);
1357 data[0] |= (read_reg(0x2a00) >> 7) & 0x40;
1358 pixfmt = (data[0] >> 3) & 0xf;
1359
1360 fb->fmt.pixelformat = pixel_format[pixfmt];
1361 fb->fmt.width = itv->osd_rect.width;
1362 fb->fmt.height = itv->osd_rect.height;
1363 fb->fmt.field = V4L2_FIELD_INTERLACED;
1364 fb->fmt.bytesperline = fb->fmt.width;
1365 fb->fmt.colorspace = V4L2_COLORSPACE_SMPTE170M;
1366 fb->fmt.field = V4L2_FIELD_INTERLACED;
1367 fb->fmt.priv = 0;
1368 if (fb->fmt.pixelformat != V4L2_PIX_FMT_PAL8)
1369 fb->fmt.bytesperline *= 2;
1370 if (fb->fmt.pixelformat == V4L2_PIX_FMT_RGB32 ||
1371 fb->fmt.pixelformat == V4L2_PIX_FMT_YUV32)
1372 fb->fmt.bytesperline *= 2;
1373 fb->fmt.sizeimage = fb->fmt.bytesperline * fb->fmt.height;
1374 fb->base = (void *)itv->osd_video_pbase;
1375 fb->flags = 0;
1376
1377 if (itv->osd_chroma_key_state)
1378 fb->flags |= V4L2_FBUF_FLAG_CHROMAKEY;
1379
1380 if (itv->osd_global_alpha_state)
1381 fb->flags |= V4L2_FBUF_FLAG_GLOBAL_ALPHA;
1382
1383 if (yi->track_osd)
1384 fb->flags |= V4L2_FBUF_FLAG_OVERLAY;
1385
1386 pixfmt &= 7;
1387
1388 /* no local alpha for RGB565 or unknown formats */
1389 if (pixfmt == 1 || pixfmt > 4)
1390 return 0;
1391
1392 /* 16-bit formats have inverted local alpha */
1393 if (pixfmt == 2 || pixfmt == 3)
1394 fb->capability |= V4L2_FBUF_CAP_LOCAL_INV_ALPHA;
1395 else
1396 fb->capability |= V4L2_FBUF_CAP_LOCAL_ALPHA;
1397
1398 if (itv->osd_local_alpha_state) {
1399 /* 16-bit formats have inverted local alpha */
1400 if (pixfmt == 2 || pixfmt == 3)
1401 fb->flags |= V4L2_FBUF_FLAG_LOCAL_INV_ALPHA;
1402 else
1403 fb->flags |= V4L2_FBUF_FLAG_LOCAL_ALPHA;
1404 }
1405
1406 return 0;
1407 }
1408
1409 static int ivtv_s_fbuf(struct file *file, void *fh, struct v4l2_framebuffer *fb)
1410 {
1411 struct ivtv_open_id *id = fh2id(fh);
1412 struct ivtv *itv = id->itv;
1413 struct yuv_playback_info *yi = &itv->yuv_info;
1414
1415 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1416 return -EINVAL;
1417 if (!itv->osd_video_pbase)
1418 return -EINVAL;
1419
1420 itv->osd_global_alpha_state = (fb->flags & V4L2_FBUF_FLAG_GLOBAL_ALPHA) != 0;
1421 itv->osd_local_alpha_state =
1422 (fb->flags & (V4L2_FBUF_FLAG_LOCAL_ALPHA|V4L2_FBUF_FLAG_LOCAL_INV_ALPHA)) != 0;
1423 itv->osd_chroma_key_state = (fb->flags & V4L2_FBUF_FLAG_CHROMAKEY) != 0;
1424 ivtv_set_osd_alpha(itv);
1425 yi->track_osd = (fb->flags & V4L2_FBUF_FLAG_OVERLAY) != 0;
1426 return ivtv_g_fbuf(file, fh, fb);
1427 }
1428
1429 static int ivtv_overlay(struct file *file, void *fh, unsigned int on)
1430 {
1431 struct ivtv_open_id *id = fh2id(fh);
1432 struct ivtv *itv = id->itv;
1433
1434 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1435 return -EINVAL;
1436
1437 ivtv_vapi(itv, CX2341X_OSD_SET_STATE, 1, on != 0);
1438
1439 return 0;
1440 }
1441
1442 static int ivtv_subscribe_event(struct v4l2_fh *fh, struct v4l2_event_subscription *sub)
1443 {
1444 switch (sub->type) {
1445 case V4L2_EVENT_VSYNC:
1446 case V4L2_EVENT_EOS:
1447 break;
1448 default:
1449 return -EINVAL;
1450 }
1451 return v4l2_event_subscribe(fh, sub);
1452 }
1453
1454 static int ivtv_log_status(struct file *file, void *fh)
1455 {
1456 struct ivtv *itv = fh2id(fh)->itv;
1457 u32 data[CX2341X_MBOX_MAX_DATA];
1458
1459 int has_output = itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT;
1460 struct v4l2_input vidin;
1461 struct v4l2_audio audin;
1462 int i;
1463
1464 IVTV_INFO("================= START STATUS CARD #%d =================\n",
1465 itv->instance);
1466 IVTV_INFO("Version: %s Card: %s\n", IVTV_VERSION, itv->card_name);
1467 if (itv->hw_flags & IVTV_HW_TVEEPROM) {
1468 struct tveeprom tv;
1469
1470 ivtv_read_eeprom(itv, &tv);
1471 }
1472 ivtv_call_all(itv, core, log_status);
1473 ivtv_get_input(itv, itv->active_input, &vidin);
1474 ivtv_get_audio_input(itv, itv->audio_input, &audin);
1475 IVTV_INFO("Video Input: %s\n", vidin.name);
1476 IVTV_INFO("Audio Input: %s%s\n", audin.name,
1477 (itv->dualwatch_stereo_mode & ~0x300) == 0x200 ? " (Bilingual)" : "");
1478 if (has_output) {
1479 struct v4l2_output vidout;
1480 struct v4l2_audioout audout;
1481 int mode = itv->output_mode;
1482 static const char * const output_modes[5] = {
1483 "None",
1484 "MPEG Streaming",
1485 "YUV Streaming",
1486 "YUV Frames",
1487 "Passthrough",
1488 };
1489 static const char * const audio_modes[5] = {
1490 "Stereo",
1491 "Left",
1492 "Right",
1493 "Mono",
1494 "Swapped"
1495 };
1496 static const char * const alpha_mode[4] = {
1497 "None",
1498 "Global",
1499 "Local",
1500 "Global and Local"
1501 };
1502 static const char * const pixel_format[16] = {
1503 "ARGB Indexed",
1504 "RGB 5:6:5",
1505 "ARGB 1:5:5:5",
1506 "ARGB 1:4:4:4",
1507 "ARGB 8:8:8:8",
1508 "5",
1509 "6",
1510 "7",
1511 "AYUV Indexed",
1512 "YUV 5:6:5",
1513 "AYUV 1:5:5:5",
1514 "AYUV 1:4:4:4",
1515 "AYUV 8:8:8:8",
1516 "13",
1517 "14",
1518 "15",
1519 };
1520
1521 ivtv_get_output(itv, itv->active_output, &vidout);
1522 ivtv_get_audio_output(itv, 0, &audout);
1523 IVTV_INFO("Video Output: %s\n", vidout.name);
1524 IVTV_INFO("Audio Output: %s (Stereo/Bilingual: %s/%s)\n", audout.name,
1525 audio_modes[itv->audio_stereo_mode],
1526 audio_modes[itv->audio_bilingual_mode]);
1527 if (mode < 0 || mode > OUT_PASSTHROUGH)
1528 mode = OUT_NONE;
1529 IVTV_INFO("Output Mode: %s\n", output_modes[mode]);
1530 ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0);
1531 data[0] |= (read_reg(0x2a00) >> 7) & 0x40;
1532 IVTV_INFO("Overlay: %s, Alpha: %s, Pixel Format: %s\n",
1533 data[0] & 1 ? "On" : "Off",
1534 alpha_mode[(data[0] >> 1) & 0x3],
1535 pixel_format[(data[0] >> 3) & 0xf]);
1536 }
1537 IVTV_INFO("Tuner: %s\n",
1538 test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ? "Radio" : "TV");
1539 v4l2_ctrl_handler_log_status(&itv->cxhdl.hdl, itv->v4l2_dev.name);
1540 IVTV_INFO("Status flags: 0x%08lx\n", itv->i_flags);
1541 for (i = 0; i < IVTV_MAX_STREAMS; i++) {
1542 struct ivtv_stream *s = &itv->streams[i];
1543
1544 if (s->vdev == NULL || s->buffers == 0)
1545 continue;
1546 IVTV_INFO("Stream %s: status 0x%04lx, %d%% of %d KiB (%d buffers) in use\n", s->name, s->s_flags,
1547 (s->buffers - s->q_free.buffers) * 100 / s->buffers,
1548 (s->buffers * s->buf_size) / 1024, s->buffers);
1549 }
1550
1551 IVTV_INFO("Read MPG/VBI: %lld/%lld bytes\n",
1552 (long long)itv->mpg_data_received,
1553 (long long)itv->vbi_data_inserted);
1554 IVTV_INFO("================== END STATUS CARD #%d ==================\n",
1555 itv->instance);
1556
1557 return 0;
1558 }
1559
1560 static int ivtv_decoder_ioctls(struct file *filp, unsigned int cmd, void *arg)
1561 {
1562 struct ivtv_open_id *id = fh2id(filp->private_data);
1563 struct ivtv *itv = id->itv;
1564 int nonblocking = filp->f_flags & O_NONBLOCK;
1565 struct ivtv_stream *s = &itv->streams[id->type];
1566 unsigned long iarg = (unsigned long)arg;
1567
1568 switch (cmd) {
1569 case IVTV_IOC_DMA_FRAME: {
1570 struct ivtv_dma_frame *args = arg;
1571
1572 IVTV_DEBUG_IOCTL("IVTV_IOC_DMA_FRAME\n");
1573 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1574 return -EINVAL;
1575 if (args->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
1576 return -EINVAL;
1577 if (itv->output_mode == OUT_UDMA_YUV && args->y_source == NULL)
1578 return 0;
1579 if (ivtv_start_decoding(id, id->type)) {
1580 return -EBUSY;
1581 }
1582 if (ivtv_set_output_mode(itv, OUT_UDMA_YUV) != OUT_UDMA_YUV) {
1583 ivtv_release_stream(s);
1584 return -EBUSY;
1585 }
1586 /* Mark that this file handle started the UDMA_YUV mode */
1587 id->yuv_frames = 1;
1588 if (args->y_source == NULL)
1589 return 0;
1590 return ivtv_yuv_prep_frame(itv, args);
1591 }
1592
1593 case VIDEO_GET_PTS: {
1594 u32 data[CX2341X_MBOX_MAX_DATA];
1595 u64 *pts = arg;
1596
1597 IVTV_DEBUG_IOCTL("VIDEO_GET_PTS\n");
1598 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) {
1599 *pts = s->dma_pts;
1600 break;
1601 }
1602 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1603 return -EINVAL;
1604
1605 if (test_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags)) {
1606 *pts = (u64) ((u64)itv->last_dec_timing[2] << 32) |
1607 (u64)itv->last_dec_timing[1];
1608 break;
1609 }
1610 *pts = 0;
1611 if (atomic_read(&itv->decoding)) {
1612 if (ivtv_api(itv, CX2341X_DEC_GET_TIMING_INFO, 5, data)) {
1613 IVTV_DEBUG_WARN("GET_TIMING: couldn't read clock\n");
1614 return -EIO;
1615 }
1616 memcpy(itv->last_dec_timing, data, sizeof(itv->last_dec_timing));
1617 set_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags);
1618 *pts = (u64) ((u64) data[2] << 32) | (u64) data[1];
1619 /*timing->scr = (u64) (((u64) data[4] << 32) | (u64) (data[3]));*/
1620 }
1621 break;
1622 }
1623
1624 case VIDEO_GET_FRAME_COUNT: {
1625 u32 data[CX2341X_MBOX_MAX_DATA];
1626 u64 *frame = arg;
1627
1628 IVTV_DEBUG_IOCTL("VIDEO_GET_FRAME_COUNT\n");
1629 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) {
1630 *frame = 0;
1631 break;
1632 }
1633 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1634 return -EINVAL;
1635
1636 if (test_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags)) {
1637 *frame = itv->last_dec_timing[0];
1638 break;
1639 }
1640 *frame = 0;
1641 if (atomic_read(&itv->decoding)) {
1642 if (ivtv_api(itv, CX2341X_DEC_GET_TIMING_INFO, 5, data)) {
1643 IVTV_DEBUG_WARN("GET_TIMING: couldn't read clock\n");
1644 return -EIO;
1645 }
1646 memcpy(itv->last_dec_timing, data, sizeof(itv->last_dec_timing));
1647 set_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags);
1648 *frame = data[0];
1649 }
1650 break;
1651 }
1652
1653 case VIDEO_PLAY: {
1654 struct video_command vc;
1655
1656 IVTV_DEBUG_IOCTL("VIDEO_PLAY\n");
1657 memset(&vc, 0, sizeof(vc));
1658 vc.cmd = VIDEO_CMD_PLAY;
1659 return ivtv_video_command(itv, id, &vc, 0);
1660 }
1661
1662 case VIDEO_STOP: {
1663 struct video_command vc;
1664
1665 IVTV_DEBUG_IOCTL("VIDEO_STOP\n");
1666 memset(&vc, 0, sizeof(vc));
1667 vc.cmd = VIDEO_CMD_STOP;
1668 vc.flags = VIDEO_CMD_STOP_TO_BLACK | VIDEO_CMD_STOP_IMMEDIATELY;
1669 return ivtv_video_command(itv, id, &vc, 0);
1670 }
1671
1672 case VIDEO_FREEZE: {
1673 struct video_command vc;
1674
1675 IVTV_DEBUG_IOCTL("VIDEO_FREEZE\n");
1676 memset(&vc, 0, sizeof(vc));
1677 vc.cmd = VIDEO_CMD_FREEZE;
1678 return ivtv_video_command(itv, id, &vc, 0);
1679 }
1680
1681 case VIDEO_CONTINUE: {
1682 struct video_command vc;
1683
1684 IVTV_DEBUG_IOCTL("VIDEO_CONTINUE\n");
1685 memset(&vc, 0, sizeof(vc));
1686 vc.cmd = VIDEO_CMD_CONTINUE;
1687 return ivtv_video_command(itv, id, &vc, 0);
1688 }
1689
1690 case VIDEO_COMMAND:
1691 case VIDEO_TRY_COMMAND: {
1692 struct video_command *vc = arg;
1693 int try = (cmd == VIDEO_TRY_COMMAND);
1694
1695 if (try)
1696 IVTV_DEBUG_IOCTL("VIDEO_TRY_COMMAND %d\n", vc->cmd);
1697 else
1698 IVTV_DEBUG_IOCTL("VIDEO_COMMAND %d\n", vc->cmd);
1699 return ivtv_video_command(itv, id, vc, try);
1700 }
1701
1702 case VIDEO_GET_EVENT: {
1703 struct video_event *ev = arg;
1704 DEFINE_WAIT(wait);
1705
1706 IVTV_DEBUG_IOCTL("VIDEO_GET_EVENT\n");
1707 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1708 return -EINVAL;
1709 memset(ev, 0, sizeof(*ev));
1710 set_bit(IVTV_F_I_EV_VSYNC_ENABLED, &itv->i_flags);
1711
1712 while (1) {
1713 if (test_and_clear_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags))
1714 ev->type = VIDEO_EVENT_DECODER_STOPPED;
1715 else if (test_and_clear_bit(IVTV_F_I_EV_VSYNC, &itv->i_flags)) {
1716 ev->type = VIDEO_EVENT_VSYNC;
1717 ev->u.vsync_field = test_bit(IVTV_F_I_EV_VSYNC_FIELD, &itv->i_flags) ?
1718 VIDEO_VSYNC_FIELD_ODD : VIDEO_VSYNC_FIELD_EVEN;
1719 if (itv->output_mode == OUT_UDMA_YUV &&
1720 (itv->yuv_info.lace_mode & IVTV_YUV_MODE_MASK) ==
1721 IVTV_YUV_MODE_PROGRESSIVE) {
1722 ev->u.vsync_field = VIDEO_VSYNC_FIELD_PROGRESSIVE;
1723 }
1724 }
1725 if (ev->type)
1726 return 0;
1727 if (nonblocking)
1728 return -EAGAIN;
1729 /* Wait for event. Note that serialize_lock is locked,
1730 so to allow other processes to access the driver while
1731 we are waiting unlock first and later lock again. */
1732 mutex_unlock(&itv->serialize_lock);
1733 prepare_to_wait(&itv->event_waitq, &wait, TASK_INTERRUPTIBLE);
1734 if (!test_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags) &&
1735 !test_bit(IVTV_F_I_EV_VSYNC, &itv->i_flags))
1736 schedule();
1737 finish_wait(&itv->event_waitq, &wait);
1738 mutex_lock(&itv->serialize_lock);
1739 if (signal_pending(current)) {
1740 /* return if a signal was received */
1741 IVTV_DEBUG_INFO("User stopped wait for event\n");
1742 return -EINTR;
1743 }
1744 }
1745 break;
1746 }
1747
1748 case VIDEO_SELECT_SOURCE:
1749 IVTV_DEBUG_IOCTL("VIDEO_SELECT_SOURCE\n");
1750 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1751 return -EINVAL;
1752 return ivtv_passthrough_mode(itv, iarg == VIDEO_SOURCE_DEMUX);
1753
1754 case AUDIO_SET_MUTE:
1755 IVTV_DEBUG_IOCTL("AUDIO_SET_MUTE\n");
1756 itv->speed_mute_audio = iarg;
1757 return 0;
1758
1759 case AUDIO_CHANNEL_SELECT:
1760 IVTV_DEBUG_IOCTL("AUDIO_CHANNEL_SELECT\n");
1761 if (iarg > AUDIO_STEREO_SWAPPED)
1762 return -EINVAL;
1763 itv->audio_stereo_mode = iarg;
1764 ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode);
1765 return 0;
1766
1767 case AUDIO_BILINGUAL_CHANNEL_SELECT:
1768 IVTV_DEBUG_IOCTL("AUDIO_BILINGUAL_CHANNEL_SELECT\n");
1769 if (iarg > AUDIO_STEREO_SWAPPED)
1770 return -EINVAL;
1771 itv->audio_bilingual_mode = iarg;
1772 ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode);
1773 return 0;
1774
1775 default:
1776 return -EINVAL;
1777 }
1778 return 0;
1779 }
1780
1781 static long ivtv_default(struct file *file, void *fh, bool valid_prio,
1782 int cmd, void *arg)
1783 {
1784 struct ivtv *itv = fh2id(fh)->itv;
1785
1786 if (!valid_prio) {
1787 switch (cmd) {
1788 case VIDEO_PLAY:
1789 case VIDEO_STOP:
1790 case VIDEO_FREEZE:
1791 case VIDEO_CONTINUE:
1792 case VIDEO_COMMAND:
1793 case VIDEO_SELECT_SOURCE:
1794 case AUDIO_SET_MUTE:
1795 case AUDIO_CHANNEL_SELECT:
1796 case AUDIO_BILINGUAL_CHANNEL_SELECT:
1797 return -EBUSY;
1798 }
1799 }
1800
1801 switch (cmd) {
1802 case VIDIOC_INT_RESET: {
1803 u32 val = *(u32 *)arg;
1804
1805 if ((val == 0 && itv->options.newi2c) || (val & 0x01))
1806 ivtv_reset_ir_gpio(itv);
1807 if (val & 0x02)
1808 v4l2_subdev_call(itv->sd_video, core, reset, 0);
1809 break;
1810 }
1811
1812 case IVTV_IOC_DMA_FRAME:
1813 case VIDEO_GET_PTS:
1814 case VIDEO_GET_FRAME_COUNT:
1815 case VIDEO_GET_EVENT:
1816 case VIDEO_PLAY:
1817 case VIDEO_STOP:
1818 case VIDEO_FREEZE:
1819 case VIDEO_CONTINUE:
1820 case VIDEO_COMMAND:
1821 case VIDEO_TRY_COMMAND:
1822 case VIDEO_SELECT_SOURCE:
1823 case AUDIO_SET_MUTE:
1824 case AUDIO_CHANNEL_SELECT:
1825 case AUDIO_BILINGUAL_CHANNEL_SELECT:
1826 return ivtv_decoder_ioctls(file, cmd, (void *)arg);
1827
1828 default:
1829 return -EINVAL;
1830 }
1831 return 0;
1832 }
1833
1834 static long ivtv_serialized_ioctl(struct ivtv *itv, struct file *filp,
1835 unsigned int cmd, unsigned long arg)
1836 {
1837 struct video_device *vfd = video_devdata(filp);
1838 long ret;
1839
1840 if (ivtv_debug & IVTV_DBGFLG_IOCTL)
1841 vfd->debug = V4L2_DEBUG_IOCTL | V4L2_DEBUG_IOCTL_ARG;
1842 ret = video_ioctl2(filp, cmd, arg);
1843 vfd->debug = 0;
1844 return ret;
1845 }
1846
1847 long ivtv_v4l2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
1848 {
1849 struct ivtv_open_id *id = fh2id(filp->private_data);
1850 struct ivtv *itv = id->itv;
1851 long res;
1852
1853 /* DQEVENT can block, so this should not run with the serialize lock */
1854 if (cmd == VIDIOC_DQEVENT)
1855 return ivtv_serialized_ioctl(itv, filp, cmd, arg);
1856 mutex_lock(&itv->serialize_lock);
1857 res = ivtv_serialized_ioctl(itv, filp, cmd, arg);
1858 mutex_unlock(&itv->serialize_lock);
1859 return res;
1860 }
1861
1862 static const struct v4l2_ioctl_ops ivtv_ioctl_ops = {
1863 .vidioc_querycap = ivtv_querycap,
1864 .vidioc_s_audio = ivtv_s_audio,
1865 .vidioc_g_audio = ivtv_g_audio,
1866 .vidioc_enumaudio = ivtv_enumaudio,
1867 .vidioc_s_audout = ivtv_s_audout,
1868 .vidioc_g_audout = ivtv_g_audout,
1869 .vidioc_enum_input = ivtv_enum_input,
1870 .vidioc_enum_output = ivtv_enum_output,
1871 .vidioc_enumaudout = ivtv_enumaudout,
1872 .vidioc_cropcap = ivtv_cropcap,
1873 .vidioc_s_crop = ivtv_s_crop,
1874 .vidioc_g_crop = ivtv_g_crop,
1875 .vidioc_g_input = ivtv_g_input,
1876 .vidioc_s_input = ivtv_s_input,
1877 .vidioc_g_output = ivtv_g_output,
1878 .vidioc_s_output = ivtv_s_output,
1879 .vidioc_g_frequency = ivtv_g_frequency,
1880 .vidioc_s_frequency = ivtv_s_frequency,
1881 .vidioc_s_tuner = ivtv_s_tuner,
1882 .vidioc_g_tuner = ivtv_g_tuner,
1883 .vidioc_g_enc_index = ivtv_g_enc_index,
1884 .vidioc_g_fbuf = ivtv_g_fbuf,
1885 .vidioc_s_fbuf = ivtv_s_fbuf,
1886 .vidioc_g_std = ivtv_g_std,
1887 .vidioc_s_std = ivtv_s_std,
1888 .vidioc_overlay = ivtv_overlay,
1889 .vidioc_log_status = ivtv_log_status,
1890 .vidioc_enum_fmt_vid_cap = ivtv_enum_fmt_vid_cap,
1891 .vidioc_encoder_cmd = ivtv_encoder_cmd,
1892 .vidioc_try_encoder_cmd = ivtv_try_encoder_cmd,
1893 .vidioc_enum_fmt_vid_out = ivtv_enum_fmt_vid_out,
1894 .vidioc_g_fmt_vid_cap = ivtv_g_fmt_vid_cap,
1895 .vidioc_g_fmt_vbi_cap = ivtv_g_fmt_vbi_cap,
1896 .vidioc_g_fmt_sliced_vbi_cap = ivtv_g_fmt_sliced_vbi_cap,
1897 .vidioc_g_fmt_vid_out = ivtv_g_fmt_vid_out,
1898 .vidioc_g_fmt_vid_out_overlay = ivtv_g_fmt_vid_out_overlay,
1899 .vidioc_g_fmt_sliced_vbi_out = ivtv_g_fmt_sliced_vbi_out,
1900 .vidioc_s_fmt_vid_cap = ivtv_s_fmt_vid_cap,
1901 .vidioc_s_fmt_vbi_cap = ivtv_s_fmt_vbi_cap,
1902 .vidioc_s_fmt_sliced_vbi_cap = ivtv_s_fmt_sliced_vbi_cap,
1903 .vidioc_s_fmt_vid_out = ivtv_s_fmt_vid_out,
1904 .vidioc_s_fmt_vid_out_overlay = ivtv_s_fmt_vid_out_overlay,
1905 .vidioc_s_fmt_sliced_vbi_out = ivtv_s_fmt_sliced_vbi_out,
1906 .vidioc_try_fmt_vid_cap = ivtv_try_fmt_vid_cap,
1907 .vidioc_try_fmt_vbi_cap = ivtv_try_fmt_vbi_cap,
1908 .vidioc_try_fmt_sliced_vbi_cap = ivtv_try_fmt_sliced_vbi_cap,
1909 .vidioc_try_fmt_vid_out = ivtv_try_fmt_vid_out,
1910 .vidioc_try_fmt_vid_out_overlay = ivtv_try_fmt_vid_out_overlay,
1911 .vidioc_try_fmt_sliced_vbi_out = ivtv_try_fmt_sliced_vbi_out,
1912 .vidioc_g_sliced_vbi_cap = ivtv_g_sliced_vbi_cap,
1913 .vidioc_g_chip_ident = ivtv_g_chip_ident,
1914 #ifdef CONFIG_VIDEO_ADV_DEBUG
1915 .vidioc_g_register = ivtv_g_register,
1916 .vidioc_s_register = ivtv_s_register,
1917 #endif
1918 .vidioc_default = ivtv_default,
1919 .vidioc_subscribe_event = ivtv_subscribe_event,
1920 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1921 };
1922
1923 void ivtv_set_funcs(struct video_device *vdev)
1924 {
1925 vdev->ioctl_ops = &ivtv_ioctl_ops;
1926 }
CRIS linux kernel tree