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