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