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 const 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 const 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         const 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_prep_dev(struct ivtv *itv, int type)
 170 {
 171         struct ivtv_stream *s = &itv->streams[type];
 172         int minor_offset = ivtv_stream_info[type].minor_offset;
 173         int minor;
 174
 175         /* These four fields are always initialized. If v4l2dev == NULL, then
 176            this stream is not in use. In that case no other fields but these
 177            four can be used. */
 178         s->v4l2dev = NULL;
 179         s->itv = itv;
 180         s->type = type;
 181         s->name = ivtv_stream_info[type].name;
 182
 183         /* Check whether the radio is supported */
 184         if (type == IVTV_ENC_STREAM_TYPE_RAD && !(itv->v4l2_cap & V4L2_CAP_RADIO))
 185                 return 0;
 186         if (type >= IVTV_DEC_STREAM_TYPE_MPG && !(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
 187                 return 0;
 188
 189         /* card number + user defined offset + device offset */
 190         minor = itv->num + ivtv_first_minor + minor_offset;
 191
 192         /* User explicitly selected 0 buffers for these streams, so don't
 193            create them. */
 194         if (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         return 0;
 223 }
 224
 225 /* Initialize v4l2 variables and prepare v4l2 devices */
 226 int ivtv_streams_setup(struct ivtv *itv)
 227 {
 228         int type;
 229
 230         /* Setup V4L2 Devices */
 231         for (type = 0; type < IVTV_MAX_STREAMS; type++) {
 232                 /* Prepare device */
 233                 if (ivtv_prep_dev(itv, type))
 234                         break;
 235
 236                 if (itv->streams[type].v4l2dev == NULL)
 237                         continue;
 238
 239                 /* Allocate Stream */
 240                 if (ivtv_stream_alloc(&itv->streams[type]))
 241                         break;
 242         }
 243         if (type == IVTV_MAX_STREAMS)
 244                 return 0;
 245
 246         /* One or more streams could not be initialized. Clean 'em all up. */
 247         ivtv_streams_cleanup(itv);
 248         return -ENOMEM;
 249 }
 250
 251 static int ivtv_reg_dev(struct ivtv *itv, int type)
 252 {
 253         struct ivtv_stream *s = &itv->streams[type];
 254         int vfl_type = ivtv_stream_info[type].vfl_type;
 255         int minor;
 256
 257         if (s->v4l2dev == NULL)
 258                 return 0;
 259
 260         minor = s->v4l2dev->minor;
 261         /* Register device. First try the desired minor, then any free one. */
 262         if (video_register_device(s->v4l2dev, vfl_type, minor) &&
 263                         video_register_device(s->v4l2dev, vfl_type, -1)) {
 264                 IVTV_ERR("Couldn't register v4l2 device for %s minor %d\n",
 265                                 s->name, minor);
 266                 video_device_release(s->v4l2dev);
 267                 s->v4l2dev = NULL;
 268                 return -ENOMEM;
 269         }
 270
 271         switch (vfl_type) {
 272         case VFL_TYPE_GRABBER:
 273                 IVTV_INFO("Registered device video%d for %s (%d kB)\n",
 274                         s->v4l2dev->minor, s->name, itv->options.kilobytes[type]);
 275                 break;
 276         case VFL_TYPE_RADIO:
 277                 IVTV_INFO("Registered device radio%d for %s\n",
 278                         s->v4l2dev->minor - MINOR_VFL_TYPE_RADIO_MIN, s->name);
 279                 break;
 280         case VFL_TYPE_VBI:
 281                 if (itv->options.kilobytes[type])
 282                         IVTV_INFO("Registered device vbi%d for %s (%d kB)\n",
 283                                 s->v4l2dev->minor - MINOR_VFL_TYPE_VBI_MIN,
 284                                 s->name, itv->options.kilobytes[type]);
 285                 else
 286                         IVTV_INFO("Registered device vbi%d for %s\n",
 287                                 s->v4l2dev->minor - MINOR_VFL_TYPE_VBI_MIN, s->name);
 288                 break;
 289         }
 290         return 0;
 291 }
 292
 293 /* Register v4l2 devices */
 294 int ivtv_streams_register(struct ivtv *itv)
 295 {
 296         int type;
 297         int err = 0;
 298
 299         /* Register V4L2 devices */
 300         for (type = 0; type < IVTV_MAX_STREAMS; type++)
 301                 err |= ivtv_reg_dev(itv, type);
 302
 303         if (err == 0)
 304                 return 0;
 305
 306         /* One or more streams could not be initialized. Clean 'em all up. */
 307         ivtv_streams_cleanup(itv);
 308         return -ENOMEM;
 309 }
 310
 311 /* Unregister v4l2 devices */
 312 void ivtv_streams_cleanup(struct ivtv *itv)
 313 {
 314         int type;
 315
 316         /* Teardown all streams */
 317         for (type = 0; type < IVTV_MAX_STREAMS; type++) {
 318                 struct video_device *vdev = itv->streams[type].v4l2dev;
 319
 320                 itv->streams[type].v4l2dev = NULL;
 321                 if (vdev == NULL)
 322                         continue;
 323
 324                 ivtv_stream_free(&itv->streams[type]);
 325                 /* Unregister device */
 326                 video_unregister_device(vdev);
 327         }
 328 }
 329
 330 static void ivtv_vbi_setup(struct ivtv *itv)
 331 {
 332         int raw = itv->vbi.sliced_in->service_set == 0;
 333         u32 data[CX2341X_MBOX_MAX_DATA];
 334         int lines;
 335         int i;
 336
 337         /* Reset VBI */
 338         ivtv_vapi(itv, CX2341X_ENC_SET_VBI_LINE, 5, 0xffff , 0, 0, 0, 0);
 339
 340         /* setup VBI registers */
 341         itv->video_dec_func(itv, VIDIOC_S_FMT, &itv->vbi.in);
 342
 343         /* determine number of lines and total number of VBI bytes.
 344            A raw line takes 1443 bytes: 2 * 720 + 4 byte frame header - 1
 345            The '- 1' byte is probably an unused U or V byte. Or something...
 346            A sliced line takes 51 bytes: 4 byte frame header, 4 byte internal
 347            header, 42 data bytes + checksum (to be confirmed) */
 348         if (raw) {
 349                 lines = itv->vbi.count * 2;
 350         } else {
 351                 lines = itv->is_60hz ? 24 : 38;
 352                 if (itv->is_60hz && (itv->hw_flags & IVTV_HW_CX25840))
 353                         lines += 2;
 354         }
 355
 356         itv->vbi.enc_size = lines * (raw ? itv->vbi.raw_size : itv->vbi.sliced_size);
 357
 358         /* Note: sliced vs raw flag doesn't seem to have any effect
 359            TODO: check mode (0x02) value with older ivtv versions. */
 360         data[0] = raw | 0x02 | (0xbd << 8);
 361
 362         /* Every X number of frames a VBI interrupt arrives (frames as in 25 or 30 fps) */
 363         data[1] = 1;
 364         /* The VBI frames are stored in a ringbuffer with this size (with a VBI frame as unit) */
 365         data[2] = raw ? 4 : 8;
 366         /* The start/stop codes determine which VBI lines end up in the raw VBI data area.
 367            The codes are from table 24 in the saa7115 datasheet. Each raw/sliced/video line
 368            is framed with codes FF0000XX where XX is the SAV/EAV (Start/End of Active Video)
 369            code. These values for raw VBI are obtained from a driver disassembly. The sliced
 370            start/stop codes was deduced from this, but they do not appear in the driver.
 371            Other code pairs that I found are: 0x250E6249/0x13545454 and 0x25256262/0x38137F54.
 372            However, I have no idea what these values are for. */
 373         if (itv->hw_flags & IVTV_HW_CX25840) {
 374                 /* Setup VBI for the cx25840 digitizer */
 375                 if (raw) {
 376                         data[3] = 0x20602060;
 377                         data[4] = 0x30703070;
 378                 } else {
 379                         data[3] = 0xB0F0B0F0;
 380                         data[4] = 0xA0E0A0E0;
 381                 }
 382                 /* Lines per frame */
 383                 data[5] = lines;
 384                 /* bytes per line */
 385                 data[6] = (raw ? itv->vbi.raw_size : itv->vbi.sliced_size);
 386         } else {
 387                 /* Setup VBI for the saa7115 digitizer */
 388                 if (raw) {
 389                         data[3] = 0x25256262;
 390                         data[4] = 0x387F7F7F;
 391                 } else {
 392                         data[3] = 0xABABECEC;
 393                         data[4] = 0xB6F1F1F1;
 394                 }
 395                 /* Lines per frame */
 396                 data[5] = lines;
 397                 /* bytes per line */
 398                 data[6] = itv->vbi.enc_size / lines;
 399         }
 400
 401         IVTV_DEBUG_INFO(
 402                 "Setup VBI API header 0x%08x pkts %d buffs %d ln %d sz %d\n",
 403                         data[0], data[1], data[2], data[5], data[6]);
 404
 405         ivtv_api(itv, CX2341X_ENC_SET_VBI_CONFIG, 7, data);
 406
 407         /* returns the VBI encoder memory area. */
 408         itv->vbi.enc_start = data[2];
 409         itv->vbi.fpi = data[0];
 410         if (!itv->vbi.fpi)
 411                 itv->vbi.fpi = 1;
 412
 413         IVTV_DEBUG_INFO("Setup VBI start 0x%08x frames %d fpi %d\n",
 414                 itv->vbi.enc_start, data[1], itv->vbi.fpi);
 415
 416         /* select VBI lines.
 417            Note that the sliced argument seems to have no effect. */
 418         for (i = 2; i <= 24; i++) {
 419                 int valid;
 420
 421                 if (itv->is_60hz) {
 422                         valid = i >= 10 && i < 22;
 423                 } else {
 424                         valid = i >= 6 && i < 24;
 425                 }
 426                 ivtv_vapi(itv, CX2341X_ENC_SET_VBI_LINE, 5, i - 1,
 427                                 valid, 0 , 0, 0);
 428                 ivtv_vapi(itv, CX2341X_ENC_SET_VBI_LINE, 5, (i - 1) | 0x80000000,
 429                                 valid, 0, 0, 0);
 430         }
 431
 432         /* Remaining VBI questions:
 433            - Is it possible to select particular VBI lines only for inclusion in the MPEG
 434            stream? Currently you can only get the first X lines.
 435            - Is mixed raw and sliced VBI possible?
 436            - What's the meaning of the raw/sliced flag?
 437            - What's the meaning of params 2, 3 & 4 of the Select VBI command? */
 438 }
 439
 440 int ivtv_start_v4l2_encode_stream(struct ivtv_stream *s)
 441 {
 442         u32 data[CX2341X_MBOX_MAX_DATA];
 443         struct ivtv *itv = s->itv;
 444         struct cx2341x_mpeg_params *p = &itv->params;
 445         int captype = 0, subtype = 0;
 446         int enable_passthrough = 0;
 447
 448         if (s->v4l2dev == NULL)
 449                 return -EINVAL;
 450
 451         IVTV_DEBUG_INFO("Start encoder stream %s\n", s->name);
 452
 453         switch (s->type) {
 454         case IVTV_ENC_STREAM_TYPE_MPG:
 455                 captype = 0;
 456                 subtype = 3;
 457
 458                 /* Stop Passthrough */
 459                 if (itv->output_mode == OUT_PASSTHROUGH) {
 460                         ivtv_passthrough_mode(itv, 0);
 461                         enable_passthrough = 1;
 462                 }
 463                 itv->mpg_data_received = itv->vbi_data_inserted = 0;
 464                 itv->dualwatch_jiffies = jiffies;
 465                 itv->dualwatch_stereo_mode = p->audio_properties & 0x0300;
 466                 itv->search_pack_header = 0;
 467                 break;
 468
 469         case IVTV_ENC_STREAM_TYPE_YUV:
 470                 if (itv->output_mode == OUT_PASSTHROUGH) {
 471                         captype = 2;
 472                         subtype = 11;   /* video+audio+decoder */
 473                         break;
 474                 }
 475                 captype = 1;
 476                 subtype = 1;
 477                 break;
 478         case IVTV_ENC_STREAM_TYPE_PCM:
 479                 captype = 1;
 480                 subtype = 2;
 481                 break;
 482         case IVTV_ENC_STREAM_TYPE_VBI:
 483                 captype = 1;
 484                 subtype = 4;
 485
 486                 itv->vbi.frame = 0;
 487                 itv->vbi.inserted_frame = 0;
 488                 memset(itv->vbi.sliced_mpeg_size,
 489                         0, sizeof(itv->vbi.sliced_mpeg_size));
 490                 break;
 491         default:
 492                 return -EINVAL;
 493         }
 494         s->subtype = subtype;
 495         s->buffers_stolen = 0;
 496
 497         /* Clear Streamoff flags in case left from last capture */
 498         clear_bit(IVTV_F_S_STREAMOFF, &s->s_flags);
 499
 500         if (atomic_read(&itv->capturing) == 0) {
 501                 int digitizer;
 502
 503                 /* Always use frame based mode. Experiments have demonstrated that byte
 504                    stream based mode results in dropped frames and corruption. Not often,
 505                    but occasionally. Many thanks go to Leonard Orb who spent a lot of
 506                    effort and time trying to trace the cause of the drop outs. */
 507                 /* 1 frame per DMA */
 508                 /*ivtv_vapi(itv, CX2341X_ENC_SET_DMA_BLOCK_SIZE, 2, 128, 0); */
 509                 ivtv_vapi(itv, CX2341X_ENC_SET_DMA_BLOCK_SIZE, 2, 1, 1);
 510
 511                 /* Stuff from Windows, we don't know what it is */
 512                 ivtv_vapi(itv, CX2341X_ENC_SET_VERT_CROP_LINE, 1, 0);
 513                 /* According to the docs, this should be correct. However, this is
 514                    untested. I don't dare enable this without having tested it.
 515                    Only very few old cards actually have this hardware combination.
 516                 ivtv_vapi(itv, CX2341X_ENC_SET_VERT_CROP_LINE, 1,
 517                         ((itv->hw_flags & IVTV_HW_SAA7114) && itv->is_60hz) ? 10001 : 0);
 518                 */
 519                 ivtv_vapi(itv, CX2341X_ENC_MISC, 2, 3, !itv->has_cx23415);
 520                 ivtv_vapi(itv, CX2341X_ENC_MISC, 2, 8, 0);
 521                 ivtv_vapi(itv, CX2341X_ENC_MISC, 2, 4, 1);
 522                 ivtv_vapi(itv, CX2341X_ENC_MISC, 1, 12);
 523
 524                 /* assign placeholder */
 525                 ivtv_vapi(itv, CX2341X_ENC_SET_PLACEHOLDER, 12,
 526                         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
 527
 528                 if (itv->card->hw_all & (IVTV_HW_SAA7115 | IVTV_HW_SAA717X))
 529                     digitizer = 0xF1;
 530                 else if (itv->card->hw_all & IVTV_HW_SAA7114)
 531                     digitizer = 0xEF;
 532                 else /* cx25840 */
 533                     digitizer = 0x140;
 534
 535                 ivtv_vapi(itv, CX2341X_ENC_SET_NUM_VSYNC_LINES, 2, digitizer, digitizer);
 536
 537                 /* Setup VBI */
 538                 if (itv->v4l2_cap & V4L2_CAP_VBI_CAPTURE) {
 539                         ivtv_vbi_setup(itv);
 540                 }
 541
 542                 /* assign program index info. Mask 7: select I/P/B, Num_req: 400 max */
 543                 ivtv_vapi_result(itv, data, CX2341X_ENC_SET_PGM_INDEX_INFO, 2, 7, 400);
 544                 itv->pgm_info_offset = data[0];
 545                 itv->pgm_info_num = data[1];
 546                 itv->pgm_info_write_idx = 0;
 547                 itv->pgm_info_read_idx = 0;
 548
 549                 IVTV_DEBUG_INFO("PGM Index at 0x%08x with %d elements\n",
 550                                 itv->pgm_info_offset, itv->pgm_info_num);
 551
 552                 /* Setup API for Stream */
 553                 cx2341x_update(itv, ivtv_api_func, NULL, p);
 554
 555                 /* mute if capturing radio */
 556                 if (test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags))
 557                         ivtv_vapi(itv, CX2341X_ENC_MUTE_VIDEO, 1,
 558                                 1 | (p->video_mute_yuv << 8));
 559         }
 560
 561         /* Vsync Setup */
 562         if (itv->has_cx23415 && !test_and_set_bit(IVTV_F_I_DIG_RST, &itv->i_flags)) {
 563                 /* event notification (on) */
 564                 ivtv_vapi(itv, CX2341X_ENC_SET_EVENT_NOTIFICATION, 4, 0, 1, IVTV_IRQ_ENC_VIM_RST, -1);
 565                 ivtv_clear_irq_mask(itv, IVTV_IRQ_ENC_VIM_RST);
 566         }
 567
 568         if (atomic_read(&itv->capturing) == 0) {
 569                 /* Clear all Pending Interrupts */
 570                 ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE);
 571
 572                 clear_bit(IVTV_F_I_EOS, &itv->i_flags);
 573
 574                 /* Initialize Digitizer for Capture */
 575                 itv->video_dec_func(itv, VIDIOC_STREAMOFF, NULL);
 576                 ivtv_msleep_timeout(300, 1);
 577                 ivtv_vapi(itv, CX2341X_ENC_INITIALIZE_INPUT, 0);
 578                 itv->video_dec_func(itv, VIDIOC_STREAMON, NULL);
 579         }
 580
 581         /* begin_capture */
 582         if (ivtv_vapi(itv, CX2341X_ENC_START_CAPTURE, 2, captype, subtype))
 583         {
 584                 IVTV_DEBUG_WARN( "Error starting capture!\n");
 585                 return -EINVAL;
 586         }
 587
 588         /* Start Passthrough */
 589         if (enable_passthrough) {
 590                 ivtv_passthrough_mode(itv, 1);
 591         }
 592
 593         if (s->type == IVTV_ENC_STREAM_TYPE_VBI)
 594                 ivtv_clear_irq_mask(itv, IVTV_IRQ_ENC_VBI_CAP);
 595         else
 596                 ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE);
 597
 598         /* you're live! sit back and await interrupts :) */
 599         atomic_inc(&itv->capturing);
 600         return 0;
 601 }
 602
 603 static int ivtv_setup_v4l2_decode_stream(struct ivtv_stream *s)
 604 {
 605         u32 data[CX2341X_MBOX_MAX_DATA];
 606         struct ivtv *itv = s->itv;
 607         struct cx2341x_mpeg_params *p = &itv->params;
 608         int datatype;
 609
 610         if (s->v4l2dev == NULL)
 611                 return -EINVAL;
 612
 613         IVTV_DEBUG_INFO("Setting some initial decoder settings\n");
 614
 615         /* set audio mode to left/stereo  for dual/stereo mode. */
 616         ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode);
 617
 618         /* set number of internal decoder buffers */
 619         ivtv_vapi(itv, CX2341X_DEC_SET_DISPLAY_BUFFERS, 1, 0);
 620
 621         /* prebuffering */
 622         ivtv_vapi(itv, CX2341X_DEC_SET_PREBUFFERING, 1, 1);
 623
 624         /* extract from user packets */
 625         ivtv_vapi_result(itv, data, CX2341X_DEC_EXTRACT_VBI, 1, 1);
 626         itv->vbi.dec_start = data[0];
 627
 628         IVTV_DEBUG_INFO("Decoder VBI RE-Insert start 0x%08x size 0x%08x\n",
 629                 itv->vbi.dec_start, data[1]);
 630
 631         /* set decoder source settings */
 632         /* Data type: 0 = mpeg from host,
 633            1 = yuv from encoder,
 634            2 = yuv_from_host */
 635         switch (s->type) {
 636         case IVTV_DEC_STREAM_TYPE_YUV:
 637                 datatype = itv->output_mode == OUT_PASSTHROUGH ? 1 : 2;
 638                 IVTV_DEBUG_INFO("Setup DEC YUV Stream data[0] = %d\n", datatype);
 639                 break;
 640         case IVTV_DEC_STREAM_TYPE_MPG:
 641         default:
 642                 datatype = 0;
 643                 break;
 644         }
 645         if (ivtv_vapi(itv, CX2341X_DEC_SET_DECODER_SOURCE, 4, datatype,
 646                         p->width, p->height, p->audio_properties)) {
 647                 IVTV_DEBUG_WARN("Couldn't initialize decoder source\n");
 648         }
 649         return 0;
 650 }
 651
 652 int ivtv_start_v4l2_decode_stream(struct ivtv_stream *s, int gop_offset)
 653 {
 654         struct ivtv *itv = s->itv;
 655
 656         if (s->v4l2dev == NULL)
 657                 return -EINVAL;
 658
 659         if (test_and_set_bit(IVTV_F_S_STREAMING, &s->s_flags))
 660                 return 0;       /* already started */
 661
 662         IVTV_DEBUG_INFO("Starting decode stream %s (gop_offset %d)\n", s->name, gop_offset);
 663
 664         ivtv_setup_v4l2_decode_stream(s);
 665
 666         /* set dma size to 65536 bytes */
 667         ivtv_vapi(itv, CX2341X_DEC_SET_DMA_BLOCK_SIZE, 1, 65536);
 668
 669         /* Clear Streamoff */
 670         clear_bit(IVTV_F_S_STREAMOFF, &s->s_flags);
 671
 672         /* Zero out decoder counters */
 673         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[0]);
 674         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[1]);
 675         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[2]);
 676         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[3]);
 677         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[0]);
 678         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[1]);
 679         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[2]);
 680         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[3]);
 681
 682         /* turn on notification of dual/stereo mode change */
 683         ivtv_vapi(itv, CX2341X_DEC_SET_EVENT_NOTIFICATION, 4, 0, 1, IVTV_IRQ_DEC_AUD_MODE_CHG, -1);
 684
 685         /* start playback */
 686         ivtv_vapi(itv, CX2341X_DEC_START_PLAYBACK, 2, gop_offset, 0);
 687
 688         /* Clear the following Interrupt mask bits for decoding */
 689         ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_DECODE);
 690         IVTV_DEBUG_IRQ("IRQ Mask is now: 0x%08x\n", itv->irqmask);
 691
 692         /* you're live! sit back and await interrupts :) */
 693         atomic_inc(&itv->decoding);
 694         return 0;
 695 }
 696
 697 void ivtv_stop_all_captures(struct ivtv *itv)
 698 {
 699         int i;
 700
 701         for (i = IVTV_MAX_STREAMS - 1; i >= 0; i--) {
 702                 struct ivtv_stream *s = &itv->streams[i];
 703
 704                 if (s->v4l2dev == NULL)
 705                         continue;
 706                 if (test_bit(IVTV_F_S_STREAMING, &s->s_flags)) {
 707                         ivtv_stop_v4l2_encode_stream(s, 0);
 708                 }
 709         }
 710 }
 711
 712 int ivtv_stop_v4l2_encode_stream(struct ivtv_stream *s, int gop_end)
 713 {
 714         struct ivtv *itv = s->itv;
 715         DECLARE_WAITQUEUE(wait, current);
 716         int cap_type;
 717         int stopmode;
 718
 719         if (s->v4l2dev == NULL)
 720                 return -EINVAL;
 721
 722         /* This function assumes that you are allowed to stop the capture
 723            and that we are actually capturing */
 724
 725         IVTV_DEBUG_INFO("Stop Capture\n");
 726
 727         if (s->type == IVTV_DEC_STREAM_TYPE_VOUT)
 728                 return 0;
 729         if (atomic_read(&itv->capturing) == 0)
 730                 return 0;
 731
 732         switch (s->type) {
 733         case IVTV_ENC_STREAM_TYPE_YUV:
 734                 cap_type = 1;
 735                 break;
 736         case IVTV_ENC_STREAM_TYPE_PCM:
 737                 cap_type = 1;
 738                 break;
 739         case IVTV_ENC_STREAM_TYPE_VBI:
 740                 cap_type = 1;
 741                 break;
 742         case IVTV_ENC_STREAM_TYPE_MPG:
 743         default:
 744                 cap_type = 0;
 745                 break;
 746         }
 747
 748         /* Stop Capture Mode */
 749         if (s->type == IVTV_ENC_STREAM_TYPE_MPG && gop_end) {
 750                 stopmode = 0;
 751         } else {
 752                 stopmode = 1;
 753         }
 754
 755         /* end_capture */
 756         /* when: 0 =  end of GOP  1 = NOW!, type: 0 = mpeg, subtype: 3 = video+audio */
 757         ivtv_vapi(itv, CX2341X_ENC_STOP_CAPTURE, 3, stopmode, cap_type, s->subtype);
 758
 759         if (!test_bit(IVTV_F_S_PASSTHROUGH, &s->s_flags)) {
 760                 if (s->type == IVTV_ENC_STREAM_TYPE_MPG && gop_end) {
 761                         /* only run these if we're shutting down the last cap */
 762                         unsigned long duration;
 763                         unsigned long then = jiffies;
 764
 765                         add_wait_queue(&itv->eos_waitq, &wait);
 766
 767                         set_current_state(TASK_INTERRUPTIBLE);
 768
 769                         /* wait 2s for EOS interrupt */
 770                         while (!test_bit(IVTV_F_I_EOS, &itv->i_flags) &&
 771                                 time_before(jiffies,
 772                                             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->eos_waitq, &wait);
 793                         set_bit(IVTV_F_S_STREAMOFF, &s->s_flags);
 794                 }
 795
 796                 /* Handle any pending interrupts */
 797                 ivtv_msleep_timeout(100, 1);
 798         }
 799
 800         atomic_dec(&itv->capturing);
 801
 802         /* Clear capture and no-read bits */
 803         clear_bit(IVTV_F_S_STREAMING, &s->s_flags);
 804
 805         if (s->type == IVTV_ENC_STREAM_TYPE_VBI)
 806                 ivtv_set_irq_mask(itv, IVTV_IRQ_ENC_VBI_CAP);
 807
 808         if (atomic_read(&itv->capturing) > 0) {
 809                 return 0;
 810         }
 811
 812         /* Set the following Interrupt mask bits for capture */
 813         ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE);
 814         del_timer(&itv->dma_timer);
 815
 816         /* event notification (off) */
 817         if (test_and_clear_bit(IVTV_F_I_DIG_RST, &itv->i_flags)) {
 818                 /* type: 0 = refresh */
 819                 /* on/off: 0 = off, intr: 0x10000000, mbox_id: -1: none */
 820                 ivtv_vapi(itv, CX2341X_ENC_SET_EVENT_NOTIFICATION, 4, 0, 0, IVTV_IRQ_ENC_VIM_RST, -1);
 821                 ivtv_set_irq_mask(itv, IVTV_IRQ_ENC_VIM_RST);
 822         }
 823
 824         wake_up(&s->waitq);
 825
 826         return 0;
 827 }
 828
 829 int ivtv_stop_v4l2_decode_stream(struct ivtv_stream *s, int flags, u64 pts)
 830 {
 831         struct ivtv *itv = s->itv;
 832
 833         if (s->v4l2dev == NULL)
 834                 return -EINVAL;
 835
 836         if (s->type != IVTV_DEC_STREAM_TYPE_YUV && s->type != IVTV_DEC_STREAM_TYPE_MPG)
 837                 return -EINVAL;
 838
 839         if (!test_bit(IVTV_F_S_STREAMING, &s->s_flags))
 840                 return 0;
 841
 842         IVTV_DEBUG_INFO("Stop Decode at %llu, flags: %x\n", (unsigned long long)pts, flags);
 843
 844         /* Stop Decoder */
 845         if (!(flags & VIDEO_CMD_STOP_IMMEDIATELY) || pts) {
 846                 u32 tmp = 0;
 847
 848                 /* Wait until the decoder is no longer running */
 849                 if (pts) {
 850                         ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3,
 851                                 0, (u32)(pts & 0xffffffff), (u32)(pts >> 32));
 852                 }
 853                 while (1) {
 854                         u32 data[CX2341X_MBOX_MAX_DATA];
 855                         ivtv_vapi_result(itv, data, CX2341X_DEC_GET_XFER_INFO, 0);
 856                         if (s->q_full.buffers + s->q_dma.buffers == 0) {
 857                                 if (tmp == data[3])
 858                                         break;
 859                                 tmp = data[3];
 860                         }
 861                         if (ivtv_msleep_timeout(100, 1))
 862                                 break;
 863                 }
 864         }
 865         ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3, flags & VIDEO_CMD_STOP_TO_BLACK, 0, 0);
 866
 867         /* turn off notification of dual/stereo mode change */
 868         ivtv_vapi(itv, CX2341X_DEC_SET_EVENT_NOTIFICATION, 4, 0, 0, IVTV_IRQ_DEC_AUD_MODE_CHG, -1);
 869
 870         ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_DECODE);
 871         del_timer(&itv->dma_timer);
 872
 873         clear_bit(IVTV_F_S_NEEDS_DATA, &s->s_flags);
 874         clear_bit(IVTV_F_S_STREAMING, &s->s_flags);
 875         ivtv_flush_queues(s);
 876
 877         /* decrement decoding */
 878         atomic_dec(&itv->decoding);
 879
 880         set_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags);
 881         wake_up(&itv->event_waitq);
 882
 883         /* wake up wait queues */
 884         wake_up(&s->waitq);
 885
 886         return 0;
 887 }
 888
 889 int ivtv_passthrough_mode(struct ivtv *itv, int enable)
 890 {
 891         struct ivtv_stream *yuv_stream = &itv->streams[IVTV_ENC_STREAM_TYPE_YUV];
 892         struct ivtv_stream *dec_stream = &itv->streams[IVTV_DEC_STREAM_TYPE_YUV];
 893
 894         if (yuv_stream->v4l2dev == NULL || dec_stream->v4l2dev == NULL)
 895                 return -EINVAL;
 896
 897         IVTV_DEBUG_INFO("ivtv ioctl: Select passthrough mode\n");
 898
 899         /* Prevent others from starting/stopping streams while we
 900            initiate/terminate passthrough mode */
 901         if (enable) {
 902                 if (itv->output_mode == OUT_PASSTHROUGH) {
 903                         return 0;
 904                 }
 905                 if (ivtv_set_output_mode(itv, OUT_PASSTHROUGH) != OUT_PASSTHROUGH)
 906                         return -EBUSY;
 907
 908                 /* Fully initialize stream, and then unflag init */
 909                 set_bit(IVTV_F_S_PASSTHROUGH, &dec_stream->s_flags);
 910                 set_bit(IVTV_F_S_STREAMING, &dec_stream->s_flags);
 911
 912                 /* Setup YUV Decoder */
 913                 ivtv_setup_v4l2_decode_stream(dec_stream);
 914
 915                 /* Start Decoder */
 916                 ivtv_vapi(itv, CX2341X_DEC_START_PLAYBACK, 2, 0, 1);
 917                 atomic_inc(&itv->decoding);
 918
 919                 /* Setup capture if not already done */
 920                 if (atomic_read(&itv->capturing) == 0) {
 921                         cx2341x_update(itv, ivtv_api_func, NULL, &itv->params);
 922                 }
 923
 924                 /* Start Passthrough Mode */
 925                 ivtv_vapi(itv, CX2341X_ENC_START_CAPTURE, 2, 2, 11);
 926                 atomic_inc(&itv->capturing);
 927                 return 0;
 928         }
 929
 930         if (itv->output_mode != OUT_PASSTHROUGH)
 931                 return 0;
 932
 933         /* Stop Passthrough Mode */
 934         ivtv_vapi(itv, CX2341X_ENC_STOP_CAPTURE, 3, 1, 2, 11);
 935         ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3, 1, 0, 0);
 936
 937         atomic_dec(&itv->capturing);
 938         atomic_dec(&itv->decoding);
 939         clear_bit(IVTV_F_S_PASSTHROUGH, &dec_stream->s_flags);
 940         clear_bit(IVTV_F_S_STREAMING, &dec_stream->s_flags);
 941         itv->output_mode = OUT_NONE;
 942
 943         return 0;
 944 }