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

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