drivers/media/pci/ivtv/ivtv-ioctl.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3     ioctl system call
   4     Copyright (C) 2003-2004  Kevin Thayer <nufan_wfk at yahoo.com>
   5     Copyright (C) 2005-2007  Hans Verkuil <hverkuil@xs4all.nl>
   6
   7  */
   8
   9 #include "ivtv-driver.h"
  10 #include "ivtv-version.h"
  11 #include "ivtv-mailbox.h"
  12 #include "ivtv-i2c.h"
  13 #include "ivtv-queue.h"
  14 #include "ivtv-fileops.h"
  15 #include "ivtv-vbi.h"
  16 #include "ivtv-routing.h"
  17 #include "ivtv-streams.h"
  18 #include "ivtv-yuv.h"
  19 #include "ivtv-ioctl.h"
  20 #include "ivtv-gpio.h"
  21 #include "ivtv-controls.h"
  22 #include "ivtv-cards.h"
  23 #include <media/i2c/saa7127.h>
  24 #include <media/tveeprom.h>
  25 #include <media/v4l2-event.h>
  26 #ifdef CONFIG_VIDEO_IVTV_DEPRECATED_IOCTLS
  27 #include <linux/compat.h>
  28 #include <linux/dvb/audio.h>
  29 #include <linux/dvb/video.h>
  30 #endif
  31
  32 u16 ivtv_service2vbi(int type)
  33 {
  34         switch (type) {
  35                 case V4L2_SLICED_TELETEXT_B:
  36                         return IVTV_SLICED_TYPE_TELETEXT_B;
  37                 case V4L2_SLICED_CAPTION_525:
  38                         return IVTV_SLICED_TYPE_CAPTION_525;
  39                 case V4L2_SLICED_WSS_625:
  40                         return IVTV_SLICED_TYPE_WSS_625;
  41                 case V4L2_SLICED_VPS:
  42                         return IVTV_SLICED_TYPE_VPS;
  43                 default:
  44                         return 0;
  45         }
  46 }
  47
  48 static int valid_service_line(int field, int line, int is_pal)
  49 {
  50         return (is_pal && line >= 6 && (line != 23 || field == 0)) ||
  51                (!is_pal && line >= 10 && line < 22);
  52 }
  53
  54 static u16 select_service_from_set(int field, int line, u16 set, int is_pal)
  55 {
  56         u16 valid_set = (is_pal ? V4L2_SLICED_VBI_625 : V4L2_SLICED_VBI_525);
  57         int i;
  58
  59         set = set & valid_set;
  60         if (set == 0 || !valid_service_line(field, line, is_pal)) {
  61                 return 0;
  62         }
  63         if (!is_pal) {
  64                 if (line == 21 && (set & V4L2_SLICED_CAPTION_525))
  65                         return V4L2_SLICED_CAPTION_525;
  66         }
  67         else {
  68                 if (line == 16 && field == 0 && (set & V4L2_SLICED_VPS))
  69                         return V4L2_SLICED_VPS;
  70                 if (line == 23 && field == 0 && (set & V4L2_SLICED_WSS_625))
  71                         return V4L2_SLICED_WSS_625;
  72                 if (line == 23)
  73                         return 0;
  74         }
  75         for (i = 0; i < 32; i++) {
  76                 if ((1 << i) & set)
  77                         return 1 << i;
  78         }
  79         return 0;
  80 }
  81
  82 void ivtv_expand_service_set(struct v4l2_sliced_vbi_format *fmt, int is_pal)
  83 {
  84         u16 set = fmt->service_set;
  85         int f, l;
  86
  87         fmt->service_set = 0;
  88         for (f = 0; f < 2; f++) {
  89                 for (l = 0; l < 24; l++) {
  90                         fmt->service_lines[f][l] = select_service_from_set(f, l, set, is_pal);
  91                 }
  92         }
  93 }
  94
  95 static void check_service_set(struct v4l2_sliced_vbi_format *fmt, int is_pal)
  96 {
  97         int f, l;
  98
  99         for (f = 0; f < 2; f++) {
 100                 for (l = 0; l < 24; l++) {
 101                         fmt->service_lines[f][l] = select_service_from_set(f, l, fmt->service_lines[f][l], is_pal);
 102                 }
 103         }
 104 }
 105
 106 u16 ivtv_get_service_set(struct v4l2_sliced_vbi_format *fmt)
 107 {
 108         int f, l;
 109         u16 set = 0;
 110
 111         for (f = 0; f < 2; f++) {
 112                 for (l = 0; l < 24; l++) {
 113                         set |= fmt->service_lines[f][l];
 114                 }
 115         }
 116         return set;
 117 }
 118
 119 void ivtv_set_osd_alpha(struct ivtv *itv)
 120 {
 121         ivtv_vapi(itv, CX2341X_OSD_SET_GLOBAL_ALPHA, 3,
 122                 itv->osd_global_alpha_state, itv->osd_global_alpha, !itv->osd_local_alpha_state);
 123         ivtv_vapi(itv, CX2341X_OSD_SET_CHROMA_KEY, 2, itv->osd_chroma_key_state, itv->osd_chroma_key);
 124 }
 125
 126 int ivtv_set_speed(struct ivtv *itv, int speed)
 127 {
 128         u32 data[CX2341X_MBOX_MAX_DATA];
 129         int single_step = (speed == 1 || speed == -1);
 130         DEFINE_WAIT(wait);
 131
 132         if (speed == 0) speed = 1000;
 133
 134         /* No change? */
 135         if (speed == itv->speed && !single_step)
 136                 return 0;
 137
 138         if (single_step && (speed < 0) == (itv->speed < 0)) {
 139                 /* Single step video and no need to change direction */
 140                 ivtv_vapi(itv, CX2341X_DEC_STEP_VIDEO, 1, 0);
 141                 itv->speed = speed;
 142                 return 0;
 143         }
 144         if (single_step)
 145                 /* Need to change direction */
 146                 speed = speed < 0 ? -1000 : 1000;
 147
 148         data[0] = (speed > 1000 || speed < -1000) ? 0x80000000 : 0;
 149         data[0] |= (speed > 1000 || speed < -1500) ? 0x40000000 : 0;
 150         data[1] = (speed < 0);
 151         data[2] = speed < 0 ? 3 : 7;
 152         data[3] = v4l2_ctrl_g_ctrl(itv->cxhdl.video_b_frames);
 153         data[4] = (speed == 1500 || speed == 500) ? itv->speed_mute_audio : 0;
 154         data[5] = 0;
 155         data[6] = 0;
 156
 157         if (speed == 1500 || speed == -1500) data[0] |= 1;
 158         else if (speed == 2000 || speed == -2000) data[0] |= 2;
 159         else if (speed > -1000 && speed < 0) data[0] |= (-1000 / speed);
 160         else if (speed < 1000 && speed > 0) data[0] |= (1000 / speed);
 161
 162         /* If not decoding, just change speed setting */
 163         if (atomic_read(&itv->decoding) > 0) {
 164                 int got_sig = 0;
 165
 166                 /* Stop all DMA and decoding activity */
 167                 ivtv_vapi(itv, CX2341X_DEC_PAUSE_PLAYBACK, 1, 0);
 168
 169                 /* Wait for any DMA to finish */
 170                 mutex_unlock(&itv->serialize_lock);
 171                 prepare_to_wait(&itv->dma_waitq, &wait, TASK_INTERRUPTIBLE);
 172                 while (test_bit(IVTV_F_I_DMA, &itv->i_flags)) {
 173                         got_sig = signal_pending(current);
 174                         if (got_sig)
 175                                 break;
 176                         got_sig = 0;
 177                         schedule();
 178                 }
 179                 finish_wait(&itv->dma_waitq, &wait);
 180                 mutex_lock(&itv->serialize_lock);
 181                 if (got_sig)
 182                         return -EINTR;
 183
 184                 /* Change Speed safely */
 185                 ivtv_api(itv, CX2341X_DEC_SET_PLAYBACK_SPEED, 7, data);
 186                 IVTV_DEBUG_INFO("Setting Speed to 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n",
 187                                 data[0], data[1], data[2], data[3], data[4], data[5], data[6]);
 188         }
 189         if (single_step) {
 190                 speed = (speed < 0) ? -1 : 1;
 191                 ivtv_vapi(itv, CX2341X_DEC_STEP_VIDEO, 1, 0);
 192         }
 193         itv->speed = speed;
 194         return 0;
 195 }
 196
 197 static int ivtv_validate_speed(int cur_speed, int new_speed)
 198 {
 199         int fact = new_speed < 0 ? -1 : 1;
 200         int s;
 201
 202         if (cur_speed == 0)
 203                 cur_speed = 1000;
 204         if (new_speed < 0)
 205                 new_speed = -new_speed;
 206         if (cur_speed < 0)
 207                 cur_speed = -cur_speed;
 208
 209         if (cur_speed <= new_speed) {
 210                 if (new_speed > 1500)
 211                         return fact * 2000;
 212                 if (new_speed > 1000)
 213                         return fact * 1500;
 214         }
 215         else {
 216                 if (new_speed >= 2000)
 217                         return fact * 2000;
 218                 if (new_speed >= 1500)
 219                         return fact * 1500;
 220                 if (new_speed >= 1000)
 221                         return fact * 1000;
 222         }
 223         if (new_speed == 0)
 224                 return 1000;
 225         if (new_speed == 1 || new_speed == 1000)
 226                 return fact * new_speed;
 227
 228         s = new_speed;
 229         new_speed = 1000 / new_speed;
 230         if (1000 / cur_speed == new_speed)
 231                 new_speed += (cur_speed < s) ? -1 : 1;
 232         if (new_speed > 60) return 1000 / (fact * 60);
 233         return 1000 / (fact * new_speed);
 234 }
 235
 236 static int ivtv_video_command(struct ivtv *itv, struct ivtv_open_id *id,
 237                 struct v4l2_decoder_cmd *dc, int try)
 238 {
 239         struct ivtv_stream *s = &itv->streams[IVTV_DEC_STREAM_TYPE_MPG];
 240
 241         if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
 242                 return -EINVAL;
 243
 244         switch (dc->cmd) {
 245         case V4L2_DEC_CMD_START: {
 246                 dc->flags &= V4L2_DEC_CMD_START_MUTE_AUDIO;
 247                 dc->start.speed = ivtv_validate_speed(itv->speed, dc->start.speed);
 248                 if (dc->start.speed < 0)
 249                         dc->start.format = V4L2_DEC_START_FMT_GOP;
 250                 else
 251                         dc->start.format = V4L2_DEC_START_FMT_NONE;
 252                 if (dc->start.speed != 500 && dc->start.speed != 1500)
 253                         dc->flags = dc->start.speed == 1000 ? 0 :
 254                                         V4L2_DEC_CMD_START_MUTE_AUDIO;
 255                 if (try) break;
 256
 257                 itv->speed_mute_audio = dc->flags & V4L2_DEC_CMD_START_MUTE_AUDIO;
 258                 if (ivtv_set_output_mode(itv, OUT_MPG) != OUT_MPG)
 259                         return -EBUSY;
 260                 if (test_and_clear_bit(IVTV_F_I_DEC_PAUSED, &itv->i_flags)) {
 261                         /* forces ivtv_set_speed to be called */
 262                         itv->speed = 0;
 263                 }
 264                 return ivtv_start_decoding(id, dc->start.speed);
 265         }
 266
 267         case V4L2_DEC_CMD_STOP:
 268                 dc->flags &= V4L2_DEC_CMD_STOP_IMMEDIATELY | V4L2_DEC_CMD_STOP_TO_BLACK;
 269                 if (dc->flags & V4L2_DEC_CMD_STOP_IMMEDIATELY)
 270                         dc->stop.pts = 0;
 271                 if (try) break;
 272                 if (atomic_read(&itv->decoding) == 0)
 273                         return 0;
 274                 if (itv->output_mode != OUT_MPG)
 275                         return -EBUSY;
 276
 277                 itv->output_mode = OUT_NONE;
 278                 return ivtv_stop_v4l2_decode_stream(s, dc->flags, dc->stop.pts);
 279
 280         case V4L2_DEC_CMD_PAUSE:
 281                 dc->flags &= V4L2_DEC_CMD_PAUSE_TO_BLACK;
 282                 if (try) break;
 283                 if (!atomic_read(&itv->decoding))
 284                         return -EPERM;
 285                 if (itv->output_mode != OUT_MPG)
 286                         return -EBUSY;
 287                 if (atomic_read(&itv->decoding) > 0) {
 288                         ivtv_vapi(itv, CX2341X_DEC_PAUSE_PLAYBACK, 1,
 289                                 (dc->flags & V4L2_DEC_CMD_PAUSE_TO_BLACK) ? 1 : 0);
 290                         set_bit(IVTV_F_I_DEC_PAUSED, &itv->i_flags);
 291                 }
 292                 break;
 293
 294         case V4L2_DEC_CMD_RESUME:
 295                 dc->flags = 0;
 296                 if (try) break;
 297                 if (!atomic_read(&itv->decoding))
 298                         return -EPERM;
 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 = fh2id(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         memset(vbifmt->service_lines, 0, sizeof(vbifmt->service_lines));
 325         if (itv->is_60hz) {
 326                 vbifmt->service_lines[0][21] = V4L2_SLICED_CAPTION_525;
 327                 vbifmt->service_lines[1][21] = V4L2_SLICED_CAPTION_525;
 328         } else {
 329                 vbifmt->service_lines[0][23] = V4L2_SLICED_WSS_625;
 330                 vbifmt->service_lines[0][16] = V4L2_SLICED_VPS;
 331         }
 332         vbifmt->service_set = ivtv_get_service_set(vbifmt);
 333         return 0;
 334 }
 335
 336 static int ivtv_g_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
 337 {
 338         struct ivtv_open_id *id = fh2id(fh);
 339         struct ivtv *itv = id->itv;
 340         struct v4l2_pix_format *pixfmt = &fmt->fmt.pix;
 341
 342         pixfmt->width = itv->cxhdl.width;
 343         pixfmt->height = itv->cxhdl.height;
 344         pixfmt->colorspace = V4L2_COLORSPACE_SMPTE170M;
 345         pixfmt->field = V4L2_FIELD_INTERLACED;
 346         if (id->type == IVTV_ENC_STREAM_TYPE_YUV) {
 347                 pixfmt->pixelformat = V4L2_PIX_FMT_HM12;
 348                 /* YUV size is (Y=(h*720) + UV=(h*(720/2))) */
 349                 pixfmt->sizeimage = pixfmt->height * 720 * 3 / 2;
 350                 pixfmt->bytesperline = 720;
 351         } else {
 352                 pixfmt->pixelformat = V4L2_PIX_FMT_MPEG;
 353                 pixfmt->sizeimage = 128 * 1024;
 354                 pixfmt->bytesperline = 0;
 355         }
 356         return 0;
 357 }
 358
 359 static int ivtv_g_fmt_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
 360 {
 361         struct ivtv *itv = fh2id(fh)->itv;
 362         struct v4l2_vbi_format *vbifmt = &fmt->fmt.vbi;
 363
 364         vbifmt->sampling_rate = 27000000;
 365         vbifmt->offset = 248;
 366         vbifmt->samples_per_line = itv->vbi.raw_decoder_line_size - 4;
 367         vbifmt->sample_format = V4L2_PIX_FMT_GREY;
 368         vbifmt->start[0] = itv->vbi.start[0];
 369         vbifmt->start[1] = itv->vbi.start[1];
 370         vbifmt->count[0] = vbifmt->count[1] = itv->vbi.count;
 371         vbifmt->flags = 0;
 372         vbifmt->reserved[0] = 0;
 373         vbifmt->reserved[1] = 0;
 374         return 0;
 375 }
 376
 377 static int ivtv_g_fmt_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
 378 {
 379         struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
 380         struct ivtv_open_id *id = fh2id(fh);
 381         struct ivtv *itv = id->itv;
 382
 383         vbifmt->reserved[0] = 0;
 384         vbifmt->reserved[1] = 0;
 385         vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
 386
 387         if (id->type == IVTV_DEC_STREAM_TYPE_VBI) {
 388                 vbifmt->service_set = itv->is_50hz ? V4L2_SLICED_VBI_625 :
 389                         V4L2_SLICED_VBI_525;
 390                 ivtv_expand_service_set(vbifmt, itv->is_50hz);
 391                 vbifmt->service_set = ivtv_get_service_set(vbifmt);
 392                 return 0;
 393         }
 394
 395         v4l2_subdev_call(itv->sd_video, vbi, g_sliced_fmt, vbifmt);
 396         vbifmt->service_set = ivtv_get_service_set(vbifmt);
 397         return 0;
 398 }
 399
 400 static int ivtv_g_fmt_vid_out(struct file *file, void *fh, struct v4l2_format *fmt)
 401 {
 402         struct ivtv_open_id *id = fh2id(fh);
 403         struct ivtv *itv = id->itv;
 404         struct v4l2_pix_format *pixfmt = &fmt->fmt.pix;
 405
 406         if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
 407                 return -EINVAL;
 408         pixfmt->width = itv->main_rect.width;
 409         pixfmt->height = itv->main_rect.height;
 410         pixfmt->colorspace = V4L2_COLORSPACE_SMPTE170M;
 411         pixfmt->field = V4L2_FIELD_INTERLACED;
 412         if (id->type == IVTV_DEC_STREAM_TYPE_YUV) {
 413                 switch (itv->yuv_info.lace_mode & IVTV_YUV_MODE_MASK) {
 414                 case IVTV_YUV_MODE_INTERLACED:
 415                         pixfmt->field = (itv->yuv_info.lace_mode & IVTV_YUV_SYNC_MASK) ?
 416                                 V4L2_FIELD_INTERLACED_BT : V4L2_FIELD_INTERLACED_TB;
 417                         break;
 418                 case IVTV_YUV_MODE_PROGRESSIVE:
 419                         pixfmt->field = V4L2_FIELD_NONE;
 420                         break;
 421                 default:
 422                         pixfmt->field = V4L2_FIELD_ANY;
 423                         break;
 424                 }
 425                 pixfmt->pixelformat = V4L2_PIX_FMT_HM12;
 426                 pixfmt->bytesperline = 720;
 427                 pixfmt->width = itv->yuv_info.v4l2_src_w;
 428                 pixfmt->height = itv->yuv_info.v4l2_src_h;
 429                 /* YUV size is (Y=(h*w) + UV=(h*(w/2))) */
 430                 pixfmt->sizeimage =
 431                         1080 * ((pixfmt->height + 31) & ~31);
 432         } else {
 433                 pixfmt->pixelformat = V4L2_PIX_FMT_MPEG;
 434                 pixfmt->sizeimage = 128 * 1024;
 435                 pixfmt->bytesperline = 0;
 436         }
 437         return 0;
 438 }
 439
 440 static int ivtv_g_fmt_vid_out_overlay(struct file *file, void *fh, struct v4l2_format *fmt)
 441 {
 442         struct ivtv *itv = fh2id(fh)->itv;
 443         struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
 444         struct v4l2_window *winfmt = &fmt->fmt.win;
 445
 446         if (!(s->caps & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
 447                 return -EINVAL;
 448         if (!itv->osd_video_pbase)
 449                 return -EINVAL;
 450         winfmt->chromakey = itv->osd_chroma_key;
 451         winfmt->global_alpha = itv->osd_global_alpha;
 452         winfmt->field = V4L2_FIELD_INTERLACED;
 453         winfmt->clips = NULL;
 454         winfmt->clipcount = 0;
 455         winfmt->bitmap = NULL;
 456         winfmt->w.top = winfmt->w.left = 0;
 457         winfmt->w.width = itv->osd_rect.width;
 458         winfmt->w.height = itv->osd_rect.height;
 459         return 0;
 460 }
 461
 462 static int ivtv_try_fmt_sliced_vbi_out(struct file *file, void *fh, struct v4l2_format *fmt)
 463 {
 464         return ivtv_g_fmt_sliced_vbi_out(file, fh, fmt);
 465 }
 466
 467 static int ivtv_try_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
 468 {
 469         struct ivtv_open_id *id = fh2id(fh);
 470         struct ivtv *itv = id->itv;
 471         int w = fmt->fmt.pix.width;
 472         int h = fmt->fmt.pix.height;
 473         int min_h = 2;
 474
 475         w = min(w, 720);
 476         w = max(w, 2);
 477         if (id->type == IVTV_ENC_STREAM_TYPE_YUV) {
 478                 /* YUV height must be a multiple of 32 */
 479                 h &= ~0x1f;
 480                 min_h = 32;
 481         }
 482         h = min(h, itv->is_50hz ? 576 : 480);
 483         h = max(h, min_h);
 484         ivtv_g_fmt_vid_cap(file, fh, fmt);
 485         fmt->fmt.pix.width = w;
 486         fmt->fmt.pix.height = h;
 487         return 0;
 488 }
 489
 490 static int ivtv_try_fmt_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
 491 {
 492         return ivtv_g_fmt_vbi_cap(file, fh, fmt);
 493 }
 494
 495 static int ivtv_try_fmt_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_format *fmt)
 496 {
 497         struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
 498         struct ivtv_open_id *id = fh2id(fh);
 499         struct ivtv *itv = id->itv;
 500
 501         if (id->type == IVTV_DEC_STREAM_TYPE_VBI)
 502                 return ivtv_g_fmt_sliced_vbi_cap(file, fh, fmt);
 503
 504         /* set sliced VBI capture format */
 505         vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
 506         vbifmt->reserved[0] = 0;
 507         vbifmt->reserved[1] = 0;
 508
 509         if (vbifmt->service_set)
 510                 ivtv_expand_service_set(vbifmt, itv->is_50hz);
 511         check_service_set(vbifmt, itv->is_50hz);
 512         vbifmt->service_set = ivtv_get_service_set(vbifmt);
 513         return 0;
 514 }
 515
 516 static int ivtv_try_fmt_vid_out(struct file *file, void *fh, struct v4l2_format *fmt)
 517 {
 518         struct ivtv_open_id *id = fh2id(fh);
 519         s32 w = fmt->fmt.pix.width;
 520         s32 h = fmt->fmt.pix.height;
 521         int field = fmt->fmt.pix.field;
 522         int ret = ivtv_g_fmt_vid_out(file, fh, fmt);
 523
 524         w = min(w, 720);
 525         w = max(w, 2);
 526         /* Why can the height be 576 even when the output is NTSC?
 527
 528            Internally the buffers of the PVR350 are always set to 720x576. The
 529            decoded video frame will always be placed in the top left corner of
 530            this buffer. For any video which is not 720x576, the buffer will
 531            then be cropped to remove the unused right and lower areas, with
 532            the remaining image being scaled by the hardware to fit the display
 533            area. The video can be scaled both up and down, so a 720x480 video
 534            can be displayed full-screen on PAL and a 720x576 video can be
 535            displayed without cropping on NTSC.
 536
 537            Note that the scaling only occurs on the video stream, the osd
 538            resolution is locked to the broadcast standard and not scaled.
 539
 540            Thanks to Ian Armstrong for this explanation. */
 541         h = min(h, 576);
 542         h = max(h, 2);
 543         if (id->type == IVTV_DEC_STREAM_TYPE_YUV)
 544                 fmt->fmt.pix.field = field;
 545         fmt->fmt.pix.width = w;
 546         fmt->fmt.pix.height = h;
 547         return ret;
 548 }
 549
 550 static int ivtv_try_fmt_vid_out_overlay(struct file *file, void *fh, struct v4l2_format *fmt)
 551 {
 552         struct ivtv *itv = fh2id(fh)->itv;
 553         struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
 554         u32 chromakey = fmt->fmt.win.chromakey;
 555         u8 global_alpha = fmt->fmt.win.global_alpha;
 556
 557         if (!(s->caps & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
 558                 return -EINVAL;
 559         if (!itv->osd_video_pbase)
 560                 return -EINVAL;
 561         ivtv_g_fmt_vid_out_overlay(file, fh, fmt);
 562         fmt->fmt.win.chromakey = chromakey;
 563         fmt->fmt.win.global_alpha = global_alpha;
 564         return 0;
 565 }
 566
 567 static int ivtv_s_fmt_sliced_vbi_out(struct file *file, void *fh, struct v4l2_format *fmt)
 568 {
 569         return ivtv_g_fmt_sliced_vbi_out(file, fh, fmt);
 570 }
 571
 572 static int ivtv_s_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
 573 {
 574         struct ivtv_open_id *id = fh2id(fh);
 575         struct ivtv *itv = id->itv;
 576         struct v4l2_subdev_format format = {
 577                 .which = V4L2_SUBDEV_FORMAT_ACTIVE,
 578         };
 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         format.format.width = fmt->fmt.pix.width;
 597         format.format.height = h;
 598         format.format.code = MEDIA_BUS_FMT_FIXED;
 599         v4l2_subdev_call(itv->sd_video, pad, set_fmt, NULL, &format);
 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 #ifdef CONFIG_VIDEO_ADV_DEBUG
 693 static int ivtv_itvc(struct ivtv *itv, bool get, u64 reg, u64 *val)
 694 {
 695         volatile u8 __iomem *reg_start;
 696
 697         if (reg & 0x3)
 698                 return -EINVAL;
 699         if (reg >= IVTV_REG_OFFSET && reg < IVTV_REG_OFFSET + IVTV_REG_SIZE)
 700                 reg_start = itv->reg_mem - IVTV_REG_OFFSET;
 701         else if (itv->has_cx23415 && reg >= IVTV_DECODER_OFFSET &&
 702                         reg < IVTV_DECODER_OFFSET + IVTV_DECODER_SIZE)
 703                 reg_start = itv->dec_mem - IVTV_DECODER_OFFSET;
 704         else if (reg < IVTV_ENCODER_SIZE)
 705                 reg_start = itv->enc_mem;
 706         else
 707                 return -EINVAL;
 708
 709         if (get)
 710                 *val = readl(reg + reg_start);
 711         else
 712                 writel(*val, reg + reg_start);
 713         return 0;
 714 }
 715
 716 static int ivtv_g_register(struct file *file, void *fh, struct v4l2_dbg_register *reg)
 717 {
 718         struct ivtv *itv = fh2id(fh)->itv;
 719
 720         reg->size = 4;
 721         return ivtv_itvc(itv, true, reg->reg, &reg->val);
 722 }
 723
 724 static int ivtv_s_register(struct file *file, void *fh, const struct v4l2_dbg_register *reg)
 725 {
 726         struct ivtv *itv = fh2id(fh)->itv;
 727         u64 val = reg->val;
 728
 729         return ivtv_itvc(itv, false, reg->reg, &val);
 730 }
 731 #endif
 732
 733 static int ivtv_querycap(struct file *file, void *fh, struct v4l2_capability *vcap)
 734 {
 735         struct ivtv_open_id *id = fh2id(file->private_data);
 736         struct ivtv *itv = id->itv;
 737
 738         strscpy(vcap->driver, IVTV_DRIVER_NAME, sizeof(vcap->driver));
 739         strscpy(vcap->card, itv->card_name, sizeof(vcap->card));
 740         snprintf(vcap->bus_info, sizeof(vcap->bus_info), "PCI:%s", pci_name(itv->pdev));
 741         vcap->capabilities = itv->v4l2_cap | V4L2_CAP_DEVICE_CAPS;
 742         return 0;
 743 }
 744
 745 static int ivtv_enumaudio(struct file *file, void *fh, struct v4l2_audio *vin)
 746 {
 747         struct ivtv *itv = fh2id(fh)->itv;
 748
 749         return ivtv_get_audio_input(itv, vin->index, vin);
 750 }
 751
 752 static int ivtv_g_audio(struct file *file, void *fh, struct v4l2_audio *vin)
 753 {
 754         struct ivtv *itv = fh2id(fh)->itv;
 755
 756         vin->index = itv->audio_input;
 757         return ivtv_get_audio_input(itv, vin->index, vin);
 758 }
 759
 760 static int ivtv_s_audio(struct file *file, void *fh, const struct v4l2_audio *vout)
 761 {
 762         struct ivtv *itv = fh2id(fh)->itv;
 763
 764         if (vout->index >= itv->nof_audio_inputs)
 765                 return -EINVAL;
 766
 767         itv->audio_input = vout->index;
 768         ivtv_audio_set_io(itv);
 769
 770         return 0;
 771 }
 772
 773 static int ivtv_enumaudout(struct file *file, void *fh, struct v4l2_audioout *vin)
 774 {
 775         struct ivtv *itv = fh2id(fh)->itv;
 776
 777         /* set it to defaults from our table */
 778         return ivtv_get_audio_output(itv, vin->index, vin);
 779 }
 780
 781 static int ivtv_g_audout(struct file *file, void *fh, struct v4l2_audioout *vin)
 782 {
 783         struct ivtv *itv = fh2id(fh)->itv;
 784
 785         vin->index = 0;
 786         return ivtv_get_audio_output(itv, vin->index, vin);
 787 }
 788
 789 static int ivtv_s_audout(struct file *file, void *fh, const struct v4l2_audioout *vout)
 790 {
 791         struct ivtv *itv = fh2id(fh)->itv;
 792
 793         if (itv->card->video_outputs == NULL || vout->index != 0)
 794                 return -EINVAL;
 795         return 0;
 796 }
 797
 798 static int ivtv_enum_input(struct file *file, void *fh, struct v4l2_input *vin)
 799 {
 800         struct ivtv *itv = fh2id(fh)->itv;
 801
 802         /* set it to defaults from our table */
 803         return ivtv_get_input(itv, vin->index, vin);
 804 }
 805
 806 static int ivtv_enum_output(struct file *file, void *fh, struct v4l2_output *vout)
 807 {
 808         struct ivtv *itv = fh2id(fh)->itv;
 809
 810         return ivtv_get_output(itv, vout->index, vout);
 811 }
 812
 813 static int ivtv_g_pixelaspect(struct file *file, void *fh,
 814                               int type, struct v4l2_fract *f)
 815 {
 816         struct ivtv_open_id *id = fh2id(fh);
 817         struct ivtv *itv = id->itv;
 818
 819         if (type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
 820                 f->numerator = itv->is_50hz ? 54 : 11;
 821                 f->denominator = itv->is_50hz ? 59 : 10;
 822         } else if (type == V4L2_BUF_TYPE_VIDEO_OUTPUT) {
 823                 f->numerator = itv->is_out_50hz ? 54 : 11;
 824                 f->denominator = itv->is_out_50hz ? 59 : 10;
 825         } else {
 826                 return -EINVAL;
 827         }
 828         return 0;
 829 }
 830
 831 static int ivtv_s_selection(struct file *file, void *fh,
 832                             struct v4l2_selection *sel)
 833 {
 834         struct ivtv_open_id *id = fh2id(fh);
 835         struct ivtv *itv = id->itv;
 836         struct yuv_playback_info *yi = &itv->yuv_info;
 837         struct v4l2_rect r = { 0, 0, 720, 0 };
 838         int streamtype = id->type;
 839
 840         if (sel->type != V4L2_BUF_TYPE_VIDEO_OUTPUT ||
 841             !(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
 842                 return -EINVAL;
 843
 844         if (sel->target != V4L2_SEL_TGT_COMPOSE)
 845                 return -EINVAL;
 846
 847
 848         if (sel->type != V4L2_BUF_TYPE_VIDEO_OUTPUT ||
 849             !(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
 850                 return -EINVAL;
 851
 852         r.height = itv->is_out_50hz ? 576 : 480;
 853         if (streamtype == IVTV_DEC_STREAM_TYPE_YUV && yi->track_osd) {
 854                 r.width = yi->osd_full_w;
 855                 r.height = yi->osd_full_h;
 856         }
 857         sel->r.width = clamp(sel->r.width, 16U, r.width);
 858         sel->r.height = clamp(sel->r.height, 16U, r.height);
 859         sel->r.left = clamp_t(unsigned, sel->r.left, 0, r.width - sel->r.width);
 860         sel->r.top = clamp_t(unsigned, sel->r.top, 0, r.height - sel->r.height);
 861
 862         if (streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
 863                 yi->main_rect = sel->r;
 864                 return 0;
 865         }
 866         if (!ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
 867                         sel->r.width, sel->r.height, sel->r.left, sel->r.top)) {
 868                 itv->main_rect = sel->r;
 869                 return 0;
 870         }
 871         return -EINVAL;
 872 }
 873
 874 static int ivtv_g_selection(struct file *file, void *fh,
 875                             struct v4l2_selection *sel)
 876 {
 877         struct ivtv_open_id *id = fh2id(fh);
 878         struct ivtv *itv = id->itv;
 879         struct yuv_playback_info *yi = &itv->yuv_info;
 880         struct v4l2_rect r = { 0, 0, 720, 0 };
 881         int streamtype = id->type;
 882
 883         if (sel->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
 884                 switch (sel->target) {
 885                 case V4L2_SEL_TGT_CROP_DEFAULT:
 886                 case V4L2_SEL_TGT_CROP_BOUNDS:
 887                         sel->r.top = sel->r.left = 0;
 888                         sel->r.width = 720;
 889                         sel->r.height = itv->is_50hz ? 576 : 480;
 890                         return 0;
 891                 default:
 892                         return -EINVAL;
 893                 }
 894         }
 895
 896         if (sel->type != V4L2_BUF_TYPE_VIDEO_OUTPUT ||
 897             !(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
 898                 return -EINVAL;
 899
 900         switch (sel->target) {
 901         case V4L2_SEL_TGT_COMPOSE:
 902                 if (streamtype == IVTV_DEC_STREAM_TYPE_YUV)
 903                         sel->r = yi->main_rect;
 904                 else
 905                         sel->r = itv->main_rect;
 906                 return 0;
 907         case V4L2_SEL_TGT_COMPOSE_DEFAULT:
 908         case V4L2_SEL_TGT_COMPOSE_BOUNDS:
 909                 r.height = itv->is_out_50hz ? 576 : 480;
 910                 if (streamtype == IVTV_DEC_STREAM_TYPE_YUV && yi->track_osd) {
 911                         r.width = yi->osd_full_w;
 912                         r.height = yi->osd_full_h;
 913                 }
 914                 sel->r = r;
 915                 return 0;
 916         }
 917         return -EINVAL;
 918 }
 919
 920 static int ivtv_enum_fmt_vid_cap(struct file *file, void *fh, struct v4l2_fmtdesc *fmt)
 921 {
 922         static const struct v4l2_fmtdesc hm12 = {
 923                 0, V4L2_BUF_TYPE_VIDEO_CAPTURE, 0,
 924                 "HM12 (YUV 4:2:0)", V4L2_PIX_FMT_HM12,
 925                 { 0, 0, 0, 0 }
 926         };
 927         static const struct v4l2_fmtdesc mpeg = {
 928                 0, V4L2_BUF_TYPE_VIDEO_CAPTURE, V4L2_FMT_FLAG_COMPRESSED,
 929                 "MPEG", V4L2_PIX_FMT_MPEG,
 930                 { 0, 0, 0, 0 }
 931         };
 932         struct ivtv *itv = fh2id(fh)->itv;
 933         struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
 934
 935         if (fmt->index)
 936                 return -EINVAL;
 937         if (s->type == IVTV_ENC_STREAM_TYPE_MPG)
 938                 *fmt = mpeg;
 939         else if (s->type == IVTV_ENC_STREAM_TYPE_YUV)
 940                 *fmt = hm12;
 941         else
 942                 return -EINVAL;
 943         return 0;
 944 }
 945
 946 static int ivtv_enum_fmt_vid_out(struct file *file, void *fh, struct v4l2_fmtdesc *fmt)
 947 {
 948         static const struct v4l2_fmtdesc hm12 = {
 949                 0, V4L2_BUF_TYPE_VIDEO_OUTPUT, 0,
 950                 "HM12 (YUV 4:2:0)", V4L2_PIX_FMT_HM12,
 951                 { 0, 0, 0, 0 }
 952         };
 953         static const struct v4l2_fmtdesc mpeg = {
 954                 0, V4L2_BUF_TYPE_VIDEO_OUTPUT, V4L2_FMT_FLAG_COMPRESSED,
 955                 "MPEG", V4L2_PIX_FMT_MPEG,
 956                 { 0, 0, 0, 0 }
 957         };
 958         struct ivtv *itv = fh2id(fh)->itv;
 959         struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
 960
 961         if (fmt->index)
 962                 return -EINVAL;
 963         if (s->type == IVTV_DEC_STREAM_TYPE_MPG)
 964                 *fmt = mpeg;
 965         else if (s->type == IVTV_DEC_STREAM_TYPE_YUV)
 966                 *fmt = hm12;
 967         else
 968                 return -EINVAL;
 969         return 0;
 970 }
 971
 972 static int ivtv_g_input(struct file *file, void *fh, unsigned int *i)
 973 {
 974         struct ivtv *itv = fh2id(fh)->itv;
 975
 976         *i = itv->active_input;
 977
 978         return 0;
 979 }
 980
 981 int ivtv_s_input(struct file *file, void *fh, unsigned int inp)
 982 {
 983         struct ivtv *itv = fh2id(fh)->itv;
 984         v4l2_std_id std;
 985         int i;
 986
 987         if (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         if (itv->card->video_inputs[inp].video_type == IVTV_CARD_INPUT_VID_TUNER)
1008                 std = itv->tuner_std;
1009         else
1010                 std = V4L2_STD_ALL;
1011         for (i = 0; i <= IVTV_ENC_STREAM_TYPE_VBI; i++)
1012                 itv->streams[i].vdev.tvnorms = std;
1013
1014         /* prevent others from messing with the streams until
1015            we're finished changing inputs. */
1016         ivtv_mute(itv);
1017         ivtv_video_set_io(itv);
1018         ivtv_audio_set_io(itv);
1019         ivtv_unmute(itv);
1020
1021         return 0;
1022 }
1023
1024 static int ivtv_g_output(struct file *file, void *fh, unsigned int *i)
1025 {
1026         struct ivtv *itv = fh2id(fh)->itv;
1027
1028         if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1029                 return -EINVAL;
1030
1031         *i = itv->active_output;
1032
1033         return 0;
1034 }
1035
1036 static int ivtv_s_output(struct file *file, void *fh, unsigned int outp)
1037 {
1038         struct ivtv *itv = fh2id(fh)->itv;
1039
1040         if (outp >= itv->card->nof_outputs)
1041                 return -EINVAL;
1042
1043         if (outp == itv->active_output) {
1044                 IVTV_DEBUG_INFO("Output unchanged\n");
1045                 return 0;
1046         }
1047         IVTV_DEBUG_INFO("Changing output from %d to %d\n",
1048                    itv->active_output, outp);
1049
1050         itv->active_output = outp;
1051         ivtv_call_hw(itv, IVTV_HW_SAA7127, video, s_routing,
1052                         SAA7127_INPUT_TYPE_NORMAL,
1053                         itv->card->video_outputs[outp].video_output, 0);
1054
1055         return 0;
1056 }
1057
1058 static int ivtv_g_frequency(struct file *file, void *fh, struct v4l2_frequency *vf)
1059 {
1060         struct ivtv *itv = fh2id(fh)->itv;
1061         struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
1062
1063         if (s->vdev.vfl_dir)
1064                 return -ENOTTY;
1065         if (vf->tuner != 0)
1066                 return -EINVAL;
1067
1068         ivtv_call_all(itv, tuner, g_frequency, vf);
1069         return 0;
1070 }
1071
1072 int ivtv_s_frequency(struct file *file, void *fh, const struct v4l2_frequency *vf)
1073 {
1074         struct ivtv *itv = fh2id(fh)->itv;
1075         struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
1076
1077         if (s->vdev.vfl_dir)
1078                 return -ENOTTY;
1079         if (vf->tuner != 0)
1080                 return -EINVAL;
1081
1082         ivtv_mute(itv);
1083         IVTV_DEBUG_INFO("v4l2 ioctl: set frequency %d\n", vf->frequency);
1084         ivtv_call_all(itv, tuner, s_frequency, vf);
1085         ivtv_unmute(itv);
1086         return 0;
1087 }
1088
1089 static int ivtv_g_std(struct file *file, void *fh, v4l2_std_id *std)
1090 {
1091         struct ivtv *itv = fh2id(fh)->itv;
1092
1093         *std = itv->std;
1094         return 0;
1095 }
1096
1097 void ivtv_s_std_enc(struct ivtv *itv, v4l2_std_id std)
1098 {
1099         itv->std = std;
1100         itv->is_60hz = (std & V4L2_STD_525_60) ? 1 : 0;
1101         itv->is_50hz = !itv->is_60hz;
1102         cx2341x_handler_set_50hz(&itv->cxhdl, itv->is_50hz);
1103         itv->cxhdl.width = 720;
1104         itv->cxhdl.height = itv->is_50hz ? 576 : 480;
1105         itv->vbi.count = itv->is_50hz ? 18 : 12;
1106         itv->vbi.start[0] = itv->is_50hz ? 6 : 10;
1107         itv->vbi.start[1] = itv->is_50hz ? 318 : 273;
1108
1109         if (itv->hw_flags & IVTV_HW_CX25840)
1110                 itv->vbi.sliced_decoder_line_size = itv->is_60hz ? 272 : 284;
1111
1112         /* Tuner */
1113         ivtv_call_all(itv, video, s_std, itv->std);
1114 }
1115
1116 void ivtv_s_std_dec(struct ivtv *itv, v4l2_std_id std)
1117 {
1118         struct yuv_playback_info *yi = &itv->yuv_info;
1119         DEFINE_WAIT(wait);
1120         int f;
1121
1122         /* set display standard */
1123         itv->std_out = std;
1124         itv->is_out_60hz = (std & V4L2_STD_525_60) ? 1 : 0;
1125         itv->is_out_50hz = !itv->is_out_60hz;
1126         ivtv_call_all(itv, video, s_std_output, itv->std_out);
1127
1128         /*
1129          * The next firmware call is time sensitive. Time it to
1130          * avoid risk of a hard lock, by trying to ensure the call
1131          * happens within the first 100 lines of the top field.
1132          * Make 4 attempts to sync to the decoder before giving up.
1133          */
1134         mutex_unlock(&itv->serialize_lock);
1135         for (f = 0; f < 4; f++) {
1136                 prepare_to_wait(&itv->vsync_waitq, &wait,
1137                                 TASK_UNINTERRUPTIBLE);
1138                 if ((read_reg(IVTV_REG_DEC_LINE_FIELD) >> 16) < 100)
1139                         break;
1140                 schedule_timeout(msecs_to_jiffies(25));
1141         }
1142         finish_wait(&itv->vsync_waitq, &wait);
1143         mutex_lock(&itv->serialize_lock);
1144
1145         if (f == 4)
1146                 IVTV_WARN("Mode change failed to sync to decoder\n");
1147
1148         ivtv_vapi(itv, CX2341X_DEC_SET_STANDARD, 1, itv->is_out_50hz);
1149         itv->main_rect.left = 0;
1150         itv->main_rect.top = 0;
1151         itv->main_rect.width = 720;
1152         itv->main_rect.height = itv->is_out_50hz ? 576 : 480;
1153         ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
1154                 720, itv->main_rect.height, 0, 0);
1155         yi->main_rect = itv->main_rect;
1156         if (!itv->osd_info) {
1157                 yi->osd_full_w = 720;
1158                 yi->osd_full_h = itv->is_out_50hz ? 576 : 480;
1159         }
1160 }
1161
1162 static int ivtv_s_std(struct file *file, void *fh, v4l2_std_id std)
1163 {
1164         struct ivtv *itv = fh2id(fh)->itv;
1165
1166         if ((std & V4L2_STD_ALL) == 0)
1167                 return -EINVAL;
1168
1169         if (std == itv->std)
1170                 return 0;
1171
1172         if (test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ||
1173             atomic_read(&itv->capturing) > 0 ||
1174             atomic_read(&itv->decoding) > 0) {
1175                 /* Switching standard would mess with already running
1176                    streams, prevent that by returning EBUSY. */
1177                 return -EBUSY;
1178         }
1179
1180         IVTV_DEBUG_INFO("Switching standard to %llx.\n",
1181                 (unsigned long long)itv->std);
1182
1183         ivtv_s_std_enc(itv, std);
1184         if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)
1185                 ivtv_s_std_dec(itv, std);
1186
1187         return 0;
1188 }
1189
1190 static int ivtv_s_tuner(struct file *file, void *fh, const struct v4l2_tuner *vt)
1191 {
1192         struct ivtv_open_id *id = fh2id(fh);
1193         struct ivtv *itv = id->itv;
1194
1195         if (vt->index != 0)
1196                 return -EINVAL;
1197
1198         ivtv_call_all(itv, tuner, s_tuner, vt);
1199
1200         return 0;
1201 }
1202
1203 static int ivtv_g_tuner(struct file *file, void *fh, struct v4l2_tuner *vt)
1204 {
1205         struct ivtv *itv = fh2id(fh)->itv;
1206
1207         if (vt->index != 0)
1208                 return -EINVAL;
1209
1210         ivtv_call_all(itv, tuner, g_tuner, vt);
1211
1212         if (vt->type == V4L2_TUNER_RADIO)
1213                 strscpy(vt->name, "ivtv Radio Tuner", sizeof(vt->name));
1214         else
1215                 strscpy(vt->name, "ivtv TV Tuner", sizeof(vt->name));
1216         return 0;
1217 }
1218
1219 static int ivtv_g_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_sliced_vbi_cap *cap)
1220 {
1221         struct ivtv *itv = fh2id(fh)->itv;
1222         int set = itv->is_50hz ? V4L2_SLICED_VBI_625 : V4L2_SLICED_VBI_525;
1223         int f, l;
1224
1225         if (cap->type == V4L2_BUF_TYPE_SLICED_VBI_CAPTURE) {
1226                 for (f = 0; f < 2; f++) {
1227                         for (l = 0; l < 24; l++) {
1228                                 if (valid_service_line(f, l, itv->is_50hz))
1229                                         cap->service_lines[f][l] = set;
1230                         }
1231                 }
1232         } else if (cap->type == V4L2_BUF_TYPE_SLICED_VBI_OUTPUT) {
1233                 if (!(itv->v4l2_cap & V4L2_CAP_SLICED_VBI_OUTPUT))
1234                         return -EINVAL;
1235                 if (itv->is_60hz) {
1236                         cap->service_lines[0][21] = V4L2_SLICED_CAPTION_525;
1237                         cap->service_lines[1][21] = V4L2_SLICED_CAPTION_525;
1238                 } else {
1239                         cap->service_lines[0][23] = V4L2_SLICED_WSS_625;
1240                         cap->service_lines[0][16] = V4L2_SLICED_VPS;
1241                 }
1242         } else {
1243                 return -EINVAL;
1244         }
1245
1246         set = 0;
1247         for (f = 0; f < 2; f++)
1248                 for (l = 0; l < 24; l++)
1249                         set |= cap->service_lines[f][l];
1250         cap->service_set = set;
1251         return 0;
1252 }
1253
1254 static int ivtv_g_enc_index(struct file *file, void *fh, struct v4l2_enc_idx *idx)
1255 {
1256         struct ivtv *itv = fh2id(fh)->itv;
1257         struct v4l2_enc_idx_entry *e = idx->entry;
1258         int entries;
1259         int i;
1260
1261         entries = (itv->pgm_info_write_idx + IVTV_MAX_PGM_INDEX - itv->pgm_info_read_idx) %
1262                                 IVTV_MAX_PGM_INDEX;
1263         if (entries > V4L2_ENC_IDX_ENTRIES)
1264                 entries = V4L2_ENC_IDX_ENTRIES;
1265         idx->entries = 0;
1266         idx->entries_cap = IVTV_MAX_PGM_INDEX;
1267         if (!atomic_read(&itv->capturing))
1268                 return 0;
1269         for (i = 0; i < entries; i++) {
1270                 *e = itv->pgm_info[(itv->pgm_info_read_idx + i) % IVTV_MAX_PGM_INDEX];
1271                 if ((e->flags & V4L2_ENC_IDX_FRAME_MASK) <= V4L2_ENC_IDX_FRAME_B) {
1272                         idx->entries++;
1273                         e++;
1274                 }
1275         }
1276         itv->pgm_info_read_idx = (itv->pgm_info_read_idx + idx->entries) % IVTV_MAX_PGM_INDEX;
1277         return 0;
1278 }
1279
1280 static int ivtv_encoder_cmd(struct file *file, void *fh, struct v4l2_encoder_cmd *enc)
1281 {
1282         struct ivtv_open_id *id = fh2id(fh);
1283         struct ivtv *itv = id->itv;
1284
1285
1286         switch (enc->cmd) {
1287         case V4L2_ENC_CMD_START:
1288                 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
1289                 enc->flags = 0;
1290                 return ivtv_start_capture(id);
1291
1292         case V4L2_ENC_CMD_STOP:
1293                 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
1294                 enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END;
1295                 ivtv_stop_capture(id, enc->flags & V4L2_ENC_CMD_STOP_AT_GOP_END);
1296                 return 0;
1297
1298         case V4L2_ENC_CMD_PAUSE:
1299                 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
1300                 enc->flags = 0;
1301
1302                 if (!atomic_read(&itv->capturing))
1303                         return -EPERM;
1304                 if (test_and_set_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags))
1305                         return 0;
1306
1307                 ivtv_mute(itv);
1308                 ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 0);
1309                 break;
1310
1311         case V4L2_ENC_CMD_RESUME:
1312                 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
1313                 enc->flags = 0;
1314
1315                 if (!atomic_read(&itv->capturing))
1316                         return -EPERM;
1317
1318                 if (!test_and_clear_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags))
1319                         return 0;
1320
1321                 ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 1);
1322                 ivtv_unmute(itv);
1323                 break;
1324         default:
1325                 IVTV_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd);
1326                 return -EINVAL;
1327         }
1328
1329         return 0;
1330 }
1331
1332 static int ivtv_try_encoder_cmd(struct file *file, void *fh, struct v4l2_encoder_cmd *enc)
1333 {
1334         struct ivtv *itv = fh2id(fh)->itv;
1335
1336         switch (enc->cmd) {
1337         case V4L2_ENC_CMD_START:
1338                 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
1339                 enc->flags = 0;
1340                 return 0;
1341
1342         case V4L2_ENC_CMD_STOP:
1343                 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
1344                 enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END;
1345                 return 0;
1346
1347         case V4L2_ENC_CMD_PAUSE:
1348                 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
1349                 enc->flags = 0;
1350                 return 0;
1351
1352         case V4L2_ENC_CMD_RESUME:
1353                 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
1354                 enc->flags = 0;
1355                 return 0;
1356         default:
1357                 IVTV_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd);
1358                 return -EINVAL;
1359         }
1360 }
1361
1362 static int ivtv_g_fbuf(struct file *file, void *fh, struct v4l2_framebuffer *fb)
1363 {
1364         struct ivtv *itv = fh2id(fh)->itv;
1365         struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
1366         u32 data[CX2341X_MBOX_MAX_DATA];
1367         struct yuv_playback_info *yi = &itv->yuv_info;
1368
1369         int pixfmt;
1370         static u32 pixel_format[16] = {
1371                 V4L2_PIX_FMT_PAL8, /* Uses a 256-entry RGB colormap */
1372                 V4L2_PIX_FMT_RGB565,
1373                 V4L2_PIX_FMT_RGB555,
1374                 V4L2_PIX_FMT_RGB444,
1375                 V4L2_PIX_FMT_RGB32,
1376                 0,
1377                 0,
1378                 0,
1379                 V4L2_PIX_FMT_PAL8, /* Uses a 256-entry YUV colormap */
1380                 V4L2_PIX_FMT_YUV565,
1381                 V4L2_PIX_FMT_YUV555,
1382                 V4L2_PIX_FMT_YUV444,
1383                 V4L2_PIX_FMT_YUV32,
1384                 0,
1385                 0,
1386                 0,
1387         };
1388
1389         if (!(s->caps & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1390                 return -ENOTTY;
1391         if (!itv->osd_video_pbase)
1392                 return -ENOTTY;
1393
1394         fb->capability = V4L2_FBUF_CAP_EXTERNOVERLAY | V4L2_FBUF_CAP_CHROMAKEY |
1395                 V4L2_FBUF_CAP_GLOBAL_ALPHA;
1396
1397         ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0);
1398         data[0] |= (read_reg(0x2a00) >> 7) & 0x40;
1399         pixfmt = (data[0] >> 3) & 0xf;
1400
1401         fb->fmt.pixelformat = pixel_format[pixfmt];
1402         fb->fmt.width = itv->osd_rect.width;
1403         fb->fmt.height = itv->osd_rect.height;
1404         fb->fmt.field = V4L2_FIELD_INTERLACED;
1405         fb->fmt.bytesperline = fb->fmt.width;
1406         fb->fmt.colorspace = V4L2_COLORSPACE_SMPTE170M;
1407         fb->fmt.field = V4L2_FIELD_INTERLACED;
1408         if (fb->fmt.pixelformat != V4L2_PIX_FMT_PAL8)
1409                 fb->fmt.bytesperline *= 2;
1410         if (fb->fmt.pixelformat == V4L2_PIX_FMT_RGB32 ||
1411             fb->fmt.pixelformat == V4L2_PIX_FMT_YUV32)
1412                 fb->fmt.bytesperline *= 2;
1413         fb->fmt.sizeimage = fb->fmt.bytesperline * fb->fmt.height;
1414         fb->base = (void *)itv->osd_video_pbase;
1415         fb->flags = 0;
1416
1417         if (itv->osd_chroma_key_state)
1418                 fb->flags |= V4L2_FBUF_FLAG_CHROMAKEY;
1419
1420         if (itv->osd_global_alpha_state)
1421                 fb->flags |= V4L2_FBUF_FLAG_GLOBAL_ALPHA;
1422
1423         if (yi->track_osd)
1424                 fb->flags |= V4L2_FBUF_FLAG_OVERLAY;
1425
1426         pixfmt &= 7;
1427
1428         /* no local alpha for RGB565 or unknown formats */
1429         if (pixfmt == 1 || pixfmt > 4)
1430                 return 0;
1431
1432         /* 16-bit formats have inverted local alpha */
1433         if (pixfmt == 2 || pixfmt == 3)
1434                 fb->capability |= V4L2_FBUF_CAP_LOCAL_INV_ALPHA;
1435         else
1436                 fb->capability |= V4L2_FBUF_CAP_LOCAL_ALPHA;
1437
1438         if (itv->osd_local_alpha_state) {
1439                 /* 16-bit formats have inverted local alpha */
1440                 if (pixfmt == 2 || pixfmt == 3)
1441                         fb->flags |= V4L2_FBUF_FLAG_LOCAL_INV_ALPHA;
1442                 else
1443                         fb->flags |= V4L2_FBUF_FLAG_LOCAL_ALPHA;
1444         }
1445
1446         return 0;
1447 }
1448
1449 static int ivtv_s_fbuf(struct file *file, void *fh, const struct v4l2_framebuffer *fb)
1450 {
1451         struct ivtv_open_id *id = fh2id(fh);
1452         struct ivtv *itv = id->itv;
1453         struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
1454         struct yuv_playback_info *yi = &itv->yuv_info;
1455
1456         if (!(s->caps & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1457                 return -ENOTTY;
1458         if (!itv->osd_video_pbase)
1459                 return -ENOTTY;
1460
1461         itv->osd_global_alpha_state = (fb->flags & V4L2_FBUF_FLAG_GLOBAL_ALPHA) != 0;
1462         itv->osd_local_alpha_state =
1463                 (fb->flags & (V4L2_FBUF_FLAG_LOCAL_ALPHA|V4L2_FBUF_FLAG_LOCAL_INV_ALPHA)) != 0;
1464         itv->osd_chroma_key_state = (fb->flags & V4L2_FBUF_FLAG_CHROMAKEY) != 0;
1465         ivtv_set_osd_alpha(itv);
1466         yi->track_osd = (fb->flags & V4L2_FBUF_FLAG_OVERLAY) != 0;
1467         return 0;
1468 }
1469
1470 static int ivtv_overlay(struct file *file, void *fh, unsigned int on)
1471 {
1472         struct ivtv_open_id *id = fh2id(fh);
1473         struct ivtv *itv = id->itv;
1474         struct ivtv_stream *s = &itv->streams[fh2id(fh)->type];
1475
1476         if (!(s->caps & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1477                 return -ENOTTY;
1478         if (!itv->osd_video_pbase)
1479                 return -ENOTTY;
1480
1481         ivtv_vapi(itv, CX2341X_OSD_SET_STATE, 1, on != 0);
1482
1483         return 0;
1484 }
1485
1486 static int ivtv_subscribe_event(struct v4l2_fh *fh, const struct v4l2_event_subscription *sub)
1487 {
1488         switch (sub->type) {
1489         case V4L2_EVENT_VSYNC:
1490         case V4L2_EVENT_EOS:
1491                 return v4l2_event_subscribe(fh, sub, 0, NULL);
1492         default:
1493                 return v4l2_ctrl_subscribe_event(fh, sub);
1494         }
1495 }
1496
1497 static int ivtv_log_status(struct file *file, void *fh)
1498 {
1499         struct ivtv *itv = fh2id(fh)->itv;
1500         u32 data[CX2341X_MBOX_MAX_DATA];
1501
1502         int has_output = itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT;
1503         struct v4l2_input vidin;
1504         struct v4l2_audio audin;
1505         int i;
1506
1507         IVTV_INFO("Version: %s Card: %s\n", IVTV_VERSION, itv->card_name);
1508         if (itv->hw_flags & IVTV_HW_TVEEPROM) {
1509                 struct tveeprom tv;
1510
1511                 ivtv_read_eeprom(itv, &tv);
1512         }
1513         ivtv_call_all(itv, core, log_status);
1514         ivtv_get_input(itv, itv->active_input, &vidin);
1515         ivtv_get_audio_input(itv, itv->audio_input, &audin);
1516         IVTV_INFO("Video Input:  %s\n", vidin.name);
1517         IVTV_INFO("Audio Input:  %s%s\n", audin.name,
1518                 itv->dualwatch_stereo_mode == V4L2_MPEG_AUDIO_MODE_DUAL ?
1519                         " (Bilingual)" : "");
1520         if (has_output) {
1521                 struct v4l2_output vidout;
1522                 struct v4l2_audioout audout;
1523                 int mode = itv->output_mode;
1524                 static const char * const output_modes[5] = {
1525                         "None",
1526                         "MPEG Streaming",
1527                         "YUV Streaming",
1528                         "YUV Frames",
1529                         "Passthrough",
1530                 };
1531                 static const char * const alpha_mode[4] = {
1532                         "None",
1533                         "Global",
1534                         "Local",
1535                         "Global and Local"
1536                 };
1537                 static const char * const pixel_format[16] = {
1538                         "ARGB Indexed",
1539                         "RGB 5:6:5",
1540                         "ARGB 1:5:5:5",
1541                         "ARGB 1:4:4:4",
1542                         "ARGB 8:8:8:8",
1543                         "5",
1544                         "6",
1545                         "7",
1546                         "AYUV Indexed",
1547                         "YUV 5:6:5",
1548                         "AYUV 1:5:5:5",
1549                         "AYUV 1:4:4:4",
1550                         "AYUV 8:8:8:8",
1551                         "13",
1552                         "14",
1553                         "15",
1554                 };
1555
1556                 ivtv_get_output(itv, itv->active_output, &vidout);
1557                 ivtv_get_audio_output(itv, 0, &audout);
1558                 IVTV_INFO("Video Output: %s\n", vidout.name);
1559                 if (mode < 0 || mode > OUT_PASSTHROUGH)
1560                         mode = OUT_NONE;
1561                 IVTV_INFO("Output Mode:  %s\n", output_modes[mode]);
1562                 ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0);
1563                 data[0] |= (read_reg(0x2a00) >> 7) & 0x40;
1564                 IVTV_INFO("Overlay:      %s, Alpha: %s, Pixel Format: %s\n",
1565                         data[0] & 1 ? "On" : "Off",
1566                         alpha_mode[(data[0] >> 1) & 0x3],
1567                         pixel_format[(data[0] >> 3) & 0xf]);
1568         }
1569         IVTV_INFO("Tuner:  %s\n",
1570                 test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ? "Radio" : "TV");
1571         v4l2_ctrl_handler_log_status(&itv->cxhdl.hdl, itv->v4l2_dev.name);
1572         IVTV_INFO("Status flags:    0x%08lx\n", itv->i_flags);
1573         for (i = 0; i < IVTV_MAX_STREAMS; i++) {
1574                 struct ivtv_stream *s = &itv->streams[i];
1575
1576                 if (s->vdev.v4l2_dev == NULL || s->buffers == 0)
1577                         continue;
1578                 IVTV_INFO("Stream %s: status 0x%04lx, %d%% of %d KiB (%d buffers) in use\n", s->name, s->s_flags,
1579                                 (s->buffers - s->q_free.buffers) * 100 / s->buffers,
1580                                 (s->buffers * s->buf_size) / 1024, s->buffers);
1581         }
1582
1583         IVTV_INFO("Read MPG/VBI: %lld/%lld bytes\n",
1584                         (long long)itv->mpg_data_received,
1585                         (long long)itv->vbi_data_inserted);
1586         return 0;
1587 }
1588
1589 static int ivtv_decoder_cmd(struct file *file, void *fh, struct v4l2_decoder_cmd *dec)
1590 {
1591         struct ivtv_open_id *id = fh2id(file->private_data);
1592         struct ivtv *itv = id->itv;
1593
1594         IVTV_DEBUG_IOCTL("VIDIOC_DECODER_CMD %d\n", dec->cmd);
1595         return ivtv_video_command(itv, id, dec, false);
1596 }
1597
1598 static int ivtv_try_decoder_cmd(struct file *file, void *fh, struct v4l2_decoder_cmd *dec)
1599 {
1600         struct ivtv_open_id *id = fh2id(file->private_data);
1601         struct ivtv *itv = id->itv;
1602
1603         IVTV_DEBUG_IOCTL("VIDIOC_TRY_DECODER_CMD %d\n", dec->cmd);
1604         return ivtv_video_command(itv, id, dec, true);
1605 }
1606
1607 #ifdef CONFIG_VIDEO_IVTV_DEPRECATED_IOCTLS
1608 static __inline__ void warn_deprecated_ioctl(const char *name)
1609 {
1610         pr_warn_once("warning: the %s ioctl is deprecated. Don't use it, as it will be removed soon\n",
1611                      name);
1612 }
1613
1614 #ifdef CONFIG_COMPAT
1615 struct compat_video_event {
1616         __s32 type;
1617         /* unused, make sure to use atomic time for y2038 if it ever gets used */
1618         compat_long_t timestamp;
1619         union {
1620                 video_size_t size;
1621                 unsigned int frame_rate;        /* in frames per 1000sec */
1622                 unsigned char vsync_field;      /* unknown/odd/even/progressive */
1623         } u;
1624 };
1625 #define VIDEO_GET_EVENT32 _IOR('o', 28, struct compat_video_event)
1626 #endif
1627
1628 #endif
1629
1630 static int ivtv_decoder_ioctls(struct file *filp, unsigned int cmd, void *arg)
1631 {
1632         struct ivtv_open_id *id = fh2id(filp->private_data);
1633         struct ivtv *itv = id->itv;
1634         struct ivtv_stream *s = &itv->streams[id->type];
1635 #ifdef CONFIG_VIDEO_IVTV_DEPRECATED_IOCTLS
1636         int nonblocking = filp->f_flags & O_NONBLOCK;
1637         unsigned long iarg = (unsigned long)arg;
1638 #endif
1639
1640         switch (cmd) {
1641         case IVTV_IOC_DMA_FRAME: {
1642                 struct ivtv_dma_frame *args = arg;
1643
1644                 IVTV_DEBUG_IOCTL("IVTV_IOC_DMA_FRAME\n");
1645                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1646                         return -EINVAL;
1647                 if (args->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
1648                         return -EINVAL;
1649                 if (itv->output_mode == OUT_UDMA_YUV && args->y_source == NULL)
1650                         return 0;
1651                 if (ivtv_start_decoding(id, id->type)) {
1652                         return -EBUSY;
1653                 }
1654                 if (ivtv_set_output_mode(itv, OUT_UDMA_YUV) != OUT_UDMA_YUV) {
1655                         ivtv_release_stream(s);
1656                         return -EBUSY;
1657                 }
1658                 /* Mark that this file handle started the UDMA_YUV mode */
1659                 id->yuv_frames = 1;
1660                 if (args->y_source == NULL)
1661                         return 0;
1662                 return ivtv_yuv_prep_frame(itv, args);
1663         }
1664
1665         case IVTV_IOC_PASSTHROUGH_MODE:
1666                 IVTV_DEBUG_IOCTL("IVTV_IOC_PASSTHROUGH_MODE\n");
1667                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1668                         return -EINVAL;
1669                 return ivtv_passthrough_mode(itv, *(int *)arg != 0);
1670 #ifdef CONFIG_VIDEO_IVTV_DEPRECATED_IOCTLS
1671         case VIDEO_GET_PTS: {
1672                 s64 *pts = arg;
1673                 s64 frame;
1674
1675                 warn_deprecated_ioctl("VIDEO_GET_PTS");
1676                 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) {
1677                         *pts = s->dma_pts;
1678                         break;
1679                 }
1680                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1681                         return -EINVAL;
1682                 return ivtv_g_pts_frame(itv, pts, &frame);
1683         }
1684
1685         case VIDEO_GET_FRAME_COUNT: {
1686                 s64 *frame = arg;
1687                 s64 pts;
1688
1689                 warn_deprecated_ioctl("VIDEO_GET_FRAME_COUNT");
1690                 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) {
1691                         *frame = 0;
1692                         break;
1693                 }
1694                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1695                         return -EINVAL;
1696                 return ivtv_g_pts_frame(itv, &pts, frame);
1697         }
1698
1699         case VIDEO_PLAY: {
1700                 struct v4l2_decoder_cmd dc;
1701
1702                 warn_deprecated_ioctl("VIDEO_PLAY");
1703                 memset(&dc, 0, sizeof(dc));
1704                 dc.cmd = V4L2_DEC_CMD_START;
1705                 return ivtv_video_command(itv, id, &dc, 0);
1706         }
1707
1708         case VIDEO_STOP: {
1709                 struct v4l2_decoder_cmd dc;
1710
1711                 warn_deprecated_ioctl("VIDEO_STOP");
1712                 memset(&dc, 0, sizeof(dc));
1713                 dc.cmd = V4L2_DEC_CMD_STOP;
1714                 dc.flags = V4L2_DEC_CMD_STOP_TO_BLACK | V4L2_DEC_CMD_STOP_IMMEDIATELY;
1715                 return ivtv_video_command(itv, id, &dc, 0);
1716         }
1717
1718         case VIDEO_FREEZE: {
1719                 struct v4l2_decoder_cmd dc;
1720
1721                 warn_deprecated_ioctl("VIDEO_FREEZE");
1722                 memset(&dc, 0, sizeof(dc));
1723                 dc.cmd = V4L2_DEC_CMD_PAUSE;
1724                 return ivtv_video_command(itv, id, &dc, 0);
1725         }
1726
1727         case VIDEO_CONTINUE: {
1728                 struct v4l2_decoder_cmd dc;
1729
1730                 warn_deprecated_ioctl("VIDEO_CONTINUE");
1731                 memset(&dc, 0, sizeof(dc));
1732                 dc.cmd = V4L2_DEC_CMD_RESUME;
1733                 return ivtv_video_command(itv, id, &dc, 0);
1734         }
1735
1736         case VIDEO_COMMAND:
1737         case VIDEO_TRY_COMMAND: {
1738                 /* Note: struct v4l2_decoder_cmd has the same layout as
1739                    struct video_command */
1740                 struct v4l2_decoder_cmd *dc = arg;
1741                 int try = (cmd == VIDEO_TRY_COMMAND);
1742
1743                 if (try)
1744                         warn_deprecated_ioctl("VIDEO_TRY_COMMAND");
1745                 else
1746                         warn_deprecated_ioctl("VIDEO_COMMAND");
1747                 return ivtv_video_command(itv, id, dc, try);
1748         }
1749
1750 #ifdef CONFIG_COMPAT
1751         case VIDEO_GET_EVENT32:
1752 #endif
1753         case VIDEO_GET_EVENT: {
1754 #ifdef CONFIG_COMPAT
1755                 struct compat_video_event *ev32 = arg;
1756 #endif
1757                 struct video_event *ev = arg;
1758                 DEFINE_WAIT(wait);
1759
1760                 warn_deprecated_ioctl("VIDEO_GET_EVENT");
1761                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1762                         return -EINVAL;
1763                 memset(ev, 0, sizeof(*ev));
1764                 set_bit(IVTV_F_I_EV_VSYNC_ENABLED, &itv->i_flags);
1765
1766                 while (1) {
1767                         if (test_and_clear_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags))
1768                                 ev->type = VIDEO_EVENT_DECODER_STOPPED;
1769                         else if (test_and_clear_bit(IVTV_F_I_EV_VSYNC, &itv->i_flags)) {
1770                                 unsigned char vsync_field;
1771
1772                                 ev->type = VIDEO_EVENT_VSYNC;
1773                                 vsync_field = test_bit(IVTV_F_I_EV_VSYNC_FIELD, &itv->i_flags) ?
1774                                         VIDEO_VSYNC_FIELD_ODD : VIDEO_VSYNC_FIELD_EVEN;
1775                                 if (itv->output_mode == OUT_UDMA_YUV &&
1776                                         (itv->yuv_info.lace_mode & IVTV_YUV_MODE_MASK) ==
1777                                                                 IVTV_YUV_MODE_PROGRESSIVE) {
1778                                         vsync_field = VIDEO_VSYNC_FIELD_PROGRESSIVE;
1779                                 }
1780 #ifdef CONFIG_COMPAT
1781                                 if (cmd == VIDEO_GET_EVENT32)
1782                                         ev32->u.vsync_field = vsync_field;
1783                                 else
1784 #endif
1785                                         ev->u.vsync_field = vsync_field;
1786                         }
1787                         if (ev->type)
1788                                 return 0;
1789                         if (nonblocking)
1790                                 return -EAGAIN;
1791                         /* Wait for event. Note that serialize_lock is locked,
1792                            so to allow other processes to access the driver while
1793                            we are waiting unlock first and later lock again. */
1794                         mutex_unlock(&itv->serialize_lock);
1795                         prepare_to_wait(&itv->event_waitq, &wait, TASK_INTERRUPTIBLE);
1796                         if (!test_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags) &&
1797                             !test_bit(IVTV_F_I_EV_VSYNC, &itv->i_flags))
1798                                 schedule();
1799                         finish_wait(&itv->event_waitq, &wait);
1800                         mutex_lock(&itv->serialize_lock);
1801                         if (signal_pending(current)) {
1802                                 /* return if a signal was received */
1803                                 IVTV_DEBUG_INFO("User stopped wait for event\n");
1804                                 return -EINTR;
1805                         }
1806                 }
1807                 break;
1808         }
1809
1810         case VIDEO_SELECT_SOURCE:
1811                 warn_deprecated_ioctl("VIDEO_SELECT_SOURCE");
1812                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1813                         return -EINVAL;
1814                 return ivtv_passthrough_mode(itv, iarg == VIDEO_SOURCE_DEMUX);
1815
1816         case AUDIO_SET_MUTE:
1817                 warn_deprecated_ioctl("AUDIO_SET_MUTE");
1818                 itv->speed_mute_audio = iarg;
1819                 return 0;
1820
1821         case AUDIO_CHANNEL_SELECT:
1822                 warn_deprecated_ioctl("AUDIO_CHANNEL_SELECT");
1823                 if (iarg > AUDIO_STEREO_SWAPPED)
1824                         return -EINVAL;
1825                 return v4l2_ctrl_s_ctrl(itv->ctrl_audio_playback, iarg + 1);
1826
1827         case AUDIO_BILINGUAL_CHANNEL_SELECT:
1828                 warn_deprecated_ioctl("AUDIO_BILINGUAL_CHANNEL_SELECT");
1829                 if (iarg > AUDIO_STEREO_SWAPPED)
1830                         return -EINVAL;
1831                 return v4l2_ctrl_s_ctrl(itv->ctrl_audio_multilingual_playback, iarg + 1);
1832 #endif
1833         default:
1834                 return -EINVAL;
1835         }
1836         return 0;
1837 }
1838
1839 static long ivtv_default(struct file *file, void *fh, bool valid_prio,
1840                          unsigned int cmd, void *arg)
1841 {
1842         struct ivtv *itv = fh2id(fh)->itv;
1843
1844         if (!valid_prio) {
1845                 switch (cmd) {
1846                 case IVTV_IOC_PASSTHROUGH_MODE:
1847 #ifdef CONFIG_VIDEO_IVTV_DEPRECATED_IOCTLS
1848                 case VIDEO_PLAY:
1849                 case VIDEO_STOP:
1850                 case VIDEO_FREEZE:
1851                 case VIDEO_CONTINUE:
1852                 case VIDEO_COMMAND:
1853                 case VIDEO_SELECT_SOURCE:
1854                 case AUDIO_SET_MUTE:
1855                 case AUDIO_CHANNEL_SELECT:
1856                 case AUDIO_BILINGUAL_CHANNEL_SELECT:
1857 #endif
1858                         return -EBUSY;
1859                 }
1860         }
1861
1862         switch (cmd) {
1863         case VIDIOC_INT_RESET: {
1864                 u32 val = *(u32 *)arg;
1865
1866                 if ((val == 0 && itv->options.newi2c) || (val & 0x01))
1867                         ivtv_reset_ir_gpio(itv);
1868                 if (val & 0x02)
1869                         v4l2_subdev_call(itv->sd_video, core, reset, 0);
1870                 break;
1871         }
1872
1873         case IVTV_IOC_DMA_FRAME:
1874         case IVTV_IOC_PASSTHROUGH_MODE:
1875 #ifdef CONFIG_VIDEO_IVTV_DEPRECATED_IOCTLS
1876         case VIDEO_GET_PTS:
1877         case VIDEO_GET_FRAME_COUNT:
1878         case VIDEO_GET_EVENT:
1879         case VIDEO_PLAY:
1880         case VIDEO_STOP:
1881         case VIDEO_FREEZE:
1882         case VIDEO_CONTINUE:
1883         case VIDEO_COMMAND:
1884         case VIDEO_TRY_COMMAND:
1885         case VIDEO_SELECT_SOURCE:
1886         case AUDIO_SET_MUTE:
1887         case AUDIO_CHANNEL_SELECT:
1888         case AUDIO_BILINGUAL_CHANNEL_SELECT:
1889 #endif
1890                 return ivtv_decoder_ioctls(file, cmd, (void *)arg);
1891
1892         default:
1893                 return -ENOTTY;
1894         }
1895         return 0;
1896 }
1897
1898 static const struct v4l2_ioctl_ops ivtv_ioctl_ops = {
1899         .vidioc_querycap                    = ivtv_querycap,
1900         .vidioc_s_audio                     = ivtv_s_audio,
1901         .vidioc_g_audio                     = ivtv_g_audio,
1902         .vidioc_enumaudio                   = ivtv_enumaudio,
1903         .vidioc_s_audout                    = ivtv_s_audout,
1904         .vidioc_g_audout                    = ivtv_g_audout,
1905         .vidioc_enum_input                  = ivtv_enum_input,
1906         .vidioc_enum_output                 = ivtv_enum_output,
1907         .vidioc_enumaudout                  = ivtv_enumaudout,
1908         .vidioc_g_pixelaspect               = ivtv_g_pixelaspect,
1909         .vidioc_s_selection                 = ivtv_s_selection,
1910         .vidioc_g_selection                 = ivtv_g_selection,
1911         .vidioc_g_input                     = ivtv_g_input,
1912         .vidioc_s_input                     = ivtv_s_input,
1913         .vidioc_g_output                    = ivtv_g_output,
1914         .vidioc_s_output                    = ivtv_s_output,
1915         .vidioc_g_frequency                 = ivtv_g_frequency,
1916         .vidioc_s_frequency                 = ivtv_s_frequency,
1917         .vidioc_s_tuner                     = ivtv_s_tuner,
1918         .vidioc_g_tuner                     = ivtv_g_tuner,
1919         .vidioc_g_enc_index                 = ivtv_g_enc_index,
1920         .vidioc_g_fbuf                      = ivtv_g_fbuf,
1921         .vidioc_s_fbuf                      = ivtv_s_fbuf,
1922         .vidioc_g_std                       = ivtv_g_std,
1923         .vidioc_s_std                       = ivtv_s_std,
1924         .vidioc_overlay                     = ivtv_overlay,
1925         .vidioc_log_status                  = ivtv_log_status,
1926         .vidioc_enum_fmt_vid_cap            = ivtv_enum_fmt_vid_cap,
1927         .vidioc_encoder_cmd                 = ivtv_encoder_cmd,
1928         .vidioc_try_encoder_cmd             = ivtv_try_encoder_cmd,
1929         .vidioc_decoder_cmd                 = ivtv_decoder_cmd,
1930         .vidioc_try_decoder_cmd             = ivtv_try_decoder_cmd,
1931         .vidioc_enum_fmt_vid_out            = ivtv_enum_fmt_vid_out,
1932         .vidioc_g_fmt_vid_cap               = ivtv_g_fmt_vid_cap,
1933         .vidioc_g_fmt_vbi_cap               = ivtv_g_fmt_vbi_cap,
1934         .vidioc_g_fmt_sliced_vbi_cap        = ivtv_g_fmt_sliced_vbi_cap,
1935         .vidioc_g_fmt_vid_out               = ivtv_g_fmt_vid_out,
1936         .vidioc_g_fmt_vid_out_overlay       = ivtv_g_fmt_vid_out_overlay,
1937         .vidioc_g_fmt_sliced_vbi_out        = ivtv_g_fmt_sliced_vbi_out,
1938         .vidioc_s_fmt_vid_cap               = ivtv_s_fmt_vid_cap,
1939         .vidioc_s_fmt_vbi_cap               = ivtv_s_fmt_vbi_cap,
1940         .vidioc_s_fmt_sliced_vbi_cap        = ivtv_s_fmt_sliced_vbi_cap,
1941         .vidioc_s_fmt_vid_out               = ivtv_s_fmt_vid_out,
1942         .vidioc_s_fmt_vid_out_overlay       = ivtv_s_fmt_vid_out_overlay,
1943         .vidioc_s_fmt_sliced_vbi_out        = ivtv_s_fmt_sliced_vbi_out,
1944         .vidioc_try_fmt_vid_cap             = ivtv_try_fmt_vid_cap,
1945         .vidioc_try_fmt_vbi_cap             = ivtv_try_fmt_vbi_cap,
1946         .vidioc_try_fmt_sliced_vbi_cap      = ivtv_try_fmt_sliced_vbi_cap,
1947         .vidioc_try_fmt_vid_out             = ivtv_try_fmt_vid_out,
1948         .vidioc_try_fmt_vid_out_overlay     = ivtv_try_fmt_vid_out_overlay,
1949         .vidioc_try_fmt_sliced_vbi_out      = ivtv_try_fmt_sliced_vbi_out,
1950         .vidioc_g_sliced_vbi_cap            = ivtv_g_sliced_vbi_cap,
1951 #ifdef CONFIG_VIDEO_ADV_DEBUG
1952         .vidioc_g_register                  = ivtv_g_register,
1953         .vidioc_s_register                  = ivtv_s_register,
1954 #endif
1955         .vidioc_default                     = ivtv_default,
1956         .vidioc_subscribe_event             = ivtv_subscribe_event,
1957         .vidioc_unsubscribe_event           = v4l2_event_unsubscribe,
1958 };
1959
1960 void ivtv_set_funcs(struct video_device *vdev)
1961 {
1962         vdev->ioctl_ops = &ivtv_ioctl_ops;
1963 }