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

   1 /*
   2     ioctl system call
   3     Copyright (C) 2003-2004  Kevin Thayer <nufan_wfk at yahoo.com>
   4     Copyright (C) 2005-2007  Hans Verkuil <hverkuil@xs4all.nl>
   5
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include "ivtv-driver.h"
  22 #include "ivtv-version.h"
  23 #include "ivtv-mailbox.h"
  24 #include "ivtv-i2c.h"
  25 #include "ivtv-queue.h"
  26 #include "ivtv-fileops.h"
  27 #include "ivtv-vbi.h"
  28 #include "ivtv-routing.h"
  29 #include "ivtv-streams.h"
  30 #include "ivtv-yuv.h"
  31 #include "ivtv-ioctl.h"
  32 #include "ivtv-gpio.h"
  33 #include "ivtv-controls.h"
  34 #include "ivtv-cards.h"
  35 #include <media/saa7127.h>
  36 #include <media/tveeprom.h>
  37 #include <media/v4l2-chip-ident.h>
  38 #include <media/v4l2-event.h>
  39 #include <linux/dvb/audio.h>
  40
  41 u16 ivtv_service2vbi(int type)
  42 {
  43         switch (type) {
  44                 case V4L2_SLICED_TELETEXT_B:
  45                         return IVTV_SLICED_TYPE_TELETEXT_B;
  46                 case V4L2_SLICED_CAPTION_525:
  47                         return IVTV_SLICED_TYPE_CAPTION_525;
  48                 case V4L2_SLICED_WSS_625:
  49                         return IVTV_SLICED_TYPE_WSS_625;
  50                 case V4L2_SLICED_VPS:
  51                         return IVTV_SLICED_TYPE_VPS;
  52                 default:
  53                         return 0;
  54         }
  55 }
  56
  57 static int valid_service_line(int field, int line, int is_pal)
  58 {
  59         return (is_pal && line >= 6 && (line != 23 || field == 0)) ||
  60                (!is_pal && line >= 10 && line < 22);
  61 }
  62
  63 static u16 select_service_from_set(int field, int line, u16 set, int is_pal)
  64 {
  65         u16 valid_set = (is_pal ? V4L2_SLICED_VBI_625 : V4L2_SLICED_VBI_525);
  66         int i;
  67
  68         set = set & valid_set;
  69         if (set == 0 || !valid_service_line(field, line, is_pal)) {
  70                 return 0;
  71         }
  72         if (!is_pal) {
  73                 if (line == 21 && (set & V4L2_SLICED_CAPTION_525))
  74                         return V4L2_SLICED_CAPTION_525;
  75         }
  76         else {
  77                 if (line == 16 && field == 0 && (set & V4L2_SLICED_VPS))
  78                         return V4L2_SLICED_VPS;
  79                 if (line == 23 && field == 0 && (set & V4L2_SLICED_WSS_625))
  80                         return V4L2_SLICED_WSS_625;
  81                 if (line == 23)
  82                         return 0;
  83         }
  84         for (i = 0; i < 32; i++) {
  85                 if ((1 << i) & set)
  86                         return 1 << i;
  87         }
  88         return 0;
  89 }
  90
  91 void ivtv_expand_service_set(struct v4l2_sliced_vbi_format *fmt, int is_pal)
  92 {
  93         u16 set = fmt->service_set;
  94         int f, l;
  95
  96         fmt->service_set = 0;
  97         for (f = 0; f < 2; f++) {
  98                 for (l = 0; l < 24; l++) {
  99                         fmt->service_lines[f][l] = select_service_from_set(f, l, set, is_pal);
 100                 }
 101         }
 102 }
 103
 104 static void check_service_set(struct v4l2_sliced_vbi_format *fmt, int is_pal)
 105 {
 106         int f, l;
 107
 108         for (f = 0; f < 2; f++) {
 109                 for (l = 0; l < 24; l++) {
 110                         fmt->service_lines[f][l] = select_service_from_set(f, l, fmt->service_lines[f][l], is_pal);
 111                 }
 112         }
 113 }
 114
 115 u16 ivtv_get_service_set(struct v4l2_sliced_vbi_format *fmt)
 116 {
 117         int f, l;
 118         u16 set = 0;
 119
 120         for (f = 0; f < 2; f++) {
 121                 for (l = 0; l < 24; l++) {
 122                         set |= fmt->service_lines[f][l];
 123                 }
 124         }
 125         return set;
 126 }
 127
 128 void ivtv_set_osd_alpha(struct ivtv *itv)
 129 {
 130         ivtv_vapi(itv, CX2341X_OSD_SET_GLOBAL_ALPHA, 3,
 131                 itv->osd_global_alpha_state, itv->osd_global_alpha, !itv->osd_local_alpha_state);
 132         ivtv_vapi(itv, CX2341X_OSD_SET_CHROMA_KEY, 2, itv->osd_chroma_key_state, itv->osd_chroma_key);
 133 }
 134
 135 int ivtv_set_speed(struct ivtv *itv, int speed)
 136 {
 137         u32 data[CX2341X_MBOX_MAX_DATA];
 138         int single_step = (speed == 1 || speed == -1);
 139         DEFINE_WAIT(wait);
 140
 141         if (speed == 0) speed = 1000;
 142
 143         /* No change? */
 144         if (speed == itv->speed && !single_step)
 145                 return 0;
 146
 147         if (single_step && (speed < 0) == (itv->speed < 0)) {
 148                 /* Single step video and no need to change direction */
 149                 ivtv_vapi(itv, CX2341X_DEC_STEP_VIDEO, 1, 0);
 150                 itv->speed = speed;
 151                 return 0;
 152         }
 153         if (single_step)
 154                 /* Need to change direction */
 155                 speed = speed < 0 ? -1000 : 1000;
 156
 157         data[0] = (speed > 1000 || speed < -1000) ? 0x80000000 : 0;
 158         data[0] |= (speed > 1000 || speed < -1500) ? 0x40000000 : 0;
 159         data[1] = (speed < 0);
 160         data[2] = speed < 0 ? 3 : 7;
 161         data[3] = v4l2_ctrl_g_ctrl(itv->cxhdl.video_b_frames);
 162         data[4] = (speed == 1500 || speed == 500) ? itv->speed_mute_audio : 0;
 163         data[5] = 0;
 164         data[6] = 0;
 165
 166         if (speed == 1500 || speed == -1500) data[0] |= 1;
 167         else if (speed == 2000 || speed == -2000) data[0] |= 2;
 168         else if (speed > -1000 && speed < 0) data[0] |= (-1000 / speed);
 169         else if (speed < 1000 && speed > 0) data[0] |= (1000 / speed);
 170
 171         /* If not decoding, just change speed setting */
 172         if (atomic_read(&itv->decoding) > 0) {
 173                 int got_sig = 0;
 174
 175                 /* Stop all DMA and decoding activity */
 176                 ivtv_vapi(itv, CX2341X_DEC_PAUSE_PLAYBACK, 1, 0);
 177
 178                 /* Wait for any DMA to finish */
 179                 mutex_unlock(&itv->serialize_lock);
 180                 prepare_to_wait(&itv->dma_waitq, &wait, TASK_INTERRUPTIBLE);
 181                 while (test_bit(IVTV_F_I_DMA, &itv->i_flags)) {
 182                         got_sig = signal_pending(current);
 183                         if (got_sig)
 184                                 break;
 185                         got_sig = 0;
 186                         schedule();
 187                 }
 188                 finish_wait(&itv->dma_waitq, &wait);
 189                 mutex_lock(&itv->serialize_lock);
 190                 if (got_sig)
 191                         return -EINTR;
 192
 193                 /* Change Speed safely */
 194                 ivtv_api(itv, CX2341X_DEC_SET_PLAYBACK_SPEED, 7, data);
 195                 IVTV_DEBUG_INFO("Setting Speed to 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n",
 196                                 data[0], data[1], data[2], data[3], data[4], data[5], data[6]);
 197         }
 198         if (single_step) {
 199                 speed = (speed < 0) ? -1 : 1;
 200                 ivtv_vapi(itv, CX2341X_DEC_STEP_VIDEO, 1, 0);
 201         }
 202         itv->speed = speed;
 203         return 0;
 204 }
 205
 206 static int ivtv_validate_speed(int cur_speed, int new_speed)
 207 {
 208         int fact = new_speed < 0 ? -1 : 1;
 209         int s;
 210
 211         if (cur_speed == 0)
 212                 cur_speed = 1000;
 213         if (new_speed < 0)
 214                 new_speed = -new_speed;
 215         if (cur_speed < 0)
 216                 cur_speed = -cur_speed;
 217
 218         if (cur_speed <= new_speed) {
 219                 if (new_speed > 1500)
 220                         return fact * 2000;
 221                 if (new_speed > 1000)
 222                         return fact * 1500;
 223         }
 224         else {
 225                 if (new_speed >= 2000)
 226                         return fact * 2000;
 227                 if (new_speed >= 1500)
 228                         return fact * 1500;
 229                 if (new_speed >= 1000)
 230                         return fact * 1000;
 231         }
 232         if (new_speed == 0)
 233                 return 1000;
 234         if (new_speed == 1 || new_speed == 1000)
 235                 return fact * new_speed;
 236
 237         s = new_speed;
 238         new_speed = 1000 / new_speed;
 239         if (1000 / cur_speed == new_speed)
 240                 new_speed += (cur_speed < s) ? -1 : 1;
 241         if (new_speed > 60) return 1000 / (fact * 60);
 242         return 1000 / (fact * new_speed);
 243 }
 244
 245 static int ivtv_video_command(struct ivtv *itv, struct ivtv_open_id *id,
 246                 struct v4l2_decoder_cmd *dc, int try)
 247 {
 248         struct ivtv_stream *s = &itv->streams[IVTV_DEC_STREAM_TYPE_MPG];
 249
 250         if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
 251                 return -EINVAL;
 252
 253         switch (dc->cmd) {
 254         case V4L2_DEC_CMD_START: {
 255                 dc->flags &= V4L2_DEC_CMD_START_MUTE_AUDIO;
 256                 dc->start.speed = ivtv_validate_speed(itv->speed, dc->start.speed);
 257                 if (dc->start.speed < 0)
 258                         dc->start.format = V4L2_DEC_START_FMT_GOP;
 259                 else
 260                         dc->start.format = V4L2_DEC_START_FMT_NONE;
 261                 if (dc->start.speed != 500 && dc->start.speed != 1500)
 262                         dc->flags = dc->start.speed == 1000 ? 0 :
 263                                         V4L2_DEC_CMD_START_MUTE_AUDIO;
 264                 if (try) break;
 265
 266                 itv->speed_mute_audio = dc->flags & V4L2_DEC_CMD_START_MUTE_AUDIO;
 267                 if (ivtv_set_output_mode(itv, OUT_MPG) != OUT_MPG)
 268                         return -EBUSY;
 269                 if (test_and_clear_bit(IVTV_F_I_DEC_PAUSED, &itv->i_flags)) {
 270                         /* forces ivtv_set_speed to be called */
 271                         itv->speed = 0;
 272                 }
 273                 return ivtv_start_decoding(id, dc->start.speed);
 274         }
 275
 276         case V4L2_DEC_CMD_STOP:
 277                 dc->flags &= V4L2_DEC_CMD_STOP_IMMEDIATELY | V4L2_DEC_CMD_STOP_TO_BLACK;
 278                 if (dc->flags & V4L2_DEC_CMD_STOP_IMMEDIATELY)
 279                         dc->stop.pts = 0;
 280                 if (try) break;
 281                 if (atomic_read(&itv->decoding) == 0)
 282                         return 0;
 283                 if (itv->output_mode != OUT_MPG)
 284                         return -EBUSY;
 285
 286                 itv->output_mode = OUT_NONE;
 287                 return ivtv_stop_v4l2_decode_stream(s, dc->flags, dc->stop.pts);
 288
 289         case V4L2_DEC_CMD_PAUSE:
 290                 dc->flags &= V4L2_DEC_CMD_PAUSE_TO_BLACK;
 291                 if (try) break;
 292                 if (!atomic_read(&itv->decoding))
 293                         return -EPERM;
 294                 if (itv->output_mode != OUT_MPG)
 295                         return -EBUSY;
 296                 if (atomic_read(&itv->decoding) > 0) {
 297                         ivtv_vapi(itv, CX2341X_DEC_PAUSE_PLAYBACK, 1,
 298                                 (dc->flags & V4L2_DEC_CMD_PAUSE_TO_BLACK) ? 1 : 0);
 299                         set_bit(IVTV_F_I_DEC_PAUSED, &itv->i_flags);
 300                 }
 301                 break;
 302
 303         case V4L2_DEC_CMD_RESUME:
 304                 dc->flags = 0;
 305                 if (try) break;
 306                 if (!atomic_read(&itv->decoding))
 307                         return -EPERM;
 308                 if (itv->output_mode != OUT_MPG)
 309                         return -EBUSY;
 310                 if (test_and_clear_bit(IVTV_F_I_DEC_PAUSED, &itv->i_flags)) {
 311                         int speed = itv->speed;
 312                         itv->speed = 0;
 313                         return ivtv_start_decoding(id, speed);
 314                 }
 315                 break;
 316
 317         default:
 318                 return -EINVAL;
 319         }
 320         return 0;
 321 }
 322
 323 static int ivtv_g_fmt_sliced_vbi_out(struct file *file, void *fh, struct v4l2_format *fmt)
 324 {
 325         struct ivtv *itv = fh2id(fh)->itv;
 326         struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
 327
 328         vbifmt->reserved[0] = 0;
 329         vbifmt->reserved[1] = 0;
 330         if (!(itv->v4l2_cap & V4L2_CAP_SLICED_VBI_OUTPUT))
 331                 return -EINVAL;
 332         vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
 333         memset(vbifmt->service_lines, 0, sizeof(vbifmt->service_lines));
 334         if (itv->is_60hz) {
 335                 vbifmt->service_lines[0][21] = V4L2_SLICED_CAPTION_525;
 336                 vbifmt->service_lines[1][21] = V4L2_SLICED_CAPTION_525;
 337         } else {
 338                 vbifmt->service_lines[0][23] = V4L2_SLICED_WSS_625;
 339                 vbifmt->service_lines[0][16] = V4L2_SLICED_VPS;
 340         }
 341         vbifmt->service_set = ivtv_get_service_set(vbifmt);
 342         return 0;
 343 }
 344
 345 static int ivtv_g_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
 346 {
 347         struct ivtv_open_id *id = fh2id(fh);
 348         struct ivtv *itv = id->itv;
 349         struct v4l2_pix_format *pixfmt = &fmt->fmt.pix;
 350
 351         pixfmt->width = itv->cxhdl.width;
 352         pixfmt->height = itv->cxhdl.height;
 353         pixfmt->colorspace = V4L2_COLORSPACE_SMPTE170M;
 354         pixfmt->field = V4L2_FIELD_INTERLACED;
 355         pixfmt->priv = 0;
 356         if (id->type == IVTV_ENC_STREAM_TYPE_YUV) {
 357                 pixfmt->pixelformat = V4L2_PIX_FMT_HM12;
 358                 /* YUV size is (Y=(h*720) + UV=(h*(720/2))) */
 359                 pixfmt->sizeimage = pixfmt->height * 720 * 3 / 2;
 360                 pixfmt->bytesperline = 720;
 361         } else {
 362                 pixfmt->pixelformat = V4L2_PIX_FMT_MPEG;
 363                 pixfmt->sizeimage = 128 * 1024;
 364                 pixfmt->bytesperline = 0;
 365         }
 366         return 0;
 367 }
 368
 369 static int ivtv_g_fmt_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
 370 {
 371         struct ivtv *itv = fh2id(fh)->itv;
 372         struct v4l2_vbi_format *vbifmt = &fmt->fmt.vbi;
 373
 374         vbifmt->sampling_rate = 27000000;
 375         vbifmt->offset = 248;
 376         vbifmt->samples_per_line = itv->vbi.raw_decoder_line_size - 4;
 377         vbifmt->sample_format = V4L2_PIX_FMT_GREY;
 378         vbifmt->start[0] = itv->vbi.start[0];
 379         vbifmt->start[1] = itv->vbi.start[1];
 380         vbifmt->count[0] = vbifmt->count[1] = itv->vbi.count;
 381         vbifmt->flags = 0;
 382         vbifmt->reserved[0] = 0;
 383         vbifmt->reserved[1] = 0;
 384         return 0;
 385 }
 386
 387 static int ivtv_g_fmt_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
 388 {
 389         struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
 390         struct ivtv_open_id *id = fh2id(fh);
 391         struct ivtv *itv = id->itv;
 392
 393         vbifmt->reserved[0] = 0;
 394         vbifmt->reserved[1] = 0;
 395         vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
 396
 397         if (id->type == IVTV_DEC_STREAM_TYPE_VBI) {
 398                 vbifmt->service_set = itv->is_50hz ? V4L2_SLICED_VBI_625 :
 399                         V4L2_SLICED_VBI_525;
 400                 ivtv_expand_service_set(vbifmt, itv->is_50hz);
 401                 vbifmt->service_set = ivtv_get_service_set(vbifmt);
 402                 return 0;
 403         }
 404
 405         v4l2_subdev_call(itv->sd_video, vbi, g_sliced_fmt, vbifmt);
 406         vbifmt->service_set = ivtv_get_service_set(vbifmt);
 407         return 0;
 408 }
 409
 410 static int ivtv_g_fmt_vid_out(struct file *file, void *fh, struct v4l2_format *fmt)
 411 {
 412         struct ivtv_open_id *id = fh2id(fh);
 413         struct ivtv *itv = id->itv;
 414         struct v4l2_pix_format *pixfmt = &fmt->fmt.pix;
 415
 416         if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
 417                 return -EINVAL;
 418         pixfmt->width = itv->main_rect.width;
 419         pixfmt->height = itv->main_rect.height;
 420         pixfmt->colorspace = V4L2_COLORSPACE_SMPTE170M;
 421         pixfmt->field = V4L2_FIELD_INTERLACED;
 422         pixfmt->priv = 0;
 423         if (id->type == IVTV_DEC_STREAM_TYPE_YUV) {
 424                 switch (itv->yuv_info.lace_mode & IVTV_YUV_MODE_MASK) {
 425                 case IVTV_YUV_MODE_INTERLACED:
 426                         pixfmt->field = (itv->yuv_info.lace_mode & IVTV_YUV_SYNC_MASK) ?
 427                                 V4L2_FIELD_INTERLACED_BT : V4L2_FIELD_INTERLACED_TB;
 428                         break;
 429                 case IVTV_YUV_MODE_PROGRESSIVE:
 430                         pixfmt->field = V4L2_FIELD_NONE;
 431                         break;
 432                 default:
 433                         pixfmt->field = V4L2_FIELD_ANY;
 434                         break;
 435                 }
 436                 pixfmt->pixelformat = V4L2_PIX_FMT_HM12;
 437                 pixfmt->bytesperline = 720;
 438                 pixfmt->width = itv->yuv_info.v4l2_src_w;
 439                 pixfmt->height = itv->yuv_info.v4l2_src_h;
 440                 /* YUV size is (Y=(h*w) + UV=(h*(w/2))) */
 441                 pixfmt->sizeimage =
 442                         1080 * ((pixfmt->height + 31) & ~31);
 443         } else {
 444                 pixfmt->pixelformat = V4L2_PIX_FMT_MPEG;
 445                 pixfmt->sizeimage = 128 * 1024;
 446                 pixfmt->bytesperline = 0;
 447         }
 448         return 0;
 449 }
 450
 451 static int ivtv_g_fmt_vid_out_overlay(struct file *file, void *fh, struct v4l2_format *fmt)
 452 {
 453         struct ivtv *itv = fh2id(fh)->itv;
 454         struct v4l2_window *winfmt = &fmt->fmt.win;
 455
 456         if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
 457                 return -EINVAL;
 458         winfmt->chromakey = itv->osd_chroma_key;
 459         winfmt->global_alpha = itv->osd_global_alpha;
 460         winfmt->field = V4L2_FIELD_INTERLACED;
 461         winfmt->clips = NULL;
 462         winfmt->clipcount = 0;
 463         winfmt->bitmap = NULL;
 464         winfmt->w.top = winfmt->w.left = 0;
 465         winfmt->w.width = itv->osd_rect.width;
 466         winfmt->w.height = itv->osd_rect.height;
 467         return 0;
 468 }
 469
 470 static int ivtv_try_fmt_sliced_vbi_out(struct file *file, void *fh, struct v4l2_format *fmt)
 471 {
 472         return ivtv_g_fmt_sliced_vbi_out(file, fh, fmt);
 473 }
 474
 475 static int ivtv_try_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
 476 {
 477         struct ivtv_open_id *id = fh2id(fh);
 478         struct ivtv *itv = id->itv;
 479         int w = fmt->fmt.pix.width;
 480         int h = fmt->fmt.pix.height;
 481         int min_h = 2;
 482
 483         w = min(w, 720);
 484         w = max(w, 2);
 485         if (id->type == IVTV_ENC_STREAM_TYPE_YUV) {
 486                 /* YUV height must be a multiple of 32 */
 487                 h &= ~0x1f;
 488                 min_h = 32;
 489         }
 490         h = min(h, itv->is_50hz ? 576 : 480);
 491         h = max(h, min_h);
 492         ivtv_g_fmt_vid_cap(file, fh, fmt);
 493         fmt->fmt.pix.width = w;
 494         fmt->fmt.pix.height = h;
 495         return 0;
 496 }
 497
 498 static int ivtv_try_fmt_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
 499 {
 500         return ivtv_g_fmt_vbi_cap(file, fh, fmt);
 501 }
 502
 503 static int ivtv_try_fmt_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
 504 {
 505         struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
 506         struct ivtv_open_id *id = fh2id(fh);
 507         struct ivtv *itv = id->itv;
 508
 509         if (id->type == IVTV_DEC_STREAM_TYPE_VBI)
 510                 return ivtv_g_fmt_sliced_vbi_cap(file, fh, fmt);
 511
 512         /* set sliced VBI capture format */
 513         vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
 514         vbifmt->reserved[0] = 0;
 515         vbifmt->reserved[1] = 0;
 516
 517         if (vbifmt->service_set)
 518                 ivtv_expand_service_set(vbifmt, itv->is_50hz);
 519         check_service_set(vbifmt, itv->is_50hz);
 520         vbifmt->service_set = ivtv_get_service_set(vbifmt);
 521         return 0;
 522 }
 523
 524 static int ivtv_try_fmt_vid_out(struct file *file, void *fh, struct v4l2_format *fmt)
 525 {
 526         struct ivtv_open_id *id = fh2id(fh);
 527         s32 w = fmt->fmt.pix.width;
 528         s32 h = fmt->fmt.pix.height;
 529         int field = fmt->fmt.pix.field;
 530         int ret = ivtv_g_fmt_vid_out(file, fh, fmt);
 531
 532         w = min(w, 720);
 533         w = max(w, 2);
 534         /* Why can the height be 576 even when the output is NTSC?
 535
 536            Internally the buffers of the PVR350 are always set to 720x576. The
 537            decoded video frame will always be placed in the top left corner of
 538            this buffer. For any video which is not 720x576, the buffer will
 539            then be cropped to remove the unused right and lower areas, with
 540            the remaining image being scaled by the hardware to fit the display
 541            area. The video can be scaled both up and down, so a 720x480 video
 542            can be displayed full-screen on PAL and a 720x576 video can be
 543            displayed without cropping on NTSC.
 544
 545            Note that the scaling only occurs on the video stream, the osd
 546            resolution is locked to the broadcast standard and not scaled.
 547
 548            Thanks to Ian Armstrong for this explanation. */
 549         h = min(h, 576);
 550         h = max(h, 2);
 551         if (id->type == IVTV_DEC_STREAM_TYPE_YUV)
 552                 fmt->fmt.pix.field = field;
 553         fmt->fmt.pix.width = w;
 554         fmt->fmt.pix.height = h;
 555         return ret;
 556 }
 557
 558 static int ivtv_try_fmt_vid_out_overlay(struct file *file, void *fh, struct v4l2_format *fmt)
 559 {
 560         struct ivtv *itv = fh2id(fh)->itv;
 561         u32 chromakey = fmt->fmt.win.chromakey;
 562         u8 global_alpha = fmt->fmt.win.global_alpha;
 563
 564         if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
 565                 return -EINVAL;
 566         ivtv_g_fmt_vid_out_overlay(file, fh, fmt);
 567         fmt->fmt.win.chromakey = chromakey;
 568         fmt->fmt.win.global_alpha = global_alpha;
 569         return 0;
 570 }
 571
 572 static int ivtv_s_fmt_sliced_vbi_out(struct file *file, void *fh, struct v4l2_format *fmt)
 573 {
 574         return ivtv_g_fmt_sliced_vbi_out(file, fh, fmt);
 575 }
 576
 577 static int ivtv_s_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
 578 {
 579         struct ivtv_open_id *id = fh2id(fh);
 580         struct ivtv *itv = id->itv;
 581         struct v4l2_mbus_framefmt mbus_fmt;
 582         int ret = ivtv_try_fmt_vid_cap(file, fh, fmt);
 583         int w = fmt->fmt.pix.width;
 584         int h = fmt->fmt.pix.height;
 585
 586         if (ret)
 587                 return ret;
 588
 589         if (itv->cxhdl.width == w && itv->cxhdl.height == h)
 590                 return 0;
 591
 592         if (atomic_read(&itv->capturing) > 0)
 593                 return -EBUSY;
 594
 595         itv->cxhdl.width = w;
 596         itv->cxhdl.height = h;
 597         if (v4l2_ctrl_g_ctrl(itv->cxhdl.video_encoding) == V4L2_MPEG_VIDEO_ENCODING_MPEG_1)
 598                 fmt->fmt.pix.width /= 2;
 599         mbus_fmt.width = fmt->fmt.pix.width;
 600         mbus_fmt.height = h;
 601         mbus_fmt.code = V4L2_MBUS_FMT_FIXED;
 602         v4l2_subdev_call(itv->sd_video, video, s_mbus_fmt, &mbus_fmt);
 603         return ivtv_g_fmt_vid_cap(file, fh, fmt);
 604 }
 605
 606 static int ivtv_s_fmt_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
 607 {
 608         struct ivtv *itv = fh2id(fh)->itv;
 609
 610         if (!ivtv_raw_vbi(itv) && atomic_read(&itv->capturing) > 0)
 611                 return -EBUSY;
 612         itv->vbi.sliced_in->service_set = 0;
 613         itv->vbi.in.type = V4L2_BUF_TYPE_VBI_CAPTURE;
 614         v4l2_subdev_call(itv->sd_video, vbi, s_raw_fmt, &fmt->fmt.vbi);
 615         return ivtv_g_fmt_vbi_cap(file, fh, fmt);
 616 }
 617
 618 static int ivtv_s_fmt_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
 619 {
 620         struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
 621         struct ivtv_open_id *id = fh2id(fh);
 622         struct ivtv *itv = id->itv;
 623         int ret = ivtv_try_fmt_sliced_vbi_cap(file, fh, fmt);
 624
 625         if (ret || id->type == IVTV_DEC_STREAM_TYPE_VBI)
 626                 return ret;
 627
 628         check_service_set(vbifmt, itv->is_50hz);
 629         if (ivtv_raw_vbi(itv) && atomic_read(&itv->capturing) > 0)
 630                 return -EBUSY;
 631         itv->vbi.in.type = V4L2_BUF_TYPE_SLICED_VBI_CAPTURE;
 632         v4l2_subdev_call(itv->sd_video, vbi, s_sliced_fmt, vbifmt);
 633         memcpy(itv->vbi.sliced_in, vbifmt, sizeof(*itv->vbi.sliced_in));
 634         return 0;
 635 }
 636
 637 static int ivtv_s_fmt_vid_out(struct file *file, void *fh, struct v4l2_format *fmt)
 638 {
 639         struct ivtv_open_id *id = fh2id(fh);
 640         struct ivtv *itv = id->itv;
 641         struct yuv_playback_info *yi = &itv->yuv_info;
 642         int ret = ivtv_try_fmt_vid_out(file, fh, fmt);
 643
 644         if (ret)
 645                 return ret;
 646
 647         if (id->type != IVTV_DEC_STREAM_TYPE_YUV)
 648                 return 0;
 649
 650         /* Return now if we already have some frame data */
 651         if (yi->stream_size)
 652                 return -EBUSY;
 653
 654         yi->v4l2_src_w = fmt->fmt.pix.width;
 655         yi->v4l2_src_h = fmt->fmt.pix.height;
 656
 657         switch (fmt->fmt.pix.field) {
 658         case V4L2_FIELD_NONE:
 659                 yi->lace_mode = IVTV_YUV_MODE_PROGRESSIVE;
 660                 break;
 661         case V4L2_FIELD_ANY:
 662                 yi->lace_mode = IVTV_YUV_MODE_AUTO;
 663                 break;
 664         case V4L2_FIELD_INTERLACED_BT:
 665                 yi->lace_mode =
 666                         IVTV_YUV_MODE_INTERLACED|IVTV_YUV_SYNC_ODD;
 667                 break;
 668         case V4L2_FIELD_INTERLACED_TB:
 669         default:
 670                 yi->lace_mode = IVTV_YUV_MODE_INTERLACED;
 671                 break;
 672         }
 673         yi->lace_sync_field = (yi->lace_mode & IVTV_YUV_SYNC_MASK) == IVTV_YUV_SYNC_EVEN ? 0 : 1;
 674
 675         if (test_bit(IVTV_F_I_DEC_YUV, &itv->i_flags))
 676                 itv->dma_data_req_size =
 677                         1080 * ((yi->v4l2_src_h + 31) & ~31);
 678
 679         return 0;
 680 }
 681
 682 static int ivtv_s_fmt_vid_out_overlay(struct file *file, void *fh, struct v4l2_format *fmt)
 683 {
 684         struct ivtv *itv = fh2id(fh)->itv;
 685         int ret = ivtv_try_fmt_vid_out_overlay(file, fh, fmt);
 686
 687         if (ret == 0) {
 688                 itv->osd_chroma_key = fmt->fmt.win.chromakey;
 689                 itv->osd_global_alpha = fmt->fmt.win.global_alpha;
 690                 ivtv_set_osd_alpha(itv);
 691         }
 692         return ret;
 693 }
 694
 695 static int ivtv_g_chip_ident(struct file *file, void *fh, struct v4l2_dbg_chip_ident *chip)
 696 {
 697         struct ivtv *itv = fh2id(fh)->itv;
 698
 699         chip->ident = V4L2_IDENT_NONE;
 700         chip->revision = 0;
 701         if (chip->match.type == V4L2_CHIP_MATCH_HOST) {
 702                 if (v4l2_chip_match_host(&chip->match))
 703                         chip->ident = itv->has_cx23415 ? V4L2_IDENT_CX23415 : V4L2_IDENT_CX23416;
 704                 return 0;
 705         }
 706         if (chip->match.type != V4L2_CHIP_MATCH_I2C_DRIVER &&
 707             chip->match.type != V4L2_CHIP_MATCH_I2C_ADDR)
 708                 return -EINVAL;
 709         /* TODO: is this correct? */
 710         return ivtv_call_all_err(itv, core, g_chip_ident, chip);
 711 }
 712
 713 #ifdef CONFIG_VIDEO_ADV_DEBUG
 714 static int ivtv_itvc(struct ivtv *itv, bool get, u64 reg, u64 *val)
 715 {
 716         volatile u8 __iomem *reg_start;
 717
 718         if (!capable(CAP_SYS_ADMIN))
 719                 return -EPERM;
 720         if (reg >= IVTV_REG_OFFSET && reg < IVTV_REG_OFFSET + IVTV_REG_SIZE)
 721                 reg_start = itv->reg_mem - IVTV_REG_OFFSET;
 722         else if (itv->has_cx23415 && reg >= IVTV_DECODER_OFFSET &&
 723                         reg < IVTV_DECODER_OFFSET + IVTV_DECODER_SIZE)
 724                 reg_start = itv->dec_mem - IVTV_DECODER_OFFSET;
 725         else if (reg < IVTV_ENCODER_SIZE)
 726                 reg_start = itv->enc_mem;
 727         else
 728                 return -EINVAL;
 729
 730         if (get)
 731                 *val = readl(reg + reg_start);
 732         else
 733                 writel(*val, reg + reg_start);
 734         return 0;
 735 }
 736
 737 static int ivtv_g_register(struct file *file, void *fh, struct v4l2_dbg_register *reg)
 738 {
 739         struct ivtv *itv = fh2id(fh)->itv;
 740
 741         if (v4l2_chip_match_host(&reg->match)) {
 742                 reg->size = 4;
 743                 return ivtv_itvc(itv, true, reg->reg, &reg->val);
 744         }
 745         /* TODO: subdev errors should not be ignored, this should become a
 746            subdev helper function. */
 747         ivtv_call_all(itv, core, g_register, reg);
 748         return 0;
 749 }
 750
 751 static int ivtv_s_register(struct file *file, void *fh, const struct v4l2_dbg_register *reg)
 752 {
 753         struct ivtv *itv = fh2id(fh)->itv;
 754
 755         if (v4l2_chip_match_host(&reg->match)) {
 756                 u64 val = reg->val;
 757
 758                 return ivtv_itvc(itv, false, reg->reg, &val);
 759         }
 760         /* TODO: subdev errors should not be ignored, this should become a
 761            subdev helper function. */
 762         ivtv_call_all(itv, core, s_register, reg);
 763         return 0;
 764 }
 765 #endif
 766
 767 static int ivtv_querycap(struct file *file, void *fh, struct v4l2_capability *vcap)
 768 {
 769         struct ivtv_open_id *id = fh2id(file->private_data);
 770         struct ivtv *itv = id->itv;
 771         struct ivtv_stream *s = &itv->streams[id->type];
 772
 773         strlcpy(vcap->driver, IVTV_DRIVER_NAME, sizeof(vcap->driver));
 774         strlcpy(vcap->card, itv->card_name, sizeof(vcap->card));
 775         snprintf(vcap->bus_info, sizeof(vcap->bus_info), "PCI:%s", pci_name(itv->pdev));
 776         vcap->capabilities = itv->v4l2_cap | V4L2_CAP_DEVICE_CAPS;
 777         vcap->device_caps = s->caps;
 778         return 0;
 779 }
 780
 781 static int ivtv_enumaudio(struct file *file, void *fh, struct v4l2_audio *vin)
 782 {
 783         struct ivtv *itv = fh2id(fh)->itv;
 784
 785         return ivtv_get_audio_input(itv, vin->index, vin);
 786 }
 787
 788 static int ivtv_g_audio(struct file *file, void *fh, struct v4l2_audio *vin)
 789 {
 790         struct ivtv *itv = fh2id(fh)->itv;
 791
 792         vin->index = itv->audio_input;
 793         return ivtv_get_audio_input(itv, vin->index, vin);
 794 }
 795
 796 static int ivtv_s_audio(struct file *file, void *fh, const struct v4l2_audio *vout)
 797 {
 798         struct ivtv *itv = fh2id(fh)->itv;
 799
 800         if (vout->index >= itv->nof_audio_inputs)
 801                 return -EINVAL;
 802
 803         itv->audio_input = vout->index;
 804         ivtv_audio_set_io(itv);
 805
 806         return 0;
 807 }
 808
 809 static int ivtv_enumaudout(struct file *file, void *fh, struct v4l2_audioout *vin)
 810 {
 811         struct ivtv *itv = fh2id(fh)->itv;
 812
 813         /* set it to defaults from our table */
 814         return ivtv_get_audio_output(itv, vin->index, vin);
 815 }
 816
 817 static int ivtv_g_audout(struct file *file, void *fh, struct v4l2_audioout *vin)
 818 {
 819         struct ivtv *itv = fh2id(fh)->itv;
 820
 821         vin->index = 0;
 822         return ivtv_get_audio_output(itv, vin->index, vin);
 823 }
 824
 825 static int ivtv_s_audout(struct file *file, void *fh, const struct v4l2_audioout *vout)
 826 {
 827         struct ivtv *itv = fh2id(fh)->itv;
 828
 829         if (itv->card->video_outputs == NULL || vout->index != 0)
 830                 return -EINVAL;
 831         return 0;
 832 }
 833
 834 static int ivtv_enum_input(struct file *file, void *fh, struct v4l2_input *vin)
 835 {
 836         struct ivtv *itv = fh2id(fh)->itv;
 837
 838         /* set it to defaults from our table */
 839         return ivtv_get_input(itv, vin->index, vin);
 840 }
 841
 842 static int ivtv_enum_output(struct file *file, void *fh, struct v4l2_output *vout)
 843 {
 844         struct ivtv *itv = fh2id(fh)->itv;
 845
 846         return ivtv_get_output(itv, vout->index, vout);
 847 }
 848
 849 static int ivtv_cropcap(struct file *file, void *fh, struct v4l2_cropcap *cropcap)
 850 {
 851         struct ivtv_open_id *id = fh2id(fh);
 852         struct ivtv *itv = id->itv;
 853         struct yuv_playback_info *yi = &itv->yuv_info;
 854         int streamtype;
 855
 856         streamtype = id->type;
 857
 858         if (cropcap->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
 859                 return -EINVAL;
 860         cropcap->bounds.top = cropcap->bounds.left = 0;
 861         cropcap->bounds.width = 720;
 862         if (cropcap->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
 863                 cropcap->bounds.height = itv->is_50hz ? 576 : 480;
 864                 cropcap->pixelaspect.numerator = itv->is_50hz ? 59 : 10;
 865                 cropcap->pixelaspect.denominator = itv->is_50hz ? 54 : 11;
 866         } else if (streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
 867                 if (yi->track_osd) {
 868                         cropcap->bounds.width = yi->osd_full_w;
 869                         cropcap->bounds.height = yi->osd_full_h;
 870                 } else {
 871                         cropcap->bounds.width = 720;
 872                         cropcap->bounds.height =
 873                                         itv->is_out_50hz ? 576 : 480;
 874                 }
 875                 cropcap->pixelaspect.numerator = itv->is_out_50hz ? 59 : 10;
 876                 cropcap->pixelaspect.denominator = itv->is_out_50hz ? 54 : 11;
 877         } else {
 878                 cropcap->bounds.height = itv->is_out_50hz ? 576 : 480;
 879                 cropcap->pixelaspect.numerator = itv->is_out_50hz ? 59 : 10;
 880                 cropcap->pixelaspect.denominator = itv->is_out_50hz ? 54 : 11;
 881         }
 882         cropcap->defrect = cropcap->bounds;
 883         return 0;
 884 }
 885
 886 static int ivtv_s_crop(struct file *file, void *fh, const struct v4l2_crop *crop)
 887 {
 888         struct ivtv_open_id *id = fh2id(fh);
 889         struct ivtv *itv = id->itv;
 890         struct yuv_playback_info *yi = &itv->yuv_info;
 891         int streamtype;
 892
 893         streamtype = id->type;
 894
 895         if (crop->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
 896             (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) {
 897                 if (streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
 898                         yi->main_rect = crop->c;
 899                         return 0;
 900                 } else {
 901                         if (!ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
 902                                 crop->c.width, crop->c.height, crop->c.left, crop->c.top)) {
 903                                 itv->main_rect = crop->c;
 904                                 return 0;
 905                         }
 906                 }
 907                 return -EINVAL;
 908         }
 909         return -EINVAL;
 910 }
 911
 912 static int ivtv_g_crop(struct file *file, void *fh, struct v4l2_crop *crop)
 913 {
 914         struct ivtv_open_id *id = fh2id(fh);
 915         struct ivtv *itv = id->itv;
 916         struct yuv_playback_info *yi = &itv->yuv_info;
 917         int streamtype;
 918
 919         streamtype = id->type;
 920
 921         if (crop->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
 922             (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) {
 923                 if (streamtype == IVTV_DEC_STREAM_TYPE_YUV)
 924                         crop->c = yi->main_rect;
 925                 else
 926                         crop->c = itv->main_rect;
 927                 return 0;
 928         }
 929         return -EINVAL;
 930 }
 931
 932 static int ivtv_enum_fmt_vid_cap(struct file *file, void *fh, struct v4l2_fmtdesc *fmt)
 933 {
 934         static const struct v4l2_fmtdesc hm12 = {
 935                 0, V4L2_BUF_TYPE_VIDEO_CAPTURE, 0,
 936                 "HM12 (YUV 4:2:0)", V4L2_PIX_FMT_HM12,
 937                 { 0, 0, 0, 0 }
 938         };
 939         static const struct v4l2_fmtdesc mpeg = {
 940                 0, V4L2_BUF_TYPE_VIDEO_CAPTURE, V4L2_FMT_FLAG_COMPRESSED,
 941                 "MPEG", V4L2_PIX_FMT_MPEG,
 942                 { 0, 0, 0, 0 }
 943         };
 944         struct ivtv *itv = fh2id(fh)->itv;
 945         struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
 946
 947         if (fmt->index)
 948                 return -EINVAL;
 949         if (s->type == IVTV_ENC_STREAM_TYPE_MPG)
 950                 *fmt = mpeg;
 951         else if (s->type == IVTV_ENC_STREAM_TYPE_YUV)
 952                 *fmt = hm12;
 953         else
 954                 return -EINVAL;
 955         return 0;
 956 }
 957
 958 static int ivtv_enum_fmt_vid_out(struct file *file, void *fh, struct v4l2_fmtdesc *fmt)
 959 {
 960         static const struct v4l2_fmtdesc hm12 = {
 961                 0, V4L2_BUF_TYPE_VIDEO_OUTPUT, 0,
 962                 "HM12 (YUV 4:2:0)", V4L2_PIX_FMT_HM12,
 963                 { 0, 0, 0, 0 }
 964         };
 965         static const struct v4l2_fmtdesc mpeg = {
 966                 0, V4L2_BUF_TYPE_VIDEO_OUTPUT, V4L2_FMT_FLAG_COMPRESSED,
 967                 "MPEG", V4L2_PIX_FMT_MPEG,
 968                 { 0, 0, 0, 0 }
 969         };
 970         struct ivtv *itv = fh2id(fh)->itv;
 971         struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
 972
 973         if (fmt->index)
 974                 return -EINVAL;
 975         if (s->type == IVTV_DEC_STREAM_TYPE_MPG)
 976                 *fmt = mpeg;
 977         else if (s->type == IVTV_DEC_STREAM_TYPE_YUV)
 978                 *fmt = hm12;
 979         else
 980                 return -EINVAL;
 981         return 0;
 982 }
 983
 984 static int ivtv_g_input(struct file *file, void *fh, unsigned int *i)
 985 {
 986         struct ivtv *itv = fh2id(fh)->itv;
 987
 988         *i = itv->active_input;
 989
 990         return 0;
 991 }
 992
 993 int ivtv_s_input(struct file *file, void *fh, unsigned int inp)
 994 {
 995         struct ivtv *itv = fh2id(fh)->itv;
 996         v4l2_std_id std;
 997         int i;
 998
 999         if (inp >= itv->nof_inputs)
1000                 return -EINVAL;
1001
1002         if (inp == itv->active_input) {
1003                 IVTV_DEBUG_INFO("Input unchanged\n");
1004                 return 0;
1005         }
1006
1007         if (atomic_read(&itv->capturing) > 0) {
1008                 return -EBUSY;
1009         }
1010
1011         IVTV_DEBUG_INFO("Changing input from %d to %d\n",
1012                         itv->active_input, inp);
1013
1014         itv->active_input = inp;
1015         /* Set the audio input to whatever is appropriate for the
1016            input type. */
1017         itv->audio_input = itv->card->video_inputs[inp].audio_index;
1018
1019         if (itv->card->video_inputs[inp].video_type == IVTV_CARD_INPUT_VID_TUNER)
1020                 std = itv->tuner_std;
1021         else
1022                 std = V4L2_STD_ALL;
1023         for (i = 0; i <= IVTV_ENC_STREAM_TYPE_VBI; i++)
1024                 itv->streams[i].vdev->tvnorms = std;
1025
1026         /* prevent others from messing with the streams until
1027            we're finished changing inputs. */
1028         ivtv_mute(itv);
1029         ivtv_video_set_io(itv);
1030         ivtv_audio_set_io(itv);
1031         ivtv_unmute(itv);
1032
1033         return 0;
1034 }
1035
1036 static int ivtv_g_output(struct file *file, void *fh, unsigned int *i)
1037 {
1038         struct ivtv *itv = fh2id(fh)->itv;
1039
1040         if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1041                 return -EINVAL;
1042
1043         *i = itv->active_output;
1044
1045         return 0;
1046 }
1047
1048 static int ivtv_s_output(struct file *file, void *fh, unsigned int outp)
1049 {
1050         struct ivtv *itv = fh2id(fh)->itv;
1051
1052         if (outp >= itv->card->nof_outputs)
1053                 return -EINVAL;
1054
1055         if (outp == itv->active_output) {
1056                 IVTV_DEBUG_INFO("Output unchanged\n");
1057                 return 0;
1058         }
1059         IVTV_DEBUG_INFO("Changing output from %d to %d\n",
1060                    itv->active_output, outp);
1061
1062         itv->active_output = outp;
1063         ivtv_call_hw(itv, IVTV_HW_SAA7127, video, s_routing,
1064                         SAA7127_INPUT_TYPE_NORMAL,
1065                         itv->card->video_outputs[outp].video_output, 0);
1066
1067         return 0;
1068 }
1069
1070 static int ivtv_g_frequency(struct file *file, void *fh, struct v4l2_frequency *vf)
1071 {
1072         struct ivtv *itv = fh2id(fh)->itv;
1073         struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
1074
1075         if (s->vdev->vfl_dir)
1076                 return -ENOTTY;
1077         if (vf->tuner != 0)
1078                 return -EINVAL;
1079
1080         ivtv_call_all(itv, tuner, g_frequency, vf);
1081         return 0;
1082 }
1083
1084 int ivtv_s_frequency(struct file *file, void *fh, const struct v4l2_frequency *vf)
1085 {
1086         struct ivtv *itv = fh2id(fh)->itv;
1087         struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
1088
1089         if (s->vdev->vfl_dir)
1090                 return -ENOTTY;
1091         if (vf->tuner != 0)
1092                 return -EINVAL;
1093
1094         ivtv_mute(itv);
1095         IVTV_DEBUG_INFO("v4l2 ioctl: set frequency %d\n", vf->frequency);
1096         ivtv_call_all(itv, tuner, s_frequency, vf);
1097         ivtv_unmute(itv);
1098         return 0;
1099 }
1100
1101 static int ivtv_g_std(struct file *file, void *fh, v4l2_std_id *std)
1102 {
1103         struct ivtv *itv = fh2id(fh)->itv;
1104
1105         *std = itv->std;
1106         return 0;
1107 }
1108
1109 void ivtv_s_std_enc(struct ivtv *itv, v4l2_std_id std)
1110 {
1111         itv->std = std;
1112         itv->is_60hz = (std & V4L2_STD_525_60) ? 1 : 0;
1113         itv->is_50hz = !itv->is_60hz;
1114         cx2341x_handler_set_50hz(&itv->cxhdl, itv->is_50hz);
1115         itv->cxhdl.width = 720;
1116         itv->cxhdl.height = itv->is_50hz ? 576 : 480;
1117         itv->vbi.count = itv->is_50hz ? 18 : 12;
1118         itv->vbi.start[0] = itv->is_50hz ? 6 : 10;
1119         itv->vbi.start[1] = itv->is_50hz ? 318 : 273;
1120
1121         if (itv->hw_flags & IVTV_HW_CX25840)
1122                 itv->vbi.sliced_decoder_line_size = itv->is_60hz ? 272 : 284;
1123
1124         /* Tuner */
1125         ivtv_call_all(itv, core, s_std, itv->std);
1126 }
1127
1128 void ivtv_s_std_dec(struct ivtv *itv, v4l2_std_id std)
1129 {
1130         struct yuv_playback_info *yi = &itv->yuv_info;
1131         DEFINE_WAIT(wait);
1132         int f;
1133
1134         /* set display standard */
1135         itv->std_out = std;
1136         itv->is_out_60hz = (std & V4L2_STD_525_60) ? 1 : 0;
1137         itv->is_out_50hz = !itv->is_out_60hz;
1138         ivtv_call_all(itv, video, s_std_output, itv->std_out);
1139
1140         /*
1141          * The next firmware call is time sensitive. Time it to
1142          * avoid risk of a hard lock, by trying to ensure the call
1143          * happens within the first 100 lines of the top field.
1144          * Make 4 attempts to sync to the decoder before giving up.
1145          */
1146         mutex_unlock(&itv->serialize_lock);
1147         for (f = 0; f < 4; f++) {
1148                 prepare_to_wait(&itv->vsync_waitq, &wait,
1149                                 TASK_UNINTERRUPTIBLE);
1150                 if ((read_reg(IVTV_REG_DEC_LINE_FIELD) >> 16) < 100)
1151                         break;
1152                 schedule_timeout(msecs_to_jiffies(25));
1153         }
1154         finish_wait(&itv->vsync_waitq, &wait);
1155         mutex_lock(&itv->serialize_lock);
1156
1157         if (f == 4)
1158                 IVTV_WARN("Mode change failed to sync to decoder\n");
1159
1160         ivtv_vapi(itv, CX2341X_DEC_SET_STANDARD, 1, itv->is_out_50hz);
1161         itv->main_rect.left = 0;
1162         itv->main_rect.top = 0;
1163         itv->main_rect.width = 720;
1164         itv->main_rect.height = itv->is_out_50hz ? 576 : 480;
1165         ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
1166                 720, itv->main_rect.height, 0, 0);
1167         yi->main_rect = itv->main_rect;
1168         if (!itv->osd_info) {
1169                 yi->osd_full_w = 720;
1170                 yi->osd_full_h = itv->is_out_50hz ? 576 : 480;
1171         }
1172 }
1173
1174 static int ivtv_s_std(struct file *file, void *fh, v4l2_std_id std)
1175 {
1176         struct ivtv *itv = fh2id(fh)->itv;
1177
1178         if ((std & V4L2_STD_ALL) == 0)
1179                 return -EINVAL;
1180
1181         if (std == itv->std)
1182                 return 0;
1183
1184         if (test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ||
1185             atomic_read(&itv->capturing) > 0 ||
1186             atomic_read(&itv->decoding) > 0) {
1187                 /* Switching standard would mess with already running
1188                    streams, prevent that by returning EBUSY. */
1189                 return -EBUSY;
1190         }
1191
1192         IVTV_DEBUG_INFO("Switching standard to %llx.\n",
1193                 (unsigned long long)itv->std);
1194
1195         ivtv_s_std_enc(itv, std);
1196         if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)
1197                 ivtv_s_std_dec(itv, std);
1198
1199         return 0;
1200 }
1201
1202 static int ivtv_s_tuner(struct file *file, void *fh, const struct v4l2_tuner *vt)
1203 {
1204         struct ivtv_open_id *id = fh2id(fh);
1205         struct ivtv *itv = id->itv;
1206
1207         if (vt->index != 0)
1208                 return -EINVAL;
1209
1210         ivtv_call_all(itv, tuner, s_tuner, vt);
1211
1212         return 0;
1213 }
1214
1215 static int ivtv_g_tuner(struct file *file, void *fh, struct v4l2_tuner *vt)
1216 {
1217         struct ivtv *itv = fh2id(fh)->itv;
1218
1219         if (vt->index != 0)
1220                 return -EINVAL;
1221
1222         ivtv_call_all(itv, tuner, g_tuner, vt);
1223
1224         if (vt->type == V4L2_TUNER_RADIO)
1225                 strlcpy(vt->name, "ivtv Radio Tuner", sizeof(vt->name));
1226         else
1227                 strlcpy(vt->name, "ivtv TV Tuner", sizeof(vt->name));
1228         return 0;
1229 }
1230
1231 static int ivtv_g_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_sliced_vbi_cap *cap)
1232 {
1233         struct ivtv *itv = fh2id(fh)->itv;
1234         int set = itv->is_50hz ? V4L2_SLICED_VBI_625 : V4L2_SLICED_VBI_525;
1235         int f, l;
1236
1237         if (cap->type == V4L2_BUF_TYPE_SLICED_VBI_CAPTURE) {
1238                 for (f = 0; f < 2; f++) {
1239                         for (l = 0; l < 24; l++) {
1240                                 if (valid_service_line(f, l, itv->is_50hz))
1241                                         cap->service_lines[f][l] = set;
1242                         }
1243                 }
1244         } else if (cap->type == V4L2_BUF_TYPE_SLICED_VBI_OUTPUT) {
1245                 if (!(itv->v4l2_cap & V4L2_CAP_SLICED_VBI_OUTPUT))
1246                         return -EINVAL;
1247                 if (itv->is_60hz) {
1248                         cap->service_lines[0][21] = V4L2_SLICED_CAPTION_525;
1249                         cap->service_lines[1][21] = V4L2_SLICED_CAPTION_525;
1250                 } else {
1251                         cap->service_lines[0][23] = V4L2_SLICED_WSS_625;
1252                         cap->service_lines[0][16] = V4L2_SLICED_VPS;
1253                 }
1254         } else {
1255                 return -EINVAL;
1256         }
1257
1258         set = 0;
1259         for (f = 0; f < 2; f++)
1260                 for (l = 0; l < 24; l++)
1261                         set |= cap->service_lines[f][l];
1262         cap->service_set = set;
1263         return 0;
1264 }
1265
1266 static int ivtv_g_enc_index(struct file *file, void *fh, struct v4l2_enc_idx *idx)
1267 {
1268         struct ivtv *itv = fh2id(fh)->itv;
1269         struct v4l2_enc_idx_entry *e = idx->entry;
1270         int entries;
1271         int i;
1272
1273         entries = (itv->pgm_info_write_idx + IVTV_MAX_PGM_INDEX - itv->pgm_info_read_idx) %
1274                                 IVTV_MAX_PGM_INDEX;
1275         if (entries > V4L2_ENC_IDX_ENTRIES)
1276                 entries = V4L2_ENC_IDX_ENTRIES;
1277         idx->entries = 0;
1278         idx->entries_cap = IVTV_MAX_PGM_INDEX;
1279         if (!atomic_read(&itv->capturing))
1280                 return 0;
1281         for (i = 0; i < entries; i++) {
1282                 *e = itv->pgm_info[(itv->pgm_info_read_idx + i) % IVTV_MAX_PGM_INDEX];
1283                 if ((e->flags & V4L2_ENC_IDX_FRAME_MASK) <= V4L2_ENC_IDX_FRAME_B) {
1284                         idx->entries++;
1285                         e++;
1286                 }
1287         }
1288         itv->pgm_info_read_idx = (itv->pgm_info_read_idx + idx->entries) % IVTV_MAX_PGM_INDEX;
1289         return 0;
1290 }
1291
1292 static int ivtv_encoder_cmd(struct file *file, void *fh, struct v4l2_encoder_cmd *enc)
1293 {
1294         struct ivtv_open_id *id = fh2id(fh);
1295         struct ivtv *itv = id->itv;
1296
1297
1298         switch (enc->cmd) {
1299         case V4L2_ENC_CMD_START:
1300                 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
1301                 enc->flags = 0;
1302                 return ivtv_start_capture(id);
1303
1304         case V4L2_ENC_CMD_STOP:
1305                 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
1306                 enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END;
1307                 ivtv_stop_capture(id, enc->flags & V4L2_ENC_CMD_STOP_AT_GOP_END);
1308                 return 0;
1309
1310         case V4L2_ENC_CMD_PAUSE:
1311                 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
1312                 enc->flags = 0;
1313
1314                 if (!atomic_read(&itv->capturing))
1315                         return -EPERM;
1316                 if (test_and_set_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags))
1317                         return 0;
1318
1319                 ivtv_mute(itv);
1320                 ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 0);
1321                 break;
1322
1323         case V4L2_ENC_CMD_RESUME:
1324                 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
1325                 enc->flags = 0;
1326
1327                 if (!atomic_read(&itv->capturing))
1328                         return -EPERM;
1329
1330                 if (!test_and_clear_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags))
1331                         return 0;
1332
1333                 ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 1);
1334                 ivtv_unmute(itv);
1335                 break;
1336         default:
1337                 IVTV_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd);
1338                 return -EINVAL;
1339         }
1340
1341         return 0;
1342 }
1343
1344 static int ivtv_try_encoder_cmd(struct file *file, void *fh, struct v4l2_encoder_cmd *enc)
1345 {
1346         struct ivtv *itv = fh2id(fh)->itv;
1347
1348         switch (enc->cmd) {
1349         case V4L2_ENC_CMD_START:
1350                 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
1351                 enc->flags = 0;
1352                 return 0;
1353
1354         case V4L2_ENC_CMD_STOP:
1355                 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
1356                 enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END;
1357                 return 0;
1358
1359         case V4L2_ENC_CMD_PAUSE:
1360                 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
1361                 enc->flags = 0;
1362                 return 0;
1363
1364         case V4L2_ENC_CMD_RESUME:
1365                 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
1366                 enc->flags = 0;
1367                 return 0;
1368         default:
1369                 IVTV_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd);
1370                 return -EINVAL;
1371         }
1372 }
1373
1374 static int ivtv_g_fbuf(struct file *file, void *fh, struct v4l2_framebuffer *fb)
1375 {
1376         struct ivtv *itv = fh2id(fh)->itv;
1377         u32 data[CX2341X_MBOX_MAX_DATA];
1378         struct yuv_playback_info *yi = &itv->yuv_info;
1379
1380         int pixfmt;
1381         static u32 pixel_format[16] = {
1382                 V4L2_PIX_FMT_PAL8, /* Uses a 256-entry RGB colormap */
1383                 V4L2_PIX_FMT_RGB565,
1384                 V4L2_PIX_FMT_RGB555,
1385                 V4L2_PIX_FMT_RGB444,
1386                 V4L2_PIX_FMT_RGB32,
1387                 0,
1388                 0,
1389                 0,
1390                 V4L2_PIX_FMT_PAL8, /* Uses a 256-entry YUV colormap */
1391                 V4L2_PIX_FMT_YUV565,
1392                 V4L2_PIX_FMT_YUV555,
1393                 V4L2_PIX_FMT_YUV444,
1394                 V4L2_PIX_FMT_YUV32,
1395                 0,
1396                 0,
1397                 0,
1398         };
1399
1400         if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1401                 return -EINVAL;
1402         if (!itv->osd_video_pbase)
1403                 return -EINVAL;
1404
1405         fb->capability = V4L2_FBUF_CAP_EXTERNOVERLAY | V4L2_FBUF_CAP_CHROMAKEY |
1406                 V4L2_FBUF_CAP_GLOBAL_ALPHA;
1407
1408         ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0);
1409         data[0] |= (read_reg(0x2a00) >> 7) & 0x40;
1410         pixfmt = (data[0] >> 3) & 0xf;
1411
1412         fb->fmt.pixelformat = pixel_format[pixfmt];
1413         fb->fmt.width = itv->osd_rect.width;
1414         fb->fmt.height = itv->osd_rect.height;
1415         fb->fmt.field = V4L2_FIELD_INTERLACED;
1416         fb->fmt.bytesperline = fb->fmt.width;
1417         fb->fmt.colorspace = V4L2_COLORSPACE_SMPTE170M;
1418         fb->fmt.field = V4L2_FIELD_INTERLACED;
1419         fb->fmt.priv = 0;
1420         if (fb->fmt.pixelformat != V4L2_PIX_FMT_PAL8)
1421                 fb->fmt.bytesperline *= 2;
1422         if (fb->fmt.pixelformat == V4L2_PIX_FMT_RGB32 ||
1423             fb->fmt.pixelformat == V4L2_PIX_FMT_YUV32)
1424                 fb->fmt.bytesperline *= 2;
1425         fb->fmt.sizeimage = fb->fmt.bytesperline * fb->fmt.height;
1426         fb->base = (void *)itv->osd_video_pbase;
1427         fb->flags = 0;
1428
1429         if (itv->osd_chroma_key_state)
1430                 fb->flags |= V4L2_FBUF_FLAG_CHROMAKEY;
1431
1432         if (itv->osd_global_alpha_state)
1433                 fb->flags |= V4L2_FBUF_FLAG_GLOBAL_ALPHA;
1434
1435         if (yi->track_osd)
1436                 fb->flags |= V4L2_FBUF_FLAG_OVERLAY;
1437
1438         pixfmt &= 7;
1439
1440         /* no local alpha for RGB565 or unknown formats */
1441         if (pixfmt == 1 || pixfmt > 4)
1442                 return 0;
1443
1444         /* 16-bit formats have inverted local alpha */
1445         if (pixfmt == 2 || pixfmt == 3)
1446                 fb->capability |= V4L2_FBUF_CAP_LOCAL_INV_ALPHA;
1447         else
1448                 fb->capability |= V4L2_FBUF_CAP_LOCAL_ALPHA;
1449
1450         if (itv->osd_local_alpha_state) {
1451                 /* 16-bit formats have inverted local alpha */
1452                 if (pixfmt == 2 || pixfmt == 3)
1453                         fb->flags |= V4L2_FBUF_FLAG_LOCAL_INV_ALPHA;
1454                 else
1455                         fb->flags |= V4L2_FBUF_FLAG_LOCAL_ALPHA;
1456         }
1457
1458         return 0;
1459 }
1460
1461 static int ivtv_s_fbuf(struct file *file, void *fh, const struct v4l2_framebuffer *fb)
1462 {
1463         struct ivtv_open_id *id = fh2id(fh);
1464         struct ivtv *itv = id->itv;
1465         struct yuv_playback_info *yi = &itv->yuv_info;
1466
1467         if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1468                 return -EINVAL;
1469         if (!itv->osd_video_pbase)
1470                 return -EINVAL;
1471
1472         itv->osd_global_alpha_state = (fb->flags & V4L2_FBUF_FLAG_GLOBAL_ALPHA) != 0;
1473         itv->osd_local_alpha_state =
1474                 (fb->flags & (V4L2_FBUF_FLAG_LOCAL_ALPHA|V4L2_FBUF_FLAG_LOCAL_INV_ALPHA)) != 0;
1475         itv->osd_chroma_key_state = (fb->flags & V4L2_FBUF_FLAG_CHROMAKEY) != 0;
1476         ivtv_set_osd_alpha(itv);
1477         yi->track_osd = (fb->flags & V4L2_FBUF_FLAG_OVERLAY) != 0;
1478         return 0;
1479 }
1480
1481 static int ivtv_overlay(struct file *file, void *fh, unsigned int on)
1482 {
1483         struct ivtv_open_id *id = fh2id(fh);
1484         struct ivtv *itv = id->itv;
1485
1486         if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1487                 return -EINVAL;
1488
1489         ivtv_vapi(itv, CX2341X_OSD_SET_STATE, 1, on != 0);
1490
1491         return 0;
1492 }
1493
1494 static int ivtv_subscribe_event(struct v4l2_fh *fh, const struct v4l2_event_subscription *sub)
1495 {
1496         switch (sub->type) {
1497         case V4L2_EVENT_VSYNC:
1498         case V4L2_EVENT_EOS:
1499                 return v4l2_event_subscribe(fh, sub, 0, NULL);
1500         case V4L2_EVENT_CTRL:
1501                 return v4l2_event_subscribe(fh, sub, 0, &v4l2_ctrl_sub_ev_ops);
1502         default:
1503                 return -EINVAL;
1504         }
1505 }
1506
1507 static int ivtv_log_status(struct file *file, void *fh)
1508 {
1509         struct ivtv *itv = fh2id(fh)->itv;
1510         u32 data[CX2341X_MBOX_MAX_DATA];
1511
1512         int has_output = itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT;
1513         struct v4l2_input vidin;
1514         struct v4l2_audio audin;
1515         int i;
1516
1517         IVTV_INFO("Version: %s Card: %s\n", IVTV_VERSION, itv->card_name);
1518         if (itv->hw_flags & IVTV_HW_TVEEPROM) {
1519                 struct tveeprom tv;
1520
1521                 ivtv_read_eeprom(itv, &tv);
1522         }
1523         ivtv_call_all(itv, core, log_status);
1524         ivtv_get_input(itv, itv->active_input, &vidin);
1525         ivtv_get_audio_input(itv, itv->audio_input, &audin);
1526         IVTV_INFO("Video Input:  %s\n", vidin.name);
1527         IVTV_INFO("Audio Input:  %s%s\n", audin.name,
1528                 (itv->dualwatch_stereo_mode & ~0x300) == 0x200 ? " (Bilingual)" : "");
1529         if (has_output) {
1530                 struct v4l2_output vidout;
1531                 struct v4l2_audioout audout;
1532                 int mode = itv->output_mode;
1533                 static const char * const output_modes[5] = {
1534                         "None",
1535                         "MPEG Streaming",
1536                         "YUV Streaming",
1537                         "YUV Frames",
1538                         "Passthrough",
1539                 };
1540                 static const char * const alpha_mode[4] = {
1541                         "None",
1542                         "Global",
1543                         "Local",
1544                         "Global and Local"
1545                 };
1546                 static const char * const pixel_format[16] = {
1547                         "ARGB Indexed",
1548                         "RGB 5:6:5",
1549                         "ARGB 1:5:5:5",
1550                         "ARGB 1:4:4:4",
1551                         "ARGB 8:8:8:8",
1552                         "5",
1553                         "6",
1554                         "7",
1555                         "AYUV Indexed",
1556                         "YUV 5:6:5",
1557                         "AYUV 1:5:5:5",
1558                         "AYUV 1:4:4:4",
1559                         "AYUV 8:8:8:8",
1560                         "13",
1561                         "14",
1562                         "15",
1563                 };
1564
1565                 ivtv_get_output(itv, itv->active_output, &vidout);
1566                 ivtv_get_audio_output(itv, 0, &audout);
1567                 IVTV_INFO("Video Output: %s\n", vidout.name);
1568                 if (mode < 0 || mode > OUT_PASSTHROUGH)
1569                         mode = OUT_NONE;
1570                 IVTV_INFO("Output Mode:  %s\n", output_modes[mode]);
1571                 ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0);
1572                 data[0] |= (read_reg(0x2a00) >> 7) & 0x40;
1573                 IVTV_INFO("Overlay:      %s, Alpha: %s, Pixel Format: %s\n",
1574                         data[0] & 1 ? "On" : "Off",
1575                         alpha_mode[(data[0] >> 1) & 0x3],
1576                         pixel_format[(data[0] >> 3) & 0xf]);
1577         }
1578         IVTV_INFO("Tuner:  %s\n",
1579                 test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ? "Radio" : "TV");
1580         v4l2_ctrl_handler_log_status(&itv->cxhdl.hdl, itv->v4l2_dev.name);
1581         IVTV_INFO("Status flags:    0x%08lx\n", itv->i_flags);
1582         for (i = 0; i < IVTV_MAX_STREAMS; i++) {
1583                 struct ivtv_stream *s = &itv->streams[i];
1584
1585                 if (s->vdev == NULL || s->buffers == 0)
1586                         continue;
1587                 IVTV_INFO("Stream %s: status 0x%04lx, %d%% of %d KiB (%d buffers) in use\n", s->name, s->s_flags,
1588                                 (s->buffers - s->q_free.buffers) * 100 / s->buffers,
1589                                 (s->buffers * s->buf_size) / 1024, s->buffers);
1590         }
1591
1592         IVTV_INFO("Read MPG/VBI: %lld/%lld bytes\n",
1593                         (long long)itv->mpg_data_received,
1594                         (long long)itv->vbi_data_inserted);
1595         return 0;
1596 }
1597
1598 static int ivtv_decoder_cmd(struct file *file, void *fh, struct v4l2_decoder_cmd *dec)
1599 {
1600         struct ivtv_open_id *id = fh2id(file->private_data);
1601         struct ivtv *itv = id->itv;
1602
1603         IVTV_DEBUG_IOCTL("VIDIOC_DECODER_CMD %d\n", dec->cmd);
1604         return ivtv_video_command(itv, id, dec, false);
1605 }
1606
1607 static int ivtv_try_decoder_cmd(struct file *file, void *fh, struct v4l2_decoder_cmd *dec)
1608 {
1609         struct ivtv_open_id *id = fh2id(file->private_data);
1610         struct ivtv *itv = id->itv;
1611
1612         IVTV_DEBUG_IOCTL("VIDIOC_TRY_DECODER_CMD %d\n", dec->cmd);
1613         return ivtv_video_command(itv, id, dec, true);
1614 }
1615
1616 static int ivtv_decoder_ioctls(struct file *filp, unsigned int cmd, void *arg)
1617 {
1618         struct ivtv_open_id *id = fh2id(filp->private_data);
1619         struct ivtv *itv = id->itv;
1620         int nonblocking = filp->f_flags & O_NONBLOCK;
1621         struct ivtv_stream *s = &itv->streams[id->type];
1622         unsigned long iarg = (unsigned long)arg;
1623
1624         switch (cmd) {
1625         case IVTV_IOC_DMA_FRAME: {
1626                 struct ivtv_dma_frame *args = arg;
1627
1628                 IVTV_DEBUG_IOCTL("IVTV_IOC_DMA_FRAME\n");
1629                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1630                         return -EINVAL;
1631                 if (args->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
1632                         return -EINVAL;
1633                 if (itv->output_mode == OUT_UDMA_YUV && args->y_source == NULL)
1634                         return 0;
1635                 if (ivtv_start_decoding(id, id->type)) {
1636                         return -EBUSY;
1637                 }
1638                 if (ivtv_set_output_mode(itv, OUT_UDMA_YUV) != OUT_UDMA_YUV) {
1639                         ivtv_release_stream(s);
1640                         return -EBUSY;
1641                 }
1642                 /* Mark that this file handle started the UDMA_YUV mode */
1643                 id->yuv_frames = 1;
1644                 if (args->y_source == NULL)
1645                         return 0;
1646                 return ivtv_yuv_prep_frame(itv, args);
1647         }
1648
1649         case IVTV_IOC_PASSTHROUGH_MODE:
1650                 IVTV_DEBUG_IOCTL("IVTV_IOC_PASSTHROUGH_MODE\n");
1651                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1652                         return -EINVAL;
1653                 return ivtv_passthrough_mode(itv, *(int *)arg != 0);
1654
1655         case VIDEO_GET_PTS: {
1656                 s64 *pts = arg;
1657                 s64 frame;
1658
1659                 IVTV_DEBUG_IOCTL("VIDEO_GET_PTS\n");
1660                 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) {
1661                         *pts = s->dma_pts;
1662                         break;
1663                 }
1664                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1665                         return -EINVAL;
1666                 return ivtv_g_pts_frame(itv, pts, &frame);
1667         }
1668
1669         case VIDEO_GET_FRAME_COUNT: {
1670                 s64 *frame = arg;
1671                 s64 pts;
1672
1673                 IVTV_DEBUG_IOCTL("VIDEO_GET_FRAME_COUNT\n");
1674                 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) {
1675                         *frame = 0;
1676                         break;
1677                 }
1678                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1679                         return -EINVAL;
1680                 return ivtv_g_pts_frame(itv, &pts, frame);
1681         }
1682
1683         case VIDEO_PLAY: {
1684                 struct v4l2_decoder_cmd dc;
1685
1686                 IVTV_DEBUG_IOCTL("VIDEO_PLAY\n");
1687                 memset(&dc, 0, sizeof(dc));
1688                 dc.cmd = V4L2_DEC_CMD_START;
1689                 return ivtv_video_command(itv, id, &dc, 0);
1690         }
1691
1692         case VIDEO_STOP: {
1693                 struct v4l2_decoder_cmd dc;
1694
1695                 IVTV_DEBUG_IOCTL("VIDEO_STOP\n");
1696                 memset(&dc, 0, sizeof(dc));
1697                 dc.cmd = V4L2_DEC_CMD_STOP;
1698                 dc.flags = V4L2_DEC_CMD_STOP_TO_BLACK | V4L2_DEC_CMD_STOP_IMMEDIATELY;
1699                 return ivtv_video_command(itv, id, &dc, 0);
1700         }
1701
1702         case VIDEO_FREEZE: {
1703                 struct v4l2_decoder_cmd dc;
1704
1705                 IVTV_DEBUG_IOCTL("VIDEO_FREEZE\n");
1706                 memset(&dc, 0, sizeof(dc));
1707                 dc.cmd = V4L2_DEC_CMD_PAUSE;
1708                 return ivtv_video_command(itv, id, &dc, 0);
1709         }
1710
1711         case VIDEO_CONTINUE: {
1712                 struct v4l2_decoder_cmd dc;
1713
1714                 IVTV_DEBUG_IOCTL("VIDEO_CONTINUE\n");
1715                 memset(&dc, 0, sizeof(dc));
1716                 dc.cmd = V4L2_DEC_CMD_RESUME;
1717                 return ivtv_video_command(itv, id, &dc, 0);
1718         }
1719
1720         case VIDEO_COMMAND:
1721         case VIDEO_TRY_COMMAND: {
1722                 /* Note: struct v4l2_decoder_cmd has the same layout as
1723                    struct video_command */
1724                 struct v4l2_decoder_cmd *dc = arg;
1725                 int try = (cmd == VIDEO_TRY_COMMAND);
1726
1727                 if (try)
1728                         IVTV_DEBUG_IOCTL("VIDEO_TRY_COMMAND %d\n", dc->cmd);
1729                 else
1730                         IVTV_DEBUG_IOCTL("VIDEO_COMMAND %d\n", dc->cmd);
1731                 return ivtv_video_command(itv, id, dc, try);
1732         }
1733
1734         case VIDEO_GET_EVENT: {
1735                 struct video_event *ev = arg;
1736                 DEFINE_WAIT(wait);
1737
1738                 IVTV_DEBUG_IOCTL("VIDEO_GET_EVENT\n");
1739                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1740                         return -EINVAL;
1741                 memset(ev, 0, sizeof(*ev));
1742                 set_bit(IVTV_F_I_EV_VSYNC_ENABLED, &itv->i_flags);
1743
1744                 while (1) {
1745                         if (test_and_clear_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags))
1746                                 ev->type = VIDEO_EVENT_DECODER_STOPPED;
1747                         else if (test_and_clear_bit(IVTV_F_I_EV_VSYNC, &itv->i_flags)) {
1748                                 ev->type = VIDEO_EVENT_VSYNC;
1749                                 ev->u.vsync_field = test_bit(IVTV_F_I_EV_VSYNC_FIELD, &itv->i_flags) ?
1750                                         VIDEO_VSYNC_FIELD_ODD : VIDEO_VSYNC_FIELD_EVEN;
1751                                 if (itv->output_mode == OUT_UDMA_YUV &&
1752                                         (itv->yuv_info.lace_mode & IVTV_YUV_MODE_MASK) ==
1753                                                                 IVTV_YUV_MODE_PROGRESSIVE) {
1754                                         ev->u.vsync_field = VIDEO_VSYNC_FIELD_PROGRESSIVE;
1755                                 }
1756                         }
1757                         if (ev->type)
1758                                 return 0;
1759                         if (nonblocking)
1760                                 return -EAGAIN;
1761                         /* Wait for event. Note that serialize_lock is locked,
1762                            so to allow other processes to access the driver while
1763                            we are waiting unlock first and later lock again. */
1764                         mutex_unlock(&itv->serialize_lock);
1765                         prepare_to_wait(&itv->event_waitq, &wait, TASK_INTERRUPTIBLE);
1766                         if (!test_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags) &&
1767                             !test_bit(IVTV_F_I_EV_VSYNC, &itv->i_flags))
1768                                 schedule();
1769                         finish_wait(&itv->event_waitq, &wait);
1770                         mutex_lock(&itv->serialize_lock);
1771                         if (signal_pending(current)) {
1772                                 /* return if a signal was received */
1773                                 IVTV_DEBUG_INFO("User stopped wait for event\n");
1774                                 return -EINTR;
1775                         }
1776                 }
1777                 break;
1778         }
1779
1780         case VIDEO_SELECT_SOURCE:
1781                 IVTV_DEBUG_IOCTL("VIDEO_SELECT_SOURCE\n");
1782                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1783                         return -EINVAL;
1784                 return ivtv_passthrough_mode(itv, iarg == VIDEO_SOURCE_DEMUX);
1785
1786         case AUDIO_SET_MUTE:
1787                 IVTV_DEBUG_IOCTL("AUDIO_SET_MUTE\n");
1788                 itv->speed_mute_audio = iarg;
1789                 return 0;
1790
1791         case AUDIO_CHANNEL_SELECT:
1792                 IVTV_DEBUG_IOCTL("AUDIO_CHANNEL_SELECT\n");
1793                 if (iarg > AUDIO_STEREO_SWAPPED)
1794                         return -EINVAL;
1795                 return v4l2_ctrl_s_ctrl(itv->ctrl_audio_playback, iarg + 1);
1796
1797         case AUDIO_BILINGUAL_CHANNEL_SELECT:
1798                 IVTV_DEBUG_IOCTL("AUDIO_BILINGUAL_CHANNEL_SELECT\n");
1799                 if (iarg > AUDIO_STEREO_SWAPPED)
1800                         return -EINVAL;
1801                 return v4l2_ctrl_s_ctrl(itv->ctrl_audio_multilingual_playback, iarg + 1);
1802
1803         default:
1804                 return -EINVAL;
1805         }
1806         return 0;
1807 }
1808
1809 static long ivtv_default(struct file *file, void *fh, bool valid_prio,
1810                          unsigned int cmd, void *arg)
1811 {
1812         struct ivtv *itv = fh2id(fh)->itv;
1813
1814         if (!valid_prio) {
1815                 switch (cmd) {
1816                 case IVTV_IOC_PASSTHROUGH_MODE:
1817                 case VIDEO_PLAY:
1818                 case VIDEO_STOP:
1819                 case VIDEO_FREEZE:
1820                 case VIDEO_CONTINUE:
1821                 case VIDEO_COMMAND:
1822                 case VIDEO_SELECT_SOURCE:
1823                 case AUDIO_SET_MUTE:
1824                 case AUDIO_CHANNEL_SELECT:
1825                 case AUDIO_BILINGUAL_CHANNEL_SELECT:
1826                         return -EBUSY;
1827                 }
1828         }
1829
1830         switch (cmd) {
1831         case VIDIOC_INT_RESET: {
1832                 u32 val = *(u32 *)arg;
1833
1834                 if ((val == 0 && itv->options.newi2c) || (val & 0x01))
1835                         ivtv_reset_ir_gpio(itv);
1836                 if (val & 0x02)
1837                         v4l2_subdev_call(itv->sd_video, core, reset, 0);
1838                 break;
1839         }
1840
1841         case IVTV_IOC_DMA_FRAME:
1842         case IVTV_IOC_PASSTHROUGH_MODE:
1843         case VIDEO_GET_PTS:
1844         case VIDEO_GET_FRAME_COUNT:
1845         case VIDEO_GET_EVENT:
1846         case VIDEO_PLAY:
1847         case VIDEO_STOP:
1848         case VIDEO_FREEZE:
1849         case VIDEO_CONTINUE:
1850         case VIDEO_COMMAND:
1851         case VIDEO_TRY_COMMAND:
1852         case VIDEO_SELECT_SOURCE:
1853         case AUDIO_SET_MUTE:
1854         case AUDIO_CHANNEL_SELECT:
1855         case AUDIO_BILINGUAL_CHANNEL_SELECT:
1856                 return ivtv_decoder_ioctls(file, cmd, (void *)arg);
1857
1858         default:
1859                 return -ENOTTY;
1860         }
1861         return 0;
1862 }
1863
1864 static const struct v4l2_ioctl_ops ivtv_ioctl_ops = {
1865         .vidioc_querycap                    = ivtv_querycap,
1866         .vidioc_s_audio                     = ivtv_s_audio,
1867         .vidioc_g_audio                     = ivtv_g_audio,
1868         .vidioc_enumaudio                   = ivtv_enumaudio,
1869         .vidioc_s_audout                    = ivtv_s_audout,
1870         .vidioc_g_audout                    = ivtv_g_audout,
1871         .vidioc_enum_input                  = ivtv_enum_input,
1872         .vidioc_enum_output                 = ivtv_enum_output,
1873         .vidioc_enumaudout                  = ivtv_enumaudout,
1874         .vidioc_cropcap                     = ivtv_cropcap,
1875         .vidioc_s_crop                      = ivtv_s_crop,
1876         .vidioc_g_crop                      = ivtv_g_crop,
1877         .vidioc_g_input                     = ivtv_g_input,
1878         .vidioc_s_input                     = ivtv_s_input,
1879         .vidioc_g_output                    = ivtv_g_output,
1880         .vidioc_s_output                    = ivtv_s_output,
1881         .vidioc_g_frequency                 = ivtv_g_frequency,
1882         .vidioc_s_frequency                 = ivtv_s_frequency,
1883         .vidioc_s_tuner                     = ivtv_s_tuner,
1884         .vidioc_g_tuner                     = ivtv_g_tuner,
1885         .vidioc_g_enc_index                 = ivtv_g_enc_index,
1886         .vidioc_g_fbuf                      = ivtv_g_fbuf,
1887         .vidioc_s_fbuf                      = ivtv_s_fbuf,
1888         .vidioc_g_std                       = ivtv_g_std,
1889         .vidioc_s_std                       = ivtv_s_std,
1890         .vidioc_overlay                     = ivtv_overlay,
1891         .vidioc_log_status                  = ivtv_log_status,
1892         .vidioc_enum_fmt_vid_cap            = ivtv_enum_fmt_vid_cap,
1893         .vidioc_encoder_cmd                 = ivtv_encoder_cmd,
1894         .vidioc_try_encoder_cmd             = ivtv_try_encoder_cmd,
1895         .vidioc_decoder_cmd                 = ivtv_decoder_cmd,
1896         .vidioc_try_decoder_cmd             = ivtv_try_decoder_cmd,
1897         .vidioc_enum_fmt_vid_out            = ivtv_enum_fmt_vid_out,
1898         .vidioc_g_fmt_vid_cap               = ivtv_g_fmt_vid_cap,
1899         .vidioc_g_fmt_vbi_cap               = ivtv_g_fmt_vbi_cap,
1900         .vidioc_g_fmt_sliced_vbi_cap        = ivtv_g_fmt_sliced_vbi_cap,
1901         .vidioc_g_fmt_vid_out               = ivtv_g_fmt_vid_out,
1902         .vidioc_g_fmt_vid_out_overlay       = ivtv_g_fmt_vid_out_overlay,
1903         .vidioc_g_fmt_sliced_vbi_out        = ivtv_g_fmt_sliced_vbi_out,
1904         .vidioc_s_fmt_vid_cap               = ivtv_s_fmt_vid_cap,
1905         .vidioc_s_fmt_vbi_cap               = ivtv_s_fmt_vbi_cap,
1906         .vidioc_s_fmt_sliced_vbi_cap        = ivtv_s_fmt_sliced_vbi_cap,
1907         .vidioc_s_fmt_vid_out               = ivtv_s_fmt_vid_out,
1908         .vidioc_s_fmt_vid_out_overlay       = ivtv_s_fmt_vid_out_overlay,
1909         .vidioc_s_fmt_sliced_vbi_out        = ivtv_s_fmt_sliced_vbi_out,
1910         .vidioc_try_fmt_vid_cap             = ivtv_try_fmt_vid_cap,
1911         .vidioc_try_fmt_vbi_cap             = ivtv_try_fmt_vbi_cap,
1912         .vidioc_try_fmt_sliced_vbi_cap      = ivtv_try_fmt_sliced_vbi_cap,
1913         .vidioc_try_fmt_vid_out             = ivtv_try_fmt_vid_out,
1914         .vidioc_try_fmt_vid_out_overlay     = ivtv_try_fmt_vid_out_overlay,
1915         .vidioc_try_fmt_sliced_vbi_out      = ivtv_try_fmt_sliced_vbi_out,
1916         .vidioc_g_sliced_vbi_cap            = ivtv_g_sliced_vbi_cap,
1917         .vidioc_g_chip_ident                = ivtv_g_chip_ident,
1918 #ifdef CONFIG_VIDEO_ADV_DEBUG
1919         .vidioc_g_register                  = ivtv_g_register,
1920         .vidioc_s_register                  = ivtv_s_register,
1921 #endif
1922         .vidioc_default                     = ivtv_default,
1923         .vidioc_subscribe_event             = ivtv_subscribe_event,
1924         .vidioc_unsubscribe_event           = v4l2_event_unsubscribe,
1925 };
1926
1927 void ivtv_set_funcs(struct video_device *vdev)
1928 {
1929         vdev->ioctl_ops = &ivtv_ioctl_ops;
1930 }