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 = ((struct ivtv_open_id *)fh)->itv;
 317         struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
 318
 319         vbifmt->reserved[0] = 0;
 320         vbifmt->reserved[1] = 0;
 321         if (!(itv->v4l2_cap & V4L2_CAP_SLICED_VBI_OUTPUT))
 322                 return -EINVAL;
 323         vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
 324         if (itv->is_60hz) {
 325                 vbifmt->service_lines[0][21] = V4L2_SLICED_CAPTION_525;
 326                 vbifmt->service_lines[1][21] = V4L2_SLICED_CAPTION_525;
 327         } else {
 328                 vbifmt->service_lines[0][23] = V4L2_SLICED_WSS_625;
 329                 vbifmt->service_lines[0][16] = V4L2_SLICED_VPS;
 330         }
 331         vbifmt->service_set = ivtv_get_service_set(vbifmt);
 332         return 0;
 333 }
 334
 335 static int ivtv_g_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
 336 {
 337         struct ivtv_open_id *id = fh;
 338         struct ivtv *itv = id->itv;
 339         struct v4l2_pix_format *pixfmt = &fmt->fmt.pix;
 340
 341         pixfmt->width = itv->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 = ((struct ivtv_open_id *)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 = 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 = 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 = ((struct ivtv_open_id *)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 = 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 = 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 = 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 = ((struct ivtv_open_id *)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 = 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 = ((struct ivtv_open_id *)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 = 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 = 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 = ((struct ivtv_open_id *)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 = ((struct ivtv_open_id *)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 = ((struct ivtv_open_id *)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 = ((struct ivtv_open_id *)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_g_priority(struct file *file, void *fh, enum v4l2_priority *p)
 754 {
 755         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
 756
 757         *p = v4l2_prio_max(&itv->prio);
 758
 759         return 0;
 760 }
 761
 762 static int ivtv_s_priority(struct file *file, void *fh, enum v4l2_priority prio)
 763 {
 764         struct ivtv_open_id *id = fh;
 765         struct ivtv *itv = id->itv;
 766
 767         return v4l2_prio_change(&itv->prio, &id->prio, prio);
 768 }
 769
 770 static int ivtv_querycap(struct file *file, void *fh, struct v4l2_capability *vcap)
 771 {
 772         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
 773
 774         strlcpy(vcap->driver, IVTV_DRIVER_NAME, sizeof(vcap->driver));
 775         strlcpy(vcap->card, itv->card_name, sizeof(vcap->card));
 776         snprintf(vcap->bus_info, sizeof(vcap->bus_info), "PCI:%s", pci_name(itv->pdev));
 777         vcap->version = IVTV_DRIVER_VERSION;        /* version */
 778         vcap->capabilities = itv->v4l2_cap;         /* capabilities */
 779         return 0;
 780 }
 781
 782 static int ivtv_enumaudio(struct file *file, void *fh, struct v4l2_audio *vin)
 783 {
 784         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
 785
 786         return ivtv_get_audio_input(itv, vin->index, vin);
 787 }
 788
 789 static int ivtv_g_audio(struct file *file, void *fh, struct v4l2_audio *vin)
 790 {
 791         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
 792
 793         vin->index = itv->audio_input;
 794         return ivtv_get_audio_input(itv, vin->index, vin);
 795 }
 796
 797 static int ivtv_s_audio(struct file *file, void *fh, struct v4l2_audio *vout)
 798 {
 799         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
 800
 801         if (vout->index >= itv->nof_audio_inputs)
 802                 return -EINVAL;
 803
 804         itv->audio_input = vout->index;
 805         ivtv_audio_set_io(itv);
 806
 807         return 0;
 808 }
 809
 810 static int ivtv_enumaudout(struct file *file, void *fh, struct v4l2_audioout *vin)
 811 {
 812         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
 813
 814         /* set it to defaults from our table */
 815         return ivtv_get_audio_output(itv, vin->index, vin);
 816 }
 817
 818 static int ivtv_g_audout(struct file *file, void *fh, struct v4l2_audioout *vin)
 819 {
 820         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
 821
 822         vin->index = 0;
 823         return ivtv_get_audio_output(itv, vin->index, vin);
 824 }
 825
 826 static int ivtv_s_audout(struct file *file, void *fh, struct v4l2_audioout *vout)
 827 {
 828         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
 829
 830         return ivtv_get_audio_output(itv, vout->index, vout);
 831 }
 832
 833 static int ivtv_enum_input(struct file *file, void *fh, struct v4l2_input *vin)
 834 {
 835         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
 836
 837         /* set it to defaults from our table */
 838         return ivtv_get_input(itv, vin->index, vin);
 839 }
 840
 841 static int ivtv_enum_output(struct file *file, void *fh, struct v4l2_output *vout)
 842 {
 843         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
 844
 845         return ivtv_get_output(itv, vout->index, vout);
 846 }
 847
 848 static int ivtv_cropcap(struct file *file, void *fh, struct v4l2_cropcap *cropcap)
 849 {
 850         struct ivtv_open_id *id = fh;
 851         struct ivtv *itv = id->itv;
 852         struct yuv_playback_info *yi = &itv->yuv_info;
 853         int streamtype;
 854
 855         streamtype = id->type;
 856
 857         if (cropcap->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
 858                 return -EINVAL;
 859         cropcap->bounds.top = cropcap->bounds.left = 0;
 860         cropcap->bounds.width = 720;
 861         if (cropcap->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
 862                 cropcap->bounds.height = itv->is_50hz ? 576 : 480;
 863                 cropcap->pixelaspect.numerator = itv->is_50hz ? 59 : 10;
 864                 cropcap->pixelaspect.denominator = itv->is_50hz ? 54 : 11;
 865         } else if (streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
 866                 if (yi->track_osd) {
 867                         cropcap->bounds.width = yi->osd_full_w;
 868                         cropcap->bounds.height = yi->osd_full_h;
 869                 } else {
 870                         cropcap->bounds.width = 720;
 871                         cropcap->bounds.height =
 872                                         itv->is_out_50hz ? 576 : 480;
 873                 }
 874                 cropcap->pixelaspect.numerator = itv->is_out_50hz ? 59 : 10;
 875                 cropcap->pixelaspect.denominator = itv->is_out_50hz ? 54 : 11;
 876         } else {
 877                 cropcap->bounds.height = itv->is_out_50hz ? 576 : 480;
 878                 cropcap->pixelaspect.numerator = itv->is_out_50hz ? 59 : 10;
 879                 cropcap->pixelaspect.denominator = itv->is_out_50hz ? 54 : 11;
 880         }
 881         cropcap->defrect = cropcap->bounds;
 882         return 0;
 883 }
 884
 885 static int ivtv_s_crop(struct file *file, void *fh, struct v4l2_crop *crop)
 886 {
 887         struct ivtv_open_id *id = fh;
 888         struct ivtv *itv = id->itv;
 889         struct yuv_playback_info *yi = &itv->yuv_info;
 890         int streamtype;
 891
 892         streamtype = id->type;
 893
 894         if (crop->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
 895             (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) {
 896                 if (streamtype == IVTV_DEC_STREAM_TYPE_YUV) {
 897                         yi->main_rect = crop->c;
 898                         return 0;
 899                 } else {
 900                         if (!ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
 901                                 crop->c.width, crop->c.height, crop->c.left, crop->c.top)) {
 902                                 itv->main_rect = crop->c;
 903                                 return 0;
 904                         }
 905                 }
 906                 return -EINVAL;
 907         }
 908         return -EINVAL;
 909 }
 910
 911 static int ivtv_g_crop(struct file *file, void *fh, struct v4l2_crop *crop)
 912 {
 913         struct ivtv_open_id *id = fh;
 914         struct ivtv *itv = id->itv;
 915         struct yuv_playback_info *yi = &itv->yuv_info;
 916         int streamtype;
 917
 918         streamtype = id->type;
 919
 920         if (crop->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
 921             (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) {
 922                 if (streamtype == IVTV_DEC_STREAM_TYPE_YUV)
 923                         crop->c = yi->main_rect;
 924                 else
 925                         crop->c = itv->main_rect;
 926                 return 0;
 927         }
 928         return -EINVAL;
 929 }
 930
 931 static int ivtv_enum_fmt_vid_cap(struct file *file, void *fh, struct v4l2_fmtdesc *fmt)
 932 {
 933         static struct v4l2_fmtdesc formats[] = {
 934                 { 0, 0, 0,
 935                   "HM12 (YUV 4:2:0)", V4L2_PIX_FMT_HM12,
 936                   { 0, 0, 0, 0 }
 937                 },
 938                 { 1, 0, V4L2_FMT_FLAG_COMPRESSED,
 939                   "MPEG", V4L2_PIX_FMT_MPEG,
 940                   { 0, 0, 0, 0 }
 941                 }
 942         };
 943         enum v4l2_buf_type type = fmt->type;
 944
 945         if (fmt->index > 1)
 946                 return -EINVAL;
 947
 948         *fmt = formats[fmt->index];
 949         fmt->type = type;
 950         return 0;
 951 }
 952
 953 static int ivtv_enum_fmt_vid_out(struct file *file, void *fh, struct v4l2_fmtdesc *fmt)
 954 {
 955         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
 956
 957         static struct v4l2_fmtdesc formats[] = {
 958                 { 0, 0, 0,
 959                   "HM12 (YUV 4:2:0)", V4L2_PIX_FMT_HM12,
 960                   { 0, 0, 0, 0 }
 961                 },
 962                 { 1, 0, V4L2_FMT_FLAG_COMPRESSED,
 963                   "MPEG", V4L2_PIX_FMT_MPEG,
 964                   { 0, 0, 0, 0 }
 965                 }
 966         };
 967         enum v4l2_buf_type type = fmt->type;
 968
 969         if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
 970                 return -EINVAL;
 971
 972         if (fmt->index > 1)
 973                 return -EINVAL;
 974
 975         *fmt = formats[fmt->index];
 976         fmt->type = type;
 977
 978         return 0;
 979 }
 980
 981 static int ivtv_g_input(struct file *file, void *fh, unsigned int *i)
 982 {
 983         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
 984
 985         *i = itv->active_input;
 986
 987         return 0;
 988 }
 989
 990 int ivtv_s_input(struct file *file, void *fh, unsigned int inp)
 991 {
 992         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
 993
 994         if (inp < 0 || inp >= itv->nof_inputs)
 995                 return -EINVAL;
 996
 997         if (inp == itv->active_input) {
 998                 IVTV_DEBUG_INFO("Input unchanged\n");
 999                 return 0;
1000         }
1001
1002         if (atomic_read(&itv->capturing) > 0) {
1003                 return -EBUSY;
1004         }
1005
1006         IVTV_DEBUG_INFO("Changing input from %d to %d\n",
1007                         itv->active_input, inp);
1008
1009         itv->active_input = inp;
1010         /* Set the audio input to whatever is appropriate for the
1011            input type. */
1012         itv->audio_input = itv->card->video_inputs[inp].audio_index;
1013
1014         /* prevent others from messing with the streams until
1015            we're finished changing inputs. */
1016         ivtv_mute(itv);
1017         ivtv_video_set_io(itv);
1018         ivtv_audio_set_io(itv);
1019         ivtv_unmute(itv);
1020
1021         return 0;
1022 }
1023
1024 static int ivtv_g_output(struct file *file, void *fh, unsigned int *i)
1025 {
1026         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
1027
1028         if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1029                 return -EINVAL;
1030
1031         *i = itv->active_output;
1032
1033         return 0;
1034 }
1035
1036 static int ivtv_s_output(struct file *file, void *fh, unsigned int outp)
1037 {
1038         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
1039
1040         if (outp >= itv->card->nof_outputs)
1041                 return -EINVAL;
1042
1043         if (outp == itv->active_output) {
1044                 IVTV_DEBUG_INFO("Output unchanged\n");
1045                 return 0;
1046         }
1047         IVTV_DEBUG_INFO("Changing output from %d to %d\n",
1048                    itv->active_output, outp);
1049
1050         itv->active_output = outp;
1051         ivtv_call_hw(itv, IVTV_HW_SAA7127, video, s_routing,
1052                         SAA7127_INPUT_TYPE_NORMAL,
1053                         itv->card->video_outputs[outp].video_output, 0);
1054
1055         return 0;
1056 }
1057
1058 static int ivtv_g_frequency(struct file *file, void *fh, struct v4l2_frequency *vf)
1059 {
1060         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
1061
1062         if (vf->tuner != 0)
1063                 return -EINVAL;
1064
1065         ivtv_call_all(itv, tuner, g_frequency, vf);
1066         return 0;
1067 }
1068
1069 int ivtv_s_frequency(struct file *file, void *fh, struct v4l2_frequency *vf)
1070 {
1071         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
1072
1073         if (vf->tuner != 0)
1074                 return -EINVAL;
1075
1076         ivtv_mute(itv);
1077         IVTV_DEBUG_INFO("v4l2 ioctl: set frequency %d\n", vf->frequency);
1078         ivtv_call_all(itv, tuner, s_frequency, vf);
1079         ivtv_unmute(itv);
1080         return 0;
1081 }
1082
1083 static int ivtv_g_std(struct file *file, void *fh, v4l2_std_id *std)
1084 {
1085         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
1086
1087         *std = itv->std;
1088         return 0;
1089 }
1090
1091 int ivtv_s_std(struct file *file, void *fh, v4l2_std_id *std)
1092 {
1093         DEFINE_WAIT(wait);
1094         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
1095         struct yuv_playback_info *yi = &itv->yuv_info;
1096         int f;
1097
1098         if ((*std & V4L2_STD_ALL) == 0)
1099                 return -EINVAL;
1100
1101         if (*std == itv->std)
1102                 return 0;
1103
1104         if (test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ||
1105             atomic_read(&itv->capturing) > 0 ||
1106             atomic_read(&itv->decoding) > 0) {
1107                 /* Switching standard would turn off the radio or mess
1108                    with already running streams, prevent that by
1109                    returning EBUSY. */
1110                 return -EBUSY;
1111         }
1112
1113         itv->std = *std;
1114         itv->is_60hz = (*std & V4L2_STD_525_60) ? 1 : 0;
1115         itv->is_50hz = !itv->is_60hz;
1116         cx2341x_handler_set_50hz(&itv->cxhdl, itv->is_50hz);
1117         itv->cxhdl.width = 720;
1118         itv->cxhdl.height = itv->is_50hz ? 576 : 480;
1119         itv->vbi.count = itv->is_50hz ? 18 : 12;
1120         itv->vbi.start[0] = itv->is_50hz ? 6 : 10;
1121         itv->vbi.start[1] = itv->is_50hz ? 318 : 273;
1122
1123         if (itv->hw_flags & IVTV_HW_CX25840)
1124                 itv->vbi.sliced_decoder_line_size = itv->is_60hz ? 272 : 284;
1125
1126         IVTV_DEBUG_INFO("Switching standard to %llx.\n", (unsigned long long)itv->std);
1127
1128         /* Tuner */
1129         ivtv_call_all(itv, core, s_std, itv->std);
1130
1131         if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT) {
1132                 /* set display standard */
1133                 itv->std_out = *std;
1134                 itv->is_out_60hz = itv->is_60hz;
1135                 itv->is_out_50hz = itv->is_50hz;
1136                 ivtv_call_all(itv, video, s_std_output, itv->std_out);
1137
1138                 /*
1139                  * The next firmware call is time sensitive. Time it to
1140                  * avoid risk of a hard lock, by trying to ensure the call
1141                  * happens within the first 100 lines of the top field.
1142                  * Make 4 attempts to sync to the decoder before giving up.
1143                  */
1144                 for (f = 0; f < 4; f++) {
1145                         prepare_to_wait(&itv->vsync_waitq, &wait,
1146                                         TASK_UNINTERRUPTIBLE);
1147                         if ((read_reg(IVTV_REG_DEC_LINE_FIELD) >> 16) < 100)
1148                                 break;
1149                         schedule_timeout(msecs_to_jiffies(25));
1150                 }
1151                 finish_wait(&itv->vsync_waitq, &wait);
1152
1153                 if (f == 4)
1154                         IVTV_WARN("Mode change failed to sync to decoder\n");
1155
1156                 ivtv_vapi(itv, CX2341X_DEC_SET_STANDARD, 1, itv->is_out_50hz);
1157                 itv->main_rect.left = itv->main_rect.top = 0;
1158                 itv->main_rect.width = 720;
1159                 itv->main_rect.height = itv->cxhdl.height;
1160                 ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
1161                         720, itv->main_rect.height, 0, 0);
1162                 yi->main_rect = itv->main_rect;
1163                 if (!itv->osd_info) {
1164                         yi->osd_full_w = 720;
1165                         yi->osd_full_h = itv->is_out_50hz ? 576 : 480;
1166                 }
1167         }
1168         return 0;
1169 }
1170
1171 static int ivtv_s_tuner(struct file *file, void *fh, struct v4l2_tuner *vt)
1172 {
1173         struct ivtv_open_id *id = fh;
1174         struct ivtv *itv = id->itv;
1175
1176         if (vt->index != 0)
1177                 return -EINVAL;
1178
1179         ivtv_call_all(itv, tuner, s_tuner, vt);
1180
1181         return 0;
1182 }
1183
1184 static int ivtv_g_tuner(struct file *file, void *fh, struct v4l2_tuner *vt)
1185 {
1186         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
1187
1188         if (vt->index != 0)
1189                 return -EINVAL;
1190
1191         ivtv_call_all(itv, tuner, g_tuner, vt);
1192
1193         if (test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags)) {
1194                 strlcpy(vt->name, "ivtv Radio Tuner", sizeof(vt->name));
1195                 vt->type = V4L2_TUNER_RADIO;
1196         } else {
1197                 strlcpy(vt->name, "ivtv TV Tuner", sizeof(vt->name));
1198                 vt->type = V4L2_TUNER_ANALOG_TV;
1199         }
1200
1201         return 0;
1202 }
1203
1204 static int ivtv_g_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_sliced_vbi_cap *cap)
1205 {
1206         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
1207         int set = itv->is_50hz ? V4L2_SLICED_VBI_625 : V4L2_SLICED_VBI_525;
1208         int f, l;
1209
1210         if (cap->type == V4L2_BUF_TYPE_SLICED_VBI_CAPTURE) {
1211                 for (f = 0; f < 2; f++) {
1212                         for (l = 0; l < 24; l++) {
1213                                 if (valid_service_line(f, l, itv->is_50hz))
1214                                         cap->service_lines[f][l] = set;
1215                         }
1216                 }
1217                 return 0;
1218         }
1219         if (cap->type == V4L2_BUF_TYPE_SLICED_VBI_OUTPUT) {
1220                 if (!(itv->v4l2_cap & V4L2_CAP_SLICED_VBI_OUTPUT))
1221                         return -EINVAL;
1222                 if (itv->is_60hz) {
1223                         cap->service_lines[0][21] = V4L2_SLICED_CAPTION_525;
1224                         cap->service_lines[1][21] = V4L2_SLICED_CAPTION_525;
1225                 } else {
1226                         cap->service_lines[0][23] = V4L2_SLICED_WSS_625;
1227                         cap->service_lines[0][16] = V4L2_SLICED_VPS;
1228                 }
1229                 return 0;
1230         }
1231         return -EINVAL;
1232 }
1233
1234 static int ivtv_g_enc_index(struct file *file, void *fh, struct v4l2_enc_idx *idx)
1235 {
1236         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
1237         struct v4l2_enc_idx_entry *e = idx->entry;
1238         int entries;
1239         int i;
1240
1241         entries = (itv->pgm_info_write_idx + IVTV_MAX_PGM_INDEX - itv->pgm_info_read_idx) %
1242                                 IVTV_MAX_PGM_INDEX;
1243         if (entries > V4L2_ENC_IDX_ENTRIES)
1244                 entries = V4L2_ENC_IDX_ENTRIES;
1245         idx->entries = 0;
1246         for (i = 0; i < entries; i++) {
1247                 *e = itv->pgm_info[(itv->pgm_info_read_idx + i) % IVTV_MAX_PGM_INDEX];
1248                 if ((e->flags & V4L2_ENC_IDX_FRAME_MASK) <= V4L2_ENC_IDX_FRAME_B) {
1249                         idx->entries++;
1250                         e++;
1251                 }
1252         }
1253         itv->pgm_info_read_idx = (itv->pgm_info_read_idx + idx->entries) % IVTV_MAX_PGM_INDEX;
1254         return 0;
1255 }
1256
1257 static int ivtv_encoder_cmd(struct file *file, void *fh, struct v4l2_encoder_cmd *enc)
1258 {
1259         struct ivtv_open_id *id = fh;
1260         struct ivtv *itv = id->itv;
1261
1262
1263         switch (enc->cmd) {
1264         case V4L2_ENC_CMD_START:
1265                 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
1266                 enc->flags = 0;
1267                 return ivtv_start_capture(id);
1268
1269         case V4L2_ENC_CMD_STOP:
1270                 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
1271                 enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END;
1272                 ivtv_stop_capture(id, enc->flags & V4L2_ENC_CMD_STOP_AT_GOP_END);
1273                 return 0;
1274
1275         case V4L2_ENC_CMD_PAUSE:
1276                 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
1277                 enc->flags = 0;
1278
1279                 if (!atomic_read(&itv->capturing))
1280                         return -EPERM;
1281                 if (test_and_set_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags))
1282                         return 0;
1283
1284                 ivtv_mute(itv);
1285                 ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 0);
1286                 break;
1287
1288         case V4L2_ENC_CMD_RESUME:
1289                 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
1290                 enc->flags = 0;
1291
1292                 if (!atomic_read(&itv->capturing))
1293                         return -EPERM;
1294
1295                 if (!test_and_clear_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags))
1296                         return 0;
1297
1298                 ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 1);
1299                 ivtv_unmute(itv);
1300                 break;
1301         default:
1302                 IVTV_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd);
1303                 return -EINVAL;
1304         }
1305
1306         return 0;
1307 }
1308
1309 static int ivtv_try_encoder_cmd(struct file *file, void *fh, struct v4l2_encoder_cmd *enc)
1310 {
1311         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
1312
1313         switch (enc->cmd) {
1314         case V4L2_ENC_CMD_START:
1315                 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
1316                 enc->flags = 0;
1317                 return 0;
1318
1319         case V4L2_ENC_CMD_STOP:
1320                 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n");
1321                 enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END;
1322                 return 0;
1323
1324         case V4L2_ENC_CMD_PAUSE:
1325                 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n");
1326                 enc->flags = 0;
1327                 return 0;
1328
1329         case V4L2_ENC_CMD_RESUME:
1330                 IVTV_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n");
1331                 enc->flags = 0;
1332                 return 0;
1333         default:
1334                 IVTV_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd);
1335                 return -EINVAL;
1336         }
1337 }
1338
1339 static int ivtv_g_fbuf(struct file *file, void *fh, struct v4l2_framebuffer *fb)
1340 {
1341         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
1342         u32 data[CX2341X_MBOX_MAX_DATA];
1343         struct yuv_playback_info *yi = &itv->yuv_info;
1344
1345         int pixfmt;
1346         static u32 pixel_format[16] = {
1347                 V4L2_PIX_FMT_PAL8, /* Uses a 256-entry RGB colormap */
1348                 V4L2_PIX_FMT_RGB565,
1349                 V4L2_PIX_FMT_RGB555,
1350                 V4L2_PIX_FMT_RGB444,
1351                 V4L2_PIX_FMT_RGB32,
1352                 0,
1353                 0,
1354                 0,
1355                 V4L2_PIX_FMT_PAL8, /* Uses a 256-entry YUV colormap */
1356                 V4L2_PIX_FMT_YUV565,
1357                 V4L2_PIX_FMT_YUV555,
1358                 V4L2_PIX_FMT_YUV444,
1359                 V4L2_PIX_FMT_YUV32,
1360                 0,
1361                 0,
1362                 0,
1363         };
1364
1365         if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1366                 return -EINVAL;
1367         if (!itv->osd_video_pbase)
1368                 return -EINVAL;
1369
1370         fb->capability = V4L2_FBUF_CAP_EXTERNOVERLAY | V4L2_FBUF_CAP_CHROMAKEY |
1371                 V4L2_FBUF_CAP_GLOBAL_ALPHA;
1372
1373         ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0);
1374         data[0] |= (read_reg(0x2a00) >> 7) & 0x40;
1375         pixfmt = (data[0] >> 3) & 0xf;
1376
1377         fb->fmt.pixelformat = pixel_format[pixfmt];
1378         fb->fmt.width = itv->osd_rect.width;
1379         fb->fmt.height = itv->osd_rect.height;
1380         fb->fmt.field = V4L2_FIELD_INTERLACED;
1381         fb->fmt.bytesperline = fb->fmt.width;
1382         fb->fmt.colorspace = V4L2_COLORSPACE_SMPTE170M;
1383         fb->fmt.field = V4L2_FIELD_INTERLACED;
1384         fb->fmt.priv = 0;
1385         if (fb->fmt.pixelformat != V4L2_PIX_FMT_PAL8)
1386                 fb->fmt.bytesperline *= 2;
1387         if (fb->fmt.pixelformat == V4L2_PIX_FMT_RGB32 ||
1388             fb->fmt.pixelformat == V4L2_PIX_FMT_YUV32)
1389                 fb->fmt.bytesperline *= 2;
1390         fb->fmt.sizeimage = fb->fmt.bytesperline * fb->fmt.height;
1391         fb->base = (void *)itv->osd_video_pbase;
1392         fb->flags = 0;
1393
1394         if (itv->osd_chroma_key_state)
1395                 fb->flags |= V4L2_FBUF_FLAG_CHROMAKEY;
1396
1397         if (itv->osd_global_alpha_state)
1398                 fb->flags |= V4L2_FBUF_FLAG_GLOBAL_ALPHA;
1399
1400         if (yi->track_osd)
1401                 fb->flags |= V4L2_FBUF_FLAG_OVERLAY;
1402
1403         pixfmt &= 7;
1404
1405         /* no local alpha for RGB565 or unknown formats */
1406         if (pixfmt == 1 || pixfmt > 4)
1407                 return 0;
1408
1409         /* 16-bit formats have inverted local alpha */
1410         if (pixfmt == 2 || pixfmt == 3)
1411                 fb->capability |= V4L2_FBUF_CAP_LOCAL_INV_ALPHA;
1412         else
1413                 fb->capability |= V4L2_FBUF_CAP_LOCAL_ALPHA;
1414
1415         if (itv->osd_local_alpha_state) {
1416                 /* 16-bit formats have inverted local alpha */
1417                 if (pixfmt == 2 || pixfmt == 3)
1418                         fb->flags |= V4L2_FBUF_FLAG_LOCAL_INV_ALPHA;
1419                 else
1420                         fb->flags |= V4L2_FBUF_FLAG_LOCAL_ALPHA;
1421         }
1422
1423         return 0;
1424 }
1425
1426 static int ivtv_s_fbuf(struct file *file, void *fh, struct v4l2_framebuffer *fb)
1427 {
1428         struct ivtv_open_id *id = fh;
1429         struct ivtv *itv = id->itv;
1430         struct yuv_playback_info *yi = &itv->yuv_info;
1431
1432         if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1433                 return -EINVAL;
1434         if (!itv->osd_video_pbase)
1435                 return -EINVAL;
1436
1437         itv->osd_global_alpha_state = (fb->flags & V4L2_FBUF_FLAG_GLOBAL_ALPHA) != 0;
1438         itv->osd_local_alpha_state =
1439                 (fb->flags & (V4L2_FBUF_FLAG_LOCAL_ALPHA|V4L2_FBUF_FLAG_LOCAL_INV_ALPHA)) != 0;
1440         itv->osd_chroma_key_state = (fb->flags & V4L2_FBUF_FLAG_CHROMAKEY) != 0;
1441         ivtv_set_osd_alpha(itv);
1442         yi->track_osd = (fb->flags & V4L2_FBUF_FLAG_OVERLAY) != 0;
1443         return ivtv_g_fbuf(file, fh, fb);
1444 }
1445
1446 static int ivtv_overlay(struct file *file, void *fh, unsigned int on)
1447 {
1448         struct ivtv_open_id *id = fh;
1449         struct ivtv *itv = id->itv;
1450
1451         if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT_OVERLAY))
1452                 return -EINVAL;
1453
1454         ivtv_vapi(itv, CX2341X_OSD_SET_STATE, 1, on != 0);
1455
1456         return 0;
1457 }
1458
1459 static int ivtv_subscribe_event(struct v4l2_fh *fh, struct v4l2_event_subscription *sub)
1460 {
1461         switch (sub->type) {
1462         case V4L2_EVENT_VSYNC:
1463         case V4L2_EVENT_EOS:
1464                 break;
1465         default:
1466                 return -EINVAL;
1467         }
1468         return v4l2_event_subscribe(fh, sub);
1469 }
1470
1471 static int ivtv_log_status(struct file *file, void *fh)
1472 {
1473         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
1474         u32 data[CX2341X_MBOX_MAX_DATA];
1475
1476         int has_output = itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT;
1477         struct v4l2_input vidin;
1478         struct v4l2_audio audin;
1479         int i;
1480
1481         IVTV_INFO("=================  START STATUS CARD #%d  =================\n",
1482                        itv->instance);
1483         IVTV_INFO("Version: %s Card: %s\n", IVTV_VERSION, itv->card_name);
1484         if (itv->hw_flags & IVTV_HW_TVEEPROM) {
1485                 struct tveeprom tv;
1486
1487                 ivtv_read_eeprom(itv, &tv);
1488         }
1489         ivtv_call_all(itv, core, log_status);
1490         ivtv_get_input(itv, itv->active_input, &vidin);
1491         ivtv_get_audio_input(itv, itv->audio_input, &audin);
1492         IVTV_INFO("Video Input:  %s\n", vidin.name);
1493         IVTV_INFO("Audio Input:  %s%s\n", audin.name,
1494                 (itv->dualwatch_stereo_mode & ~0x300) == 0x200 ? " (Bilingual)" : "");
1495         if (has_output) {
1496                 struct v4l2_output vidout;
1497                 struct v4l2_audioout audout;
1498                 int mode = itv->output_mode;
1499                 static const char * const output_modes[5] = {
1500                         "None",
1501                         "MPEG Streaming",
1502                         "YUV Streaming",
1503                         "YUV Frames",
1504                         "Passthrough",
1505                 };
1506                 static const char * const audio_modes[5] = {
1507                         "Stereo",
1508                         "Left",
1509                         "Right",
1510                         "Mono",
1511                         "Swapped"
1512                 };
1513                 static const char * const alpha_mode[4] = {
1514                         "None",
1515                         "Global",
1516                         "Local",
1517                         "Global and Local"
1518                 };
1519                 static const char * const pixel_format[16] = {
1520                         "ARGB Indexed",
1521                         "RGB 5:6:5",
1522                         "ARGB 1:5:5:5",
1523                         "ARGB 1:4:4:4",
1524                         "ARGB 8:8:8:8",
1525                         "5",
1526                         "6",
1527                         "7",
1528                         "AYUV Indexed",
1529                         "YUV 5:6:5",
1530                         "AYUV 1:5:5:5",
1531                         "AYUV 1:4:4:4",
1532                         "AYUV 8:8:8:8",
1533                         "13",
1534                         "14",
1535                         "15",
1536                 };
1537
1538                 ivtv_get_output(itv, itv->active_output, &vidout);
1539                 ivtv_get_audio_output(itv, 0, &audout);
1540                 IVTV_INFO("Video Output: %s\n", vidout.name);
1541                 IVTV_INFO("Audio Output: %s (Stereo/Bilingual: %s/%s)\n", audout.name,
1542                         audio_modes[itv->audio_stereo_mode],
1543                         audio_modes[itv->audio_bilingual_mode]);
1544                 if (mode < 0 || mode > OUT_PASSTHROUGH)
1545                         mode = OUT_NONE;
1546                 IVTV_INFO("Output Mode:  %s\n", output_modes[mode]);
1547                 ivtv_vapi_result(itv, data, CX2341X_OSD_GET_STATE, 0);
1548                 data[0] |= (read_reg(0x2a00) >> 7) & 0x40;
1549                 IVTV_INFO("Overlay:      %s, Alpha: %s, Pixel Format: %s\n",
1550                         data[0] & 1 ? "On" : "Off",
1551                         alpha_mode[(data[0] >> 1) & 0x3],
1552                         pixel_format[(data[0] >> 3) & 0xf]);
1553         }
1554         IVTV_INFO("Tuner:  %s\n",
1555                 test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ? "Radio" : "TV");
1556         v4l2_ctrl_handler_log_status(&itv->cxhdl.hdl, itv->v4l2_dev.name);
1557         IVTV_INFO("Status flags:    0x%08lx\n", itv->i_flags);
1558         for (i = 0; i < IVTV_MAX_STREAMS; i++) {
1559                 struct ivtv_stream *s = &itv->streams[i];
1560
1561                 if (s->vdev == NULL || s->buffers == 0)
1562                         continue;
1563                 IVTV_INFO("Stream %s: status 0x%04lx, %d%% of %d KiB (%d buffers) in use\n", s->name, s->s_flags,
1564                                 (s->buffers - s->q_free.buffers) * 100 / s->buffers,
1565                                 (s->buffers * s->buf_size) / 1024, s->buffers);
1566         }
1567
1568         IVTV_INFO("Read MPG/VBI: %lld/%lld bytes\n",
1569                         (long long)itv->mpg_data_received,
1570                         (long long)itv->vbi_data_inserted);
1571         IVTV_INFO("==================  END STATUS CARD #%d  ==================\n",
1572                         itv->instance);
1573
1574         return 0;
1575 }
1576
1577 static int ivtv_decoder_ioctls(struct file *filp, unsigned int cmd, void *arg)
1578 {
1579         struct ivtv_open_id *id = fh2id(filp->private_data);
1580         struct ivtv *itv = id->itv;
1581         int nonblocking = filp->f_flags & O_NONBLOCK;
1582         struct ivtv_stream *s = &itv->streams[id->type];
1583         unsigned long iarg = (unsigned long)arg;
1584
1585         switch (cmd) {
1586         case IVTV_IOC_DMA_FRAME: {
1587                 struct ivtv_dma_frame *args = arg;
1588
1589                 IVTV_DEBUG_IOCTL("IVTV_IOC_DMA_FRAME\n");
1590                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1591                         return -EINVAL;
1592                 if (args->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
1593                         return -EINVAL;
1594                 if (itv->output_mode == OUT_UDMA_YUV && args->y_source == NULL)
1595                         return 0;
1596                 if (ivtv_start_decoding(id, id->type)) {
1597                         return -EBUSY;
1598                 }
1599                 if (ivtv_set_output_mode(itv, OUT_UDMA_YUV) != OUT_UDMA_YUV) {
1600                         ivtv_release_stream(s);
1601                         return -EBUSY;
1602                 }
1603                 /* Mark that this file handle started the UDMA_YUV mode */
1604                 id->yuv_frames = 1;
1605                 if (args->y_source == NULL)
1606                         return 0;
1607                 return ivtv_yuv_prep_frame(itv, args);
1608         }
1609
1610         case VIDEO_GET_PTS: {
1611                 u32 data[CX2341X_MBOX_MAX_DATA];
1612                 u64 *pts = arg;
1613
1614                 IVTV_DEBUG_IOCTL("VIDEO_GET_PTS\n");
1615                 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) {
1616                         *pts = s->dma_pts;
1617                         break;
1618                 }
1619                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1620                         return -EINVAL;
1621
1622                 if (test_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags)) {
1623                         *pts = (u64) ((u64)itv->last_dec_timing[2] << 32) |
1624                                         (u64)itv->last_dec_timing[1];
1625                         break;
1626                 }
1627                 *pts = 0;
1628                 if (atomic_read(&itv->decoding)) {
1629                         if (ivtv_api(itv, CX2341X_DEC_GET_TIMING_INFO, 5, data)) {
1630                                 IVTV_DEBUG_WARN("GET_TIMING: couldn't read clock\n");
1631                                 return -EIO;
1632                         }
1633                         memcpy(itv->last_dec_timing, data, sizeof(itv->last_dec_timing));
1634                         set_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags);
1635                         *pts = (u64) ((u64) data[2] << 32) | (u64) data[1];
1636                         /*timing->scr = (u64) (((u64) data[4] << 32) | (u64) (data[3]));*/
1637                 }
1638                 break;
1639         }
1640
1641         case VIDEO_GET_FRAME_COUNT: {
1642                 u32 data[CX2341X_MBOX_MAX_DATA];
1643                 u64 *frame = arg;
1644
1645                 IVTV_DEBUG_IOCTL("VIDEO_GET_FRAME_COUNT\n");
1646                 if (s->type < IVTV_DEC_STREAM_TYPE_MPG) {
1647                         *frame = 0;
1648                         break;
1649                 }
1650                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1651                         return -EINVAL;
1652
1653                 if (test_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags)) {
1654                         *frame = itv->last_dec_timing[0];
1655                         break;
1656                 }
1657                 *frame = 0;
1658                 if (atomic_read(&itv->decoding)) {
1659                         if (ivtv_api(itv, CX2341X_DEC_GET_TIMING_INFO, 5, data)) {
1660                                 IVTV_DEBUG_WARN("GET_TIMING: couldn't read clock\n");
1661                                 return -EIO;
1662                         }
1663                         memcpy(itv->last_dec_timing, data, sizeof(itv->last_dec_timing));
1664                         set_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags);
1665                         *frame = data[0];
1666                 }
1667                 break;
1668         }
1669
1670         case VIDEO_PLAY: {
1671                 struct video_command vc;
1672
1673                 IVTV_DEBUG_IOCTL("VIDEO_PLAY\n");
1674                 memset(&vc, 0, sizeof(vc));
1675                 vc.cmd = VIDEO_CMD_PLAY;
1676                 return ivtv_video_command(itv, id, &vc, 0);
1677         }
1678
1679         case VIDEO_STOP: {
1680                 struct video_command vc;
1681
1682                 IVTV_DEBUG_IOCTL("VIDEO_STOP\n");
1683                 memset(&vc, 0, sizeof(vc));
1684                 vc.cmd = VIDEO_CMD_STOP;
1685                 vc.flags = VIDEO_CMD_STOP_TO_BLACK | VIDEO_CMD_STOP_IMMEDIATELY;
1686                 return ivtv_video_command(itv, id, &vc, 0);
1687         }
1688
1689         case VIDEO_FREEZE: {
1690                 struct video_command vc;
1691
1692                 IVTV_DEBUG_IOCTL("VIDEO_FREEZE\n");
1693                 memset(&vc, 0, sizeof(vc));
1694                 vc.cmd = VIDEO_CMD_FREEZE;
1695                 return ivtv_video_command(itv, id, &vc, 0);
1696         }
1697
1698         case VIDEO_CONTINUE: {
1699                 struct video_command vc;
1700
1701                 IVTV_DEBUG_IOCTL("VIDEO_CONTINUE\n");
1702                 memset(&vc, 0, sizeof(vc));
1703                 vc.cmd = VIDEO_CMD_CONTINUE;
1704                 return ivtv_video_command(itv, id, &vc, 0);
1705         }
1706
1707         case VIDEO_COMMAND:
1708         case VIDEO_TRY_COMMAND: {
1709                 struct video_command *vc = arg;
1710                 int try = (cmd == VIDEO_TRY_COMMAND);
1711
1712                 if (try)
1713                         IVTV_DEBUG_IOCTL("VIDEO_TRY_COMMAND %d\n", vc->cmd);
1714                 else
1715                         IVTV_DEBUG_IOCTL("VIDEO_COMMAND %d\n", vc->cmd);
1716                 return ivtv_video_command(itv, id, vc, try);
1717         }
1718
1719         case VIDEO_GET_EVENT: {
1720                 struct video_event *ev = arg;
1721                 DEFINE_WAIT(wait);
1722
1723                 IVTV_DEBUG_IOCTL("VIDEO_GET_EVENT\n");
1724                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1725                         return -EINVAL;
1726                 memset(ev, 0, sizeof(*ev));
1727                 set_bit(IVTV_F_I_EV_VSYNC_ENABLED, &itv->i_flags);
1728
1729                 while (1) {
1730                         if (test_and_clear_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags))
1731                                 ev->type = VIDEO_EVENT_DECODER_STOPPED;
1732                         else if (test_and_clear_bit(IVTV_F_I_EV_VSYNC, &itv->i_flags)) {
1733                                 ev->type = VIDEO_EVENT_VSYNC;
1734                                 ev->u.vsync_field = test_bit(IVTV_F_I_EV_VSYNC_FIELD, &itv->i_flags) ?
1735                                         VIDEO_VSYNC_FIELD_ODD : VIDEO_VSYNC_FIELD_EVEN;
1736                                 if (itv->output_mode == OUT_UDMA_YUV &&
1737                                         (itv->yuv_info.lace_mode & IVTV_YUV_MODE_MASK) ==
1738                                                                 IVTV_YUV_MODE_PROGRESSIVE) {
1739                                         ev->u.vsync_field = VIDEO_VSYNC_FIELD_PROGRESSIVE;
1740                                 }
1741                         }
1742                         if (ev->type)
1743                                 return 0;
1744                         if (nonblocking)
1745                                 return -EAGAIN;
1746                         /* Wait for event. Note that serialize_lock is locked,
1747                            so to allow other processes to access the driver while
1748                            we are waiting unlock first and later lock again. */
1749                         mutex_unlock(&itv->serialize_lock);
1750                         prepare_to_wait(&itv->event_waitq, &wait, TASK_INTERRUPTIBLE);
1751                         if (!test_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags) &&
1752                             !test_bit(IVTV_F_I_EV_VSYNC, &itv->i_flags))
1753                                 schedule();
1754                         finish_wait(&itv->event_waitq, &wait);
1755                         mutex_lock(&itv->serialize_lock);
1756                         if (signal_pending(current)) {
1757                                 /* return if a signal was received */
1758                                 IVTV_DEBUG_INFO("User stopped wait for event\n");
1759                                 return -EINTR;
1760                         }
1761                 }
1762                 break;
1763         }
1764
1765         case VIDEO_SELECT_SOURCE:
1766                 IVTV_DEBUG_IOCTL("VIDEO_SELECT_SOURCE\n");
1767                 if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
1768                         return -EINVAL;
1769                 return ivtv_passthrough_mode(itv, iarg == VIDEO_SOURCE_DEMUX);
1770
1771         case AUDIO_SET_MUTE:
1772                 IVTV_DEBUG_IOCTL("AUDIO_SET_MUTE\n");
1773                 itv->speed_mute_audio = iarg;
1774                 return 0;
1775
1776         case AUDIO_CHANNEL_SELECT:
1777                 IVTV_DEBUG_IOCTL("AUDIO_CHANNEL_SELECT\n");
1778                 if (iarg > AUDIO_STEREO_SWAPPED)
1779                         return -EINVAL;
1780                 itv->audio_stereo_mode = iarg;
1781                 ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode);
1782                 return 0;
1783
1784         case AUDIO_BILINGUAL_CHANNEL_SELECT:
1785                 IVTV_DEBUG_IOCTL("AUDIO_BILINGUAL_CHANNEL_SELECT\n");
1786                 if (iarg > AUDIO_STEREO_SWAPPED)
1787                         return -EINVAL;
1788                 itv->audio_bilingual_mode = iarg;
1789                 ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode);
1790                 return 0;
1791
1792         default:
1793                 return -EINVAL;
1794         }
1795         return 0;
1796 }
1797
1798 static long ivtv_default(struct file *file, void *fh, int cmd, void *arg)
1799 {
1800         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
1801
1802         switch (cmd) {
1803         case VIDIOC_INT_RESET: {
1804                 u32 val = *(u32 *)arg;
1805
1806                 if ((val == 0 && itv->options.newi2c) || (val & 0x01))
1807                         ivtv_reset_ir_gpio(itv);
1808                 if (val & 0x02)
1809                         v4l2_subdev_call(itv->sd_video, core, reset, 0);
1810                 break;
1811         }
1812
1813         case IVTV_IOC_DMA_FRAME:
1814         case VIDEO_GET_PTS:
1815         case VIDEO_GET_FRAME_COUNT:
1816         case VIDEO_GET_EVENT:
1817         case VIDEO_PLAY:
1818         case VIDEO_STOP:
1819         case VIDEO_FREEZE:
1820         case VIDEO_CONTINUE:
1821         case VIDEO_COMMAND:
1822         case VIDEO_TRY_COMMAND:
1823         case VIDEO_SELECT_SOURCE:
1824         case AUDIO_SET_MUTE:
1825         case AUDIO_CHANNEL_SELECT:
1826         case AUDIO_BILINGUAL_CHANNEL_SELECT:
1827                 return ivtv_decoder_ioctls(file, cmd, (void *)arg);
1828
1829         default:
1830                 return -EINVAL;
1831         }
1832         return 0;
1833 }
1834
1835 static long ivtv_serialized_ioctl(struct ivtv *itv, struct file *filp,
1836                 unsigned int cmd, unsigned long arg)
1837 {
1838         struct video_device *vfd = video_devdata(filp);
1839         struct ivtv_open_id *id = fh2id(filp->private_data);
1840         long ret;
1841
1842         /* check priority */
1843         switch (cmd) {
1844         case VIDIOC_S_CTRL:
1845         case VIDIOC_S_STD:
1846         case VIDIOC_S_INPUT:
1847         case VIDIOC_S_OUTPUT:
1848         case VIDIOC_S_TUNER:
1849         case VIDIOC_S_FREQUENCY:
1850         case VIDIOC_S_FMT:
1851         case VIDIOC_S_CROP:
1852         case VIDIOC_S_AUDIO:
1853         case VIDIOC_S_AUDOUT:
1854         case VIDIOC_S_EXT_CTRLS:
1855         case VIDIOC_S_FBUF:
1856         case VIDIOC_S_PRIORITY:
1857         case VIDIOC_OVERLAY:
1858                 ret = v4l2_prio_check(&itv->prio, id->prio);
1859                 if (ret)
1860                         return ret;
1861         }
1862
1863         if (ivtv_debug & IVTV_DBGFLG_IOCTL)
1864                 vfd->debug = V4L2_DEBUG_IOCTL | V4L2_DEBUG_IOCTL_ARG;
1865         ret = video_ioctl2(filp, cmd, arg);
1866         vfd->debug = 0;
1867         return ret;
1868 }
1869
1870 long ivtv_v4l2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
1871 {
1872         struct ivtv_open_id *id = fh2id(filp->private_data);
1873         struct ivtv *itv = id->itv;
1874         long res;
1875
1876         /* DQEVENT can block, so this should not run with the serialize lock */
1877         if (cmd == VIDIOC_DQEVENT)
1878                 return ivtv_serialized_ioctl(itv, filp, cmd, arg);
1879         mutex_lock(&itv->serialize_lock);
1880         res = ivtv_serialized_ioctl(itv, filp, cmd, arg);
1881         mutex_unlock(&itv->serialize_lock);
1882         return res;
1883 }
1884
1885 static const struct v4l2_ioctl_ops ivtv_ioctl_ops = {
1886         .vidioc_querycap                    = ivtv_querycap,
1887         .vidioc_g_priority                  = ivtv_g_priority,
1888         .vidioc_s_priority                  = ivtv_s_priority,
1889         .vidioc_s_audio                     = ivtv_s_audio,
1890         .vidioc_g_audio                     = ivtv_g_audio,
1891         .vidioc_enumaudio                   = ivtv_enumaudio,
1892         .vidioc_s_audout                    = ivtv_s_audout,
1893         .vidioc_g_audout                    = ivtv_g_audout,
1894         .vidioc_enum_input                  = ivtv_enum_input,
1895         .vidioc_enum_output                 = ivtv_enum_output,
1896         .vidioc_enumaudout                  = ivtv_enumaudout,
1897         .vidioc_cropcap                     = ivtv_cropcap,
1898         .vidioc_s_crop                      = ivtv_s_crop,
1899         .vidioc_g_crop                      = ivtv_g_crop,
1900         .vidioc_g_input                     = ivtv_g_input,
1901         .vidioc_s_input                     = ivtv_s_input,
1902         .vidioc_g_output                    = ivtv_g_output,
1903         .vidioc_s_output                    = ivtv_s_output,
1904         .vidioc_g_frequency                 = ivtv_g_frequency,
1905         .vidioc_s_frequency                 = ivtv_s_frequency,
1906         .vidioc_s_tuner                     = ivtv_s_tuner,
1907         .vidioc_g_tuner                     = ivtv_g_tuner,
1908         .vidioc_g_enc_index                 = ivtv_g_enc_index,
1909         .vidioc_g_fbuf                      = ivtv_g_fbuf,
1910         .vidioc_s_fbuf                      = ivtv_s_fbuf,
1911         .vidioc_g_std                       = ivtv_g_std,
1912         .vidioc_s_std                       = ivtv_s_std,
1913         .vidioc_overlay                     = ivtv_overlay,
1914         .vidioc_log_status                  = ivtv_log_status,
1915         .vidioc_enum_fmt_vid_cap            = ivtv_enum_fmt_vid_cap,
1916         .vidioc_encoder_cmd                 = ivtv_encoder_cmd,
1917         .vidioc_try_encoder_cmd             = ivtv_try_encoder_cmd,
1918         .vidioc_enum_fmt_vid_out            = ivtv_enum_fmt_vid_out,
1919         .vidioc_g_fmt_vid_cap               = ivtv_g_fmt_vid_cap,
1920         .vidioc_g_fmt_vbi_cap               = ivtv_g_fmt_vbi_cap,
1921         .vidioc_g_fmt_sliced_vbi_cap        = ivtv_g_fmt_sliced_vbi_cap,
1922         .vidioc_g_fmt_vid_out               = ivtv_g_fmt_vid_out,
1923         .vidioc_g_fmt_vid_out_overlay       = ivtv_g_fmt_vid_out_overlay,
1924         .vidioc_g_fmt_sliced_vbi_out        = ivtv_g_fmt_sliced_vbi_out,
1925         .vidioc_s_fmt_vid_cap               = ivtv_s_fmt_vid_cap,
1926         .vidioc_s_fmt_vbi_cap               = ivtv_s_fmt_vbi_cap,
1927         .vidioc_s_fmt_sliced_vbi_cap        = ivtv_s_fmt_sliced_vbi_cap,
1928         .vidioc_s_fmt_vid_out               = ivtv_s_fmt_vid_out,
1929         .vidioc_s_fmt_vid_out_overlay       = ivtv_s_fmt_vid_out_overlay,
1930         .vidioc_s_fmt_sliced_vbi_out        = ivtv_s_fmt_sliced_vbi_out,
1931         .vidioc_try_fmt_vid_cap             = ivtv_try_fmt_vid_cap,
1932         .vidioc_try_fmt_vbi_cap             = ivtv_try_fmt_vbi_cap,
1933         .vidioc_try_fmt_sliced_vbi_cap      = ivtv_try_fmt_sliced_vbi_cap,
1934         .vidioc_try_fmt_vid_out             = ivtv_try_fmt_vid_out,
1935         .vidioc_try_fmt_vid_out_overlay     = ivtv_try_fmt_vid_out_overlay,
1936         .vidioc_try_fmt_sliced_vbi_out      = ivtv_try_fmt_sliced_vbi_out,
1937         .vidioc_g_sliced_vbi_cap            = ivtv_g_sliced_vbi_cap,
1938         .vidioc_g_chip_ident                = ivtv_g_chip_ident,
1939 #ifdef CONFIG_VIDEO_ADV_DEBUG
1940         .vidioc_g_register                  = ivtv_g_register,
1941         .vidioc_s_register                  = ivtv_s_register,
1942 #endif
1943         .vidioc_default                     = ivtv_default,
1944         .vidioc_subscribe_event             = ivtv_subscribe_event,
1945         .vidioc_unsubscribe_event           = v4l2_event_unsubscribe,
1946 };
1947
1948 void ivtv_set_funcs(struct video_device *vdev)
1949 {
1950         vdev->ioctl_ops = &ivtv_ioctl_ops;
1951 }