err.no 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 struct file_operations ivtv_v4l2_enc_fops = {
  47       .owner = THIS_MODULE,
  48       .read = ivtv_v4l2_read,
  49       .write = ivtv_v4l2_write,
  50       .open = ivtv_v4l2_open,
  51       .ioctl = ivtv_v4l2_ioctl,
  52       .release = ivtv_v4l2_close,
  53       .poll = ivtv_v4l2_enc_poll,
  54 };
  55
  56 static struct file_operations ivtv_v4l2_dec_fops = {
  57       .owner = THIS_MODULE,
  58       .read = ivtv_v4l2_read,
  59       .write = ivtv_v4l2_write,
  60       .open = ivtv_v4l2_open,
  61       .ioctl = ivtv_v4l2_ioctl,
  62       .release = ivtv_v4l2_close,
  63       .poll = ivtv_v4l2_dec_poll,
  64 };
  65
  66 #define IVTV_V4L2_DEC_MPG_OFFSET  16    /* offset from 0 to register decoder mpg v4l2 minors on */
  67 #define IVTV_V4L2_ENC_PCM_OFFSET  24    /* offset from 0 to register pcm v4l2 minors on */
  68 #define IVTV_V4L2_ENC_YUV_OFFSET  32    /* offset from 0 to register yuv v4l2 minors on */
  69 #define IVTV_V4L2_DEC_YUV_OFFSET  48    /* offset from 0 to register decoder yuv v4l2 minors on */
  70 #define IVTV_V4L2_DEC_VBI_OFFSET   8    /* offset from 0 to register decoder vbi input v4l2 minors on */
  71 #define IVTV_V4L2_DEC_VOUT_OFFSET 16    /* offset from 0 to register vbi output v4l2 minors on */
  72
  73 static struct {
  74         const char *name;
  75         int vfl_type;
  76         int minor_offset;
  77         int dma, pio;
  78         enum v4l2_buf_type buf_type;
  79         struct file_operations *fops;
  80 } ivtv_stream_info[] = {
  81         {       /* IVTV_ENC_STREAM_TYPE_MPG */
  82                 "encoder MPG",
  83                 VFL_TYPE_GRABBER, 0,
  84                 PCI_DMA_FROMDEVICE, 0, V4L2_BUF_TYPE_VIDEO_CAPTURE,
  85                 &ivtv_v4l2_enc_fops
  86         },
  87         {       /* IVTV_ENC_STREAM_TYPE_YUV */
  88                 "encoder YUV",
  89                 VFL_TYPE_GRABBER, IVTV_V4L2_ENC_YUV_OFFSET,
  90                 PCI_DMA_FROMDEVICE, 0, V4L2_BUF_TYPE_VIDEO_CAPTURE,
  91                 &ivtv_v4l2_enc_fops
  92         },
  93         {       /* IVTV_ENC_STREAM_TYPE_VBI */
  94                 "encoder VBI",
  95                 VFL_TYPE_VBI, 0,
  96                 PCI_DMA_FROMDEVICE, 0, V4L2_BUF_TYPE_VBI_CAPTURE,
  97                 &ivtv_v4l2_enc_fops
  98         },
  99         {       /* IVTV_ENC_STREAM_TYPE_PCM */
 100                 "encoder PCM",
 101                 VFL_TYPE_GRABBER, IVTV_V4L2_ENC_PCM_OFFSET,
 102                 PCI_DMA_FROMDEVICE, 0, V4L2_BUF_TYPE_PRIVATE,
 103                 &ivtv_v4l2_enc_fops
 104         },
 105         {       /* IVTV_ENC_STREAM_TYPE_RAD */
 106                 "encoder radio",
 107                 VFL_TYPE_RADIO, 0,
 108                 PCI_DMA_NONE, 1, V4L2_BUF_TYPE_PRIVATE,
 109                 &ivtv_v4l2_enc_fops
 110         },
 111         {       /* IVTV_DEC_STREAM_TYPE_MPG */
 112                 "decoder MPG",
 113                 VFL_TYPE_GRABBER, IVTV_V4L2_DEC_MPG_OFFSET,
 114                 PCI_DMA_TODEVICE, 0, V4L2_BUF_TYPE_VIDEO_OUTPUT,
 115                 &ivtv_v4l2_dec_fops
 116         },
 117         {       /* IVTV_DEC_STREAM_TYPE_VBI */
 118                 "decoder VBI",
 119                 VFL_TYPE_VBI, IVTV_V4L2_DEC_VBI_OFFSET,
 120                 PCI_DMA_NONE, 1, V4L2_BUF_TYPE_VBI_CAPTURE,
 121                 &ivtv_v4l2_enc_fops
 122         },
 123         {       /* IVTV_DEC_STREAM_TYPE_VOUT */
 124                 "decoder VOUT",
 125                 VFL_TYPE_VBI, IVTV_V4L2_DEC_VOUT_OFFSET,
 126                 PCI_DMA_NONE, 1, V4L2_BUF_TYPE_VBI_OUTPUT,
 127                 &ivtv_v4l2_dec_fops
 128         },
 129         {       /* IVTV_DEC_STREAM_TYPE_YUV */
 130                 "decoder YUV",
 131                 VFL_TYPE_GRABBER, IVTV_V4L2_DEC_YUV_OFFSET,
 132                 PCI_DMA_TODEVICE, 0, V4L2_BUF_TYPE_VIDEO_OUTPUT,
 133                 &ivtv_v4l2_dec_fops
 134         }
 135 };
 136
 137 static void ivtv_stream_init(struct ivtv *itv, int type)
 138 {
 139         struct ivtv_stream *s = &itv->streams[type];
 140         struct video_device *dev = s->v4l2dev;
 141
 142         /* we need to keep v4l2dev, so restore it afterwards */
 143         memset(s, 0, sizeof(*s));
 144         s->v4l2dev = dev;
 145
 146         /* initialize ivtv_stream fields */
 147         s->itv = itv;
 148         s->type = type;
 149         s->name = ivtv_stream_info[type].name;
 150
 151         if (ivtv_stream_info[type].pio)
 152                 s->dma = PCI_DMA_NONE;
 153         else
 154                 s->dma = ivtv_stream_info[type].dma;
 155         s->buf_size = itv->stream_buf_size[type];
 156         if (s->buf_size)
 157                 s->buffers = (itv->options.kilobytes[type] * 1024 + s->buf_size - 1) / s->buf_size;
 158         spin_lock_init(&s->qlock);
 159         init_waitqueue_head(&s->waitq);
 160         s->id = -1;
 161         s->sg_handle = IVTV_DMA_UNMAPPED;
 162         ivtv_queue_init(&s->q_free);
 163         ivtv_queue_init(&s->q_full);
 164         ivtv_queue_init(&s->q_dma);
 165         ivtv_queue_init(&s->q_predma);
 166         ivtv_queue_init(&s->q_io);
 167 }
 168
 169 static int ivtv_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         int captype = 0, subtype = 0;
 445         int enable_passthrough = 0;
 446
 447         if (s->v4l2dev == NULL)
 448                 return -EINVAL;
 449
 450         IVTV_DEBUG_INFO("Start encoder stream %s\n", s->name);
 451
 452         switch (s->type) {
 453         case IVTV_ENC_STREAM_TYPE_MPG:
 454                 captype = 0;
 455                 subtype = 3;
 456
 457                 /* Stop Passthrough */
 458                 if (itv->output_mode == OUT_PASSTHROUGH) {
 459                         ivtv_passthrough_mode(itv, 0);
 460                         enable_passthrough = 1;
 461                 }
 462                 itv->mpg_data_received = itv->vbi_data_inserted = 0;
 463                 itv->dualwatch_jiffies = jiffies;
 464                 itv->dualwatch_stereo_mode = itv->params.audio_properties & 0x0300;
 465                 itv->search_pack_header = 0;
 466                 break;
 467
 468         case IVTV_ENC_STREAM_TYPE_YUV:
 469                 if (itv->output_mode == OUT_PASSTHROUGH) {
 470                         captype = 2;
 471                         subtype = 11;   /* video+audio+decoder */
 472                         break;
 473                 }
 474                 captype = 1;
 475                 subtype = 1;
 476                 break;
 477         case IVTV_ENC_STREAM_TYPE_PCM:
 478                 captype = 1;
 479                 subtype = 2;
 480                 break;
 481         case IVTV_ENC_STREAM_TYPE_VBI:
 482                 captype = 1;
 483                 subtype = 4;
 484
 485                 itv->vbi.frame = 0;
 486                 itv->vbi.inserted_frame = 0;
 487                 memset(itv->vbi.sliced_mpeg_size,
 488                         0, sizeof(itv->vbi.sliced_mpeg_size));
 489                 break;
 490         default:
 491                 return -EINVAL;
 492         }
 493         s->subtype = subtype;
 494         s->buffers_stolen = 0;
 495
 496         /* mute/unmute video */
 497         ivtv_vapi(itv, CX2341X_ENC_MUTE_VIDEO, 1,
 498                 test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ? 0x00808001 : 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, &itv->params);
 557         }
 558
 559         /* Vsync Setup */
 560         if (itv->has_cx23415 && !test_and_set_bit(IVTV_F_I_DIG_RST, &itv->i_flags)) {
 561                 /* event notification (on) */
 562                 ivtv_vapi(itv, CX2341X_ENC_SET_EVENT_NOTIFICATION, 4, 0, 1, IVTV_IRQ_ENC_VIM_RST, -1);
 563                 ivtv_clear_irq_mask(itv, IVTV_IRQ_ENC_VIM_RST);
 564         }
 565
 566         if (atomic_read(&itv->capturing) == 0) {
 567                 /* Clear all Pending Interrupts */
 568                 ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE);
 569
 570                 clear_bit(IVTV_F_I_EOS, &itv->i_flags);
 571
 572                 /* Initialize Digitizer for Capture */
 573                 itv->video_dec_func(itv, VIDIOC_STREAMOFF, 0);
 574                 ivtv_msleep_timeout(300, 1);
 575                 ivtv_vapi(itv, CX2341X_ENC_INITIALIZE_INPUT, 0);
 576                 itv->video_dec_func(itv, VIDIOC_STREAMON, 0);
 577         }
 578
 579         /* begin_capture */
 580         if (ivtv_vapi(itv, CX2341X_ENC_START_CAPTURE, 2, captype, subtype))
 581         {
 582                 IVTV_DEBUG_WARN( "Error starting capture!\n");
 583                 return -EINVAL;
 584         }
 585
 586         /* Start Passthrough */
 587         if (enable_passthrough) {
 588                 ivtv_passthrough_mode(itv, 1);
 589         }
 590
 591         if (s->type == IVTV_ENC_STREAM_TYPE_VBI)
 592                 ivtv_clear_irq_mask(itv, IVTV_IRQ_ENC_VBI_CAP);
 593         else
 594                 ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE);
 595
 596         /* you're live! sit back and await interrupts :) */
 597         atomic_inc(&itv->capturing);
 598         return 0;
 599 }
 600
 601 static int ivtv_setup_v4l2_decode_stream(struct ivtv_stream *s)
 602 {
 603         u32 data[CX2341X_MBOX_MAX_DATA];
 604         struct ivtv *itv = s->itv;
 605         int datatype;
 606
 607         if (s->v4l2dev == NULL)
 608                 return -EINVAL;
 609
 610         IVTV_DEBUG_INFO("Setting some initial decoder settings\n");
 611
 612         /* set audio mode to left/stereo  for dual/stereo mode. */
 613         ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode);
 614
 615         /* set number of internal decoder buffers */
 616         ivtv_vapi(itv, CX2341X_DEC_SET_DISPLAY_BUFFERS, 1, 0);
 617
 618         /* prebuffering */
 619         ivtv_vapi(itv, CX2341X_DEC_SET_PREBUFFERING, 1, 1);
 620
 621         /* extract from user packets */
 622         ivtv_vapi_result(itv, data, CX2341X_DEC_EXTRACT_VBI, 1, 1);
 623         itv->vbi.dec_start = data[0];
 624
 625         IVTV_DEBUG_INFO("Decoder VBI RE-Insert start 0x%08x size 0x%08x\n",
 626                 itv->vbi.dec_start, data[1]);
 627
 628         /* set decoder source settings */
 629         /* Data type: 0 = mpeg from host,
 630            1 = yuv from encoder,
 631            2 = yuv_from_host */
 632         switch (s->type) {
 633         case IVTV_DEC_STREAM_TYPE_YUV:
 634                 datatype = itv->output_mode == OUT_PASSTHROUGH ? 1 : 2;
 635                 IVTV_DEBUG_INFO("Setup DEC YUV Stream data[0] = %d\n", datatype);
 636                 break;
 637         case IVTV_DEC_STREAM_TYPE_MPG:
 638         default:
 639                 datatype = 0;
 640                 break;
 641         }
 642         if (ivtv_vapi(itv, CX2341X_DEC_SET_DECODER_SOURCE, 4, datatype,
 643                         itv->params.width, itv->params.height, itv->params.audio_properties)) {
 644                 IVTV_DEBUG_WARN("Couldn't initialize decoder source\n");
 645         }
 646         return 0;
 647 }
 648
 649 int ivtv_start_v4l2_decode_stream(struct ivtv_stream *s, int gop_offset)
 650 {
 651         struct ivtv *itv = s->itv;
 652
 653         if (s->v4l2dev == NULL)
 654                 return -EINVAL;
 655
 656         if (test_and_set_bit(IVTV_F_S_STREAMING, &s->s_flags))
 657                 return 0;       /* already started */
 658
 659         IVTV_DEBUG_INFO("Starting decode stream %s (gop_offset %d)\n", s->name, gop_offset);
 660
 661         /* Clear Streamoff */
 662         if (s->type == IVTV_DEC_STREAM_TYPE_YUV) {
 663                 /* Initialize Decoder */
 664                 /* Reprogram Decoder YUV Buffers for YUV */
 665                 write_reg(yuv_offset[0] >> 4, 0x82c);
 666                 write_reg((yuv_offset[0] + IVTV_YUV_BUFFER_UV_OFFSET) >> 4, 0x830);
 667                 write_reg(yuv_offset[0] >> 4, 0x834);
 668                 write_reg((yuv_offset[0] + IVTV_YUV_BUFFER_UV_OFFSET) >> 4, 0x838);
 669
 670                 write_reg_sync(0x00000000 | (0x0c << 16) | (0x0b << 8), 0x2d24);
 671
 672                 write_reg_sync(0x00108080, 0x2898);
 673                 /* Enable YUV decoder output */
 674                 write_reg_sync(0x01, IVTV_REG_VDM);
 675         }
 676
 677         ivtv_setup_v4l2_decode_stream(s);
 678
 679         /* set dma size to 65536 bytes */
 680         ivtv_vapi(itv, CX2341X_DEC_SET_DMA_BLOCK_SIZE, 1, 65536);
 681
 682         clear_bit(IVTV_F_S_STREAMOFF, &s->s_flags);
 683
 684         /* Zero out decoder counters */
 685         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[0]);
 686         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[1]);
 687         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[2]);
 688         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[3]);
 689         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[0]);
 690         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[1]);
 691         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[2]);
 692         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[3]);
 693
 694         /* turn on notification of dual/stereo mode change */
 695         ivtv_vapi(itv, CX2341X_DEC_SET_EVENT_NOTIFICATION, 4, 0, 1, IVTV_IRQ_DEC_AUD_MODE_CHG, -1);
 696
 697         /* start playback */
 698         ivtv_vapi(itv, CX2341X_DEC_START_PLAYBACK, 2, gop_offset, 0);
 699
 700         /* Clear the following Interrupt mask bits for decoding */
 701         ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_DECODE);
 702         IVTV_DEBUG_IRQ("IRQ Mask is now: 0x%08x\n", itv->irqmask);
 703
 704         /* you're live! sit back and await interrupts :) */
 705         atomic_inc(&itv->decoding);
 706         return 0;
 707 }
 708
 709 void ivtv_stop_all_captures(struct ivtv *itv)
 710 {
 711         int i;
 712
 713         for (i = IVTV_MAX_STREAMS - 1; i >= 0; i--) {
 714                 struct ivtv_stream *s = &itv->streams[i];
 715
 716                 if (s->v4l2dev == NULL)
 717                         continue;
 718                 if (test_bit(IVTV_F_S_STREAMING, &s->s_flags)) {
 719                         ivtv_stop_v4l2_encode_stream(s, 0);
 720                 }
 721         }
 722 }
 723
 724 int ivtv_stop_v4l2_encode_stream(struct ivtv_stream *s, int gop_end)
 725 {
 726         struct ivtv *itv = s->itv;
 727         DECLARE_WAITQUEUE(wait, current);
 728         int cap_type;
 729         int stopmode;
 730
 731         if (s->v4l2dev == NULL)
 732                 return -EINVAL;
 733
 734         /* This function assumes that you are allowed to stop the capture
 735            and that we are actually capturing */
 736
 737         IVTV_DEBUG_INFO("Stop Capture\n");
 738
 739         if (s->type == IVTV_DEC_STREAM_TYPE_VOUT)
 740                 return 0;
 741         if (atomic_read(&itv->capturing) == 0)
 742                 return 0;
 743
 744         switch (s->type) {
 745         case IVTV_ENC_STREAM_TYPE_YUV:
 746                 cap_type = 1;
 747                 break;
 748         case IVTV_ENC_STREAM_TYPE_PCM:
 749                 cap_type = 1;
 750                 break;
 751         case IVTV_ENC_STREAM_TYPE_VBI:
 752                 cap_type = 1;
 753                 break;
 754         case IVTV_ENC_STREAM_TYPE_MPG:
 755         default:
 756                 cap_type = 0;
 757                 break;
 758         }
 759
 760         /* Stop Capture Mode */
 761         if (s->type == IVTV_ENC_STREAM_TYPE_MPG && gop_end) {
 762                 stopmode = 0;
 763         } else {
 764                 stopmode = 1;
 765         }
 766
 767         /* end_capture */
 768         /* when: 0 =  end of GOP  1 = NOW!, type: 0 = mpeg, subtype: 3 = video+audio */
 769         ivtv_vapi(itv, CX2341X_ENC_STOP_CAPTURE, 3, stopmode, cap_type, s->subtype);
 770
 771         if (!test_bit(IVTV_F_S_PASSTHROUGH, &s->s_flags)) {
 772                 if (s->type == IVTV_ENC_STREAM_TYPE_MPG && gop_end) {
 773                         /* only run these if we're shutting down the last cap */
 774                         unsigned long duration;
 775                         unsigned long then = jiffies;
 776
 777                         add_wait_queue(&itv->eos_waitq, &wait);
 778
 779                         set_current_state(TASK_INTERRUPTIBLE);
 780
 781                         /* wait 2s for EOS interrupt */
 782                         while (!test_bit(IVTV_F_I_EOS, &itv->i_flags) &&
 783                                 jiffies < then + msecs_to_jiffies (2000)) {
 784                                 schedule_timeout(msecs_to_jiffies(10));
 785                         }
 786
 787                         /* To convert jiffies to ms, we must multiply by 1000
 788                          * and divide by HZ.  To avoid runtime division, we
 789                          * convert this to multiplication by 1000/HZ.
 790                          * Since integer division truncates, we get the best
 791                          * accuracy if we do a rounding calculation of the constant.
 792                          * Think of the case where HZ is 1024.
 793                          */
 794                         duration = ((1000 + HZ / 2) / HZ) * (jiffies - then);
 795
 796                         if (!test_bit(IVTV_F_I_EOS, &itv->i_flags)) {
 797                                 IVTV_DEBUG_WARN("%s: EOS interrupt not received! stopping anyway.\n", s->name);
 798                                 IVTV_DEBUG_WARN("%s: waited %lu ms.\n", s->name, duration);
 799                         } else {
 800                                 IVTV_DEBUG_INFO("%s: EOS took %lu ms to occur.\n", s->name, duration);
 801                         }
 802                         set_current_state(TASK_RUNNING);
 803                         remove_wait_queue(&itv->eos_waitq, &wait);
 804                         set_bit(IVTV_F_S_STREAMOFF, &s->s_flags);
 805                 }
 806
 807                 /* Handle any pending interrupts */
 808                 ivtv_msleep_timeout(100, 1);
 809         }
 810
 811         atomic_dec(&itv->capturing);
 812
 813         /* Clear capture and no-read bits */
 814         clear_bit(IVTV_F_S_STREAMING, &s->s_flags);
 815
 816         if (s->type == IVTV_ENC_STREAM_TYPE_VBI)
 817                 ivtv_set_irq_mask(itv, IVTV_IRQ_ENC_VBI_CAP);
 818
 819         if (atomic_read(&itv->capturing) > 0) {
 820                 return 0;
 821         }
 822
 823         /* Set the following Interrupt mask bits for capture */
 824         ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE);
 825         del_timer(&itv->dma_timer);
 826
 827         /* event notification (off) */
 828         if (test_and_clear_bit(IVTV_F_I_DIG_RST, &itv->i_flags)) {
 829                 /* type: 0 = refresh */
 830                 /* on/off: 0 = off, intr: 0x10000000, mbox_id: -1: none */
 831                 ivtv_vapi(itv, CX2341X_ENC_SET_EVENT_NOTIFICATION, 4, 0, 0, IVTV_IRQ_ENC_VIM_RST, -1);
 832                 ivtv_set_irq_mask(itv, IVTV_IRQ_ENC_VIM_RST);
 833         }
 834
 835         wake_up(&s->waitq);
 836
 837         return 0;
 838 }
 839
 840 int ivtv_stop_v4l2_decode_stream(struct ivtv_stream *s, int flags, u64 pts)
 841 {
 842         struct ivtv *itv = s->itv;
 843
 844         if (s->v4l2dev == NULL)
 845                 return -EINVAL;
 846
 847         if (s->type != IVTV_DEC_STREAM_TYPE_YUV && s->type != IVTV_DEC_STREAM_TYPE_MPG)
 848                 return -EINVAL;
 849
 850         if (!test_bit(IVTV_F_S_STREAMING, &s->s_flags))
 851                 return 0;
 852
 853         IVTV_DEBUG_INFO("Stop Decode at %llu, flags: %x\n", (unsigned long long)pts, flags);
 854
 855         /* Stop Decoder */
 856         if (!(flags & VIDEO_CMD_STOP_IMMEDIATELY) || pts) {
 857                 u32 tmp = 0;
 858
 859                 /* Wait until the decoder is no longer running */
 860                 if (pts) {
 861                         ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3,
 862                                 0, (u32)(pts & 0xffffffff), (u32)(pts >> 32));
 863                 }
 864                 while (1) {
 865                         u32 data[CX2341X_MBOX_MAX_DATA];
 866                         ivtv_vapi_result(itv, data, CX2341X_DEC_GET_XFER_INFO, 0);
 867                         if (s->q_full.buffers + s->q_dma.buffers == 0) {
 868                                 if (tmp == data[3])
 869                                         break;
 870                                 tmp = data[3];
 871                         }
 872                         if (ivtv_msleep_timeout(100, 1))
 873                                 break;
 874                 }
 875         }
 876         ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3, flags & VIDEO_CMD_STOP_TO_BLACK, 0, 0);
 877
 878         /* turn off notification of dual/stereo mode change */
 879         ivtv_vapi(itv, CX2341X_DEC_SET_EVENT_NOTIFICATION, 4, 0, 0, IVTV_IRQ_DEC_AUD_MODE_CHG, -1);
 880
 881         ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_DECODE);
 882         del_timer(&itv->dma_timer);
 883
 884         clear_bit(IVTV_F_S_NEEDS_DATA, &s->s_flags);
 885         clear_bit(IVTV_F_S_STREAMING, &s->s_flags);
 886         ivtv_flush_queues(s);
 887
 888         /* decrement decoding */
 889         atomic_dec(&itv->decoding);
 890
 891         set_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags);
 892         wake_up(&itv->event_waitq);
 893
 894         /* wake up wait queues */
 895         wake_up(&s->waitq);
 896
 897         return 0;
 898 }
 899
 900 int ivtv_passthrough_mode(struct ivtv *itv, int enable)
 901 {
 902         struct ivtv_stream *yuv_stream = &itv->streams[IVTV_ENC_STREAM_TYPE_YUV];
 903         struct ivtv_stream *dec_stream = &itv->streams[IVTV_DEC_STREAM_TYPE_YUV];
 904
 905         if (yuv_stream->v4l2dev == NULL || dec_stream->v4l2dev == NULL)
 906                 return -EINVAL;
 907
 908         IVTV_DEBUG_INFO("ivtv ioctl: Select passthrough mode\n");
 909
 910         /* Prevent others from starting/stopping streams while we
 911            initiate/terminate passthrough mode */
 912         if (enable) {
 913                 if (itv->output_mode == OUT_PASSTHROUGH) {
 914                         return 0;
 915                 }
 916                 if (ivtv_set_output_mode(itv, OUT_PASSTHROUGH) != OUT_PASSTHROUGH)
 917                         return -EBUSY;
 918
 919                 /* Fully initialize stream, and then unflag init */
 920                 set_bit(IVTV_F_S_PASSTHROUGH, &dec_stream->s_flags);
 921                 set_bit(IVTV_F_S_STREAMING, &dec_stream->s_flags);
 922
 923                 /* Setup YUV Decoder */
 924                 ivtv_setup_v4l2_decode_stream(dec_stream);
 925
 926                 /* Start Decoder */
 927                 ivtv_vapi(itv, CX2341X_DEC_START_PLAYBACK, 2, 0, 1);
 928                 atomic_inc(&itv->decoding);
 929
 930                 /* Setup capture if not already done */
 931                 if (atomic_read(&itv->capturing) == 0) {
 932                         cx2341x_update(itv, ivtv_api_func, NULL, &itv->params);
 933                 }
 934
 935                 /* Start Passthrough Mode */
 936                 ivtv_vapi(itv, CX2341X_ENC_START_CAPTURE, 2, 2, 11);
 937                 atomic_inc(&itv->capturing);
 938                 return 0;
 939         }
 940
 941         if (itv->output_mode != OUT_PASSTHROUGH)
 942                 return 0;
 943
 944         /* Stop Passthrough Mode */
 945         ivtv_vapi(itv, CX2341X_ENC_STOP_CAPTURE, 3, 1, 2, 11);
 946         ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3, 1, 0, 0);
 947
 948         atomic_dec(&itv->capturing);
 949         atomic_dec(&itv->decoding);
 950         clear_bit(IVTV_F_S_PASSTHROUGH, &dec_stream->s_flags);
 951         clear_bit(IVTV_F_S_STREAMING, &dec_stream->s_flags);
 952         itv->output_mode = OUT_NONE;
 953
 954         return 0;
 955 }