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 pixfmt->priv = 0; 355 if (id->type == IVTV_ENC_STREAM_TYPE_YUV) { 356 pixfmt->pixelformat = V4L2_PIX_FMT_HM12; 357 /* YUV size is (Y=(h*720) + UV=(h*(720/2))) */ 358 pixfmt->sizeimage = pixfmt->height * 720 * 3 / 2; 359 pixfmt->bytesperline = 720; 360 } else { 361 pixfmt->pixelformat = V4L2_PIX_FMT_MPEG; 362 pixfmt->sizeimage = 128 * 1024; 363 pixfmt->bytesperline = 0; 364 } 365 return 0; 366 } 367 368 static int ivtv_g_fmt_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt) 369 { 370 struct ivtv *itv = fh2id(fh)->itv; 371 struct v4l2_vbi_format *vbifmt = &fmt->fmt.vbi; 372 373 vbifmt->sampling_rate = 27000000; 374 vbifmt->offset = 248; 375 vbifmt->samples_per_line = itv->vbi.raw_decoder_line_size - 4; 376 vbifmt->sample_format = V4L2_PIX_FMT_GREY; 377 vbifmt->start[0] = itv->vbi.start[0]; 378 vbifmt->start[1] = itv->vbi.start[1]; 379 vbifmt->count[0] = vbifmt->count[1] = itv->vbi.count; 380 vbifmt->flags = 0; 381 vbifmt->reserved[0] = 0; 382 vbifmt->reserved[1] = 0; 383 return 0; 384 } 385 386 static int ivtv_g_fmt_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt) 387 { 388 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced; 389 struct ivtv_open_id *id = fh2id(fh); 390 struct ivtv *itv = id->itv; 391 392 vbifmt->reserved[0] = 0; 393 vbifmt->reserved[1] = 0; 394 vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36; 395 396 if (id->type == IVTV_DEC_STREAM_TYPE_VBI) { 397 vbifmt->service_set = itv->is_50hz ? V4L2_SLICED_VBI_625 : 398 V4L2_SLICED_VBI_525; 399 ivtv_expand_service_set(vbifmt, itv->is_50hz); 400 vbifmt->service_set = ivtv_get_service_set(vbifmt); 401 return 0; 402 } 403 404 v4l2_subdev_call(itv->sd_video, vbi, g_sliced_fmt, vbifmt); 405 vbifmt->service_set = ivtv_get_service_set(vbifmt); 406 return 0; 407 } 408 409 static int ivtv_g_fmt_vid_out(struct file *file, void *fh, struct v4l2_format *fmt) 410 { 411 struct ivtv_open_id *id = fh2id(fh); 412 struct ivtv *itv = id->itv; 413 struct v4l2_pix_format *pixfmt = &fmt->fmt.pix; 414 415 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) 416 return -EINVAL; 417 pixfmt->width = itv->main_rect.width; 418 pixfmt->height = itv->main_rect.height; 419 pixfmt->colorspace = V4L2_COLORSPACE_SMPTE170M; 420 pixfmt->field = V4L2_FIELD_INTERLACED; 421 pixfmt->priv = 0; 422 if (id->type == IVTV_DEC_STREAM_TYPE_YUV) { 423 switch (itv->yuv_info.lace_mode & IVTV_YUV_MODE_MASK) { 424 case IVTV_YUV_MODE_INTERLACED: 425 pixfmt->field = (itv->yuv_info.lace_mode & IVTV_YUV_SYNC_MASK) ? 426 V4L2_FIELD_INTERLACED_BT : V4L2_FIELD_INTERLACED_TB; 427 break; 428 case IVTV_YUV_MODE_PROGRESSIVE: 429 pixfmt->field = V4L2_FIELD_NONE; 430 break; 431 default: 432 pixfmt->field = V4L2_FIELD_ANY; 433 break; 434 } 435 pixfmt->pixelformat = V4L2_PIX_FMT_HM12; 436 pixfmt->bytesperline = 720; 437 pixfmt->width = itv->yuv_info.v4l2_src_w; 438 pixfmt->height = itv->yuv_info.v4l2_src_h; 439 /* YUV size is (Y=(h*w) + UV=(h*(w/2))) */ 440 pixfmt->sizeimage = 441 1080 * ((pixfmt->height + 31) & ~31); 442 } else { 443 pixfmt->pixelformat = V4L2_PIX_FMT_MPEG; 444 pixfmt->sizeimage = 128 * 1024; 445 pixfmt->bytesperline = 0; 446 } 447 return 0; 448 } 449 450 static int ivtv_g_fmt_vid_out_overlay(struct file *file, void *fh, struct v4l2_format *fmt) 451 { 452 struct ivtv *itv = fh2id(fh)->itv; 453 struct v4l2_window *winfmt = &fmt->fmt.win; 454 455 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) 456 return -EINVAL; 457 winfmt->chromakey = itv->osd_chroma_key; 458 winfmt->global_alpha = itv->osd_global_alpha; 459 winfmt->field = V4L2_FIELD_INTERLACED; 460 winfmt->clips = NULL; 461 winfmt->clipcount = 0; 462 winfmt->bitmap = NULL; 463 winfmt->w.top = winfmt->w.left = 0; 464 winfmt->w.width = itv->osd_rect.width; 465 winfmt->w.height = itv->osd_rect.height; 466 return 0; 467 } 468 469 static int ivtv_try_fmt_sliced_vbi_out(struct file *file, void *fh, struct v4l2_format *fmt) 470 { 471 return ivtv_g_fmt_sliced_vbi_out(file, fh, fmt); 472 } 473 474 static int ivtv_try_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt) 475 { 476 struct ivtv_open_id *id = fh2id(fh); 477 struct ivtv *itv = id->itv; 478 int w = fmt->fmt.pix.width; 479 int h = fmt->fmt.pix.height; 480 int min_h = 2; 481 482 w = min(w, 720); 483 w = max(w, 2); 484 if (id->type == IVTV_ENC_STREAM_TYPE_YUV) { 485 /* YUV height must be a multiple of 32 */ 486 h &= ~0x1f; 487 min_h = 32; 488 } 489 h = min(h, itv->is_50hz ? 576 : 480); 490 h = max(h, min_h); 491 ivtv_g_fmt_vid_cap(file, fh, fmt); 492 fmt->fmt.pix.width = w; 493 fmt->fmt.pix.height = h; 494 return 0; 495 } 496 497 static int ivtv_try_fmt_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt) 498 { 499 return ivtv_g_fmt_vbi_cap(file, fh, fmt); 500 } 501 502 static int ivtv_try_fmt_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt) 503 { 504 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced; 505 struct ivtv_open_id *id = fh2id(fh); 506 struct ivtv *itv = id->itv; 507 508 if (id->type == IVTV_DEC_STREAM_TYPE_VBI) 509 return ivtv_g_fmt_sliced_vbi_cap(file, fh, fmt); 510 511 /* set sliced VBI capture format */ 512 vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36; 513 vbifmt->reserved[0] = 0; 514 vbifmt->reserved[1] = 0; 515 516 if (vbifmt->service_set) 517 ivtv_expand_service_set(vbifmt, itv->is_50hz); 518 check_service_set(vbifmt, itv->is_50hz); 519 vbifmt->service_set = ivtv_get_service_set(vbifmt); 520 return 0; 521 } 522 523 static int ivtv_try_fmt_vid_out(struct file *file, void *fh, struct v4l2_format *fmt) 524 { 525 struct ivtv_open_id *id = fh2id(fh); 526 s32 w = fmt->fmt.pix.width; 527 s32 h = fmt->fmt.pix.height; 528 int field = fmt->fmt.pix.field; 529 int ret = ivtv_g_fmt_vid_out(file, fh, fmt); 530 531 w = min(w, 720); 532 w = max(w, 2); 533 /* Why can the height be 576 even when the output is NTSC? 534 535 Internally the buffers of the PVR350 are always set to 720x576. The 536 decoded video frame will always be placed in the top left corner of 537 this buffer. For any video which is not 720x576, the buffer will 538 then be cropped to remove the unused right and lower areas, with 539 the remaining image being scaled by the hardware to fit the display 540 area. The video can be scaled both up and down, so a 720x480 video 541 can be displayed full-screen on PAL and a 720x576 video can be 542 displayed without cropping on NTSC. 543 544 Note that the scaling only occurs on the video stream, the osd 545 resolution is locked to the broadcast standard and not scaled. 546 547 Thanks to Ian Armstrong for this explanation. */ 548 h = min(h, 576); 549 h = max(h, 2); 550 if (id->type == IVTV_DEC_STREAM_TYPE_YUV) 551 fmt->fmt.pix.field = field; 552 fmt->fmt.pix.width = w; 553 fmt->fmt.pix.height = h; 554 return ret; 555 } 556 557 static int ivtv_try_fmt_vid_out_overlay(struct file *file, void *fh, struct v4l2_format *fmt) 558 { 559 struct ivtv *itv = fh2id(fh)->itv; 560 u32 chromakey = fmt->fmt.win.chromakey; 561 u8 global_alpha = fmt->fmt.win.global_alpha; 562 563 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) 564 return -EINVAL; 565 ivtv_g_fmt_vid_out_overlay(file, fh, fmt); 566 fmt->fmt.win.chromakey = chromakey; 567 fmt->fmt.win.global_alpha = global_alpha; 568 return 0; 569 } 570 571 static int ivtv_s_fmt_sliced_vbi_out(struct file *file, void *fh, struct v4l2_format *fmt) 572 { 573 return ivtv_g_fmt_sliced_vbi_out(file, fh, fmt); 574 } 575 576 static int ivtv_s_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt) 577 { 578 struct ivtv_open_id *id = fh2id(fh); 579 struct ivtv *itv = id->itv; 580 struct v4l2_mbus_framefmt mbus_fmt; 581 int ret = ivtv_try_fmt_vid_cap(file, fh, fmt); 582 int w = fmt->fmt.pix.width; 583 int h = fmt->fmt.pix.height; 584 585 if (ret) 586 return ret; 587 588 if (itv->cxhdl.width == w && itv->cxhdl.height == h) 589 return 0; 590 591 if (atomic_read(&itv->capturing) > 0) 592 return -EBUSY; 593 594 itv->cxhdl.width = w; 595 itv->cxhdl.height = h; 596 if (v4l2_ctrl_g_ctrl(itv->cxhdl.video_encoding) == V4L2_MPEG_VIDEO_ENCODING_MPEG_1) 597 fmt->fmt.pix.width /= 2; 598 mbus_fmt.width = fmt->fmt.pix.width; 599 mbus_fmt.height = h; 600 mbus_fmt.code = V4L2_MBUS_FMT_FIXED; 601 v4l2_subdev_call(itv->sd_video, video, s_mbus_fmt, &mbus_fmt); 602 return ivtv_g_fmt_vid_cap(file, fh, fmt); 603 } 604 605 static int ivtv_s_fmt_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt) 606 { 607 struct ivtv *itv = fh2id(fh)->itv; 608 609 if (!ivtv_raw_vbi(itv) && atomic_read(&itv->capturing) > 0) 610 return -EBUSY; 611 itv->vbi.sliced_in->service_set = 0; 612 itv->vbi.in.type = V4L2_BUF_TYPE_VBI_CAPTURE; 613 v4l2_subdev_call(itv->sd_video, vbi, s_raw_fmt, &fmt->fmt.vbi); 614 return ivtv_g_fmt_vbi_cap(file, fh, fmt); 615 } 616 617 static int ivtv_s_fmt_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt) 618 { 619 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced; 620 struct ivtv_open_id *id = fh2id(fh); 621 struct ivtv *itv = id->itv; 622 int ret = ivtv_try_fmt_sliced_vbi_cap(file, fh, fmt); 623 624 if (ret || id->type == IVTV_DEC_STREAM_TYPE_VBI) 625 return ret; 626 627 check_service_set(vbifmt, itv->is_50hz); 628 if (ivtv_raw_vbi(itv) && atomic_read(&itv->capturing) > 0) 629 return -EBUSY; 630 itv->vbi.in.type = V4L2_BUF_TYPE_SLICED_VBI_CAPTURE; 631 v4l2_subdev_call(itv->sd_video, vbi, s_sliced_fmt, vbifmt); 632 memcpy(itv->vbi.sliced_in, vbifmt, sizeof(*itv->vbi.sliced_in)); 633 return 0; 634 } 635 636 static int ivtv_s_fmt_vid_out(struct file *file, void *fh, struct v4l2_format *fmt) 637 { 638 struct ivtv_open_id *id = fh2id(fh); 639 struct ivtv *itv = id->itv; 640 struct yuv_playback_info *yi = &itv->yuv_info; 641 int ret = ivtv_try_fmt_vid_out(file, fh, fmt); 642 643 if (ret) 644 return ret; 645 646 if (id->type != IVTV_DEC_STREAM_TYPE_YUV) 647 return 0; 648 649 /* Return now if we already have some frame data */ 650 if (yi->stream_size) 651 return -EBUSY; 652 653 yi->v4l2_src_w = fmt->fmt.pix.width; 654 yi->v4l2_src_h = fmt->fmt.pix.height; 655 656 switch (fmt->fmt.pix.field) { 657 case V4L2_FIELD_NONE: 658 yi->lace_mode = IVTV_YUV_MODE_PROGRESSIVE; 659 break; 660 case V4L2_FIELD_ANY: 661 yi->lace_mode = IVTV_YUV_MODE_AUTO; 662 break; 663 case V4L2_FIELD_INTERLACED_BT: 664 yi->lace_mode = 665 IVTV_YUV_MODE_INTERLACED|IVTV_YUV_SYNC_ODD; 666 break; 667 case V4L2_FIELD_INTERLACED_TB: 668 default: 669 yi->lace_mode = IVTV_YUV_MODE_INTERLACED; 670 break; 671 } 672 yi->lace_sync_field = (yi->lace_mode & IVTV_YUV_SYNC_MASK) == IVTV_YUV_SYNC_EVEN ? 0 : 1; 673 674 if (test_bit(IVTV_F_I_DEC_YUV, &itv->i_flags)) 675 itv->dma_data_req_size = 676 1080 * ((yi->v4l2_src_h + 31) & ~31); 677 678 return 0; 679 } 680 681 static int ivtv_s_fmt_vid_out_overlay(struct file *file, void *fh, struct v4l2_format *fmt) 682 { 683 struct ivtv *itv = fh2id(fh)->itv; 684 int ret = ivtv_try_fmt_vid_out_overlay(file, fh, fmt); 685 686 if (ret == 0) { 687 itv->osd_chroma_key = fmt->fmt.win.chromakey; 688 itv->osd_global_alpha = fmt->fmt.win.global_alpha; 689 ivtv_set_osd_alpha(itv); 690 } 691 return ret; 692 } 693 694 #ifdef CONFIG_VIDEO_ADV_DEBUG 695 static int ivtv_itvc(struct ivtv *itv, bool get, u64 reg, u64 *val) 696 { 697 volatile u8 __iomem *reg_start; 698 699 if (reg & 0x3) 700 return -EINVAL; 701 if (reg >= IVTV_REG_OFFSET && reg < IVTV_REG_OFFSET + IVTV_REG_SIZE) 702 reg_start = itv->reg_mem - IVTV_REG_OFFSET; 703 else if (itv->has_cx23415 && reg >= IVTV_DECODER_OFFSET && 704 reg < IVTV_DECODER_OFFSET + IVTV_DECODER_SIZE) 705 reg_start = itv->dec_mem - IVTV_DECODER_OFFSET; 706 else if (reg < IVTV_ENCODER_SIZE) 707 reg_start = itv->enc_mem; 708 else 709 return -EINVAL; 710 711 if (get) 712 *val = readl(reg + reg_start); 713 else 714 writel(*val, reg + reg_start); 715 return 0; 716 } 717 718 static int ivtv_g_register(struct file *file, void *fh, struct v4l2_dbg_register *reg) 719 { 720 struct ivtv *itv = fh2id(fh)->itv; 721 722 reg->size = 4; 723 return ivtv_itvc(itv, true, reg->reg, ®->val); 724 } 725 726 static int ivtv_s_register(struct file *file, void *fh, const struct v4l2_dbg_register *reg) 727 { 728 struct ivtv *itv = fh2id(fh)->itv; 729 u64 val = reg->val; 730 731 return ivtv_itvc(itv, false, reg->reg, &val); 732 } 733 #endif 734 735 static int ivtv_querycap(struct file *file, void *fh, struct v4l2_capability *vcap) 736 { 737 struct ivtv_open_id *id = fh2id(file->private_data); 738 struct ivtv *itv = id->itv; 739 struct ivtv_stream *s = &itv->streams[id->type]; 740 741 strlcpy(vcap->driver, IVTV_DRIVER_NAME, sizeof(vcap->driver)); 742 strlcpy(vcap->card, itv->card_name, sizeof(vcap->card)); 743 snprintf(vcap->bus_info, sizeof(vcap->bus_info), "PCI:%s", pci_name(itv->pdev)); 744 vcap->capabilities = itv->v4l2_cap | V4L2_CAP_DEVICE_CAPS; 745 vcap->device_caps = s->caps; 746 return 0; 747 } 748 749 static int ivtv_enumaudio(struct file *file, void *fh, struct v4l2_audio *vin) 750 { 751 struct ivtv *itv = fh2id(fh)->itv; 752 753 return ivtv_get_audio_input(itv, vin->index, vin); 754 } 755 756 static int ivtv_g_audio(struct file *file, void *fh, struct v4l2_audio *vin) 757 { 758 struct ivtv *itv = fh2id(fh)->itv; 759 760 vin->index = itv->audio_input; 761 return ivtv_get_audio_input(itv, vin->index, vin); 762 } 763 764 static int ivtv_s_audio(struct file *file, void *fh, const struct v4l2_audio *vout) 765 { 766 struct ivtv *itv = fh2id(fh)->itv; 767 768 if (vout->index >= itv->nof_audio_inputs) 769 return -EINVAL; 770 771 itv->audio_input = vout->index; 772 ivtv_audio_set_io(itv); 773 774 return 0; 775 } 776 777 static int ivtv_enumaudout(struct file *file, void *fh, struct v4l2_audioout *vin) 778 { 779 struct ivtv *itv = fh2id(fh)->itv; 780 781 /* set it to defaults from our table */ 782 return ivtv_get_audio_output(itv, vin->index, vin); 783 } 784 785 static int ivtv_g_audout(struct file *file, void *fh, struct v4l2_audioout *vin) 786 { 787 struct ivtv *itv = fh2id(fh)->itv; 788 789 vin->index = 0; 790 return ivtv_get_audio_output(itv, vin->index, vin); 791 } 792 793 static int ivtv_s_audout(struct file *file, void *fh, const struct v4l2_audioout *vout) 794 { 795 struct ivtv *itv = fh2id(fh)->itv; 796 797 if (itv->card->video_outputs == NULL || vout->index != 0) 798 return -EINVAL; 799 return 0; 800 } 801 802 static int ivtv_enum_input(struct file *file, void *fh, struct v4l2_input *vin) 803 { 804 struct ivtv *itv = fh2id(fh)->itv; 805 806 /* set it to defaults from our table */ 807 return ivtv_get_input(itv, vin->index, vin); 808 } 809 810 static int ivtv_enum_output(struct file *file, void *fh, struct v4l2_output *vout) 811 { 812 struct ivtv *itv = fh2id(fh)->itv; 813 814 return ivtv_get_output(itv, vout->index, vout); 815 } 816 817 static int ivtv_cropcap(struct file *file, void *fh, struct v4l2_cropcap *cropcap) 818 { 819 struct ivtv_open_id *id = fh2id(fh); 820 struct ivtv *itv = id->itv; 821 struct yuv_playback_info *yi = &itv->yuv_info; 822 int streamtype; 823 824 streamtype = id->type; 825 826 if (cropcap->type != V4L2_BUF_TYPE_VIDEO_OUTPUT) 827 return -EINVAL; 828 cropcap->bounds.top = cropcap->bounds.left = 0; 829 cropcap->bounds.width = 720; 830 if (cropcap->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) { 831 cropcap->bounds.height = itv->is_50hz ? 576 : 480; 832 cropcap->pixelaspect.numerator = itv->is_50hz ? 59 : 10; 833 cropcap->pixelaspect.denominator = itv->is_50hz ? 54 : 11; 834 } else if (streamtype == IVTV_DEC_STREAM_TYPE_YUV) { 835 if (yi->track_osd) { 836 cropcap->bounds.width = yi->osd_full_w; 837 cropcap->bounds.height = yi->osd_full_h; 838 } else { 839 cropcap->bounds.width = 720; 840 cropcap->bounds.height = 841 itv->is_out_50hz ? 576 : 480; 842 } 843 cropcap->pixelaspect.numerator = itv->is_out_50hz ? 59 : 10; 844 cropcap->pixelaspect.denominator = itv->is_out_50hz ? 54 : 11; 845 } else { 846 cropcap->bounds.height = itv->is_out_50hz ? 576 : 480; 847 cropcap->pixelaspect.numerator = itv->is_out_50hz ? 59 : 10; 848 cropcap->pixelaspect.denominator = itv->is_out_50hz ? 54 : 11; 849 } 850 cropcap->defrect = cropcap->bounds; 851 return 0; 852 } 853 854 static int ivtv_s_crop(struct file *file, void *fh, const struct v4l2_crop *crop) 855 { 856 struct ivtv_open_id *id = fh2id(fh); 857 struct ivtv *itv = id->itv; 858 struct yuv_playback_info *yi = &itv->yuv_info; 859 int streamtype; 860 861 streamtype = id->type; 862 863 if (crop->type == V4L2_BUF_TYPE_VIDEO_OUTPUT && 864 (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) { 865 if (streamtype == IVTV_DEC_STREAM_TYPE_YUV) { 866 yi->main_rect = crop->c; 867 return 0; 868 } else { 869 if (!ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4, 870 crop->c.width, crop->c.height, crop->c.left, crop->c.top)) { 871 itv->main_rect = crop->c; 872 return 0; 873 } 874 } 875 return -EINVAL; 876 } 877 return -EINVAL; 878 } 879 880 static int ivtv_g_crop(struct file *file, void *fh, struct v4l2_crop *crop) 881 { 882 struct ivtv_open_id *id = fh2id(fh); 883 struct ivtv *itv = id->itv; 884 struct yuv_playback_info *yi = &itv->yuv_info; 885 int streamtype; 886 887 streamtype = id->type; 888 889 if (crop->type == V4L2_BUF_TYPE_VIDEO_OUTPUT && 890 (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) { 891 if (streamtype == IVTV_DEC_STREAM_TYPE_YUV) 892 crop->c = yi->main_rect; 893 else 894 crop->c = itv->main_rect; 895 return 0; 896 } 897 return -EINVAL; 898 } 899 900 static int ivtv_enum_fmt_vid_cap(struct file *file, void *fh, struct v4l2_fmtdesc *fmt) 901 { 902 static const struct v4l2_fmtdesc hm12 = { 903 0, V4L2_BUF_TYPE_VIDEO_CAPTURE, 0, 904 "HM12 (YUV 4:2:0)", V4L2_PIX_FMT_HM12, 905 { 0, 0, 0, 0 } 906 }; 907 static const struct v4l2_fmtdesc mpeg = { 908 0, V4L2_BUF_TYPE_VIDEO_CAPTURE, V4L2_FMT_FLAG_COMPRESSED, 909 "MPEG", V4L2_PIX_FMT_MPEG, 910 { 0, 0, 0, 0 } 911 }; 912 struct ivtv *itv = fh2id(fh)->itv; 913 struct ivtv_stream *s = &itv->streams[fh2id(fh)->type]; 914 915 if (fmt->index) 916 return -EINVAL; 917 if (s->type == IVTV_ENC_STREAM_TYPE_MPG) 918 *fmt = mpeg; 919 else if (s->type == IVTV_ENC_STREAM_TYPE_YUV) 920 *fmt = hm12; 921 else 922 return -EINVAL; 923 return 0; 924 } 925 926 static int ivtv_enum_fmt_vid_out(struct file *file, void *fh, struct v4l2_fmtdesc *fmt) 927 { 928 static const struct v4l2_fmtdesc hm12 = { 929 0, V4L2_BUF_TYPE_VIDEO_OUTPUT, 0, 930 "HM12 (YUV 4:2:0)", V4L2_PIX_FMT_HM12, 931 { 0, 0, 0, 0 } 932 }; 933 static const struct v4l2_fmtdesc mpeg = { 934 0, V4L2_BUF_TYPE_VIDEO_OUTPUT, V4L2_FMT_FLAG_COMPRESSED, 935 "MPEG", V4L2_PIX_FMT_MPEG, 936 { 0, 0, 0, 0 } 937 }; 938 struct ivtv *itv = fh2id(fh)->itv; 939 struct ivtv_stream *s = &itv->streams[fh2id(fh)->type]; 940 941 if (fmt->index) 942 return -EINVAL; 943 if (s->type == IVTV_DEC_STREAM_TYPE_MPG) 944 *fmt = mpeg; 945 else if (s->type == IVTV_DEC_STREAM_TYPE_YUV) 946 *fmt = hm12; 947 else 948 return -EINVAL; 949 return 0; 950 } 951 952 static int ivtv_g_input(struct file *file, void *fh, unsigned int *i) 953 { 954 struct ivtv *itv = fh2id(fh)->itv; 955 956 *i = itv->active_input; 957 958 return 0; 959 } 960 961 int ivtv_s_input(struct file *file, void *fh, unsigned int inp) 962 { 963 struct ivtv *itv = fh2id(fh)->itv; 964 v4l2_std_id std; 965 int i; 966 967 if (inp >= itv->nof_inputs) 968 return -EINVAL; 969 970 if (inp == itv->active_input) { 971 IVTV_DEBUG_INFO("Input unchanged\n"); 972 return 0; 973 } 974 975 if (atomic_read(&itv->capturing) > 0) { 976 return -EBUSY; 977 } 978 979 IVTV_DEBUG_INFO("Changing input from %d to %d\n", 980 itv->active_input, inp); 981 982 itv->active_input = inp; 983 /* Set the audio input to whatever is appropriate for the 984 input type. */ 985 itv->audio_input = itv->card->video_inputs[inp].audio_index; 986 987 if (itv->card->video_inputs[inp].video_type == IVTV_CARD_INPUT_VID_TUNER) 988 std = itv->tuner_std; 989 else 990 std = V4L2_STD_ALL; 991 for (i = 0; i <= IVTV_ENC_STREAM_TYPE_VBI; i++) 992 itv->streams[i].vdev->tvnorms = std; 993 994 /* prevent others from messing with the streams until 995 we're finished changing inputs. */ 996 ivtv_mute(itv); 997 ivtv_video_set_io(itv); 998 ivtv_audio_set_io(itv); 999 ivtv_unmute(itv); 1000 1001 return 0; 1002 } 1003 1004 static int ivtv_g_output(struct file *file, void *fh, unsigned int *i) 1005 { 1006 struct ivtv *itv = fh2id(fh)->itv; 1007 1008 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) 1009 return -EINVAL; 1010 1011 *i = itv->active_output; 1012 1013 return 0; 1014 } 1015 1016 static int ivtv_s_output(struct file *file, void *fh, unsigned int outp) 1017 { 1018 struct ivtv *itv = fh2id(fh)->itv; 1019 1020 if (outp >= itv->card->nof_outputs) 1021 return -EINVAL; 1022 1023 if (outp == itv->active_output) { 1024 IVTV_DEBUG_INFO("Output unchanged\n"); 1025 return 0; 1026 } 1027 IVTV_DEBUG_INFO("Changing output from %d to %d\n", 1028 itv->active_output, outp); 1029 1030 itv->active_output = outp; 1031 ivtv_call_hw(itv, IVTV_HW_SAA7127, video, s_routing, 1032 SAA7127_INPUT_TYPE_NORMAL, 1033 itv->card->video_outputs[outp].video_output, 0); 1034 1035 return 0; 1036 } 1037 1038 static int ivtv_g_frequency(struct file *file, void *fh, struct v4l2_frequency *vf) 1039 { 1040 struct ivtv *itv = fh2id(fh)->itv; 1041 struct ivtv_stream *s = &itv->streams[fh2id(fh)->type]; 1042 1043 if (s->vdev->vfl_dir) 1044 return -ENOTTY; 1045 if (vf->tuner != 0) 1046 return -EINVAL; 1047 1048 ivtv_call_all(itv, tuner, g_frequency, vf); 1049 return 0; 1050 } 1051 1052 int ivtv_s_frequency(struct file *file, void *fh, const struct v4l2_frequency *vf) 1053 { 1054 struct ivtv *itv = fh2id(fh)->itv; 1055 struct ivtv_stream *s = &itv->streams[fh2id(fh)->type]; 1056 1057 if (s->vdev->vfl_dir) 1058 return -ENOTTY; 1059 if (vf->tuner != 0) 1060 return -EINVAL; 1061 1062 ivtv_mute(itv); 1063 IVTV_DEBUG_INFO("v4l2 ioctl: set frequency %d\n", vf->frequency); 1064 ivtv_call_all(itv, tuner, s_frequency, vf); 1065 ivtv_unmute(itv); 1066 return 0; 1067 } 1068 1069 static int ivtv_g_std(struct file *file, void *fh, v4l2_std_id *std) 1070 { 1071 struct ivtv *itv = fh2id(fh)->itv; 1072 1073 *std = itv->std; 1074 return 0; 1075 } 1076 1077 void ivtv_s_std_enc(struct ivtv *itv, v4l2_std_id std) 1078 { 1079 itv->std = std; 1080 itv->is_60hz = (std & V4L2_STD_525_60) ? 1 : 0; 1081 itv->is_50hz = !itv->is_60hz; 1082 cx2341x_handler_set_50hz(&itv->cxhdl, itv->is_50hz); 1083 itv->cxhdl.width = 720; 1084 itv->cxhdl.height = itv->is_50hz ? 576 : 480; 1085 itv->vbi.count = itv->is_50hz ? 18 : 12; 1086 itv->vbi.start[0] = itv->is_50hz ? 6 : 10; 1087 itv->vbi.start[1] = itv->is_50hz ? 318 : 273; 1088 1089 if (itv->hw_flags & IVTV_HW_CX25840) 1090 itv->vbi.sliced_decoder_line_size = itv->is_60hz ? 272 : 284; 1091 1092 /* Tuner */ 1093 ivtv_call_all(itv, core, s_std, itv->std); 1094 } 1095 1096 void ivtv_s_std_dec(struct ivtv *itv, v4l2_std_id std) 1097 { 1098 struct yuv_playback_info *yi = &itv->yuv_info; 1099 DEFINE_WAIT(wait); 1100 int f; 1101 1102 /* set display standard */ 1103 itv->std_out = std; 1104 itv->is_out_60hz = (std & V4L2_STD_525_60) ? 1 : 0; 1105 itv->is_out_50hz = !itv->is_out_60hz; 1106 ivtv_call_all(itv, video, s_std_output, itv->std_out); 1107 1108 /* 1109 * The next firmware call is time sensitive. Time it to 1110 * avoid risk of a hard lock, by trying to ensure the call 1111 * happens within the first 100 lines of the top field. 1112 * Make 4 attempts to sync to the decoder before giving up. 1113 */ 1114 mutex_unlock(&itv->serialize_lock); 1115 for (f = 0; f < 4; f++) { 1116 prepare_to_wait(&itv->vsync_waitq, &wait, 1117 TASK_UNINTERRUPTIBLE); 1118 if ((read_reg(IVTV_REG_DEC_LINE_FIELD) >> 16) < 100) 1119 break; 1120 schedule_timeout(msecs_to_jiffies(25)); 1121 } 1122 finish_wait(&itv->vsync_waitq, &wait); 1123 mutex_lock(&itv->serialize_lock); 1124 1125 if (f == 4) 1126 IVTV_WARN("Mode change failed to sync to decoder\n"); 1127 1128 ivtv_vapi(itv, CX2341X_DEC_SET_STANDARD, 1, itv->is_out_50hz); 1129 itv->main_rect.left = 0; 1130 itv->main_rect.top = 0; 1131 itv->main_rect.width = 720; 1132 itv->main_rect.height = itv->is_out_50hz ? 576 : 480; 1133 ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4, 1134 720, itv->main_rect.height, 0, 0); 1135 yi->main_rect = itv->main_rect; 1136 if (!itv->osd_info) { 1137 yi->osd_full_w = 720; 1138 yi->osd_full_h = itv->is_out_50hz ? 576 : 480; 1139 } 1140 } 1141 1142 static int ivtv_s_std(struct file *file, void *fh, v4l2_std_id std) 1143 { 1144 struct ivtv *itv = fh2id(fh)->itv; 1145 1146 if ((std & V4L2_STD_ALL) == 0) 1147 return -EINVAL; 1148 1149 if (std == itv->std) 1150 return 0; 1151 1152 if (test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) || 1153 atomic_read(&itv->capturing) > 0 || 1154 atomic_read(&itv->decoding) > 0) { 1155 /* Switching standard would mess with already running 1156 streams, prevent that by returning EBUSY. */ 1157 return -EBUSY; 1158 } 1159 1160 IVTV_DEBUG_INFO("Switching standard to %llx.\n", 1161 (unsigned long long)itv->std); 1162 1163 ivtv_s_std_enc(itv, std); 1164 if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT) 1165 ivtv_s_std_dec(itv, std); 1166 1167 return 0; 1168 } 1169 1170 static int ivtv_s_tuner(struct file *file, void *fh, const struct v4l2_tuner *vt) 1171 { 1172 struct ivtv_open_id *id = fh2id(fh); 1173 struct ivtv *itv = id->itv; 1174 1175 if (vt->index != 0) 1176 return -EINVAL; 1177 1178 ivtv_call_all(itv, tuner, s_tuner, vt); 1179 1180 return 0; 1181 } 1182 1183 static int ivtv_g_tuner(struct file *file, void *fh, struct v4l2_tuner *vt) 1184 { 1185 struct ivtv *itv = fh2id(fh)->itv; 1186 1187 if (vt->index != 0) 1188 return -EINVAL; 1189 1190 ivtv_call_all(itv, tuner, g_tuner, vt); 1191 1192 if (vt->type == V4L2_TUNER_RADIO) 1193 strlcpy(vt->name, "ivtv Radio Tuner", sizeof(vt->name)); 1194 else 1195 strlcpy(vt->name, "ivtv TV Tuner", sizeof(vt->name)); 1196 return 0; 1197 } 1198 1199 static int ivtv_g_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_sliced_vbi_cap *cap) 1200 { 1201 struct ivtv *itv = fh2id(fh)->itv; 1202 int set = itv->is_50hz ? V4L2_SLICED_VBI_625 : V4L2_SLICED_VBI_525; 1203 int f, l; 1204 1205 if (cap->type == V4L2_BUF_TYPE_SLICED_VBI_CAPTURE) { 1206 for (f = 0; f < 2; f++) { 1207 for (l = 0; l < 24; l++) { 1208 if (valid_service_line(f, l, itv->is_50hz)) 1209 cap->service_lines[f][l] = set; 1210 } 1211 } 1212 } else if (cap->type == V4L2_BUF_TYPE_SLICED_VBI_OUTPUT) { 1213 if (!(itv->v4l2_cap & V4L2_CAP_SLICED_VBI_OUTPUT)) 1214 return -EINVAL; 1215 if (itv->is_60hz) { 1216 cap->service_lines[0][21] = V4L2_SLICED_CAPTION_525; 1217 cap->service_lines[1][21] = V4L2_SLICED_CAPTION_525; 1218 } else { 1219 cap->service_lines[0][23] = V4L2_SLICED_WSS_625; 1220 cap->service_lines[0][16] = V4L2_SLICED_VPS; 1221 } 1222 } else { 1223 return -EINVAL; 1224 } 1225 1226 set = 0; 1227 for (f = 0; f < 2; f++) 1228 for (l = 0; l < 24; l++) 1229 set |= cap->service_lines[f][l]; 1230 cap->service_set = set; 1231 return 0; 1232 } 1233 1234 static int ivtv_g_enc_index(struct file *file, void *fh, struct v4l2_enc_idx *idx) 1235 { 1236 struct ivtv *itv = fh2id(fh)->itv; 1237 struct v4l2_enc_idx_entry *e = idx->entry; 1238 int entries; 1239 int i; 1240 1241 entries = (itv->pgm_info_write_idx + IVTV_MAX_PGM_INDEX - itv->pgm_info_read_idx) % 1242 IVTV_MAX_PGM_INDEX; 1243 if (entries > V4L2_ENC_IDX_ENTRIES) 1244 entries = V4L2_ENC_IDX_ENTRIES; 1245 idx->entries = 0; 1246 idx->entries_cap = IVTV_MAX_PGM_INDEX; 1247 if (!atomic_read(&itv->capturing)) 1248 return 0; 1249 for (i = 0; i < entries; i++) { 1250 *e = itv->pgm_info[(itv->pgm_info_read_idx + i) % IVTV_MAX_PGM_INDEX]; 1251 if ((e->flags & V4L2_ENC_IDX_FRAME_MASK) <= V4L2_ENC_IDX_FRAME_B) { 1252 idx->entries++; 1253 e++; 1254 } 1255 } 1256 itv->pgm_info_read_idx = (itv->pgm_info_read_idx + idx->entries) % IVTV_MAX_PGM_INDEX; 1257 return 0; 1258 } 1259 1260 static int ivtv_encoder_cmd(struct file *file, void *fh, struct v4l2_encoder_cmd *enc) 1261 { 1262 struct ivtv_open_id *id = fh2id(fh); 1263 struct ivtv *itv = id->itv; 1264 1265 1266 switch (enc->cmd) { 1267 case V4L2_ENC_CMD_START: 1268 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_START\n"); 1269 enc->flags = 0; 1270 return ivtv_start_capture(id); 1271 1272 case V4L2_ENC_CMD_STOP: 1273 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n"); 1274 enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END; 1275 ivtv_stop_capture(id, enc->flags & V4L2_ENC_CMD_STOP_AT_GOP_END); 1276 return 0; 1277 1278 case V4L2_ENC_CMD_PAUSE: 1279 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n"); 1280 enc->flags = 0; 1281 1282 if (!atomic_read(&itv->capturing)) 1283 return -EPERM; 1284 if (test_and_set_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags)) 1285 return 0; 1286 1287 ivtv_mute(itv); 1288 ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 0); 1289 break; 1290 1291 case V4L2_ENC_CMD_RESUME: 1292 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n"); 1293 enc->flags = 0; 1294 1295 if (!atomic_read(&itv->capturing)) 1296 return -EPERM; 1297 1298 if (!test_and_clear_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags)) 1299 return 0; 1300 1301 ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 1); 1302 ivtv_unmute(itv); 1303 break; 1304 default: 1305 IVTV_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd); 1306 return -EINVAL; 1307 } 1308 1309 return 0; 1310 } 1311 1312 static int ivtv_try_encoder_cmd(struct file *file, void *fh, struct v4l2_encoder_cmd *enc) 1313 { 1314 struct ivtv *itv = fh2id(fh)->itv; 1315 1316 switch (enc->cmd) { 1317 case V4L2_ENC_CMD_START: 1318 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_START\n"); 1319 enc->flags = 0; 1320 return 0; 1321 1322 case V4L2_ENC_CMD_STOP: 1323 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n"); 1324 enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END; 1325 return 0; 1326 1327 case V4L2_ENC_CMD_PAUSE: 1328 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n"); 1329 enc->flags = 0; 1330 return 0; 1331 1332 case V4L2_ENC_CMD_RESUME: 1333 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n"); 1334 enc->flags = 0; 1335 return 0; 1336 default: 1337 IVTV_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd); 1338 return -EINVAL; 1339 } 1340 } 1341 1342 static int ivtv_g_fbuf(struct file *file, void *fh, struct v4l2_framebuffer *fb) 1343 { 1344 struct ivtv *itv = fh2id(fh)->itv; 1345 u32 data[CX2341X_MBOX_MAX_DATA]; 1346 struct yuv_playback_info *yi = &itv->yuv_info; 1347 1348 int pixfmt; 1349 static u32 pixel_format[16] = { 1350 V4L2_PIX_FMT_PAL8, /* Uses a 256-entry RGB colormap */ 1351 V4L2_PIX_FMT_RGB565, 1352 V4L2_PIX_FMT_RGB555, 1353 V4L2_PIX_FMT_RGB444, 1354 V4L2_PIX_FMT_RGB32, 1355 0, 1356 0, 1357 0, 1358 V4L2_PIX_FMT_PAL8, /* Uses a 256-entry YUV colormap */ 1359 V4L2_PIX_FMT_YUV565, 1360 V4L2_PIX_FMT_YUV555, 1361 V4L2_PIX_FMT_YUV444, 1362 V4L2_PIX_FMT_YUV32, 1363 0, 1364 0, 1365 0, 1366 }; 1367 1368 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY)) 1369 return -EINVAL; 1370 if (!itv->osd_video_pbase) 1371 return -EINVAL; 1372 1373 fb->capability = V4L2_FBUF_CAP_EXTERNOVERLAY | V4L2_FBUF_CAP_CHROMAKEY | 1374 V4L2_FBUF_CAP_GLOBAL_ALPHA; 1375 1376 ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0); 1377 data[0] |= (read_reg(0x2a00) >> 7) & 0x40; 1378 pixfmt = (data[0] >> 3) & 0xf; 1379 1380 fb->fmt.pixelformat = pixel_format[pixfmt]; 1381 fb->fmt.width = itv->osd_rect.width; 1382 fb->fmt.height = itv->osd_rect.height; 1383 fb->fmt.field = V4L2_FIELD_INTERLACED; 1384 fb->fmt.bytesperline = fb->fmt.width; 1385 fb->fmt.colorspace = V4L2_COLORSPACE_SMPTE170M; 1386 fb->fmt.field = V4L2_FIELD_INTERLACED; 1387 fb->fmt.priv = 0; 1388 if (fb->fmt.pixelformat != V4L2_PIX_FMT_PAL8) 1389 fb->fmt.bytesperline *= 2; 1390 if (fb->fmt.pixelformat == V4L2_PIX_FMT_RGB32 || 1391 fb->fmt.pixelformat == V4L2_PIX_FMT_YUV32) 1392 fb->fmt.bytesperline *= 2; 1393 fb->fmt.sizeimage = fb->fmt.bytesperline * fb->fmt.height; 1394 fb->base = (void *)itv->osd_video_pbase; 1395 fb->flags = 0; 1396 1397 if (itv->osd_chroma_key_state) 1398 fb->flags |= V4L2_FBUF_FLAG_CHROMAKEY; 1399 1400 if (itv->osd_global_alpha_state) 1401 fb->flags |= V4L2_FBUF_FLAG_GLOBAL_ALPHA; 1402 1403 if (yi->track_osd) 1404 fb->flags |= V4L2_FBUF_FLAG_OVERLAY; 1405 1406 pixfmt &= 7; 1407 1408 /* no local alpha for RGB565 or unknown formats */ 1409 if (pixfmt == 1 || pixfmt > 4) 1410 return 0; 1411 1412 /* 16-bit formats have inverted local alpha */ 1413 if (pixfmt == 2 || pixfmt == 3) 1414 fb->capability |= V4L2_FBUF_CAP_LOCAL_INV_ALPHA; 1415 else 1416 fb->capability |= V4L2_FBUF_CAP_LOCAL_ALPHA; 1417 1418 if (itv->osd_local_alpha_state) { 1419 /* 16-bit formats have inverted local alpha */ 1420 if (pixfmt == 2 || pixfmt == 3) 1421 fb->flags |= V4L2_FBUF_FLAG_LOCAL_INV_ALPHA; 1422 else 1423 fb->flags |= V4L2_FBUF_FLAG_LOCAL_ALPHA; 1424 } 1425 1426 return 0; 1427 } 1428 1429 static int ivtv_s_fbuf(struct file *file, void *fh, const struct v4l2_framebuffer *fb) 1430 { 1431 struct ivtv_open_id *id = fh2id(fh); 1432 struct ivtv *itv = id->itv; 1433 struct yuv_playback_info *yi = &itv->yuv_info; 1434 1435 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY)) 1436 return -EINVAL; 1437 if (!itv->osd_video_pbase) 1438 return -EINVAL; 1439 1440 itv->osd_global_alpha_state = (fb->flags & V4L2_FBUF_FLAG_GLOBAL_ALPHA) != 0; 1441 itv->osd_local_alpha_state = 1442 (fb->flags & (V4L2_FBUF_FLAG_LOCAL_ALPHA|V4L2_FBUF_FLAG_LOCAL_INV_ALPHA)) != 0; 1443 itv->osd_chroma_key_state = (fb->flags & V4L2_FBUF_FLAG_CHROMAKEY) != 0; 1444 ivtv_set_osd_alpha(itv); 1445 yi->track_osd = (fb->flags & V4L2_FBUF_FLAG_OVERLAY) != 0; 1446 return 0; 1447 } 1448 1449 static int ivtv_overlay(struct file *file, void *fh, unsigned int on) 1450 { 1451 struct ivtv_open_id *id = fh2id(fh); 1452 struct ivtv *itv = id->itv; 1453 1454 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY)) 1455 return -EINVAL; 1456 1457 ivtv_vapi(itv, CX2341X_OSD_SET_STATE, 1, on != 0); 1458 1459 return 0; 1460 } 1461 1462 static int ivtv_subscribe_event(struct v4l2_fh *fh, const struct v4l2_event_subscription *sub) 1463 { 1464 switch (sub->type) { 1465 case V4L2_EVENT_VSYNC: 1466 case V4L2_EVENT_EOS: 1467 return v4l2_event_subscribe(fh, sub, 0, NULL); 1468 case V4L2_EVENT_CTRL: 1469 return v4l2_event_subscribe(fh, sub, 0, &v4l2_ctrl_sub_ev_ops); 1470 default: 1471 return -EINVAL; 1472 } 1473 } 1474 1475 static int ivtv_log_status(struct file *file, void *fh) 1476 { 1477 struct ivtv *itv = fh2id(fh)->itv; 1478 u32 data[CX2341X_MBOX_MAX_DATA]; 1479 1480 int has_output = itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT; 1481 struct v4l2_input vidin; 1482 struct v4l2_audio audin; 1483 int i; 1484 1485 IVTV_INFO("Version: %s Card: %s\n", IVTV_VERSION, itv->card_name); 1486 if (itv->hw_flags & IVTV_HW_TVEEPROM) { 1487 struct tveeprom tv; 1488 1489 ivtv_read_eeprom(itv, &tv); 1490 } 1491 ivtv_call_all(itv, core, log_status); 1492 ivtv_get_input(itv, itv->active_input, &vidin); 1493 ivtv_get_audio_input(itv, itv->audio_input, &audin); 1494 IVTV_INFO("Video Input: %s\n", vidin.name); 1495 IVTV_INFO("Audio Input: %s%s\n", audin.name, 1496 (itv->dualwatch_stereo_mode & ~0x300) == 0x200 ? " (Bilingual)" : ""); 1497 if (has_output) { 1498 struct v4l2_output vidout; 1499 struct v4l2_audioout audout; 1500 int mode = itv->output_mode; 1501 static const char * const output_modes[5] = { 1502 "None", 1503 "MPEG Streaming", 1504 "YUV Streaming", 1505 "YUV Frames", 1506 "Passthrough", 1507 }; 1508 static const char * const alpha_mode[4] = { 1509 "None", 1510 "Global", 1511 "Local", 1512 "Global and Local" 1513 }; 1514 static const char * const pixel_format[16] = { 1515 "ARGB Indexed", 1516 "RGB 5:6:5", 1517 "ARGB 1:5:5:5", 1518 "ARGB 1:4:4:4", 1519 "ARGB 8:8:8:8", 1520 "5", 1521 "6", 1522 "7", 1523 "AYUV Indexed", 1524 "YUV 5:6:5", 1525 "AYUV 1:5:5:5", 1526 "AYUV 1:4:4:4", 1527 "AYUV 8:8:8:8", 1528 "13", 1529 "14", 1530 "15", 1531 }; 1532 1533 ivtv_get_output(itv, itv->active_output, &vidout); 1534 ivtv_get_audio_output(itv, 0, &audout); 1535 IVTV_INFO("Video Output: %s\n", vidout.name); 1536 if (mode < 0 || mode > OUT_PASSTHROUGH) 1537 mode = OUT_NONE; 1538 IVTV_INFO("Output Mode: %s\n", output_modes[mode]); 1539 ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0); 1540 data[0] |= (read_reg(0x2a00) >> 7) & 0x40; 1541 IVTV_INFO("Overlay: %s, Alpha: %s, Pixel Format: %s\n", 1542 data[0] & 1 ? "On" : "Off", 1543 alpha_mode[(data[0] >> 1) & 0x3], 1544 pixel_format[(data[0] >> 3) & 0xf]); 1545 } 1546 IVTV_INFO("Tuner: %s\n", 1547 test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ? "Radio" : "TV"); 1548 v4l2_ctrl_handler_log_status(&itv->cxhdl.hdl, itv->v4l2_dev.name); 1549 IVTV_INFO("Status flags: 0x%08lx\n", itv->i_flags); 1550 for (i = 0; i < IVTV_MAX_STREAMS; i++) { 1551 struct ivtv_stream *s = &itv->streams[i]; 1552 1553 if (s->vdev == NULL || s->buffers == 0) 1554 continue; 1555 IVTV_INFO("Stream %s: status 0x%04lx, %d%% of %d KiB (%d buffers) in use\n", s->name, s->s_flags, 1556 (s->buffers - s->q_free.buffers) * 100 / s->buffers, 1557 (s->buffers * s->buf_size) / 1024, s->buffers); 1558 } 1559 1560 IVTV_INFO("Read MPG/VBI: %lld/%lld bytes\n", 1561 (long long)itv->mpg_data_received, 1562 (long long)itv->vbi_data_inserted); 1563 return 0; 1564 } 1565 1566 static int ivtv_decoder_cmd(struct file *file, void *fh, struct v4l2_decoder_cmd *dec) 1567 { 1568 struct ivtv_open_id *id = fh2id(file->private_data); 1569 struct ivtv *itv = id->itv; 1570 1571 IVTV_DEBUG_IOCTL("VIDIOC_DECODER_CMD %d\n", dec->cmd); 1572 return ivtv_video_command(itv, id, dec, false); 1573 } 1574 1575 static int ivtv_try_decoder_cmd(struct file *file, void *fh, struct v4l2_decoder_cmd *dec) 1576 { 1577 struct ivtv_open_id *id = fh2id(file->private_data); 1578 struct ivtv *itv = id->itv; 1579 1580 IVTV_DEBUG_IOCTL("VIDIOC_TRY_DECODER_CMD %d\n", dec->cmd); 1581 return ivtv_video_command(itv, id, dec, true); 1582 } 1583 1584 static int ivtv_decoder_ioctls(struct file *filp, unsigned int cmd, void *arg) 1585 { 1586 struct ivtv_open_id *id = fh2id(filp->private_data); 1587 struct ivtv *itv = id->itv; 1588 int nonblocking = filp->f_flags & O_NONBLOCK; 1589 struct ivtv_stream *s = &itv->streams[id->type]; 1590 unsigned long iarg = (unsigned long)arg; 1591 1592 switch (cmd) { 1593 case IVTV_IOC_DMA_FRAME: { 1594 struct ivtv_dma_frame *args = arg; 1595 1596 IVTV_DEBUG_IOCTL("IVTV_IOC_DMA_FRAME\n"); 1597 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) 1598 return -EINVAL; 1599 if (args->type != V4L2_BUF_TYPE_VIDEO_OUTPUT) 1600 return -EINVAL; 1601 if (itv->output_mode == OUT_UDMA_YUV && args->y_source == NULL) 1602 return 0; 1603 if (ivtv_start_decoding(id, id->type)) { 1604 return -EBUSY; 1605 } 1606 if (ivtv_set_output_mode(itv, OUT_UDMA_YUV) != OUT_UDMA_YUV) { 1607 ivtv_release_stream(s); 1608 return -EBUSY; 1609 } 1610 /* Mark that this file handle started the UDMA_YUV mode */ 1611 id->yuv_frames = 1; 1612 if (args->y_source == NULL) 1613 return 0; 1614 return ivtv_yuv_prep_frame(itv, args); 1615 } 1616 1617 case IVTV_IOC_PASSTHROUGH_MODE: 1618 IVTV_DEBUG_IOCTL("IVTV_IOC_PASSTHROUGH_MODE\n"); 1619 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) 1620 return -EINVAL; 1621 return ivtv_passthrough_mode(itv, *(int *)arg != 0); 1622 1623 case VIDEO_GET_PTS: { 1624 s64 *pts = arg; 1625 s64 frame; 1626 1627 IVTV_DEBUG_IOCTL("VIDEO_GET_PTS\n"); 1628 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) { 1629 *pts = s->dma_pts; 1630 break; 1631 } 1632 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) 1633 return -EINVAL; 1634 return ivtv_g_pts_frame(itv, pts, &frame); 1635 } 1636 1637 case VIDEO_GET_FRAME_COUNT: { 1638 s64 *frame = arg; 1639 s64 pts; 1640 1641 IVTV_DEBUG_IOCTL("VIDEO_GET_FRAME_COUNT\n"); 1642 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) { 1643 *frame = 0; 1644 break; 1645 } 1646 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) 1647 return -EINVAL; 1648 return ivtv_g_pts_frame(itv, &pts, frame); 1649 } 1650 1651 case VIDEO_PLAY: { 1652 struct v4l2_decoder_cmd dc; 1653 1654 IVTV_DEBUG_IOCTL("VIDEO_PLAY\n"); 1655 memset(&dc, 0, sizeof(dc)); 1656 dc.cmd = V4L2_DEC_CMD_START; 1657 return ivtv_video_command(itv, id, &dc, 0); 1658 } 1659 1660 case VIDEO_STOP: { 1661 struct v4l2_decoder_cmd dc; 1662 1663 IVTV_DEBUG_IOCTL("VIDEO_STOP\n"); 1664 memset(&dc, 0, sizeof(dc)); 1665 dc.cmd = V4L2_DEC_CMD_STOP; 1666 dc.flags = V4L2_DEC_CMD_STOP_TO_BLACK | V4L2_DEC_CMD_STOP_IMMEDIATELY; 1667 return ivtv_video_command(itv, id, &dc, 0); 1668 } 1669 1670 case VIDEO_FREEZE: { 1671 struct v4l2_decoder_cmd dc; 1672 1673 IVTV_DEBUG_IOCTL("VIDEO_FREEZE\n"); 1674 memset(&dc, 0, sizeof(dc)); 1675 dc.cmd = V4L2_DEC_CMD_PAUSE; 1676 return ivtv_video_command(itv, id, &dc, 0); 1677 } 1678 1679 case VIDEO_CONTINUE: { 1680 struct v4l2_decoder_cmd dc; 1681 1682 IVTV_DEBUG_IOCTL("VIDEO_CONTINUE\n"); 1683 memset(&dc, 0, sizeof(dc)); 1684 dc.cmd = V4L2_DEC_CMD_RESUME; 1685 return ivtv_video_command(itv, id, &dc, 0); 1686 } 1687 1688 case VIDEO_COMMAND: 1689 case VIDEO_TRY_COMMAND: { 1690 /* Note: struct v4l2_decoder_cmd has the same layout as 1691 struct video_command */ 1692 struct v4l2_decoder_cmd *dc = arg; 1693 int try = (cmd == VIDEO_TRY_COMMAND); 1694 1695 if (try) 1696 IVTV_DEBUG_IOCTL("VIDEO_TRY_COMMAND %d\n", dc->cmd); 1697 else 1698 IVTV_DEBUG_IOCTL("VIDEO_COMMAND %d\n", dc->cmd); 1699 return ivtv_video_command(itv, id, dc, try); 1700 } 1701 1702 case VIDEO_GET_EVENT: { 1703 struct video_event *ev = arg; 1704 DEFINE_WAIT(wait); 1705 1706 IVTV_DEBUG_IOCTL("VIDEO_GET_EVENT\n"); 1707 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) 1708 return -EINVAL; 1709 memset(ev, 0, sizeof(*ev)); 1710 set_bit(IVTV_F_I_EV_VSYNC_ENABLED, &itv->i_flags); 1711 1712 while (1) { 1713 if (test_and_clear_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags)) 1714 ev->type = VIDEO_EVENT_DECODER_STOPPED; 1715 else if (test_and_clear_bit(IVTV_F_I_EV_VSYNC, &itv->i_flags)) { 1716 ev->type = VIDEO_EVENT_VSYNC; 1717 ev->u.vsync_field = test_bit(IVTV_F_I_EV_VSYNC_FIELD, &itv->i_flags) ? 1718 VIDEO_VSYNC_FIELD_ODD : VIDEO_VSYNC_FIELD_EVEN; 1719 if (itv->output_mode == OUT_UDMA_YUV && 1720 (itv->yuv_info.lace_mode & IVTV_YUV_MODE_MASK) == 1721 IVTV_YUV_MODE_PROGRESSIVE) { 1722 ev->u.vsync_field = VIDEO_VSYNC_FIELD_PROGRESSIVE; 1723 } 1724 } 1725 if (ev->type) 1726 return 0; 1727 if (nonblocking) 1728 return -EAGAIN; 1729 /* Wait for event. Note that serialize_lock is locked, 1730 so to allow other processes to access the driver while 1731 we are waiting unlock first and later lock again. */ 1732 mutex_unlock(&itv->serialize_lock); 1733 prepare_to_wait(&itv->event_waitq, &wait, TASK_INTERRUPTIBLE); 1734 if (!test_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags) && 1735 !test_bit(IVTV_F_I_EV_VSYNC, &itv->i_flags)) 1736 schedule(); 1737 finish_wait(&itv->event_waitq, &wait); 1738 mutex_lock(&itv->serialize_lock); 1739 if (signal_pending(current)) { 1740 /* return if a signal was received */ 1741 IVTV_DEBUG_INFO("User stopped wait for event\n"); 1742 return -EINTR; 1743 } 1744 } 1745 break; 1746 } 1747 1748 case VIDEO_SELECT_SOURCE: 1749 IVTV_DEBUG_IOCTL("VIDEO_SELECT_SOURCE\n"); 1750 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) 1751 return -EINVAL; 1752 return ivtv_passthrough_mode(itv, iarg == VIDEO_SOURCE_DEMUX); 1753 1754 case AUDIO_SET_MUTE: 1755 IVTV_DEBUG_IOCTL("AUDIO_SET_MUTE\n"); 1756 itv->speed_mute_audio = iarg; 1757 return 0; 1758 1759 case AUDIO_CHANNEL_SELECT: 1760 IVTV_DEBUG_IOCTL("AUDIO_CHANNEL_SELECT\n"); 1761 if (iarg > AUDIO_STEREO_SWAPPED) 1762 return -EINVAL; 1763 return v4l2_ctrl_s_ctrl(itv->ctrl_audio_playback, iarg + 1); 1764 1765 case AUDIO_BILINGUAL_CHANNEL_SELECT: 1766 IVTV_DEBUG_IOCTL("AUDIO_BILINGUAL_CHANNEL_SELECT\n"); 1767 if (iarg > AUDIO_STEREO_SWAPPED) 1768 return -EINVAL; 1769 return v4l2_ctrl_s_ctrl(itv->ctrl_audio_multilingual_playback, iarg + 1); 1770 1771 default: 1772 return -EINVAL; 1773 } 1774 return 0; 1775 } 1776 1777 static long ivtv_default(struct file *file, void *fh, bool valid_prio, 1778 unsigned int cmd, void *arg) 1779 { 1780 struct ivtv *itv = fh2id(fh)->itv; 1781 1782 if (!valid_prio) { 1783 switch (cmd) { 1784 case IVTV_IOC_PASSTHROUGH_MODE: 1785 case VIDEO_PLAY: 1786 case VIDEO_STOP: 1787 case VIDEO_FREEZE: 1788 case VIDEO_CONTINUE: 1789 case VIDEO_COMMAND: 1790 case VIDEO_SELECT_SOURCE: 1791 case AUDIO_SET_MUTE: 1792 case AUDIO_CHANNEL_SELECT: 1793 case AUDIO_BILINGUAL_CHANNEL_SELECT: 1794 return -EBUSY; 1795 } 1796 } 1797 1798 switch (cmd) { 1799 case VIDIOC_INT_RESET: { 1800 u32 val = *(u32 *)arg; 1801 1802 if ((val == 0 && itv->options.newi2c) || (val & 0x01)) 1803 ivtv_reset_ir_gpio(itv); 1804 if (val & 0x02) 1805 v4l2_subdev_call(itv->sd_video, core, reset, 0); 1806 break; 1807 } 1808 1809 case IVTV_IOC_DMA_FRAME: 1810 case IVTV_IOC_PASSTHROUGH_MODE: 1811 case VIDEO_GET_PTS: 1812 case VIDEO_GET_FRAME_COUNT: 1813 case VIDEO_GET_EVENT: 1814 case VIDEO_PLAY: 1815 case VIDEO_STOP: 1816 case VIDEO_FREEZE: 1817 case VIDEO_CONTINUE: 1818 case VIDEO_COMMAND: 1819 case VIDEO_TRY_COMMAND: 1820 case VIDEO_SELECT_SOURCE: 1821 case AUDIO_SET_MUTE: 1822 case AUDIO_CHANNEL_SELECT: 1823 case AUDIO_BILINGUAL_CHANNEL_SELECT: 1824 return ivtv_decoder_ioctls(file, cmd, (void *)arg); 1825 1826 default: 1827 return -ENOTTY; 1828 } 1829 return 0; 1830 } 1831 1832 static const struct v4l2_ioctl_ops ivtv_ioctl_ops = { 1833 .vidioc_querycap = ivtv_querycap, 1834 .vidioc_s_audio = ivtv_s_audio, 1835 .vidioc_g_audio = ivtv_g_audio, 1836 .vidioc_enumaudio = ivtv_enumaudio, 1837 .vidioc_s_audout = ivtv_s_audout, 1838 .vidioc_g_audout = ivtv_g_audout, 1839 .vidioc_enum_input = ivtv_enum_input, 1840 .vidioc_enum_output = ivtv_enum_output, 1841 .vidioc_enumaudout = ivtv_enumaudout, 1842 .vidioc_cropcap = ivtv_cropcap, 1843 .vidioc_s_crop = ivtv_s_crop, 1844 .vidioc_g_crop = ivtv_g_crop, 1845 .vidioc_g_input = ivtv_g_input, 1846 .vidioc_s_input = ivtv_s_input, 1847 .vidioc_g_output = ivtv_g_output, 1848 .vidioc_s_output = ivtv_s_output, 1849 .vidioc_g_frequency = ivtv_g_frequency, 1850 .vidioc_s_frequency = ivtv_s_frequency, 1851 .vidioc_s_tuner = ivtv_s_tuner, 1852 .vidioc_g_tuner = ivtv_g_tuner, 1853 .vidioc_g_enc_index = ivtv_g_enc_index, 1854 .vidioc_g_fbuf = ivtv_g_fbuf, 1855 .vidioc_s_fbuf = ivtv_s_fbuf, 1856 .vidioc_g_std = ivtv_g_std, 1857 .vidioc_s_std = ivtv_s_std, 1858 .vidioc_overlay = ivtv_overlay, 1859 .vidioc_log_status = ivtv_log_status, 1860 .vidioc_enum_fmt_vid_cap = ivtv_enum_fmt_vid_cap, 1861 .vidioc_encoder_cmd = ivtv_encoder_cmd, 1862 .vidioc_try_encoder_cmd = ivtv_try_encoder_cmd, 1863 .vidioc_decoder_cmd = ivtv_decoder_cmd, 1864 .vidioc_try_decoder_cmd = ivtv_try_decoder_cmd, 1865 .vidioc_enum_fmt_vid_out = ivtv_enum_fmt_vid_out, 1866 .vidioc_g_fmt_vid_cap = ivtv_g_fmt_vid_cap, 1867 .vidioc_g_fmt_vbi_cap = ivtv_g_fmt_vbi_cap, 1868 .vidioc_g_fmt_sliced_vbi_cap = ivtv_g_fmt_sliced_vbi_cap, 1869 .vidioc_g_fmt_vid_out = ivtv_g_fmt_vid_out, 1870 .vidioc_g_fmt_vid_out_overlay = ivtv_g_fmt_vid_out_overlay, 1871 .vidioc_g_fmt_sliced_vbi_out = ivtv_g_fmt_sliced_vbi_out, 1872 .vidioc_s_fmt_vid_cap = ivtv_s_fmt_vid_cap, 1873 .vidioc_s_fmt_vbi_cap = ivtv_s_fmt_vbi_cap, 1874 .vidioc_s_fmt_sliced_vbi_cap = ivtv_s_fmt_sliced_vbi_cap, 1875 .vidioc_s_fmt_vid_out = ivtv_s_fmt_vid_out, 1876 .vidioc_s_fmt_vid_out_overlay = ivtv_s_fmt_vid_out_overlay, 1877 .vidioc_s_fmt_sliced_vbi_out = ivtv_s_fmt_sliced_vbi_out, 1878 .vidioc_try_fmt_vid_cap = ivtv_try_fmt_vid_cap, 1879 .vidioc_try_fmt_vbi_cap = ivtv_try_fmt_vbi_cap, 1880 .vidioc_try_fmt_sliced_vbi_cap = ivtv_try_fmt_sliced_vbi_cap, 1881 .vidioc_try_fmt_vid_out = ivtv_try_fmt_vid_out, 1882 .vidioc_try_fmt_vid_out_overlay = ivtv_try_fmt_vid_out_overlay, 1883 .vidioc_try_fmt_sliced_vbi_out = ivtv_try_fmt_sliced_vbi_out, 1884 .vidioc_g_sliced_vbi_cap = ivtv_g_sliced_vbi_cap, 1885 #ifdef CONFIG_VIDEO_ADV_DEBUG 1886 .vidioc_g_register = ivtv_g_register, 1887 .vidioc_s_register = ivtv_s_register, 1888 #endif 1889 .vidioc_default = ivtv_default, 1890 .vidioc_subscribe_event = ivtv_subscribe_event, 1891 .vidioc_unsubscribe_event = v4l2_event_unsubscribe, 1892 }; 1893 1894 void ivtv_set_funcs(struct video_device *vdev) 1895 { 1896 vdev->ioctl_ops = &ivtv_ioctl_ops; 1897 } 1898