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