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 41u16 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 57static 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 63static 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 91void 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 104static 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 115u16 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 128void 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 135int 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 209static 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 248static 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 322static 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 343static 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 367static 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 385static 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 407static 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 448static 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 467static 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 472static 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 495static 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 500static 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 521static 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 555static 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 569static 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 574static 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 603static 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 615static 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 634static 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 679static 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 692static 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 711static 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 736static 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 748static 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 761static 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 775static 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 782static 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 790static 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 803static 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 811static 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 819static 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 826static 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 834static 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 841static 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 878static 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 904static 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 924static 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 946static 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 974static 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 983int 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 1017static 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 1029static 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 1051static 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 1062int 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 1076static 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 1084void 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 1103void 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 1149int 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 1177static 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 1190static 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 1206static 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 1241static 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 1264static 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 1316static 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 1346static 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 1433static 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 1453static 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 1466static 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 1478static 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 1569static 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 1578static 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 1587static 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 1780static 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 1835long 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 1847static 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 1910void ivtv_set_funcs(struct video_device *vdev) 1911{ 1912 vdev->ioctl_ops = &ivtv_ioctl_ops; 1913} 1914