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