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

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