drivers/media/video/ivtv/ivtv-streams.c

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