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.kilobytes[type] * 1024 + s->buf_size - 1) / 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.kilobytes[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 kB)\n",
 242                         s->v4l2dev->minor, s->name, itv->options.kilobytes[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.kilobytes[type])
 250                         IVTV_INFO("Registered device vbi%d for %s (%d kB)\n",
 251                                 s->v4l2dev->minor - MINOR_VFL_TYPE_VBI_MIN,
 252                                 s->name, itv->options.kilobytes[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         IVTV_DEBUG_INFO("Start encoder stream %s\n", s->name);
 441
 442         switch (s->type) {
 443         case IVTV_ENC_STREAM_TYPE_MPG:
 444                 captype = 0;
 445                 subtype = 3;
 446
 447                 /* Stop Passthrough */
 448                 if (itv->output_mode == OUT_PASSTHROUGH) {
 449                         ivtv_passthrough_mode(itv, 0);
 450                         enable_passthrough = 1;
 451                 }
 452                 itv->mpg_data_received = itv->vbi_data_inserted = 0;
 453                 itv->dualwatch_jiffies = jiffies;
 454                 itv->dualwatch_stereo_mode = itv->params.audio_properties & 0x0300;
 455                 itv->search_pack_header = 0;
 456                 break;
 457
 458         case IVTV_ENC_STREAM_TYPE_YUV:
 459                 if (itv->output_mode == OUT_PASSTHROUGH) {
 460                         captype = 2;
 461                         subtype = 11;   /* video+audio+decoder */
 462                         break;
 463                 }
 464                 captype = 1;
 465                 subtype = 1;
 466                 break;
 467         case IVTV_ENC_STREAM_TYPE_PCM:
 468                 captype = 1;
 469                 subtype = 2;
 470                 break;
 471         case IVTV_ENC_STREAM_TYPE_VBI:
 472                 captype = 1;
 473                 subtype = 4;
 474
 475                 itv->vbi.frame = 0;
 476                 itv->vbi.inserted_frame = 0;
 477                 memset(itv->vbi.sliced_mpeg_size,
 478                         0, sizeof(itv->vbi.sliced_mpeg_size));
 479                 break;
 480         default:
 481                 return -EINVAL;
 482         }
 483         s->subtype = subtype;
 484         s->buffers_stolen = 0;
 485
 486         /* mute/unmute video */
 487         ivtv_vapi(itv, CX2341X_ENC_MUTE_VIDEO, 1, test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ? 1 : 0);
 488
 489         /* Clear Streamoff flags in case left from last capture */
 490         clear_bit(IVTV_F_S_STREAMOFF, &s->s_flags);
 491
 492         if (atomic_read(&itv->capturing) == 0) {
 493                 /* Always use frame based mode. Experiments have demonstrated that byte
 494                    stream based mode results in dropped frames and corruption. Not often,
 495                    but occasionally. Many thanks go to Leonard Orb who spent a lot of
 496                    effort and time trying to trace the cause of the drop outs. */
 497                 /* 1 frame per DMA */
 498                 /*ivtv_vapi(itv, CX2341X_ENC_SET_DMA_BLOCK_SIZE, 2, 128, 0); */
 499                 ivtv_vapi(itv, CX2341X_ENC_SET_DMA_BLOCK_SIZE, 2, 1, 1);
 500
 501                 /* Stuff from Windows, we don't know what it is */
 502                 ivtv_vapi(itv, CX2341X_ENC_SET_VERT_CROP_LINE, 1, 0);
 503                 /* According to the docs, this should be correct. However, this is
 504                    untested. I don't dare enable this without having tested it.
 505                    Only very few old cards actually have this hardware combination.
 506                 ivtv_vapi(itv, CX2341X_ENC_SET_VERT_CROP_LINE, 1,
 507                         ((itv->hw_flags & IVTV_HW_SAA7114) && itv->is_60hz) ? 10001 : 0);
 508                 */
 509                 ivtv_vapi(itv, CX2341X_ENC_MISC, 2, 3, !itv->has_cx23415);
 510                 ivtv_vapi(itv, CX2341X_ENC_MISC, 2, 8, 0);
 511                 ivtv_vapi(itv, CX2341X_ENC_MISC, 2, 4, 1);
 512                 ivtv_vapi(itv, CX2341X_ENC_MISC, 1, 12);
 513
 514                 /* assign placeholder */
 515                 ivtv_vapi(itv, CX2341X_ENC_SET_PLACEHOLDER, 12,
 516                         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
 517
 518                 ivtv_vapi(itv, CX2341X_ENC_SET_NUM_VSYNC_LINES, 2, itv->digitizer, itv->digitizer);
 519
 520                 /* Setup VBI */
 521                 if (itv->v4l2_cap & V4L2_CAP_VBI_CAPTURE) {
 522                         ivtv_vbi_setup(itv);
 523                 }
 524
 525                 /* assign program index info. Mask 7: select I/P/B, Num_req: 400 max */
 526                 ivtv_vapi_result(itv, data, CX2341X_ENC_SET_PGM_INDEX_INFO, 2, 7, 400);
 527                 itv->pgm_info_offset = data[0];
 528                 itv->pgm_info_num = data[1];
 529                 itv->pgm_info_write_idx = 0;
 530                 itv->pgm_info_read_idx = 0;
 531
 532                 IVTV_DEBUG_INFO("PGM Index at 0x%08x with %d elements\n",
 533                                 itv->pgm_info_offset, itv->pgm_info_num);
 534
 535                 /* Setup API for Stream */
 536                 cx2341x_update(itv, ivtv_api_func, NULL, &itv->params);
 537         }
 538
 539         /* Vsync Setup */
 540         if (itv->has_cx23415 && !test_and_set_bit(IVTV_F_I_DIG_RST, &itv->i_flags)) {
 541                 /* event notification (on) */
 542                 ivtv_vapi(itv, CX2341X_ENC_SET_EVENT_NOTIFICATION, 4, 0, 1, IVTV_IRQ_ENC_VIM_RST, -1);
 543                 ivtv_clear_irq_mask(itv, IVTV_IRQ_ENC_VIM_RST);
 544         }
 545
 546         if (atomic_read(&itv->capturing) == 0) {
 547                 /* Clear all Pending Interrupts */
 548                 ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE);
 549
 550                 clear_bit(IVTV_F_I_EOS, &itv->i_flags);
 551
 552                 /* Initialize Digitizer for Capture */
 553                 itv->video_dec_func(itv, VIDIOC_STREAMOFF, 0);
 554                 ivtv_msleep_timeout(300, 1);
 555                 ivtv_vapi(itv, CX2341X_ENC_INITIALIZE_INPUT, 0);
 556                 itv->video_dec_func(itv, VIDIOC_STREAMON, 0);
 557         }
 558
 559         /* begin_capture */
 560         if (ivtv_vapi(itv, CX2341X_ENC_START_CAPTURE, 2, captype, subtype))
 561         {
 562                 IVTV_DEBUG_WARN( "Error starting capture!\n");
 563                 return -EINVAL;
 564         }
 565
 566         /* Start Passthrough */
 567         if (enable_passthrough) {
 568                 ivtv_passthrough_mode(itv, 1);
 569         }
 570
 571         if (s->type == IVTV_ENC_STREAM_TYPE_VBI)
 572                 ivtv_clear_irq_mask(itv, IVTV_IRQ_ENC_VBI_CAP);
 573         else
 574                 ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE);
 575
 576         /* you're live! sit back and await interrupts :) */
 577         atomic_inc(&itv->capturing);
 578         return 0;
 579 }
 580
 581 static int ivtv_setup_v4l2_decode_stream(struct ivtv_stream *s)
 582 {
 583         u32 data[CX2341X_MBOX_MAX_DATA];
 584         struct ivtv *itv = s->itv;
 585         int datatype;
 586
 587         if (s->v4l2dev == NULL)
 588                 return -EINVAL;
 589
 590         IVTV_DEBUG_INFO("Setting some initial decoder settings\n");
 591
 592         /* set audio mode to left/stereo  for dual/stereo mode. */
 593         ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode);
 594
 595         /* set number of internal decoder buffers */
 596         ivtv_vapi(itv, CX2341X_DEC_SET_DISPLAY_BUFFERS, 1, 0);
 597
 598         /* prebuffering */
 599         ivtv_vapi(itv, CX2341X_DEC_SET_PREBUFFERING, 1, 1);
 600
 601         /* extract from user packets */
 602         ivtv_vapi_result(itv, data, CX2341X_DEC_EXTRACT_VBI, 1, 1);
 603         itv->vbi.dec_start = data[0];
 604
 605         IVTV_DEBUG_INFO("Decoder VBI RE-Insert start 0x%08x size 0x%08x\n",
 606                 itv->vbi.dec_start, data[1]);
 607
 608         /* set decoder source settings */
 609         /* Data type: 0 = mpeg from host,
 610            1 = yuv from encoder,
 611            2 = yuv_from_host */
 612         switch (s->type) {
 613         case IVTV_DEC_STREAM_TYPE_YUV:
 614                 datatype = itv->output_mode == OUT_PASSTHROUGH ? 1 : 2;
 615                 IVTV_DEBUG_INFO("Setup DEC YUV Stream data[0] = %d\n", datatype);
 616                 break;
 617         case IVTV_DEC_STREAM_TYPE_MPG:
 618         default:
 619                 datatype = 0;
 620                 break;
 621         }
 622         if (ivtv_vapi(itv, CX2341X_DEC_SET_DECODER_SOURCE, 4, datatype,
 623                         itv->params.width, itv->params.height, itv->params.audio_properties)) {
 624                 IVTV_DEBUG_WARN("Couldn't initialize decoder source\n");
 625         }
 626         return 0;
 627 }
 628
 629 int ivtv_start_v4l2_decode_stream(struct ivtv_stream *s, int gop_offset)
 630 {
 631         struct ivtv *itv = s->itv;
 632
 633         if (s->v4l2dev == NULL)
 634                 return -EINVAL;
 635
 636         if (test_and_set_bit(IVTV_F_S_STREAMING, &s->s_flags))
 637                 return 0;       /* already started */
 638
 639         IVTV_DEBUG_INFO("Starting decode stream %s (gop_offset %d)\n", s->name, gop_offset);
 640
 641         /* Clear Streamoff */
 642         if (s->type == IVTV_DEC_STREAM_TYPE_YUV) {
 643                 /* Initialize Decoder */
 644                 /* Reprogram Decoder YUV Buffers for YUV */
 645                 write_reg(yuv_offset[0] >> 4, 0x82c);
 646                 write_reg((yuv_offset[0] + IVTV_YUV_BUFFER_UV_OFFSET) >> 4, 0x830);
 647                 write_reg(yuv_offset[0] >> 4, 0x834);
 648                 write_reg((yuv_offset[0] + IVTV_YUV_BUFFER_UV_OFFSET) >> 4, 0x838);
 649
 650                 write_reg_sync(0x00000000 | (0x0c << 16) | (0x0b << 8), 0x2d24);
 651
 652                 write_reg_sync(0x00108080, 0x2898);
 653                 /* Enable YUV decoder output */
 654                 write_reg_sync(0x01, IVTV_REG_VDM);
 655         }
 656
 657         ivtv_setup_v4l2_decode_stream(s);
 658
 659         /* set dma size to 65536 bytes */
 660         ivtv_vapi(itv, CX2341X_DEC_SET_DMA_BLOCK_SIZE, 1, 65536);
 661
 662         clear_bit(IVTV_F_S_STREAMOFF, &s->s_flags);
 663
 664         /* Zero out decoder counters */
 665         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_FIELD_DISPLAYED].data[0]);
 666         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_FIELD_DISPLAYED].data[1]);
 667         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_FIELD_DISPLAYED].data[2]);
 668         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_FIELD_DISPLAYED].data[3]);
 669         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[0]);
 670         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[1]);
 671         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[2]);
 672         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[3]);
 673
 674         /* turn on notification of dual/stereo mode change */
 675         ivtv_vapi(itv, CX2341X_DEC_SET_EVENT_NOTIFICATION, 4, 0, 1, IVTV_IRQ_DEC_AUD_MODE_CHG, -1);
 676
 677         /* start playback */
 678         ivtv_vapi(itv, CX2341X_DEC_START_PLAYBACK, 2, gop_offset, 0);
 679
 680         /* Clear the following Interrupt mask bits for decoding */
 681         ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_DECODE);
 682         IVTV_DEBUG_IRQ("IRQ Mask is now: 0x%08x\n", itv->irqmask);
 683
 684         /* you're live! sit back and await interrupts :) */
 685         atomic_inc(&itv->decoding);
 686         return 0;
 687 }
 688
 689 void ivtv_stop_all_captures(struct ivtv *itv)
 690 {
 691         int i;
 692
 693         for (i = IVTV_MAX_STREAMS - 1; i >= 0; i--) {
 694                 struct ivtv_stream *s = &itv->streams[i];
 695
 696                 if (s->v4l2dev == NULL)
 697                         continue;
 698                 if (test_bit(IVTV_F_S_STREAMING, &s->s_flags)) {
 699                         ivtv_stop_v4l2_encode_stream(s, 0);
 700                 }
 701         }
 702 }
 703
 704 int ivtv_stop_v4l2_encode_stream(struct ivtv_stream *s, int gop_end)
 705 {
 706         struct ivtv *itv = s->itv;
 707         DECLARE_WAITQUEUE(wait, current);
 708         int cap_type;
 709         unsigned long then;
 710         int stopmode;
 711
 712         if (s->v4l2dev == NULL)
 713                 return -EINVAL;
 714
 715         /* This function assumes that you are allowed to stop the capture
 716            and that we are actually capturing */
 717
 718         IVTV_DEBUG_INFO("Stop Capture\n");
 719
 720         if (s->type == IVTV_DEC_STREAM_TYPE_VOUT)
 721                 return 0;
 722         if (atomic_read(&itv->capturing) == 0)
 723                 return 0;
 724
 725         switch (s->type) {
 726         case IVTV_ENC_STREAM_TYPE_YUV:
 727                 cap_type = 1;
 728                 break;
 729         case IVTV_ENC_STREAM_TYPE_PCM:
 730                 cap_type = 1;
 731                 break;
 732         case IVTV_ENC_STREAM_TYPE_VBI:
 733                 cap_type = 1;
 734                 break;
 735         case IVTV_ENC_STREAM_TYPE_MPG:
 736         default:
 737                 cap_type = 0;
 738                 break;
 739         }
 740
 741         /* Stop Capture Mode */
 742         if (s->type == IVTV_ENC_STREAM_TYPE_MPG && gop_end) {
 743                 stopmode = 0;
 744         } else {
 745                 stopmode = 1;
 746         }
 747
 748         /* end_capture */
 749         /* when: 0 =  end of GOP  1 = NOW!, type: 0 = mpeg, subtype: 3 = video+audio */
 750         ivtv_vapi(itv, CX2341X_ENC_STOP_CAPTURE, 3, stopmode, cap_type, s->subtype);
 751
 752         then = jiffies;
 753
 754         if (!test_bit(IVTV_F_S_PASSTHROUGH, &s->s_flags)) {
 755                 if (s->type == IVTV_ENC_STREAM_TYPE_MPG && gop_end) {
 756                         /* only run these if we're shutting down the last cap */
 757                         unsigned long duration;
 758
 759                         then = jiffies;
 760                         add_wait_queue(&itv->cap_w, &wait);
 761
 762                         set_current_state(TASK_INTERRUPTIBLE);
 763
 764                         /* wait 2s for EOS interrupt */
 765                         while (!test_bit(IVTV_F_I_EOS, &itv->i_flags) &&
 766                                 jiffies < then + msecs_to_jiffies (2000)) {
 767                                 schedule_timeout(msecs_to_jiffies(10));
 768                         }
 769
 770                         /* To convert jiffies to ms, we must multiply by 1000
 771                          * and divide by HZ.  To avoid runtime division, we
 772                          * convert this to multiplication by 1000/HZ.
 773                          * Since integer division truncates, we get the best
 774                          * accuracy if we do a rounding calculation of the constant.
 775                          * Think of the case where HZ is 1024.
 776                          */
 777                         duration = ((1000 + HZ / 2) / HZ) * (jiffies - then);
 778
 779                         if (!test_bit(IVTV_F_I_EOS, &itv->i_flags)) {
 780                                 IVTV_DEBUG_WARN("%s: EOS interrupt not received! stopping anyway.\n", s->name);
 781                                 IVTV_DEBUG_WARN("%s: waited %lu ms.\n", s->name, duration);
 782                         } else {
 783                                 IVTV_DEBUG_INFO("%s: EOS took %lu ms to occur.\n", s->name, duration);
 784                         }
 785                         set_current_state(TASK_RUNNING);
 786                         remove_wait_queue(&itv->cap_w, &wait);
 787                 }
 788
 789                 then = jiffies;
 790
 791                 /* Handle any pending interrupts */
 792                 ivtv_msleep_timeout(100, 1);
 793         }
 794
 795         atomic_dec(&itv->capturing);
 796
 797         /* Clear capture and no-read bits */
 798         clear_bit(IVTV_F_S_STREAMING, &s->s_flags);
 799
 800         if (s->type == IVTV_ENC_STREAM_TYPE_VBI)
 801                 ivtv_set_irq_mask(itv, IVTV_IRQ_ENC_VBI_CAP);
 802
 803         if (atomic_read(&itv->capturing) > 0) {
 804                 return 0;
 805         }
 806
 807         /* Set the following Interrupt mask bits for capture */
 808         ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE);
 809         del_timer(&itv->dma_timer);
 810
 811         /* event notification (off) */
 812         if (test_and_clear_bit(IVTV_F_I_DIG_RST, &itv->i_flags)) {
 813                 /* type: 0 = refresh */
 814                 /* on/off: 0 = off, intr: 0x10000000, mbox_id: -1: none */
 815                 ivtv_vapi(itv, CX2341X_ENC_SET_EVENT_NOTIFICATION, 4, 0, 0, IVTV_IRQ_ENC_VIM_RST, -1);
 816                 ivtv_set_irq_mask(itv, IVTV_IRQ_ENC_VIM_RST);
 817         }
 818
 819         wake_up(&s->waitq);
 820
 821         return 0;
 822 }
 823
 824 int ivtv_stop_v4l2_decode_stream(struct ivtv_stream *s, int flags, u64 pts)
 825 {
 826         struct ivtv *itv = s->itv;
 827
 828         if (s->v4l2dev == NULL)
 829                 return -EINVAL;
 830
 831         if (s->type != IVTV_DEC_STREAM_TYPE_YUV && s->type != IVTV_DEC_STREAM_TYPE_MPG)
 832                 return -EINVAL;
 833
 834         if (!test_bit(IVTV_F_S_STREAMING, &s->s_flags))
 835                 return 0;
 836
 837         IVTV_DEBUG_INFO("Stop Decode at %llu, flags: %x\n", (unsigned long long)pts, flags);
 838
 839         /* Stop Decoder */
 840         if (!(flags & VIDEO_CMD_STOP_IMMEDIATELY) || pts) {
 841                 u32 tmp = 0;
 842
 843                 /* Wait until the decoder is no longer running */
 844                 if (pts) {
 845                         ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3,
 846                                 0, (u32)(pts & 0xffffffff), (u32)(pts >> 32));
 847                 }
 848                 while (1) {
 849                         u32 data[CX2341X_MBOX_MAX_DATA];
 850                         ivtv_vapi_result(itv, data, CX2341X_DEC_GET_XFER_INFO, 0);
 851                         if (s->q_full.buffers + s->q_dma.buffers == 0) {
 852                                 if (tmp == data[3])
 853                                         break;
 854                                 tmp = data[3];
 855                         }
 856                         if (ivtv_msleep_timeout(100, 1))
 857                                 break;
 858                 }
 859         }
 860         ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3, flags & VIDEO_CMD_STOP_TO_BLACK, 0, 0);
 861
 862         /* turn off notification of dual/stereo mode change */
 863         ivtv_vapi(itv, CX2341X_DEC_SET_EVENT_NOTIFICATION, 4, 0, 0, IVTV_IRQ_DEC_AUD_MODE_CHG, -1);
 864
 865         ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_DECODE);
 866         del_timer(&itv->dma_timer);
 867
 868         clear_bit(IVTV_F_S_NEEDS_DATA, &s->s_flags);
 869         clear_bit(IVTV_F_S_STREAMING, &s->s_flags);
 870         ivtv_flush_queues(s);
 871
 872         /* decrement decoding */
 873         atomic_dec(&itv->decoding);
 874
 875         set_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags);
 876         wake_up(&itv->event_waitq);
 877
 878         /* wake up wait queues */
 879         wake_up(&s->waitq);
 880
 881         return 0;
 882 }
 883
 884 int ivtv_passthrough_mode(struct ivtv *itv, int enable)
 885 {
 886         struct ivtv_stream *yuv_stream = &itv->streams[IVTV_ENC_STREAM_TYPE_YUV];
 887         struct ivtv_stream *dec_stream = &itv->streams[IVTV_DEC_STREAM_TYPE_YUV];
 888
 889         if (yuv_stream->v4l2dev == NULL || dec_stream->v4l2dev == NULL)
 890                 return -EINVAL;
 891
 892         IVTV_DEBUG_INFO("ivtv ioctl: Select passthrough mode\n");
 893
 894         /* Prevent others from starting/stopping streams while we
 895            initiate/terminate passthrough mode */
 896         if (enable) {
 897                 if (itv->output_mode == OUT_PASSTHROUGH) {
 898                         return 0;
 899                 }
 900                 if (ivtv_set_output_mode(itv, OUT_PASSTHROUGH) != OUT_PASSTHROUGH)
 901                         return -EBUSY;
 902
 903                 /* Fully initialize stream, and then unflag init */
 904                 set_bit(IVTV_F_S_PASSTHROUGH, &dec_stream->s_flags);
 905                 set_bit(IVTV_F_S_STREAMING, &dec_stream->s_flags);
 906
 907                 /* Setup YUV Decoder */
 908                 ivtv_setup_v4l2_decode_stream(dec_stream);
 909
 910                 /* Start Decoder */
 911                 ivtv_vapi(itv, CX2341X_DEC_START_PLAYBACK, 2, 0, 1);
 912                 atomic_inc(&itv->decoding);
 913
 914                 /* Setup capture if not already done */
 915                 if (atomic_read(&itv->capturing) == 0) {
 916                         cx2341x_update(itv, ivtv_api_func, NULL, &itv->params);
 917                 }
 918
 919                 /* Start Passthrough Mode */
 920                 ivtv_vapi(itv, CX2341X_ENC_START_CAPTURE, 2, 2, 11);
 921                 atomic_inc(&itv->capturing);
 922                 return 0;
 923         }
 924
 925         if (itv->output_mode != OUT_PASSTHROUGH)
 926                 return 0;
 927
 928         /* Stop Passthrough Mode */
 929         ivtv_vapi(itv, CX2341X_ENC_STOP_CAPTURE, 3, 1, 2, 11);
 930         ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3, 1, 0, 0);
 931
 932         atomic_dec(&itv->capturing);
 933         atomic_dec(&itv->decoding);
 934         clear_bit(IVTV_F_S_PASSTHROUGH, &dec_stream->s_flags);
 935         clear_bit(IVTV_F_S_STREAMING, &dec_stream->s_flags);
 936         itv->output_mode = OUT_NONE;
 937
 938         return 0;
 939 }