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