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