git.oblomov.eu Git - linux-2.6/blob - drivers/media/video/ivtv/ivtv-ioctl.c

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