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