err.no Git - linux-2.6/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 <linux/dvb/audio.h>
  39 #include <linux/i2c-id.h>
  40
  41 u16 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 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 int check_service_set(struct v4l2_sliced_vbi_format *fmt, int is_pal)
 105 {
 106         int f, l;
 107         u16 set = 0;
 108
 109         for (f = 0; f < 2; f++) {
 110                 for (l = 0; l < 24; l++) {
 111                         fmt->service_lines[f][l] = select_service_from_set(f, l, fmt->service_lines[f][l], is_pal);
 112                         set |= fmt->service_lines[f][l];
 113                 }
 114         }
 115         return set != 0;
 116 }
 117
 118 u16 get_service_set(struct v4l2_sliced_vbi_format *fmt)
 119 {
 120         int f, l;
 121         u16 set = 0;
 122
 123         for (f = 0; f < 2; f++) {
 124                 for (l = 0; l < 24; l++) {
 125                         set |= fmt->service_lines[f][l];
 126                 }
 127         }
 128         return set;
 129 }
 130
 131 static const struct {
 132         v4l2_std_id  std;
 133         char        *name;
 134 } enum_stds[] = {
 135         { V4L2_STD_PAL_BG | V4L2_STD_PAL_H, "PAL-BGH" },
 136         { V4L2_STD_PAL_DK,    "PAL-DK"    },
 137         { V4L2_STD_PAL_I,     "PAL-I"     },
 138         { V4L2_STD_PAL_M,     "PAL-M"     },
 139         { V4L2_STD_PAL_N,     "PAL-N"     },
 140         { V4L2_STD_PAL_Nc,    "PAL-Nc"    },
 141         { V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H, "SECAM-BGH" },
 142         { V4L2_STD_SECAM_DK,  "SECAM-DK"  },
 143         { V4L2_STD_SECAM_L,   "SECAM-L"   },
 144         { V4L2_STD_SECAM_LC,  "SECAM-L'"  },
 145         { V4L2_STD_NTSC_M,    "NTSC-M"    },
 146         { V4L2_STD_NTSC_M_JP, "NTSC-J"    },
 147         { V4L2_STD_NTSC_M_KR, "NTSC-K"    },
 148 };
 149
 150 static const struct v4l2_standard ivtv_std_60hz =
 151 {
 152         .frameperiod = {.numerator = 1001, .denominator = 30000},
 153         .framelines = 525,
 154 };
 155
 156 static const struct v4l2_standard ivtv_std_50hz =
 157 {
 158         .frameperiod = {.numerator = 1, .denominator = 25},
 159         .framelines = 625,
 160 };
 161
 162 void ivtv_set_osd_alpha(struct ivtv *itv)
 163 {
 164         ivtv_vapi(itv, CX2341X_OSD_SET_GLOBAL_ALPHA, 3,
 165                 itv->osd_global_alpha_state, itv->osd_global_alpha, !itv->osd_local_alpha_state);
 166         ivtv_vapi(itv, CX2341X_OSD_SET_CHROMA_KEY, 2, itv->osd_chroma_key_state, itv->osd_chroma_key);
 167 }
 168
 169 int ivtv_set_speed(struct ivtv *itv, int speed)
 170 {
 171         u32 data[CX2341X_MBOX_MAX_DATA];
 172         struct ivtv_stream *s;
 173         int single_step = (speed == 1 || speed == -1);
 174         DEFINE_WAIT(wait);
 175
 176         if (speed == 0) speed = 1000;
 177
 178         /* No change? */
 179         if (speed == itv->speed && !single_step)
 180                 return 0;
 181
 182         s = &itv->streams[IVTV_DEC_STREAM_TYPE_MPG];
 183
 184         if (single_step && (speed < 0) == (itv->speed < 0)) {
 185                 /* Single step video and no need to change direction */
 186                 ivtv_vapi(itv, CX2341X_DEC_STEP_VIDEO, 1, 0);
 187                 itv->speed = speed;
 188                 return 0;
 189         }
 190         if (single_step)
 191                 /* Need to change direction */
 192                 speed = speed < 0 ? -1000 : 1000;
 193
 194         data[0] = (speed > 1000 || speed < -1000) ? 0x80000000 : 0;
 195         data[0] |= (speed > 1000 || speed < -1500) ? 0x40000000 : 0;
 196         data[1] = (speed < 0);
 197         data[2] = speed < 0 ? 3 : 7;
 198         data[3] = itv->params.video_b_frames;
 199         data[4] = (speed == 1500 || speed == 500) ? itv->speed_mute_audio : 0;
 200         data[5] = 0;
 201         data[6] = 0;
 202
 203         if (speed == 1500 || speed == -1500) data[0] |= 1;
 204         else if (speed == 2000 || speed == -2000) data[0] |= 2;
 205         else if (speed > -1000 && speed < 0) data[0] |= (-1000 / speed);
 206         else if (speed < 1000 && speed > 0) data[0] |= (1000 / speed);
 207
 208         /* If not decoding, just change speed setting */
 209         if (atomic_read(&itv->decoding) > 0) {
 210                 int got_sig = 0;
 211
 212                 /* Stop all DMA and decoding activity */
 213                 ivtv_vapi(itv, CX2341X_DEC_PAUSE_PLAYBACK, 1, 0);
 214
 215                 /* Wait for any DMA to finish */
 216                 prepare_to_wait(&itv->dma_waitq, &wait, TASK_INTERRUPTIBLE);
 217                 while (itv->i_flags & IVTV_F_I_DMA) {
 218                         got_sig = signal_pending(current);
 219                         if (got_sig)
 220                                 break;
 221                         got_sig = 0;
 222                         schedule();
 223                 }
 224                 finish_wait(&itv->dma_waitq, &wait);
 225                 if (got_sig)
 226                         return -EINTR;
 227
 228                 /* Change Speed safely */
 229                 ivtv_api(itv, CX2341X_DEC_SET_PLAYBACK_SPEED, 7, data);
 230                 IVTV_DEBUG_INFO("Setting Speed to 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n",
 231                                 data[0], data[1], data[2], data[3], data[4], data[5], data[6]);
 232         }
 233         if (single_step) {
 234                 speed = (speed < 0) ? -1 : 1;
 235                 ivtv_vapi(itv, CX2341X_DEC_STEP_VIDEO, 1, 0);
 236         }
 237         itv->speed = speed;
 238         return 0;
 239 }
 240
 241 static int ivtv_validate_speed(int cur_speed, int new_speed)
 242 {
 243         int fact = new_speed < 0 ? -1 : 1;
 244         int s;
 245
 246         if (new_speed < 0) new_speed = -new_speed;
 247         if (cur_speed < 0) cur_speed = -cur_speed;
 248
 249         if (cur_speed <= new_speed) {
 250                 if (new_speed > 1500) return fact * 2000;
 251                 if (new_speed > 1000) return fact * 1500;
 252         }
 253         else {
 254                 if (new_speed >= 2000) return fact * 2000;
 255                 if (new_speed >= 1500) return fact * 1500;
 256                 if (new_speed >= 1000) return fact * 1000;
 257         }
 258         if (new_speed == 0) return 1000;
 259         if (new_speed == 1 || new_speed == 1000) return fact * new_speed;
 260
 261         s = new_speed;
 262         new_speed = 1000 / new_speed;
 263         if (1000 / cur_speed == new_speed)
 264                 new_speed += (cur_speed < s) ? -1 : 1;
 265         if (new_speed > 60) return 1000 / (fact * 60);
 266         return 1000 / (fact * new_speed);
 267 }
 268
 269 static int ivtv_video_command(struct ivtv *itv, struct ivtv_open_id *id,
 270                 struct video_command *vc, int try)
 271 {
 272         struct ivtv_stream *s = &itv->streams[IVTV_DEC_STREAM_TYPE_MPG];
 273
 274         if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
 275                 return -EINVAL;
 276
 277         switch (vc->cmd) {
 278         case VIDEO_CMD_PLAY: {
 279                 vc->flags = 0;
 280                 vc->play.speed = ivtv_validate_speed(itv->speed, vc->play.speed);
 281                 if (vc->play.speed < 0)
 282                         vc->play.format = VIDEO_PLAY_FMT_GOP;
 283                 if (try) break;
 284
 285                 if (ivtv_set_output_mode(itv, OUT_MPG) != OUT_MPG)
 286                         return -EBUSY;
 287                 if (test_and_clear_bit(IVTV_F_I_DEC_PAUSED, &itv->i_flags)) {
 288                         /* forces ivtv_set_speed to be called */
 289                         itv->speed = 0;
 290                 }
 291                 return ivtv_start_decoding(id, vc->play.speed);
 292         }
 293
 294         case VIDEO_CMD_STOP:
 295                 vc->flags &= VIDEO_CMD_STOP_IMMEDIATELY|VIDEO_CMD_STOP_TO_BLACK;
 296                 if (vc->flags & VIDEO_CMD_STOP_IMMEDIATELY)
 297                         vc->stop.pts = 0;
 298                 if (try) break;
 299                 if (atomic_read(&itv->decoding) == 0)
 300                         return 0;
 301                 if (itv->output_mode != OUT_MPG)
 302                         return -EBUSY;
 303
 304                 itv->output_mode = OUT_NONE;
 305                 return ivtv_stop_v4l2_decode_stream(s, vc->flags, vc->stop.pts);
 306
 307         case VIDEO_CMD_FREEZE:
 308                 vc->flags &= VIDEO_CMD_FREEZE_TO_BLACK;
 309                 if (try) break;
 310                 if (itv->output_mode != OUT_MPG)
 311                         return -EBUSY;
 312                 if (atomic_read(&itv->decoding) > 0) {
 313                         ivtv_vapi(itv, CX2341X_DEC_PAUSE_PLAYBACK, 1,
 314                                 (vc->flags & VIDEO_CMD_FREEZE_TO_BLACK) ? 1 : 0);
 315                         set_bit(IVTV_F_I_DEC_PAUSED, &itv->i_flags);
 316                 }
 317                 break;
 318
 319         case VIDEO_CMD_CONTINUE:
 320                 vc->flags = 0;
 321                 if (try) break;
 322                 if (itv->output_mode != OUT_MPG)
 323                         return -EBUSY;
 324                 if (test_and_clear_bit(IVTV_F_I_DEC_PAUSED, &itv->i_flags)) {
 325                         int speed = itv->speed;
 326                         itv->speed = 0;
 327                         return ivtv_start_decoding(id, speed);
 328                 }
 329                 break;
 330
 331         default:
 332                 return -EINVAL;
 333         }
 334         return 0;
 335 }
 336
 337 static int ivtv_itvc(struct ivtv *itv, unsigned int cmd, void *arg)
 338 {
 339         struct v4l2_register *regs = arg;
 340         unsigned long flags;
 341         volatile u8 __iomem *reg_start;
 342
 343         if (!capable(CAP_SYS_ADMIN))
 344                 return -EPERM;
 345         if (regs->reg >= IVTV_REG_OFFSET && regs->reg < IVTV_REG_OFFSET + IVTV_REG_SIZE)
 346                 reg_start = itv->reg_mem - IVTV_REG_OFFSET;
 347         else if (itv->has_cx23415 && regs->reg >= IVTV_DECODER_OFFSET &&
 348                         regs->reg < IVTV_DECODER_OFFSET + IVTV_DECODER_SIZE)
 349                 reg_start = itv->dec_mem - IVTV_DECODER_OFFSET;
 350         else if (regs->reg >= 0 && regs->reg < IVTV_ENCODER_SIZE)
 351                 reg_start = itv->enc_mem;
 352         else
 353                 return -EINVAL;
 354
 355         spin_lock_irqsave(&ivtv_cards_lock, flags);
 356         if (cmd == VIDIOC_DBG_G_REGISTER) {
 357                 regs->val = readl(regs->reg + reg_start);
 358         } else {
 359                 writel(regs->val, regs->reg + reg_start);
 360         }
 361         spin_unlock_irqrestore(&ivtv_cards_lock, flags);
 362         return 0;
 363 }
 364
 365 static int ivtv_get_fmt(struct ivtv *itv, int streamtype, struct v4l2_format *fmt)
 366 {
 367         switch (fmt->type) {
 368         case V4L2_BUF_TYPE_VIDEO_OUTPUT:
 369                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
 370                         return -EINVAL;
 371                 fmt->fmt.pix.width = itv->main_rect.width;
 372                 fmt->fmt.pix.height = itv->main_rect.height;
 373                 fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
 374                 fmt->fmt.pix.field = V4L2_FIELD_INTERLACED;
 375                 if (streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
 376                         switch (itv->yuv_info.lace_mode & IVTV_YUV_MODE_MASK) {
 377                         case IVTV_YUV_MODE_INTERLACED:
 378                                 fmt->fmt.pix.field = (itv->yuv_info.lace_mode & IVTV_YUV_SYNC_MASK) ?
 379                                         V4L2_FIELD_INTERLACED_BT : V4L2_FIELD_INTERLACED_TB;
 380                                 break;
 381                         case IVTV_YUV_MODE_PROGRESSIVE:
 382                                 fmt->fmt.pix.field = V4L2_FIELD_NONE;
 383                                 break;
 384                         default:
 385                                 fmt->fmt.pix.field = V4L2_FIELD_ANY;
 386                                 break;
 387                         }
 388                         fmt->fmt.pix.pixelformat = V4L2_PIX_FMT_HM12;
 389                         fmt->fmt.pix.bytesperline = 720;
 390                         fmt->fmt.pix.width = itv->yuv_info.v4l2_src_w;
 391                         fmt->fmt.pix.height = itv->yuv_info.v4l2_src_h;
 392                         /* YUV size is (Y=(h*w) + UV=(h*(w/2))) */
 393                         fmt->fmt.pix.sizeimage =
 394                                 1080 * ((fmt->fmt.pix.height + 31) & ~31);
 395                 } else if (streamtype == IVTV_ENC_STREAM_TYPE_YUV) {
 396                         fmt->fmt.pix.pixelformat = V4L2_PIX_FMT_HM12;
 397                         /* YUV size is (Y=(h*w) + UV=(h*(w/2))) */
 398                         fmt->fmt.pix.sizeimage =
 399                                 fmt->fmt.pix.height * fmt->fmt.pix.width +
 400                                 fmt->fmt.pix.height * (fmt->fmt.pix.width / 2);
 401                 } else {
 402                         fmt->fmt.pix.pixelformat = V4L2_PIX_FMT_MPEG;
 403                         fmt->fmt.pix.sizeimage = 128 * 1024;
 404                 }
 405                 break;
 406
 407         case V4L2_BUF_TYPE_VIDEO_CAPTURE:
 408                 fmt->fmt.pix.width = itv->params.width;
 409                 fmt->fmt.pix.height = itv->params.height;
 410                 fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
 411                 fmt->fmt.pix.field = V4L2_FIELD_INTERLACED;
 412                 if (streamtype == IVTV_ENC_STREAM_TYPE_YUV ||
 413                                 streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
 414                         fmt->fmt.pix.pixelformat = V4L2_PIX_FMT_HM12;
 415                         /* YUV size is (Y=(h*w) + UV=(h*(w/2))) */
 416                         fmt->fmt.pix.sizeimage =
 417                                 fmt->fmt.pix.height * fmt->fmt.pix.width +
 418                                 fmt->fmt.pix.height * (fmt->fmt.pix.width / 2);
 419                 } else {
 420                         fmt->fmt.pix.pixelformat = V4L2_PIX_FMT_MPEG;
 421                         fmt->fmt.pix.sizeimage = 128 * 1024;
 422                 }
 423                 break;
 424
 425         case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
 426                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
 427                         return -EINVAL;
 428                 fmt->fmt.win.chromakey = itv->osd_chroma_key;
 429                 fmt->fmt.win.global_alpha = itv->osd_global_alpha;
 430                 break;
 431
 432         case V4L2_BUF_TYPE_VBI_CAPTURE:
 433                 fmt->fmt.vbi.sampling_rate = 27000000;
 434                 fmt->fmt.vbi.offset = 248;
 435                 fmt->fmt.vbi.samples_per_line = itv->vbi.raw_decoder_line_size - 4;
 436                 fmt->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY;
 437                 fmt->fmt.vbi.start[0] = itv->vbi.start[0];
 438                 fmt->fmt.vbi.start[1] = itv->vbi.start[1];
 439                 fmt->fmt.vbi.count[0] = fmt->fmt.vbi.count[1] = itv->vbi.count;
 440                 break;
 441
 442         case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
 443         {
 444                 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
 445
 446                 if (!(itv->v4l2_cap & V4L2_CAP_SLICED_VBI_OUTPUT))
 447                         return -EINVAL;
 448                 vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
 449                 memset(vbifmt->reserved, 0, sizeof(vbifmt->reserved));
 450                 memset(vbifmt->service_lines, 0, sizeof(vbifmt->service_lines));
 451                 if (itv->is_60hz) {
 452                         vbifmt->service_lines[0][21] = V4L2_SLICED_CAPTION_525;
 453                         vbifmt->service_lines[1][21] = V4L2_SLICED_CAPTION_525;
 454                 } else {
 455                         vbifmt->service_lines[0][23] = V4L2_SLICED_WSS_625;
 456                         vbifmt->service_lines[0][16] = V4L2_SLICED_VPS;
 457                 }
 458                 vbifmt->service_set = get_service_set(vbifmt);
 459                 break;
 460         }
 461
 462         case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
 463         {
 464                 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
 465
 466                 vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
 467                 memset(vbifmt->reserved, 0, sizeof(vbifmt->reserved));
 468                 memset(vbifmt->service_lines, 0, sizeof(vbifmt->service_lines));
 469
 470                 if (streamtype == IVTV_DEC_STREAM_TYPE_VBI) {
 471                         vbifmt->service_set = itv->is_50hz ? V4L2_SLICED_VBI_625 :
 472                                                  V4L2_SLICED_VBI_525;
 473                         expand_service_set(vbifmt, itv->is_50hz);
 474                         break;
 475                 }
 476
 477                 itv->video_dec_func(itv, VIDIOC_G_FMT, fmt);
 478                 vbifmt->service_set = get_service_set(vbifmt);
 479                 break;
 480         }
 481         case V4L2_BUF_TYPE_VBI_OUTPUT:
 482         case V4L2_BUF_TYPE_VIDEO_OVERLAY:
 483         default:
 484                 return -EINVAL;
 485         }
 486         return 0;
 487 }
 488
 489 static int ivtv_try_or_set_fmt(struct ivtv *itv, int streamtype,
 490                 struct v4l2_format *fmt, int set_fmt)
 491 {
 492         struct yuv_playback_info *yi = &itv->yuv_info;
 493         struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
 494         u16 set;
 495
 496         if (fmt->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) {
 497                 struct v4l2_rect r;
 498                 int field;
 499
 500                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
 501                         return -EINVAL;
 502                 field = fmt->fmt.pix.field;
 503                 r.top = 0;
 504                 r.left = 0;
 505                 r.width = fmt->fmt.pix.width;
 506                 r.height = fmt->fmt.pix.height;
 507                 ivtv_get_fmt(itv, streamtype, fmt);
 508                 fmt->fmt.pix.width = r.width;
 509                 fmt->fmt.pix.height = r.height;
 510                 if (streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
 511                         fmt->fmt.pix.field = field;
 512                         if (fmt->fmt.pix.width < 2)
 513                                 fmt->fmt.pix.width = 2;
 514                         if (fmt->fmt.pix.width > 720)
 515                                 fmt->fmt.pix.width = 720;
 516                         if (fmt->fmt.pix.height < 2)
 517                                 fmt->fmt.pix.height = 2;
 518                         if (fmt->fmt.pix.height > 576)
 519                                 fmt->fmt.pix.height = 576;
 520                 }
 521                 if (set_fmt && streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
 522                         /* Return now if we already have some frame data */
 523                         if (yi->stream_size)
 524                                 return -EBUSY;
 525
 526                         yi->v4l2_src_w = r.width;
 527                         yi->v4l2_src_h = r.height;
 528
 529                         switch (field) {
 530                         case V4L2_FIELD_NONE:
 531                                 yi->lace_mode = IVTV_YUV_MODE_PROGRESSIVE;
 532                                 break;
 533                         case V4L2_FIELD_ANY:
 534                                 yi->lace_mode = IVTV_YUV_MODE_AUTO;
 535                                 break;
 536                         case V4L2_FIELD_INTERLACED_BT:
 537                                 yi->lace_mode =
 538                                      IVTV_YUV_MODE_INTERLACED|IVTV_YUV_SYNC_ODD;
 539                                 break;
 540                         case V4L2_FIELD_INTERLACED_TB:
 541                         default:
 542                                 yi->lace_mode = IVTV_YUV_MODE_INTERLACED;
 543                                 break;
 544                         }
 545                         yi->lace_sync_field = (yi->lace_mode & IVTV_YUV_SYNC_MASK) == IVTV_YUV_SYNC_EVEN ? 0 : 1;
 546
 547                         if (test_bit(IVTV_F_I_DEC_YUV, &itv->i_flags))
 548                                 itv->dma_data_req_size =
 549                                            1080 * ((yi->v4l2_src_h + 31) & ~31);
 550
 551                         /* Force update of yuv registers */
 552                         yi->yuv_forced_update = 1;
 553                         return 0;
 554                 }
 555                 return 0;
 556         }
 557
 558         if (fmt->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY) {
 559                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
 560                         return -EINVAL;
 561                 if (set_fmt) {
 562                         itv->osd_chroma_key = fmt->fmt.win.chromakey;
 563                         itv->osd_global_alpha = fmt->fmt.win.global_alpha;
 564                         ivtv_set_osd_alpha(itv);
 565                 }
 566                 return 0;
 567         }
 568
 569         /* set window size */
 570         if (fmt->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
 571                 struct cx2341x_mpeg_params *p = &itv->params;
 572                 int w = fmt->fmt.pix.width;
 573                 int h = fmt->fmt.pix.height;
 574
 575                 if (w > 720) w = 720;
 576                 else if (w < 1) w = 1;
 577                 if (h > (itv->is_50hz ? 576 : 480)) h = (itv->is_50hz ? 576 : 480);
 578                 else if (h < 2) h = 2;
 579                 ivtv_get_fmt(itv, streamtype, fmt);
 580                 fmt->fmt.pix.width = w;
 581                 fmt->fmt.pix.height = h;
 582
 583                 if (!set_fmt || (p->width == w && p->height == h))
 584                         return 0;
 585                 if (atomic_read(&itv->capturing) > 0)
 586                         return -EBUSY;
 587
 588                 p->width = w;
 589                 p->height = h;
 590                 if (w != 720 || h != (itv->is_50hz ? 576 : 480))
 591                         p->video_temporal_filter = 0;
 592                 else
 593                         p->video_temporal_filter = 8;
 594                 if (p->video_encoding == V4L2_MPEG_VIDEO_ENCODING_MPEG_1)
 595                         fmt->fmt.pix.width /= 2;
 596                 itv->video_dec_func(itv, VIDIOC_S_FMT, fmt);
 597                 return ivtv_get_fmt(itv, streamtype, fmt);
 598         }
 599
 600         /* set raw VBI format */
 601         if (fmt->type == V4L2_BUF_TYPE_VBI_CAPTURE) {
 602                 if (set_fmt && atomic_read(&itv->capturing) > 0) {
 603                         return -EBUSY;
 604                 }
 605                 if (set_fmt) {
 606                         itv->vbi.sliced_in->service_set = 0;
 607                         itv->video_dec_func(itv, VIDIOC_S_FMT, &itv->vbi.in);
 608                 }
 609                 return ivtv_get_fmt(itv, streamtype, fmt);
 610         }
 611
 612         /* set sliced VBI output
 613            In principle the user could request that only certain
 614            VBI types are output and that the others are ignored.
 615            I.e., suppress CC in the even fields or only output
 616            WSS and no VPS. Currently though there is no choice. */
 617         if (fmt->type == V4L2_BUF_TYPE_SLICED_VBI_OUTPUT)
 618                 return ivtv_get_fmt(itv, streamtype, fmt);
 619
 620         /* any else but sliced VBI capture is an error */
 621         if (fmt->type != V4L2_BUF_TYPE_SLICED_VBI_CAPTURE)
 622                 return -EINVAL;
 623
 624         if (streamtype == IVTV_DEC_STREAM_TYPE_VBI)
 625                 return ivtv_get_fmt(itv, streamtype, fmt);
 626
 627         /* set sliced VBI capture format */
 628         vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
 629         memset(vbifmt->reserved, 0, sizeof(vbifmt->reserved));
 630
 631         if (vbifmt->service_set)
 632                 expand_service_set(vbifmt, itv->is_50hz);
 633         set = check_service_set(vbifmt, itv->is_50hz);
 634         vbifmt->service_set = get_service_set(vbifmt);
 635
 636         if (!set_fmt)
 637                 return 0;
 638         if (set == 0)
 639                 return -EINVAL;
 640         if (atomic_read(&itv->capturing) > 0) {
 641                 return -EBUSY;
 642         }
 643         itv->video_dec_func(itv, VIDIOC_S_FMT, fmt);
 644         memcpy(itv->vbi.sliced_in, vbifmt, sizeof(*itv->vbi.sliced_in));
 645         return 0;
 646 }
 647
 648 static int ivtv_debug_ioctls(struct file *filp, unsigned int cmd, void *arg)
 649 {
 650         struct ivtv_open_id *id = (struct ivtv_open_id *)filp->private_data;
 651         struct ivtv *itv = id->itv;
 652         struct v4l2_register *reg = arg;
 653
 654         switch (cmd) {
 655         /* ioctls to allow direct access to the encoder registers for testing */
 656         case VIDIOC_DBG_G_REGISTER:
 657                 if (v4l2_chip_match_host(reg->match_type, reg->match_chip))
 658                         return ivtv_itvc(itv, cmd, arg);
 659                 if (reg->match_type == V4L2_CHIP_MATCH_I2C_DRIVER)
 660                         return ivtv_i2c_id(itv, reg->match_chip, cmd, arg);
 661                 return ivtv_call_i2c_client(itv, reg->match_chip, cmd, arg);
 662
 663         case VIDIOC_DBG_S_REGISTER:
 664                 if (v4l2_chip_match_host(reg->match_type, reg->match_chip))
 665                         return ivtv_itvc(itv, cmd, arg);
 666                 if (reg->match_type == V4L2_CHIP_MATCH_I2C_DRIVER)
 667                         return ivtv_i2c_id(itv, reg->match_chip, cmd, arg);
 668                 return ivtv_call_i2c_client(itv, reg->match_chip, cmd, arg);
 669
 670         case VIDIOC_G_CHIP_IDENT: {
 671                 struct v4l2_chip_ident *chip = arg;
 672
 673                 chip->ident = V4L2_IDENT_NONE;
 674                 chip->revision = 0;
 675                 if (reg->match_type == V4L2_CHIP_MATCH_HOST) {
 676                         if (v4l2_chip_match_host(reg->match_type, reg->match_chip))
 677                                 chip->ident = itv->has_cx23415 ? V4L2_IDENT_CX23415 : V4L2_IDENT_CX23416;
 678                         return 0;
 679                 }
 680                 if (reg->match_type == V4L2_CHIP_MATCH_I2C_DRIVER)
 681                         return ivtv_i2c_id(itv, reg->match_chip, cmd, arg);
 682                 if (reg->match_type == V4L2_CHIP_MATCH_I2C_ADDR)
 683                         return ivtv_call_i2c_client(itv, reg->match_chip, cmd, arg);
 684                 return -EINVAL;
 685         }
 686
 687         case VIDIOC_INT_S_AUDIO_ROUTING: {
 688                 struct v4l2_routing *route = arg;
 689
 690                 ivtv_i2c_hw(itv, itv->card->hw_audio, VIDIOC_INT_S_AUDIO_ROUTING, route);
 691                 break;
 692         }
 693
 694         case VIDIOC_INT_RESET: {
 695                 u32 val = *(u32 *)arg;
 696
 697                 if ((val == 0 && itv->options.newi2c) || (val & 0x01)) {
 698                         ivtv_reset_ir_gpio(itv);
 699                 }
 700                 if (val & 0x02) {
 701                         itv->video_dec_func(itv, cmd, NULL);
 702                 }
 703                 break;
 704         }
 705
 706         default:
 707                 return -EINVAL;
 708         }
 709         return 0;
 710 }
 711
 712 int ivtv_v4l2_ioctls(struct ivtv *itv, struct file *filp, unsigned int cmd, void *arg)
 713 {
 714         struct ivtv_open_id *id = NULL;
 715         u32 data[CX2341X_MBOX_MAX_DATA];
 716         int streamtype = 0;
 717
 718         if (filp) {
 719                 id = (struct ivtv_open_id *)filp->private_data;
 720                 streamtype = id->type;
 721         }
 722
 723         switch (cmd) {
 724         case VIDIOC_G_PRIORITY:
 725         {
 726                 enum v4l2_priority *p = arg;
 727
 728                 *p = v4l2_prio_max(&itv->prio);
 729                 break;
 730         }
 731
 732         case VIDIOC_S_PRIORITY:
 733         {
 734                 enum v4l2_priority *prio = arg;
 735
 736                 return v4l2_prio_change(&itv->prio, &id->prio, *prio);
 737         }
 738
 739         case VIDIOC_QUERYCAP:{
 740                 struct v4l2_capability *vcap = arg;
 741
 742                 memset(vcap, 0, sizeof(*vcap));
 743                 strcpy(vcap->driver, IVTV_DRIVER_NAME);     /* driver name */
 744                 strcpy(vcap->card, itv->card_name);         /* card type */
 745                 strcpy(vcap->bus_info, pci_name(itv->dev)); /* bus info... */
 746                 vcap->version = IVTV_DRIVER_VERSION;        /* version */
 747                 vcap->capabilities = itv->v4l2_cap;         /* capabilities */
 748
 749                 /* reserved.. must set to 0! */
 750                 vcap->reserved[0] = vcap->reserved[1] =
 751                         vcap->reserved[2] = vcap->reserved[3] = 0;
 752                 break;
 753         }
 754
 755         case VIDIOC_ENUMAUDIO:{
 756                 struct v4l2_audio *vin = arg;
 757
 758                 return ivtv_get_audio_input(itv, vin->index, vin);
 759         }
 760
 761         case VIDIOC_G_AUDIO:{
 762                 struct v4l2_audio *vin = arg;
 763
 764                 vin->index = itv->audio_input;
 765                 return ivtv_get_audio_input(itv, vin->index, vin);
 766         }
 767
 768         case VIDIOC_S_AUDIO:{
 769                 struct v4l2_audio *vout = arg;
 770
 771                 if (vout->index >= itv->nof_audio_inputs)
 772                         return -EINVAL;
 773                 itv->audio_input = vout->index;
 774                 ivtv_audio_set_io(itv);
 775                 break;
 776         }
 777
 778         case VIDIOC_ENUMAUDOUT:{
 779                 struct v4l2_audioout *vin = arg;
 780
 781                 /* set it to defaults from our table */
 782                 return ivtv_get_audio_output(itv, vin->index, vin);
 783         }
 784
 785         case VIDIOC_G_AUDOUT:{
 786                 struct v4l2_audioout *vin = arg;
 787
 788                 vin->index = 0;
 789                 return ivtv_get_audio_output(itv, vin->index, vin);
 790         }
 791
 792         case VIDIOC_S_AUDOUT:{
 793                 struct v4l2_audioout *vout = arg;
 794
 795                 return ivtv_get_audio_output(itv, vout->index, vout);
 796         }
 797
 798         case VIDIOC_ENUMINPUT:{
 799                 struct v4l2_input *vin = arg;
 800
 801                 /* set it to defaults from our table */
 802                 return ivtv_get_input(itv, vin->index, vin);
 803         }
 804
 805         case VIDIOC_ENUMOUTPUT:{
 806                 struct v4l2_output *vout = arg;
 807
 808                 return ivtv_get_output(itv, vout->index, vout);
 809         }
 810
 811         case VIDIOC_TRY_FMT:
 812         case VIDIOC_S_FMT: {
 813                 struct v4l2_format *fmt = arg;
 814
 815                 return ivtv_try_or_set_fmt(itv, id->type, fmt, cmd == VIDIOC_S_FMT);
 816         }
 817
 818         case VIDIOC_G_FMT: {
 819                 struct v4l2_format *fmt = arg;
 820                 int type = fmt->type;
 821
 822                 memset(fmt, 0, sizeof(*fmt));
 823                 fmt->type = type;
 824                 return ivtv_get_fmt(itv, id->type, fmt);
 825         }
 826
 827         case VIDIOC_CROPCAP: {
 828                 struct v4l2_cropcap *cropcap = arg;
 829
 830                 if (cropcap->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
 831                     cropcap->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
 832                         return -EINVAL;
 833                 cropcap->bounds.top = cropcap->bounds.left = 0;
 834                 cropcap->bounds.width = 720;
 835                 if (cropcap->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
 836                         cropcap->bounds.height = itv->is_50hz ? 576 : 480;
 837                         cropcap->pixelaspect.numerator = itv->is_50hz ? 59 : 10;
 838                         cropcap->pixelaspect.denominator = itv->is_50hz ? 54 : 11;
 839                 } else if (streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
 840                         cropcap->bounds.width = itv->yuv_info.osd_full_w;
 841                         cropcap->bounds.height = itv->yuv_info.osd_full_h;
 842                         cropcap->pixelaspect.numerator = itv->is_out_50hz ? 59 : 10;
 843                         cropcap->pixelaspect.denominator = itv->is_out_50hz ? 54 : 11;
 844                 } else {
 845                         cropcap->bounds.height = itv->is_out_50hz ? 576 : 480;
 846                         cropcap->pixelaspect.numerator = itv->is_out_50hz ? 59 : 10;
 847                         cropcap->pixelaspect.denominator = itv->is_out_50hz ? 54 : 11;
 848                 }
 849                 cropcap->defrect = cropcap->bounds;
 850                 return 0;
 851         }
 852
 853         case VIDIOC_S_CROP: {
 854                 struct v4l2_crop *crop = arg;
 855
 856                 if (crop->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
 857                     (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) {
 858                         if (streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
 859                                 itv->yuv_info.main_rect = crop->c;
 860                                 return 0;
 861                         } else {
 862                                 if (!ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
 863                                         crop->c.width, crop->c.height, crop->c.left, crop->c.top)) {
 864                                         itv->main_rect = crop->c;
 865                                         return 0;
 866                                 }
 867                         }
 868                         return -EINVAL;
 869                 }
 870                 if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 871                         return -EINVAL;
 872                 return itv->video_dec_func(itv, VIDIOC_S_CROP, arg);
 873         }
 874
 875         case VIDIOC_G_CROP: {
 876                 struct v4l2_crop *crop = arg;
 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                                 crop->c = itv->yuv_info.main_rect;
 882                         else
 883                                 crop->c = itv->main_rect;
 884                         return 0;
 885                 }
 886                 if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 887                         return -EINVAL;
 888                 return itv->video_dec_func(itv, VIDIOC_G_CROP, arg);
 889         }
 890
 891         case VIDIOC_ENUM_FMT: {
 892                 static struct v4l2_fmtdesc formats[] = {
 893                         { 0, 0, 0,
 894                           "HM12 (YUV 4:2:0)", V4L2_PIX_FMT_HM12,
 895                           { 0, 0, 0, 0 }
 896                         },
 897                         { 1, 0, V4L2_FMT_FLAG_COMPRESSED,
 898                           "MPEG", V4L2_PIX_FMT_MPEG,
 899                           { 0, 0, 0, 0 }
 900                         }
 901                 };
 902                 struct v4l2_fmtdesc *fmt = arg;
 903                 enum v4l2_buf_type type = fmt->type;
 904
 905                 switch (type) {
 906                 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
 907                         break;
 908                 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
 909                         if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
 910                                 return -EINVAL;
 911                         break;
 912                 default:
 913                         return -EINVAL;
 914                 }
 915                 if (fmt->index > 1)
 916                         return -EINVAL;
 917                 *fmt = formats[fmt->index];
 918                 fmt->type = type;
 919                 return 0;
 920         }
 921
 922         case VIDIOC_G_INPUT:{
 923                 *(int *)arg = itv->active_input;
 924                 break;
 925         }
 926
 927         case VIDIOC_S_INPUT:{
 928                 int inp = *(int *)arg;
 929
 930                 if (inp < 0 || inp >= itv->nof_inputs)
 931                         return -EINVAL;
 932
 933                 if (inp == itv->active_input) {
 934                         IVTV_DEBUG_INFO("Input unchanged\n");
 935                         break;
 936                 }
 937                 if (atomic_read(&itv->capturing) > 0) {
 938                         return -EBUSY;
 939                 }
 940                 IVTV_DEBUG_INFO("Changing input from %d to %d\n",
 941                                 itv->active_input, inp);
 942
 943                 itv->active_input = inp;
 944                 /* Set the audio input to whatever is appropriate for the
 945                    input type. */
 946                 itv->audio_input = itv->card->video_inputs[inp].audio_index;
 947
 948                 /* prevent others from messing with the streams until
 949                    we're finished changing inputs. */
 950                 ivtv_mute(itv);
 951                 ivtv_video_set_io(itv);
 952                 ivtv_audio_set_io(itv);
 953                 ivtv_unmute(itv);
 954                 break;
 955         }
 956
 957         case VIDIOC_G_OUTPUT:{
 958                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
 959                         return -EINVAL;
 960                 *(int *)arg = itv->active_output;
 961                 break;
 962         }
 963
 964         case VIDIOC_S_OUTPUT:{
 965                 int outp = *(int *)arg;
 966                 struct v4l2_routing route;
 967
 968                 if (outp >= itv->card->nof_outputs)
 969                         return -EINVAL;
 970
 971                 if (outp == itv->active_output) {
 972                         IVTV_DEBUG_INFO("Output unchanged\n");
 973                         break;
 974                 }
 975                 IVTV_DEBUG_INFO("Changing output from %d to %d\n",
 976                            itv->active_output, outp);
 977
 978                 itv->active_output = outp;
 979                 route.input = SAA7127_INPUT_TYPE_NORMAL;
 980                 route.output = itv->card->video_outputs[outp].video_output;
 981                 ivtv_saa7127(itv, VIDIOC_INT_S_VIDEO_ROUTING, &route);
 982                 break;
 983         }
 984
 985         case VIDIOC_G_FREQUENCY:{
 986                 struct v4l2_frequency *vf = arg;
 987
 988                 if (vf->tuner != 0)
 989                         return -EINVAL;
 990                 ivtv_call_i2c_clients(itv, cmd, arg);
 991                 break;
 992         }
 993
 994         case VIDIOC_S_FREQUENCY:{
 995                 struct v4l2_frequency vf = *(struct v4l2_frequency *)arg;
 996
 997                 if (vf.tuner != 0)
 998                         return -EINVAL;
 999
1000                 ivtv_mute(itv);
1001                 IVTV_DEBUG_INFO("v4l2 ioctl: set frequency %d\n", vf.frequency);
1002                 ivtv_call_i2c_clients(itv, cmd, &vf);
1003                 ivtv_unmute(itv);
1004                 break;
1005         }
1006
1007         case VIDIOC_ENUMSTD:{
1008                 struct v4l2_standard *vs = arg;
1009                 int idx = vs->index;
1010
1011                 if (idx < 0 || idx >= ARRAY_SIZE(enum_stds))
1012                         return -EINVAL;
1013
1014                 *vs = (enum_stds[idx].std & V4L2_STD_525_60) ?
1015                                 ivtv_std_60hz : ivtv_std_50hz;
1016                 vs->index = idx;
1017                 vs->id = enum_stds[idx].std;
1018                 strcpy(vs->name, enum_stds[idx].name);
1019                 break;
1020         }
1021
1022         case VIDIOC_G_STD:{
1023                 *(v4l2_std_id *) arg = itv->std;
1024                 break;
1025         }
1026
1027         case VIDIOC_S_STD: {
1028                 v4l2_std_id std = *(v4l2_std_id *) arg;
1029
1030                 if ((std & V4L2_STD_ALL) == 0)
1031                         return -EINVAL;
1032
1033                 if (std == itv->std)
1034                         break;
1035
1036                 if (test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ||
1037                     atomic_read(&itv->capturing) > 0 ||
1038                     atomic_read(&itv->decoding) > 0) {
1039                         /* Switching standard would turn off the radio or mess
1040                            with already running streams, prevent that by
1041                            returning EBUSY. */
1042                         return -EBUSY;
1043                 }
1044
1045                 itv->std = std;
1046                 itv->is_60hz = (std & V4L2_STD_525_60) ? 1 : 0;
1047                 itv->params.is_50hz = itv->is_50hz = !itv->is_60hz;
1048                 itv->params.width = 720;
1049                 itv->params.height = itv->is_50hz ? 576 : 480;
1050                 itv->vbi.count = itv->is_50hz ? 18 : 12;
1051                 itv->vbi.start[0] = itv->is_50hz ? 6 : 10;
1052                 itv->vbi.start[1] = itv->is_50hz ? 318 : 273;
1053                 if (itv->hw_flags & IVTV_HW_CX25840) {
1054                         itv->vbi.sliced_decoder_line_size = itv->is_60hz ? 272 : 284;
1055                 }
1056                 IVTV_DEBUG_INFO("Switching standard to %llx.\n", (unsigned long long)itv->std);
1057
1058                 /* Tuner */
1059                 ivtv_call_i2c_clients(itv, VIDIOC_S_STD, &itv->std);
1060
1061                 if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT) {
1062                         /* set display standard */
1063                         itv->std_out = std;
1064                         itv->is_out_60hz = itv->is_60hz;
1065                         itv->is_out_50hz = itv->is_50hz;
1066                         ivtv_call_i2c_clients(itv, VIDIOC_INT_S_STD_OUTPUT, &itv->std_out);
1067                         ivtv_vapi(itv, CX2341X_DEC_SET_STANDARD, 1, itv->is_out_50hz);
1068                         itv->main_rect.left = itv->main_rect.top = 0;
1069                         itv->main_rect.width = 720;
1070                         itv->main_rect.height = itv->params.height;
1071                         ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
1072                                 720, itv->main_rect.height, 0, 0);
1073                         itv->yuv_info.main_rect = itv->main_rect;
1074                         if (!itv->osd_info) {
1075                                 itv->yuv_info.osd_full_w = 720;
1076                                 itv->yuv_info.osd_full_h =
1077                                                 itv->is_out_50hz ? 576 : 480;
1078                         }
1079                 }
1080                 break;
1081         }
1082
1083         case VIDIOC_S_TUNER: {  /* Setting tuner can only set audio mode */
1084                 struct v4l2_tuner *vt = arg;
1085
1086                 if (vt->index != 0)
1087                         return -EINVAL;
1088
1089                 ivtv_call_i2c_clients(itv, VIDIOC_S_TUNER, vt);
1090                 break;
1091         }
1092
1093         case VIDIOC_G_TUNER: {
1094                 struct v4l2_tuner *vt = arg;
1095
1096                 if (vt->index != 0)
1097                         return -EINVAL;
1098
1099                 memset(vt, 0, sizeof(*vt));
1100                 ivtv_call_i2c_clients(itv, VIDIOC_G_TUNER, vt);
1101
1102                 if (test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags)) {
1103                         strcpy(vt->name, "ivtv Radio Tuner");
1104                         vt->type = V4L2_TUNER_RADIO;
1105                 } else {
1106                         strcpy(vt->name, "ivtv TV Tuner");
1107                         vt->type = V4L2_TUNER_ANALOG_TV;
1108                 }
1109                 break;
1110         }
1111
1112         case VIDIOC_G_SLICED_VBI_CAP: {
1113                 struct v4l2_sliced_vbi_cap *cap = arg;
1114                 int set = itv->is_50hz ? V4L2_SLICED_VBI_625 : V4L2_SLICED_VBI_525;
1115                 int f, l;
1116                 enum v4l2_buf_type type = cap->type;
1117
1118                 memset(cap, 0, sizeof(*cap));
1119                 cap->type = type;
1120                 if (type == V4L2_BUF_TYPE_SLICED_VBI_CAPTURE) {
1121                         for (f = 0; f < 2; f++) {
1122                                 for (l = 0; l < 24; l++) {
1123                                         if (valid_service_line(f, l, itv->is_50hz)) {
1124                                                 cap->service_lines[f][l] = set;
1125                                         }
1126                                 }
1127                         }
1128                         return 0;
1129                 }
1130                 if (type == V4L2_BUF_TYPE_SLICED_VBI_OUTPUT) {
1131                         if (!(itv->v4l2_cap & V4L2_CAP_SLICED_VBI_OUTPUT))
1132                                 return -EINVAL;
1133                         if (itv->is_60hz) {
1134                                 cap->service_lines[0][21] = V4L2_SLICED_CAPTION_525;
1135                                 cap->service_lines[1][21] = V4L2_SLICED_CAPTION_525;
1136                         } else {
1137                                 cap->service_lines[0][23] = V4L2_SLICED_WSS_625;
1138                                 cap->service_lines[0][16] = V4L2_SLICED_VPS;
1139                         }
1140                         return 0;
1141                 }
1142                 return -EINVAL;
1143         }
1144
1145         case VIDIOC_G_ENC_INDEX: {
1146                 struct v4l2_enc_idx *idx = arg;
1147                 struct v4l2_enc_idx_entry *e = idx->entry;
1148                 int entries;
1149                 int i;
1150
1151                 entries = (itv->pgm_info_write_idx + IVTV_MAX_PGM_INDEX - itv->pgm_info_read_idx) %
1152                                         IVTV_MAX_PGM_INDEX;
1153                 if (entries > V4L2_ENC_IDX_ENTRIES)
1154                         entries = V4L2_ENC_IDX_ENTRIES;
1155                 idx->entries = 0;
1156                 for (i = 0; i < entries; i++) {
1157                         *e = itv->pgm_info[(itv->pgm_info_read_idx + i) % IVTV_MAX_PGM_INDEX];
1158                         if ((e->flags & V4L2_ENC_IDX_FRAME_MASK) <= V4L2_ENC_IDX_FRAME_B) {
1159                                 idx->entries++;
1160                                 e++;
1161                         }
1162                 }
1163                 itv->pgm_info_read_idx = (itv->pgm_info_read_idx + idx->entries) % IVTV_MAX_PGM_INDEX;
1164                 break;
1165         }
1166
1167         case VIDIOC_ENCODER_CMD:
1168         case VIDIOC_TRY_ENCODER_CMD: {
1169                 struct v4l2_encoder_cmd *enc = arg;
1170                 int try = cmd == VIDIOC_TRY_ENCODER_CMD;
1171
1172                 memset(&enc->raw, 0, sizeof(enc->raw));
1173                 switch (enc->cmd) {
1174                 case V4L2_ENC_CMD_START:
1175                         IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
1176                         enc->flags = 0;
1177                         if (try)
1178                                 return 0;
1179                         return ivtv_start_capture(id);
1180
1181                 case V4L2_ENC_CMD_STOP:
1182                         IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
1183                         enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END;
1184                         if (try)
1185                                 return 0;
1186                         ivtv_stop_capture(id, enc->flags & V4L2_ENC_CMD_STOP_AT_GOP_END);
1187                         return 0;
1188
1189                 case V4L2_ENC_CMD_PAUSE:
1190                         IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
1191                         enc->flags = 0;
1192                         if (try)
1193                                 return 0;
1194                         if (!atomic_read(&itv->capturing))
1195                                 return -EPERM;
1196                         if (test_and_set_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags))
1197                                 return 0;
1198                         ivtv_mute(itv);
1199                         ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 0);
1200                         break;
1201
1202                 case V4L2_ENC_CMD_RESUME:
1203                         IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
1204                         enc->flags = 0;
1205                         if (try)
1206                                 return 0;
1207                         if (!atomic_read(&itv->capturing))
1208                                 return -EPERM;
1209                         if (!test_and_clear_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags))
1210                                 return 0;
1211                         ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 1);
1212                         ivtv_unmute(itv);
1213                         break;
1214                 default:
1215                         IVTV_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd);
1216                         return -EINVAL;
1217                 }
1218                 break;
1219         }
1220
1221         case VIDIOC_G_FBUF: {
1222                 struct v4l2_framebuffer *fb = arg;
1223                 int pixfmt;
1224                 static u32 pixel_format[16] = {
1225                         V4L2_PIX_FMT_PAL8, /* Uses a 256-entry RGB colormap */
1226                         V4L2_PIX_FMT_RGB565,
1227                         V4L2_PIX_FMT_RGB555,
1228                         V4L2_PIX_FMT_RGB444,
1229                         V4L2_PIX_FMT_RGB32,
1230                         0,
1231                         0,
1232                         0,
1233                         V4L2_PIX_FMT_PAL8, /* Uses a 256-entry YUV colormap */
1234                         V4L2_PIX_FMT_YUV565,
1235                         V4L2_PIX_FMT_YUV555,
1236                         V4L2_PIX_FMT_YUV444,
1237                         V4L2_PIX_FMT_YUV32,
1238                         0,
1239                         0,
1240                         0,
1241                 };
1242
1243                 memset(fb, 0, sizeof(*fb));
1244                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1245                         return -EINVAL;
1246                 fb->capability = V4L2_FBUF_CAP_EXTERNOVERLAY | V4L2_FBUF_CAP_CHROMAKEY |
1247                         V4L2_FBUF_CAP_GLOBAL_ALPHA;
1248                 ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0);
1249                 data[0] |= (read_reg(0x2a00) >> 7) & 0x40;
1250                 pixfmt = (data[0] >> 3) & 0xf;
1251                 fb->fmt.pixelformat = pixel_format[pixfmt];
1252                 fb->fmt.width = itv->osd_rect.width;
1253                 fb->fmt.height = itv->osd_rect.height;
1254                 fb->base = (void *)itv->osd_video_pbase;
1255                 if (itv->osd_chroma_key_state)
1256                         fb->flags |= V4L2_FBUF_FLAG_CHROMAKEY;
1257                 if (itv->osd_global_alpha_state)
1258                         fb->flags |= V4L2_FBUF_FLAG_GLOBAL_ALPHA;
1259                 pixfmt &= 7;
1260                 /* no local alpha for RGB565 or unknown formats */
1261                 if (pixfmt == 1 || pixfmt > 4)
1262                         break;
1263                 /* 16-bit formats have inverted local alpha */
1264                 if (pixfmt == 2 || pixfmt == 3)
1265                         fb->capability |= V4L2_FBUF_CAP_LOCAL_INV_ALPHA;
1266                 else
1267                         fb->capability |= V4L2_FBUF_CAP_LOCAL_ALPHA;
1268                 if (itv->osd_local_alpha_state) {
1269                         /* 16-bit formats have inverted local alpha */
1270                         if (pixfmt == 2 || pixfmt == 3)
1271                                 fb->flags |= V4L2_FBUF_FLAG_LOCAL_INV_ALPHA;
1272                         else
1273                                 fb->flags |= V4L2_FBUF_FLAG_LOCAL_ALPHA;
1274                 }
1275                 break;
1276         }
1277
1278         case VIDIOC_S_FBUF: {
1279                 struct v4l2_framebuffer *fb = arg;
1280
1281                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1282                         return -EINVAL;
1283                 itv->osd_global_alpha_state = (fb->flags & V4L2_FBUF_FLAG_GLOBAL_ALPHA) != 0;
1284                 itv->osd_local_alpha_state =
1285                         (fb->flags & (V4L2_FBUF_FLAG_LOCAL_ALPHA|V4L2_FBUF_FLAG_LOCAL_INV_ALPHA)) != 0;
1286                 itv->osd_chroma_key_state = (fb->flags & V4L2_FBUF_FLAG_CHROMAKEY) != 0;
1287                 ivtv_set_osd_alpha(itv);
1288                 break;
1289         }
1290
1291         case VIDIOC_OVERLAY: {
1292                 int *on = arg;
1293
1294                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1295                         return -EINVAL;
1296                 ivtv_vapi(itv, CX2341X_OSD_SET_STATE, 1, *on != 0);
1297                 break;
1298         }
1299
1300         case VIDIOC_LOG_STATUS:
1301         {
1302                 int has_output = itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT;
1303                 struct v4l2_input vidin;
1304                 struct v4l2_audio audin;
1305                 int i;
1306
1307                 IVTV_INFO("=================  START STATUS CARD #%d  =================\n", itv->num);
1308                 IVTV_INFO("Version: %s Card: %s\n", IVTV_VERSION, itv->card_name);
1309                 if (itv->hw_flags & IVTV_HW_TVEEPROM) {
1310                         struct tveeprom tv;
1311
1312                         ivtv_read_eeprom(itv, &tv);
1313                 }
1314                 ivtv_call_i2c_clients(itv, VIDIOC_LOG_STATUS, NULL);
1315                 ivtv_get_input(itv, itv->active_input, &vidin);
1316                 ivtv_get_audio_input(itv, itv->audio_input, &audin);
1317                 IVTV_INFO("Video Input:  %s\n", vidin.name);
1318                 IVTV_INFO("Audio Input:  %s%s\n", audin.name,
1319                         (itv->dualwatch_stereo_mode & ~0x300) == 0x200 ? " (Bilingual)" : "");
1320                 if (has_output) {
1321                         struct v4l2_output vidout;
1322                         struct v4l2_audioout audout;
1323                         int mode = itv->output_mode;
1324                         static const char * const output_modes[5] = {
1325                                 "None",
1326                                 "MPEG Streaming",
1327                                 "YUV Streaming",
1328                                 "YUV Frames",
1329                                 "Passthrough",
1330                         };
1331                         static const char * const audio_modes[5] = {
1332                                 "Stereo",
1333                                 "Left",
1334                                 "Right",
1335                                 "Mono",
1336                                 "Swapped"
1337                         };
1338                         static const char * const alpha_mode[4] = {
1339                                 "None",
1340                                 "Global",
1341                                 "Local",
1342                                 "Global and Local"
1343                         };
1344                         static const char * const pixel_format[16] = {
1345                                 "ARGB Indexed",
1346                                 "RGB 5:6:5",
1347                                 "ARGB 1:5:5:5",
1348                                 "ARGB 1:4:4:4",
1349                                 "ARGB 8:8:8:8",
1350                                 "5",
1351                                 "6",
1352                                 "7",
1353                                 "AYUV Indexed",
1354                                 "YUV 5:6:5",
1355                                 "AYUV 1:5:5:5",
1356                                 "AYUV 1:4:4:4",
1357                                 "AYUV 8:8:8:8",
1358                                 "13",
1359                                 "14",
1360                                 "15",
1361                         };
1362
1363                         ivtv_get_output(itv, itv->active_output, &vidout);
1364                         ivtv_get_audio_output(itv, 0, &audout);
1365                         IVTV_INFO("Video Output: %s\n", vidout.name);
1366                         IVTV_INFO("Audio Output: %s (Stereo/Bilingual: %s/%s)\n", audout.name,
1367                                 audio_modes[itv->audio_stereo_mode],
1368                                 audio_modes[itv->audio_bilingual_mode]);
1369                         if (mode < 0 || mode > OUT_PASSTHROUGH)
1370                                 mode = OUT_NONE;
1371                         IVTV_INFO("Output Mode:  %s\n", output_modes[mode]);
1372                         ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0);
1373                         data[0] |= (read_reg(0x2a00) >> 7) & 0x40;
1374                         IVTV_INFO("Overlay:      %s, Alpha: %s, Pixel Format: %s\n",
1375                                 data[0] & 1 ? "On" : "Off",
1376                                 alpha_mode[(data[0] >> 1) & 0x3],
1377                                 pixel_format[(data[0] >> 3) & 0xf]);
1378                 }
1379                 IVTV_INFO("Tuner:  %s\n",
1380                         test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ? "Radio" : "TV");
1381                 cx2341x_log_status(&itv->params, itv->name);
1382                 IVTV_INFO("Status flags:    0x%08lx\n", itv->i_flags);
1383                 for (i = 0; i < IVTV_MAX_STREAMS; i++) {
1384                         struct ivtv_stream *s = &itv->streams[i];
1385
1386                         if (s->v4l2dev == NULL || s->buffers == 0)
1387                                 continue;
1388                         IVTV_INFO("Stream %s: status 0x%04lx, %d%% of %d KiB (%d buffers) in use\n", s->name, s->s_flags,
1389                                         (s->buffers - s->q_free.buffers) * 100 / s->buffers,
1390                                         (s->buffers * s->buf_size) / 1024, s->buffers);
1391                 }
1392                 IVTV_INFO("Read MPG/VBI: %lld/%lld bytes\n", (long long)itv->mpg_data_received, (long long)itv->vbi_data_inserted);
1393                 IVTV_INFO("==================  END STATUS CARD #%d  ==================\n", itv->num);
1394                 break;
1395         }
1396
1397         default:
1398                 return -EINVAL;
1399         }
1400         return 0;
1401 }
1402
1403 static int ivtv_decoder_ioctls(struct file *filp, unsigned int cmd, void *arg)
1404 {
1405         struct ivtv_open_id *id = (struct ivtv_open_id *)filp->private_data;
1406         struct ivtv *itv = id->itv;
1407         int nonblocking = filp->f_flags & O_NONBLOCK;
1408         struct ivtv_stream *s = &itv->streams[id->type];
1409
1410         switch (cmd) {
1411         case IVTV_IOC_DMA_FRAME: {
1412                 struct ivtv_dma_frame *args = arg;
1413
1414                 IVTV_DEBUG_IOCTL("IVTV_IOC_DMA_FRAME\n");
1415                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1416                         return -EINVAL;
1417                 if (args->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
1418                         return -EINVAL;
1419                 if (itv->output_mode == OUT_UDMA_YUV && args->y_source == NULL)
1420                         return 0;
1421                 if (ivtv_claim_stream(id, id->type)) {
1422                         return -EBUSY;
1423                 }
1424                 if (ivtv_set_output_mode(itv, OUT_UDMA_YUV) != OUT_UDMA_YUV) {
1425                         ivtv_release_stream(s);
1426                         return -EBUSY;
1427                 }
1428                 /* Mark that this file handle started the UDMA_YUV mode */
1429                 id->yuv_frames = 1;
1430                 if (args->y_source == NULL)
1431                         return 0;
1432                 return ivtv_yuv_prep_frame(itv, args);
1433         }
1434
1435         case VIDEO_GET_PTS: {
1436                 u32 data[CX2341X_MBOX_MAX_DATA];
1437                 u64 *pts = arg;
1438
1439                 IVTV_DEBUG_IOCTL("VIDEO_GET_PTS\n");
1440                 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) {
1441                         *pts = s->dma_pts;
1442                         break;
1443                 }
1444                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1445                         return -EINVAL;
1446
1447                 if (test_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags)) {
1448                         *pts = (u64) ((u64)itv->last_dec_timing[2] << 32) |
1449                                         (u64)itv->last_dec_timing[1];
1450                         break;
1451                 }
1452                 *pts = 0;
1453                 if (atomic_read(&itv->decoding)) {
1454                         if (ivtv_api(itv, CX2341X_DEC_GET_TIMING_INFO, 5, data)) {
1455                                 IVTV_DEBUG_WARN("GET_TIMING: couldn't read clock\n");
1456                                 return -EIO;
1457                         }
1458                         memcpy(itv->last_dec_timing, data, sizeof(itv->last_dec_timing));
1459                         set_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags);
1460                         *pts = (u64) ((u64) data[2] << 32) | (u64) data[1];
1461                         /*timing->scr = (u64) (((u64) data[4] << 32) | (u64) (data[3]));*/
1462                 }
1463                 break;
1464         }
1465
1466         case VIDEO_GET_FRAME_COUNT: {
1467                 u32 data[CX2341X_MBOX_MAX_DATA];
1468                 u64 *frame = arg;
1469
1470                 IVTV_DEBUG_IOCTL("VIDEO_GET_FRAME_COUNT\n");
1471                 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) {
1472                         *frame = 0;
1473                         break;
1474                 }
1475                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1476                         return -EINVAL;
1477
1478                 if (test_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags)) {
1479                         *frame = itv->last_dec_timing[0];
1480                         break;
1481                 }
1482                 *frame = 0;
1483                 if (atomic_read(&itv->decoding)) {
1484                         if (ivtv_api(itv, CX2341X_DEC_GET_TIMING_INFO, 5, data)) {
1485                                 IVTV_DEBUG_WARN("GET_TIMING: couldn't read clock\n");
1486                                 return -EIO;
1487                         }
1488                         memcpy(itv->last_dec_timing, data, sizeof(itv->last_dec_timing));
1489                         set_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags);
1490                         *frame = data[0];
1491                 }
1492                 break;
1493         }
1494
1495         case VIDEO_PLAY: {
1496                 struct video_command vc;
1497
1498                 IVTV_DEBUG_IOCTL("VIDEO_PLAY\n");
1499                 memset(&vc, 0, sizeof(vc));
1500                 vc.cmd = VIDEO_CMD_PLAY;
1501                 return ivtv_video_command(itv, id, &vc, 0);
1502         }
1503
1504         case VIDEO_STOP: {
1505                 struct video_command vc;
1506
1507                 IVTV_DEBUG_IOCTL("VIDEO_STOP\n");
1508                 memset(&vc, 0, sizeof(vc));
1509                 vc.cmd = VIDEO_CMD_STOP;
1510                 vc.flags = VIDEO_CMD_STOP_TO_BLACK | VIDEO_CMD_STOP_IMMEDIATELY;
1511                 return ivtv_video_command(itv, id, &vc, 0);
1512         }
1513
1514         case VIDEO_FREEZE: {
1515                 struct video_command vc;
1516
1517                 IVTV_DEBUG_IOCTL("VIDEO_FREEZE\n");
1518                 memset(&vc, 0, sizeof(vc));
1519                 vc.cmd = VIDEO_CMD_FREEZE;
1520                 return ivtv_video_command(itv, id, &vc, 0);
1521         }
1522
1523         case VIDEO_CONTINUE: {
1524                 struct video_command vc;
1525
1526                 IVTV_DEBUG_IOCTL("VIDEO_CONTINUE\n");
1527                 memset(&vc, 0, sizeof(vc));
1528                 vc.cmd = VIDEO_CMD_CONTINUE;
1529                 return ivtv_video_command(itv, id, &vc, 0);
1530         }
1531
1532         case VIDEO_COMMAND:
1533         case VIDEO_TRY_COMMAND: {
1534                 struct video_command *vc = arg;
1535                 int try = (cmd == VIDEO_TRY_COMMAND);
1536
1537                 if (try)
1538                         IVTV_DEBUG_IOCTL("VIDEO_TRY_COMMAND %d\n", vc->cmd);
1539                 else
1540                         IVTV_DEBUG_IOCTL("VIDEO_COMMAND %d\n", vc->cmd);
1541                 return ivtv_video_command(itv, id, vc, try);
1542         }
1543
1544         case VIDEO_GET_EVENT: {
1545                 struct video_event *ev = arg;
1546                 DEFINE_WAIT(wait);
1547
1548                 IVTV_DEBUG_IOCTL("VIDEO_GET_EVENT\n");
1549                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1550                         return -EINVAL;
1551                 memset(ev, 0, sizeof(*ev));
1552                 set_bit(IVTV_F_I_EV_VSYNC_ENABLED, &itv->i_flags);
1553
1554                 while (1) {
1555                         if (test_and_clear_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags))
1556                                 ev->type = VIDEO_EVENT_DECODER_STOPPED;
1557                         else if (test_and_clear_bit(IVTV_F_I_EV_VSYNC, &itv->i_flags)) {
1558                                 ev->type = VIDEO_EVENT_VSYNC;
1559                                 ev->u.vsync_field = test_bit(IVTV_F_I_EV_VSYNC_FIELD, &itv->i_flags) ?
1560                                         VIDEO_VSYNC_FIELD_ODD : VIDEO_VSYNC_FIELD_EVEN;
1561                                 if (itv->output_mode == OUT_UDMA_YUV &&
1562                                         (itv->yuv_info.lace_mode & IVTV_YUV_MODE_MASK) ==
1563                                                                 IVTV_YUV_MODE_PROGRESSIVE) {
1564                                         ev->u.vsync_field = VIDEO_VSYNC_FIELD_PROGRESSIVE;
1565                                 }
1566                         }
1567                         if (ev->type)
1568                                 return 0;
1569                         if (nonblocking)
1570                                 return -EAGAIN;
1571                         /* Wait for event. Note that serialize_lock is locked,
1572                            so to allow other processes to access the driver while
1573                            we are waiting unlock first and later lock again. */
1574                         mutex_unlock(&itv->serialize_lock);
1575                         prepare_to_wait(&itv->event_waitq, &wait, TASK_INTERRUPTIBLE);
1576                         if ((itv->i_flags & (IVTV_F_I_EV_DEC_STOPPED|IVTV_F_I_EV_VSYNC)) == 0)
1577                                 schedule();
1578                         finish_wait(&itv->event_waitq, &wait);
1579                         mutex_lock(&itv->serialize_lock);
1580                         if (signal_pending(current)) {
1581                                 /* return if a signal was received */
1582                                 IVTV_DEBUG_INFO("User stopped wait for event\n");
1583                                 return -EINTR;
1584                         }
1585                 }
1586                 break;
1587         }
1588
1589         default:
1590                 return -EINVAL;
1591         }
1592         return 0;
1593 }
1594
1595 static int ivtv_v4l2_do_ioctl(struct inode *inode, struct file *filp,
1596                               unsigned int cmd, void *arg)
1597 {
1598         struct ivtv_open_id *id = (struct ivtv_open_id *)filp->private_data;
1599         struct ivtv *itv = id->itv;
1600         int ret;
1601
1602         /* check priority */
1603         switch (cmd) {
1604         case VIDIOC_S_CTRL:
1605         case VIDIOC_S_STD:
1606         case VIDIOC_S_INPUT:
1607         case VIDIOC_S_OUTPUT:
1608         case VIDIOC_S_TUNER:
1609         case VIDIOC_S_FREQUENCY:
1610         case VIDIOC_S_FMT:
1611         case VIDIOC_S_CROP:
1612         case VIDIOC_S_AUDIO:
1613         case VIDIOC_S_AUDOUT:
1614         case VIDIOC_S_EXT_CTRLS:
1615         case VIDIOC_S_FBUF:
1616         case VIDIOC_OVERLAY:
1617                 ret = v4l2_prio_check(&itv->prio, &id->prio);
1618                 if (ret)
1619                         return ret;
1620         }
1621
1622         switch (cmd) {
1623         case VIDIOC_DBG_G_REGISTER:
1624         case VIDIOC_DBG_S_REGISTER:
1625         case VIDIOC_G_CHIP_IDENT:
1626         case VIDIOC_INT_S_AUDIO_ROUTING:
1627         case VIDIOC_INT_RESET:
1628                 if (ivtv_debug & IVTV_DBGFLG_IOCTL) {
1629                         printk(KERN_INFO "ivtv%d ioctl: ", itv->num);
1630                         v4l_printk_ioctl(cmd);
1631                 }
1632                 return ivtv_debug_ioctls(filp, cmd, arg);
1633
1634         case VIDIOC_G_PRIORITY:
1635         case VIDIOC_S_PRIORITY:
1636         case VIDIOC_QUERYCAP:
1637         case VIDIOC_ENUMINPUT:
1638         case VIDIOC_G_INPUT:
1639         case VIDIOC_S_INPUT:
1640         case VIDIOC_ENUMOUTPUT:
1641         case VIDIOC_G_OUTPUT:
1642         case VIDIOC_S_OUTPUT:
1643         case VIDIOC_G_FMT:
1644         case VIDIOC_S_FMT:
1645         case VIDIOC_TRY_FMT:
1646         case VIDIOC_ENUM_FMT:
1647         case VIDIOC_CROPCAP:
1648         case VIDIOC_G_CROP:
1649         case VIDIOC_S_CROP:
1650         case VIDIOC_G_FREQUENCY:
1651         case VIDIOC_S_FREQUENCY:
1652         case VIDIOC_ENUMSTD:
1653         case VIDIOC_G_STD:
1654         case VIDIOC_S_STD:
1655         case VIDIOC_S_TUNER:
1656         case VIDIOC_G_TUNER:
1657         case VIDIOC_ENUMAUDIO:
1658         case VIDIOC_S_AUDIO:
1659         case VIDIOC_G_AUDIO:
1660         case VIDIOC_ENUMAUDOUT:
1661         case VIDIOC_S_AUDOUT:
1662         case VIDIOC_G_AUDOUT:
1663         case VIDIOC_G_SLICED_VBI_CAP:
1664         case VIDIOC_LOG_STATUS:
1665         case VIDIOC_G_ENC_INDEX:
1666         case VIDIOC_ENCODER_CMD:
1667         case VIDIOC_TRY_ENCODER_CMD:
1668         case VIDIOC_G_FBUF:
1669         case VIDIOC_S_FBUF:
1670         case VIDIOC_OVERLAY:
1671                 if (ivtv_debug & IVTV_DBGFLG_IOCTL) {
1672                         printk(KERN_INFO "ivtv%d ioctl: ", itv->num);
1673                         v4l_printk_ioctl(cmd);
1674                 }
1675                 return ivtv_v4l2_ioctls(itv, filp, cmd, arg);
1676
1677         case VIDIOC_QUERYMENU:
1678         case VIDIOC_QUERYCTRL:
1679         case VIDIOC_S_CTRL:
1680         case VIDIOC_G_CTRL:
1681         case VIDIOC_S_EXT_CTRLS:
1682         case VIDIOC_G_EXT_CTRLS:
1683         case VIDIOC_TRY_EXT_CTRLS:
1684                 if (ivtv_debug & IVTV_DBGFLG_IOCTL) {
1685                         printk(KERN_INFO "ivtv%d ioctl: ", itv->num);
1686                         v4l_printk_ioctl(cmd);
1687                 }
1688                 return ivtv_control_ioctls(itv, cmd, arg);
1689
1690         case IVTV_IOC_DMA_FRAME:
1691         case VIDEO_GET_PTS:
1692         case VIDEO_GET_FRAME_COUNT:
1693         case VIDEO_GET_EVENT:
1694         case VIDEO_PLAY:
1695         case VIDEO_STOP:
1696         case VIDEO_FREEZE:
1697         case VIDEO_CONTINUE:
1698         case VIDEO_COMMAND:
1699         case VIDEO_TRY_COMMAND:
1700                 return ivtv_decoder_ioctls(filp, cmd, arg);
1701
1702         case 0x00005401:        /* Handle isatty() calls */
1703                 return -EINVAL;
1704         default:
1705                 return v4l_compat_translate_ioctl(inode, filp, cmd, arg,
1706                                                    ivtv_v4l2_do_ioctl);
1707         }
1708         return 0;
1709 }
1710
1711 static int ivtv_serialized_ioctl(struct ivtv *itv, struct inode *inode, struct file *filp,
1712                 unsigned int cmd, unsigned long arg)
1713 {
1714         /* Filter dvb ioctls that cannot be handled by video_usercopy */
1715         switch (cmd) {
1716         case VIDEO_SELECT_SOURCE:
1717                 IVTV_DEBUG_IOCTL("VIDEO_SELECT_SOURCE\n");
1718                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1719                         return -EINVAL;
1720                 return ivtv_passthrough_mode(itv, arg == VIDEO_SOURCE_DEMUX);
1721
1722         case AUDIO_SET_MUTE:
1723                 IVTV_DEBUG_IOCTL("AUDIO_SET_MUTE\n");
1724                 itv->speed_mute_audio = arg;
1725                 return 0;
1726
1727         case AUDIO_CHANNEL_SELECT:
1728                 IVTV_DEBUG_IOCTL("AUDIO_CHANNEL_SELECT\n");
1729                 if (arg > AUDIO_STEREO_SWAPPED)
1730                         return -EINVAL;
1731                 itv->audio_stereo_mode = arg;
1732                 ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode);
1733                 return 0;
1734
1735         case AUDIO_BILINGUAL_CHANNEL_SELECT:
1736                 IVTV_DEBUG_IOCTL("AUDIO_BILINGUAL_CHANNEL_SELECT\n");
1737                 if (arg > AUDIO_STEREO_SWAPPED)
1738                         return -EINVAL;
1739                 itv->audio_bilingual_mode = arg;
1740                 ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode);
1741                 return 0;
1742
1743         default:
1744                 break;
1745         }
1746         return video_usercopy(inode, filp, cmd, arg, ivtv_v4l2_do_ioctl);
1747 }
1748
1749 int ivtv_v4l2_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
1750                     unsigned long arg)
1751 {
1752         struct ivtv_open_id *id = (struct ivtv_open_id *)filp->private_data;
1753         struct ivtv *itv = id->itv;
1754         int res;
1755
1756         mutex_lock(&itv->serialize_lock);
1757         res = ivtv_serialized_ioctl(itv, inode, filp, cmd, arg);
1758         mutex_unlock(&itv->serialize_lock);
1759         return res;
1760 }