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