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