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