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