SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/media/video/ivtv/ivtv-streams.c

   1 /*
   2     init/start/stop/exit stream functions
   3     Copyright (C) 2003-2004  Kevin Thayer <nufan_wfk at yahoo.com>
   4     Copyright (C) 2004  Chris Kennedy <c@groovy.org>
   5     Copyright (C) 2005-2007  Hans Verkuil <hverkuil@xs4all.nl>
   6
   7     This program is free software; you can redistribute it and/or modify
   8     it under the terms of the GNU General Public License as published by
   9     the Free Software Foundation; either version 2 of the License, or
  10     (at your option) any later version.
  11
  12     This program is distributed in the hope that it will be useful,
  13     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15     GNU General Public License for more details.
  16
  17     You should have received a copy of the GNU General Public License
  18     along with this program; if not, write to the Free Software
  19     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 /* License: GPL
  23  * Author: Kevin Thayer <nufan_wfk at yahoo dot com>
  24  *
  25  * This file will hold API related functions, both internal (firmware api)
  26  * and external (v4l2, etc)
  27  *
  28  * -----
  29  * MPG600/MPG160 support by  T.Adachi <tadachi@tadachi-net.com>
  30  *                      and Takeru KOMORIYA<komoriya@paken.org>
  31  *
  32  * AVerMedia M179 GPIO info by Chris Pinkham <cpinkham@bc2va.org>
  33  *                using information provided by Jiun-Kuei Jung @ AVerMedia.
  34  */
  35
  36 #include "ivtv-driver.h"
  37 #include "ivtv-fileops.h"
  38 #include "ivtv-queue.h"
  39 #include "ivtv-mailbox.h"
  40 #include "ivtv-ioctl.h"
  41 #include "ivtv-irq.h"
  42 #include "ivtv-yuv.h"
  43 #include "ivtv-cards.h"
  44 #include "ivtv-streams.h"
  45
  46 static struct file_operations ivtv_v4l2_enc_fops = {
  47       .owner = THIS_MODULE,
  48       .read = ivtv_v4l2_read,
  49       .write = ivtv_v4l2_write,
  50       .open = ivtv_v4l2_open,
  51       .ioctl = ivtv_v4l2_ioctl,
  52       .release = ivtv_v4l2_close,
  53       .poll = ivtv_v4l2_enc_poll,
  54 };
  55
  56 static struct file_operations ivtv_v4l2_dec_fops = {
  57       .owner = THIS_MODULE,
  58       .read = ivtv_v4l2_read,
  59       .write = ivtv_v4l2_write,
  60       .open = ivtv_v4l2_open,
  61       .ioctl = ivtv_v4l2_ioctl,
  62       .release = ivtv_v4l2_close,
  63       .poll = ivtv_v4l2_dec_poll,
  64 };
  65
  66 #define IVTV_V4L2_DEC_MPG_OFFSET  16    /* offset from 0 to register decoder mpg v4l2 minors on */
  67 #define IVTV_V4L2_ENC_PCM_OFFSET  24    /* offset from 0 to register pcm v4l2 minors on */
  68 #define IVTV_V4L2_ENC_YUV_OFFSET  32    /* offset from 0 to register yuv v4l2 minors on */
  69 #define IVTV_V4L2_DEC_YUV_OFFSET  48    /* offset from 0 to register decoder yuv v4l2 minors on */
  70 #define IVTV_V4L2_DEC_VBI_OFFSET   8    /* offset from 0 to register decoder vbi input v4l2 minors on */
  71 #define IVTV_V4L2_DEC_VOUT_OFFSET 16    /* offset from 0 to register vbi output v4l2 minors on */
  72
  73 static struct {
  74         const char *name;
  75         int vfl_type;
  76         int minor_offset;
  77         int dma, pio;
  78         enum v4l2_buf_type buf_type;
  79         struct file_operations *fops;
  80 } ivtv_stream_info[] = {
  81         {       /* IVTV_ENC_STREAM_TYPE_MPG */
  82                 "encoder MPG",
  83                 VFL_TYPE_GRABBER, 0,
  84                 PCI_DMA_FROMDEVICE, 0, V4L2_BUF_TYPE_VIDEO_CAPTURE,
  85                 &ivtv_v4l2_enc_fops
  86         },
  87         {       /* IVTV_ENC_STREAM_TYPE_YUV */
  88                 "encoder YUV",
  89                 VFL_TYPE_GRABBER, IVTV_V4L2_ENC_YUV_OFFSET,
  90                 PCI_DMA_FROMDEVICE, 0, V4L2_BUF_TYPE_VIDEO_CAPTURE,
  91                 &ivtv_v4l2_enc_fops
  92         },
  93         {       /* IVTV_ENC_STREAM_TYPE_VBI */
  94                 "encoder VBI",
  95                 VFL_TYPE_VBI, 0,
  96                 PCI_DMA_FROMDEVICE, 0, V4L2_BUF_TYPE_VBI_CAPTURE,
  97                 &ivtv_v4l2_enc_fops
  98         },
  99         {       /* IVTV_ENC_STREAM_TYPE_PCM */
 100                 "encoder PCM",
 101                 VFL_TYPE_GRABBER, IVTV_V4L2_ENC_PCM_OFFSET,
 102                 PCI_DMA_FROMDEVICE, 0, V4L2_BUF_TYPE_PRIVATE,
 103                 &ivtv_v4l2_enc_fops
 104         },
 105         {       /* IVTV_ENC_STREAM_TYPE_RAD */
 106                 "encoder radio",
 107                 VFL_TYPE_RADIO, 0,
 108                 PCI_DMA_NONE, 1, V4L2_BUF_TYPE_PRIVATE,
 109                 &ivtv_v4l2_enc_fops
 110         },
 111         {       /* IVTV_DEC_STREAM_TYPE_MPG */
 112                 "decoder MPG",
 113                 VFL_TYPE_GRABBER, IVTV_V4L2_DEC_MPG_OFFSET,
 114                 PCI_DMA_TODEVICE, 0, V4L2_BUF_TYPE_VIDEO_OUTPUT,
 115                 &ivtv_v4l2_dec_fops
 116         },
 117         {       /* IVTV_DEC_STREAM_TYPE_VBI */
 118                 "decoder VBI",
 119                 VFL_TYPE_VBI, IVTV_V4L2_DEC_VBI_OFFSET,
 120                 PCI_DMA_NONE, 1, V4L2_BUF_TYPE_VBI_CAPTURE,
 121                 &ivtv_v4l2_enc_fops
 122         },
 123         {       /* IVTV_DEC_STREAM_TYPE_VOUT */
 124                 "decoder VOUT",
 125                 VFL_TYPE_VBI, IVTV_V4L2_DEC_VOUT_OFFSET,
 126                 PCI_DMA_NONE, 1, V4L2_BUF_TYPE_VBI_OUTPUT,
 127                 &ivtv_v4l2_dec_fops
 128         },
 129         {       /* IVTV_DEC_STREAM_TYPE_YUV */
 130                 "decoder YUV",
 131                 VFL_TYPE_GRABBER, IVTV_V4L2_DEC_YUV_OFFSET,
 132                 PCI_DMA_TODEVICE, 0, V4L2_BUF_TYPE_VIDEO_OUTPUT,
 133                 &ivtv_v4l2_dec_fops
 134         }
 135 };
 136
 137 static void ivtv_stream_init(struct ivtv *itv, int type)
 138 {
 139         struct ivtv_stream *s = &itv->streams[type];
 140         struct video_device *dev = s->v4l2dev;
 141
 142         /* we need to keep v4l2dev, so restore it afterwards */
 143         memset(s, 0, sizeof(*s));
 144         s->v4l2dev = dev;
 145
 146         /* initialize ivtv_stream fields */
 147         s->itv = itv;
 148         s->type = type;
 149         s->name = ivtv_stream_info[type].name;
 150
 151         if (ivtv_stream_info[type].pio)
 152                 s->dma = PCI_DMA_NONE;
 153         else
 154                 s->dma = ivtv_stream_info[type].dma;
 155         s->buf_size = itv->stream_buf_size[type];
 156         if (s->buf_size)
 157                 s->buffers = (itv->options.kilobytes[type] * 1024 + s->buf_size - 1) / s->buf_size;
 158         spin_lock_init(&s->qlock);
 159         init_waitqueue_head(&s->waitq);
 160         s->id = -1;
 161         s->sg_handle = IVTV_DMA_UNMAPPED;
 162         ivtv_queue_init(&s->q_free);
 163         ivtv_queue_init(&s->q_full);
 164         ivtv_queue_init(&s->q_dma);
 165         ivtv_queue_init(&s->q_predma);
 166         ivtv_queue_init(&s->q_io);
 167 }
 168
 169 static int ivtv_reg_dev(struct ivtv *itv, int type)
 170 {
 171         struct ivtv_stream *s = &itv->streams[type];
 172         int vfl_type = ivtv_stream_info[type].vfl_type;
 173         int minor_offset = ivtv_stream_info[type].minor_offset;
 174         int minor;
 175
 176         /* These four fields are always initialized. If v4l2dev == NULL, then
 177            this stream is not in use. In that case no other fields but these
 178            four can be used. */
 179         s->v4l2dev = NULL;
 180         s->itv = itv;
 181         s->type = type;
 182         s->name = ivtv_stream_info[type].name;
 183
 184         /* Check whether the radio is supported */
 185         if (type == IVTV_ENC_STREAM_TYPE_RAD && !(itv->v4l2_cap & V4L2_CAP_RADIO))
 186                 return 0;
 187         if (type >= IVTV_DEC_STREAM_TYPE_MPG && !(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
 188                 return 0;
 189
 190         if (minor_offset >= 0)
 191                 /* card number + user defined offset + device offset */
 192                 minor = itv->num + ivtv_first_minor + minor_offset;
 193         else
 194                 minor = -1;
 195
 196         /* User explicitly selected 0 buffers for these streams, so don't
 197            create them. */
 198         if (minor >= 0 && ivtv_stream_info[type].dma != PCI_DMA_NONE &&
 199             itv->options.kilobytes[type] == 0) {
 200                 IVTV_INFO("Disabled %s device\n", ivtv_stream_info[type].name);
 201                 return 0;
 202         }
 203
 204         ivtv_stream_init(itv, type);
 205
 206         /* allocate and initialize the v4l2 video device structure */
 207         s->v4l2dev = video_device_alloc();
 208         if (s->v4l2dev == NULL) {
 209                 IVTV_ERR("Couldn't allocate v4l2 video_device for %s\n", s->name);
 210                 return -ENOMEM;
 211         }
 212
 213         s->v4l2dev->type = VID_TYPE_CAPTURE | VID_TYPE_TUNER | VID_TYPE_TELETEXT |
 214                     VID_TYPE_CLIPPING | VID_TYPE_SCALES | VID_TYPE_MPEG_ENCODER;
 215         if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT) {
 216                 s->v4l2dev->type |= VID_TYPE_MPEG_DECODER;
 217         }
 218         snprintf(s->v4l2dev->name, sizeof(s->v4l2dev->name), "ivtv%d %s",
 219                         itv->num, s->name);
 220
 221         s->v4l2dev->minor = minor;
 222         s->v4l2dev->dev = &itv->dev->dev;
 223         s->v4l2dev->fops = ivtv_stream_info[type].fops;
 224         s->v4l2dev->release = video_device_release;
 225
 226         if (minor >= 0) {
 227                 /* Register device. First try the desired minor, then any free one. */
 228                 if (video_register_device(s->v4l2dev, vfl_type, minor) &&
 229                     video_register_device(s->v4l2dev, vfl_type, -1)) {
 230                         IVTV_ERR("Couldn't register v4l2 device for %s minor %d\n",
 231                                         s->name, minor);
 232                         video_device_release(s->v4l2dev);
 233                         s->v4l2dev = NULL;
 234                         return -ENOMEM;
 235                 }
 236         }
 237         else {
 238                 /* Don't register a 'hidden' stream (OSD) */
 239                 IVTV_INFO("Created framebuffer stream for %s\n", s->name);
 240                 return 0;
 241         }
 242
 243         switch (vfl_type) {
 244         case VFL_TYPE_GRABBER:
 245                 IVTV_INFO("Registered device video%d for %s (%d kB)\n",
 246                         s->v4l2dev->minor, s->name, itv->options.kilobytes[type]);
 247                 break;
 248         case VFL_TYPE_RADIO:
 249                 IVTV_INFO("Registered device radio%d for %s\n",
 250                         s->v4l2dev->minor - MINOR_VFL_TYPE_RADIO_MIN, s->name);
 251                 break;
 252         case VFL_TYPE_VBI:
 253                 if (itv->options.kilobytes[type])
 254                         IVTV_INFO("Registered device vbi%d for %s (%d kB)\n",
 255                                 s->v4l2dev->minor - MINOR_VFL_TYPE_VBI_MIN,
 256                                 s->name, itv->options.kilobytes[type]);
 257                 else
 258                         IVTV_INFO("Registered device vbi%d for %s\n",
 259                                 s->v4l2dev->minor - MINOR_VFL_TYPE_VBI_MIN, s->name);
 260                 break;
 261         }
 262         return 0;
 263 }
 264
 265 /* Initialize v4l2 variables and register v4l2 devices */
 266 int ivtv_streams_setup(struct ivtv *itv)
 267 {
 268         int type;
 269
 270         /* Setup V4L2 Devices */
 271         for (type = 0; type < IVTV_MAX_STREAMS; type++) {
 272                 /* Register Device */
 273                 if (ivtv_reg_dev(itv, type))
 274                         break;
 275
 276                 if (itv->streams[type].v4l2dev == NULL)
 277                         continue;
 278
 279                 /* Allocate Stream */
 280                 if (ivtv_stream_alloc(&itv->streams[type]))
 281                         break;
 282         }
 283         if (type == IVTV_MAX_STREAMS) {
 284                 return 0;
 285         }
 286
 287         /* One or more streams could not be initialized. Clean 'em all up. */
 288         ivtv_streams_cleanup(itv);
 289         return -ENOMEM;
 290 }
 291
 292 /* Unregister v4l2 devices */
 293 void ivtv_streams_cleanup(struct ivtv *itv)
 294 {
 295         int type;
 296
 297         /* Teardown all streams */
 298         for (type = 0; type < IVTV_MAX_STREAMS; type++) {
 299                 struct video_device *vdev = itv->streams[type].v4l2dev;
 300
 301                 itv->streams[type].v4l2dev = NULL;
 302                 if (vdev == NULL)
 303                         continue;
 304
 305                 ivtv_stream_free(&itv->streams[type]);
 306                 /* Free Device */
 307                 if (vdev->minor == -1) /* 'Hidden' never registered stream (OSD) */
 308                         video_device_release(vdev);
 309                 else    /* All others, just unregister. */
 310                         video_unregister_device(vdev);
 311         }
 312 }
 313
 314 static void ivtv_vbi_setup(struct ivtv *itv)
 315 {
 316         int raw = itv->vbi.sliced_in->service_set == 0;
 317         u32 data[CX2341X_MBOX_MAX_DATA];
 318         int lines;
 319         int i;
 320
 321         /* Reset VBI */
 322         ivtv_vapi(itv, CX2341X_ENC_SET_VBI_LINE, 5, 0xffff , 0, 0, 0, 0);
 323
 324         if (itv->is_60hz) {
 325                 itv->vbi.count = 12;
 326                 itv->vbi.start[0] = 10;
 327                 itv->vbi.start[1] = 273;
 328         } else {        /* PAL/SECAM */
 329                 itv->vbi.count = 18;
 330                 itv->vbi.start[0] = 6;
 331                 itv->vbi.start[1] = 318;
 332         }
 333
 334         /* setup VBI registers */
 335         itv->video_dec_func(itv, VIDIOC_S_FMT, &itv->vbi.in);
 336
 337         /* determine number of lines and total number of VBI bytes.
 338            A raw line takes 1443 bytes: 2 * 720 + 4 byte frame header - 1
 339            The '- 1' byte is probably an unused U or V byte. Or something...
 340            A sliced line takes 51 bytes: 4 byte frame header, 4 byte internal
 341            header, 42 data bytes + checksum (to be confirmed) */
 342         if (raw) {
 343                 lines = itv->vbi.count * 2;
 344         } else {
 345                 lines = itv->is_60hz ? 24 : 38;
 346                 if (itv->is_60hz && (itv->hw_flags & IVTV_HW_CX25840))
 347                         lines += 2;
 348         }
 349
 350         itv->vbi.enc_size = lines * (raw ? itv->vbi.raw_size : itv->vbi.sliced_size);
 351
 352         /* Note: sliced vs raw flag doesn't seem to have any effect
 353            TODO: check mode (0x02) value with older ivtv versions. */
 354         data[0] = raw | 0x02 | (0xbd << 8);
 355
 356         /* Every X number of frames a VBI interrupt arrives (frames as in 25 or 30 fps) */
 357         data[1] = 1;
 358         /* The VBI frames are stored in a ringbuffer with this size (with a VBI frame as unit) */
 359         data[2] = raw ? 4 : 8;
 360         /* The start/stop codes determine which VBI lines end up in the raw VBI data area.
 361            The codes are from table 24 in the saa7115 datasheet. Each raw/sliced/video line
 362            is framed with codes FF0000XX where XX is the SAV/EAV (Start/End of Active Video)
 363            code. These values for raw VBI are obtained from a driver disassembly. The sliced
 364            start/stop codes was deduced from this, but they do not appear in the driver.
 365            Other code pairs that I found are: 0x250E6249/0x13545454 and 0x25256262/0x38137F54.
 366            However, I have no idea what these values are for. */
 367         if (itv->hw_flags & IVTV_HW_CX25840) {
 368                 /* Setup VBI for the cx25840 digitizer */
 369                 if (raw) {
 370                         data[3] = 0x20602060;
 371                         data[4] = 0x30703070;
 372                 } else {
 373                         data[3] = 0xB0F0B0F0;
 374                         data[4] = 0xA0E0A0E0;
 375                 }
 376                 /* Lines per frame */
 377                 data[5] = lines;
 378                 /* bytes per line */
 379                 data[6] = (raw ? itv->vbi.raw_size : itv->vbi.sliced_size);
 380         } else {
 381                 /* Setup VBI for the saa7115 digitizer */
 382                 if (raw) {
 383                         data[3] = 0x25256262;
 384                         data[4] = 0x387F7F7F;
 385                 } else {
 386                         data[3] = 0xABABECEC;
 387                         data[4] = 0xB6F1F1F1;
 388                 }
 389                 /* Lines per frame */
 390                 data[5] = lines;
 391                 /* bytes per line */
 392                 data[6] = itv->vbi.enc_size / lines;
 393         }
 394
 395         IVTV_DEBUG_INFO(
 396                 "Setup VBI API header 0x%08x pkts %d buffs %d ln %d sz %d\n",
 397                         data[0], data[1], data[2], data[5], data[6]);
 398
 399         ivtv_api(itv, CX2341X_ENC_SET_VBI_CONFIG, 7, data);
 400
 401         /* returns the VBI encoder memory area. */
 402         itv->vbi.enc_start = data[2];
 403         itv->vbi.fpi = data[0];
 404         if (!itv->vbi.fpi)
 405                 itv->vbi.fpi = 1;
 406
 407         IVTV_DEBUG_INFO("Setup VBI start 0x%08x frames %d fpi %d\n",
 408                 itv->vbi.enc_start, data[1], itv->vbi.fpi);
 409
 410         /* select VBI lines.
 411            Note that the sliced argument seems to have no effect. */
 412         for (i = 2; i <= 24; i++) {
 413                 int valid;
 414
 415                 if (itv->is_60hz) {
 416                         valid = i >= 10 && i < 22;
 417                 } else {
 418                         valid = i >= 6 && i < 24;
 419                 }
 420                 ivtv_vapi(itv, CX2341X_ENC_SET_VBI_LINE, 5, i - 1,
 421                                 valid, 0 , 0, 0);
 422                 ivtv_vapi(itv, CX2341X_ENC_SET_VBI_LINE, 5, (i - 1) | 0x80000000,
 423                                 valid, 0, 0, 0);
 424         }
 425
 426         /* Remaining VBI questions:
 427            - Is it possible to select particular VBI lines only for inclusion in the MPEG
 428            stream? Currently you can only get the first X lines.
 429            - Is mixed raw and sliced VBI possible?
 430            - What's the meaning of the raw/sliced flag?
 431            - What's the meaning of params 2, 3 & 4 of the Select VBI command? */
 432 }
 433
 434 int ivtv_start_v4l2_encode_stream(struct ivtv_stream *s)
 435 {
 436         u32 data[CX2341X_MBOX_MAX_DATA];
 437         struct ivtv *itv = s->itv;
 438         int captype = 0, subtype = 0;
 439         int enable_passthrough = 0;
 440
 441         if (s->v4l2dev == NULL)
 442                 return -EINVAL;
 443
 444         IVTV_DEBUG_INFO("Start encoder stream %s\n", s->name);
 445
 446         switch (s->type) {
 447         case IVTV_ENC_STREAM_TYPE_MPG:
 448                 captype = 0;
 449                 subtype = 3;
 450
 451                 /* Stop Passthrough */
 452                 if (itv->output_mode == OUT_PASSTHROUGH) {
 453                         ivtv_passthrough_mode(itv, 0);
 454                         enable_passthrough = 1;
 455                 }
 456                 itv->mpg_data_received = itv->vbi_data_inserted = 0;
 457                 itv->dualwatch_jiffies = jiffies;
 458                 itv->dualwatch_stereo_mode = itv->params.audio_properties & 0x0300;
 459                 itv->search_pack_header = 0;
 460                 break;
 461
 462         case IVTV_ENC_STREAM_TYPE_YUV:
 463                 if (itv->output_mode == OUT_PASSTHROUGH) {
 464                         captype = 2;
 465                         subtype = 11;   /* video+audio+decoder */
 466                         break;
 467                 }
 468                 captype = 1;
 469                 subtype = 1;
 470                 break;
 471         case IVTV_ENC_STREAM_TYPE_PCM:
 472                 captype = 1;
 473                 subtype = 2;
 474                 break;
 475         case IVTV_ENC_STREAM_TYPE_VBI:
 476                 captype = 1;
 477                 subtype = 4;
 478
 479                 itv->vbi.frame = 0;
 480                 itv->vbi.inserted_frame = 0;
 481                 memset(itv->vbi.sliced_mpeg_size,
 482                         0, sizeof(itv->vbi.sliced_mpeg_size));
 483                 break;
 484         default:
 485                 return -EINVAL;
 486         }
 487         s->subtype = subtype;
 488         s->buffers_stolen = 0;
 489
 490         /* mute/unmute video */
 491         ivtv_vapi(itv, CX2341X_ENC_MUTE_VIDEO, 1, test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ? 1 : 0);
 492
 493         /* Clear Streamoff flags in case left from last capture */
 494         clear_bit(IVTV_F_S_STREAMOFF, &s->s_flags);
 495
 496         if (atomic_read(&itv->capturing) == 0) {
 497                 int digitizer;
 498
 499                 /* Always use frame based mode. Experiments have demonstrated that byte
 500                    stream based mode results in dropped frames and corruption. Not often,
 501                    but occasionally. Many thanks go to Leonard Orb who spent a lot of
 502                    effort and time trying to trace the cause of the drop outs. */
 503                 /* 1 frame per DMA */
 504                 /*ivtv_vapi(itv, CX2341X_ENC_SET_DMA_BLOCK_SIZE, 2, 128, 0); */
 505                 ivtv_vapi(itv, CX2341X_ENC_SET_DMA_BLOCK_SIZE, 2, 1, 1);
 506
 507                 /* Stuff from Windows, we don't know what it is */
 508                 ivtv_vapi(itv, CX2341X_ENC_SET_VERT_CROP_LINE, 1, 0);
 509                 /* According to the docs, this should be correct. However, this is
 510                    untested. I don't dare enable this without having tested it.
 511                    Only very few old cards actually have this hardware combination.
 512                 ivtv_vapi(itv, CX2341X_ENC_SET_VERT_CROP_LINE, 1,
 513                         ((itv->hw_flags & IVTV_HW_SAA7114) && itv->is_60hz) ? 10001 : 0);
 514                 */
 515                 ivtv_vapi(itv, CX2341X_ENC_MISC, 2, 3, !itv->has_cx23415);
 516                 ivtv_vapi(itv, CX2341X_ENC_MISC, 2, 8, 0);
 517                 ivtv_vapi(itv, CX2341X_ENC_MISC, 2, 4, 1);
 518                 ivtv_vapi(itv, CX2341X_ENC_MISC, 1, 12);
 519
 520                 /* assign placeholder */
 521                 ivtv_vapi(itv, CX2341X_ENC_SET_PLACEHOLDER, 12,
 522                         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
 523
 524                 if (itv->card->hw_all & (IVTV_HW_SAA7115 | IVTV_HW_SAA717X))
 525                     digitizer = 0xF1;
 526                 else if (itv->card->hw_all & IVTV_HW_SAA7114)
 527                     digitizer = 0xEF;
 528                 else /* cx25840 */
 529                     digitizer = 0x140;
 530
 531                 ivtv_vapi(itv, CX2341X_ENC_SET_NUM_VSYNC_LINES, 2, digitizer, digitizer);
 532
 533                 /* Setup VBI */
 534                 if (itv->v4l2_cap & V4L2_CAP_VBI_CAPTURE) {
 535                         ivtv_vbi_setup(itv);
 536                 }
 537
 538                 /* assign program index info. Mask 7: select I/P/B, Num_req: 400 max */
 539                 ivtv_vapi_result(itv, data, CX2341X_ENC_SET_PGM_INDEX_INFO, 2, 7, 400);
 540                 itv->pgm_info_offset = data[0];
 541                 itv->pgm_info_num = data[1];
 542                 itv->pgm_info_write_idx = 0;
 543                 itv->pgm_info_read_idx = 0;
 544
 545                 IVTV_DEBUG_INFO("PGM Index at 0x%08x with %d elements\n",
 546                                 itv->pgm_info_offset, itv->pgm_info_num);
 547
 548                 /* Setup API for Stream */
 549                 cx2341x_update(itv, ivtv_api_func, NULL, &itv->params);
 550         }
 551
 552         /* Vsync Setup */
 553         if (itv->has_cx23415 && !test_and_set_bit(IVTV_F_I_DIG_RST, &itv->i_flags)) {
 554                 /* event notification (on) */
 555                 ivtv_vapi(itv, CX2341X_ENC_SET_EVENT_NOTIFICATION, 4, 0, 1, IVTV_IRQ_ENC_VIM_RST, -1);
 556                 ivtv_clear_irq_mask(itv, IVTV_IRQ_ENC_VIM_RST);
 557         }
 558
 559         if (atomic_read(&itv->capturing) == 0) {
 560                 /* Clear all Pending Interrupts */
 561                 ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE);
 562
 563                 clear_bit(IVTV_F_I_EOS, &itv->i_flags);
 564
 565                 /* Initialize Digitizer for Capture */
 566                 itv->video_dec_func(itv, VIDIOC_STREAMOFF, 0);
 567                 ivtv_msleep_timeout(300, 1);
 568                 ivtv_vapi(itv, CX2341X_ENC_INITIALIZE_INPUT, 0);
 569                 itv->video_dec_func(itv, VIDIOC_STREAMON, 0);
 570         }
 571
 572         /* begin_capture */
 573         if (ivtv_vapi(itv, CX2341X_ENC_START_CAPTURE, 2, captype, subtype))
 574         {
 575                 IVTV_DEBUG_WARN( "Error starting capture!\n");
 576                 return -EINVAL;
 577         }
 578
 579         /* Start Passthrough */
 580         if (enable_passthrough) {
 581                 ivtv_passthrough_mode(itv, 1);
 582         }
 583
 584         if (s->type == IVTV_ENC_STREAM_TYPE_VBI)
 585                 ivtv_clear_irq_mask(itv, IVTV_IRQ_ENC_VBI_CAP);
 586         else
 587                 ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE);
 588
 589         /* you're live! sit back and await interrupts :) */
 590         atomic_inc(&itv->capturing);
 591         return 0;
 592 }
 593
 594 static int ivtv_setup_v4l2_decode_stream(struct ivtv_stream *s)
 595 {
 596         u32 data[CX2341X_MBOX_MAX_DATA];
 597         struct ivtv *itv = s->itv;
 598         int datatype;
 599
 600         if (s->v4l2dev == NULL)
 601                 return -EINVAL;
 602
 603         IVTV_DEBUG_INFO("Setting some initial decoder settings\n");
 604
 605         /* set audio mode to left/stereo  for dual/stereo mode. */
 606         ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode);
 607
 608         /* set number of internal decoder buffers */
 609         ivtv_vapi(itv, CX2341X_DEC_SET_DISPLAY_BUFFERS, 1, 0);
 610
 611         /* prebuffering */
 612         ivtv_vapi(itv, CX2341X_DEC_SET_PREBUFFERING, 1, 1);
 613
 614         /* extract from user packets */
 615         ivtv_vapi_result(itv, data, CX2341X_DEC_EXTRACT_VBI, 1, 1);
 616         itv->vbi.dec_start = data[0];
 617
 618         IVTV_DEBUG_INFO("Decoder VBI RE-Insert start 0x%08x size 0x%08x\n",
 619                 itv->vbi.dec_start, data[1]);
 620
 621         /* set decoder source settings */
 622         /* Data type: 0 = mpeg from host,
 623            1 = yuv from encoder,
 624            2 = yuv_from_host */
 625         switch (s->type) {
 626         case IVTV_DEC_STREAM_TYPE_YUV:
 627                 datatype = itv->output_mode == OUT_PASSTHROUGH ? 1 : 2;
 628                 IVTV_DEBUG_INFO("Setup DEC YUV Stream data[0] = %d\n", datatype);
 629                 break;
 630         case IVTV_DEC_STREAM_TYPE_MPG:
 631         default:
 632                 datatype = 0;
 633                 break;
 634         }
 635         if (ivtv_vapi(itv, CX2341X_DEC_SET_DECODER_SOURCE, 4, datatype,
 636                         itv->params.width, itv->params.height, itv->params.audio_properties)) {
 637                 IVTV_DEBUG_WARN("Couldn't initialize decoder source\n");
 638         }
 639         return 0;
 640 }
 641
 642 int ivtv_start_v4l2_decode_stream(struct ivtv_stream *s, int gop_offset)
 643 {
 644         struct ivtv *itv = s->itv;
 645
 646         if (s->v4l2dev == NULL)
 647                 return -EINVAL;
 648
 649         if (test_and_set_bit(IVTV_F_S_STREAMING, &s->s_flags))
 650                 return 0;       /* already started */
 651
 652         IVTV_DEBUG_INFO("Starting decode stream %s (gop_offset %d)\n", s->name, gop_offset);
 653
 654         /* Clear Streamoff */
 655         if (s->type == IVTV_DEC_STREAM_TYPE_YUV) {
 656                 /* Initialize Decoder */
 657                 /* Reprogram Decoder YUV Buffers for YUV */
 658                 write_reg(yuv_offset[0] >> 4, 0x82c);
 659                 write_reg((yuv_offset[0] + IVTV_YUV_BUFFER_UV_OFFSET) >> 4, 0x830);
 660                 write_reg(yuv_offset[0] >> 4, 0x834);
 661                 write_reg((yuv_offset[0] + IVTV_YUV_BUFFER_UV_OFFSET) >> 4, 0x838);
 662
 663                 write_reg_sync(0x00000000 | (0x0c << 16) | (0x0b << 8), 0x2d24);
 664
 665                 write_reg_sync(0x00108080, 0x2898);
 666                 /* Enable YUV decoder output */
 667                 write_reg_sync(0x01, IVTV_REG_VDM);
 668         }
 669
 670         ivtv_setup_v4l2_decode_stream(s);
 671
 672         /* set dma size to 65536 bytes */
 673         ivtv_vapi(itv, CX2341X_DEC_SET_DMA_BLOCK_SIZE, 1, 65536);
 674
 675         clear_bit(IVTV_F_S_STREAMOFF, &s->s_flags);
 676
 677         /* Zero out decoder counters */
 678         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[0]);
 679         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[1]);
 680         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[2]);
 681         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[3]);
 682         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[0]);
 683         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[1]);
 684         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[2]);
 685         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[3]);
 686
 687         /* turn on notification of dual/stereo mode change */
 688         ivtv_vapi(itv, CX2341X_DEC_SET_EVENT_NOTIFICATION, 4, 0, 1, IVTV_IRQ_DEC_AUD_MODE_CHG, -1);
 689
 690         /* start playback */
 691         ivtv_vapi(itv, CX2341X_DEC_START_PLAYBACK, 2, gop_offset, 0);
 692
 693         /* Clear the following Interrupt mask bits for decoding */
 694         ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_DECODE);
 695         IVTV_DEBUG_IRQ("IRQ Mask is now: 0x%08x\n", itv->irqmask);
 696
 697         /* you're live! sit back and await interrupts :) */
 698         atomic_inc(&itv->decoding);
 699         return 0;
 700 }
 701
 702 void ivtv_stop_all_captures(struct ivtv *itv)
 703 {
 704         int i;
 705
 706         for (i = IVTV_MAX_STREAMS - 1; i >= 0; i--) {
 707                 struct ivtv_stream *s = &itv->streams[i];
 708
 709                 if (s->v4l2dev == NULL)
 710                         continue;
 711                 if (test_bit(IVTV_F_S_STREAMING, &s->s_flags)) {
 712                         ivtv_stop_v4l2_encode_stream(s, 0);
 713                 }
 714         }
 715 }
 716
 717 int ivtv_stop_v4l2_encode_stream(struct ivtv_stream *s, int gop_end)
 718 {
 719         struct ivtv *itv = s->itv;
 720         DECLARE_WAITQUEUE(wait, current);
 721         int cap_type;
 722         unsigned long then;
 723         int stopmode;
 724
 725         if (s->v4l2dev == NULL)
 726                 return -EINVAL;
 727
 728         /* This function assumes that you are allowed to stop the capture
 729            and that we are actually capturing */
 730
 731         IVTV_DEBUG_INFO("Stop Capture\n");
 732
 733         if (s->type == IVTV_DEC_STREAM_TYPE_VOUT)
 734                 return 0;
 735         if (atomic_read(&itv->capturing) == 0)
 736                 return 0;
 737
 738         switch (s->type) {
 739         case IVTV_ENC_STREAM_TYPE_YUV:
 740                 cap_type = 1;
 741                 break;
 742         case IVTV_ENC_STREAM_TYPE_PCM:
 743                 cap_type = 1;
 744                 break;
 745         case IVTV_ENC_STREAM_TYPE_VBI:
 746                 cap_type = 1;
 747                 break;
 748         case IVTV_ENC_STREAM_TYPE_MPG:
 749         default:
 750                 cap_type = 0;
 751                 break;
 752         }
 753
 754         /* Stop Capture Mode */
 755         if (s->type == IVTV_ENC_STREAM_TYPE_MPG && gop_end) {
 756                 stopmode = 0;
 757         } else {
 758                 stopmode = 1;
 759         }
 760
 761         /* end_capture */
 762         /* when: 0 =  end of GOP  1 = NOW!, type: 0 = mpeg, subtype: 3 = video+audio */
 763         ivtv_vapi(itv, CX2341X_ENC_STOP_CAPTURE, 3, stopmode, cap_type, s->subtype);
 764
 765         then = jiffies;
 766
 767         if (!test_bit(IVTV_F_S_PASSTHROUGH, &s->s_flags)) {
 768                 if (s->type == IVTV_ENC_STREAM_TYPE_MPG && gop_end) {
 769                         /* only run these if we're shutting down the last cap */
 770                         unsigned long duration;
 771
 772                         then = jiffies;
 773                         add_wait_queue(&itv->eos_waitq, &wait);
 774
 775                         set_current_state(TASK_INTERRUPTIBLE);
 776
 777                         /* wait 2s for EOS interrupt */
 778                         while (!test_bit(IVTV_F_I_EOS, &itv->i_flags) &&
 779                                 jiffies < then + msecs_to_jiffies (2000)) {
 780                                 schedule_timeout(msecs_to_jiffies(10));
 781                         }
 782
 783                         /* To convert jiffies to ms, we must multiply by 1000
 784                          * and divide by HZ.  To avoid runtime division, we
 785                          * convert this to multiplication by 1000/HZ.
 786                          * Since integer division truncates, we get the best
 787                          * accuracy if we do a rounding calculation of the constant.
 788                          * Think of the case where HZ is 1024.
 789                          */
 790                         duration = ((1000 + HZ / 2) / HZ) * (jiffies - then);
 791
 792                         if (!test_bit(IVTV_F_I_EOS, &itv->i_flags)) {
 793                                 IVTV_DEBUG_WARN("%s: EOS interrupt not received! stopping anyway.\n", s->name);
 794                                 IVTV_DEBUG_WARN("%s: waited %lu ms.\n", s->name, duration);
 795                         } else {
 796                                 IVTV_DEBUG_INFO("%s: EOS took %lu ms to occur.\n", s->name, duration);
 797                         }
 798                         set_current_state(TASK_RUNNING);
 799                         remove_wait_queue(&itv->eos_waitq, &wait);
 800                 }
 801
 802                 then = jiffies;
 803
 804                 /* Handle any pending interrupts */
 805                 ivtv_msleep_timeout(100, 1);
 806         }
 807
 808         atomic_dec(&itv->capturing);
 809
 810         /* Clear capture and no-read bits */
 811         clear_bit(IVTV_F_S_STREAMING, &s->s_flags);
 812
 813         if (s->type == IVTV_ENC_STREAM_TYPE_VBI)
 814                 ivtv_set_irq_mask(itv, IVTV_IRQ_ENC_VBI_CAP);
 815
 816         if (atomic_read(&itv->capturing) > 0) {
 817                 return 0;
 818         }
 819
 820         /* Set the following Interrupt mask bits for capture */
 821         ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE);
 822         del_timer(&itv->dma_timer);
 823
 824         /* event notification (off) */
 825         if (test_and_clear_bit(IVTV_F_I_DIG_RST, &itv->i_flags)) {
 826                 /* type: 0 = refresh */
 827                 /* on/off: 0 = off, intr: 0x10000000, mbox_id: -1: none */
 828                 ivtv_vapi(itv, CX2341X_ENC_SET_EVENT_NOTIFICATION, 4, 0, 0, IVTV_IRQ_ENC_VIM_RST, -1);
 829                 ivtv_set_irq_mask(itv, IVTV_IRQ_ENC_VIM_RST);
 830         }
 831
 832         wake_up(&s->waitq);
 833
 834         return 0;
 835 }
 836
 837 int ivtv_stop_v4l2_decode_stream(struct ivtv_stream *s, int flags, u64 pts)
 838 {
 839         struct ivtv *itv = s->itv;
 840
 841         if (s->v4l2dev == NULL)
 842                 return -EINVAL;
 843
 844         if (s->type != IVTV_DEC_STREAM_TYPE_YUV && s->type != IVTV_DEC_STREAM_TYPE_MPG)
 845                 return -EINVAL;
 846
 847         if (!test_bit(IVTV_F_S_STREAMING, &s->s_flags))
 848                 return 0;
 849
 850         IVTV_DEBUG_INFO("Stop Decode at %llu, flags: %x\n", (unsigned long long)pts, flags);
 851
 852         /* Stop Decoder */
 853         if (!(flags & VIDEO_CMD_STOP_IMMEDIATELY) || pts) {
 854                 u32 tmp = 0;
 855
 856                 /* Wait until the decoder is no longer running */
 857                 if (pts) {
 858                         ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3,
 859                                 0, (u32)(pts & 0xffffffff), (u32)(pts >> 32));
 860                 }
 861                 while (1) {
 862                         u32 data[CX2341X_MBOX_MAX_DATA];
 863                         ivtv_vapi_result(itv, data, CX2341X_DEC_GET_XFER_INFO, 0);
 864                         if (s->q_full.buffers + s->q_dma.buffers == 0) {
 865                                 if (tmp == data[3])
 866                                         break;
 867                                 tmp = data[3];
 868                         }
 869                         if (ivtv_msleep_timeout(100, 1))
 870                                 break;
 871                 }
 872         }
 873         ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3, flags & VIDEO_CMD_STOP_TO_BLACK, 0, 0);
 874
 875         /* turn off notification of dual/stereo mode change */
 876         ivtv_vapi(itv, CX2341X_DEC_SET_EVENT_NOTIFICATION, 4, 0, 0, IVTV_IRQ_DEC_AUD_MODE_CHG, -1);
 877
 878         ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_DECODE);
 879         del_timer(&itv->dma_timer);
 880
 881         clear_bit(IVTV_F_S_NEEDS_DATA, &s->s_flags);
 882         clear_bit(IVTV_F_S_STREAMING, &s->s_flags);
 883         ivtv_flush_queues(s);
 884
 885         /* decrement decoding */
 886         atomic_dec(&itv->decoding);
 887
 888         set_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags);
 889         wake_up(&itv->event_waitq);
 890
 891         /* wake up wait queues */
 892         wake_up(&s->waitq);
 893
 894         return 0;
 895 }
 896
 897 int ivtv_passthrough_mode(struct ivtv *itv, int enable)
 898 {
 899         struct ivtv_stream *yuv_stream = &itv->streams[IVTV_ENC_STREAM_TYPE_YUV];
 900         struct ivtv_stream *dec_stream = &itv->streams[IVTV_DEC_STREAM_TYPE_YUV];
 901
 902         if (yuv_stream->v4l2dev == NULL || dec_stream->v4l2dev == NULL)
 903                 return -EINVAL;
 904
 905         IVTV_DEBUG_INFO("ivtv ioctl: Select passthrough mode\n");
 906
 907         /* Prevent others from starting/stopping streams while we
 908            initiate/terminate passthrough mode */
 909         if (enable) {
 910                 if (itv->output_mode == OUT_PASSTHROUGH) {
 911                         return 0;
 912                 }
 913                 if (ivtv_set_output_mode(itv, OUT_PASSTHROUGH) != OUT_PASSTHROUGH)
 914                         return -EBUSY;
 915
 916                 /* Fully initialize stream, and then unflag init */
 917                 set_bit(IVTV_F_S_PASSTHROUGH, &dec_stream->s_flags);
 918                 set_bit(IVTV_F_S_STREAMING, &dec_stream->s_flags);
 919
 920                 /* Setup YUV Decoder */
 921                 ivtv_setup_v4l2_decode_stream(dec_stream);
 922
 923                 /* Start Decoder */
 924                 ivtv_vapi(itv, CX2341X_DEC_START_PLAYBACK, 2, 0, 1);
 925                 atomic_inc(&itv->decoding);
 926
 927                 /* Setup capture if not already done */
 928                 if (atomic_read(&itv->capturing) == 0) {
 929                         cx2341x_update(itv, ivtv_api_func, NULL, &itv->params);
 930                 }
 931
 932                 /* Start Passthrough Mode */
 933                 ivtv_vapi(itv, CX2341X_ENC_START_CAPTURE, 2, 2, 11);
 934                 atomic_inc(&itv->capturing);
 935                 return 0;
 936         }
 937
 938         if (itv->output_mode != OUT_PASSTHROUGH)
 939                 return 0;
 940
 941         /* Stop Passthrough Mode */
 942         ivtv_vapi(itv, CX2341X_ENC_STOP_CAPTURE, 3, 1, 2, 11);
 943         ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3, 1, 0, 0);
 944
 945         atomic_dec(&itv->capturing);
 946         atomic_dec(&itv->decoding);
 947         clear_bit(IVTV_F_S_PASSTHROUGH, &dec_stream->s_flags);
 948         clear_bit(IVTV_F_S_STREAMING, &dec_stream->s_flags);
 949         itv->output_mode = OUT_NONE;
 950
 951         return 0;
 952 }