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