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