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-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         /* Reset VBI */
 318         ivtv_vapi(itv, CX2341X_ENC_SET_VBI_LINE, 5, 0xffff , 0, 0, 0, 0);
 319
 320         if (itv->is_60hz) {
 321                 itv->vbi.count = 12;
 322                 itv->vbi.start[0] = 10;
 323                 itv->vbi.start[1] = 273;
 324         } else {        /* PAL/SECAM */
 325                 itv->vbi.count = 18;
 326                 itv->vbi.start[0] = 6;
 327                 itv->vbi.start[1] = 318;
 328         }
 329
 330         /* setup VBI registers */
 331         itv->video_dec_func(itv, VIDIOC_S_FMT, &itv->vbi.in);
 332
 333         /* determine number of lines and total number of VBI bytes.
 334            A raw line takes 1443 bytes: 2 * 720 + 4 byte frame header - 1
 335            The '- 1' byte is probably an unused U or V byte. Or something...
 336            A sliced line takes 51 bytes: 4 byte frame header, 4 byte internal
 337            header, 42 data bytes + checksum (to be confirmed) */
 338         if (raw) {
 339                 lines = itv->vbi.count * 2;
 340         } else {
 341                 lines = itv->is_60hz ? 24 : 38;
 342                 if (itv->is_60hz && (itv->hw_flags & IVTV_HW_CX25840))
 343                         lines += 2;
 344         }
 345
 346         itv->vbi.enc_size = lines * (raw ? itv->vbi.raw_size : itv->vbi.sliced_size);
 347
 348         /* Note: sliced vs raw flag doesn't seem to have any effect
 349            TODO: check mode (0x02) value with older ivtv versions. */
 350         data[0] = raw | 0x02 | (0xbd << 8);
 351
 352         /* Every X number of frames a VBI interrupt arrives (frames as in 25 or 30 fps) */
 353         data[1] = 1;
 354         /* The VBI frames are stored in a ringbuffer with this size (with a VBI frame as unit) */
 355         data[2] = raw ? 4 : 8;
 356         /* The start/stop codes determine which VBI lines end up in the raw VBI data area.
 357            The codes are from table 24 in the saa7115 datasheet. Each raw/sliced/video line
 358            is framed with codes FF0000XX where XX is the SAV/EAV (Start/End of Active Video)
 359            code. These values for raw VBI are obtained from a driver disassembly. The sliced
 360            start/stop codes was deduced from this, but they do not appear in the driver.
 361            Other code pairs that I found are: 0x250E6249/0x13545454 and 0x25256262/0x38137F54.
 362            However, I have no idea what these values are for. */
 363         if (itv->hw_flags & IVTV_HW_CX25840) {
 364                 /* Setup VBI for the cx25840 digitizer */
 365                 if (raw) {
 366                         data[3] = 0x20602060;
 367                         data[4] = 0x30703070;
 368                 } else {
 369                         data[3] = 0xB0F0B0F0;
 370                         data[4] = 0xA0E0A0E0;
 371                 }
 372                 /* Lines per frame */
 373                 data[5] = lines;
 374                 /* bytes per line */
 375                 data[6] = (raw ? itv->vbi.raw_size : itv->vbi.sliced_size);
 376         } else {
 377                 /* Setup VBI for the saa7115 digitizer */
 378                 if (raw) {
 379                         data[3] = 0x25256262;
 380                         data[4] = 0x387F7F7F;
 381                 } else {
 382                         data[3] = 0xABABECEC;
 383                         data[4] = 0xB6F1F1F1;
 384                 }
 385                 /* Lines per frame */
 386                 data[5] = lines;
 387                 /* bytes per line */
 388                 data[6] = itv->vbi.enc_size / lines;
 389         }
 390
 391         IVTV_DEBUG_INFO(
 392                 "Setup VBI API header 0x%08x pkts %d buffs %d ln %d sz %d\n",
 393                         data[0], data[1], data[2], data[5], data[6]);
 394
 395         ivtv_api(itv, CX2341X_ENC_SET_VBI_CONFIG, 7, data);
 396
 397         /* returns the VBI encoder memory area. */
 398         itv->vbi.enc_start = data[2];
 399         itv->vbi.fpi = data[0];
 400         if (!itv->vbi.fpi)
 401                 itv->vbi.fpi = 1;
 402
 403         IVTV_DEBUG_INFO("Setup VBI start 0x%08x frames %d fpi %d lines 0x%08x\n",
 404                 itv->vbi.enc_start, data[1], itv->vbi.fpi, itv->digitizer);
 405
 406         /* select VBI lines.
 407            Note that the sliced argument seems to have no effect. */
 408         for (i = 2; i <= 24; i++) {
 409                 int valid;
 410
 411                 if (itv->is_60hz) {
 412                         valid = i >= 10 && i < 22;
 413                 } else {
 414                         valid = i >= 6 && i < 24;
 415                 }
 416                 ivtv_vapi(itv, CX2341X_ENC_SET_VBI_LINE, 5, i - 1,
 417                                 valid, 0 , 0, 0);
 418                 ivtv_vapi(itv, CX2341X_ENC_SET_VBI_LINE, 5, (i - 1) | 0x80000000,
 419                                 valid, 0, 0, 0);
 420         }
 421
 422         /* Remaining VBI questions:
 423            - Is it possible to select particular VBI lines only for inclusion in the MPEG
 424            stream? Currently you can only get the first X lines.
 425            - Is mixed raw and sliced VBI possible?
 426            - What's the meaning of the raw/sliced flag?
 427            - What's the meaning of params 2, 3 & 4 of the Select VBI command? */
 428 }
 429
 430 int ivtv_start_v4l2_encode_stream(struct ivtv_stream *s)
 431 {
 432         u32 data[CX2341X_MBOX_MAX_DATA];
 433         struct ivtv *itv = s->itv;
 434         int captype = 0, subtype = 0;
 435         int enable_passthrough = 0;
 436
 437         if (s->v4l2dev == NULL)
 438                 return -EINVAL;
 439
 440         /* Big serialization lock to ensure no two streams are started
 441            simultaneously: that can give all sorts of weird results. */
 442         mutex_lock(&itv->serialize_lock);
 443         IVTV_DEBUG_INFO("Start encoder stream %s\n", s->name);
 444
 445         switch (s->type) {
 446         case IVTV_ENC_STREAM_TYPE_MPG:
 447                 captype = 0;
 448                 subtype = 3;
 449
 450                 /* Stop Passthrough */
 451                 if (itv->output_mode == OUT_PASSTHROUGH) {
 452                         ivtv_passthrough_mode(itv, 0);
 453                         enable_passthrough = 1;
 454                 }
 455                 itv->mpg_data_received = itv->vbi_data_inserted = 0;
 456                 itv->dualwatch_jiffies = jiffies;
 457                 itv->dualwatch_stereo_mode = itv->params.audio_properties & 0x0300;
 458                 itv->search_pack_header = 0;
 459                 break;
 460
 461         case IVTV_ENC_STREAM_TYPE_YUV:
 462                 if (itv->output_mode == OUT_PASSTHROUGH) {
 463                         captype = 2;
 464                         subtype = 11;   /* video+audio+decoder */
 465                         break;
 466                 }
 467                 captype = 1;
 468                 subtype = 1;
 469                 break;
 470         case IVTV_ENC_STREAM_TYPE_PCM:
 471                 captype = 1;
 472                 subtype = 2;
 473                 break;
 474         case IVTV_ENC_STREAM_TYPE_VBI:
 475                 captype = 1;
 476                 subtype = 4;
 477
 478                 itv->vbi.frame = 0;
 479                 itv->vbi.inserted_frame = 0;
 480                 memset(itv->vbi.sliced_mpeg_size,
 481                         0, sizeof(itv->vbi.sliced_mpeg_size));
 482                 break;
 483         default:
 484                 mutex_unlock(&itv->serialize_lock);
 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                 /* Always use frame based mode. Experiments have demonstrated that byte
 498                    stream based mode results in dropped frames and corruption. Not often,
 499                    but occasionally. Many thanks go to Leonard Orb who spent a lot of
 500                    effort and time trying to trace the cause of the drop outs. */
 501                 /* 1 frame per DMA */
 502                 /*ivtv_vapi(itv, CX2341X_ENC_SET_DMA_BLOCK_SIZE, 2, 128, 0); */
 503                 ivtv_vapi(itv, CX2341X_ENC_SET_DMA_BLOCK_SIZE, 2, 1, 1);
 504
 505                 /* Stuff from Windows, we don't know what it is */
 506                 ivtv_vapi(itv, CX2341X_ENC_SET_VERT_CROP_LINE, 1, 0);
 507                 /* According to the docs, this should be correct. However, this is
 508                    untested. I don't dare enable this without having tested it.
 509                    Only very few old cards actually have this hardware combination.
 510                 ivtv_vapi(itv, CX2341X_ENC_SET_VERT_CROP_LINE, 1,
 511                         ((itv->hw_flags & IVTV_HW_SAA7114) && itv->is_60hz) ? 10001 : 0);
 512                 */
 513                 ivtv_vapi(itv, CX2341X_ENC_MISC, 2, 3, !itv->has_cx23415);
 514                 ivtv_vapi(itv, CX2341X_ENC_MISC, 2, 8, 0);
 515                 ivtv_vapi(itv, CX2341X_ENC_MISC, 2, 4, 1);
 516                 ivtv_vapi(itv, CX2341X_ENC_MISC, 1, 12);
 517
 518                 /* assign placeholder */
 519                 ivtv_vapi(itv, CX2341X_ENC_SET_PLACEHOLDER, 12,
 520                         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
 521
 522                 ivtv_vapi(itv, CX2341X_ENC_SET_NUM_VSYNC_LINES, 2, itv->digitizer, itv->digitizer);
 523
 524                 /* Setup VBI */
 525                 if (itv->v4l2_cap & V4L2_CAP_VBI_CAPTURE) {
 526                         ivtv_vbi_setup(itv);
 527                 }
 528
 529                 /* assign program index info. Mask 7: select I/P/B, Num_req: 400 max */
 530                 ivtv_vapi_result(itv, data, CX2341X_ENC_SET_PGM_INDEX_INFO, 2, 7, 400);
 531                 itv->pgm_info_offset = data[0];
 532                 itv->pgm_info_num = data[1];
 533                 itv->pgm_info_write_idx = 0;
 534                 itv->pgm_info_read_idx = 0;
 535
 536                 IVTV_DEBUG_INFO("PGM Index at 0x%08x with %d elements\n",
 537                                 itv->pgm_info_offset, itv->pgm_info_num);
 538
 539                 /* Setup API for Stream */
 540                 cx2341x_update(itv, ivtv_api_func, NULL, &itv->params);
 541         }
 542
 543         /* Vsync Setup */
 544         if (itv->has_cx23415 && !test_and_set_bit(IVTV_F_I_DIG_RST, &itv->i_flags)) {
 545                 /* event notification (on) */
 546                 ivtv_vapi(itv, CX2341X_ENC_SET_EVENT_NOTIFICATION, 4, 0, 1, IVTV_IRQ_ENC_VIM_RST, -1);
 547                 ivtv_clear_irq_mask(itv, IVTV_IRQ_ENC_VIM_RST);
 548         }
 549
 550         if (atomic_read(&itv->capturing) == 0) {
 551                 /* Clear all Pending Interrupts */
 552                 ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE);
 553
 554                 clear_bit(IVTV_F_I_EOS, &itv->i_flags);
 555
 556                 /* Initialize Digitizer for Capture */
 557                 itv->video_dec_func(itv, VIDIOC_STREAMOFF, 0);
 558                 ivtv_msleep_timeout(300, 1);
 559                 ivtv_vapi(itv, CX2341X_ENC_INITIALIZE_INPUT, 0);
 560                 itv->video_dec_func(itv, VIDIOC_STREAMON, 0);
 561         }
 562
 563         /* begin_capture */
 564         if (ivtv_vapi(itv, CX2341X_ENC_START_CAPTURE, 2, captype, subtype))
 565         {
 566                 IVTV_DEBUG_WARN( "Error starting capture!\n");
 567                 mutex_unlock(&itv->serialize_lock);
 568                 return -EINVAL;
 569         }
 570
 571         /* Start Passthrough */
 572         if (enable_passthrough) {
 573                 ivtv_passthrough_mode(itv, 1);
 574         }
 575
 576         if (s->type == IVTV_ENC_STREAM_TYPE_VBI)
 577                 ivtv_clear_irq_mask(itv, IVTV_IRQ_ENC_VBI_CAP);
 578         else
 579                 ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE);
 580
 581         /* you're live! sit back and await interrupts :) */
 582         atomic_inc(&itv->capturing);
 583         mutex_unlock(&itv->serialize_lock);
 584         return 0;
 585 }
 586
 587 static int ivtv_setup_v4l2_decode_stream(struct ivtv_stream *s)
 588 {
 589         u32 data[CX2341X_MBOX_MAX_DATA];
 590         struct ivtv *itv = s->itv;
 591         int datatype;
 592
 593         if (s->v4l2dev == NULL)
 594                 return -EINVAL;
 595
 596         IVTV_DEBUG_INFO("Setting some initial decoder settings\n");
 597
 598         /* set audio mode to left/stereo  for dual/stereo mode. */
 599         ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode);
 600
 601         /* set number of internal decoder buffers */
 602         ivtv_vapi(itv, CX2341X_DEC_SET_DISPLAY_BUFFERS, 1, 0);
 603
 604         /* prebuffering */
 605         ivtv_vapi(itv, CX2341X_DEC_SET_PREBUFFERING, 1, 1);
 606
 607         /* extract from user packets */
 608         ivtv_vapi_result(itv, data, CX2341X_DEC_EXTRACT_VBI, 1, 1);
 609         itv->vbi.dec_start = data[0];
 610
 611         IVTV_DEBUG_INFO("Decoder VBI RE-Insert start 0x%08x size 0x%08x\n",
 612                 itv->vbi.dec_start, data[1]);
 613
 614         /* set decoder source settings */
 615         /* Data type: 0 = mpeg from host,
 616            1 = yuv from encoder,
 617            2 = yuv_from_host */
 618         switch (s->type) {
 619         case IVTV_DEC_STREAM_TYPE_YUV:
 620                 datatype = itv->output_mode == OUT_PASSTHROUGH ? 1 : 2;
 621                 IVTV_DEBUG_INFO("Setup DEC YUV Stream data[0] = %d\n", datatype);
 622                 break;
 623         case IVTV_DEC_STREAM_TYPE_MPG:
 624         default:
 625                 datatype = 0;
 626                 break;
 627         }
 628         if (ivtv_vapi(itv, CX2341X_DEC_SET_DECODER_SOURCE, 4, datatype,
 629                         itv->params.width, itv->params.height, itv->params.audio_properties)) {
 630                 IVTV_DEBUG_WARN("Couldn't initialize decoder source\n");
 631         }
 632         return 0;
 633 }
 634
 635 int ivtv_start_v4l2_decode_stream(struct ivtv_stream *s, int gop_offset)
 636 {
 637         struct ivtv *itv = s->itv;
 638
 639         if (s->v4l2dev == NULL)
 640                 return -EINVAL;
 641
 642         if (test_and_set_bit(IVTV_F_S_STREAMING, &s->s_flags))
 643                 return 0;       /* already started */
 644
 645         IVTV_DEBUG_INFO("Starting decode stream %s (gop_offset %d)\n", s->name, gop_offset);
 646
 647         /* Clear Streamoff */
 648         if (s->type == IVTV_DEC_STREAM_TYPE_YUV) {
 649                 /* Initialize Decoder */
 650                 /* Reprogram Decoder YUV Buffers for YUV */
 651                 write_reg(yuv_offset[0] >> 4, 0x82c);
 652                 write_reg((yuv_offset[0] + IVTV_YUV_BUFFER_UV_OFFSET) >> 4, 0x830);
 653                 write_reg(yuv_offset[0] >> 4, 0x834);
 654                 write_reg((yuv_offset[0] + IVTV_YUV_BUFFER_UV_OFFSET) >> 4, 0x838);
 655
 656                 write_reg_sync(0x00000000 | (0x0c << 16) | (0x0b << 8), 0x2d24);
 657
 658                 write_reg_sync(0x00108080, 0x2898);
 659                 /* Enable YUV decoder output */
 660                 write_reg_sync(0x01, IVTV_REG_VDM);
 661         }
 662
 663         ivtv_setup_v4l2_decode_stream(s);
 664
 665         /* set dma size to 65536 bytes */
 666         ivtv_vapi(itv, CX2341X_DEC_SET_DMA_BLOCK_SIZE, 1, 65536);
 667
 668         clear_bit(IVTV_F_S_STREAMOFF, &s->s_flags);
 669
 670         /* Zero out decoder counters */
 671         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_FIELD_DISPLAYED].data[0]);
 672         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_FIELD_DISPLAYED].data[1]);
 673         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_FIELD_DISPLAYED].data[2]);
 674         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_FIELD_DISPLAYED].data[3]);
 675         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[0]);
 676         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[1]);
 677         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[2]);
 678         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[3]);
 679
 680         /* turn on notification of dual/stereo mode change */
 681         ivtv_vapi(itv, CX2341X_DEC_SET_EVENT_NOTIFICATION, 4, 0, 1, IVTV_IRQ_DEC_AUD_MODE_CHG, -1);
 682
 683         /* start playback */
 684         ivtv_vapi(itv, CX2341X_DEC_START_PLAYBACK, 2, gop_offset, 0);
 685
 686         /* Clear the following Interrupt mask bits for decoding */
 687         ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_DECODE);
 688         IVTV_DEBUG_IRQ("IRQ Mask is now: 0x%08x\n", itv->irqmask);
 689
 690         /* you're live! sit back and await interrupts :) */
 691         atomic_inc(&itv->decoding);
 692         return 0;
 693 }
 694
 695 void ivtv_stop_all_captures(struct ivtv *itv)
 696 {
 697         int i;
 698
 699         for (i = IVTV_MAX_STREAMS - 1; i >= 0; i--) {
 700                 struct ivtv_stream *s = &itv->streams[i];
 701
 702                 if (s->v4l2dev == NULL)
 703                         continue;
 704                 if (test_bit(IVTV_F_S_STREAMING, &s->s_flags)) {
 705                         ivtv_stop_v4l2_encode_stream(s, 0);
 706                 }
 707         }
 708 }
 709
 710 int ivtv_stop_v4l2_encode_stream(struct ivtv_stream *s, int gop_end)
 711 {
 712         struct ivtv *itv = s->itv;
 713         DECLARE_WAITQUEUE(wait, current);
 714         int cap_type;
 715         unsigned long then;
 716         int stopmode;
 717
 718         if (s->v4l2dev == NULL)
 719                 return -EINVAL;
 720
 721         /* This function assumes that you are allowed to stop the capture
 722            and that we are actually capturing */
 723
 724         IVTV_DEBUG_INFO("Stop Capture\n");
 725
 726         if (s->type == IVTV_DEC_STREAM_TYPE_VOUT)
 727                 return 0;
 728         if (atomic_read(&itv->capturing) == 0)
 729                 return 0;
 730
 731         switch (s->type) {
 732         case IVTV_ENC_STREAM_TYPE_YUV:
 733                 cap_type = 1;
 734                 break;
 735         case IVTV_ENC_STREAM_TYPE_PCM:
 736                 cap_type = 1;
 737                 break;
 738         case IVTV_ENC_STREAM_TYPE_VBI:
 739                 cap_type = 1;
 740                 break;
 741         case IVTV_ENC_STREAM_TYPE_MPG:
 742         default:
 743                 cap_type = 0;
 744                 break;
 745         }
 746
 747         /* Stop Capture Mode */
 748         if (s->type == IVTV_ENC_STREAM_TYPE_MPG && gop_end) {
 749                 stopmode = 0;
 750         } else {
 751                 stopmode = 1;
 752         }
 753
 754         /* ensure these actions are done only once */
 755         mutex_lock(&itv->serialize_lock);
 756
 757         /* end_capture */
 758         /* when: 0 =  end of GOP  1 = NOW!, type: 0 = mpeg, subtype: 3 = video+audio */
 759         ivtv_vapi(itv, CX2341X_ENC_STOP_CAPTURE, 3, stopmode, cap_type, s->subtype);
 760
 761         then = jiffies;
 762
 763         if (!test_bit(IVTV_F_S_PASSTHROUGH, &s->s_flags)) {
 764                 if (s->type == IVTV_ENC_STREAM_TYPE_MPG && gop_end) {
 765                         /* only run these if we're shutting down the last cap */
 766                         unsigned long duration;
 767
 768                         then = jiffies;
 769                         add_wait_queue(&itv->cap_w, &wait);
 770
 771                         set_current_state(TASK_INTERRUPTIBLE);
 772
 773                         /* wait 2s for EOS interrupt */
 774                         while (!test_bit(IVTV_F_I_EOS, &itv->i_flags) &&
 775                                 jiffies < then + msecs_to_jiffies (2000)) {
 776                                 schedule_timeout(msecs_to_jiffies(10));
 777                         }
 778
 779                         /* To convert jiffies to ms, we must multiply by 1000
 780                          * and divide by HZ.  To avoid runtime division, we
 781                          * convert this to multiplication by 1000/HZ.
 782                          * Since integer division truncates, we get the best
 783                          * accuracy if we do a rounding calculation of the constant.
 784                          * Think of the case where HZ is 1024.
 785                          */
 786                         duration = ((1000 + HZ / 2) / HZ) * (jiffies - then);
 787
 788                         if (!test_bit(IVTV_F_I_EOS, &itv->i_flags)) {
 789                                 IVTV_DEBUG_WARN("%s: EOS interrupt not received! stopping anyway.\n", s->name);
 790                                 IVTV_DEBUG_WARN("%s: waited %lu ms.\n", s->name, duration);
 791                         } else {
 792                                 IVTV_DEBUG_INFO("%s: EOS took %lu ms to occur.\n", s->name, duration);
 793                         }
 794                         set_current_state(TASK_RUNNING);
 795                         remove_wait_queue(&itv->cap_w, &wait);
 796                 }
 797
 798                 then = jiffies;
 799
 800                 /* Handle any pending interrupts */
 801                 ivtv_msleep_timeout(100, 1);
 802         }
 803
 804         atomic_dec(&itv->capturing);
 805
 806         /* Clear capture and no-read bits */
 807         clear_bit(IVTV_F_S_STREAMING, &s->s_flags);
 808
 809         if (s->type == IVTV_ENC_STREAM_TYPE_VBI)
 810                 ivtv_set_irq_mask(itv, IVTV_IRQ_ENC_VBI_CAP);
 811
 812         if (atomic_read(&itv->capturing) > 0) {
 813                 mutex_unlock(&itv->serialize_lock);
 814                 return 0;
 815         }
 816
 817         /* Set the following Interrupt mask bits for capture */
 818         ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE);
 819
 820         /* event notification (off) */
 821         if (test_and_clear_bit(IVTV_F_I_DIG_RST, &itv->i_flags)) {
 822                 /* type: 0 = refresh */
 823                 /* on/off: 0 = off, intr: 0x10000000, mbox_id: -1: none */
 824                 ivtv_vapi(itv, CX2341X_ENC_SET_EVENT_NOTIFICATION, 4, 0, 0, IVTV_IRQ_ENC_VIM_RST, -1);
 825                 ivtv_set_irq_mask(itv, IVTV_IRQ_ENC_VIM_RST);
 826         }
 827
 828         wake_up(&s->waitq);
 829         mutex_unlock(&itv->serialize_lock);
 830
 831         return 0;
 832 }
 833
 834 int ivtv_stop_v4l2_decode_stream(struct ivtv_stream *s, int flags, u64 pts)
 835 {
 836         struct ivtv *itv = s->itv;
 837
 838         if (s->v4l2dev == NULL)
 839                 return -EINVAL;
 840
 841         if (s->type != IVTV_DEC_STREAM_TYPE_YUV && s->type != IVTV_DEC_STREAM_TYPE_MPG)
 842                 return -EINVAL;
 843
 844         if (!test_bit(IVTV_F_S_STREAMING, &s->s_flags))
 845                 return 0;
 846
 847         IVTV_DEBUG_INFO("Stop Decode at %llu, flags: %x\n", (unsigned long long)pts, flags);
 848
 849         /* Stop Decoder */
 850         if (!(flags & VIDEO_CMD_STOP_IMMEDIATELY) || pts) {
 851                 u32 tmp = 0;
 852
 853                 /* Wait until the decoder is no longer running */
 854                 if (pts) {
 855                         ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3,
 856                                 0, (u32)(pts & 0xffffffff), (u32)(pts >> 32));
 857                 }
 858                 while (1) {
 859                         u32 data[CX2341X_MBOX_MAX_DATA];
 860                         ivtv_vapi_result(itv, data, CX2341X_DEC_GET_XFER_INFO, 0);
 861                         if (s->q_full.buffers + s->q_dma.buffers == 0) {
 862                                 if (tmp == data[3])
 863                                         break;
 864                                 tmp = data[3];
 865                         }
 866                         if (ivtv_msleep_timeout(100, 1))
 867                                 break;
 868                 }
 869         }
 870         ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3, flags & VIDEO_CMD_STOP_TO_BLACK, 0, 0);
 871
 872         /* turn off notification of dual/stereo mode change */
 873         ivtv_vapi(itv, CX2341X_DEC_SET_EVENT_NOTIFICATION, 4, 0, 0, IVTV_IRQ_DEC_AUD_MODE_CHG, -1);
 874
 875         ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_DECODE);
 876
 877         clear_bit(IVTV_F_S_NEEDS_DATA, &s->s_flags);
 878         clear_bit(IVTV_F_S_STREAMING, &s->s_flags);
 879         ivtv_flush_queues(s);
 880
 881         /* decrement decoding */
 882         atomic_dec(&itv->decoding);
 883
 884         set_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags);
 885         wake_up(&itv->event_waitq);
 886
 887         /* wake up wait queues */
 888         wake_up(&s->waitq);
 889
 890         return 0;
 891 }
 892
 893 int ivtv_passthrough_mode(struct ivtv *itv, int enable)
 894 {
 895         struct ivtv_stream *yuv_stream = &itv->streams[IVTV_ENC_STREAM_TYPE_YUV];
 896         struct ivtv_stream *dec_stream = &itv->streams[IVTV_DEC_STREAM_TYPE_YUV];
 897
 898         if (yuv_stream->v4l2dev == NULL || dec_stream->v4l2dev == NULL)
 899                 return -EINVAL;
 900
 901         IVTV_DEBUG_INFO("ivtv ioctl: Select passthrough mode\n");
 902
 903         /* Prevent others from starting/stopping streams while we
 904            initiate/terminate passthrough mode */
 905         if (enable) {
 906                 if (itv->output_mode == OUT_PASSTHROUGH) {
 907                         return 0;
 908                 }
 909                 if (ivtv_set_output_mode(itv, OUT_PASSTHROUGH) != OUT_PASSTHROUGH)
 910                         return -EBUSY;
 911
 912                 /* Fully initialize stream, and then unflag init */
 913                 set_bit(IVTV_F_S_PASSTHROUGH, &dec_stream->s_flags);
 914                 set_bit(IVTV_F_S_STREAMING, &dec_stream->s_flags);
 915
 916                 /* Setup YUV Decoder */
 917                 ivtv_setup_v4l2_decode_stream(dec_stream);
 918
 919                 /* Start Decoder */
 920                 ivtv_vapi(itv, CX2341X_DEC_START_PLAYBACK, 2, 0, 1);
 921                 atomic_inc(&itv->decoding);
 922
 923                 /* Setup capture if not already done */
 924                 if (atomic_read(&itv->capturing) == 0) {
 925                         cx2341x_update(itv, ivtv_api_func, NULL, &itv->params);
 926                 }
 927
 928                 /* Start Passthrough Mode */
 929                 ivtv_vapi(itv, CX2341X_ENC_START_CAPTURE, 2, 2, 11);
 930                 atomic_inc(&itv->capturing);
 931                 return 0;
 932         }
 933
 934         if (itv->output_mode != OUT_PASSTHROUGH)
 935                 return 0;
 936
 937         /* Stop Passthrough Mode */
 938         ivtv_vapi(itv, CX2341X_ENC_STOP_CAPTURE, 3, 1, 2, 11);
 939         ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3, 1, 0, 0);
 940
 941         atomic_dec(&itv->capturing);
 942         atomic_dec(&itv->decoding);
 943         clear_bit(IVTV_F_S_PASSTHROUGH, &dec_stream->s_flags);
 944         clear_bit(IVTV_F_S_STREAMING, &dec_stream->s_flags);
 945         itv->output_mode = OUT_NONE;
 946
 947         return 0;
 948 }