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