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