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 <[email protected]>
   5     Copyright (C) 2005-2007  Hans Verkuil <[email protected]>
   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 <[email protected]>
  30  *                      and Takeru KOMORIYA<[email protected]>
  31  *
  32  * AVerMedia M179 GPIO info by Chris Pinkham <[email protected]>
  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                 DMA_FROM_DEVICE, 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                 DMA_FROM_DEVICE, 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                 DMA_FROM_DEVICE, 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                 DMA_FROM_DEVICE, 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                 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                 DMA_TO_DEVICE, 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                 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                 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                 DMA_TO_DEVICE, 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->vdev.device_caps = ivtv_stream_info[type].v4l2_caps;
 180
 181         if (ivtv_stream_info[type].pio)
 182                 s->dma = 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 != 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         if (itv->osd_video_pbase && (type == IVTV_DEC_STREAM_TYPE_YUV ||
 303                                      type == IVTV_DEC_STREAM_TYPE_MPG)) {
 304                 s->vdev.device_caps |= V4L2_CAP_VIDEO_OUTPUT_OVERLAY;
 305                 itv->v4l2_cap |= V4L2_CAP_VIDEO_OUTPUT_OVERLAY;
 306         }
 307         video_set_drvdata(&s->vdev, s);
 308
 309         /* Register device. First try the desired minor, then any free one. */
 310         if (video_register_device_no_warn(&s->vdev, vfl_type, num)) {
 311                 IVTV_ERR("Couldn't register v4l2 device for %s (device node number %d)\n",
 312                                 s->name, num);
 313                 return -ENOMEM;
 314         }
 315         name = video_device_node_name(&s->vdev);
 316
 317         switch (vfl_type) {
 318         case VFL_TYPE_VIDEO:
 319                 IVTV_INFO("Registered device %s for %s (%d kB)\n",
 320                         name, s->name, itv->options.kilobytes[type]);
 321                 break;
 322         case VFL_TYPE_RADIO:
 323                 IVTV_INFO("Registered device %s for %s\n",
 324                         name, s->name);
 325                 break;
 326         case VFL_TYPE_VBI:
 327                 if (itv->options.kilobytes[type])
 328                         IVTV_INFO("Registered device %s for %s (%d kB)\n",
 329                                 name, s->name, itv->options.kilobytes[type]);
 330                 else
 331                         IVTV_INFO("Registered device %s for %s\n",
 332                                 name, s->name);
 333                 break;
 334         }
 335         return 0;
 336 }
 337
 338 /* Register v4l2 devices */
 339 int ivtv_streams_register(struct ivtv *itv)
 340 {
 341         int type;
 342         int err = 0;
 343
 344         /* Register V4L2 devices */
 345         for (type = 0; type < IVTV_MAX_STREAMS; type++)
 346                 err |= ivtv_reg_dev(itv, type);
 347
 348         if (err == 0)
 349                 return 0;
 350
 351         /* One or more streams could not be initialized. Clean 'em all up. */
 352         ivtv_streams_cleanup(itv);
 353         return -ENOMEM;
 354 }
 355
 356 /* Unregister v4l2 devices */
 357 void ivtv_streams_cleanup(struct ivtv *itv)
 358 {
 359         int type;
 360
 361         /* Teardown all streams */
 362         for (type = 0; type < IVTV_MAX_STREAMS; type++) {
 363                 struct video_device *vdev = &itv->streams[type].vdev;
 364
 365                 if (vdev->v4l2_dev == NULL)
 366                         continue;
 367
 368                 video_unregister_device(vdev);
 369                 ivtv_stream_free(&itv->streams[type]);
 370                 itv->streams[type].vdev.v4l2_dev = NULL;
 371         }
 372 }
 373
 374 static void ivtv_vbi_setup(struct ivtv *itv)
 375 {
 376         int raw = ivtv_raw_vbi(itv);
 377         u32 data[CX2341X_MBOX_MAX_DATA];
 378         int lines;
 379         int i;
 380
 381         /* Reset VBI */
 382         ivtv_vapi(itv, CX2341X_ENC_SET_VBI_LINE, 5, 0xffff , 0, 0, 0, 0);
 383
 384         /* setup VBI registers */
 385         if (raw)
 386                 v4l2_subdev_call(itv->sd_video, vbi, s_raw_fmt, &itv->vbi.in.fmt.vbi);
 387         else
 388                 v4l2_subdev_call(itv->sd_video, vbi, s_sliced_fmt, &itv->vbi.in.fmt.sliced);
 389
 390         /* determine number of lines and total number of VBI bytes.
 391            A raw line takes 1443 bytes: 2 * 720 + 4 byte frame header - 1
 392            The '- 1' byte is probably an unused U or V byte. Or something...
 393            A sliced line takes 51 bytes: 4 byte frame header, 4 byte internal
 394            header, 42 data bytes + checksum (to be confirmed) */
 395         if (raw) {
 396                 lines = itv->vbi.count * 2;
 397         } else {
 398                 lines = itv->is_60hz ? 24 : 38;
 399                 if (itv->is_60hz && (itv->hw_flags & IVTV_HW_CX25840))
 400                         lines += 2;
 401         }
 402
 403         itv->vbi.enc_size = lines * (raw ? itv->vbi.raw_size : itv->vbi.sliced_size);
 404
 405         /* Note: sliced vs raw flag doesn't seem to have any effect
 406            TODO: check mode (0x02) value with older ivtv versions. */
 407         data[0] = raw | 0x02 | (0xbd << 8);
 408
 409         /* Every X number of frames a VBI interrupt arrives (frames as in 25 or 30 fps) */
 410         data[1] = 1;
 411         /* The VBI frames are stored in a ringbuffer with this size (with a VBI frame as unit) */
 412         data[2] = raw ? 4 : 4 * (itv->vbi.raw_size / itv->vbi.enc_size);
 413         /* The start/stop codes determine which VBI lines end up in the raw VBI data area.
 414            The codes are from table 24 in the saa7115 datasheet. Each raw/sliced/video line
 415            is framed with codes FF0000XX where XX is the SAV/EAV (Start/End of Active Video)
 416            code. These values for raw VBI are obtained from a driver disassembly. The sliced
 417            start/stop codes was deduced from this, but they do not appear in the driver.
 418            Other code pairs that I found are: 0x250E6249/0x13545454 and 0x25256262/0x38137F54.
 419            However, I have no idea what these values are for. */
 420         if (itv->hw_flags & IVTV_HW_CX25840) {
 421                 /* Setup VBI for the cx25840 digitizer */
 422                 if (raw) {
 423                         data[3] = 0x20602060;
 424                         data[4] = 0x30703070;
 425                 } else {
 426                         data[3] = 0xB0F0B0F0;
 427                         data[4] = 0xA0E0A0E0;
 428                 }
 429                 /* Lines per frame */
 430                 data[5] = lines;
 431                 /* bytes per line */
 432                 data[6] = (raw ? itv->vbi.raw_size : itv->vbi.sliced_size);
 433         } else {
 434                 /* Setup VBI for the saa7115 digitizer */
 435                 if (raw) {
 436                         data[3] = 0x25256262;
 437                         data[4] = 0x387F7F7F;
 438                 } else {
 439                         data[3] = 0xABABECEC;
 440                         data[4] = 0xB6F1F1F1;
 441                 }
 442                 /* Lines per frame */
 443                 data[5] = lines;
 444                 /* bytes per line */
 445                 data[6] = itv->vbi.enc_size / lines;
 446         }
 447
 448         IVTV_DEBUG_INFO(
 449                 "Setup VBI API header 0x%08x pkts %d buffs %d ln %d sz %d\n",
 450                         data[0], data[1], data[2], data[5], data[6]);
 451
 452         ivtv_api(itv, CX2341X_ENC_SET_VBI_CONFIG, 7, data);
 453
 454         /* returns the VBI encoder memory area. */
 455         itv->vbi.enc_start = data[2];
 456         itv->vbi.fpi = data[0];
 457         if (!itv->vbi.fpi)
 458                 itv->vbi.fpi = 1;
 459
 460         IVTV_DEBUG_INFO("Setup VBI start 0x%08x frames %d fpi %d\n",
 461                 itv->vbi.enc_start, data[1], itv->vbi.fpi);
 462
 463         /* select VBI lines.
 464            Note that the sliced argument seems to have no effect. */
 465         for (i = 2; i <= 24; i++) {
 466                 int valid;
 467
 468                 if (itv->is_60hz) {
 469                         valid = i >= 10 && i < 22;
 470                 } else {
 471                         valid = i >= 6 && i < 24;
 472                 }
 473                 ivtv_vapi(itv, CX2341X_ENC_SET_VBI_LINE, 5, i - 1,
 474                                 valid, 0 , 0, 0);
 475                 ivtv_vapi(itv, CX2341X_ENC_SET_VBI_LINE, 5, (i - 1) | 0x80000000,
 476                                 valid, 0, 0, 0);
 477         }
 478
 479         /* Remaining VBI questions:
 480            - Is it possible to select particular VBI lines only for inclusion in the MPEG
 481            stream? Currently you can only get the first X lines.
 482            - Is mixed raw and sliced VBI possible?
 483            - What's the meaning of the raw/sliced flag?
 484            - What's the meaning of params 2, 3 & 4 of the Select VBI command? */
 485 }
 486
 487 int ivtv_start_v4l2_encode_stream(struct ivtv_stream *s)
 488 {
 489         u32 data[CX2341X_MBOX_MAX_DATA];
 490         struct ivtv *itv = s->itv;
 491         int captype = 0, subtype = 0;
 492         int enable_passthrough = 0;
 493
 494         if (s->vdev.v4l2_dev == NULL)
 495                 return -EINVAL;
 496
 497         IVTV_DEBUG_INFO("Start encoder stream %s\n", s->name);
 498
 499         switch (s->type) {
 500         case IVTV_ENC_STREAM_TYPE_MPG:
 501                 captype = 0;
 502                 subtype = 3;
 503
 504                 /* Stop Passthrough */
 505                 if (itv->output_mode == OUT_PASSTHROUGH) {
 506                         ivtv_passthrough_mode(itv, 0);
 507                         enable_passthrough = 1;
 508                 }
 509                 itv->mpg_data_received = itv->vbi_data_inserted = 0;
 510                 itv->dualwatch_jiffies = jiffies;
 511                 itv->dualwatch_stereo_mode = v4l2_ctrl_g_ctrl(itv->cxhdl.audio_mode);
 512                 itv->search_pack_header = 0;
 513                 break;
 514
 515         case IVTV_ENC_STREAM_TYPE_YUV:
 516                 if (itv->output_mode == OUT_PASSTHROUGH) {
 517                         captype = 2;
 518                         subtype = 11;   /* video+audio+decoder */
 519                         break;
 520                 }
 521                 captype = 1;
 522                 subtype = 1;
 523                 break;
 524         case IVTV_ENC_STREAM_TYPE_PCM:
 525                 captype = 1;
 526                 subtype = 2;
 527                 break;
 528         case IVTV_ENC_STREAM_TYPE_VBI:
 529                 captype = 1;
 530                 subtype = 4;
 531
 532                 itv->vbi.frame = 0;
 533                 itv->vbi.inserted_frame = 0;
 534                 memset(itv->vbi.sliced_mpeg_size,
 535                         0, sizeof(itv->vbi.sliced_mpeg_size));
 536                 break;
 537         default:
 538                 return -EINVAL;
 539         }
 540         s->subtype = subtype;
 541         s->buffers_stolen = 0;
 542
 543         /* Clear Streamoff flags in case left from last capture */
 544         clear_bit(IVTV_F_S_STREAMOFF, &s->s_flags);
 545
 546         if (atomic_read(&itv->capturing) == 0) {
 547                 int digitizer;
 548
 549                 /* Always use frame based mode. Experiments have demonstrated that byte
 550                    stream based mode results in dropped frames and corruption. Not often,
 551                    but occasionally. Many thanks go to Leonard Orb who spent a lot of
 552                    effort and time trying to trace the cause of the drop outs. */
 553                 /* 1 frame per DMA */
 554                 /*ivtv_vapi(itv, CX2341X_ENC_SET_DMA_BLOCK_SIZE, 2, 128, 0); */
 555                 ivtv_vapi(itv, CX2341X_ENC_SET_DMA_BLOCK_SIZE, 2, 1, 1);
 556
 557                 /* Stuff from Windows, we don't know what it is */
 558                 ivtv_vapi(itv, CX2341X_ENC_SET_VERT_CROP_LINE, 1, 0);
 559                 /* According to the docs, this should be correct. However, this is
 560                    untested. I don't dare enable this without having tested it.
 561                    Only very few old cards actually have this hardware combination.
 562                 ivtv_vapi(itv, CX2341X_ENC_SET_VERT_CROP_LINE, 1,
 563                         ((itv->hw_flags & IVTV_HW_SAA7114) && itv->is_60hz) ? 10001 : 0);
 564                 */
 565                 ivtv_vapi(itv, CX2341X_ENC_MISC, 2, 3, !itv->has_cx23415);
 566                 ivtv_vapi(itv, CX2341X_ENC_MISC, 2, 8, 0);
 567                 ivtv_vapi(itv, CX2341X_ENC_MISC, 2, 4, 1);
 568                 ivtv_vapi(itv, CX2341X_ENC_MISC, 1, 12);
 569
 570                 /* assign placeholder */
 571                 ivtv_vapi(itv, CX2341X_ENC_SET_PLACEHOLDER, 12,
 572                         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
 573
 574                 if (itv->card->hw_all & (IVTV_HW_SAA7115 | IVTV_HW_SAA717X))
 575                     digitizer = 0xF1;
 576                 else if (itv->card->hw_all & IVTV_HW_SAA7114)
 577                     digitizer = 0xEF;
 578                 else /* cx25840 */
 579                     digitizer = 0x140;
 580
 581                 ivtv_vapi(itv, CX2341X_ENC_SET_NUM_VSYNC_LINES, 2, digitizer, digitizer);
 582
 583                 /* Setup VBI */
 584                 if (itv->v4l2_cap & V4L2_CAP_VBI_CAPTURE) {
 585                         ivtv_vbi_setup(itv);
 586                 }
 587
 588                 /* assign program index info. Mask 7: select I/P/B, Num_req: 400 max */
 589                 ivtv_vapi_result(itv, data, CX2341X_ENC_SET_PGM_INDEX_INFO, 2, 7, 400);
 590                 itv->pgm_info_offset = data[0];
 591                 itv->pgm_info_num = data[1];
 592                 itv->pgm_info_write_idx = 0;
 593                 itv->pgm_info_read_idx = 0;
 594
 595                 IVTV_DEBUG_INFO("PGM Index at 0x%08x with %d elements\n",
 596                                 itv->pgm_info_offset, itv->pgm_info_num);
 597
 598                 /* Setup API for Stream */
 599                 cx2341x_handler_setup(&itv->cxhdl);
 600
 601                 /* mute if capturing radio */
 602                 if (test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags))
 603                         ivtv_vapi(itv, CX2341X_ENC_MUTE_VIDEO, 1,
 604                                 1 | (v4l2_ctrl_g_ctrl(itv->cxhdl.video_mute_yuv) << 8));
 605         }
 606
 607         /* Vsync Setup */
 608         if (itv->has_cx23415 && !test_and_set_bit(IVTV_F_I_DIG_RST, &itv->i_flags)) {
 609                 /* event notification (on) */
 610                 ivtv_vapi(itv, CX2341X_ENC_SET_EVENT_NOTIFICATION, 4, 0, 1, IVTV_IRQ_ENC_VIM_RST, -1);
 611                 ivtv_clear_irq_mask(itv, IVTV_IRQ_ENC_VIM_RST);
 612         }
 613
 614         if (atomic_read(&itv->capturing) == 0) {
 615                 /* Clear all Pending Interrupts */
 616                 ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE);
 617
 618                 clear_bit(IVTV_F_I_EOS, &itv->i_flags);
 619
 620                 cx2341x_handler_set_busy(&itv->cxhdl, 1);
 621
 622                 /* Initialize Digitizer for Capture */
 623                 /* Avoid tinny audio problem - ensure audio clocks are going */
 624                 v4l2_subdev_call(itv->sd_audio, audio, s_stream, 1);
 625                 /* Avoid unpredictable PCI bus hang - disable video clocks */
 626                 if (itv->sd_video_is_streaming)
 627                         v4l2_subdev_call(itv->sd_video, video, s_stream, 0);
 628                 ivtv_msleep_timeout(300, 0);
 629                 ivtv_vapi(itv, CX2341X_ENC_INITIALIZE_INPUT, 0);
 630                 v4l2_subdev_call(itv->sd_video, video, s_stream, 1);
 631                 itv->sd_video_is_streaming = true;
 632         }
 633
 634         /* begin_capture */
 635         if (ivtv_vapi(itv, CX2341X_ENC_START_CAPTURE, 2, captype, subtype))
 636         {
 637                 IVTV_DEBUG_WARN( "Error starting capture!\n");
 638                 return -EINVAL;
 639         }
 640
 641         /* Start Passthrough */
 642         if (enable_passthrough) {
 643                 ivtv_passthrough_mode(itv, 1);
 644         }
 645
 646         if (s->type == IVTV_ENC_STREAM_TYPE_VBI)
 647                 ivtv_clear_irq_mask(itv, IVTV_IRQ_ENC_VBI_CAP);
 648         else
 649                 ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE);
 650
 651         /* you're live! sit back and await interrupts :) */
 652         atomic_inc(&itv->capturing);
 653         return 0;
 654 }
 655 EXPORT_SYMBOL(ivtv_start_v4l2_encode_stream);
 656
 657 static int ivtv_setup_v4l2_decode_stream(struct ivtv_stream *s)
 658 {
 659         u32 data[CX2341X_MBOX_MAX_DATA];
 660         struct ivtv *itv = s->itv;
 661         int datatype;
 662         u16 width;
 663         u16 height;
 664
 665         if (s->vdev.v4l2_dev == NULL)
 666                 return -EINVAL;
 667
 668         IVTV_DEBUG_INFO("Setting some initial decoder settings\n");
 669
 670         width = itv->cxhdl.width;
 671         height = itv->cxhdl.height;
 672
 673         /* set audio mode to left/stereo  for dual/stereo mode. */
 674         ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode);
 675
 676         /* set number of internal decoder buffers */
 677         ivtv_vapi(itv, CX2341X_DEC_SET_DISPLAY_BUFFERS, 1, 0);
 678
 679         /* prebuffering */
 680         ivtv_vapi(itv, CX2341X_DEC_SET_PREBUFFERING, 1, 1);
 681
 682         /* extract from user packets */
 683         ivtv_vapi_result(itv, data, CX2341X_DEC_EXTRACT_VBI, 1, 1);
 684         itv->vbi.dec_start = data[0];
 685
 686         IVTV_DEBUG_INFO("Decoder VBI RE-Insert start 0x%08x size 0x%08x\n",
 687                 itv->vbi.dec_start, data[1]);
 688
 689         /* set decoder source settings */
 690         /* Data type: 0 = mpeg from host,
 691            1 = yuv from encoder,
 692            2 = yuv_from_host */
 693         switch (s->type) {
 694         case IVTV_DEC_STREAM_TYPE_YUV:
 695                 if (itv->output_mode == OUT_PASSTHROUGH) {
 696                         datatype = 1;
 697                 } else {
 698                         /* Fake size to avoid switching video standard */
 699                         datatype = 2;
 700                         width = 720;
 701                         height = itv->is_out_50hz ? 576 : 480;
 702                 }
 703                 IVTV_DEBUG_INFO("Setup DEC YUV Stream data[0] = %d\n", datatype);
 704                 break;
 705         case IVTV_DEC_STREAM_TYPE_MPG:
 706         default:
 707                 datatype = 0;
 708                 break;
 709         }
 710         if (ivtv_vapi(itv, CX2341X_DEC_SET_DECODER_SOURCE, 4, datatype,
 711                         width, height, itv->cxhdl.audio_properties)) {
 712                 IVTV_DEBUG_WARN("Couldn't initialize decoder source\n");
 713         }
 714
 715         /* Decoder sometimes dies here, so wait a moment */
 716         ivtv_msleep_timeout(10, 0);
 717
 718         /* Known failure point for firmware, so check */
 719         return ivtv_firmware_check(itv, "ivtv_setup_v4l2_decode_stream");
 720 }
 721
 722 int ivtv_start_v4l2_decode_stream(struct ivtv_stream *s, int gop_offset)
 723 {
 724         struct ivtv *itv = s->itv;
 725         int rc;
 726
 727         if (s->vdev.v4l2_dev == NULL)
 728                 return -EINVAL;
 729
 730         if (test_and_set_bit(IVTV_F_S_STREAMING, &s->s_flags))
 731                 return 0;       /* already started */
 732
 733         IVTV_DEBUG_INFO("Starting decode stream %s (gop_offset %d)\n", s->name, gop_offset);
 734
 735         rc = ivtv_setup_v4l2_decode_stream(s);
 736         if (rc < 0) {
 737                 clear_bit(IVTV_F_S_STREAMING, &s->s_flags);
 738                 return rc;
 739         }
 740
 741         /* set dma size to 65536 bytes */
 742         ivtv_vapi(itv, CX2341X_DEC_SET_DMA_BLOCK_SIZE, 1, 65536);
 743
 744         /* Clear Streamoff */
 745         clear_bit(IVTV_F_S_STREAMOFF, &s->s_flags);
 746
 747         /* Zero out decoder counters */
 748         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[0]);
 749         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[1]);
 750         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[2]);
 751         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[3]);
 752         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[0]);
 753         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[1]);
 754         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[2]);
 755         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[3]);
 756
 757         /* turn on notification of dual/stereo mode change */
 758         ivtv_vapi(itv, CX2341X_DEC_SET_EVENT_NOTIFICATION, 4, 0, 1, IVTV_IRQ_DEC_AUD_MODE_CHG, -1);
 759
 760         /* start playback */
 761         ivtv_vapi(itv, CX2341X_DEC_START_PLAYBACK, 2, gop_offset, 0);
 762
 763         /* Let things settle before we actually start */
 764         ivtv_msleep_timeout(10, 0);
 765
 766         /* Clear the following Interrupt mask bits for decoding */
 767         ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_DECODE);
 768         IVTV_DEBUG_IRQ("IRQ Mask is now: 0x%08x\n", itv->irqmask);
 769
 770         /* you're live! sit back and await interrupts :) */
 771         atomic_inc(&itv->decoding);
 772         return 0;
 773 }
 774
 775 void ivtv_stop_all_captures(struct ivtv *itv)
 776 {
 777         int i;
 778
 779         for (i = IVTV_MAX_STREAMS - 1; i >= 0; i--) {
 780                 struct ivtv_stream *s = &itv->streams[i];
 781
 782                 if (s->vdev.v4l2_dev == NULL)
 783                         continue;
 784                 if (test_bit(IVTV_F_S_STREAMING, &s->s_flags)) {
 785                         ivtv_stop_v4l2_encode_stream(s, 0);
 786                 }
 787         }
 788 }
 789
 790 int ivtv_stop_v4l2_encode_stream(struct ivtv_stream *s, int gop_end)
 791 {
 792         struct ivtv *itv = s->itv;
 793         DECLARE_WAITQUEUE(wait, current);
 794         int cap_type;
 795         int stopmode;
 796
 797         if (s->vdev.v4l2_dev == NULL)
 798                 return -EINVAL;
 799
 800         /* This function assumes that you are allowed to stop the capture
 801            and that we are actually capturing */
 802
 803         IVTV_DEBUG_INFO("Stop Capture\n");
 804
 805         if (s->type == IVTV_DEC_STREAM_TYPE_VOUT)
 806                 return 0;
 807         if (atomic_read(&itv->capturing) == 0)
 808                 return 0;
 809
 810         switch (s->type) {
 811         case IVTV_ENC_STREAM_TYPE_YUV:
 812                 cap_type = 1;
 813                 break;
 814         case IVTV_ENC_STREAM_TYPE_PCM:
 815                 cap_type = 1;
 816                 break;
 817         case IVTV_ENC_STREAM_TYPE_VBI:
 818                 cap_type = 1;
 819                 break;
 820         case IVTV_ENC_STREAM_TYPE_MPG:
 821         default:
 822                 cap_type = 0;
 823                 break;
 824         }
 825
 826         /* Stop Capture Mode */
 827         if (s->type == IVTV_ENC_STREAM_TYPE_MPG && gop_end) {
 828                 stopmode = 0;
 829         } else {
 830                 stopmode = 1;
 831         }
 832
 833         /* end_capture */
 834         /* when: 0 =  end of GOP  1 = NOW!, type: 0 = mpeg, subtype: 3 = video+audio */
 835         ivtv_vapi(itv, CX2341X_ENC_STOP_CAPTURE, 3, stopmode, cap_type, s->subtype);
 836
 837         if (!test_bit(IVTV_F_S_PASSTHROUGH, &s->s_flags)) {
 838                 if (s->type == IVTV_ENC_STREAM_TYPE_MPG && gop_end) {
 839                         /* only run these if we're shutting down the last cap */
 840                         unsigned long duration;
 841                         unsigned long then = jiffies;
 842
 843                         add_wait_queue(&itv->eos_waitq, &wait);
 844
 845                         set_current_state(TASK_INTERRUPTIBLE);
 846
 847                         /* wait 2s for EOS interrupt */
 848                         while (!test_bit(IVTV_F_I_EOS, &itv->i_flags) &&
 849                                 time_before(jiffies,
 850                                             then + msecs_to_jiffies(2000))) {
 851                                 schedule_timeout(msecs_to_jiffies(10));
 852                         }
 853
 854                         /* To convert jiffies to ms, we must multiply by 1000
 855                          * and divide by HZ.  To avoid runtime division, we
 856                          * convert this to multiplication by 1000/HZ.
 857                          * Since integer division truncates, we get the best
 858                          * accuracy if we do a rounding calculation of the constant.
 859                          * Think of the case where HZ is 1024.
 860                          */
 861                         duration = ((1000 + HZ / 2) / HZ) * (jiffies - then);
 862
 863                         if (!test_bit(IVTV_F_I_EOS, &itv->i_flags)) {
 864                                 IVTV_DEBUG_WARN("%s: EOS interrupt not received! stopping anyway.\n", s->name);
 865                                 IVTV_DEBUG_WARN("%s: waited %lu ms.\n", s->name, duration);
 866                         } else {
 867                                 IVTV_DEBUG_INFO("%s: EOS took %lu ms to occur.\n", s->name, duration);
 868                         }
 869                         set_current_state(TASK_RUNNING);
 870                         remove_wait_queue(&itv->eos_waitq, &wait);
 871                         set_bit(IVTV_F_S_STREAMOFF, &s->s_flags);
 872                 }
 873
 874                 /* Handle any pending interrupts */
 875                 ivtv_msleep_timeout(100, 0);
 876         }
 877
 878         atomic_dec(&itv->capturing);
 879
 880         /* Clear capture and no-read bits */
 881         clear_bit(IVTV_F_S_STREAMING, &s->s_flags);
 882
 883         if (s->type == IVTV_ENC_STREAM_TYPE_VBI)
 884                 ivtv_set_irq_mask(itv, IVTV_IRQ_ENC_VBI_CAP);
 885
 886         if (atomic_read(&itv->capturing) > 0) {
 887                 return 0;
 888         }
 889
 890         cx2341x_handler_set_busy(&itv->cxhdl, 0);
 891
 892         /* Set the following Interrupt mask bits for capture */
 893         ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE);
 894         del_timer(&itv->dma_timer);
 895
 896         /* event notification (off) */
 897         if (test_and_clear_bit(IVTV_F_I_DIG_RST, &itv->i_flags)) {
 898                 /* type: 0 = refresh */
 899                 /* on/off: 0 = off, intr: 0x10000000, mbox_id: -1: none */
 900                 ivtv_vapi(itv, CX2341X_ENC_SET_EVENT_NOTIFICATION, 4, 0, 0, IVTV_IRQ_ENC_VIM_RST, -1);
 901                 ivtv_set_irq_mask(itv, IVTV_IRQ_ENC_VIM_RST);
 902         }
 903
 904         /* Raw-passthrough is implied on start. Make sure it's stopped so
 905            the encoder will re-initialize when next started */
 906         ivtv_vapi(itv, CX2341X_ENC_STOP_CAPTURE, 3, 1, 2, 7);
 907
 908         wake_up(&s->waitq);
 909
 910         return 0;
 911 }
 912 EXPORT_SYMBOL(ivtv_stop_v4l2_encode_stream);
 913
 914 int ivtv_stop_v4l2_decode_stream(struct ivtv_stream *s, int flags, u64 pts)
 915 {
 916         static const struct v4l2_event ev = {
 917                 .type = V4L2_EVENT_EOS,
 918         };
 919         struct ivtv *itv = s->itv;
 920
 921         if (s->vdev.v4l2_dev == NULL)
 922                 return -EINVAL;
 923
 924         if (s->type != IVTV_DEC_STREAM_TYPE_YUV && s->type != IVTV_DEC_STREAM_TYPE_MPG)
 925                 return -EINVAL;
 926
 927         if (!test_bit(IVTV_F_S_STREAMING, &s->s_flags))
 928                 return 0;
 929
 930         IVTV_DEBUG_INFO("Stop Decode at %llu, flags: %x\n", (unsigned long long)pts, flags);
 931
 932         /* Stop Decoder */
 933         if (!(flags & V4L2_DEC_CMD_STOP_IMMEDIATELY) || pts) {
 934                 u32 tmp = 0;
 935
 936                 /* Wait until the decoder is no longer running */
 937                 if (pts) {
 938                         ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3,
 939                                 0, (u32)(pts & 0xffffffff), (u32)(pts >> 32));
 940                 }
 941                 while (1) {
 942                         u32 data[CX2341X_MBOX_MAX_DATA];
 943                         ivtv_vapi_result(itv, data, CX2341X_DEC_GET_XFER_INFO, 0);
 944                         if (s->q_full.buffers + s->q_dma.buffers == 0) {
 945                                 if (tmp == data[3])
 946                                         break;
 947                                 tmp = data[3];
 948                         }
 949                         if (ivtv_msleep_timeout(100, 1))
 950                                 break;
 951                 }
 952         }
 953         ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3, flags & V4L2_DEC_CMD_STOP_TO_BLACK, 0, 0);
 954
 955         /* turn off notification of dual/stereo mode change */
 956         ivtv_vapi(itv, CX2341X_DEC_SET_EVENT_NOTIFICATION, 4, 0, 0, IVTV_IRQ_DEC_AUD_MODE_CHG, -1);
 957
 958         ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_DECODE);
 959         del_timer(&itv->dma_timer);
 960
 961         clear_bit(IVTV_F_S_NEEDS_DATA, &s->s_flags);
 962         clear_bit(IVTV_F_S_STREAMING, &s->s_flags);
 963         ivtv_flush_queues(s);
 964
 965         /* decoder needs time to settle */
 966         ivtv_msleep_timeout(40, 0);
 967
 968         /* decrement decoding */
 969         atomic_dec(&itv->decoding);
 970
 971         set_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags);
 972         wake_up(&itv->event_waitq);
 973         v4l2_event_queue(&s->vdev, &ev);
 974
 975         /* wake up wait queues */
 976         wake_up(&s->waitq);
 977
 978         return 0;
 979 }
 980
 981 int ivtv_passthrough_mode(struct ivtv *itv, int enable)
 982 {
 983         struct ivtv_stream *yuv_stream = &itv->streams[IVTV_ENC_STREAM_TYPE_YUV];
 984         struct ivtv_stream *dec_stream = &itv->streams[IVTV_DEC_STREAM_TYPE_YUV];
 985
 986         if (yuv_stream->vdev.v4l2_dev == NULL || dec_stream->vdev.v4l2_dev == NULL)
 987                 return -EINVAL;
 988
 989         IVTV_DEBUG_INFO("ivtv ioctl: Select passthrough mode\n");
 990
 991         /* Prevent others from starting/stopping streams while we
 992            initiate/terminate passthrough mode */
 993         if (enable) {
 994                 if (itv->output_mode == OUT_PASSTHROUGH) {
 995                         return 0;
 996                 }
 997                 if (ivtv_set_output_mode(itv, OUT_PASSTHROUGH) != OUT_PASSTHROUGH)
 998                         return -EBUSY;
 999
1000                 /* Fully initialize stream, and then unflag init */
1001                 set_bit(IVTV_F_S_PASSTHROUGH, &dec_stream->s_flags);
1002                 set_bit(IVTV_F_S_STREAMING, &dec_stream->s_flags);
1003
1004                 /* Setup YUV Decoder */
1005                 ivtv_setup_v4l2_decode_stream(dec_stream);
1006
1007                 /* Start Decoder */
1008                 ivtv_vapi(itv, CX2341X_DEC_START_PLAYBACK, 2, 0, 1);
1009                 atomic_inc(&itv->decoding);
1010
1011                 /* Setup capture if not already done */
1012                 if (atomic_read(&itv->capturing) == 0) {
1013                         cx2341x_handler_setup(&itv->cxhdl);
1014                         cx2341x_handler_set_busy(&itv->cxhdl, 1);
1015                 }
1016
1017                 /* Start Passthrough Mode */
1018                 ivtv_vapi(itv, CX2341X_ENC_START_CAPTURE, 2, 2, 11);
1019                 atomic_inc(&itv->capturing);
1020                 return 0;
1021         }
1022
1023         if (itv->output_mode != OUT_PASSTHROUGH)
1024                 return 0;
1025
1026         /* Stop Passthrough Mode */
1027         ivtv_vapi(itv, CX2341X_ENC_STOP_CAPTURE, 3, 1, 2, 11);
1028         ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3, 1, 0, 0);
1029
1030         atomic_dec(&itv->capturing);
1031         atomic_dec(&itv->decoding);
1032         clear_bit(IVTV_F_S_PASSTHROUGH, &dec_stream->s_flags);
1033         clear_bit(IVTV_F_S_STREAMING, &dec_stream->s_flags);
1034         itv->output_mode = OUT_NONE;
1035         if (atomic_read(&itv->capturing) == 0)
1036                 cx2341x_handler_set_busy(&itv->cxhdl, 0);
1037
1038         return 0;
1039 }