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

   1 /*
   2     ioctl system call
   3     Copyright (C) 2003-2004  Kevin Thayer <nufan_wfk at yahoo.com>
   4     Copyright (C) 2005-2007  Hans Verkuil <hverkuil@xs4all.nl>
   5
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include "ivtv-driver.h"
  22 #include "ivtv-version.h"
  23 #include "ivtv-mailbox.h"
  24 #include "ivtv-i2c.h"
  25 #include "ivtv-queue.h"
  26 #include "ivtv-fileops.h"
  27 #include "ivtv-vbi.h"
  28 #include "ivtv-routing.h"
  29 #include "ivtv-streams.h"
  30 #include "ivtv-yuv.h"
  31 #include "ivtv-ioctl.h"
  32 #include "ivtv-gpio.h"
  33 #include "ivtv-controls.h"
  34 #include "ivtv-cards.h"
  35 #include <media/saa7127.h>
  36 #include <media/tveeprom.h>
  37 #include <media/v4l2-chip-ident.h>
  38 #include <linux/dvb/audio.h>
  39 #include <linux/i2c-id.h>
  40
  41 u16 ivtv_service2vbi(int type)
  42 {
  43         switch (type) {
  44                 case V4L2_SLICED_TELETEXT_B:
  45                         return IVTV_SLICED_TYPE_TELETEXT_B;
  46                 case V4L2_SLICED_CAPTION_525:
  47                         return IVTV_SLICED_TYPE_CAPTION_525;
  48                 case V4L2_SLICED_WSS_625:
  49                         return IVTV_SLICED_TYPE_WSS_625;
  50                 case V4L2_SLICED_VPS:
  51                         return IVTV_SLICED_TYPE_VPS;
  52                 default:
  53                         return 0;
  54         }
  55 }
  56
  57 static int valid_service_line(int field, int line, int is_pal)
  58 {
  59         return (is_pal && line >= 6 && (line != 23 || field == 0)) ||
  60                (!is_pal && line >= 10 && line < 22);
  61 }
  62
  63 static u16 select_service_from_set(int field, int line, u16 set, int is_pal)
  64 {
  65         u16 valid_set = (is_pal ? V4L2_SLICED_VBI_625 : V4L2_SLICED_VBI_525);
  66         int i;
  67
  68         set = set & valid_set;
  69         if (set == 0 || !valid_service_line(field, line, is_pal)) {
  70                 return 0;
  71         }
  72         if (!is_pal) {
  73                 if (line == 21 && (set & V4L2_SLICED_CAPTION_525))
  74                         return V4L2_SLICED_CAPTION_525;
  75         }
  76         else {
  77                 if (line == 16 && field == 0 && (set & V4L2_SLICED_VPS))
  78                         return V4L2_SLICED_VPS;
  79                 if (line == 23 && field == 0 && (set & V4L2_SLICED_WSS_625))
  80                         return V4L2_SLICED_WSS_625;
  81                 if (line == 23)
  82                         return 0;
  83         }
  84         for (i = 0; i < 32; i++) {
  85                 if ((1 << i) & set)
  86                         return 1 << i;
  87         }
  88         return 0;
  89 }
  90
  91 void ivtv_expand_service_set(struct v4l2_sliced_vbi_format *fmt, int is_pal)
  92 {
  93         u16 set = fmt->service_set;
  94         int f, l;
  95
  96         fmt->service_set = 0;
  97         for (f = 0; f < 2; f++) {
  98                 for (l = 0; l < 24; l++) {
  99                         fmt->service_lines[f][l] = select_service_from_set(f, l, set, is_pal);
 100                 }
 101         }
 102 }
 103
 104 static void check_service_set(struct v4l2_sliced_vbi_format *fmt, int is_pal)
 105 {
 106         int f, l;
 107
 108         for (f = 0; f < 2; f++) {
 109                 for (l = 0; l < 24; l++) {
 110                         fmt->service_lines[f][l] = select_service_from_set(f, l, fmt->service_lines[f][l], is_pal);
 111                 }
 112         }
 113 }
 114
 115 u16 ivtv_get_service_set(struct v4l2_sliced_vbi_format *fmt)
 116 {
 117         int f, l;
 118         u16 set = 0;
 119
 120         for (f = 0; f < 2; f++) {
 121                 for (l = 0; l < 24; l++) {
 122                         set |= fmt->service_lines[f][l];
 123                 }
 124         }
 125         return set;
 126 }
 127
 128 void ivtv_set_osd_alpha(struct ivtv *itv)
 129 {
 130         ivtv_vapi(itv, CX2341X_OSD_SET_GLOBAL_ALPHA, 3,
 131                 itv->osd_global_alpha_state, itv->osd_global_alpha, !itv->osd_local_alpha_state);
 132         ivtv_vapi(itv, CX2341X_OSD_SET_CHROMA_KEY, 2, itv->osd_chroma_key_state, itv->osd_chroma_key);
 133 }
 134
 135 int ivtv_set_speed(struct ivtv *itv, int speed)
 136 {
 137         u32 data[CX2341X_MBOX_MAX_DATA];
 138         struct ivtv_stream *s;
 139         int single_step = (speed == 1 || speed == -1);
 140         DEFINE_WAIT(wait);
 141
 142         if (speed == 0) speed = 1000;
 143
 144         /* No change? */
 145         if (speed == itv->speed && !single_step)
 146                 return 0;
 147
 148         s = &itv->streams[IVTV_DEC_STREAM_TYPE_MPG];
 149
 150         if (single_step && (speed < 0) == (itv->speed < 0)) {
 151                 /* Single step video and no need to change direction */
 152                 ivtv_vapi(itv, CX2341X_DEC_STEP_VIDEO, 1, 0);
 153                 itv->speed = speed;
 154                 return 0;
 155         }
 156         if (single_step)
 157                 /* Need to change direction */
 158                 speed = speed < 0 ? -1000 : 1000;
 159
 160         data[0] = (speed > 1000 || speed < -1000) ? 0x80000000 : 0;
 161         data[0] |= (speed > 1000 || speed < -1500) ? 0x40000000 : 0;
 162         data[1] = (speed < 0);
 163         data[2] = speed < 0 ? 3 : 7;
 164         data[3] = itv->params.video_b_frames;
 165         data[4] = (speed == 1500 || speed == 500) ? itv->speed_mute_audio : 0;
 166         data[5] = 0;
 167         data[6] = 0;
 168
 169         if (speed == 1500 || speed == -1500) data[0] |= 1;
 170         else if (speed == 2000 || speed == -2000) data[0] |= 2;
 171         else if (speed > -1000 && speed < 0) data[0] |= (-1000 / speed);
 172         else if (speed < 1000 && speed > 0) data[0] |= (1000 / speed);
 173
 174         /* If not decoding, just change speed setting */
 175         if (atomic_read(&itv->decoding) > 0) {
 176                 int got_sig = 0;
 177
 178                 /* Stop all DMA and decoding activity */
 179                 ivtv_vapi(itv, CX2341X_DEC_PAUSE_PLAYBACK, 1, 0);
 180
 181                 /* Wait for any DMA to finish */
 182                 prepare_to_wait(&itv->dma_waitq, &wait, TASK_INTERRUPTIBLE);
 183                 while (itv->i_flags & IVTV_F_I_DMA) {
 184                         got_sig = signal_pending(current);
 185                         if (got_sig)
 186                                 break;
 187                         got_sig = 0;
 188                         schedule();
 189                 }
 190                 finish_wait(&itv->dma_waitq, &wait);
 191                 if (got_sig)
 192                         return -EINTR;
 193
 194                 /* Change Speed safely */
 195                 ivtv_api(itv, CX2341X_DEC_SET_PLAYBACK_SPEED, 7, data);
 196                 IVTV_DEBUG_INFO("Setting Speed to 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n",
 197                                 data[0], data[1], data[2], data[3], data[4], data[5], data[6]);
 198         }
 199         if (single_step) {
 200                 speed = (speed < 0) ? -1 : 1;
 201                 ivtv_vapi(itv, CX2341X_DEC_STEP_VIDEO, 1, 0);
 202         }
 203         itv->speed = speed;
 204         return 0;
 205 }
 206
 207 static int ivtv_validate_speed(int cur_speed, int new_speed)
 208 {
 209         int fact = new_speed < 0 ? -1 : 1;
 210         int s;
 211
 212         if (cur_speed == 0)
 213                 cur_speed = 1000;
 214         if (new_speed < 0)
 215                 new_speed = -new_speed;
 216         if (cur_speed < 0)
 217                 cur_speed = -cur_speed;
 218
 219         if (cur_speed <= new_speed) {
 220                 if (new_speed > 1500)
 221                         return fact * 2000;
 222                 if (new_speed > 1000)
 223                         return fact * 1500;
 224         }
 225         else {
 226                 if (new_speed >= 2000)
 227                         return fact * 2000;
 228                 if (new_speed >= 1500)
 229                         return fact * 1500;
 230                 if (new_speed >= 1000)
 231                         return fact * 1000;
 232         }
 233         if (new_speed == 0)
 234                 return 1000;
 235         if (new_speed == 1 || new_speed == 1000)
 236                 return fact * new_speed;
 237
 238         s = new_speed;
 239         new_speed = 1000 / new_speed;
 240         if (1000 / cur_speed == new_speed)
 241                 new_speed += (cur_speed < s) ? -1 : 1;
 242         if (new_speed > 60) return 1000 / (fact * 60);
 243         return 1000 / (fact * new_speed);
 244 }
 245
 246 static int ivtv_video_command(struct ivtv *itv, struct ivtv_open_id *id,
 247                 struct video_command *vc, int try)
 248 {
 249         struct ivtv_stream *s = &itv->streams[IVTV_DEC_STREAM_TYPE_MPG];
 250
 251         if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
 252                 return -EINVAL;
 253
 254         switch (vc->cmd) {
 255         case VIDEO_CMD_PLAY: {
 256                 vc->flags = 0;
 257                 vc->play.speed = ivtv_validate_speed(itv->speed, vc->play.speed);
 258                 if (vc->play.speed < 0)
 259                         vc->play.format = VIDEO_PLAY_FMT_GOP;
 260                 if (try) break;
 261
 262                 if (ivtv_set_output_mode(itv, OUT_MPG) != OUT_MPG)
 263                         return -EBUSY;
 264                 if (test_and_clear_bit(IVTV_F_I_DEC_PAUSED, &itv->i_flags)) {
 265                         /* forces ivtv_set_speed to be called */
 266                         itv->speed = 0;
 267                 }
 268                 return ivtv_start_decoding(id, vc->play.speed);
 269         }
 270
 271         case VIDEO_CMD_STOP:
 272                 vc->flags &= VIDEO_CMD_STOP_IMMEDIATELY|VIDEO_CMD_STOP_TO_BLACK;
 273                 if (vc->flags & VIDEO_CMD_STOP_IMMEDIATELY)
 274                         vc->stop.pts = 0;
 275                 if (try) break;
 276                 if (atomic_read(&itv->decoding) == 0)
 277                         return 0;
 278                 if (itv->output_mode != OUT_MPG)
 279                         return -EBUSY;
 280
 281                 itv->output_mode = OUT_NONE;
 282                 return ivtv_stop_v4l2_decode_stream(s, vc->flags, vc->stop.pts);
 283
 284         case VIDEO_CMD_FREEZE:
 285                 vc->flags &= VIDEO_CMD_FREEZE_TO_BLACK;
 286                 if (try) break;
 287                 if (itv->output_mode != OUT_MPG)
 288                         return -EBUSY;
 289                 if (atomic_read(&itv->decoding) > 0) {
 290                         ivtv_vapi(itv, CX2341X_DEC_PAUSE_PLAYBACK, 1,
 291                                 (vc->flags & VIDEO_CMD_FREEZE_TO_BLACK) ? 1 : 0);
 292                         set_bit(IVTV_F_I_DEC_PAUSED, &itv->i_flags);
 293                 }
 294                 break;
 295
 296         case VIDEO_CMD_CONTINUE:
 297                 vc->flags = 0;
 298                 if (try) break;
 299                 if (itv->output_mode != OUT_MPG)
 300                         return -EBUSY;
 301                 if (test_and_clear_bit(IVTV_F_I_DEC_PAUSED, &itv->i_flags)) {
 302                         int speed = itv->speed;
 303                         itv->speed = 0;
 304                         return ivtv_start_decoding(id, speed);
 305                 }
 306                 break;
 307
 308         default:
 309                 return -EINVAL;
 310         }
 311         return 0;
 312 }
 313
 314 static int ivtv_g_fmt_sliced_vbi_out(struct file *file, void *fh, struct v4l2_format *fmt)
 315 {
 316         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
 317         struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
 318
 319         vbifmt->reserved[0] = 0;
 320         vbifmt->reserved[1] = 0;
 321         if (!(itv->v4l2_cap & V4L2_CAP_SLICED_VBI_OUTPUT))
 322                 return -EINVAL;
 323         vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
 324         if (itv->is_60hz) {
 325                 vbifmt->service_lines[0][21] = V4L2_SLICED_CAPTION_525;
 326                 vbifmt->service_lines[1][21] = V4L2_SLICED_CAPTION_525;
 327         } else {
 328                 vbifmt->service_lines[0][23] = V4L2_SLICED_WSS_625;
 329                 vbifmt->service_lines[0][16] = V4L2_SLICED_VPS;
 330         }
 331         vbifmt->service_set = ivtv_get_service_set(vbifmt);
 332         return 0;
 333 }
 334
 335 static int ivtv_g_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
 336 {
 337         struct ivtv_open_id *id = fh;
 338         struct ivtv *itv = id->itv;
 339         struct v4l2_pix_format *pixfmt = &fmt->fmt.pix;
 340
 341         pixfmt->width = itv->params.width;
 342         pixfmt->height = itv->params.height;
 343         pixfmt->colorspace = V4L2_COLORSPACE_SMPTE170M;
 344         pixfmt->field = V4L2_FIELD_INTERLACED;
 345         pixfmt->priv = 0;
 346         if (id->type == IVTV_ENC_STREAM_TYPE_YUV) {
 347                 pixfmt->pixelformat = V4L2_PIX_FMT_HM12;
 348                 /* YUV size is (Y=(h*w) + UV=(h*(w/2))) */
 349                 pixfmt->sizeimage =
 350                         pixfmt->height * pixfmt->width +
 351                         pixfmt->height * (pixfmt->width / 2);
 352                 pixfmt->bytesperline = 720;
 353         } else {
 354                 pixfmt->pixelformat = V4L2_PIX_FMT_MPEG;
 355                 pixfmt->sizeimage = 128 * 1024;
 356                 pixfmt->bytesperline = 0;
 357         }
 358         return 0;
 359 }
 360
 361 static int ivtv_g_fmt_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
 362 {
 363         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
 364         struct v4l2_vbi_format *vbifmt = &fmt->fmt.vbi;
 365
 366         vbifmt->sampling_rate = 27000000;
 367         vbifmt->offset = 248;
 368         vbifmt->samples_per_line = itv->vbi.raw_decoder_line_size - 4;
 369         vbifmt->sample_format = V4L2_PIX_FMT_GREY;
 370         vbifmt->start[0] = itv->vbi.start[0];
 371         vbifmt->start[1] = itv->vbi.start[1];
 372         vbifmt->count[0] = vbifmt->count[1] = itv->vbi.count;
 373         vbifmt->flags = 0;
 374         vbifmt->reserved[0] = 0;
 375         vbifmt->reserved[1] = 0;
 376         return 0;
 377 }
 378
 379 static int ivtv_g_fmt_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
 380 {
 381         struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
 382         struct ivtv_open_id *id = fh;
 383         struct ivtv *itv = id->itv;
 384
 385         vbifmt->reserved[0] = 0;
 386         vbifmt->reserved[1] = 0;
 387         vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
 388
 389         if (id->type == IVTV_DEC_STREAM_TYPE_VBI) {
 390                 vbifmt->service_set = itv->is_50hz ? V4L2_SLICED_VBI_625 :
 391                         V4L2_SLICED_VBI_525;
 392                 ivtv_expand_service_set(vbifmt, itv->is_50hz);
 393                 return 0;
 394         }
 395
 396         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_dbg_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))
 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_dbg_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         regs->size = 4;
 714         if (cmd == VIDIOC_DBG_G_REGISTER)
 715                 regs->val = readl(regs->reg + reg_start);
 716         else
 717                 writel(regs->val, regs->reg + reg_start);
 718         return 0;
 719 }
 720
 721 static int ivtv_g_register(struct file *file, void *fh, struct v4l2_dbg_register *reg)
 722 {
 723         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
 724
 725         if (v4l2_chip_match_host(&reg->match))
 726                 return ivtv_itvc(itv, VIDIOC_DBG_G_REGISTER, reg);
 727         /* TODO: subdev errors should not be ignored, this should become a
 728            subdev helper function. */
 729         ivtv_call_all(itv, core, g_register, reg);
 730         return 0;
 731 }
 732
 733 static int ivtv_s_register(struct file *file, void *fh, struct v4l2_dbg_register *reg)
 734 {
 735         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
 736
 737         if (v4l2_chip_match_host(&reg->match))
 738                 return ivtv_itvc(itv, VIDIOC_DBG_S_REGISTER, reg);
 739         /* TODO: subdev errors should not be ignored, this should become a
 740            subdev helper function. */
 741         ivtv_call_all(itv, core, s_register, reg);
 742         return 0;
 743 }
 744 #endif
 745
 746 static int ivtv_g_priority(struct file *file, void *fh, enum v4l2_priority *p)
 747 {
 748         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
 749
 750         *p = v4l2_prio_max(&itv->prio);
 751
 752         return 0;
 753 }
 754
 755 static int ivtv_s_priority(struct file *file, void *fh, enum v4l2_priority prio)
 756 {
 757         struct ivtv_open_id *id = fh;
 758         struct ivtv *itv = id->itv;
 759
 760         return v4l2_prio_change(&itv->prio, &id->prio, prio);
 761 }
 762
 763 static int ivtv_querycap(struct file *file, void *fh, struct v4l2_capability *vcap)
 764 {
 765         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
 766
 767         strlcpy(vcap->driver, IVTV_DRIVER_NAME, sizeof(vcap->driver));
 768         strlcpy(vcap->card, itv->card_name, sizeof(vcap->card));
 769         snprintf(vcap->bus_info, sizeof(vcap->bus_info), "PCI:%s", pci_name(itv->dev));
 770         vcap->version = IVTV_DRIVER_VERSION;        /* version */
 771         vcap->capabilities = itv->v4l2_cap;         /* capabilities */
 772         return 0;
 773 }
 774
 775 static int ivtv_enumaudio(struct file *file, void *fh, struct v4l2_audio *vin)
 776 {
 777         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
 778
 779         return ivtv_get_audio_input(itv, vin->index, vin);
 780 }
 781
 782 static int ivtv_g_audio(struct file *file, void *fh, struct v4l2_audio *vin)
 783 {
 784         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
 785
 786         vin->index = itv->audio_input;
 787         return ivtv_get_audio_input(itv, vin->index, vin);
 788 }
 789
 790 static int ivtv_s_audio(struct file *file, void *fh, struct v4l2_audio *vout)
 791 {
 792         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
 793
 794         if (vout->index >= itv->nof_audio_inputs)
 795                 return -EINVAL;
 796
 797         itv->audio_input = vout->index;
 798         ivtv_audio_set_io(itv);
 799
 800         return 0;
 801 }
 802
 803 static int ivtv_enumaudout(struct file *file, void *fh, struct v4l2_audioout *vin)
 804 {
 805         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
 806
 807         /* set it to defaults from our table */
 808         return ivtv_get_audio_output(itv, vin->index, vin);
 809 }
 810
 811 static int ivtv_g_audout(struct file *file, void *fh, struct v4l2_audioout *vin)
 812 {
 813         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
 814
 815         vin->index = 0;
 816         return ivtv_get_audio_output(itv, vin->index, vin);
 817 }
 818
 819 static int ivtv_s_audout(struct file *file, void *fh, struct v4l2_audioout *vout)
 820 {
 821         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
 822
 823         return ivtv_get_audio_output(itv, vout->index, vout);
 824 }
 825
 826 static int ivtv_enum_input(struct file *file, void *fh, struct v4l2_input *vin)
 827 {
 828         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
 829
 830         /* set it to defaults from our table */
 831         return ivtv_get_input(itv, vin->index, vin);
 832 }
 833
 834 static int ivtv_enum_output(struct file *file, void *fh, struct v4l2_output *vout)
 835 {
 836         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
 837
 838         return ivtv_get_output(itv, vout->index, vout);
 839 }
 840
 841 static int ivtv_cropcap(struct file *file, void *fh, struct v4l2_cropcap *cropcap)
 842 {
 843         struct ivtv_open_id *id = fh;
 844         struct ivtv *itv = id->itv;
 845         struct yuv_playback_info *yi = &itv->yuv_info;
 846         int streamtype;
 847
 848         streamtype = id->type;
 849
 850         if (cropcap->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
 851                 return -EINVAL;
 852         cropcap->bounds.top = cropcap->bounds.left = 0;
 853         cropcap->bounds.width = 720;
 854         if (cropcap->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
 855                 cropcap->bounds.height = itv->is_50hz ? 576 : 480;
 856                 cropcap->pixelaspect.numerator = itv->is_50hz ? 59 : 10;
 857                 cropcap->pixelaspect.denominator = itv->is_50hz ? 54 : 11;
 858         } else if (streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
 859                 if (yi->track_osd) {
 860                         cropcap->bounds.width = yi->osd_full_w;
 861                         cropcap->bounds.height = yi->osd_full_h;
 862                 } else {
 863                         cropcap->bounds.width = 720;
 864                         cropcap->bounds.height =
 865                                         itv->is_out_50hz ? 576 : 480;
 866                 }
 867                 cropcap->pixelaspect.numerator = itv->is_out_50hz ? 59 : 10;
 868                 cropcap->pixelaspect.denominator = itv->is_out_50hz ? 54 : 11;
 869         } else {
 870                 cropcap->bounds.height = itv->is_out_50hz ? 576 : 480;
 871                 cropcap->pixelaspect.numerator = itv->is_out_50hz ? 59 : 10;
 872                 cropcap->pixelaspect.denominator = itv->is_out_50hz ? 54 : 11;
 873         }
 874         cropcap->defrect = cropcap->bounds;
 875         return 0;
 876 }
 877
 878 static int ivtv_s_crop(struct file *file, void *fh, struct v4l2_crop *crop)
 879 {
 880         struct ivtv_open_id *id = fh;
 881         struct ivtv *itv = id->itv;
 882         struct yuv_playback_info *yi = &itv->yuv_info;
 883         int streamtype;
 884
 885         streamtype = id->type;
 886
 887         if (crop->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
 888             (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) {
 889                 if (streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
 890                         yi->main_rect = crop->c;
 891                         return 0;
 892                 } else {
 893                         if (!ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
 894                                 crop->c.width, crop->c.height, crop->c.left, crop->c.top)) {
 895                                 itv->main_rect = crop->c;
 896                                 return 0;
 897                         }
 898                 }
 899                 return -EINVAL;
 900         }
 901         return -EINVAL;
 902 }
 903
 904 static int ivtv_g_crop(struct file *file, void *fh, struct v4l2_crop *crop)
 905 {
 906         struct ivtv_open_id *id = fh;
 907         struct ivtv *itv = id->itv;
 908         struct yuv_playback_info *yi = &itv->yuv_info;
 909         int streamtype;
 910
 911         streamtype = id->type;
 912
 913         if (crop->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
 914             (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) {
 915                 if (streamtype == IVTV_DEC_STREAM_TYPE_YUV)
 916                         crop->c = yi->main_rect;
 917                 else
 918                         crop->c = itv->main_rect;
 919                 return 0;
 920         }
 921         return -EINVAL;
 922 }
 923
 924 static int ivtv_enum_fmt_vid_cap(struct file *file, void *fh, struct v4l2_fmtdesc *fmt)
 925 {
 926         static struct v4l2_fmtdesc formats[] = {
 927                 { 0, 0, 0,
 928                   "HM12 (YUV 4:2:0)", V4L2_PIX_FMT_HM12,
 929                   { 0, 0, 0, 0 }
 930                 },
 931                 { 1, 0, V4L2_FMT_FLAG_COMPRESSED,
 932                   "MPEG", V4L2_PIX_FMT_MPEG,
 933                   { 0, 0, 0, 0 }
 934                 }
 935         };
 936         enum v4l2_buf_type type = fmt->type;
 937
 938         if (fmt->index > 1)
 939                 return -EINVAL;
 940
 941         *fmt = formats[fmt->index];
 942         fmt->type = type;
 943         return 0;
 944 }
 945
 946 static int ivtv_enum_fmt_vid_out(struct file *file, void *fh, struct v4l2_fmtdesc *fmt)
 947 {
 948         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
 949
 950         static struct v4l2_fmtdesc formats[] = {
 951                 { 0, 0, 0,
 952                   "HM12 (YUV 4:2:0)", V4L2_PIX_FMT_HM12,
 953                   { 0, 0, 0, 0 }
 954                 },
 955                 { 1, 0, V4L2_FMT_FLAG_COMPRESSED,
 956                   "MPEG", V4L2_PIX_FMT_MPEG,
 957                   { 0, 0, 0, 0 }
 958                 }
 959         };
 960         enum v4l2_buf_type type = fmt->type;
 961
 962         if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
 963                 return -EINVAL;
 964
 965         if (fmt->index > 1)
 966                 return -EINVAL;
 967
 968         *fmt = formats[fmt->index];
 969         fmt->type = type;
 970
 971         return 0;
 972 }
 973
 974 static int ivtv_g_input(struct file *file, void *fh, unsigned int *i)
 975 {
 976         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
 977
 978         *i = itv->active_input;
 979
 980         return 0;
 981 }
 982
 983 int ivtv_s_input(struct file *file, void *fh, unsigned int inp)
 984 {
 985         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
 986
 987         if (inp < 0 || inp >= itv->nof_inputs)
 988                 return -EINVAL;
 989
 990         if (inp == itv->active_input) {
 991                 IVTV_DEBUG_INFO("Input unchanged\n");
 992                 return 0;
 993         }
 994
 995         if (atomic_read(&itv->capturing) > 0) {
 996                 return -EBUSY;
 997         }
 998
 999         IVTV_DEBUG_INFO("Changing input from %d to %d\n",
1000                         itv->active_input, inp);
1001
1002         itv->active_input = inp;
1003         /* Set the audio input to whatever is appropriate for the
1004            input type. */
1005         itv->audio_input = itv->card->video_inputs[inp].audio_index;
1006
1007         /* prevent others from messing with the streams until
1008            we're finished changing inputs. */
1009         ivtv_mute(itv);
1010         ivtv_video_set_io(itv);
1011         ivtv_audio_set_io(itv);
1012         ivtv_unmute(itv);
1013
1014         return 0;
1015 }
1016
1017 static int ivtv_g_output(struct file *file, void *fh, unsigned int *i)
1018 {
1019         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
1020
1021         if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1022                 return -EINVAL;
1023
1024         *i = itv->active_output;
1025
1026         return 0;
1027 }
1028
1029 static int ivtv_s_output(struct file *file, void *fh, unsigned int outp)
1030 {
1031         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
1032         struct v4l2_routing route;
1033
1034         if (outp >= itv->card->nof_outputs)
1035                 return -EINVAL;
1036
1037         if (outp == itv->active_output) {
1038                 IVTV_DEBUG_INFO("Output unchanged\n");
1039                 return 0;
1040         }
1041         IVTV_DEBUG_INFO("Changing output from %d to %d\n",
1042                    itv->active_output, outp);
1043
1044         itv->active_output = outp;
1045         route.input = SAA7127_INPUT_TYPE_NORMAL;
1046         route.output = itv->card->video_outputs[outp].video_output;
1047         ivtv_call_hw(itv, IVTV_HW_SAA7127, video, s_routing, &route);
1048
1049         return 0;
1050 }
1051
1052 static int ivtv_g_frequency(struct file *file, void *fh, struct v4l2_frequency *vf)
1053 {
1054         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
1055
1056         if (vf->tuner != 0)
1057                 return -EINVAL;
1058
1059         ivtv_call_all(itv, tuner, g_frequency, vf);
1060         return 0;
1061 }
1062
1063 int ivtv_s_frequency(struct file *file, void *fh, struct v4l2_frequency *vf)
1064 {
1065         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
1066
1067         if (vf->tuner != 0)
1068                 return -EINVAL;
1069
1070         ivtv_mute(itv);
1071         IVTV_DEBUG_INFO("v4l2 ioctl: set frequency %d\n", vf->frequency);
1072         ivtv_call_all(itv, tuner, s_frequency, vf);
1073         ivtv_unmute(itv);
1074         return 0;
1075 }
1076
1077 static int ivtv_g_std(struct file *file, void *fh, v4l2_std_id *std)
1078 {
1079         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
1080
1081         *std = itv->std;
1082         return 0;
1083 }
1084
1085 int ivtv_s_std(struct file *file, void *fh, v4l2_std_id *std)
1086 {
1087         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
1088         struct yuv_playback_info *yi = &itv->yuv_info;
1089
1090         if ((*std & V4L2_STD_ALL) == 0)
1091                 return -EINVAL;
1092
1093         if (*std == itv->std)
1094                 return 0;
1095
1096         if (test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ||
1097             atomic_read(&itv->capturing) > 0 ||
1098             atomic_read(&itv->decoding) > 0) {
1099                 /* Switching standard would turn off the radio or mess
1100                    with already running streams, prevent that by
1101                    returning EBUSY. */
1102                 return -EBUSY;
1103         }
1104
1105         itv->std = *std;
1106         itv->is_60hz = (*std & V4L2_STD_525_60) ? 1 : 0;
1107         itv->params.is_50hz = itv->is_50hz = !itv->is_60hz;
1108         itv->params.width = 720;
1109         itv->params.height = itv->is_50hz ? 576 : 480;
1110         itv->vbi.count = itv->is_50hz ? 18 : 12;
1111         itv->vbi.start[0] = itv->is_50hz ? 6 : 10;
1112         itv->vbi.start[1] = itv->is_50hz ? 318 : 273;
1113
1114         if (itv->hw_flags & IVTV_HW_CX25840)
1115                 itv->vbi.sliced_decoder_line_size = itv->is_60hz ? 272 : 284;
1116
1117         IVTV_DEBUG_INFO("Switching standard to %llx.\n", (unsigned long long)itv->std);
1118
1119         /* Tuner */
1120         ivtv_call_all(itv, tuner, s_std, itv->std);
1121
1122         if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT) {
1123                 /* set display standard */
1124                 itv->std_out = *std;
1125                 itv->is_out_60hz = itv->is_60hz;
1126                 itv->is_out_50hz = itv->is_50hz;
1127                 ivtv_call_all(itv, video, s_std_output, itv->std_out);
1128                 ivtv_vapi(itv, CX2341X_DEC_SET_STANDARD, 1, itv->is_out_50hz);
1129                 itv->main_rect.left = itv->main_rect.top = 0;
1130                 itv->main_rect.width = 720;
1131                 itv->main_rect.height = itv->params.height;
1132                 ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
1133                         720, itv->main_rect.height, 0, 0);
1134                 yi->main_rect = itv->main_rect;
1135                 if (!itv->osd_info) {
1136                         yi->osd_full_w = 720;
1137                         yi->osd_full_h = itv->is_out_50hz ? 576 : 480;
1138                 }
1139         }
1140         return 0;
1141 }
1142
1143 static int ivtv_s_tuner(struct file *file, void *fh, struct v4l2_tuner *vt)
1144 {
1145         struct ivtv_open_id *id = fh;
1146         struct ivtv *itv = id->itv;
1147
1148         if (vt->index != 0)
1149                 return -EINVAL;
1150
1151         ivtv_call_all(itv, tuner, s_tuner, vt);
1152
1153         return 0;
1154 }
1155
1156 static int ivtv_g_tuner(struct file *file, void *fh, struct v4l2_tuner *vt)
1157 {
1158         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
1159
1160         if (vt->index != 0)
1161                 return -EINVAL;
1162
1163         ivtv_call_all(itv, tuner, g_tuner, vt);
1164
1165         if (test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags)) {
1166                 strlcpy(vt->name, "ivtv Radio Tuner", sizeof(vt->name));
1167                 vt->type = V4L2_TUNER_RADIO;
1168         } else {
1169                 strlcpy(vt->name, "ivtv TV Tuner", sizeof(vt->name));
1170                 vt->type = V4L2_TUNER_ANALOG_TV;
1171         }
1172
1173         return 0;
1174 }
1175
1176 static int ivtv_g_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_sliced_vbi_cap *cap)
1177 {
1178         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
1179         int set = itv->is_50hz ? V4L2_SLICED_VBI_625 : V4L2_SLICED_VBI_525;
1180         int f, l;
1181
1182         if (cap->type == V4L2_BUF_TYPE_SLICED_VBI_CAPTURE) {
1183                 for (f = 0; f < 2; f++) {
1184                         for (l = 0; l < 24; l++) {
1185                                 if (valid_service_line(f, l, itv->is_50hz))
1186                                         cap->service_lines[f][l] = set;
1187                         }
1188                 }
1189                 return 0;
1190         }
1191         if (cap->type == V4L2_BUF_TYPE_SLICED_VBI_OUTPUT) {
1192                 if (!(itv->v4l2_cap & V4L2_CAP_SLICED_VBI_OUTPUT))
1193                         return -EINVAL;
1194                 if (itv->is_60hz) {
1195                         cap->service_lines[0][21] = V4L2_SLICED_CAPTION_525;
1196                         cap->service_lines[1][21] = V4L2_SLICED_CAPTION_525;
1197                 } else {
1198                         cap->service_lines[0][23] = V4L2_SLICED_WSS_625;
1199                         cap->service_lines[0][16] = V4L2_SLICED_VPS;
1200                 }
1201                 return 0;
1202         }
1203         return -EINVAL;
1204 }
1205
1206 static int ivtv_g_enc_index(struct file *file, void *fh, struct v4l2_enc_idx *idx)
1207 {
1208         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
1209         struct v4l2_enc_idx_entry *e = idx->entry;
1210         int entries;
1211         int i;
1212
1213         entries = (itv->pgm_info_write_idx + IVTV_MAX_PGM_INDEX - itv->pgm_info_read_idx) %
1214                                 IVTV_MAX_PGM_INDEX;
1215         if (entries > V4L2_ENC_IDX_ENTRIES)
1216                 entries = V4L2_ENC_IDX_ENTRIES;
1217         idx->entries = 0;
1218         for (i = 0; i < entries; i++) {
1219                 *e = itv->pgm_info[(itv->pgm_info_read_idx + i) % IVTV_MAX_PGM_INDEX];
1220                 if ((e->flags & V4L2_ENC_IDX_FRAME_MASK) <= V4L2_ENC_IDX_FRAME_B) {
1221                         idx->entries++;
1222                         e++;
1223                 }
1224         }
1225         itv->pgm_info_read_idx = (itv->pgm_info_read_idx + idx->entries) % IVTV_MAX_PGM_INDEX;
1226         return 0;
1227 }
1228
1229 static int ivtv_encoder_cmd(struct file *file, void *fh, struct v4l2_encoder_cmd *enc)
1230 {
1231         struct ivtv_open_id *id = fh;
1232         struct ivtv *itv = id->itv;
1233
1234
1235         switch (enc->cmd) {
1236         case V4L2_ENC_CMD_START:
1237                 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
1238                 enc->flags = 0;
1239                 return ivtv_start_capture(id);
1240
1241         case V4L2_ENC_CMD_STOP:
1242                 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
1243                 enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END;
1244                 ivtv_stop_capture(id, enc->flags & V4L2_ENC_CMD_STOP_AT_GOP_END);
1245                 return 0;
1246
1247         case V4L2_ENC_CMD_PAUSE:
1248                 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
1249                 enc->flags = 0;
1250
1251                 if (!atomic_read(&itv->capturing))
1252                         return -EPERM;
1253                 if (test_and_set_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags))
1254                         return 0;
1255
1256                 ivtv_mute(itv);
1257                 ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 0);
1258                 break;
1259
1260         case V4L2_ENC_CMD_RESUME:
1261                 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
1262                 enc->flags = 0;
1263
1264                 if (!atomic_read(&itv->capturing))
1265                         return -EPERM;
1266
1267                 if (!test_and_clear_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags))
1268                         return 0;
1269
1270                 ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 1);
1271                 ivtv_unmute(itv);
1272                 break;
1273         default:
1274                 IVTV_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd);
1275                 return -EINVAL;
1276         }
1277
1278         return 0;
1279 }
1280
1281 static int ivtv_try_encoder_cmd(struct file *file, void *fh, struct v4l2_encoder_cmd *enc)
1282 {
1283         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
1284
1285         switch (enc->cmd) {
1286         case V4L2_ENC_CMD_START:
1287                 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
1288                 enc->flags = 0;
1289                 return 0;
1290
1291         case V4L2_ENC_CMD_STOP:
1292                 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
1293                 enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END;
1294                 return 0;
1295
1296         case V4L2_ENC_CMD_PAUSE:
1297                 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
1298                 enc->flags = 0;
1299                 return 0;
1300
1301         case V4L2_ENC_CMD_RESUME:
1302                 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
1303                 enc->flags = 0;
1304                 return 0;
1305         default:
1306                 IVTV_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd);
1307                 return -EINVAL;
1308         }
1309 }
1310
1311 static int ivtv_g_fbuf(struct file *file, void *fh, struct v4l2_framebuffer *fb)
1312 {
1313         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
1314         u32 data[CX2341X_MBOX_MAX_DATA];
1315         struct yuv_playback_info *yi = &itv->yuv_info;
1316
1317         int pixfmt;
1318         static u32 pixel_format[16] = {
1319                 V4L2_PIX_FMT_PAL8, /* Uses a 256-entry RGB colormap */
1320                 V4L2_PIX_FMT_RGB565,
1321                 V4L2_PIX_FMT_RGB555,
1322                 V4L2_PIX_FMT_RGB444,
1323                 V4L2_PIX_FMT_RGB32,
1324                 0,
1325                 0,
1326                 0,
1327                 V4L2_PIX_FMT_PAL8, /* Uses a 256-entry YUV colormap */
1328                 V4L2_PIX_FMT_YUV565,
1329                 V4L2_PIX_FMT_YUV555,
1330                 V4L2_PIX_FMT_YUV444,
1331                 V4L2_PIX_FMT_YUV32,
1332                 0,
1333                 0,
1334                 0,
1335         };
1336
1337         if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1338                 return -EINVAL;
1339         if (!itv->osd_video_pbase)
1340                 return -EINVAL;
1341
1342         fb->capability = V4L2_FBUF_CAP_EXTERNOVERLAY | V4L2_FBUF_CAP_CHROMAKEY |
1343                 V4L2_FBUF_CAP_GLOBAL_ALPHA;
1344
1345         ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0);
1346         data[0] |= (read_reg(0x2a00) >> 7) & 0x40;
1347         pixfmt = (data[0] >> 3) & 0xf;
1348
1349         fb->fmt.pixelformat = pixel_format[pixfmt];
1350         fb->fmt.width = itv->osd_rect.width;
1351         fb->fmt.height = itv->osd_rect.height;
1352         fb->fmt.field = V4L2_FIELD_INTERLACED;
1353         fb->fmt.bytesperline = fb->fmt.width;
1354         fb->fmt.colorspace = V4L2_COLORSPACE_SMPTE170M;
1355         fb->fmt.field = V4L2_FIELD_INTERLACED;
1356         fb->fmt.priv = 0;
1357         if (fb->fmt.pixelformat != V4L2_PIX_FMT_PAL8)
1358                 fb->fmt.bytesperline *= 2;
1359         if (fb->fmt.pixelformat == V4L2_PIX_FMT_RGB32 ||
1360             fb->fmt.pixelformat == V4L2_PIX_FMT_YUV32)
1361                 fb->fmt.bytesperline *= 2;
1362         fb->fmt.sizeimage = fb->fmt.bytesperline * fb->fmt.height;
1363         fb->base = (void *)itv->osd_video_pbase;
1364         fb->flags = 0;
1365
1366         if (itv->osd_chroma_key_state)
1367                 fb->flags |= V4L2_FBUF_FLAG_CHROMAKEY;
1368
1369         if (itv->osd_global_alpha_state)
1370                 fb->flags |= V4L2_FBUF_FLAG_GLOBAL_ALPHA;
1371
1372         if (yi->track_osd)
1373                 fb->flags |= V4L2_FBUF_FLAG_OVERLAY;
1374
1375         pixfmt &= 7;
1376
1377         /* no local alpha for RGB565 or unknown formats */
1378         if (pixfmt == 1 || pixfmt > 4)
1379                 return 0;
1380
1381         /* 16-bit formats have inverted local alpha */
1382         if (pixfmt == 2 || pixfmt == 3)
1383                 fb->capability |= V4L2_FBUF_CAP_LOCAL_INV_ALPHA;
1384         else
1385                 fb->capability |= V4L2_FBUF_CAP_LOCAL_ALPHA;
1386
1387         if (itv->osd_local_alpha_state) {
1388                 /* 16-bit formats have inverted local alpha */
1389                 if (pixfmt == 2 || pixfmt == 3)
1390                         fb->flags |= V4L2_FBUF_FLAG_LOCAL_INV_ALPHA;
1391                 else
1392                         fb->flags |= V4L2_FBUF_FLAG_LOCAL_ALPHA;
1393         }
1394
1395         return 0;
1396 }
1397
1398 static int ivtv_s_fbuf(struct file *file, void *fh, struct v4l2_framebuffer *fb)
1399 {
1400         struct ivtv_open_id *id = fh;
1401         struct ivtv *itv = id->itv;
1402         struct yuv_playback_info *yi = &itv->yuv_info;
1403
1404         if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1405                 return -EINVAL;
1406         if (!itv->osd_video_pbase)
1407                 return -EINVAL;
1408
1409         itv->osd_global_alpha_state = (fb->flags & V4L2_FBUF_FLAG_GLOBAL_ALPHA) != 0;
1410         itv->osd_local_alpha_state =
1411                 (fb->flags & (V4L2_FBUF_FLAG_LOCAL_ALPHA|V4L2_FBUF_FLAG_LOCAL_INV_ALPHA)) != 0;
1412         itv->osd_chroma_key_state = (fb->flags & V4L2_FBUF_FLAG_CHROMAKEY) != 0;
1413         ivtv_set_osd_alpha(itv);
1414         yi->track_osd = (fb->flags & V4L2_FBUF_FLAG_OVERLAY) != 0;
1415         return ivtv_g_fbuf(file, fh, fb);
1416 }
1417
1418 static int ivtv_overlay(struct file *file, void *fh, unsigned int on)
1419 {
1420         struct ivtv_open_id *id = fh;
1421         struct ivtv *itv = id->itv;
1422
1423         if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1424                 return -EINVAL;
1425
1426         ivtv_vapi(itv, CX2341X_OSD_SET_STATE, 1, on != 0);
1427
1428         return 0;
1429 }
1430
1431 static int ivtv_log_status(struct file *file, void *fh)
1432 {
1433         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
1434         u32 data[CX2341X_MBOX_MAX_DATA];
1435
1436         int has_output = itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT;
1437         struct v4l2_input vidin;
1438         struct v4l2_audio audin;
1439         int i;
1440
1441         IVTV_INFO("=================  START STATUS CARD #%d  =================\n",
1442                        itv->instance);
1443         IVTV_INFO("Version: %s Card: %s\n", IVTV_VERSION, itv->card_name);
1444         if (itv->hw_flags & IVTV_HW_TVEEPROM) {
1445                 struct tveeprom tv;
1446
1447                 ivtv_read_eeprom(itv, &tv);
1448         }
1449         ivtv_call_all(itv, core, log_status);
1450         ivtv_get_input(itv, itv->active_input, &vidin);
1451         ivtv_get_audio_input(itv, itv->audio_input, &audin);
1452         IVTV_INFO("Video Input:  %s\n", vidin.name);
1453         IVTV_INFO("Audio Input:  %s%s\n", audin.name,
1454                 (itv->dualwatch_stereo_mode & ~0x300) == 0x200 ? " (Bilingual)" : "");
1455         if (has_output) {
1456                 struct v4l2_output vidout;
1457                 struct v4l2_audioout audout;
1458                 int mode = itv->output_mode;
1459                 static const char * const output_modes[5] = {
1460                         "None",
1461                         "MPEG Streaming",
1462                         "YUV Streaming",
1463                         "YUV Frames",
1464                         "Passthrough",
1465                 };
1466                 static const char * const audio_modes[5] = {
1467                         "Stereo",
1468                         "Left",
1469                         "Right",
1470                         "Mono",
1471                         "Swapped"
1472                 };
1473                 static const char * const alpha_mode[4] = {
1474                         "None",
1475                         "Global",
1476                         "Local",
1477                         "Global and Local"
1478                 };
1479                 static const char * const pixel_format[16] = {
1480                         "ARGB Indexed",
1481                         "RGB 5:6:5",
1482                         "ARGB 1:5:5:5",
1483                         "ARGB 1:4:4:4",
1484                         "ARGB 8:8:8:8",
1485                         "5",
1486                         "6",
1487                         "7",
1488                         "AYUV Indexed",
1489                         "YUV 5:6:5",
1490                         "AYUV 1:5:5:5",
1491                         "AYUV 1:4:4:4",
1492                         "AYUV 8:8:8:8",
1493                         "13",
1494                         "14",
1495                         "15",
1496                 };
1497
1498                 ivtv_get_output(itv, itv->active_output, &vidout);
1499                 ivtv_get_audio_output(itv, 0, &audout);
1500                 IVTV_INFO("Video Output: %s\n", vidout.name);
1501                 IVTV_INFO("Audio Output: %s (Stereo/Bilingual: %s/%s)\n", audout.name,
1502                         audio_modes[itv->audio_stereo_mode],
1503                         audio_modes[itv->audio_bilingual_mode]);
1504                 if (mode < 0 || mode > OUT_PASSTHROUGH)
1505                         mode = OUT_NONE;
1506                 IVTV_INFO("Output Mode:  %s\n", output_modes[mode]);
1507                 ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0);
1508                 data[0] |= (read_reg(0x2a00) >> 7) & 0x40;
1509                 IVTV_INFO("Overlay:      %s, Alpha: %s, Pixel Format: %s\n",
1510                         data[0] & 1 ? "On" : "Off",
1511                         alpha_mode[(data[0] >> 1) & 0x3],
1512                         pixel_format[(data[0] >> 3) & 0xf]);
1513         }
1514         IVTV_INFO("Tuner:  %s\n",
1515                 test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ? "Radio" : "TV");
1516         cx2341x_log_status(&itv->params, itv->device.name);
1517         IVTV_INFO("Status flags:    0x%08lx\n", itv->i_flags);
1518         for (i = 0; i < IVTV_MAX_STREAMS; i++) {
1519                 struct ivtv_stream *s = &itv->streams[i];
1520
1521                 if (s->v4l2dev == NULL || s->buffers == 0)
1522                         continue;
1523                 IVTV_INFO("Stream %s: status 0x%04lx, %d%% of %d KiB (%d buffers) in use\n", s->name, s->s_flags,
1524                                 (s->buffers - s->q_free.buffers) * 100 / s->buffers,
1525                                 (s->buffers * s->buf_size) / 1024, s->buffers);
1526         }
1527
1528         IVTV_INFO("Read MPG/VBI: %lld/%lld bytes\n",
1529                         (long long)itv->mpg_data_received,
1530                         (long long)itv->vbi_data_inserted);
1531         IVTV_INFO("==================  END STATUS CARD #%d  ==================\n",
1532                         itv->instance);
1533
1534         return 0;
1535 }
1536
1537 static int ivtv_decoder_ioctls(struct file *filp, unsigned int cmd, void *arg)
1538 {
1539         struct ivtv_open_id *id = (struct ivtv_open_id *)filp->private_data;
1540         struct ivtv *itv = id->itv;
1541         int nonblocking = filp->f_flags & O_NONBLOCK;
1542         struct ivtv_stream *s = &itv->streams[id->type];
1543
1544         switch (cmd) {
1545         case IVTV_IOC_DMA_FRAME: {
1546                 struct ivtv_dma_frame *args = arg;
1547
1548                 IVTV_DEBUG_IOCTL("IVTV_IOC_DMA_FRAME\n");
1549                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1550                         return -EINVAL;
1551                 if (args->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
1552                         return -EINVAL;
1553                 if (itv->output_mode == OUT_UDMA_YUV && args->y_source == NULL)
1554                         return 0;
1555                 if (ivtv_start_decoding(id, id->type)) {
1556                         return -EBUSY;
1557                 }
1558                 if (ivtv_set_output_mode(itv, OUT_UDMA_YUV) != OUT_UDMA_YUV) {
1559                         ivtv_release_stream(s);
1560                         return -EBUSY;
1561                 }
1562                 /* Mark that this file handle started the UDMA_YUV mode */
1563                 id->yuv_frames = 1;
1564                 if (args->y_source == NULL)
1565                         return 0;
1566                 return ivtv_yuv_prep_frame(itv, args);
1567         }
1568
1569         case VIDEO_GET_PTS: {
1570                 u32 data[CX2341X_MBOX_MAX_DATA];
1571                 u64 *pts = arg;
1572
1573                 IVTV_DEBUG_IOCTL("VIDEO_GET_PTS\n");
1574                 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) {
1575                         *pts = s->dma_pts;
1576                         break;
1577                 }
1578                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1579                         return -EINVAL;
1580
1581                 if (test_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags)) {
1582                         *pts = (u64) ((u64)itv->last_dec_timing[2] << 32) |
1583                                         (u64)itv->last_dec_timing[1];
1584                         break;
1585                 }
1586                 *pts = 0;
1587                 if (atomic_read(&itv->decoding)) {
1588                         if (ivtv_api(itv, CX2341X_DEC_GET_TIMING_INFO, 5, data)) {
1589                                 IVTV_DEBUG_WARN("GET_TIMING: couldn't read clock\n");
1590                                 return -EIO;
1591                         }
1592                         memcpy(itv->last_dec_timing, data, sizeof(itv->last_dec_timing));
1593                         set_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags);
1594                         *pts = (u64) ((u64) data[2] << 32) | (u64) data[1];
1595                         /*timing->scr = (u64) (((u64) data[4] << 32) | (u64) (data[3]));*/
1596                 }
1597                 break;
1598         }
1599
1600         case VIDEO_GET_FRAME_COUNT: {
1601                 u32 data[CX2341X_MBOX_MAX_DATA];
1602                 u64 *frame = arg;
1603
1604                 IVTV_DEBUG_IOCTL("VIDEO_GET_FRAME_COUNT\n");
1605                 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) {
1606                         *frame = 0;
1607                         break;
1608                 }
1609                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1610                         return -EINVAL;
1611
1612                 if (test_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags)) {
1613                         *frame = itv->last_dec_timing[0];
1614                         break;
1615                 }
1616                 *frame = 0;
1617                 if (atomic_read(&itv->decoding)) {
1618                         if (ivtv_api(itv, CX2341X_DEC_GET_TIMING_INFO, 5, data)) {
1619                                 IVTV_DEBUG_WARN("GET_TIMING: couldn't read clock\n");
1620                                 return -EIO;
1621                         }
1622                         memcpy(itv->last_dec_timing, data, sizeof(itv->last_dec_timing));
1623                         set_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags);
1624                         *frame = data[0];
1625                 }
1626                 break;
1627         }
1628
1629         case VIDEO_PLAY: {
1630                 struct video_command vc;
1631
1632                 IVTV_DEBUG_IOCTL("VIDEO_PLAY\n");
1633                 memset(&vc, 0, sizeof(vc));
1634                 vc.cmd = VIDEO_CMD_PLAY;
1635                 return ivtv_video_command(itv, id, &vc, 0);
1636         }
1637
1638         case VIDEO_STOP: {
1639                 struct video_command vc;
1640
1641                 IVTV_DEBUG_IOCTL("VIDEO_STOP\n");
1642                 memset(&vc, 0, sizeof(vc));
1643                 vc.cmd = VIDEO_CMD_STOP;
1644                 vc.flags = VIDEO_CMD_STOP_TO_BLACK | VIDEO_CMD_STOP_IMMEDIATELY;
1645                 return ivtv_video_command(itv, id, &vc, 0);
1646         }
1647
1648         case VIDEO_FREEZE: {
1649                 struct video_command vc;
1650
1651                 IVTV_DEBUG_IOCTL("VIDEO_FREEZE\n");
1652                 memset(&vc, 0, sizeof(vc));
1653                 vc.cmd = VIDEO_CMD_FREEZE;
1654                 return ivtv_video_command(itv, id, &vc, 0);
1655         }
1656
1657         case VIDEO_CONTINUE: {
1658                 struct video_command vc;
1659
1660                 IVTV_DEBUG_IOCTL("VIDEO_CONTINUE\n");
1661                 memset(&vc, 0, sizeof(vc));
1662                 vc.cmd = VIDEO_CMD_CONTINUE;
1663                 return ivtv_video_command(itv, id, &vc, 0);
1664         }
1665
1666         case VIDEO_COMMAND:
1667         case VIDEO_TRY_COMMAND: {
1668                 struct video_command *vc = arg;
1669                 int try = (cmd == VIDEO_TRY_COMMAND);
1670
1671                 if (try)
1672                         IVTV_DEBUG_IOCTL("VIDEO_TRY_COMMAND %d\n", vc->cmd);
1673                 else
1674                         IVTV_DEBUG_IOCTL("VIDEO_COMMAND %d\n", vc->cmd);
1675                 return ivtv_video_command(itv, id, vc, try);
1676         }
1677
1678         case VIDEO_GET_EVENT: {
1679                 struct video_event *ev = arg;
1680                 DEFINE_WAIT(wait);
1681
1682                 IVTV_DEBUG_IOCTL("VIDEO_GET_EVENT\n");
1683                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1684                         return -EINVAL;
1685                 memset(ev, 0, sizeof(*ev));
1686                 set_bit(IVTV_F_I_EV_VSYNC_ENABLED, &itv->i_flags);
1687
1688                 while (1) {
1689                         if (test_and_clear_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags))
1690                                 ev->type = VIDEO_EVENT_DECODER_STOPPED;
1691                         else if (test_and_clear_bit(IVTV_F_I_EV_VSYNC, &itv->i_flags)) {
1692                                 ev->type = VIDEO_EVENT_VSYNC;
1693                                 ev->u.vsync_field = test_bit(IVTV_F_I_EV_VSYNC_FIELD, &itv->i_flags) ?
1694                                         VIDEO_VSYNC_FIELD_ODD : VIDEO_VSYNC_FIELD_EVEN;
1695                                 if (itv->output_mode == OUT_UDMA_YUV &&
1696                                         (itv->yuv_info.lace_mode & IVTV_YUV_MODE_MASK) ==
1697                                                                 IVTV_YUV_MODE_PROGRESSIVE) {
1698                                         ev->u.vsync_field = VIDEO_VSYNC_FIELD_PROGRESSIVE;
1699                                 }
1700                         }
1701                         if (ev->type)
1702                                 return 0;
1703                         if (nonblocking)
1704                                 return -EAGAIN;
1705                         /* Wait for event. Note that serialize_lock is locked,
1706                            so to allow other processes to access the driver while
1707                            we are waiting unlock first and later lock again. */
1708                         mutex_unlock(&itv->serialize_lock);
1709                         prepare_to_wait(&itv->event_waitq, &wait, TASK_INTERRUPTIBLE);
1710                         if ((itv->i_flags & (IVTV_F_I_EV_DEC_STOPPED|IVTV_F_I_EV_VSYNC)) == 0)
1711                                 schedule();
1712                         finish_wait(&itv->event_waitq, &wait);
1713                         mutex_lock(&itv->serialize_lock);
1714                         if (signal_pending(current)) {
1715                                 /* return if a signal was received */
1716                                 IVTV_DEBUG_INFO("User stopped wait for event\n");
1717                                 return -EINTR;
1718                         }
1719                 }
1720                 break;
1721         }
1722
1723         default:
1724                 return -EINVAL;
1725         }
1726         return 0;
1727 }
1728
1729 static long ivtv_default(struct file *file, void *fh, int cmd, void *arg)
1730 {
1731         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
1732
1733         switch (cmd) {
1734         case VIDIOC_INT_S_AUDIO_ROUTING: {
1735                 struct v4l2_routing *route = arg;
1736
1737                 ivtv_call_hw(itv, itv->card->hw_audio, audio, s_routing, route);
1738                 break;
1739         }
1740
1741         case VIDIOC_INT_RESET: {
1742                 u32 val = *(u32 *)arg;
1743
1744                 if ((val == 0 && itv->options.newi2c) || (val & 0x01))
1745                         ivtv_reset_ir_gpio(itv);
1746                 if (val & 0x02)
1747                         v4l2_subdev_call(itv->sd_video, core, reset, 0);
1748                 break;
1749         }
1750
1751         default:
1752                 return -EINVAL;
1753         }
1754         return 0;
1755 }
1756
1757 static long ivtv_serialized_ioctl(struct ivtv *itv, struct file *filp,
1758                 unsigned int cmd, unsigned long arg)
1759 {
1760         struct video_device *vfd = video_devdata(filp);
1761         struct ivtv_open_id *id = (struct ivtv_open_id *)filp->private_data;
1762         long ret;
1763
1764         /* Filter dvb ioctls that cannot be handled by the v4l ioctl framework */
1765         switch (cmd) {
1766         case VIDEO_SELECT_SOURCE:
1767                 IVTV_DEBUG_IOCTL("VIDEO_SELECT_SOURCE\n");
1768                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1769                         return -EINVAL;
1770                 return ivtv_passthrough_mode(itv, arg == VIDEO_SOURCE_DEMUX);
1771
1772         case AUDIO_SET_MUTE:
1773                 IVTV_DEBUG_IOCTL("AUDIO_SET_MUTE\n");
1774                 itv->speed_mute_audio = arg;
1775                 return 0;
1776
1777         case AUDIO_CHANNEL_SELECT:
1778                 IVTV_DEBUG_IOCTL("AUDIO_CHANNEL_SELECT\n");
1779                 if (arg > AUDIO_STEREO_SWAPPED)
1780                         return -EINVAL;
1781                 itv->audio_stereo_mode = arg;
1782                 ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode);
1783                 return 0;
1784
1785         case AUDIO_BILINGUAL_CHANNEL_SELECT:
1786                 IVTV_DEBUG_IOCTL("AUDIO_BILINGUAL_CHANNEL_SELECT\n");
1787                 if (arg > AUDIO_STEREO_SWAPPED)
1788                         return -EINVAL;
1789                 itv->audio_bilingual_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 IVTV_IOC_DMA_FRAME:
1794         case VIDEO_GET_PTS:
1795         case VIDEO_GET_FRAME_COUNT:
1796         case VIDEO_GET_EVENT:
1797         case VIDEO_PLAY:
1798         case VIDEO_STOP:
1799         case VIDEO_FREEZE:
1800         case VIDEO_CONTINUE:
1801         case VIDEO_COMMAND:
1802         case VIDEO_TRY_COMMAND:
1803                 return ivtv_decoder_ioctls(filp, cmd, (void *)arg);
1804
1805         default:
1806                 break;
1807         }
1808
1809         /* check priority */
1810         switch (cmd) {
1811         case VIDIOC_S_CTRL:
1812         case VIDIOC_S_STD:
1813         case VIDIOC_S_INPUT:
1814         case VIDIOC_S_OUTPUT:
1815         case VIDIOC_S_TUNER:
1816         case VIDIOC_S_FREQUENCY:
1817         case VIDIOC_S_FMT:
1818         case VIDIOC_S_CROP:
1819         case VIDIOC_S_AUDIO:
1820         case VIDIOC_S_AUDOUT:
1821         case VIDIOC_S_EXT_CTRLS:
1822         case VIDIOC_S_FBUF:
1823         case VIDIOC_OVERLAY:
1824                 ret = v4l2_prio_check(&itv->prio, &id->prio);
1825                 if (ret)
1826                         return ret;
1827         }
1828
1829         if (ivtv_debug & IVTV_DBGFLG_IOCTL)
1830                 vfd->debug = V4L2_DEBUG_IOCTL | V4L2_DEBUG_IOCTL_ARG;
1831         ret = video_ioctl2(filp, cmd, arg);
1832         vfd->debug = 0;
1833         return ret;
1834 }
1835
1836 long ivtv_v4l2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
1837 {
1838         struct ivtv_open_id *id = (struct ivtv_open_id *)filp->private_data;
1839         struct ivtv *itv = id->itv;
1840         long res;
1841
1842         mutex_lock(&itv->serialize_lock);
1843         res = ivtv_serialized_ioctl(itv, filp, cmd, arg);
1844         mutex_unlock(&itv->serialize_lock);
1845         return res;
1846 }
1847
1848 static const struct v4l2_ioctl_ops ivtv_ioctl_ops = {
1849         .vidioc_querycap                    = ivtv_querycap,
1850         .vidioc_g_priority                  = ivtv_g_priority,
1851         .vidioc_s_priority                  = ivtv_s_priority,
1852         .vidioc_s_audio                     = ivtv_s_audio,
1853         .vidioc_g_audio                     = ivtv_g_audio,
1854         .vidioc_enumaudio                   = ivtv_enumaudio,
1855         .vidioc_s_audout                    = ivtv_s_audout,
1856         .vidioc_g_audout                    = ivtv_g_audout,
1857         .vidioc_enum_input                  = ivtv_enum_input,
1858         .vidioc_enum_output                 = ivtv_enum_output,
1859         .vidioc_enumaudout                  = ivtv_enumaudout,
1860         .vidioc_cropcap                     = ivtv_cropcap,
1861         .vidioc_s_crop                      = ivtv_s_crop,
1862         .vidioc_g_crop                      = ivtv_g_crop,
1863         .vidioc_g_input                     = ivtv_g_input,
1864         .vidioc_s_input                     = ivtv_s_input,
1865         .vidioc_g_output                    = ivtv_g_output,
1866         .vidioc_s_output                    = ivtv_s_output,
1867         .vidioc_g_frequency                 = ivtv_g_frequency,
1868         .vidioc_s_frequency                 = ivtv_s_frequency,
1869         .vidioc_s_tuner                     = ivtv_s_tuner,
1870         .vidioc_g_tuner                     = ivtv_g_tuner,
1871         .vidioc_g_enc_index                 = ivtv_g_enc_index,
1872         .vidioc_g_fbuf                      = ivtv_g_fbuf,
1873         .vidioc_s_fbuf                      = ivtv_s_fbuf,
1874         .vidioc_g_std                       = ivtv_g_std,
1875         .vidioc_s_std                       = ivtv_s_std,
1876         .vidioc_overlay                     = ivtv_overlay,
1877         .vidioc_log_status                  = ivtv_log_status,
1878         .vidioc_enum_fmt_vid_cap            = ivtv_enum_fmt_vid_cap,
1879         .vidioc_encoder_cmd                 = ivtv_encoder_cmd,
1880         .vidioc_try_encoder_cmd             = ivtv_try_encoder_cmd,
1881         .vidioc_enum_fmt_vid_out            = ivtv_enum_fmt_vid_out,
1882         .vidioc_g_fmt_vid_cap               = ivtv_g_fmt_vid_cap,
1883         .vidioc_g_fmt_vbi_cap               = ivtv_g_fmt_vbi_cap,
1884         .vidioc_g_fmt_sliced_vbi_cap        = ivtv_g_fmt_sliced_vbi_cap,
1885         .vidioc_g_fmt_vid_out               = ivtv_g_fmt_vid_out,
1886         .vidioc_g_fmt_vid_out_overlay       = ivtv_g_fmt_vid_out_overlay,
1887         .vidioc_g_fmt_sliced_vbi_out        = ivtv_g_fmt_sliced_vbi_out,
1888         .vidioc_s_fmt_vid_cap               = ivtv_s_fmt_vid_cap,
1889         .vidioc_s_fmt_vbi_cap               = ivtv_s_fmt_vbi_cap,
1890         .vidioc_s_fmt_sliced_vbi_cap        = ivtv_s_fmt_sliced_vbi_cap,
1891         .vidioc_s_fmt_vid_out               = ivtv_s_fmt_vid_out,
1892         .vidioc_s_fmt_vid_out_overlay       = ivtv_s_fmt_vid_out_overlay,
1893         .vidioc_s_fmt_sliced_vbi_out        = ivtv_s_fmt_sliced_vbi_out,
1894         .vidioc_try_fmt_vid_cap             = ivtv_try_fmt_vid_cap,
1895         .vidioc_try_fmt_vbi_cap             = ivtv_try_fmt_vbi_cap,
1896         .vidioc_try_fmt_sliced_vbi_cap      = ivtv_try_fmt_sliced_vbi_cap,
1897         .vidioc_try_fmt_vid_out             = ivtv_try_fmt_vid_out,
1898         .vidioc_try_fmt_vid_out_overlay     = ivtv_try_fmt_vid_out_overlay,
1899         .vidioc_try_fmt_sliced_vbi_out      = ivtv_try_fmt_sliced_vbi_out,
1900         .vidioc_g_sliced_vbi_cap            = ivtv_g_sliced_vbi_cap,
1901         .vidioc_g_chip_ident                = ivtv_g_chip_ident,
1902 #ifdef CONFIG_VIDEO_ADV_DEBUG
1903         .vidioc_g_register                  = ivtv_g_register,
1904         .vidioc_s_register                  = ivtv_s_register,
1905 #endif
1906         .vidioc_default                     = ivtv_default,
1907         .vidioc_queryctrl                   = ivtv_queryctrl,
1908         .vidioc_querymenu                   = ivtv_querymenu,
1909         .vidioc_g_ext_ctrls                 = ivtv_g_ext_ctrls,
1910         .vidioc_s_ext_ctrls                 = ivtv_s_ext_ctrls,
1911         .vidioc_try_ext_ctrls               = ivtv_try_ext_ctrls,
1912 };
1913
1914 void ivtv_set_funcs(struct video_device *vdev)
1915 {
1916         vdev->ioctl_ops = &ivtv_ioctl_ops;
1917 }