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