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         struct yuv_playback_info *yi = &itv->yuv_info;
 716         u32 data[CX2341X_MBOX_MAX_DATA];
 717         int streamtype = 0;
 718
 719         if (filp) {
 720                 id = (struct ivtv_open_id *)filp->private_data;
 721                 streamtype = id->type;
 722         }
 723
 724         switch (cmd) {
 725         case VIDIOC_G_PRIORITY:
 726         {
 727                 enum v4l2_priority *p = arg;
 728
 729                 *p = v4l2_prio_max(&itv->prio);
 730                 break;
 731         }
 732
 733         case VIDIOC_S_PRIORITY:
 734         {
 735                 enum v4l2_priority *prio = arg;
 736
 737                 return v4l2_prio_change(&itv->prio, &id->prio, *prio);
 738         }
 739
 740         case VIDIOC_QUERYCAP:{
 741                 struct v4l2_capability *vcap = arg;
 742
 743                 memset(vcap, 0, sizeof(*vcap));
 744                 strcpy(vcap->driver, IVTV_DRIVER_NAME);     /* driver name */
 745                 strncpy(vcap->card, itv->card_name,
 746                                 sizeof(vcap->card)-1);      /* card type */
 747                 strcpy(vcap->bus_info, pci_name(itv->dev)); /* bus info... */
 748                 vcap->version = IVTV_DRIVER_VERSION;        /* version */
 749                 vcap->capabilities = itv->v4l2_cap;         /* capabilities */
 750
 751                 /* reserved.. must set to 0! */
 752                 vcap->reserved[0] = vcap->reserved[1] =
 753                         vcap->reserved[2] = vcap->reserved[3] = 0;
 754                 break;
 755         }
 756
 757         case VIDIOC_ENUMAUDIO:{
 758                 struct v4l2_audio *vin = arg;
 759
 760                 return ivtv_get_audio_input(itv, vin->index, vin);
 761         }
 762
 763         case VIDIOC_G_AUDIO:{
 764                 struct v4l2_audio *vin = arg;
 765
 766                 vin->index = itv->audio_input;
 767                 return ivtv_get_audio_input(itv, vin->index, vin);
 768         }
 769
 770         case VIDIOC_S_AUDIO:{
 771                 struct v4l2_audio *vout = arg;
 772
 773                 if (vout->index >= itv->nof_audio_inputs)
 774                         return -EINVAL;
 775                 itv->audio_input = vout->index;
 776                 ivtv_audio_set_io(itv);
 777                 break;
 778         }
 779
 780         case VIDIOC_ENUMAUDOUT:{
 781                 struct v4l2_audioout *vin = arg;
 782
 783                 /* set it to defaults from our table */
 784                 return ivtv_get_audio_output(itv, vin->index, vin);
 785         }
 786
 787         case VIDIOC_G_AUDOUT:{
 788                 struct v4l2_audioout *vin = arg;
 789
 790                 vin->index = 0;
 791                 return ivtv_get_audio_output(itv, vin->index, vin);
 792         }
 793
 794         case VIDIOC_S_AUDOUT:{
 795                 struct v4l2_audioout *vout = arg;
 796
 797                 return ivtv_get_audio_output(itv, vout->index, vout);
 798         }
 799
 800         case VIDIOC_ENUMINPUT:{
 801                 struct v4l2_input *vin = arg;
 802
 803                 /* set it to defaults from our table */
 804                 return ivtv_get_input(itv, vin->index, vin);
 805         }
 806
 807         case VIDIOC_ENUMOUTPUT:{
 808                 struct v4l2_output *vout = arg;
 809
 810                 return ivtv_get_output(itv, vout->index, vout);
 811         }
 812
 813         case VIDIOC_TRY_FMT:
 814         case VIDIOC_S_FMT: {
 815                 struct v4l2_format *fmt = arg;
 816
 817                 return ivtv_try_or_set_fmt(itv, id->type, fmt, cmd == VIDIOC_S_FMT);
 818         }
 819
 820         case VIDIOC_G_FMT: {
 821                 struct v4l2_format *fmt = arg;
 822                 int type = fmt->type;
 823
 824                 memset(fmt, 0, sizeof(*fmt));
 825                 fmt->type = type;
 826                 return ivtv_get_fmt(itv, id->type, fmt);
 827         }
 828
 829         case VIDIOC_CROPCAP: {
 830                 struct v4l2_cropcap *cropcap = arg;
 831
 832                 if (cropcap->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
 833                         return -EINVAL;
 834                 cropcap->bounds.top = cropcap->bounds.left = 0;
 835                 cropcap->bounds.width = 720;
 836                 if (cropcap->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
 837                         cropcap->bounds.height = itv->is_50hz ? 576 : 480;
 838                         cropcap->pixelaspect.numerator = itv->is_50hz ? 59 : 10;
 839                         cropcap->pixelaspect.denominator = itv->is_50hz ? 54 : 11;
 840                 } else if (streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
 841                         if (yi->track_osd) {
 842                                 cropcap->bounds.width = yi->osd_full_w;
 843                                 cropcap->bounds.height = yi->osd_full_h;
 844                         } else {
 845                                 cropcap->bounds.width = 720;
 846                                 cropcap->bounds.height =
 847                                                 itv->is_out_50hz ? 576 : 480;
 848                         }
 849                         cropcap->pixelaspect.numerator = itv->is_out_50hz ? 59 : 10;
 850                         cropcap->pixelaspect.denominator = itv->is_out_50hz ? 54 : 11;
 851                 } else {
 852                         cropcap->bounds.height = itv->is_out_50hz ? 576 : 480;
 853                         cropcap->pixelaspect.numerator = itv->is_out_50hz ? 59 : 10;
 854                         cropcap->pixelaspect.denominator = itv->is_out_50hz ? 54 : 11;
 855                 }
 856                 cropcap->defrect = cropcap->bounds;
 857                 return 0;
 858         }
 859
 860         case VIDIOC_S_CROP: {
 861                 struct v4l2_crop *crop = arg;
 862
 863                 if (crop->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
 864                     (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) {
 865                         if (streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
 866                                 yi->main_rect = crop->c;
 867                                 return 0;
 868                         } else {
 869                                 if (!ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
 870                                         crop->c.width, crop->c.height, crop->c.left, crop->c.top)) {
 871                                         itv->main_rect = crop->c;
 872                                         return 0;
 873                                 }
 874                         }
 875                         return -EINVAL;
 876                 }
 877                 return -EINVAL;
 878         }
 879
 880         case VIDIOC_G_CROP: {
 881                 struct v4l2_crop *crop = arg;
 882
 883                 if (crop->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
 884                     (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) {
 885                         if (streamtype == IVTV_DEC_STREAM_TYPE_YUV)
 886                                 crop->c = yi->main_rect;
 887                         else
 888                                 crop->c = itv->main_rect;
 889                         return 0;
 890                 }
 891                 return -EINVAL;
 892         }
 893
 894         case VIDIOC_ENUM_FMT: {
 895                 static struct v4l2_fmtdesc formats[] = {
 896                         { 0, 0, 0,
 897                           "HM12 (YUV 4:2:0)", V4L2_PIX_FMT_HM12,
 898                           { 0, 0, 0, 0 }
 899                         },
 900                         { 1, 0, V4L2_FMT_FLAG_COMPRESSED,
 901                           "MPEG", V4L2_PIX_FMT_MPEG,
 902                           { 0, 0, 0, 0 }
 903                         }
 904                 };
 905                 struct v4l2_fmtdesc *fmt = arg;
 906                 enum v4l2_buf_type type = fmt->type;
 907
 908                 switch (type) {
 909                 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
 910                         break;
 911                 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
 912                         if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
 913                                 return -EINVAL;
 914                         break;
 915                 default:
 916                         return -EINVAL;
 917                 }
 918                 if (fmt->index > 1)
 919                         return -EINVAL;
 920                 *fmt = formats[fmt->index];
 921                 fmt->type = type;
 922                 return 0;
 923         }
 924
 925         case VIDIOC_G_INPUT:{
 926                 *(int *)arg = itv->active_input;
 927                 break;
 928         }
 929
 930         case VIDIOC_S_INPUT:{
 931                 int inp = *(int *)arg;
 932
 933                 if (inp < 0 || inp >= itv->nof_inputs)
 934                         return -EINVAL;
 935
 936                 if (inp == itv->active_input) {
 937                         IVTV_DEBUG_INFO("Input unchanged\n");
 938                         break;
 939                 }
 940                 if (atomic_read(&itv->capturing) > 0) {
 941                         return -EBUSY;
 942                 }
 943                 IVTV_DEBUG_INFO("Changing input from %d to %d\n",
 944                                 itv->active_input, inp);
 945
 946                 itv->active_input = inp;
 947                 /* Set the audio input to whatever is appropriate for the
 948                    input type. */
 949                 itv->audio_input = itv->card->video_inputs[inp].audio_index;
 950
 951                 /* prevent others from messing with the streams until
 952                    we're finished changing inputs. */
 953                 ivtv_mute(itv);
 954                 ivtv_video_set_io(itv);
 955                 ivtv_audio_set_io(itv);
 956                 ivtv_unmute(itv);
 957                 break;
 958         }
 959
 960         case VIDIOC_G_OUTPUT:{
 961                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
 962                         return -EINVAL;
 963                 *(int *)arg = itv->active_output;
 964                 break;
 965         }
 966
 967         case VIDIOC_S_OUTPUT:{
 968                 int outp = *(int *)arg;
 969                 struct v4l2_routing route;
 970
 971                 if (outp >= itv->card->nof_outputs)
 972                         return -EINVAL;
 973
 974                 if (outp == itv->active_output) {
 975                         IVTV_DEBUG_INFO("Output unchanged\n");
 976                         break;
 977                 }
 978                 IVTV_DEBUG_INFO("Changing output from %d to %d\n",
 979                            itv->active_output, outp);
 980
 981                 itv->active_output = outp;
 982                 route.input = SAA7127_INPUT_TYPE_NORMAL;
 983                 route.output = itv->card->video_outputs[outp].video_output;
 984                 ivtv_saa7127(itv, VIDIOC_INT_S_VIDEO_ROUTING, &route);
 985                 break;
 986         }
 987
 988         case VIDIOC_G_FREQUENCY:{
 989                 struct v4l2_frequency *vf = arg;
 990
 991                 if (vf->tuner != 0)
 992                         return -EINVAL;
 993                 ivtv_call_i2c_clients(itv, cmd, arg);
 994                 break;
 995         }
 996
 997         case VIDIOC_S_FREQUENCY:{
 998                 struct v4l2_frequency vf = *(struct v4l2_frequency *)arg;
 999
1000                 if (vf.tuner != 0)
1001                         return -EINVAL;
1002
1003                 ivtv_mute(itv);
1004                 IVTV_DEBUG_INFO("v4l2 ioctl: set frequency %d\n", vf.frequency);
1005                 ivtv_call_i2c_clients(itv, cmd, &vf);
1006                 ivtv_unmute(itv);
1007                 break;
1008         }
1009
1010         case VIDIOC_ENUMSTD:{
1011                 struct v4l2_standard *vs = arg;
1012                 int idx = vs->index;
1013
1014                 if (idx < 0 || idx >= ARRAY_SIZE(enum_stds))
1015                         return -EINVAL;
1016
1017                 *vs = (enum_stds[idx].std & V4L2_STD_525_60) ?
1018                                 ivtv_std_60hz : ivtv_std_50hz;
1019                 vs->index = idx;
1020                 vs->id = enum_stds[idx].std;
1021                 strcpy(vs->name, enum_stds[idx].name);
1022                 break;
1023         }
1024
1025         case VIDIOC_G_STD:{
1026                 *(v4l2_std_id *) arg = itv->std;
1027                 break;
1028         }
1029
1030         case VIDIOC_S_STD: {
1031                 v4l2_std_id std = *(v4l2_std_id *) arg;
1032
1033                 if ((std & V4L2_STD_ALL) == 0)
1034                         return -EINVAL;
1035
1036                 if (std == itv->std)
1037                         break;
1038
1039                 if (test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ||
1040                     atomic_read(&itv->capturing) > 0 ||
1041                     atomic_read(&itv->decoding) > 0) {
1042                         /* Switching standard would turn off the radio or mess
1043                            with already running streams, prevent that by
1044                            returning EBUSY. */
1045                         return -EBUSY;
1046                 }
1047
1048                 itv->std = std;
1049                 itv->is_60hz = (std & V4L2_STD_525_60) ? 1 : 0;
1050                 itv->params.is_50hz = itv->is_50hz = !itv->is_60hz;
1051                 itv->params.width = 720;
1052                 itv->params.height = itv->is_50hz ? 576 : 480;
1053                 itv->vbi.count = itv->is_50hz ? 18 : 12;
1054                 itv->vbi.start[0] = itv->is_50hz ? 6 : 10;
1055                 itv->vbi.start[1] = itv->is_50hz ? 318 : 273;
1056                 if (itv->hw_flags & IVTV_HW_CX25840) {
1057                         itv->vbi.sliced_decoder_line_size = itv->is_60hz ? 272 : 284;
1058                 }
1059                 IVTV_DEBUG_INFO("Switching standard to %llx.\n", (unsigned long long)itv->std);
1060
1061                 /* Tuner */
1062                 ivtv_call_i2c_clients(itv, VIDIOC_S_STD, &itv->std);
1063
1064                 if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT) {
1065                         /* set display standard */
1066                         itv->std_out = std;
1067                         itv->is_out_60hz = itv->is_60hz;
1068                         itv->is_out_50hz = itv->is_50hz;
1069                         ivtv_call_i2c_clients(itv, VIDIOC_INT_S_STD_OUTPUT, &itv->std_out);
1070                         ivtv_vapi(itv, CX2341X_DEC_SET_STANDARD, 1, itv->is_out_50hz);
1071                         itv->main_rect.left = itv->main_rect.top = 0;
1072                         itv->main_rect.width = 720;
1073                         itv->main_rect.height = itv->params.height;
1074                         ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
1075                                 720, itv->main_rect.height, 0, 0);
1076                         yi->main_rect = itv->main_rect;
1077                         if (!itv->osd_info) {
1078                                 yi->osd_full_w = 720;
1079                                 yi->osd_full_h = itv->is_out_50hz ? 576 : 480;
1080                         }
1081                 }
1082                 break;
1083         }
1084
1085         case VIDIOC_S_TUNER: {  /* Setting tuner can only set audio mode */
1086                 struct v4l2_tuner *vt = arg;
1087
1088                 if (vt->index != 0)
1089                         return -EINVAL;
1090
1091                 ivtv_call_i2c_clients(itv, VIDIOC_S_TUNER, vt);
1092                 break;
1093         }
1094
1095         case VIDIOC_G_TUNER: {
1096                 struct v4l2_tuner *vt = arg;
1097
1098                 if (vt->index != 0)
1099                         return -EINVAL;
1100
1101                 memset(vt, 0, sizeof(*vt));
1102                 ivtv_call_i2c_clients(itv, VIDIOC_G_TUNER, vt);
1103
1104                 if (test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags)) {
1105                         strcpy(vt->name, "ivtv Radio Tuner");
1106                         vt->type = V4L2_TUNER_RADIO;
1107                 } else {
1108                         strcpy(vt->name, "ivtv TV Tuner");
1109                         vt->type = V4L2_TUNER_ANALOG_TV;
1110                 }
1111                 break;
1112         }
1113
1114         case VIDIOC_G_SLICED_VBI_CAP: {
1115                 struct v4l2_sliced_vbi_cap *cap = arg;
1116                 int set = itv->is_50hz ? V4L2_SLICED_VBI_625 : V4L2_SLICED_VBI_525;
1117                 int f, l;
1118                 enum v4l2_buf_type type = cap->type;
1119
1120                 memset(cap, 0, sizeof(*cap));
1121                 cap->type = type;
1122                 if (type == V4L2_BUF_TYPE_SLICED_VBI_CAPTURE) {
1123                         for (f = 0; f < 2; f++) {
1124                                 for (l = 0; l < 24; l++) {
1125                                         if (valid_service_line(f, l, itv->is_50hz)) {
1126                                                 cap->service_lines[f][l] = set;
1127                                         }
1128                                 }
1129                         }
1130                         return 0;
1131                 }
1132                 if (type == V4L2_BUF_TYPE_SLICED_VBI_OUTPUT) {
1133                         if (!(itv->v4l2_cap & V4L2_CAP_SLICED_VBI_OUTPUT))
1134                                 return -EINVAL;
1135                         if (itv->is_60hz) {
1136                                 cap->service_lines[0][21] = V4L2_SLICED_CAPTION_525;
1137                                 cap->service_lines[1][21] = V4L2_SLICED_CAPTION_525;
1138                         } else {
1139                                 cap->service_lines[0][23] = V4L2_SLICED_WSS_625;
1140                                 cap->service_lines[0][16] = V4L2_SLICED_VPS;
1141                         }
1142                         return 0;
1143                 }
1144                 return -EINVAL;
1145         }
1146
1147         case VIDIOC_G_ENC_INDEX: {
1148                 struct v4l2_enc_idx *idx = arg;
1149                 struct v4l2_enc_idx_entry *e = idx->entry;
1150                 int entries;
1151                 int i;
1152
1153                 entries = (itv->pgm_info_write_idx + IVTV_MAX_PGM_INDEX - itv->pgm_info_read_idx) %
1154                                         IVTV_MAX_PGM_INDEX;
1155                 if (entries > V4L2_ENC_IDX_ENTRIES)
1156                         entries = V4L2_ENC_IDX_ENTRIES;
1157                 idx->entries = 0;
1158                 for (i = 0; i < entries; i++) {
1159                         *e = itv->pgm_info[(itv->pgm_info_read_idx + i) % IVTV_MAX_PGM_INDEX];
1160                         if ((e->flags & V4L2_ENC_IDX_FRAME_MASK) <= V4L2_ENC_IDX_FRAME_B) {
1161                                 idx->entries++;
1162                                 e++;
1163                         }
1164                 }
1165                 itv->pgm_info_read_idx = (itv->pgm_info_read_idx + idx->entries) % IVTV_MAX_PGM_INDEX;
1166                 break;
1167         }
1168
1169         case VIDIOC_ENCODER_CMD:
1170         case VIDIOC_TRY_ENCODER_CMD: {
1171                 struct v4l2_encoder_cmd *enc = arg;
1172                 int try = cmd == VIDIOC_TRY_ENCODER_CMD;
1173
1174                 memset(&enc->raw, 0, sizeof(enc->raw));
1175                 switch (enc->cmd) {
1176                 case V4L2_ENC_CMD_START:
1177                         IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
1178                         enc->flags = 0;
1179                         if (try)
1180                                 return 0;
1181                         return ivtv_start_capture(id);
1182
1183                 case V4L2_ENC_CMD_STOP:
1184                         IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
1185                         enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END;
1186                         if (try)
1187                                 return 0;
1188                         ivtv_stop_capture(id, enc->flags & V4L2_ENC_CMD_STOP_AT_GOP_END);
1189                         return 0;
1190
1191                 case V4L2_ENC_CMD_PAUSE:
1192                         IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
1193                         enc->flags = 0;
1194                         if (try)
1195                                 return 0;
1196                         if (!atomic_read(&itv->capturing))
1197                                 return -EPERM;
1198                         if (test_and_set_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags))
1199                                 return 0;
1200                         ivtv_mute(itv);
1201                         ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 0);
1202                         break;
1203
1204                 case V4L2_ENC_CMD_RESUME:
1205                         IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
1206                         enc->flags = 0;
1207                         if (try)
1208                                 return 0;
1209                         if (!atomic_read(&itv->capturing))
1210                                 return -EPERM;
1211                         if (!test_and_clear_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags))
1212                                 return 0;
1213                         ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 1);
1214                         ivtv_unmute(itv);
1215                         break;
1216                 default:
1217                         IVTV_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd);
1218                         return -EINVAL;
1219                 }
1220                 break;
1221         }
1222
1223         case VIDIOC_G_FBUF: {
1224                 struct v4l2_framebuffer *fb = arg;
1225                 int pixfmt;
1226                 static u32 pixel_format[16] = {
1227                         V4L2_PIX_FMT_PAL8, /* Uses a 256-entry RGB colormap */
1228                         V4L2_PIX_FMT_RGB565,
1229                         V4L2_PIX_FMT_RGB555,
1230                         V4L2_PIX_FMT_RGB444,
1231                         V4L2_PIX_FMT_RGB32,
1232                         0,
1233                         0,
1234                         0,
1235                         V4L2_PIX_FMT_PAL8, /* Uses a 256-entry YUV colormap */
1236                         V4L2_PIX_FMT_YUV565,
1237                         V4L2_PIX_FMT_YUV555,
1238                         V4L2_PIX_FMT_YUV444,
1239                         V4L2_PIX_FMT_YUV32,
1240                         0,
1241                         0,
1242                         0,
1243                 };
1244
1245                 memset(fb, 0, sizeof(*fb));
1246                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1247                         return -EINVAL;
1248                 fb->capability = V4L2_FBUF_CAP_EXTERNOVERLAY | V4L2_FBUF_CAP_CHROMAKEY |
1249                         V4L2_FBUF_CAP_GLOBAL_ALPHA;
1250                 ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0);
1251                 data[0] |= (read_reg(0x2a00) >> 7) & 0x40;
1252                 pixfmt = (data[0] >> 3) & 0xf;
1253                 fb->fmt.pixelformat = pixel_format[pixfmt];
1254                 fb->fmt.width = itv->osd_rect.width;
1255                 fb->fmt.height = itv->osd_rect.height;
1256                 fb->base = (void *)itv->osd_video_pbase;
1257                 if (itv->osd_chroma_key_state)
1258                         fb->flags |= V4L2_FBUF_FLAG_CHROMAKEY;
1259                 if (itv->osd_global_alpha_state)
1260                         fb->flags |= V4L2_FBUF_FLAG_GLOBAL_ALPHA;
1261                 pixfmt &= 7;
1262                 /* no local alpha for RGB565 or unknown formats */
1263                 if (pixfmt == 1 || pixfmt > 4)
1264                         break;
1265                 /* 16-bit formats have inverted local alpha */
1266                 if (pixfmt == 2 || pixfmt == 3)
1267                         fb->capability |= V4L2_FBUF_CAP_LOCAL_INV_ALPHA;
1268                 else
1269                         fb->capability |= V4L2_FBUF_CAP_LOCAL_ALPHA;
1270                 if (itv->osd_local_alpha_state) {
1271                         /* 16-bit formats have inverted local alpha */
1272                         if (pixfmt == 2 || pixfmt == 3)
1273                                 fb->flags |= V4L2_FBUF_FLAG_LOCAL_INV_ALPHA;
1274                         else
1275                                 fb->flags |= V4L2_FBUF_FLAG_LOCAL_ALPHA;
1276                 }
1277                 if (yi->track_osd)
1278                         fb->flags |= V4L2_FBUF_FLAG_OVERLAY;
1279                 break;
1280         }
1281
1282         case VIDIOC_S_FBUF: {
1283                 struct v4l2_framebuffer *fb = arg;
1284
1285                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1286                         return -EINVAL;
1287                 itv->osd_global_alpha_state = (fb->flags & V4L2_FBUF_FLAG_GLOBAL_ALPHA) != 0;
1288                 itv->osd_local_alpha_state =
1289                         (fb->flags & (V4L2_FBUF_FLAG_LOCAL_ALPHA|V4L2_FBUF_FLAG_LOCAL_INV_ALPHA)) != 0;
1290                 itv->osd_chroma_key_state = (fb->flags & V4L2_FBUF_FLAG_CHROMAKEY) != 0;
1291                 ivtv_set_osd_alpha(itv);
1292                 yi->track_osd = (fb->flags & V4L2_FBUF_FLAG_OVERLAY) != 0;
1293                 break;
1294         }
1295
1296         case VIDIOC_OVERLAY: {
1297                 int *on = arg;
1298
1299                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1300                         return -EINVAL;
1301                 ivtv_vapi(itv, CX2341X_OSD_SET_STATE, 1, *on != 0);
1302                 break;
1303         }
1304
1305         case VIDIOC_LOG_STATUS:
1306         {
1307                 int has_output = itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT;
1308                 struct v4l2_input vidin;
1309                 struct v4l2_audio audin;
1310                 int i;
1311
1312                 IVTV_INFO("=================  START STATUS CARD #%d  =================\n", itv->num);
1313                 IVTV_INFO("Version: %s Card: %s\n", IVTV_VERSION, itv->card_name);
1314                 if (itv->hw_flags & IVTV_HW_TVEEPROM) {
1315                         struct tveeprom tv;
1316
1317                         ivtv_read_eeprom(itv, &tv);
1318                 }
1319                 ivtv_call_i2c_clients(itv, VIDIOC_LOG_STATUS, NULL);
1320                 ivtv_get_input(itv, itv->active_input, &vidin);
1321                 ivtv_get_audio_input(itv, itv->audio_input, &audin);
1322                 IVTV_INFO("Video Input:  %s\n", vidin.name);
1323                 IVTV_INFO("Audio Input:  %s%s\n", audin.name,
1324                         (itv->dualwatch_stereo_mode & ~0x300) == 0x200 ? " (Bilingual)" : "");
1325                 if (has_output) {
1326                         struct v4l2_output vidout;
1327                         struct v4l2_audioout audout;
1328                         int mode = itv->output_mode;
1329                         static const char * const output_modes[5] = {
1330                                 "None",
1331                                 "MPEG Streaming",
1332                                 "YUV Streaming",
1333                                 "YUV Frames",
1334                                 "Passthrough",
1335                         };
1336                         static const char * const audio_modes[5] = {
1337                                 "Stereo",
1338                                 "Left",
1339                                 "Right",
1340                                 "Mono",
1341                                 "Swapped"
1342                         };
1343                         static const char * const alpha_mode[4] = {
1344                                 "None",
1345                                 "Global",
1346                                 "Local",
1347                                 "Global and Local"
1348                         };
1349                         static const char * const pixel_format[16] = {
1350                                 "ARGB Indexed",
1351                                 "RGB 5:6:5",
1352                                 "ARGB 1:5:5:5",
1353                                 "ARGB 1:4:4:4",
1354                                 "ARGB 8:8:8:8",
1355                                 "5",
1356                                 "6",
1357                                 "7",
1358                                 "AYUV Indexed",
1359                                 "YUV 5:6:5",
1360                                 "AYUV 1:5:5:5",
1361                                 "AYUV 1:4:4:4",
1362                                 "AYUV 8:8:8:8",
1363                                 "13",
1364                                 "14",
1365                                 "15",
1366                         };
1367
1368                         ivtv_get_output(itv, itv->active_output, &vidout);
1369                         ivtv_get_audio_output(itv, 0, &audout);
1370                         IVTV_INFO("Video Output: %s\n", vidout.name);
1371                         IVTV_INFO("Audio Output: %s (Stereo/Bilingual: %s/%s)\n", audout.name,
1372                                 audio_modes[itv->audio_stereo_mode],
1373                                 audio_modes[itv->audio_bilingual_mode]);
1374                         if (mode < 0 || mode > OUT_PASSTHROUGH)
1375                                 mode = OUT_NONE;
1376                         IVTV_INFO("Output Mode:  %s\n", output_modes[mode]);
1377                         ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0);
1378                         data[0] |= (read_reg(0x2a00) >> 7) & 0x40;
1379                         IVTV_INFO("Overlay:      %s, Alpha: %s, Pixel Format: %s\n",
1380                                 data[0] & 1 ? "On" : "Off",
1381                                 alpha_mode[(data[0] >> 1) & 0x3],
1382                                 pixel_format[(data[0] >> 3) & 0xf]);
1383                 }
1384                 IVTV_INFO("Tuner:  %s\n",
1385                         test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ? "Radio" : "TV");
1386                 cx2341x_log_status(&itv->params, itv->name);
1387                 IVTV_INFO("Status flags:    0x%08lx\n", itv->i_flags);
1388                 for (i = 0; i < IVTV_MAX_STREAMS; i++) {
1389                         struct ivtv_stream *s = &itv->streams[i];
1390
1391                         if (s->v4l2dev == NULL || s->buffers == 0)
1392                                 continue;
1393                         IVTV_INFO("Stream %s: status 0x%04lx, %d%% of %d KiB (%d buffers) in use\n", s->name, s->s_flags,
1394                                         (s->buffers - s->q_free.buffers) * 100 / s->buffers,
1395                                         (s->buffers * s->buf_size) / 1024, s->buffers);
1396                 }
1397                 IVTV_INFO("Read MPG/VBI: %lld/%lld bytes\n", (long long)itv->mpg_data_received, (long long)itv->vbi_data_inserted);
1398                 IVTV_INFO("==================  END STATUS CARD #%d  ==================\n", itv->num);
1399                 break;
1400         }
1401
1402         default:
1403                 return -EINVAL;
1404         }
1405         return 0;
1406 }
1407
1408 static int ivtv_decoder_ioctls(struct file *filp, unsigned int cmd, void *arg)
1409 {
1410         struct ivtv_open_id *id = (struct ivtv_open_id *)filp->private_data;
1411         struct ivtv *itv = id->itv;
1412         int nonblocking = filp->f_flags & O_NONBLOCK;
1413         struct ivtv_stream *s = &itv->streams[id->type];
1414
1415         switch (cmd) {
1416         case IVTV_IOC_DMA_FRAME: {
1417                 struct ivtv_dma_frame *args = arg;
1418
1419                 IVTV_DEBUG_IOCTL("IVTV_IOC_DMA_FRAME\n");
1420                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1421                         return -EINVAL;
1422                 if (args->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
1423                         return -EINVAL;
1424                 if (itv->output_mode == OUT_UDMA_YUV && args->y_source == NULL)
1425                         return 0;
1426                 if (ivtv_claim_stream(id, id->type)) {
1427                         return -EBUSY;
1428                 }
1429                 if (ivtv_set_output_mode(itv, OUT_UDMA_YUV) != OUT_UDMA_YUV) {
1430                         ivtv_release_stream(s);
1431                         return -EBUSY;
1432                 }
1433                 /* Mark that this file handle started the UDMA_YUV mode */
1434                 id->yuv_frames = 1;
1435                 if (args->y_source == NULL)
1436                         return 0;
1437                 return ivtv_yuv_prep_frame(itv, args);
1438         }
1439
1440         case VIDEO_GET_PTS: {
1441                 u32 data[CX2341X_MBOX_MAX_DATA];
1442                 u64 *pts = arg;
1443
1444                 IVTV_DEBUG_IOCTL("VIDEO_GET_PTS\n");
1445                 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) {
1446                         *pts = s->dma_pts;
1447                         break;
1448                 }
1449                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1450                         return -EINVAL;
1451
1452                 if (test_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags)) {
1453                         *pts = (u64) ((u64)itv->last_dec_timing[2] << 32) |
1454                                         (u64)itv->last_dec_timing[1];
1455                         break;
1456                 }
1457                 *pts = 0;
1458                 if (atomic_read(&itv->decoding)) {
1459                         if (ivtv_api(itv, CX2341X_DEC_GET_TIMING_INFO, 5, data)) {
1460                                 IVTV_DEBUG_WARN("GET_TIMING: couldn't read clock\n");
1461                                 return -EIO;
1462                         }
1463                         memcpy(itv->last_dec_timing, data, sizeof(itv->last_dec_timing));
1464                         set_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags);
1465                         *pts = (u64) ((u64) data[2] << 32) | (u64) data[1];
1466                         /*timing->scr = (u64) (((u64) data[4] << 32) | (u64) (data[3]));*/
1467                 }
1468                 break;
1469         }
1470
1471         case VIDEO_GET_FRAME_COUNT: {
1472                 u32 data[CX2341X_MBOX_MAX_DATA];
1473                 u64 *frame = arg;
1474
1475                 IVTV_DEBUG_IOCTL("VIDEO_GET_FRAME_COUNT\n");
1476                 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) {
1477                         *frame = 0;
1478                         break;
1479                 }
1480                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1481                         return -EINVAL;
1482
1483                 if (test_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags)) {
1484                         *frame = itv->last_dec_timing[0];
1485                         break;
1486                 }
1487                 *frame = 0;
1488                 if (atomic_read(&itv->decoding)) {
1489                         if (ivtv_api(itv, CX2341X_DEC_GET_TIMING_INFO, 5, data)) {
1490                                 IVTV_DEBUG_WARN("GET_TIMING: couldn't read clock\n");
1491                                 return -EIO;
1492                         }
1493                         memcpy(itv->last_dec_timing, data, sizeof(itv->last_dec_timing));
1494                         set_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags);
1495                         *frame = data[0];
1496                 }
1497                 break;
1498         }
1499
1500         case VIDEO_PLAY: {
1501                 struct video_command vc;
1502
1503                 IVTV_DEBUG_IOCTL("VIDEO_PLAY\n");
1504                 memset(&vc, 0, sizeof(vc));
1505                 vc.cmd = VIDEO_CMD_PLAY;
1506                 return ivtv_video_command(itv, id, &vc, 0);
1507         }
1508
1509         case VIDEO_STOP: {
1510                 struct video_command vc;
1511
1512                 IVTV_DEBUG_IOCTL("VIDEO_STOP\n");
1513                 memset(&vc, 0, sizeof(vc));
1514                 vc.cmd = VIDEO_CMD_STOP;
1515                 vc.flags = VIDEO_CMD_STOP_TO_BLACK | VIDEO_CMD_STOP_IMMEDIATELY;
1516                 return ivtv_video_command(itv, id, &vc, 0);
1517         }
1518
1519         case VIDEO_FREEZE: {
1520                 struct video_command vc;
1521
1522                 IVTV_DEBUG_IOCTL("VIDEO_FREEZE\n");
1523                 memset(&vc, 0, sizeof(vc));
1524                 vc.cmd = VIDEO_CMD_FREEZE;
1525                 return ivtv_video_command(itv, id, &vc, 0);
1526         }
1527
1528         case VIDEO_CONTINUE: {
1529                 struct video_command vc;
1530
1531                 IVTV_DEBUG_IOCTL("VIDEO_CONTINUE\n");
1532                 memset(&vc, 0, sizeof(vc));
1533                 vc.cmd = VIDEO_CMD_CONTINUE;
1534                 return ivtv_video_command(itv, id, &vc, 0);
1535         }
1536
1537         case VIDEO_COMMAND:
1538         case VIDEO_TRY_COMMAND: {
1539                 struct video_command *vc = arg;
1540                 int try = (cmd == VIDEO_TRY_COMMAND);
1541
1542                 if (try)
1543                         IVTV_DEBUG_IOCTL("VIDEO_TRY_COMMAND %d\n", vc->cmd);
1544                 else
1545                         IVTV_DEBUG_IOCTL("VIDEO_COMMAND %d\n", vc->cmd);
1546                 return ivtv_video_command(itv, id, vc, try);
1547         }
1548
1549         case VIDEO_GET_EVENT: {
1550                 struct video_event *ev = arg;
1551                 DEFINE_WAIT(wait);
1552
1553                 IVTV_DEBUG_IOCTL("VIDEO_GET_EVENT\n");
1554                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1555                         return -EINVAL;
1556                 memset(ev, 0, sizeof(*ev));
1557                 set_bit(IVTV_F_I_EV_VSYNC_ENABLED, &itv->i_flags);
1558
1559                 while (1) {
1560                         if (test_and_clear_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags))
1561                                 ev->type = VIDEO_EVENT_DECODER_STOPPED;
1562                         else if (test_and_clear_bit(IVTV_F_I_EV_VSYNC, &itv->i_flags)) {
1563                                 ev->type = VIDEO_EVENT_VSYNC;
1564                                 ev->u.vsync_field = test_bit(IVTV_F_I_EV_VSYNC_FIELD, &itv->i_flags) ?
1565                                         VIDEO_VSYNC_FIELD_ODD : VIDEO_VSYNC_FIELD_EVEN;
1566                                 if (itv->output_mode == OUT_UDMA_YUV &&
1567                                         (itv->yuv_info.lace_mode & IVTV_YUV_MODE_MASK) ==
1568                                                                 IVTV_YUV_MODE_PROGRESSIVE) {
1569                                         ev->u.vsync_field = VIDEO_VSYNC_FIELD_PROGRESSIVE;
1570                                 }
1571                         }
1572                         if (ev->type)
1573                                 return 0;
1574                         if (nonblocking)
1575                                 return -EAGAIN;
1576                         /* Wait for event. Note that serialize_lock is locked,
1577                            so to allow other processes to access the driver while
1578                            we are waiting unlock first and later lock again. */
1579                         mutex_unlock(&itv->serialize_lock);
1580                         prepare_to_wait(&itv->event_waitq, &wait, TASK_INTERRUPTIBLE);
1581                         if ((itv->i_flags & (IVTV_F_I_EV_DEC_STOPPED|IVTV_F_I_EV_VSYNC)) == 0)
1582                                 schedule();
1583                         finish_wait(&itv->event_waitq, &wait);
1584                         mutex_lock(&itv->serialize_lock);
1585                         if (signal_pending(current)) {
1586                                 /* return if a signal was received */
1587                                 IVTV_DEBUG_INFO("User stopped wait for event\n");
1588                                 return -EINTR;
1589                         }
1590                 }
1591                 break;
1592         }
1593
1594         default:
1595                 return -EINVAL;
1596         }
1597         return 0;
1598 }
1599
1600 static int ivtv_v4l2_do_ioctl(struct inode *inode, struct file *filp,
1601                               unsigned int cmd, void *arg)
1602 {
1603         struct ivtv_open_id *id = (struct ivtv_open_id *)filp->private_data;
1604         struct ivtv *itv = id->itv;
1605         int ret;
1606
1607         /* check priority */
1608         switch (cmd) {
1609         case VIDIOC_S_CTRL:
1610         case VIDIOC_S_STD:
1611         case VIDIOC_S_INPUT:
1612         case VIDIOC_S_OUTPUT:
1613         case VIDIOC_S_TUNER:
1614         case VIDIOC_S_FREQUENCY:
1615         case VIDIOC_S_FMT:
1616         case VIDIOC_S_CROP:
1617         case VIDIOC_S_AUDIO:
1618         case VIDIOC_S_AUDOUT:
1619         case VIDIOC_S_EXT_CTRLS:
1620         case VIDIOC_S_FBUF:
1621         case VIDIOC_OVERLAY:
1622                 ret = v4l2_prio_check(&itv->prio, &id->prio);
1623                 if (ret)
1624                         return ret;
1625         }
1626
1627         switch (cmd) {
1628         case VIDIOC_DBG_G_REGISTER:
1629         case VIDIOC_DBG_S_REGISTER:
1630         case VIDIOC_G_CHIP_IDENT:
1631         case VIDIOC_INT_S_AUDIO_ROUTING:
1632         case VIDIOC_INT_RESET:
1633                 if (ivtv_debug & IVTV_DBGFLG_IOCTL) {
1634                         printk(KERN_INFO "ivtv%d ioctl: ", itv->num);
1635                         v4l_printk_ioctl(cmd);
1636                         printk("\n");
1637                 }
1638                 return ivtv_debug_ioctls(filp, cmd, arg);
1639
1640         case VIDIOC_G_PRIORITY:
1641         case VIDIOC_S_PRIORITY:
1642         case VIDIOC_QUERYCAP:
1643         case VIDIOC_ENUMINPUT:
1644         case VIDIOC_G_INPUT:
1645         case VIDIOC_S_INPUT:
1646         case VIDIOC_ENUMOUTPUT:
1647         case VIDIOC_G_OUTPUT:
1648         case VIDIOC_S_OUTPUT:
1649         case VIDIOC_G_FMT:
1650         case VIDIOC_S_FMT:
1651         case VIDIOC_TRY_FMT:
1652         case VIDIOC_ENUM_FMT:
1653         case VIDIOC_CROPCAP:
1654         case VIDIOC_G_CROP:
1655         case VIDIOC_S_CROP:
1656         case VIDIOC_G_FREQUENCY:
1657         case VIDIOC_S_FREQUENCY:
1658         case VIDIOC_ENUMSTD:
1659         case VIDIOC_G_STD:
1660         case VIDIOC_S_STD:
1661         case VIDIOC_S_TUNER:
1662         case VIDIOC_G_TUNER:
1663         case VIDIOC_ENUMAUDIO:
1664         case VIDIOC_S_AUDIO:
1665         case VIDIOC_G_AUDIO:
1666         case VIDIOC_ENUMAUDOUT:
1667         case VIDIOC_S_AUDOUT:
1668         case VIDIOC_G_AUDOUT:
1669         case VIDIOC_G_SLICED_VBI_CAP:
1670         case VIDIOC_LOG_STATUS:
1671         case VIDIOC_G_ENC_INDEX:
1672         case VIDIOC_ENCODER_CMD:
1673         case VIDIOC_TRY_ENCODER_CMD:
1674         case VIDIOC_G_FBUF:
1675         case VIDIOC_S_FBUF:
1676         case VIDIOC_OVERLAY:
1677                 if (ivtv_debug & IVTV_DBGFLG_IOCTL) {
1678                         printk(KERN_INFO "ivtv%d ioctl: ", itv->num);
1679                         v4l_printk_ioctl(cmd);
1680                         printk("\n");
1681                 }
1682                 return ivtv_v4l2_ioctls(itv, filp, cmd, arg);
1683
1684         case VIDIOC_QUERYMENU:
1685         case VIDIOC_QUERYCTRL:
1686         case VIDIOC_S_CTRL:
1687         case VIDIOC_G_CTRL:
1688         case VIDIOC_S_EXT_CTRLS:
1689         case VIDIOC_G_EXT_CTRLS:
1690         case VIDIOC_TRY_EXT_CTRLS:
1691                 if (ivtv_debug & IVTV_DBGFLG_IOCTL) {
1692                         printk(KERN_INFO "ivtv%d ioctl: ", itv->num);
1693                         v4l_printk_ioctl(cmd);
1694                         printk("\n");
1695                 }
1696                 return ivtv_control_ioctls(itv, cmd, arg);
1697
1698         case IVTV_IOC_DMA_FRAME:
1699         case VIDEO_GET_PTS:
1700         case VIDEO_GET_FRAME_COUNT:
1701         case VIDEO_GET_EVENT:
1702         case VIDEO_PLAY:
1703         case VIDEO_STOP:
1704         case VIDEO_FREEZE:
1705         case VIDEO_CONTINUE:
1706         case VIDEO_COMMAND:
1707         case VIDEO_TRY_COMMAND:
1708                 return ivtv_decoder_ioctls(filp, cmd, arg);
1709
1710         case 0x00005401:        /* Handle isatty() calls */
1711                 return -EINVAL;
1712         default:
1713                 return v4l_compat_translate_ioctl(inode, filp, cmd, arg,
1714                                                    ivtv_v4l2_do_ioctl);
1715         }
1716         return 0;
1717 }
1718
1719 static int ivtv_serialized_ioctl(struct ivtv *itv, struct inode *inode, struct file *filp,
1720                 unsigned int cmd, unsigned long arg)
1721 {
1722         /* Filter dvb ioctls that cannot be handled by video_usercopy */
1723         switch (cmd) {
1724         case VIDEO_SELECT_SOURCE:
1725                 IVTV_DEBUG_IOCTL("VIDEO_SELECT_SOURCE\n");
1726                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1727                         return -EINVAL;
1728                 return ivtv_passthrough_mode(itv, arg == VIDEO_SOURCE_DEMUX);
1729
1730         case AUDIO_SET_MUTE:
1731                 IVTV_DEBUG_IOCTL("AUDIO_SET_MUTE\n");
1732                 itv->speed_mute_audio = arg;
1733                 return 0;
1734
1735         case AUDIO_CHANNEL_SELECT:
1736                 IVTV_DEBUG_IOCTL("AUDIO_CHANNEL_SELECT\n");
1737                 if (arg > AUDIO_STEREO_SWAPPED)
1738                         return -EINVAL;
1739                 itv->audio_stereo_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         case AUDIO_BILINGUAL_CHANNEL_SELECT:
1744                 IVTV_DEBUG_IOCTL("AUDIO_BILINGUAL_CHANNEL_SELECT\n");
1745                 if (arg > AUDIO_STEREO_SWAPPED)
1746                         return -EINVAL;
1747                 itv->audio_bilingual_mode = arg;
1748                 ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode);
1749                 return 0;
1750
1751         default:
1752                 break;
1753         }
1754         return video_usercopy(inode, filp, cmd, arg, ivtv_v4l2_do_ioctl);
1755 }
1756
1757 int ivtv_v4l2_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
1758                     unsigned long arg)
1759 {
1760         struct ivtv_open_id *id = (struct ivtv_open_id *)filp->private_data;
1761         struct ivtv *itv = id->itv;
1762         int res;
1763
1764         mutex_lock(&itv->serialize_lock);
1765         res = ivtv_serialized_ioctl(itv, inode, filp, cmd, arg);
1766         mutex_unlock(&itv->serialize_lock);
1767         return res;
1768 }