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