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