Pileus Git - ~andy/linux/blob - drivers/media/video/ivtv/ivtv-ioctl.c

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