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