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         /* disable VBI signals, if the MPEG stream contains VBI data,
 607            then that data will be processed automatically for you. */
 608         ivtv_disable_vbi(itv);
 609
 610         /* set audio mode to left/stereo  for dual/stereo mode. */
 611         ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode);
 612
 613         /* set number of internal decoder buffers */
 614         ivtv_vapi(itv, CX2341X_DEC_SET_DISPLAY_BUFFERS, 1, 0);
 615
 616         /* prebuffering */
 617         ivtv_vapi(itv, CX2341X_DEC_SET_PREBUFFERING, 1, 1);
 618
 619         /* extract from user packets */
 620         ivtv_vapi_result(itv, data, CX2341X_DEC_EXTRACT_VBI, 1, 1);
 621         itv->vbi.dec_start = data[0];
 622
 623         IVTV_DEBUG_INFO("Decoder VBI RE-Insert start 0x%08x size 0x%08x\n",
 624                 itv->vbi.dec_start, data[1]);
 625
 626         /* set decoder source settings */
 627         /* Data type: 0 = mpeg from host,
 628            1 = yuv from encoder,
 629            2 = yuv_from_host */
 630         switch (s->type) {
 631         case IVTV_DEC_STREAM_TYPE_YUV:
 632                 datatype = itv->output_mode == OUT_PASSTHROUGH ? 1 : 2;
 633                 IVTV_DEBUG_INFO("Setup DEC YUV Stream data[0] = %d\n", datatype);
 634                 break;
 635         case IVTV_DEC_STREAM_TYPE_MPG:
 636         default:
 637                 datatype = 0;
 638                 break;
 639         }
 640         if (ivtv_vapi(itv, CX2341X_DEC_SET_DECODER_SOURCE, 4, datatype,
 641                         itv->params.width, itv->params.height, itv->params.audio_properties)) {
 642                 IVTV_DEBUG_WARN("COULDN'T INITIALIZE DECODER SOURCE\n");
 643         }
 644         return 0;
 645 }
 646
 647 int ivtv_start_v4l2_decode_stream(struct ivtv_stream *s, int gop_offset)
 648 {
 649         struct ivtv *itv = s->itv;
 650
 651         if (s->v4l2dev == NULL)
 652                 return -EINVAL;
 653
 654         if (test_and_set_bit(IVTV_F_S_STREAMING, &s->s_flags))
 655                 return 0;       /* already started */
 656
 657         IVTV_DEBUG_INFO("Starting decode stream %s (gop_offset %d)\n", s->name, gop_offset);
 658
 659         /* Clear Streamoff */
 660         if (s->type == IVTV_DEC_STREAM_TYPE_YUV) {
 661                 /* Initialize Decoder */
 662                 /* Reprogram Decoder YUV Buffers for YUV */
 663                 write_reg(yuv_offset[0] >> 4, 0x82c);
 664                 write_reg((yuv_offset[0] + IVTV_YUV_BUFFER_UV_OFFSET) >> 4, 0x830);
 665                 write_reg(yuv_offset[0] >> 4, 0x834);
 666                 write_reg((yuv_offset[0] + IVTV_YUV_BUFFER_UV_OFFSET) >> 4, 0x838);
 667
 668                 write_reg_sync(0x00000000 | (0x0c << 16) | (0x0b << 8), 0x2d24);
 669
 670                 write_reg_sync(0x00108080, 0x2898);
 671                 /* Enable YUV decoder output */
 672                 write_reg_sync(0x01, IVTV_REG_VDM);
 673         }
 674
 675         ivtv_setup_v4l2_decode_stream(s);
 676
 677         /* set dma size to 65536 bytes */
 678         ivtv_vapi(itv, CX2341X_DEC_SET_DMA_BLOCK_SIZE, 1, 65536);
 679
 680         clear_bit(IVTV_F_S_STREAMOFF, &s->s_flags);
 681
 682         /* Zero out decoder counters */
 683         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_FIELD_DISPLAYED].data[0]);
 684         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_FIELD_DISPLAYED].data[1]);
 685         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_FIELD_DISPLAYED].data[2]);
 686         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_FIELD_DISPLAYED].data[3]);
 687         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[0]);
 688         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[1]);
 689         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[2]);
 690         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[3]);
 691
 692         /* turn on notification of dual/stereo mode change */
 693         ivtv_vapi(itv, CX2341X_DEC_SET_EVENT_NOTIFICATION, 4, 0, 1, IVTV_IRQ_DEC_AUD_MODE_CHG, -1);
 694
 695         /* start playback */
 696         ivtv_vapi(itv, CX2341X_DEC_START_PLAYBACK, 2, gop_offset, 0);
 697
 698         /* Clear the following Interrupt mask bits for decoding */
 699         ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_DECODE);
 700         IVTV_DEBUG_IRQ("IRQ Mask is now: 0x%08x\n", itv->irqmask);
 701
 702         /* you're live! sit back and await interrupts :) */
 703         atomic_inc(&itv->decoding);
 704         return 0;
 705 }
 706
 707 void ivtv_stop_all_captures(struct ivtv *itv)
 708 {
 709         int i;
 710
 711         for (i = IVTV_MAX_STREAMS - 1; i >= 0; i--) {
 712                 struct ivtv_stream *s = &itv->streams[i];
 713
 714                 if (s->v4l2dev == NULL)
 715                         continue;
 716                 if (test_bit(IVTV_F_S_STREAMING, &s->s_flags)) {
 717                         ivtv_stop_v4l2_encode_stream(s, 0);
 718                 }
 719         }
 720 }
 721
 722 int ivtv_stop_v4l2_encode_stream(struct ivtv_stream *s, int gop_end)
 723 {
 724         struct ivtv *itv = s->itv;
 725         DECLARE_WAITQUEUE(wait, current);
 726         int cap_type;
 727         unsigned long then;
 728         int stopmode;
 729         u32 data[CX2341X_MBOX_MAX_DATA];
 730
 731         if (s->v4l2dev == NULL)
 732                 return -EINVAL;
 733
 734         /* This function assumes that you are allowed to stop the capture
 735            and that we are actually capturing */
 736
 737         IVTV_DEBUG_INFO("Stop Capture\n");
 738
 739         if (s->type == IVTV_DEC_STREAM_TYPE_VOUT)
 740                 return 0;
 741         if (atomic_read(&itv->capturing) == 0)
 742                 return 0;
 743
 744         switch (s->type) {
 745         case IVTV_ENC_STREAM_TYPE_YUV:
 746                 cap_type = 1;
 747                 break;
 748         case IVTV_ENC_STREAM_TYPE_PCM:
 749                 cap_type = 1;
 750                 break;
 751         case IVTV_ENC_STREAM_TYPE_VBI:
 752                 cap_type = 1;
 753                 break;
 754         case IVTV_ENC_STREAM_TYPE_MPG:
 755         default:
 756                 cap_type = 0;
 757                 break;
 758         }
 759
 760         /* Stop Capture Mode */
 761         if (s->type == IVTV_ENC_STREAM_TYPE_MPG && gop_end) {
 762                 stopmode = 0;
 763         } else {
 764                 stopmode = 1;
 765         }
 766
 767         /* end_capture */
 768         /* when: 0 =  end of GOP  1 = NOW!, type: 0 = mpeg, subtype: 3 = video+audio */
 769         ivtv_vapi(itv, CX2341X_ENC_STOP_CAPTURE, 3, stopmode, cap_type, s->subtype);
 770
 771         then = jiffies;
 772
 773         if (!test_bit(IVTV_F_S_PASSTHROUGH, &s->s_flags)) {
 774                 if (s->type == IVTV_ENC_STREAM_TYPE_MPG && gop_end) {
 775                         /* only run these if we're shutting down the last cap */
 776                         unsigned long duration;
 777
 778                         then = jiffies;
 779                         add_wait_queue(&itv->cap_w, &wait);
 780
 781                         set_current_state(TASK_INTERRUPTIBLE);
 782
 783                         /* wait 2s for EOS interrupt */
 784                         while (!test_bit(IVTV_F_I_EOS, &itv->i_flags) &&
 785                                 jiffies < then + msecs_to_jiffies (2000)) {
 786                                 schedule_timeout(msecs_to_jiffies(10));
 787                         }
 788
 789                         /* To convert jiffies to ms, we must multiply by 1000
 790                          * and divide by HZ.  To avoid runtime division, we
 791                          * convert this to multiplication by 1000/HZ.
 792                          * Since integer division truncates, we get the best
 793                          * accuracy if we do a rounding calculation of the constant.
 794                          * Think of the case where HZ is 1024.
 795                          */
 796                         duration = ((1000 + HZ / 2) / HZ) * (jiffies - then);
 797
 798                         if (!test_bit(IVTV_F_I_EOS, &itv->i_flags)) {
 799                                 IVTV_DEBUG_WARN("%s: EOS interrupt not received! stopping anyway.\n", s->name);
 800                                 IVTV_DEBUG_WARN("%s: waited %lu ms.\n", s->name, duration);
 801                         } else {
 802                                 IVTV_DEBUG_INFO("%s: EOS took %lu ms to occur.\n", s->name, duration);
 803                         }
 804                         set_current_state(TASK_RUNNING);
 805                         remove_wait_queue(&itv->cap_w, &wait);
 806                 }
 807
 808                 then = jiffies;
 809                 /* Make sure DMA is complete */
 810                 add_wait_queue(&s->waitq, &wait);
 811                 do {
 812                         /* check if DMA is pending */
 813                         if ((s->type == IVTV_ENC_STREAM_TYPE_MPG) &&    /* MPG Only */
 814                             (read_reg(IVTV_REG_DMASTATUS) & 0x02)) {
 815                                 /* Check for last DMA */
 816                                 ivtv_vapi_result(itv, data, CX2341X_ENC_GET_SEQ_END, 2, 0, 0);
 817
 818                                 if (data[0] == 1) {
 819                                         IVTV_DEBUG_DMA("%s: Last DMA of size 0x%08x\n", s->name, data[1]);
 820                                         break;
 821                                 }
 822                         } else if (read_reg(IVTV_REG_DMASTATUS) & 0x02) {
 823                                 break;
 824                         }
 825                 } while (!ivtv_msleep_timeout(10, 1) &&
 826                          then + msecs_to_jiffies(2000) > jiffies);
 827
 828                 set_current_state(TASK_RUNNING);
 829                 remove_wait_queue(&s->waitq, &wait);
 830         }
 831
 832         atomic_dec(&itv->capturing);
 833
 834         /* Clear capture and no-read bits */
 835         clear_bit(IVTV_F_S_STREAMING, &s->s_flags);
 836
 837         /* ensure these global cleanup actions are done only once */
 838         mutex_lock(&itv->serialize_lock);
 839
 840         if (s->type == IVTV_ENC_STREAM_TYPE_VBI)
 841                 ivtv_set_irq_mask(itv, IVTV_IRQ_ENC_VBI_CAP);
 842
 843         if (atomic_read(&itv->capturing) > 0) {
 844                 mutex_unlock(&itv->serialize_lock);
 845                 return 0;
 846         }
 847
 848         /* Set the following Interrupt mask bits for capture */
 849         ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE);
 850
 851         /* event notification (off) */
 852         if (test_and_clear_bit(IVTV_F_I_DIG_RST, &itv->i_flags)) {
 853                 /* type: 0 = refresh */
 854                 /* on/off: 0 = off, intr: 0x10000000, mbox_id: -1: none */
 855                 ivtv_vapi(itv, CX2341X_ENC_SET_EVENT_NOTIFICATION, 4, 0, 0, IVTV_IRQ_ENC_VIM_RST, -1);
 856                 ivtv_set_irq_mask(itv, IVTV_IRQ_ENC_VIM_RST);
 857         }
 858
 859         wake_up(&s->waitq);
 860         mutex_unlock(&itv->serialize_lock);
 861
 862         return 0;
 863 }
 864
 865 int ivtv_stop_v4l2_decode_stream(struct ivtv_stream *s, int flags, u64 pts)
 866 {
 867         struct ivtv *itv = s->itv;
 868
 869         if (s->v4l2dev == NULL)
 870                 return -EINVAL;
 871
 872         if (s->type != IVTV_DEC_STREAM_TYPE_YUV && s->type != IVTV_DEC_STREAM_TYPE_MPG)
 873                 return -EINVAL;
 874
 875         if (!test_bit(IVTV_F_S_STREAMING, &s->s_flags))
 876                 return 0;
 877
 878         IVTV_DEBUG_INFO("Stop Decode at %llu, flags: %x\n", (unsigned long long)pts, flags);
 879
 880         /* Stop Decoder */
 881         if (!(flags & VIDEO_CMD_STOP_IMMEDIATELY) || pts) {
 882                 u32 tmp = 0;
 883
 884                 /* Wait until the decoder is no longer running */
 885                 if (pts) {
 886                         ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3,
 887                                 0, (u32)(pts & 0xffffffff), (u32)(pts >> 32));
 888                 }
 889                 while (1) {
 890                         u32 data[CX2341X_MBOX_MAX_DATA];
 891                         ivtv_vapi_result(itv, data, CX2341X_DEC_GET_XFER_INFO, 0);
 892                         if (s->q_full.buffers + s->q_dma.buffers == 0) {
 893                                 if (tmp == data[3])
 894                                         break;
 895                                 tmp = data[3];
 896                         }
 897                         if (ivtv_msleep_timeout(100, 1))
 898                                 break;
 899                 }
 900         }
 901         ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3, flags & VIDEO_CMD_STOP_TO_BLACK, 0, 0);
 902
 903         /* turn off notification of dual/stereo mode change */
 904         ivtv_vapi(itv, CX2341X_DEC_SET_EVENT_NOTIFICATION, 4, 0, 0, IVTV_IRQ_DEC_AUD_MODE_CHG, -1);
 905
 906         ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_DECODE);
 907
 908         clear_bit(IVTV_F_S_NEEDS_DATA, &s->s_flags);
 909         clear_bit(IVTV_F_S_STREAMING, &s->s_flags);
 910         ivtv_flush_queues(s);
 911
 912         if (!test_bit(IVTV_F_S_PASSTHROUGH, &s->s_flags)) {
 913                 /* disable VBI on TV-out */
 914                 ivtv_disable_vbi(itv);
 915         }
 916
 917         /* decrement decoding */
 918         atomic_dec(&itv->decoding);
 919
 920         set_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags);
 921         wake_up(&itv->event_waitq);
 922
 923         /* wake up wait queues */
 924         wake_up(&s->waitq);
 925
 926         return 0;
 927 }
 928
 929 int ivtv_passthrough_mode(struct ivtv *itv, int enable)
 930 {
 931         struct ivtv_stream *yuv_stream = &itv->streams[IVTV_ENC_STREAM_TYPE_YUV];
 932         struct ivtv_stream *dec_stream = &itv->streams[IVTV_DEC_STREAM_TYPE_YUV];
 933
 934         if (yuv_stream->v4l2dev == NULL || dec_stream->v4l2dev == NULL)
 935                 return -EINVAL;
 936
 937         IVTV_DEBUG_INFO("ivtv ioctl: Select passthrough mode\n");
 938
 939         /* Prevent others from starting/stopping streams while we
 940            initiate/terminate passthrough mode */
 941         if (enable) {
 942                 if (itv->output_mode == OUT_PASSTHROUGH) {
 943                         return 0;
 944                 }
 945                 if (ivtv_set_output_mode(itv, OUT_PASSTHROUGH) != OUT_PASSTHROUGH)
 946                         return -EBUSY;
 947
 948                 /* Fully initialize stream, and then unflag init */
 949                 set_bit(IVTV_F_S_PASSTHROUGH, &dec_stream->s_flags);
 950                 set_bit(IVTV_F_S_STREAMING, &dec_stream->s_flags);
 951
 952                 /* Setup YUV Decoder */
 953                 ivtv_setup_v4l2_decode_stream(dec_stream);
 954
 955                 /* Start Decoder */
 956                 ivtv_vapi(itv, CX2341X_DEC_START_PLAYBACK, 2, 0, 1);
 957                 atomic_inc(&itv->decoding);
 958
 959                 /* Setup capture if not already done */
 960                 if (atomic_read(&itv->capturing) == 0) {
 961                         cx2341x_update(itv, ivtv_api_func, NULL, &itv->params);
 962                 }
 963
 964                 /* Start Passthrough Mode */
 965                 ivtv_vapi(itv, CX2341X_ENC_START_CAPTURE, 2, 2, 11);
 966                 atomic_inc(&itv->capturing);
 967                 return 0;
 968         }
 969
 970         if (itv->output_mode != OUT_PASSTHROUGH)
 971                 return 0;
 972
 973         /* Stop Passthrough Mode */
 974         ivtv_vapi(itv, CX2341X_ENC_STOP_CAPTURE, 3, 1, 2, 11);
 975         ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3, 1, 0, 0);
 976
 977         atomic_dec(&itv->capturing);
 978         atomic_dec(&itv->decoding);
 979         clear_bit(IVTV_F_S_PASSTHROUGH, &dec_stream->s_flags);
 980         clear_bit(IVTV_F_S_STREAMING, &dec_stream->s_flags);
 981         itv->output_mode = OUT_NONE;
 982
 983         return 0;
 984 }