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 <media/v4l2-event.h>
  39 #include <linux/dvb/audio.h>
  40
  41 u16 ivtv_service2vbi(int type)
  42 {
  43         switch (type) {
  44                 case V4L2_SLICED_TELETEXT_B:
  45                         return IVTV_SLICED_TYPE_TELETEXT_B;
  46                 case V4L2_SLICED_CAPTION_525:
  47                         return IVTV_SLICED_TYPE_CAPTION_525;
  48                 case V4L2_SLICED_WSS_625:
  49                         return IVTV_SLICED_TYPE_WSS_625;
  50                 case V4L2_SLICED_VPS:
  51                         return IVTV_SLICED_TYPE_VPS;
  52                 default:
  53                         return 0;
  54         }
  55 }
  56
  57 static int valid_service_line(int field, int line, int is_pal)
  58 {
  59         return (is_pal && line >= 6 && (line != 23 || field == 0)) ||
  60                (!is_pal && line >= 10 && line < 22);
  61 }
  62
  63 static u16 select_service_from_set(int field, int line, u16 set, int is_pal)
  64 {
  65         u16 valid_set = (is_pal ? V4L2_SLICED_VBI_625 : V4L2_SLICED_VBI_525);
  66         int i;
  67
  68         set = set & valid_set;
  69         if (set == 0 || !valid_service_line(field, line, is_pal)) {
  70                 return 0;
  71         }
  72         if (!is_pal) {
  73                 if (line == 21 && (set & V4L2_SLICED_CAPTION_525))
  74                         return V4L2_SLICED_CAPTION_525;
  75         }
  76         else {
  77                 if (line == 16 && field == 0 && (set & V4L2_SLICED_VPS))
  78                         return V4L2_SLICED_VPS;
  79                 if (line == 23 && field == 0 && (set & V4L2_SLICED_WSS_625))
  80                         return V4L2_SLICED_WSS_625;
  81                 if (line == 23)
  82                         return 0;
  83         }
  84         for (i = 0; i < 32; i++) {
  85                 if ((1 << i) & set)
  86                         return 1 << i;
  87         }
  88         return 0;
  89 }
  90
  91 void ivtv_expand_service_set(struct v4l2_sliced_vbi_format *fmt, int is_pal)
  92 {
  93         u16 set = fmt->service_set;
  94         int f, l;
  95
  96         fmt->service_set = 0;
  97         for (f = 0; f < 2; f++) {
  98                 for (l = 0; l < 24; l++) {
  99                         fmt->service_lines[f][l] = select_service_from_set(f, l, set, is_pal);
 100                 }
 101         }
 102 }
 103
 104 static void check_service_set(struct v4l2_sliced_vbi_format *fmt, int is_pal)
 105 {
 106         int f, l;
 107
 108         for (f = 0; f < 2; f++) {
 109                 for (l = 0; l < 24; l++) {
 110                         fmt->service_lines[f][l] = select_service_from_set(f, l, fmt->service_lines[f][l], is_pal);
 111                 }
 112         }
 113 }
 114
 115 u16 ivtv_get_service_set(struct v4l2_sliced_vbi_format *fmt)
 116 {
 117         int f, l;
 118         u16 set = 0;
 119
 120         for (f = 0; f < 2; f++) {
 121                 for (l = 0; l < 24; l++) {
 122                         set |= fmt->service_lines[f][l];
 123                 }
 124         }
 125         return set;
 126 }
 127
 128 void ivtv_set_osd_alpha(struct ivtv *itv)
 129 {
 130         ivtv_vapi(itv, CX2341X_OSD_SET_GLOBAL_ALPHA, 3,
 131                 itv->osd_global_alpha_state, itv->osd_global_alpha, !itv->osd_local_alpha_state);
 132         ivtv_vapi(itv, CX2341X_OSD_SET_CHROMA_KEY, 2, itv->osd_chroma_key_state, itv->osd_chroma_key);
 133 }
 134
 135 int ivtv_set_speed(struct ivtv *itv, int speed)
 136 {
 137         u32 data[CX2341X_MBOX_MAX_DATA];
 138         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] = v4l2_ctrl_g_ctrl(itv->cxhdl.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                 mutex_unlock(&itv->serialize_lock);
 183                 prepare_to_wait(&itv->dma_waitq, &wait, TASK_INTERRUPTIBLE);
 184                 while (test_bit(IVTV_F_I_DMA, &itv->i_flags)) {
 185                         got_sig = signal_pending(current);
 186                         if (got_sig)
 187                                 break;
 188                         got_sig = 0;
 189                         schedule();
 190                 }
 191                 finish_wait(&itv->dma_waitq, &wait);
 192                 mutex_lock(&itv->serialize_lock);
 193                 if (got_sig)
 194                         return -EINTR;
 195
 196                 /* Change Speed safely */
 197                 ivtv_api(itv, CX2341X_DEC_SET_PLAYBACK_SPEED, 7, data);
 198                 IVTV_DEBUG_INFO("Setting Speed to 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n",
 199                                 data[0], data[1], data[2], data[3], data[4], data[5], data[6]);
 200         }
 201         if (single_step) {
 202                 speed = (speed < 0) ? -1 : 1;
 203                 ivtv_vapi(itv, CX2341X_DEC_STEP_VIDEO, 1, 0);
 204         }
 205         itv->speed = speed;
 206         return 0;
 207 }
 208
 209 static int ivtv_validate_speed(int cur_speed, int new_speed)
 210 {
 211         int fact = new_speed < 0 ? -1 : 1;
 212         int s;
 213
 214         if (cur_speed == 0)
 215                 cur_speed = 1000;
 216         if (new_speed < 0)
 217                 new_speed = -new_speed;
 218         if (cur_speed < 0)
 219                 cur_speed = -cur_speed;
 220
 221         if (cur_speed <= new_speed) {
 222                 if (new_speed > 1500)
 223                         return fact * 2000;
 224                 if (new_speed > 1000)
 225                         return fact * 1500;
 226         }
 227         else {
 228                 if (new_speed >= 2000)
 229                         return fact * 2000;
 230                 if (new_speed >= 1500)
 231                         return fact * 1500;
 232                 if (new_speed >= 1000)
 233                         return fact * 1000;
 234         }
 235         if (new_speed == 0)
 236                 return 1000;
 237         if (new_speed == 1 || new_speed == 1000)
 238                 return fact * new_speed;
 239
 240         s = new_speed;
 241         new_speed = 1000 / new_speed;
 242         if (1000 / cur_speed == new_speed)
 243                 new_speed += (cur_speed < s) ? -1 : 1;
 244         if (new_speed > 60) return 1000 / (fact * 60);
 245         return 1000 / (fact * new_speed);
 246 }
 247
 248 static int ivtv_video_command(struct ivtv *itv, struct ivtv_open_id *id,
 249                 struct v4l2_decoder_cmd *dc, int try)
 250 {
 251         struct ivtv_stream *s = &itv->streams[IVTV_DEC_STREAM_TYPE_MPG];
 252
 253         if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
 254                 return -EINVAL;
 255
 256         switch (dc->cmd) {
 257         case V4L2_DEC_CMD_START: {
 258                 dc->flags &= V4L2_DEC_CMD_START_MUTE_AUDIO;
 259                 dc->start.speed = ivtv_validate_speed(itv->speed, dc->start.speed);
 260                 if (dc->start.speed < 0)
 261                         dc->start.format = V4L2_DEC_START_FMT_GOP;
 262                 else
 263                         dc->start.format = V4L2_DEC_START_FMT_NONE;
 264                 if (dc->start.speed != 500 && dc->start.speed != 1500)
 265                         dc->flags = dc->start.speed == 1000 ? 0 :
 266                                         V4L2_DEC_CMD_START_MUTE_AUDIO;
 267                 if (try) break;
 268
 269                 itv->speed_mute_audio = dc->flags & V4L2_DEC_CMD_START_MUTE_AUDIO;
 270                 if (ivtv_set_output_mode(itv, OUT_MPG) != OUT_MPG)
 271                         return -EBUSY;
 272                 if (test_and_clear_bit(IVTV_F_I_DEC_PAUSED, &itv->i_flags)) {
 273                         /* forces ivtv_set_speed to be called */
 274                         itv->speed = 0;
 275                 }
 276                 return ivtv_start_decoding(id, dc->start.speed);
 277         }
 278
 279         case V4L2_DEC_CMD_STOP:
 280                 dc->flags &= V4L2_DEC_CMD_STOP_IMMEDIATELY | V4L2_DEC_CMD_STOP_TO_BLACK;
 281                 if (dc->flags & V4L2_DEC_CMD_STOP_IMMEDIATELY)
 282                         dc->stop.pts = 0;
 283                 if (try) break;
 284                 if (atomic_read(&itv->decoding) == 0)
 285                         return 0;
 286                 if (itv->output_mode != OUT_MPG)
 287                         return -EBUSY;
 288
 289                 itv->output_mode = OUT_NONE;
 290                 return ivtv_stop_v4l2_decode_stream(s, dc->flags, dc->stop.pts);
 291
 292         case V4L2_DEC_CMD_PAUSE:
 293                 dc->flags &= V4L2_DEC_CMD_PAUSE_TO_BLACK;
 294                 if (try) break;
 295                 if (itv->output_mode != OUT_MPG)
 296                         return -EBUSY;
 297                 if (atomic_read(&itv->decoding) > 0) {
 298                         ivtv_vapi(itv, CX2341X_DEC_PAUSE_PLAYBACK, 1,
 299                                 (dc->flags & V4L2_DEC_CMD_PAUSE_TO_BLACK) ? 1 : 0);
 300                         set_bit(IVTV_F_I_DEC_PAUSED, &itv->i_flags);
 301                 }
 302                 break;
 303
 304         case V4L2_DEC_CMD_RESUME:
 305                 dc->flags = 0;
 306                 if (try) break;
 307                 if (itv->output_mode != OUT_MPG)
 308                         return -EBUSY;
 309                 if (test_and_clear_bit(IVTV_F_I_DEC_PAUSED, &itv->i_flags)) {
 310                         int speed = itv->speed;
 311                         itv->speed = 0;
 312                         return ivtv_start_decoding(id, speed);
 313                 }
 314                 break;
 315
 316         default:
 317                 return -EINVAL;
 318         }
 319         return 0;
 320 }
 321
 322 static int ivtv_g_fmt_sliced_vbi_out(struct file *file, void *fh, struct v4l2_format *fmt)
 323 {
 324         struct ivtv *itv = fh2id(fh)->itv;
 325         struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
 326
 327         vbifmt->reserved[0] = 0;
 328         vbifmt->reserved[1] = 0;
 329         if (!(itv->v4l2_cap & V4L2_CAP_SLICED_VBI_OUTPUT))
 330                 return -EINVAL;
 331         vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
 332         if (itv->is_60hz) {
 333                 vbifmt->service_lines[0][21] = V4L2_SLICED_CAPTION_525;
 334                 vbifmt->service_lines[1][21] = V4L2_SLICED_CAPTION_525;
 335         } else {
 336                 vbifmt->service_lines[0][23] = V4L2_SLICED_WSS_625;
 337                 vbifmt->service_lines[0][16] = V4L2_SLICED_VPS;
 338         }
 339         vbifmt->service_set = ivtv_get_service_set(vbifmt);
 340         return 0;
 341 }
 342
 343 static int ivtv_g_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
 344 {
 345         struct ivtv_open_id *id = fh2id(fh);
 346         struct ivtv *itv = id->itv;
 347         struct v4l2_pix_format *pixfmt = &fmt->fmt.pix;
 348
 349         pixfmt->width = itv->cxhdl.width;
 350         pixfmt->height = itv->cxhdl.height;
 351         pixfmt->colorspace = V4L2_COLORSPACE_SMPTE170M;
 352         pixfmt->field = V4L2_FIELD_INTERLACED;
 353         pixfmt->priv = 0;
 354         if (id->type == IVTV_ENC_STREAM_TYPE_YUV) {
 355                 pixfmt->pixelformat = V4L2_PIX_FMT_HM12;
 356                 /* YUV size is (Y=(h*720) + UV=(h*(720/2))) */
 357                 pixfmt->sizeimage = pixfmt->height * 720 * 3 / 2;
 358                 pixfmt->bytesperline = 720;
 359         } else {
 360                 pixfmt->pixelformat = V4L2_PIX_FMT_MPEG;
 361                 pixfmt->sizeimage = 128 * 1024;
 362                 pixfmt->bytesperline = 0;
 363         }
 364         return 0;
 365 }
 366
 367 static int ivtv_g_fmt_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
 368 {
 369         struct ivtv *itv = fh2id(fh)->itv;
 370         struct v4l2_vbi_format *vbifmt = &fmt->fmt.vbi;
 371
 372         vbifmt->sampling_rate = 27000000;
 373         vbifmt->offset = 248;
 374         vbifmt->samples_per_line = itv->vbi.raw_decoder_line_size - 4;
 375         vbifmt->sample_format = V4L2_PIX_FMT_GREY;
 376         vbifmt->start[0] = itv->vbi.start[0];
 377         vbifmt->start[1] = itv->vbi.start[1];
 378         vbifmt->count[0] = vbifmt->count[1] = itv->vbi.count;
 379         vbifmt->flags = 0;
 380         vbifmt->reserved[0] = 0;
 381         vbifmt->reserved[1] = 0;
 382         return 0;
 383 }
 384
 385 static int ivtv_g_fmt_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
 386 {
 387         struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
 388         struct ivtv_open_id *id = fh2id(fh);
 389         struct ivtv *itv = id->itv;
 390
 391         vbifmt->reserved[0] = 0;
 392         vbifmt->reserved[1] = 0;
 393         vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
 394
 395         if (id->type == IVTV_DEC_STREAM_TYPE_VBI) {
 396                 vbifmt->service_set = itv->is_50hz ? V4L2_SLICED_VBI_625 :
 397                         V4L2_SLICED_VBI_525;
 398                 ivtv_expand_service_set(vbifmt, itv->is_50hz);
 399                 return 0;
 400         }
 401
 402         v4l2_subdev_call(itv->sd_video, vbi, g_sliced_fmt, vbifmt);
 403         vbifmt->service_set = ivtv_get_service_set(vbifmt);
 404         return 0;
 405 }
 406
 407 static int ivtv_g_fmt_vid_out(struct file *file, void *fh, struct v4l2_format *fmt)
 408 {
 409         struct ivtv_open_id *id = fh2id(fh);
 410         struct ivtv *itv = id->itv;
 411         struct v4l2_pix_format *pixfmt = &fmt->fmt.pix;
 412
 413         if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
 414                 return -EINVAL;
 415         pixfmt->width = itv->main_rect.width;
 416         pixfmt->height = itv->main_rect.height;
 417         pixfmt->colorspace = V4L2_COLORSPACE_SMPTE170M;
 418         pixfmt->field = V4L2_FIELD_INTERLACED;
 419         pixfmt->priv = 0;
 420         if (id->type == IVTV_DEC_STREAM_TYPE_YUV) {
 421                 switch (itv->yuv_info.lace_mode & IVTV_YUV_MODE_MASK) {
 422                 case IVTV_YUV_MODE_INTERLACED:
 423                         pixfmt->field = (itv->yuv_info.lace_mode & IVTV_YUV_SYNC_MASK) ?
 424                                 V4L2_FIELD_INTERLACED_BT : V4L2_FIELD_INTERLACED_TB;
 425                         break;
 426                 case IVTV_YUV_MODE_PROGRESSIVE:
 427                         pixfmt->field = V4L2_FIELD_NONE;
 428                         break;
 429                 default:
 430                         pixfmt->field = V4L2_FIELD_ANY;
 431                         break;
 432                 }
 433                 pixfmt->pixelformat = V4L2_PIX_FMT_HM12;
 434                 pixfmt->bytesperline = 720;
 435                 pixfmt->width = itv->yuv_info.v4l2_src_w;
 436                 pixfmt->height = itv->yuv_info.v4l2_src_h;
 437                 /* YUV size is (Y=(h*w) + UV=(h*(w/2))) */
 438                 pixfmt->sizeimage =
 439                         1080 * ((pixfmt->height + 31) & ~31);
 440         } else {
 441                 pixfmt->pixelformat = V4L2_PIX_FMT_MPEG;
 442                 pixfmt->sizeimage = 128 * 1024;
 443                 pixfmt->bytesperline = 0;
 444         }
 445         return 0;
 446 }
 447
 448 static int ivtv_g_fmt_vid_out_overlay(struct file *file, void *fh, struct v4l2_format *fmt)
 449 {
 450         struct ivtv *itv = fh2id(fh)->itv;
 451         struct v4l2_window *winfmt = &fmt->fmt.win;
 452
 453         if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
 454                 return -EINVAL;
 455         winfmt->chromakey = itv->osd_chroma_key;
 456         winfmt->global_alpha = itv->osd_global_alpha;
 457         winfmt->field = V4L2_FIELD_INTERLACED;
 458         winfmt->clips = NULL;
 459         winfmt->clipcount = 0;
 460         winfmt->bitmap = NULL;
 461         winfmt->w.top = winfmt->w.left = 0;
 462         winfmt->w.width = itv->osd_rect.width;
 463         winfmt->w.height = itv->osd_rect.height;
 464         return 0;
 465 }
 466
 467 static int ivtv_try_fmt_sliced_vbi_out(struct file *file, void *fh, struct v4l2_format *fmt)
 468 {
 469         return ivtv_g_fmt_sliced_vbi_out(file, fh, fmt);
 470 }
 471
 472 static int ivtv_try_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
 473 {
 474         struct ivtv_open_id *id = fh2id(fh);
 475         struct ivtv *itv = id->itv;
 476         int w = fmt->fmt.pix.width;
 477         int h = fmt->fmt.pix.height;
 478         int min_h = 2;
 479
 480         w = min(w, 720);
 481         w = max(w, 2);
 482         if (id->type == IVTV_ENC_STREAM_TYPE_YUV) {
 483                 /* YUV height must be a multiple of 32 */
 484                 h &= ~0x1f;
 485                 min_h = 32;
 486         }
 487         h = min(h, itv->is_50hz ? 576 : 480);
 488         h = max(h, min_h);
 489         ivtv_g_fmt_vid_cap(file, fh, fmt);
 490         fmt->fmt.pix.width = w;
 491         fmt->fmt.pix.height = h;
 492         return 0;
 493 }
 494
 495 static int ivtv_try_fmt_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
 496 {
 497         return ivtv_g_fmt_vbi_cap(file, fh, fmt);
 498 }
 499
 500 static int ivtv_try_fmt_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
 501 {
 502         struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
 503         struct ivtv_open_id *id = fh2id(fh);
 504         struct ivtv *itv = id->itv;
 505
 506         if (id->type == IVTV_DEC_STREAM_TYPE_VBI)
 507                 return ivtv_g_fmt_sliced_vbi_cap(file, fh, fmt);
 508
 509         /* set sliced VBI capture format */
 510         vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
 511         vbifmt->reserved[0] = 0;
 512         vbifmt->reserved[1] = 0;
 513
 514         if (vbifmt->service_set)
 515                 ivtv_expand_service_set(vbifmt, itv->is_50hz);
 516         check_service_set(vbifmt, itv->is_50hz);
 517         vbifmt->service_set = ivtv_get_service_set(vbifmt);
 518         return 0;
 519 }
 520
 521 static int ivtv_try_fmt_vid_out(struct file *file, void *fh, struct v4l2_format *fmt)
 522 {
 523         struct ivtv_open_id *id = fh2id(fh);
 524         s32 w = fmt->fmt.pix.width;
 525         s32 h = fmt->fmt.pix.height;
 526         int field = fmt->fmt.pix.field;
 527         int ret = ivtv_g_fmt_vid_out(file, fh, fmt);
 528
 529         w = min(w, 720);
 530         w = max(w, 2);
 531         /* Why can the height be 576 even when the output is NTSC?
 532
 533            Internally the buffers of the PVR350 are always set to 720x576. The
 534            decoded video frame will always be placed in the top left corner of
 535            this buffer. For any video which is not 720x576, the buffer will
 536            then be cropped to remove the unused right and lower areas, with
 537            the remaining image being scaled by the hardware to fit the display
 538            area. The video can be scaled both up and down, so a 720x480 video
 539            can be displayed full-screen on PAL and a 720x576 video can be
 540            displayed without cropping on NTSC.
 541
 542            Note that the scaling only occurs on the video stream, the osd
 543            resolution is locked to the broadcast standard and not scaled.
 544
 545            Thanks to Ian Armstrong for this explanation. */
 546         h = min(h, 576);
 547         h = max(h, 2);
 548         if (id->type == IVTV_DEC_STREAM_TYPE_YUV)
 549                 fmt->fmt.pix.field = field;
 550         fmt->fmt.pix.width = w;
 551         fmt->fmt.pix.height = h;
 552         return ret;
 553 }
 554
 555 static int ivtv_try_fmt_vid_out_overlay(struct file *file, void *fh, struct v4l2_format *fmt)
 556 {
 557         struct ivtv *itv = fh2id(fh)->itv;
 558         u32 chromakey = fmt->fmt.win.chromakey;
 559         u8 global_alpha = fmt->fmt.win.global_alpha;
 560
 561         if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
 562                 return -EINVAL;
 563         ivtv_g_fmt_vid_out_overlay(file, fh, fmt);
 564         fmt->fmt.win.chromakey = chromakey;
 565         fmt->fmt.win.global_alpha = global_alpha;
 566         return 0;
 567 }
 568
 569 static int ivtv_s_fmt_sliced_vbi_out(struct file *file, void *fh, struct v4l2_format *fmt)
 570 {
 571         return ivtv_g_fmt_sliced_vbi_out(file, fh, fmt);
 572 }
 573
 574 static int ivtv_s_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
 575 {
 576         struct ivtv_open_id *id = fh2id(fh);
 577         struct ivtv *itv = id->itv;
 578         struct v4l2_mbus_framefmt mbus_fmt;
 579         int ret = ivtv_try_fmt_vid_cap(file, fh, fmt);
 580         int w = fmt->fmt.pix.width;
 581         int h = fmt->fmt.pix.height;
 582
 583         if (ret)
 584                 return ret;
 585
 586         if (itv->cxhdl.width == w && itv->cxhdl.height == h)
 587                 return 0;
 588
 589         if (atomic_read(&itv->capturing) > 0)
 590                 return -EBUSY;
 591
 592         itv->cxhdl.width = w;
 593         itv->cxhdl.height = h;
 594         if (v4l2_ctrl_g_ctrl(itv->cxhdl.video_encoding) == V4L2_MPEG_VIDEO_ENCODING_MPEG_1)
 595                 fmt->fmt.pix.width /= 2;
 596         mbus_fmt.width = fmt->fmt.pix.width;
 597         mbus_fmt.height = h;
 598         mbus_fmt.code = V4L2_MBUS_FMT_FIXED;
 599         v4l2_subdev_call(itv->sd_video, video, s_mbus_fmt, &mbus_fmt);
 600         return ivtv_g_fmt_vid_cap(file, fh, fmt);
 601 }
 602
 603 static int ivtv_s_fmt_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
 604 {
 605         struct ivtv *itv = fh2id(fh)->itv;
 606
 607         if (!ivtv_raw_vbi(itv) && atomic_read(&itv->capturing) > 0)
 608                 return -EBUSY;
 609         itv->vbi.sliced_in->service_set = 0;
 610         itv->vbi.in.type = V4L2_BUF_TYPE_VBI_CAPTURE;
 611         v4l2_subdev_call(itv->sd_video, vbi, s_raw_fmt, &fmt->fmt.vbi);
 612         return ivtv_g_fmt_vbi_cap(file, fh, fmt);
 613 }
 614
 615 static int ivtv_s_fmt_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
 616 {
 617         struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
 618         struct ivtv_open_id *id = fh2id(fh);
 619         struct ivtv *itv = id->itv;
 620         int ret = ivtv_try_fmt_sliced_vbi_cap(file, fh, fmt);
 621
 622         if (ret || id->type == IVTV_DEC_STREAM_TYPE_VBI)
 623                 return ret;
 624
 625         check_service_set(vbifmt, itv->is_50hz);
 626         if (ivtv_raw_vbi(itv) && atomic_read(&itv->capturing) > 0)
 627                 return -EBUSY;
 628         itv->vbi.in.type = V4L2_BUF_TYPE_SLICED_VBI_CAPTURE;
 629         v4l2_subdev_call(itv->sd_video, vbi, s_sliced_fmt, vbifmt);
 630         memcpy(itv->vbi.sliced_in, vbifmt, sizeof(*itv->vbi.sliced_in));
 631         return 0;
 632 }
 633
 634 static int ivtv_s_fmt_vid_out(struct file *file, void *fh, struct v4l2_format *fmt)
 635 {
 636         struct ivtv_open_id *id = fh2id(fh);
 637         struct ivtv *itv = id->itv;
 638         struct yuv_playback_info *yi = &itv->yuv_info;
 639         int ret = ivtv_try_fmt_vid_out(file, fh, fmt);
 640
 641         if (ret)
 642                 return ret;
 643
 644         if (id->type != IVTV_DEC_STREAM_TYPE_YUV)
 645                 return 0;
 646
 647         /* Return now if we already have some frame data */
 648         if (yi->stream_size)
 649                 return -EBUSY;
 650
 651         yi->v4l2_src_w = fmt->fmt.pix.width;
 652         yi->v4l2_src_h = fmt->fmt.pix.height;
 653
 654         switch (fmt->fmt.pix.field) {
 655         case V4L2_FIELD_NONE:
 656                 yi->lace_mode = IVTV_YUV_MODE_PROGRESSIVE;
 657                 break;
 658         case V4L2_FIELD_ANY:
 659                 yi->lace_mode = IVTV_YUV_MODE_AUTO;
 660                 break;
 661         case V4L2_FIELD_INTERLACED_BT:
 662                 yi->lace_mode =
 663                         IVTV_YUV_MODE_INTERLACED|IVTV_YUV_SYNC_ODD;
 664                 break;
 665         case V4L2_FIELD_INTERLACED_TB:
 666         default:
 667                 yi->lace_mode = IVTV_YUV_MODE_INTERLACED;
 668                 break;
 669         }
 670         yi->lace_sync_field = (yi->lace_mode & IVTV_YUV_SYNC_MASK) == IVTV_YUV_SYNC_EVEN ? 0 : 1;
 671
 672         if (test_bit(IVTV_F_I_DEC_YUV, &itv->i_flags))
 673                 itv->dma_data_req_size =
 674                         1080 * ((yi->v4l2_src_h + 31) & ~31);
 675
 676         return 0;
 677 }
 678
 679 static int ivtv_s_fmt_vid_out_overlay(struct file *file, void *fh, struct v4l2_format *fmt)
 680 {
 681         struct ivtv *itv = fh2id(fh)->itv;
 682         int ret = ivtv_try_fmt_vid_out_overlay(file, fh, fmt);
 683
 684         if (ret == 0) {
 685                 itv->osd_chroma_key = fmt->fmt.win.chromakey;
 686                 itv->osd_global_alpha = fmt->fmt.win.global_alpha;
 687                 ivtv_set_osd_alpha(itv);
 688         }
 689         return ret;
 690 }
 691
 692 static int ivtv_g_chip_ident(struct file *file, void *fh, struct v4l2_dbg_chip_ident *chip)
 693 {
 694         struct ivtv *itv = fh2id(fh)->itv;
 695
 696         chip->ident = V4L2_IDENT_NONE;
 697         chip->revision = 0;
 698         if (chip->match.type == V4L2_CHIP_MATCH_HOST) {
 699                 if (v4l2_chip_match_host(&chip->match))
 700                         chip->ident = itv->has_cx23415 ? V4L2_IDENT_CX23415 : V4L2_IDENT_CX23416;
 701                 return 0;
 702         }
 703         if (chip->match.type != V4L2_CHIP_MATCH_I2C_DRIVER &&
 704             chip->match.type != V4L2_CHIP_MATCH_I2C_ADDR)
 705                 return -EINVAL;
 706         /* TODO: is this correct? */
 707         return ivtv_call_all_err(itv, core, g_chip_ident, chip);
 708 }
 709
 710 #ifdef CONFIG_VIDEO_ADV_DEBUG
 711 static int ivtv_itvc(struct ivtv *itv, unsigned int cmd, void *arg)
 712 {
 713         struct v4l2_dbg_register *regs = arg;
 714         volatile u8 __iomem *reg_start;
 715
 716         if (!capable(CAP_SYS_ADMIN))
 717                 return -EPERM;
 718         if (regs->reg >= IVTV_REG_OFFSET && regs->reg < IVTV_REG_OFFSET + IVTV_REG_SIZE)
 719                 reg_start = itv->reg_mem - IVTV_REG_OFFSET;
 720         else if (itv->has_cx23415 && regs->reg >= IVTV_DECODER_OFFSET &&
 721                         regs->reg < IVTV_DECODER_OFFSET + IVTV_DECODER_SIZE)
 722                 reg_start = itv->dec_mem - IVTV_DECODER_OFFSET;
 723         else if (regs->reg < IVTV_ENCODER_SIZE)
 724                 reg_start = itv->enc_mem;
 725         else
 726                 return -EINVAL;
 727
 728         regs->size = 4;
 729         if (cmd == VIDIOC_DBG_G_REGISTER)
 730                 regs->val = readl(regs->reg + reg_start);
 731         else
 732                 writel(regs->val, regs->reg + reg_start);
 733         return 0;
 734 }
 735
 736 static int ivtv_g_register(struct file *file, void *fh, struct v4l2_dbg_register *reg)
 737 {
 738         struct ivtv *itv = fh2id(fh)->itv;
 739
 740         if (v4l2_chip_match_host(&reg->match))
 741                 return ivtv_itvc(itv, VIDIOC_DBG_G_REGISTER, reg);
 742         /* TODO: subdev errors should not be ignored, this should become a
 743            subdev helper function. */
 744         ivtv_call_all(itv, core, g_register, reg);
 745         return 0;
 746 }
 747
 748 static int ivtv_s_register(struct file *file, void *fh, struct v4l2_dbg_register *reg)
 749 {
 750         struct ivtv *itv = fh2id(fh)->itv;
 751
 752         if (v4l2_chip_match_host(&reg->match))
 753                 return ivtv_itvc(itv, VIDIOC_DBG_S_REGISTER, reg);
 754         /* TODO: subdev errors should not be ignored, this should become a
 755            subdev helper function. */
 756         ivtv_call_all(itv, core, s_register, reg);
 757         return 0;
 758 }
 759 #endif
 760
 761 static int ivtv_querycap(struct file *file, void *fh, struct v4l2_capability *vcap)
 762 {
 763         struct ivtv_open_id *id = fh2id(file->private_data);
 764         struct ivtv *itv = id->itv;
 765         struct ivtv_stream *s = &itv->streams[id->type];
 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->pdev));
 770         vcap->capabilities = itv->v4l2_cap | V4L2_CAP_DEVICE_CAPS;
 771         vcap->device_caps = s->caps;
 772         return 0;
 773 }
 774
 775 static int ivtv_enumaudio(struct file *file, void *fh, struct v4l2_audio *vin)
 776 {
 777         struct ivtv *itv = fh2id(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 = fh2id(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 = fh2id(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 = fh2id(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 = fh2id(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 = fh2id(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 = fh2id(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 = fh2id(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 = fh2id(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 = fh2id(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 = fh2id(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 = fh2id(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 = fh2id(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 = fh2id(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 = fh2id(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 = fh2id(fh)->itv;
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         ivtv_call_hw(itv, IVTV_HW_SAA7127, video, s_routing,
1045                         SAA7127_INPUT_TYPE_NORMAL,
1046                         itv->card->video_outputs[outp].video_output, 0);
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 = fh2id(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 = fh2id(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 = fh2id(fh)->itv;
1079
1080         *std = itv->std;
1081         return 0;
1082 }
1083
1084 void ivtv_s_std_enc(struct ivtv *itv, v4l2_std_id *std)
1085 {
1086         itv->std = *std;
1087         itv->is_60hz = (*std & V4L2_STD_525_60) ? 1 : 0;
1088         itv->is_50hz = !itv->is_60hz;
1089         cx2341x_handler_set_50hz(&itv->cxhdl, itv->is_50hz);
1090         itv->cxhdl.width = 720;
1091         itv->cxhdl.height = itv->is_50hz ? 576 : 480;
1092         itv->vbi.count = itv->is_50hz ? 18 : 12;
1093         itv->vbi.start[0] = itv->is_50hz ? 6 : 10;
1094         itv->vbi.start[1] = itv->is_50hz ? 318 : 273;
1095
1096         if (itv->hw_flags & IVTV_HW_CX25840)
1097                 itv->vbi.sliced_decoder_line_size = itv->is_60hz ? 272 : 284;
1098
1099         /* Tuner */
1100         ivtv_call_all(itv, core, s_std, itv->std);
1101 }
1102
1103 void ivtv_s_std_dec(struct ivtv *itv, v4l2_std_id *std)
1104 {
1105         struct yuv_playback_info *yi = &itv->yuv_info;
1106         DEFINE_WAIT(wait);
1107         int f;
1108
1109         /* set display standard */
1110         itv->std_out = *std;
1111         itv->is_out_60hz = (*std & V4L2_STD_525_60) ? 1 : 0;
1112         itv->is_out_50hz = !itv->is_out_60hz;
1113         ivtv_call_all(itv, video, s_std_output, itv->std_out);
1114
1115         /*
1116          * The next firmware call is time sensitive. Time it to
1117          * avoid risk of a hard lock, by trying to ensure the call
1118          * happens within the first 100 lines of the top field.
1119          * Make 4 attempts to sync to the decoder before giving up.
1120          */
1121         mutex_unlock(&itv->serialize_lock);
1122         for (f = 0; f < 4; f++) {
1123                 prepare_to_wait(&itv->vsync_waitq, &wait,
1124                                 TASK_UNINTERRUPTIBLE);
1125                 if ((read_reg(IVTV_REG_DEC_LINE_FIELD) >> 16) < 100)
1126                         break;
1127                 schedule_timeout(msecs_to_jiffies(25));
1128         }
1129         finish_wait(&itv->vsync_waitq, &wait);
1130         mutex_lock(&itv->serialize_lock);
1131
1132         if (f == 4)
1133                 IVTV_WARN("Mode change failed to sync to decoder\n");
1134
1135         ivtv_vapi(itv, CX2341X_DEC_SET_STANDARD, 1, itv->is_out_50hz);
1136         itv->main_rect.left = 0;
1137         itv->main_rect.top = 0;
1138         itv->main_rect.width = 720;
1139         itv->main_rect.height = itv->is_out_50hz ? 576 : 480;
1140         ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
1141                 720, itv->main_rect.height, 0, 0);
1142         yi->main_rect = itv->main_rect;
1143         if (!itv->osd_info) {
1144                 yi->osd_full_w = 720;
1145                 yi->osd_full_h = itv->is_out_50hz ? 576 : 480;
1146         }
1147 }
1148
1149 int ivtv_s_std(struct file *file, void *fh, v4l2_std_id *std)
1150 {
1151         struct ivtv *itv = fh2id(fh)->itv;
1152
1153         if ((*std & V4L2_STD_ALL) == 0)
1154                 return -EINVAL;
1155
1156         if (*std == itv->std)
1157                 return 0;
1158
1159         if (test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ||
1160             atomic_read(&itv->capturing) > 0 ||
1161             atomic_read(&itv->decoding) > 0) {
1162                 /* Switching standard would mess with already running
1163                    streams, prevent that by returning EBUSY. */
1164                 return -EBUSY;
1165         }
1166
1167         IVTV_DEBUG_INFO("Switching standard to %llx.\n",
1168                 (unsigned long long)itv->std);
1169
1170         ivtv_s_std_enc(itv, std);
1171         if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)
1172                 ivtv_s_std_dec(itv, std);
1173
1174         return 0;
1175 }
1176
1177 static int ivtv_s_tuner(struct file *file, void *fh, struct v4l2_tuner *vt)
1178 {
1179         struct ivtv_open_id *id = fh2id(fh);
1180         struct ivtv *itv = id->itv;
1181
1182         if (vt->index != 0)
1183                 return -EINVAL;
1184
1185         ivtv_call_all(itv, tuner, s_tuner, vt);
1186
1187         return 0;
1188 }
1189
1190 static int ivtv_g_tuner(struct file *file, void *fh, struct v4l2_tuner *vt)
1191 {
1192         struct ivtv *itv = fh2id(fh)->itv;
1193
1194         if (vt->index != 0)
1195                 return -EINVAL;
1196
1197         ivtv_call_all(itv, tuner, g_tuner, vt);
1198
1199         if (vt->type == V4L2_TUNER_RADIO)
1200                 strlcpy(vt->name, "ivtv Radio Tuner", sizeof(vt->name));
1201         else
1202                 strlcpy(vt->name, "ivtv TV Tuner", sizeof(vt->name));
1203         return 0;
1204 }
1205
1206 static int ivtv_g_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_sliced_vbi_cap *cap)
1207 {
1208         struct ivtv *itv = fh2id(fh)->itv;
1209         int set = itv->is_50hz ? V4L2_SLICED_VBI_625 : V4L2_SLICED_VBI_525;
1210         int f, l;
1211
1212         if (cap->type == V4L2_BUF_TYPE_SLICED_VBI_CAPTURE) {
1213                 for (f = 0; f < 2; f++) {
1214                         for (l = 0; l < 24; l++) {
1215                                 if (valid_service_line(f, l, itv->is_50hz))
1216                                         cap->service_lines[f][l] = set;
1217                         }
1218                 }
1219         } else if (cap->type == V4L2_BUF_TYPE_SLICED_VBI_OUTPUT) {
1220                 if (!(itv->v4l2_cap & V4L2_CAP_SLICED_VBI_OUTPUT))
1221                         return -EINVAL;
1222                 if (itv->is_60hz) {
1223                         cap->service_lines[0][21] = V4L2_SLICED_CAPTION_525;
1224                         cap->service_lines[1][21] = V4L2_SLICED_CAPTION_525;
1225                 } else {
1226                         cap->service_lines[0][23] = V4L2_SLICED_WSS_625;
1227                         cap->service_lines[0][16] = V4L2_SLICED_VPS;
1228                 }
1229         } else {
1230                 return -EINVAL;
1231         }
1232
1233         set = 0;
1234         for (f = 0; f < 2; f++)
1235                 for (l = 0; l < 24; l++)
1236                         set |= cap->service_lines[f][l];
1237         cap->service_set = set;
1238         return 0;
1239 }
1240
1241 static int ivtv_g_enc_index(struct file *file, void *fh, struct v4l2_enc_idx *idx)
1242 {
1243         struct ivtv *itv = fh2id(fh)->itv;
1244         struct v4l2_enc_idx_entry *e = idx->entry;
1245         int entries;
1246         int i;
1247
1248         entries = (itv->pgm_info_write_idx + IVTV_MAX_PGM_INDEX - itv->pgm_info_read_idx) %
1249                                 IVTV_MAX_PGM_INDEX;
1250         if (entries > V4L2_ENC_IDX_ENTRIES)
1251                 entries = V4L2_ENC_IDX_ENTRIES;
1252         idx->entries = 0;
1253         for (i = 0; i < entries; i++) {
1254                 *e = itv->pgm_info[(itv->pgm_info_read_idx + i) % IVTV_MAX_PGM_INDEX];
1255                 if ((e->flags & V4L2_ENC_IDX_FRAME_MASK) <= V4L2_ENC_IDX_FRAME_B) {
1256                         idx->entries++;
1257                         e++;
1258                 }
1259         }
1260         itv->pgm_info_read_idx = (itv->pgm_info_read_idx + idx->entries) % IVTV_MAX_PGM_INDEX;
1261         return 0;
1262 }
1263
1264 static int ivtv_encoder_cmd(struct file *file, void *fh, struct v4l2_encoder_cmd *enc)
1265 {
1266         struct ivtv_open_id *id = fh2id(fh);
1267         struct ivtv *itv = id->itv;
1268
1269
1270         switch (enc->cmd) {
1271         case V4L2_ENC_CMD_START:
1272                 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
1273                 enc->flags = 0;
1274                 return ivtv_start_capture(id);
1275
1276         case V4L2_ENC_CMD_STOP:
1277                 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
1278                 enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END;
1279                 ivtv_stop_capture(id, enc->flags & V4L2_ENC_CMD_STOP_AT_GOP_END);
1280                 return 0;
1281
1282         case V4L2_ENC_CMD_PAUSE:
1283                 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
1284                 enc->flags = 0;
1285
1286                 if (!atomic_read(&itv->capturing))
1287                         return -EPERM;
1288                 if (test_and_set_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags))
1289                         return 0;
1290
1291                 ivtv_mute(itv);
1292                 ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 0);
1293                 break;
1294
1295         case V4L2_ENC_CMD_RESUME:
1296                 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
1297                 enc->flags = 0;
1298
1299                 if (!atomic_read(&itv->capturing))
1300                         return -EPERM;
1301
1302                 if (!test_and_clear_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags))
1303                         return 0;
1304
1305                 ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 1);
1306                 ivtv_unmute(itv);
1307                 break;
1308         default:
1309                 IVTV_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd);
1310                 return -EINVAL;
1311         }
1312
1313         return 0;
1314 }
1315
1316 static int ivtv_try_encoder_cmd(struct file *file, void *fh, struct v4l2_encoder_cmd *enc)
1317 {
1318         struct ivtv *itv = fh2id(fh)->itv;
1319
1320         switch (enc->cmd) {
1321         case V4L2_ENC_CMD_START:
1322                 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
1323                 enc->flags = 0;
1324                 return 0;
1325
1326         case V4L2_ENC_CMD_STOP:
1327                 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
1328                 enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END;
1329                 return 0;
1330
1331         case V4L2_ENC_CMD_PAUSE:
1332                 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
1333                 enc->flags = 0;
1334                 return 0;
1335
1336         case V4L2_ENC_CMD_RESUME:
1337                 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
1338                 enc->flags = 0;
1339                 return 0;
1340         default:
1341                 IVTV_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd);
1342                 return -EINVAL;
1343         }
1344 }
1345
1346 static int ivtv_g_fbuf(struct file *file, void *fh, struct v4l2_framebuffer *fb)
1347 {
1348         struct ivtv *itv = fh2id(fh)->itv;
1349         u32 data[CX2341X_MBOX_MAX_DATA];
1350         struct yuv_playback_info *yi = &itv->yuv_info;
1351
1352         int pixfmt;
1353         static u32 pixel_format[16] = {
1354                 V4L2_PIX_FMT_PAL8, /* Uses a 256-entry RGB colormap */
1355                 V4L2_PIX_FMT_RGB565,
1356                 V4L2_PIX_FMT_RGB555,
1357                 V4L2_PIX_FMT_RGB444,
1358                 V4L2_PIX_FMT_RGB32,
1359                 0,
1360                 0,
1361                 0,
1362                 V4L2_PIX_FMT_PAL8, /* Uses a 256-entry YUV colormap */
1363                 V4L2_PIX_FMT_YUV565,
1364                 V4L2_PIX_FMT_YUV555,
1365                 V4L2_PIX_FMT_YUV444,
1366                 V4L2_PIX_FMT_YUV32,
1367                 0,
1368                 0,
1369                 0,
1370         };
1371
1372         if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1373                 return -EINVAL;
1374         if (!itv->osd_video_pbase)
1375                 return -EINVAL;
1376
1377         fb->capability = V4L2_FBUF_CAP_EXTERNOVERLAY | V4L2_FBUF_CAP_CHROMAKEY |
1378                 V4L2_FBUF_CAP_GLOBAL_ALPHA;
1379
1380         ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0);
1381         data[0] |= (read_reg(0x2a00) >> 7) & 0x40;
1382         pixfmt = (data[0] >> 3) & 0xf;
1383
1384         fb->fmt.pixelformat = pixel_format[pixfmt];
1385         fb->fmt.width = itv->osd_rect.width;
1386         fb->fmt.height = itv->osd_rect.height;
1387         fb->fmt.field = V4L2_FIELD_INTERLACED;
1388         fb->fmt.bytesperline = fb->fmt.width;
1389         fb->fmt.colorspace = V4L2_COLORSPACE_SMPTE170M;
1390         fb->fmt.field = V4L2_FIELD_INTERLACED;
1391         fb->fmt.priv = 0;
1392         if (fb->fmt.pixelformat != V4L2_PIX_FMT_PAL8)
1393                 fb->fmt.bytesperline *= 2;
1394         if (fb->fmt.pixelformat == V4L2_PIX_FMT_RGB32 ||
1395             fb->fmt.pixelformat == V4L2_PIX_FMT_YUV32)
1396                 fb->fmt.bytesperline *= 2;
1397         fb->fmt.sizeimage = fb->fmt.bytesperline * fb->fmt.height;
1398         fb->base = (void *)itv->osd_video_pbase;
1399         fb->flags = 0;
1400
1401         if (itv->osd_chroma_key_state)
1402                 fb->flags |= V4L2_FBUF_FLAG_CHROMAKEY;
1403
1404         if (itv->osd_global_alpha_state)
1405                 fb->flags |= V4L2_FBUF_FLAG_GLOBAL_ALPHA;
1406
1407         if (yi->track_osd)
1408                 fb->flags |= V4L2_FBUF_FLAG_OVERLAY;
1409
1410         pixfmt &= 7;
1411
1412         /* no local alpha for RGB565 or unknown formats */
1413         if (pixfmt == 1 || pixfmt > 4)
1414                 return 0;
1415
1416         /* 16-bit formats have inverted local alpha */
1417         if (pixfmt == 2 || pixfmt == 3)
1418                 fb->capability |= V4L2_FBUF_CAP_LOCAL_INV_ALPHA;
1419         else
1420                 fb->capability |= V4L2_FBUF_CAP_LOCAL_ALPHA;
1421
1422         if (itv->osd_local_alpha_state) {
1423                 /* 16-bit formats have inverted local alpha */
1424                 if (pixfmt == 2 || pixfmt == 3)
1425                         fb->flags |= V4L2_FBUF_FLAG_LOCAL_INV_ALPHA;
1426                 else
1427                         fb->flags |= V4L2_FBUF_FLAG_LOCAL_ALPHA;
1428         }
1429
1430         return 0;
1431 }
1432
1433 static int ivtv_s_fbuf(struct file *file, void *fh, struct v4l2_framebuffer *fb)
1434 {
1435         struct ivtv_open_id *id = fh2id(fh);
1436         struct ivtv *itv = id->itv;
1437         struct yuv_playback_info *yi = &itv->yuv_info;
1438
1439         if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1440                 return -EINVAL;
1441         if (!itv->osd_video_pbase)
1442                 return -EINVAL;
1443
1444         itv->osd_global_alpha_state = (fb->flags & V4L2_FBUF_FLAG_GLOBAL_ALPHA) != 0;
1445         itv->osd_local_alpha_state =
1446                 (fb->flags & (V4L2_FBUF_FLAG_LOCAL_ALPHA|V4L2_FBUF_FLAG_LOCAL_INV_ALPHA)) != 0;
1447         itv->osd_chroma_key_state = (fb->flags & V4L2_FBUF_FLAG_CHROMAKEY) != 0;
1448         ivtv_set_osd_alpha(itv);
1449         yi->track_osd = (fb->flags & V4L2_FBUF_FLAG_OVERLAY) != 0;
1450         return ivtv_g_fbuf(file, fh, fb);
1451 }
1452
1453 static int ivtv_overlay(struct file *file, void *fh, unsigned int on)
1454 {
1455         struct ivtv_open_id *id = fh2id(fh);
1456         struct ivtv *itv = id->itv;
1457
1458         if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1459                 return -EINVAL;
1460
1461         ivtv_vapi(itv, CX2341X_OSD_SET_STATE, 1, on != 0);
1462
1463         return 0;
1464 }
1465
1466 static int ivtv_subscribe_event(struct v4l2_fh *fh, struct v4l2_event_subscription *sub)
1467 {
1468         switch (sub->type) {
1469         case V4L2_EVENT_VSYNC:
1470         case V4L2_EVENT_EOS:
1471         case V4L2_EVENT_CTRL:
1472                 return v4l2_event_subscribe(fh, sub, 0);
1473         default:
1474                 return -EINVAL;
1475         }
1476 }
1477
1478 static int ivtv_log_status(struct file *file, void *fh)
1479 {
1480         struct ivtv *itv = fh2id(fh)->itv;
1481         u32 data[CX2341X_MBOX_MAX_DATA];
1482
1483         int has_output = itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT;
1484         struct v4l2_input vidin;
1485         struct v4l2_audio audin;
1486         int i;
1487
1488         IVTV_INFO("Version: %s Card: %s\n", IVTV_VERSION, itv->card_name);
1489         if (itv->hw_flags & IVTV_HW_TVEEPROM) {
1490                 struct tveeprom tv;
1491
1492                 ivtv_read_eeprom(itv, &tv);
1493         }
1494         ivtv_call_all(itv, core, log_status);
1495         ivtv_get_input(itv, itv->active_input, &vidin);
1496         ivtv_get_audio_input(itv, itv->audio_input, &audin);
1497         IVTV_INFO("Video Input:  %s\n", vidin.name);
1498         IVTV_INFO("Audio Input:  %s%s\n", audin.name,
1499                 (itv->dualwatch_stereo_mode & ~0x300) == 0x200 ? " (Bilingual)" : "");
1500         if (has_output) {
1501                 struct v4l2_output vidout;
1502                 struct v4l2_audioout audout;
1503                 int mode = itv->output_mode;
1504                 static const char * const output_modes[5] = {
1505                         "None",
1506                         "MPEG Streaming",
1507                         "YUV Streaming",
1508                         "YUV Frames",
1509                         "Passthrough",
1510                 };
1511                 static const char * const alpha_mode[4] = {
1512                         "None",
1513                         "Global",
1514                         "Local",
1515                         "Global and Local"
1516                 };
1517                 static const char * const pixel_format[16] = {
1518                         "ARGB Indexed",
1519                         "RGB 5:6:5",
1520                         "ARGB 1:5:5:5",
1521                         "ARGB 1:4:4:4",
1522                         "ARGB 8:8:8:8",
1523                         "5",
1524                         "6",
1525                         "7",
1526                         "AYUV Indexed",
1527                         "YUV 5:6:5",
1528                         "AYUV 1:5:5:5",
1529                         "AYUV 1:4:4:4",
1530                         "AYUV 8:8:8:8",
1531                         "13",
1532                         "14",
1533                         "15",
1534                 };
1535
1536                 ivtv_get_output(itv, itv->active_output, &vidout);
1537                 ivtv_get_audio_output(itv, 0, &audout);
1538                 IVTV_INFO("Video Output: %s\n", vidout.name);
1539                 if (mode < 0 || mode > OUT_PASSTHROUGH)
1540                         mode = OUT_NONE;
1541                 IVTV_INFO("Output Mode:  %s\n", output_modes[mode]);
1542                 ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0);
1543                 data[0] |= (read_reg(0x2a00) >> 7) & 0x40;
1544                 IVTV_INFO("Overlay:      %s, Alpha: %s, Pixel Format: %s\n",
1545                         data[0] & 1 ? "On" : "Off",
1546                         alpha_mode[(data[0] >> 1) & 0x3],
1547                         pixel_format[(data[0] >> 3) & 0xf]);
1548         }
1549         IVTV_INFO("Tuner:  %s\n",
1550                 test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ? "Radio" : "TV");
1551         v4l2_ctrl_handler_log_status(&itv->cxhdl.hdl, itv->v4l2_dev.name);
1552         IVTV_INFO("Status flags:    0x%08lx\n", itv->i_flags);
1553         for (i = 0; i < IVTV_MAX_STREAMS; i++) {
1554                 struct ivtv_stream *s = &itv->streams[i];
1555
1556                 if (s->vdev == NULL || s->buffers == 0)
1557                         continue;
1558                 IVTV_INFO("Stream %s: status 0x%04lx, %d%% of %d KiB (%d buffers) in use\n", s->name, s->s_flags,
1559                                 (s->buffers - s->q_free.buffers) * 100 / s->buffers,
1560                                 (s->buffers * s->buf_size) / 1024, s->buffers);
1561         }
1562
1563         IVTV_INFO("Read MPG/VBI: %lld/%lld bytes\n",
1564                         (long long)itv->mpg_data_received,
1565                         (long long)itv->vbi_data_inserted);
1566         return 0;
1567 }
1568
1569 static int ivtv_decoder_cmd(struct file *file, void *fh, struct v4l2_decoder_cmd *dec)
1570 {
1571         struct ivtv_open_id *id = fh2id(file->private_data);
1572         struct ivtv *itv = id->itv;
1573
1574         IVTV_DEBUG_IOCTL("VIDIOC_DECODER_CMD %d\n", dec->cmd);
1575         return ivtv_video_command(itv, id, dec, false);
1576 }
1577
1578 static int ivtv_try_decoder_cmd(struct file *file, void *fh, struct v4l2_decoder_cmd *dec)
1579 {
1580         struct ivtv_open_id *id = fh2id(file->private_data);
1581         struct ivtv *itv = id->itv;
1582
1583         IVTV_DEBUG_IOCTL("VIDIOC_TRY_DECODER_CMD %d\n", dec->cmd);
1584         return ivtv_video_command(itv, id, dec, true);
1585 }
1586
1587 static int ivtv_decoder_ioctls(struct file *filp, unsigned int cmd, void *arg)
1588 {
1589         struct ivtv_open_id *id = fh2id(filp->private_data);
1590         struct ivtv *itv = id->itv;
1591         int nonblocking = filp->f_flags & O_NONBLOCK;
1592         struct ivtv_stream *s = &itv->streams[id->type];
1593         unsigned long iarg = (unsigned long)arg;
1594
1595         switch (cmd) {
1596         case IVTV_IOC_DMA_FRAME: {
1597                 struct ivtv_dma_frame *args = arg;
1598
1599                 IVTV_DEBUG_IOCTL("IVTV_IOC_DMA_FRAME\n");
1600                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1601                         return -EINVAL;
1602                 if (args->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
1603                         return -EINVAL;
1604                 if (itv->output_mode == OUT_UDMA_YUV && args->y_source == NULL)
1605                         return 0;
1606                 if (ivtv_start_decoding(id, id->type)) {
1607                         return -EBUSY;
1608                 }
1609                 if (ivtv_set_output_mode(itv, OUT_UDMA_YUV) != OUT_UDMA_YUV) {
1610                         ivtv_release_stream(s);
1611                         return -EBUSY;
1612                 }
1613                 /* Mark that this file handle started the UDMA_YUV mode */
1614                 id->yuv_frames = 1;
1615                 if (args->y_source == NULL)
1616                         return 0;
1617                 return ivtv_yuv_prep_frame(itv, args);
1618         }
1619
1620         case IVTV_IOC_PASSTHROUGH_MODE:
1621                 IVTV_DEBUG_IOCTL("IVTV_IOC_PASSTHROUGH_MODE\n");
1622                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1623                         return -EINVAL;
1624                 return ivtv_passthrough_mode(itv, *(int *)arg != 0);
1625
1626         case VIDEO_GET_PTS: {
1627                 s64 *pts = arg;
1628                 s64 frame;
1629
1630                 IVTV_DEBUG_IOCTL("VIDEO_GET_PTS\n");
1631                 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) {
1632                         *pts = s->dma_pts;
1633                         break;
1634                 }
1635                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1636                         return -EINVAL;
1637                 return ivtv_g_pts_frame(itv, pts, &frame);
1638         }
1639
1640         case VIDEO_GET_FRAME_COUNT: {
1641                 s64 *frame = arg;
1642                 s64 pts;
1643
1644                 IVTV_DEBUG_IOCTL("VIDEO_GET_FRAME_COUNT\n");
1645                 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) {
1646                         *frame = 0;
1647                         break;
1648                 }
1649                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1650                         return -EINVAL;
1651                 return ivtv_g_pts_frame(itv, &pts, frame);
1652         }
1653
1654         case VIDEO_PLAY: {
1655                 struct v4l2_decoder_cmd dc;
1656
1657                 IVTV_DEBUG_IOCTL("VIDEO_PLAY\n");
1658                 memset(&dc, 0, sizeof(dc));
1659                 dc.cmd = V4L2_DEC_CMD_START;
1660                 return ivtv_video_command(itv, id, &dc, 0);
1661         }
1662
1663         case VIDEO_STOP: {
1664                 struct v4l2_decoder_cmd dc;
1665
1666                 IVTV_DEBUG_IOCTL("VIDEO_STOP\n");
1667                 memset(&dc, 0, sizeof(dc));
1668                 dc.cmd = V4L2_DEC_CMD_STOP;
1669                 dc.flags = V4L2_DEC_CMD_STOP_TO_BLACK | V4L2_DEC_CMD_STOP_IMMEDIATELY;
1670                 return ivtv_video_command(itv, id, &dc, 0);
1671         }
1672
1673         case VIDEO_FREEZE: {
1674                 struct v4l2_decoder_cmd dc;
1675
1676                 IVTV_DEBUG_IOCTL("VIDEO_FREEZE\n");
1677                 memset(&dc, 0, sizeof(dc));
1678                 dc.cmd = V4L2_DEC_CMD_PAUSE;
1679                 return ivtv_video_command(itv, id, &dc, 0);
1680         }
1681
1682         case VIDEO_CONTINUE: {
1683                 struct v4l2_decoder_cmd dc;
1684
1685                 IVTV_DEBUG_IOCTL("VIDEO_CONTINUE\n");
1686                 memset(&dc, 0, sizeof(dc));
1687                 dc.cmd = V4L2_DEC_CMD_RESUME;
1688                 return ivtv_video_command(itv, id, &dc, 0);
1689         }
1690
1691         case VIDEO_COMMAND:
1692         case VIDEO_TRY_COMMAND: {
1693                 /* Note: struct v4l2_decoder_cmd has the same layout as
1694                    struct video_command */
1695                 struct v4l2_decoder_cmd *dc = arg;
1696                 int try = (cmd == VIDEO_TRY_COMMAND);
1697
1698                 if (try)
1699                         IVTV_DEBUG_IOCTL("VIDEO_TRY_COMMAND %d\n", dc->cmd);
1700                 else
1701                         IVTV_DEBUG_IOCTL("VIDEO_COMMAND %d\n", dc->cmd);
1702                 return ivtv_video_command(itv, id, dc, try);
1703         }
1704
1705         case VIDEO_GET_EVENT: {
1706                 struct video_event *ev = arg;
1707                 DEFINE_WAIT(wait);
1708
1709                 IVTV_DEBUG_IOCTL("VIDEO_GET_EVENT\n");
1710                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1711                         return -EINVAL;
1712                 memset(ev, 0, sizeof(*ev));
1713                 set_bit(IVTV_F_I_EV_VSYNC_ENABLED, &itv->i_flags);
1714
1715                 while (1) {
1716                         if (test_and_clear_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags))
1717                                 ev->type = VIDEO_EVENT_DECODER_STOPPED;
1718                         else if (test_and_clear_bit(IVTV_F_I_EV_VSYNC, &itv->i_flags)) {
1719                                 ev->type = VIDEO_EVENT_VSYNC;
1720                                 ev->u.vsync_field = test_bit(IVTV_F_I_EV_VSYNC_FIELD, &itv->i_flags) ?
1721                                         VIDEO_VSYNC_FIELD_ODD : VIDEO_VSYNC_FIELD_EVEN;
1722                                 if (itv->output_mode == OUT_UDMA_YUV &&
1723                                         (itv->yuv_info.lace_mode & IVTV_YUV_MODE_MASK) ==
1724                                                                 IVTV_YUV_MODE_PROGRESSIVE) {
1725                                         ev->u.vsync_field = VIDEO_VSYNC_FIELD_PROGRESSIVE;
1726                                 }
1727                         }
1728                         if (ev->type)
1729                                 return 0;
1730                         if (nonblocking)
1731                                 return -EAGAIN;
1732                         /* Wait for event. Note that serialize_lock is locked,
1733                            so to allow other processes to access the driver while
1734                            we are waiting unlock first and later lock again. */
1735                         mutex_unlock(&itv->serialize_lock);
1736                         prepare_to_wait(&itv->event_waitq, &wait, TASK_INTERRUPTIBLE);
1737                         if (!test_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags) &&
1738                             !test_bit(IVTV_F_I_EV_VSYNC, &itv->i_flags))
1739                                 schedule();
1740                         finish_wait(&itv->event_waitq, &wait);
1741                         mutex_lock(&itv->serialize_lock);
1742                         if (signal_pending(current)) {
1743                                 /* return if a signal was received */
1744                                 IVTV_DEBUG_INFO("User stopped wait for event\n");
1745                                 return -EINTR;
1746                         }
1747                 }
1748                 break;
1749         }
1750
1751         case VIDEO_SELECT_SOURCE:
1752                 IVTV_DEBUG_IOCTL("VIDEO_SELECT_SOURCE\n");
1753                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1754                         return -EINVAL;
1755                 return ivtv_passthrough_mode(itv, iarg == VIDEO_SOURCE_DEMUX);
1756
1757         case AUDIO_SET_MUTE:
1758                 IVTV_DEBUG_IOCTL("AUDIO_SET_MUTE\n");
1759                 itv->speed_mute_audio = iarg;
1760                 return 0;
1761
1762         case AUDIO_CHANNEL_SELECT:
1763                 IVTV_DEBUG_IOCTL("AUDIO_CHANNEL_SELECT\n");
1764                 if (iarg > AUDIO_STEREO_SWAPPED)
1765                         return -EINVAL;
1766                 return v4l2_ctrl_s_ctrl(itv->ctrl_audio_playback, iarg + 1);
1767
1768         case AUDIO_BILINGUAL_CHANNEL_SELECT:
1769                 IVTV_DEBUG_IOCTL("AUDIO_BILINGUAL_CHANNEL_SELECT\n");
1770                 if (iarg > AUDIO_STEREO_SWAPPED)
1771                         return -EINVAL;
1772                 return v4l2_ctrl_s_ctrl(itv->ctrl_audio_multilingual_playback, iarg + 1);
1773
1774         default:
1775                 return -EINVAL;
1776         }
1777         return 0;
1778 }
1779
1780 static long ivtv_default(struct file *file, void *fh, bool valid_prio,
1781                          int cmd, void *arg)
1782 {
1783         struct ivtv *itv = fh2id(fh)->itv;
1784
1785         if (!valid_prio) {
1786                 switch (cmd) {
1787                 case IVTV_IOC_PASSTHROUGH_MODE:
1788                 case VIDEO_PLAY:
1789                 case VIDEO_STOP:
1790                 case VIDEO_FREEZE:
1791                 case VIDEO_CONTINUE:
1792                 case VIDEO_COMMAND:
1793                 case VIDEO_SELECT_SOURCE:
1794                 case AUDIO_SET_MUTE:
1795                 case AUDIO_CHANNEL_SELECT:
1796                 case AUDIO_BILINGUAL_CHANNEL_SELECT:
1797                         return -EBUSY;
1798                 }
1799         }
1800
1801         switch (cmd) {
1802         case VIDIOC_INT_RESET: {
1803                 u32 val = *(u32 *)arg;
1804
1805                 if ((val == 0 && itv->options.newi2c) || (val & 0x01))
1806                         ivtv_reset_ir_gpio(itv);
1807                 if (val & 0x02)
1808                         v4l2_subdev_call(itv->sd_video, core, reset, 0);
1809                 break;
1810         }
1811
1812         case IVTV_IOC_DMA_FRAME:
1813         case IVTV_IOC_PASSTHROUGH_MODE:
1814         case VIDEO_GET_PTS:
1815         case VIDEO_GET_FRAME_COUNT:
1816         case VIDEO_GET_EVENT:
1817         case VIDEO_PLAY:
1818         case VIDEO_STOP:
1819         case VIDEO_FREEZE:
1820         case VIDEO_CONTINUE:
1821         case VIDEO_COMMAND:
1822         case VIDEO_TRY_COMMAND:
1823         case VIDEO_SELECT_SOURCE:
1824         case AUDIO_SET_MUTE:
1825         case AUDIO_CHANNEL_SELECT:
1826         case AUDIO_BILINGUAL_CHANNEL_SELECT:
1827                 return ivtv_decoder_ioctls(file, cmd, (void *)arg);
1828
1829         default:
1830                 return -EINVAL;
1831         }
1832         return 0;
1833 }
1834
1835 long ivtv_v4l2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
1836 {
1837         struct video_device *vfd = video_devdata(filp);
1838         long ret;
1839
1840         if (ivtv_debug & IVTV_DBGFLG_IOCTL)
1841                 vfd->debug = V4L2_DEBUG_IOCTL | V4L2_DEBUG_IOCTL_ARG;
1842         ret = video_ioctl2(filp, cmd, arg);
1843         vfd->debug = 0;
1844         return ret;
1845 }
1846
1847 static const struct v4l2_ioctl_ops ivtv_ioctl_ops = {
1848         .vidioc_querycap                    = ivtv_querycap,
1849         .vidioc_s_audio                     = ivtv_s_audio,
1850         .vidioc_g_audio                     = ivtv_g_audio,
1851         .vidioc_enumaudio                   = ivtv_enumaudio,
1852         .vidioc_s_audout                    = ivtv_s_audout,
1853         .vidioc_g_audout                    = ivtv_g_audout,
1854         .vidioc_enum_input                  = ivtv_enum_input,
1855         .vidioc_enum_output                 = ivtv_enum_output,
1856         .vidioc_enumaudout                  = ivtv_enumaudout,
1857         .vidioc_cropcap                     = ivtv_cropcap,
1858         .vidioc_s_crop                      = ivtv_s_crop,
1859         .vidioc_g_crop                      = ivtv_g_crop,
1860         .vidioc_g_input                     = ivtv_g_input,
1861         .vidioc_s_input                     = ivtv_s_input,
1862         .vidioc_g_output                    = ivtv_g_output,
1863         .vidioc_s_output                    = ivtv_s_output,
1864         .vidioc_g_frequency                 = ivtv_g_frequency,
1865         .vidioc_s_frequency                 = ivtv_s_frequency,
1866         .vidioc_s_tuner                     = ivtv_s_tuner,
1867         .vidioc_g_tuner                     = ivtv_g_tuner,
1868         .vidioc_g_enc_index                 = ivtv_g_enc_index,
1869         .vidioc_g_fbuf                      = ivtv_g_fbuf,
1870         .vidioc_s_fbuf                      = ivtv_s_fbuf,
1871         .vidioc_g_std                       = ivtv_g_std,
1872         .vidioc_s_std                       = ivtv_s_std,
1873         .vidioc_overlay                     = ivtv_overlay,
1874         .vidioc_log_status                  = ivtv_log_status,
1875         .vidioc_enum_fmt_vid_cap            = ivtv_enum_fmt_vid_cap,
1876         .vidioc_encoder_cmd                 = ivtv_encoder_cmd,
1877         .vidioc_try_encoder_cmd             = ivtv_try_encoder_cmd,
1878         .vidioc_decoder_cmd                 = ivtv_decoder_cmd,
1879         .vidioc_try_decoder_cmd             = ivtv_try_decoder_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_subscribe_event             = ivtv_subscribe_event,
1907         .vidioc_unsubscribe_event           = v4l2_event_unsubscribe,
1908 };
1909
1910 void ivtv_set_funcs(struct video_device *vdev)
1911 {
1912         vdev->ioctl_ops = &ivtv_ioctl_ops;
1913 }