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, unsigned int cmd, void *arg)
 715 {
 716         struct v4l2_dbg_register *regs = arg;
 717         volatile u8 __iomem *reg_start;
 718
 719         if (!capable(CAP_SYS_ADMIN))
 720                 return -EPERM;
 721         if (regs->reg >= IVTV_REG_OFFSET && regs->reg < IVTV_REG_OFFSET + IVTV_REG_SIZE)
 722                 reg_start = itv->reg_mem - IVTV_REG_OFFSET;
 723         else if (itv->has_cx23415 && regs->reg >= IVTV_DECODER_OFFSET &&
 724                         regs->reg < IVTV_DECODER_OFFSET + IVTV_DECODER_SIZE)
 725                 reg_start = itv->dec_mem - IVTV_DECODER_OFFSET;
 726         else if (regs->reg < IVTV_ENCODER_SIZE)
 727                 reg_start = itv->enc_mem;
 728         else
 729                 return -EINVAL;
 730
 731         regs->size = 4;
 732         if (cmd == VIDIOC_DBG_G_REGISTER)
 733                 regs->val = readl(regs->reg + reg_start);
 734         else
 735                 writel(regs->val, regs->reg + reg_start);
 736         return 0;
 737 }
 738
 739 static int ivtv_g_register(struct file *file, void *fh, struct v4l2_dbg_register *reg)
 740 {
 741         struct ivtv *itv = fh2id(fh)->itv;
 742
 743         if (v4l2_chip_match_host(&reg->match))
 744                 return ivtv_itvc(itv, VIDIOC_DBG_G_REGISTER, reg);
 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, struct v4l2_dbg_register *reg)
 752 {
 753         struct ivtv *itv = fh2id(fh)->itv;
 754
 755         if (v4l2_chip_match_host(&reg->match))
 756                 return ivtv_itvc(itv, VIDIOC_DBG_S_REGISTER, reg);
 757         /* TODO: subdev errors should not be ignored, this should become a
 758            subdev helper function. */
 759         ivtv_call_all(itv, core, s_register, reg);
 760         return 0;
 761 }
 762 #endif
 763
 764 static int ivtv_querycap(struct file *file, void *fh, struct v4l2_capability *vcap)
 765 {
 766         struct ivtv_open_id *id = fh2id(file->private_data);
 767         struct ivtv *itv = id->itv;
 768         struct ivtv_stream *s = &itv->streams[id->type];
 769
 770         strlcpy(vcap->driver, IVTV_DRIVER_NAME, sizeof(vcap->driver));
 771         strlcpy(vcap->card, itv->card_name, sizeof(vcap->card));
 772         snprintf(vcap->bus_info, sizeof(vcap->bus_info), "PCI:%s", pci_name(itv->pdev));
 773         vcap->capabilities = itv->v4l2_cap | V4L2_CAP_DEVICE_CAPS;
 774         vcap->device_caps = s->caps;
 775         return 0;
 776 }
 777
 778 static int ivtv_enumaudio(struct file *file, void *fh, struct v4l2_audio *vin)
 779 {
 780         struct ivtv *itv = fh2id(fh)->itv;
 781
 782         return ivtv_get_audio_input(itv, vin->index, vin);
 783 }
 784
 785 static int ivtv_g_audio(struct file *file, void *fh, struct v4l2_audio *vin)
 786 {
 787         struct ivtv *itv = fh2id(fh)->itv;
 788
 789         vin->index = itv->audio_input;
 790         return ivtv_get_audio_input(itv, vin->index, vin);
 791 }
 792
 793 static int ivtv_s_audio(struct file *file, void *fh, const struct v4l2_audio *vout)
 794 {
 795         struct ivtv *itv = fh2id(fh)->itv;
 796
 797         if (vout->index >= itv->nof_audio_inputs)
 798                 return -EINVAL;
 799
 800         itv->audio_input = vout->index;
 801         ivtv_audio_set_io(itv);
 802
 803         return 0;
 804 }
 805
 806 static int ivtv_enumaudout(struct file *file, void *fh, struct v4l2_audioout *vin)
 807 {
 808         struct ivtv *itv = fh2id(fh)->itv;
 809
 810         /* set it to defaults from our table */
 811         return ivtv_get_audio_output(itv, vin->index, vin);
 812 }
 813
 814 static int ivtv_g_audout(struct file *file, void *fh, struct v4l2_audioout *vin)
 815 {
 816         struct ivtv *itv = fh2id(fh)->itv;
 817
 818         vin->index = 0;
 819         return ivtv_get_audio_output(itv, vin->index, vin);
 820 }
 821
 822 static int ivtv_s_audout(struct file *file, void *fh, const struct v4l2_audioout *vout)
 823 {
 824         struct ivtv *itv = fh2id(fh)->itv;
 825
 826         if (itv->card->video_outputs == NULL || vout->index != 0)
 827                 return -EINVAL;
 828         return 0;
 829 }
 830
 831 static int ivtv_enum_input(struct file *file, void *fh, struct v4l2_input *vin)
 832 {
 833         struct ivtv *itv = fh2id(fh)->itv;
 834
 835         /* set it to defaults from our table */
 836         return ivtv_get_input(itv, vin->index, vin);
 837 }
 838
 839 static int ivtv_enum_output(struct file *file, void *fh, struct v4l2_output *vout)
 840 {
 841         struct ivtv *itv = fh2id(fh)->itv;
 842
 843         return ivtv_get_output(itv, vout->index, vout);
 844 }
 845
 846 static int ivtv_cropcap(struct file *file, void *fh, struct v4l2_cropcap *cropcap)
 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         int streamtype;
 852
 853         streamtype = id->type;
 854
 855         if (cropcap->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
 856                 return -EINVAL;
 857         cropcap->bounds.top = cropcap->bounds.left = 0;
 858         cropcap->bounds.width = 720;
 859         if (cropcap->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
 860                 cropcap->bounds.height = itv->is_50hz ? 576 : 480;
 861                 cropcap->pixelaspect.numerator = itv->is_50hz ? 59 : 10;
 862                 cropcap->pixelaspect.denominator = itv->is_50hz ? 54 : 11;
 863         } else if (streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
 864                 if (yi->track_osd) {
 865                         cropcap->bounds.width = yi->osd_full_w;
 866                         cropcap->bounds.height = yi->osd_full_h;
 867                 } else {
 868                         cropcap->bounds.width = 720;
 869                         cropcap->bounds.height =
 870                                         itv->is_out_50hz ? 576 : 480;
 871                 }
 872                 cropcap->pixelaspect.numerator = itv->is_out_50hz ? 59 : 10;
 873                 cropcap->pixelaspect.denominator = itv->is_out_50hz ? 54 : 11;
 874         } else {
 875                 cropcap->bounds.height = itv->is_out_50hz ? 576 : 480;
 876                 cropcap->pixelaspect.numerator = itv->is_out_50hz ? 59 : 10;
 877                 cropcap->pixelaspect.denominator = itv->is_out_50hz ? 54 : 11;
 878         }
 879         cropcap->defrect = cropcap->bounds;
 880         return 0;
 881 }
 882
 883 static int ivtv_s_crop(struct file *file, void *fh, const struct v4l2_crop *crop)
 884 {
 885         struct ivtv_open_id *id = fh2id(fh);
 886         struct ivtv *itv = id->itv;
 887         struct yuv_playback_info *yi = &itv->yuv_info;
 888         int streamtype;
 889
 890         streamtype = id->type;
 891
 892         if (crop->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
 893             (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) {
 894                 if (streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
 895                         yi->main_rect = crop->c;
 896                         return 0;
 897                 } else {
 898                         if (!ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
 899                                 crop->c.width, crop->c.height, crop->c.left, crop->c.top)) {
 900                                 itv->main_rect = crop->c;
 901                                 return 0;
 902                         }
 903                 }
 904                 return -EINVAL;
 905         }
 906         return -EINVAL;
 907 }
 908
 909 static int ivtv_g_crop(struct file *file, void *fh, struct v4l2_crop *crop)
 910 {
 911         struct ivtv_open_id *id = fh2id(fh);
 912         struct ivtv *itv = id->itv;
 913         struct yuv_playback_info *yi = &itv->yuv_info;
 914         int streamtype;
 915
 916         streamtype = id->type;
 917
 918         if (crop->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
 919             (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) {
 920                 if (streamtype == IVTV_DEC_STREAM_TYPE_YUV)
 921                         crop->c = yi->main_rect;
 922                 else
 923                         crop->c = itv->main_rect;
 924                 return 0;
 925         }
 926         return -EINVAL;
 927 }
 928
 929 static int ivtv_enum_fmt_vid_cap(struct file *file, void *fh, struct v4l2_fmtdesc *fmt)
 930 {
 931         static const struct v4l2_fmtdesc hm12 = {
 932                 0, V4L2_BUF_TYPE_VIDEO_CAPTURE, 0,
 933                 "HM12 (YUV 4:2:0)", V4L2_PIX_FMT_HM12,
 934                 { 0, 0, 0, 0 }
 935         };
 936         static const struct v4l2_fmtdesc mpeg = {
 937                 0, V4L2_BUF_TYPE_VIDEO_CAPTURE, V4L2_FMT_FLAG_COMPRESSED,
 938                 "MPEG", V4L2_PIX_FMT_MPEG,
 939                 { 0, 0, 0, 0 }
 940         };
 941         struct ivtv *itv = fh2id(fh)->itv;
 942         struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
 943
 944         if (fmt->index)
 945                 return -EINVAL;
 946         if (s->type == IVTV_ENC_STREAM_TYPE_MPG)
 947                 *fmt = mpeg;
 948         else if (s->type == IVTV_ENC_STREAM_TYPE_YUV)
 949                 *fmt = hm12;
 950         else
 951                 return -EINVAL;
 952         return 0;
 953 }
 954
 955 static int ivtv_enum_fmt_vid_out(struct file *file, void *fh, struct v4l2_fmtdesc *fmt)
 956 {
 957         static const struct v4l2_fmtdesc hm12 = {
 958                 0, V4L2_BUF_TYPE_VIDEO_OUTPUT, 0,
 959                 "HM12 (YUV 4:2:0)", V4L2_PIX_FMT_HM12,
 960                 { 0, 0, 0, 0 }
 961         };
 962         static const struct v4l2_fmtdesc mpeg = {
 963                 0, V4L2_BUF_TYPE_VIDEO_OUTPUT, V4L2_FMT_FLAG_COMPRESSED,
 964                 "MPEG", V4L2_PIX_FMT_MPEG,
 965                 { 0, 0, 0, 0 }
 966         };
 967         struct ivtv *itv = fh2id(fh)->itv;
 968         struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
 969
 970         if (fmt->index)
 971                 return -EINVAL;
 972         if (s->type == IVTV_DEC_STREAM_TYPE_MPG)
 973                 *fmt = mpeg;
 974         else if (s->type == IVTV_DEC_STREAM_TYPE_YUV)
 975                 *fmt = hm12;
 976         else
 977                 return -EINVAL;
 978         return 0;
 979 }
 980
 981 static int ivtv_g_input(struct file *file, void *fh, unsigned int *i)
 982 {
 983         struct ivtv *itv = fh2id(fh)->itv;
 984
 985         *i = itv->active_input;
 986
 987         return 0;
 988 }
 989
 990 int ivtv_s_input(struct file *file, void *fh, unsigned int inp)
 991 {
 992         struct ivtv *itv = fh2id(fh)->itv;
 993         v4l2_std_id std;
 994         int i;
 995
 996         if (inp >= itv->nof_inputs)
 997                 return -EINVAL;
 998
 999         if (inp == itv->active_input) {
1000                 IVTV_DEBUG_INFO("Input unchanged\n");
1001                 return 0;
1002         }
1003
1004         if (atomic_read(&itv->capturing) > 0) {
1005                 return -EBUSY;
1006         }
1007
1008         IVTV_DEBUG_INFO("Changing input from %d to %d\n",
1009                         itv->active_input, inp);
1010
1011         itv->active_input = inp;
1012         /* Set the audio input to whatever is appropriate for the
1013            input type. */
1014         itv->audio_input = itv->card->video_inputs[inp].audio_index;
1015
1016         if (itv->card->video_inputs[inp].video_type == IVTV_CARD_INPUT_VID_TUNER)
1017                 std = itv->tuner_std;
1018         else
1019                 std = V4L2_STD_ALL;
1020         for (i = 0; i <= IVTV_ENC_STREAM_TYPE_VBI; i++)
1021                 itv->streams[i].vdev->tvnorms = std;
1022
1023         /* prevent others from messing with the streams until
1024            we're finished changing inputs. */
1025         ivtv_mute(itv);
1026         ivtv_video_set_io(itv);
1027         ivtv_audio_set_io(itv);
1028         ivtv_unmute(itv);
1029
1030         return 0;
1031 }
1032
1033 static int ivtv_g_output(struct file *file, void *fh, unsigned int *i)
1034 {
1035         struct ivtv *itv = fh2id(fh)->itv;
1036
1037         if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1038                 return -EINVAL;
1039
1040         *i = itv->active_output;
1041
1042         return 0;
1043 }
1044
1045 static int ivtv_s_output(struct file *file, void *fh, unsigned int outp)
1046 {
1047         struct ivtv *itv = fh2id(fh)->itv;
1048
1049         if (outp >= itv->card->nof_outputs)
1050                 return -EINVAL;
1051
1052         if (outp == itv->active_output) {
1053                 IVTV_DEBUG_INFO("Output unchanged\n");
1054                 return 0;
1055         }
1056         IVTV_DEBUG_INFO("Changing output from %d to %d\n",
1057                    itv->active_output, outp);
1058
1059         itv->active_output = outp;
1060         ivtv_call_hw(itv, IVTV_HW_SAA7127, video, s_routing,
1061                         SAA7127_INPUT_TYPE_NORMAL,
1062                         itv->card->video_outputs[outp].video_output, 0);
1063
1064         return 0;
1065 }
1066
1067 static int ivtv_g_frequency(struct file *file, void *fh, struct v4l2_frequency *vf)
1068 {
1069         struct ivtv *itv = fh2id(fh)->itv;
1070         struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
1071
1072         if (s->vdev->vfl_dir)
1073                 return -ENOTTY;
1074         if (vf->tuner != 0)
1075                 return -EINVAL;
1076
1077         ivtv_call_all(itv, tuner, g_frequency, vf);
1078         return 0;
1079 }
1080
1081 int ivtv_s_frequency(struct file *file, void *fh, struct v4l2_frequency *vf)
1082 {
1083         struct ivtv *itv = fh2id(fh)->itv;
1084         struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
1085
1086         if (s->vdev->vfl_dir)
1087                 return -ENOTTY;
1088         if (vf->tuner != 0)
1089                 return -EINVAL;
1090
1091         ivtv_mute(itv);
1092         IVTV_DEBUG_INFO("v4l2 ioctl: set frequency %d\n", vf->frequency);
1093         ivtv_call_all(itv, tuner, s_frequency, vf);
1094         ivtv_unmute(itv);
1095         return 0;
1096 }
1097
1098 static int ivtv_g_std(struct file *file, void *fh, v4l2_std_id *std)
1099 {
1100         struct ivtv *itv = fh2id(fh)->itv;
1101
1102         *std = itv->std;
1103         return 0;
1104 }
1105
1106 void ivtv_s_std_enc(struct ivtv *itv, v4l2_std_id *std)
1107 {
1108         itv->std = *std;
1109         itv->is_60hz = (*std & V4L2_STD_525_60) ? 1 : 0;
1110         itv->is_50hz = !itv->is_60hz;
1111         cx2341x_handler_set_50hz(&itv->cxhdl, itv->is_50hz);
1112         itv->cxhdl.width = 720;
1113         itv->cxhdl.height = itv->is_50hz ? 576 : 480;
1114         itv->vbi.count = itv->is_50hz ? 18 : 12;
1115         itv->vbi.start[0] = itv->is_50hz ? 6 : 10;
1116         itv->vbi.start[1] = itv->is_50hz ? 318 : 273;
1117
1118         if (itv->hw_flags & IVTV_HW_CX25840)
1119                 itv->vbi.sliced_decoder_line_size = itv->is_60hz ? 272 : 284;
1120
1121         /* Tuner */
1122         ivtv_call_all(itv, core, s_std, itv->std);
1123 }
1124
1125 void ivtv_s_std_dec(struct ivtv *itv, v4l2_std_id *std)
1126 {
1127         struct yuv_playback_info *yi = &itv->yuv_info;
1128         DEFINE_WAIT(wait);
1129         int f;
1130
1131         /* set display standard */
1132         itv->std_out = *std;
1133         itv->is_out_60hz = (*std & V4L2_STD_525_60) ? 1 : 0;
1134         itv->is_out_50hz = !itv->is_out_60hz;
1135         ivtv_call_all(itv, video, s_std_output, itv->std_out);
1136
1137         /*
1138          * The next firmware call is time sensitive. Time it to
1139          * avoid risk of a hard lock, by trying to ensure the call
1140          * happens within the first 100 lines of the top field.
1141          * Make 4 attempts to sync to the decoder before giving up.
1142          */
1143         mutex_unlock(&itv->serialize_lock);
1144         for (f = 0; f < 4; f++) {
1145                 prepare_to_wait(&itv->vsync_waitq, &wait,
1146                                 TASK_UNINTERRUPTIBLE);
1147                 if ((read_reg(IVTV_REG_DEC_LINE_FIELD) >> 16) < 100)
1148                         break;
1149                 schedule_timeout(msecs_to_jiffies(25));
1150         }
1151         finish_wait(&itv->vsync_waitq, &wait);
1152         mutex_lock(&itv->serialize_lock);
1153
1154         if (f == 4)
1155                 IVTV_WARN("Mode change failed to sync to decoder\n");
1156
1157         ivtv_vapi(itv, CX2341X_DEC_SET_STANDARD, 1, itv->is_out_50hz);
1158         itv->main_rect.left = 0;
1159         itv->main_rect.top = 0;
1160         itv->main_rect.width = 720;
1161         itv->main_rect.height = itv->is_out_50hz ? 576 : 480;
1162         ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
1163                 720, itv->main_rect.height, 0, 0);
1164         yi->main_rect = itv->main_rect;
1165         if (!itv->osd_info) {
1166                 yi->osd_full_w = 720;
1167                 yi->osd_full_h = itv->is_out_50hz ? 576 : 480;
1168         }
1169 }
1170
1171 static int ivtv_s_std(struct file *file, void *fh, v4l2_std_id *std)
1172 {
1173         struct ivtv *itv = fh2id(fh)->itv;
1174
1175         if ((*std & V4L2_STD_ALL) == 0)
1176                 return -EINVAL;
1177
1178         if (*std == itv->std)
1179                 return 0;
1180
1181         if (test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ||
1182             atomic_read(&itv->capturing) > 0 ||
1183             atomic_read(&itv->decoding) > 0) {
1184                 /* Switching standard would mess with already running
1185                    streams, prevent that by returning EBUSY. */
1186                 return -EBUSY;
1187         }
1188
1189         IVTV_DEBUG_INFO("Switching standard to %llx.\n",
1190                 (unsigned long long)itv->std);
1191
1192         ivtv_s_std_enc(itv, std);
1193         if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)
1194                 ivtv_s_std_dec(itv, std);
1195
1196         return 0;
1197 }
1198
1199 static int ivtv_s_tuner(struct file *file, void *fh, struct v4l2_tuner *vt)
1200 {
1201         struct ivtv_open_id *id = fh2id(fh);
1202         struct ivtv *itv = id->itv;
1203
1204         if (vt->index != 0)
1205                 return -EINVAL;
1206
1207         ivtv_call_all(itv, tuner, s_tuner, vt);
1208
1209         return 0;
1210 }
1211
1212 static int ivtv_g_tuner(struct file *file, void *fh, struct v4l2_tuner *vt)
1213 {
1214         struct ivtv *itv = fh2id(fh)->itv;
1215
1216         if (vt->index != 0)
1217                 return -EINVAL;
1218
1219         ivtv_call_all(itv, tuner, g_tuner, vt);
1220
1221         if (vt->type == V4L2_TUNER_RADIO)
1222                 strlcpy(vt->name, "ivtv Radio Tuner", sizeof(vt->name));
1223         else
1224                 strlcpy(vt->name, "ivtv TV Tuner", sizeof(vt->name));
1225         return 0;
1226 }
1227
1228 static int ivtv_g_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_sliced_vbi_cap *cap)
1229 {
1230         struct ivtv *itv = fh2id(fh)->itv;
1231         int set = itv->is_50hz ? V4L2_SLICED_VBI_625 : V4L2_SLICED_VBI_525;
1232         int f, l;
1233
1234         if (cap->type == V4L2_BUF_TYPE_SLICED_VBI_CAPTURE) {
1235                 for (f = 0; f < 2; f++) {
1236                         for (l = 0; l < 24; l++) {
1237                                 if (valid_service_line(f, l, itv->is_50hz))
1238                                         cap->service_lines[f][l] = set;
1239                         }
1240                 }
1241         } else if (cap->type == V4L2_BUF_TYPE_SLICED_VBI_OUTPUT) {
1242                 if (!(itv->v4l2_cap & V4L2_CAP_SLICED_VBI_OUTPUT))
1243                         return -EINVAL;
1244                 if (itv->is_60hz) {
1245                         cap->service_lines[0][21] = V4L2_SLICED_CAPTION_525;
1246                         cap->service_lines[1][21] = V4L2_SLICED_CAPTION_525;
1247                 } else {
1248                         cap->service_lines[0][23] = V4L2_SLICED_WSS_625;
1249                         cap->service_lines[0][16] = V4L2_SLICED_VPS;
1250                 }
1251         } else {
1252                 return -EINVAL;
1253         }
1254
1255         set = 0;
1256         for (f = 0; f < 2; f++)
1257                 for (l = 0; l < 24; l++)
1258                         set |= cap->service_lines[f][l];
1259         cap->service_set = set;
1260         return 0;
1261 }
1262
1263 static int ivtv_g_enc_index(struct file *file, void *fh, struct v4l2_enc_idx *idx)
1264 {
1265         struct ivtv *itv = fh2id(fh)->itv;
1266         struct v4l2_enc_idx_entry *e = idx->entry;
1267         int entries;
1268         int i;
1269
1270         entries = (itv->pgm_info_write_idx + IVTV_MAX_PGM_INDEX - itv->pgm_info_read_idx) %
1271                                 IVTV_MAX_PGM_INDEX;
1272         if (entries > V4L2_ENC_IDX_ENTRIES)
1273                 entries = V4L2_ENC_IDX_ENTRIES;
1274         idx->entries = 0;
1275         idx->entries_cap = IVTV_MAX_PGM_INDEX;
1276         if (!atomic_read(&itv->capturing))
1277                 return 0;
1278         for (i = 0; i < entries; i++) {
1279                 *e = itv->pgm_info[(itv->pgm_info_read_idx + i) % IVTV_MAX_PGM_INDEX];
1280                 if ((e->flags & V4L2_ENC_IDX_FRAME_MASK) <= V4L2_ENC_IDX_FRAME_B) {
1281                         idx->entries++;
1282                         e++;
1283                 }
1284         }
1285         itv->pgm_info_read_idx = (itv->pgm_info_read_idx + idx->entries) % IVTV_MAX_PGM_INDEX;
1286         return 0;
1287 }
1288
1289 static int ivtv_encoder_cmd(struct file *file, void *fh, struct v4l2_encoder_cmd *enc)
1290 {
1291         struct ivtv_open_id *id = fh2id(fh);
1292         struct ivtv *itv = id->itv;
1293
1294
1295         switch (enc->cmd) {
1296         case V4L2_ENC_CMD_START:
1297                 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
1298                 enc->flags = 0;
1299                 return ivtv_start_capture(id);
1300
1301         case V4L2_ENC_CMD_STOP:
1302                 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
1303                 enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END;
1304                 ivtv_stop_capture(id, enc->flags & V4L2_ENC_CMD_STOP_AT_GOP_END);
1305                 return 0;
1306
1307         case V4L2_ENC_CMD_PAUSE:
1308                 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
1309                 enc->flags = 0;
1310
1311                 if (!atomic_read(&itv->capturing))
1312                         return -EPERM;
1313                 if (test_and_set_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags))
1314                         return 0;
1315
1316                 ivtv_mute(itv);
1317                 ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 0);
1318                 break;
1319
1320         case V4L2_ENC_CMD_RESUME:
1321                 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
1322                 enc->flags = 0;
1323
1324                 if (!atomic_read(&itv->capturing))
1325                         return -EPERM;
1326
1327                 if (!test_and_clear_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags))
1328                         return 0;
1329
1330                 ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 1);
1331                 ivtv_unmute(itv);
1332                 break;
1333         default:
1334                 IVTV_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd);
1335                 return -EINVAL;
1336         }
1337
1338         return 0;
1339 }
1340
1341 static int ivtv_try_encoder_cmd(struct file *file, void *fh, struct v4l2_encoder_cmd *enc)
1342 {
1343         struct ivtv *itv = fh2id(fh)->itv;
1344
1345         switch (enc->cmd) {
1346         case V4L2_ENC_CMD_START:
1347                 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
1348                 enc->flags = 0;
1349                 return 0;
1350
1351         case V4L2_ENC_CMD_STOP:
1352                 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
1353                 enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END;
1354                 return 0;
1355
1356         case V4L2_ENC_CMD_PAUSE:
1357                 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
1358                 enc->flags = 0;
1359                 return 0;
1360
1361         case V4L2_ENC_CMD_RESUME:
1362                 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
1363                 enc->flags = 0;
1364                 return 0;
1365         default:
1366                 IVTV_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd);
1367                 return -EINVAL;
1368         }
1369 }
1370
1371 static int ivtv_g_fbuf(struct file *file, void *fh, struct v4l2_framebuffer *fb)
1372 {
1373         struct ivtv *itv = fh2id(fh)->itv;
1374         u32 data[CX2341X_MBOX_MAX_DATA];
1375         struct yuv_playback_info *yi = &itv->yuv_info;
1376
1377         int pixfmt;
1378         static u32 pixel_format[16] = {
1379                 V4L2_PIX_FMT_PAL8, /* Uses a 256-entry RGB colormap */
1380                 V4L2_PIX_FMT_RGB565,
1381                 V4L2_PIX_FMT_RGB555,
1382                 V4L2_PIX_FMT_RGB444,
1383                 V4L2_PIX_FMT_RGB32,
1384                 0,
1385                 0,
1386                 0,
1387                 V4L2_PIX_FMT_PAL8, /* Uses a 256-entry YUV colormap */
1388                 V4L2_PIX_FMT_YUV565,
1389                 V4L2_PIX_FMT_YUV555,
1390                 V4L2_PIX_FMT_YUV444,
1391                 V4L2_PIX_FMT_YUV32,
1392                 0,
1393                 0,
1394                 0,
1395         };
1396
1397         if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1398                 return -EINVAL;
1399         if (!itv->osd_video_pbase)
1400                 return -EINVAL;
1401
1402         fb->capability = V4L2_FBUF_CAP_EXTERNOVERLAY | V4L2_FBUF_CAP_CHROMAKEY |
1403                 V4L2_FBUF_CAP_GLOBAL_ALPHA;
1404
1405         ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0);
1406         data[0] |= (read_reg(0x2a00) >> 7) & 0x40;
1407         pixfmt = (data[0] >> 3) & 0xf;
1408
1409         fb->fmt.pixelformat = pixel_format[pixfmt];
1410         fb->fmt.width = itv->osd_rect.width;
1411         fb->fmt.height = itv->osd_rect.height;
1412         fb->fmt.field = V4L2_FIELD_INTERLACED;
1413         fb->fmt.bytesperline = fb->fmt.width;
1414         fb->fmt.colorspace = V4L2_COLORSPACE_SMPTE170M;
1415         fb->fmt.field = V4L2_FIELD_INTERLACED;
1416         fb->fmt.priv = 0;
1417         if (fb->fmt.pixelformat != V4L2_PIX_FMT_PAL8)
1418                 fb->fmt.bytesperline *= 2;
1419         if (fb->fmt.pixelformat == V4L2_PIX_FMT_RGB32 ||
1420             fb->fmt.pixelformat == V4L2_PIX_FMT_YUV32)
1421                 fb->fmt.bytesperline *= 2;
1422         fb->fmt.sizeimage = fb->fmt.bytesperline * fb->fmt.height;
1423         fb->base = (void *)itv->osd_video_pbase;
1424         fb->flags = 0;
1425
1426         if (itv->osd_chroma_key_state)
1427                 fb->flags |= V4L2_FBUF_FLAG_CHROMAKEY;
1428
1429         if (itv->osd_global_alpha_state)
1430                 fb->flags |= V4L2_FBUF_FLAG_GLOBAL_ALPHA;
1431
1432         if (yi->track_osd)
1433                 fb->flags |= V4L2_FBUF_FLAG_OVERLAY;
1434
1435         pixfmt &= 7;
1436
1437         /* no local alpha for RGB565 or unknown formats */
1438         if (pixfmt == 1 || pixfmt > 4)
1439                 return 0;
1440
1441         /* 16-bit formats have inverted local alpha */
1442         if (pixfmt == 2 || pixfmt == 3)
1443                 fb->capability |= V4L2_FBUF_CAP_LOCAL_INV_ALPHA;
1444         else
1445                 fb->capability |= V4L2_FBUF_CAP_LOCAL_ALPHA;
1446
1447         if (itv->osd_local_alpha_state) {
1448                 /* 16-bit formats have inverted local alpha */
1449                 if (pixfmt == 2 || pixfmt == 3)
1450                         fb->flags |= V4L2_FBUF_FLAG_LOCAL_INV_ALPHA;
1451                 else
1452                         fb->flags |= V4L2_FBUF_FLAG_LOCAL_ALPHA;
1453         }
1454
1455         return 0;
1456 }
1457
1458 static int ivtv_s_fbuf(struct file *file, void *fh, const struct v4l2_framebuffer *fb)
1459 {
1460         struct ivtv_open_id *id = fh2id(fh);
1461         struct ivtv *itv = id->itv;
1462         struct yuv_playback_info *yi = &itv->yuv_info;
1463
1464         if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1465                 return -EINVAL;
1466         if (!itv->osd_video_pbase)
1467                 return -EINVAL;
1468
1469         itv->osd_global_alpha_state = (fb->flags & V4L2_FBUF_FLAG_GLOBAL_ALPHA) != 0;
1470         itv->osd_local_alpha_state =
1471                 (fb->flags & (V4L2_FBUF_FLAG_LOCAL_ALPHA|V4L2_FBUF_FLAG_LOCAL_INV_ALPHA)) != 0;
1472         itv->osd_chroma_key_state = (fb->flags & V4L2_FBUF_FLAG_CHROMAKEY) != 0;
1473         ivtv_set_osd_alpha(itv);
1474         yi->track_osd = (fb->flags & V4L2_FBUF_FLAG_OVERLAY) != 0;
1475         return 0;
1476 }
1477
1478 static int ivtv_overlay(struct file *file, void *fh, unsigned int on)
1479 {
1480         struct ivtv_open_id *id = fh2id(fh);
1481         struct ivtv *itv = id->itv;
1482
1483         if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1484                 return -EINVAL;
1485
1486         ivtv_vapi(itv, CX2341X_OSD_SET_STATE, 1, on != 0);
1487
1488         return 0;
1489 }
1490
1491 static int ivtv_subscribe_event(struct v4l2_fh *fh, const struct v4l2_event_subscription *sub)
1492 {
1493         switch (sub->type) {
1494         case V4L2_EVENT_VSYNC:
1495         case V4L2_EVENT_EOS:
1496                 return v4l2_event_subscribe(fh, sub, 0, NULL);
1497         case V4L2_EVENT_CTRL:
1498                 return v4l2_event_subscribe(fh, sub, 0, &v4l2_ctrl_sub_ev_ops);
1499         default:
1500                 return -EINVAL;
1501         }
1502 }
1503
1504 static int ivtv_log_status(struct file *file, void *fh)
1505 {
1506         struct ivtv *itv = fh2id(fh)->itv;
1507         u32 data[CX2341X_MBOX_MAX_DATA];
1508
1509         int has_output = itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT;
1510         struct v4l2_input vidin;
1511         struct v4l2_audio audin;
1512         int i;
1513
1514         IVTV_INFO("Version: %s Card: %s\n", IVTV_VERSION, itv->card_name);
1515         if (itv->hw_flags & IVTV_HW_TVEEPROM) {
1516                 struct tveeprom tv;
1517
1518                 ivtv_read_eeprom(itv, &tv);
1519         }
1520         ivtv_call_all(itv, core, log_status);
1521         ivtv_get_input(itv, itv->active_input, &vidin);
1522         ivtv_get_audio_input(itv, itv->audio_input, &audin);
1523         IVTV_INFO("Video Input:  %s\n", vidin.name);
1524         IVTV_INFO("Audio Input:  %s%s\n", audin.name,
1525                 (itv->dualwatch_stereo_mode & ~0x300) == 0x200 ? " (Bilingual)" : "");
1526         if (has_output) {
1527                 struct v4l2_output vidout;
1528                 struct v4l2_audioout audout;
1529                 int mode = itv->output_mode;
1530                 static const char * const output_modes[5] = {
1531                         "None",
1532                         "MPEG Streaming",
1533                         "YUV Streaming",
1534                         "YUV Frames",
1535                         "Passthrough",
1536                 };
1537                 static const char * const alpha_mode[4] = {
1538                         "None",
1539                         "Global",
1540                         "Local",
1541                         "Global and Local"
1542                 };
1543                 static const char * const pixel_format[16] = {
1544                         "ARGB Indexed",
1545                         "RGB 5:6:5",
1546                         "ARGB 1:5:5:5",
1547                         "ARGB 1:4:4:4",
1548                         "ARGB 8:8:8:8",
1549                         "5",
1550                         "6",
1551                         "7",
1552                         "AYUV Indexed",
1553                         "YUV 5:6:5",
1554                         "AYUV 1:5:5:5",
1555                         "AYUV 1:4:4:4",
1556                         "AYUV 8:8:8:8",
1557                         "13",
1558                         "14",
1559                         "15",
1560                 };
1561
1562                 ivtv_get_output(itv, itv->active_output, &vidout);
1563                 ivtv_get_audio_output(itv, 0, &audout);
1564                 IVTV_INFO("Video Output: %s\n", vidout.name);
1565                 if (mode < 0 || mode > OUT_PASSTHROUGH)
1566                         mode = OUT_NONE;
1567                 IVTV_INFO("Output Mode:  %s\n", output_modes[mode]);
1568                 ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0);
1569                 data[0] |= (read_reg(0x2a00) >> 7) & 0x40;
1570                 IVTV_INFO("Overlay:      %s, Alpha: %s, Pixel Format: %s\n",
1571                         data[0] & 1 ? "On" : "Off",
1572                         alpha_mode[(data[0] >> 1) & 0x3],
1573                         pixel_format[(data[0] >> 3) & 0xf]);
1574         }
1575         IVTV_INFO("Tuner:  %s\n",
1576                 test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ? "Radio" : "TV");
1577         v4l2_ctrl_handler_log_status(&itv->cxhdl.hdl, itv->v4l2_dev.name);
1578         IVTV_INFO("Status flags:    0x%08lx\n", itv->i_flags);
1579         for (i = 0; i < IVTV_MAX_STREAMS; i++) {
1580                 struct ivtv_stream *s = &itv->streams[i];
1581
1582                 if (s->vdev == NULL || s->buffers == 0)
1583                         continue;
1584                 IVTV_INFO("Stream %s: status 0x%04lx, %d%% of %d KiB (%d buffers) in use\n", s->name, s->s_flags,
1585                                 (s->buffers - s->q_free.buffers) * 100 / s->buffers,
1586                                 (s->buffers * s->buf_size) / 1024, s->buffers);
1587         }
1588
1589         IVTV_INFO("Read MPG/VBI: %lld/%lld bytes\n",
1590                         (long long)itv->mpg_data_received,
1591                         (long long)itv->vbi_data_inserted);
1592         return 0;
1593 }
1594
1595 static int ivtv_decoder_cmd(struct file *file, void *fh, struct v4l2_decoder_cmd *dec)
1596 {
1597         struct ivtv_open_id *id = fh2id(file->private_data);
1598         struct ivtv *itv = id->itv;
1599
1600         IVTV_DEBUG_IOCTL("VIDIOC_DECODER_CMD %d\n", dec->cmd);
1601         return ivtv_video_command(itv, id, dec, false);
1602 }
1603
1604 static int ivtv_try_decoder_cmd(struct file *file, void *fh, struct v4l2_decoder_cmd *dec)
1605 {
1606         struct ivtv_open_id *id = fh2id(file->private_data);
1607         struct ivtv *itv = id->itv;
1608
1609         IVTV_DEBUG_IOCTL("VIDIOC_TRY_DECODER_CMD %d\n", dec->cmd);
1610         return ivtv_video_command(itv, id, dec, true);
1611 }
1612
1613 static int ivtv_decoder_ioctls(struct file *filp, unsigned int cmd, void *arg)
1614 {
1615         struct ivtv_open_id *id = fh2id(filp->private_data);
1616         struct ivtv *itv = id->itv;
1617         int nonblocking = filp->f_flags & O_NONBLOCK;
1618         struct ivtv_stream *s = &itv->streams[id->type];
1619         unsigned long iarg = (unsigned long)arg;
1620
1621         switch (cmd) {
1622         case IVTV_IOC_DMA_FRAME: {
1623                 struct ivtv_dma_frame *args = arg;
1624
1625                 IVTV_DEBUG_IOCTL("IVTV_IOC_DMA_FRAME\n");
1626                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1627                         return -EINVAL;
1628                 if (args->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
1629                         return -EINVAL;
1630                 if (itv->output_mode == OUT_UDMA_YUV && args->y_source == NULL)
1631                         return 0;
1632                 if (ivtv_start_decoding(id, id->type)) {
1633                         return -EBUSY;
1634                 }
1635                 if (ivtv_set_output_mode(itv, OUT_UDMA_YUV) != OUT_UDMA_YUV) {
1636                         ivtv_release_stream(s);
1637                         return -EBUSY;
1638                 }
1639                 /* Mark that this file handle started the UDMA_YUV mode */
1640                 id->yuv_frames = 1;
1641                 if (args->y_source == NULL)
1642                         return 0;
1643                 return ivtv_yuv_prep_frame(itv, args);
1644         }
1645
1646         case IVTV_IOC_PASSTHROUGH_MODE:
1647                 IVTV_DEBUG_IOCTL("IVTV_IOC_PASSTHROUGH_MODE\n");
1648                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1649                         return -EINVAL;
1650                 return ivtv_passthrough_mode(itv, *(int *)arg != 0);
1651
1652         case VIDEO_GET_PTS: {
1653                 s64 *pts = arg;
1654                 s64 frame;
1655
1656                 IVTV_DEBUG_IOCTL("VIDEO_GET_PTS\n");
1657                 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) {
1658                         *pts = s->dma_pts;
1659                         break;
1660                 }
1661                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1662                         return -EINVAL;
1663                 return ivtv_g_pts_frame(itv, pts, &frame);
1664         }
1665
1666         case VIDEO_GET_FRAME_COUNT: {
1667                 s64 *frame = arg;
1668                 s64 pts;
1669
1670                 IVTV_DEBUG_IOCTL("VIDEO_GET_FRAME_COUNT\n");
1671                 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) {
1672                         *frame = 0;
1673                         break;
1674                 }
1675                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1676                         return -EINVAL;
1677                 return ivtv_g_pts_frame(itv, &pts, frame);
1678         }
1679
1680         case VIDEO_PLAY: {
1681                 struct v4l2_decoder_cmd dc;
1682
1683                 IVTV_DEBUG_IOCTL("VIDEO_PLAY\n");
1684                 memset(&dc, 0, sizeof(dc));
1685                 dc.cmd = V4L2_DEC_CMD_START;
1686                 return ivtv_video_command(itv, id, &dc, 0);
1687         }
1688
1689         case VIDEO_STOP: {
1690                 struct v4l2_decoder_cmd dc;
1691
1692                 IVTV_DEBUG_IOCTL("VIDEO_STOP\n");
1693                 memset(&dc, 0, sizeof(dc));
1694                 dc.cmd = V4L2_DEC_CMD_STOP;
1695                 dc.flags = V4L2_DEC_CMD_STOP_TO_BLACK | V4L2_DEC_CMD_STOP_IMMEDIATELY;
1696                 return ivtv_video_command(itv, id, &dc, 0);
1697         }
1698
1699         case VIDEO_FREEZE: {
1700                 struct v4l2_decoder_cmd dc;
1701
1702                 IVTV_DEBUG_IOCTL("VIDEO_FREEZE\n");
1703                 memset(&dc, 0, sizeof(dc));
1704                 dc.cmd = V4L2_DEC_CMD_PAUSE;
1705                 return ivtv_video_command(itv, id, &dc, 0);
1706         }
1707
1708         case VIDEO_CONTINUE: {
1709                 struct v4l2_decoder_cmd dc;
1710
1711                 IVTV_DEBUG_IOCTL("VIDEO_CONTINUE\n");
1712                 memset(&dc, 0, sizeof(dc));
1713                 dc.cmd = V4L2_DEC_CMD_RESUME;
1714                 return ivtv_video_command(itv, id, &dc, 0);
1715         }
1716
1717         case VIDEO_COMMAND:
1718         case VIDEO_TRY_COMMAND: {
1719                 /* Note: struct v4l2_decoder_cmd has the same layout as
1720                    struct video_command */
1721                 struct v4l2_decoder_cmd *dc = arg;
1722                 int try = (cmd == VIDEO_TRY_COMMAND);
1723
1724                 if (try)
1725                         IVTV_DEBUG_IOCTL("VIDEO_TRY_COMMAND %d\n", dc->cmd);
1726                 else
1727                         IVTV_DEBUG_IOCTL("VIDEO_COMMAND %d\n", dc->cmd);
1728                 return ivtv_video_command(itv, id, dc, try);
1729         }
1730
1731         case VIDEO_GET_EVENT: {
1732                 struct video_event *ev = arg;
1733                 DEFINE_WAIT(wait);
1734
1735                 IVTV_DEBUG_IOCTL("VIDEO_GET_EVENT\n");
1736                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1737                         return -EINVAL;
1738                 memset(ev, 0, sizeof(*ev));
1739                 set_bit(IVTV_F_I_EV_VSYNC_ENABLED, &itv->i_flags);
1740
1741                 while (1) {
1742                         if (test_and_clear_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags))
1743                                 ev->type = VIDEO_EVENT_DECODER_STOPPED;
1744                         else if (test_and_clear_bit(IVTV_F_I_EV_VSYNC, &itv->i_flags)) {
1745                                 ev->type = VIDEO_EVENT_VSYNC;
1746                                 ev->u.vsync_field = test_bit(IVTV_F_I_EV_VSYNC_FIELD, &itv->i_flags) ?
1747                                         VIDEO_VSYNC_FIELD_ODD : VIDEO_VSYNC_FIELD_EVEN;
1748                                 if (itv->output_mode == OUT_UDMA_YUV &&
1749                                         (itv->yuv_info.lace_mode & IVTV_YUV_MODE_MASK) ==
1750                                                                 IVTV_YUV_MODE_PROGRESSIVE) {
1751                                         ev->u.vsync_field = VIDEO_VSYNC_FIELD_PROGRESSIVE;
1752                                 }
1753                         }
1754                         if (ev->type)
1755                                 return 0;
1756                         if (nonblocking)
1757                                 return -EAGAIN;
1758                         /* Wait for event. Note that serialize_lock is locked,
1759                            so to allow other processes to access the driver while
1760                            we are waiting unlock first and later lock again. */
1761                         mutex_unlock(&itv->serialize_lock);
1762                         prepare_to_wait(&itv->event_waitq, &wait, TASK_INTERRUPTIBLE);
1763                         if (!test_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags) &&
1764                             !test_bit(IVTV_F_I_EV_VSYNC, &itv->i_flags))
1765                                 schedule();
1766                         finish_wait(&itv->event_waitq, &wait);
1767                         mutex_lock(&itv->serialize_lock);
1768                         if (signal_pending(current)) {
1769                                 /* return if a signal was received */
1770                                 IVTV_DEBUG_INFO("User stopped wait for event\n");
1771                                 return -EINTR;
1772                         }
1773                 }
1774                 break;
1775         }
1776
1777         case VIDEO_SELECT_SOURCE:
1778                 IVTV_DEBUG_IOCTL("VIDEO_SELECT_SOURCE\n");
1779                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1780                         return -EINVAL;
1781                 return ivtv_passthrough_mode(itv, iarg == VIDEO_SOURCE_DEMUX);
1782
1783         case AUDIO_SET_MUTE:
1784                 IVTV_DEBUG_IOCTL("AUDIO_SET_MUTE\n");
1785                 itv->speed_mute_audio = iarg;
1786                 return 0;
1787
1788         case AUDIO_CHANNEL_SELECT:
1789                 IVTV_DEBUG_IOCTL("AUDIO_CHANNEL_SELECT\n");
1790                 if (iarg > AUDIO_STEREO_SWAPPED)
1791                         return -EINVAL;
1792                 return v4l2_ctrl_s_ctrl(itv->ctrl_audio_playback, iarg + 1);
1793
1794         case AUDIO_BILINGUAL_CHANNEL_SELECT:
1795                 IVTV_DEBUG_IOCTL("AUDIO_BILINGUAL_CHANNEL_SELECT\n");
1796                 if (iarg > AUDIO_STEREO_SWAPPED)
1797                         return -EINVAL;
1798                 return v4l2_ctrl_s_ctrl(itv->ctrl_audio_multilingual_playback, iarg + 1);
1799
1800         default:
1801                 return -EINVAL;
1802         }
1803         return 0;
1804 }
1805
1806 static long ivtv_default(struct file *file, void *fh, bool valid_prio,
1807                          int cmd, void *arg)
1808 {
1809         struct ivtv *itv = fh2id(fh)->itv;
1810
1811         if (!valid_prio) {
1812                 switch (cmd) {
1813                 case IVTV_IOC_PASSTHROUGH_MODE:
1814                 case VIDEO_PLAY:
1815                 case VIDEO_STOP:
1816                 case VIDEO_FREEZE:
1817                 case VIDEO_CONTINUE:
1818                 case VIDEO_COMMAND:
1819                 case VIDEO_SELECT_SOURCE:
1820                 case AUDIO_SET_MUTE:
1821                 case AUDIO_CHANNEL_SELECT:
1822                 case AUDIO_BILINGUAL_CHANNEL_SELECT:
1823                         return -EBUSY;
1824                 }
1825         }
1826
1827         switch (cmd) {
1828         case VIDIOC_INT_RESET: {
1829                 u32 val = *(u32 *)arg;
1830
1831                 if ((val == 0 && itv->options.newi2c) || (val & 0x01))
1832                         ivtv_reset_ir_gpio(itv);
1833                 if (val & 0x02)
1834                         v4l2_subdev_call(itv->sd_video, core, reset, 0);
1835                 break;
1836         }
1837
1838         case IVTV_IOC_DMA_FRAME:
1839         case IVTV_IOC_PASSTHROUGH_MODE:
1840         case VIDEO_GET_PTS:
1841         case VIDEO_GET_FRAME_COUNT:
1842         case VIDEO_GET_EVENT:
1843         case VIDEO_PLAY:
1844         case VIDEO_STOP:
1845         case VIDEO_FREEZE:
1846         case VIDEO_CONTINUE:
1847         case VIDEO_COMMAND:
1848         case VIDEO_TRY_COMMAND:
1849         case VIDEO_SELECT_SOURCE:
1850         case AUDIO_SET_MUTE:
1851         case AUDIO_CHANNEL_SELECT:
1852         case AUDIO_BILINGUAL_CHANNEL_SELECT:
1853                 return ivtv_decoder_ioctls(file, cmd, (void *)arg);
1854
1855         default:
1856                 return -ENOTTY;
1857         }
1858         return 0;
1859 }
1860
1861 static const struct v4l2_ioctl_ops ivtv_ioctl_ops = {
1862         .vidioc_querycap                    = ivtv_querycap,
1863         .vidioc_s_audio                     = ivtv_s_audio,
1864         .vidioc_g_audio                     = ivtv_g_audio,
1865         .vidioc_enumaudio                   = ivtv_enumaudio,
1866         .vidioc_s_audout                    = ivtv_s_audout,
1867         .vidioc_g_audout                    = ivtv_g_audout,
1868         .vidioc_enum_input                  = ivtv_enum_input,
1869         .vidioc_enum_output                 = ivtv_enum_output,
1870         .vidioc_enumaudout                  = ivtv_enumaudout,
1871         .vidioc_cropcap                     = ivtv_cropcap,
1872         .vidioc_s_crop                      = ivtv_s_crop,
1873         .vidioc_g_crop                      = ivtv_g_crop,
1874         .vidioc_g_input                     = ivtv_g_input,
1875         .vidioc_s_input                     = ivtv_s_input,
1876         .vidioc_g_output                    = ivtv_g_output,
1877         .vidioc_s_output                    = ivtv_s_output,
1878         .vidioc_g_frequency                 = ivtv_g_frequency,
1879         .vidioc_s_frequency                 = ivtv_s_frequency,
1880         .vidioc_s_tuner                     = ivtv_s_tuner,
1881         .vidioc_g_tuner                     = ivtv_g_tuner,
1882         .vidioc_g_enc_index                 = ivtv_g_enc_index,
1883         .vidioc_g_fbuf                      = ivtv_g_fbuf,
1884         .vidioc_s_fbuf                      = ivtv_s_fbuf,
1885         .vidioc_g_std                       = ivtv_g_std,
1886         .vidioc_s_std                       = ivtv_s_std,
1887         .vidioc_overlay                     = ivtv_overlay,
1888         .vidioc_log_status                  = ivtv_log_status,
1889         .vidioc_enum_fmt_vid_cap            = ivtv_enum_fmt_vid_cap,
1890         .vidioc_encoder_cmd                 = ivtv_encoder_cmd,
1891         .vidioc_try_encoder_cmd             = ivtv_try_encoder_cmd,
1892         .vidioc_decoder_cmd                 = ivtv_decoder_cmd,
1893         .vidioc_try_decoder_cmd             = ivtv_try_decoder_cmd,
1894         .vidioc_enum_fmt_vid_out            = ivtv_enum_fmt_vid_out,
1895         .vidioc_g_fmt_vid_cap               = ivtv_g_fmt_vid_cap,
1896         .vidioc_g_fmt_vbi_cap               = ivtv_g_fmt_vbi_cap,
1897         .vidioc_g_fmt_sliced_vbi_cap        = ivtv_g_fmt_sliced_vbi_cap,
1898         .vidioc_g_fmt_vid_out               = ivtv_g_fmt_vid_out,
1899         .vidioc_g_fmt_vid_out_overlay       = ivtv_g_fmt_vid_out_overlay,
1900         .vidioc_g_fmt_sliced_vbi_out        = ivtv_g_fmt_sliced_vbi_out,
1901         .vidioc_s_fmt_vid_cap               = ivtv_s_fmt_vid_cap,
1902         .vidioc_s_fmt_vbi_cap               = ivtv_s_fmt_vbi_cap,
1903         .vidioc_s_fmt_sliced_vbi_cap        = ivtv_s_fmt_sliced_vbi_cap,
1904         .vidioc_s_fmt_vid_out               = ivtv_s_fmt_vid_out,
1905         .vidioc_s_fmt_vid_out_overlay       = ivtv_s_fmt_vid_out_overlay,
1906         .vidioc_s_fmt_sliced_vbi_out        = ivtv_s_fmt_sliced_vbi_out,
1907         .vidioc_try_fmt_vid_cap             = ivtv_try_fmt_vid_cap,
1908         .vidioc_try_fmt_vbi_cap             = ivtv_try_fmt_vbi_cap,
1909         .vidioc_try_fmt_sliced_vbi_cap      = ivtv_try_fmt_sliced_vbi_cap,
1910         .vidioc_try_fmt_vid_out             = ivtv_try_fmt_vid_out,
1911         .vidioc_try_fmt_vid_out_overlay     = ivtv_try_fmt_vid_out_overlay,
1912         .vidioc_try_fmt_sliced_vbi_out      = ivtv_try_fmt_sliced_vbi_out,
1913         .vidioc_g_sliced_vbi_cap            = ivtv_g_sliced_vbi_cap,
1914         .vidioc_g_chip_ident                = ivtv_g_chip_ident,
1915 #ifdef CONFIG_VIDEO_ADV_DEBUG
1916         .vidioc_g_register                  = ivtv_g_register,
1917         .vidioc_s_register                  = ivtv_s_register,
1918 #endif
1919         .vidioc_default                     = ivtv_default,
1920         .vidioc_subscribe_event             = ivtv_subscribe_event,
1921         .vidioc_unsubscribe_event           = v4l2_event_unsubscribe,
1922 };
1923
1924 void ivtv_set_funcs(struct video_device *vdev)
1925 {
1926         vdev->ioctl_ops = &ivtv_ioctl_ops;
1927 }