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