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