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