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         .release = ivtv_v4l2_close,
  55         .poll = ivtv_v4l2_enc_poll,
  56 };
  57
  58 static const struct v4l2_file_operations ivtv_v4l2_dec_fops = {
  59         .owner = THIS_MODULE,
  60         .read = ivtv_v4l2_read,
  61         .write = ivtv_v4l2_write,
  62         .open = ivtv_v4l2_open,
  63         .unlocked_ioctl = video_ioctl2,
  64         .release = ivtv_v4l2_close,
  65         .poll = ivtv_v4l2_dec_poll,
  66 };
  67
  68 static const struct v4l2_file_operations ivtv_v4l2_radio_fops = {
  69         .owner = THIS_MODULE,
  70         .open = ivtv_v4l2_open,
  71         .unlocked_ioctl = video_ioctl2,
  72         .release = ivtv_v4l2_close,
  73         .poll = ivtv_v4l2_enc_poll,
  74 };
  75
  76 #define IVTV_V4L2_DEC_MPG_OFFSET  16    /* offset from 0 to register decoder mpg v4l2 minors on */
  77 #define IVTV_V4L2_ENC_PCM_OFFSET  24    /* offset from 0 to register pcm v4l2 minors on */
  78 #define IVTV_V4L2_ENC_YUV_OFFSET  32    /* offset from 0 to register yuv v4l2 minors on */
  79 #define IVTV_V4L2_DEC_YUV_OFFSET  48    /* offset from 0 to register decoder yuv v4l2 minors on */
  80 #define IVTV_V4L2_DEC_VBI_OFFSET   8    /* offset from 0 to register decoder vbi input v4l2 minors on */
  81 #define IVTV_V4L2_DEC_VOUT_OFFSET 16    /* offset from 0 to register vbi output v4l2 minors on */
  82
  83 static struct {
  84         const char *name;
  85         int vfl_type;
  86         int num_offset;
  87         int dma, pio;
  88         u32 v4l2_caps;
  89         const struct v4l2_file_operations *fops;
  90 } ivtv_stream_info[] = {
  91         {       /* IVTV_ENC_STREAM_TYPE_MPG */
  92                 "encoder MPG",
  93                 VFL_TYPE_GRABBER, 0,
  94                 PCI_DMA_FROMDEVICE, 0,
  95                 V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_TUNER |
  96                         V4L2_CAP_AUDIO | V4L2_CAP_READWRITE,
  97                 &ivtv_v4l2_enc_fops
  98         },
  99         {       /* IVTV_ENC_STREAM_TYPE_YUV */
 100                 "encoder YUV",
 101                 VFL_TYPE_GRABBER, IVTV_V4L2_ENC_YUV_OFFSET,
 102                 PCI_DMA_FROMDEVICE, 0,
 103                 V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_TUNER |
 104                         V4L2_CAP_AUDIO | V4L2_CAP_READWRITE,
 105                 &ivtv_v4l2_enc_fops
 106         },
 107         {       /* IVTV_ENC_STREAM_TYPE_VBI */
 108                 "encoder VBI",
 109                 VFL_TYPE_VBI, 0,
 110                 PCI_DMA_FROMDEVICE, 0,
 111                 V4L2_CAP_VBI_CAPTURE | V4L2_CAP_SLICED_VBI_CAPTURE | V4L2_CAP_TUNER |
 112                         V4L2_CAP_AUDIO | V4L2_CAP_READWRITE,
 113                 &ivtv_v4l2_enc_fops
 114         },
 115         {       /* IVTV_ENC_STREAM_TYPE_PCM */
 116                 "encoder PCM",
 117                 VFL_TYPE_GRABBER, IVTV_V4L2_ENC_PCM_OFFSET,
 118                 PCI_DMA_FROMDEVICE, 0,
 119                 V4L2_CAP_TUNER | V4L2_CAP_AUDIO | V4L2_CAP_READWRITE,
 120                 &ivtv_v4l2_enc_fops
 121         },
 122         {       /* IVTV_ENC_STREAM_TYPE_RAD */
 123                 "encoder radio",
 124                 VFL_TYPE_RADIO, 0,
 125                 PCI_DMA_NONE, 1,
 126                 V4L2_CAP_RADIO | V4L2_CAP_TUNER,
 127                 &ivtv_v4l2_radio_fops
 128         },
 129         {       /* IVTV_DEC_STREAM_TYPE_MPG */
 130                 "decoder MPG",
 131                 VFL_TYPE_GRABBER, IVTV_V4L2_DEC_MPG_OFFSET,
 132                 PCI_DMA_TODEVICE, 0,
 133                 V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_AUDIO | V4L2_CAP_READWRITE,
 134                 &ivtv_v4l2_dec_fops
 135         },
 136         {       /* IVTV_DEC_STREAM_TYPE_VBI */
 137                 "decoder VBI",
 138                 VFL_TYPE_VBI, IVTV_V4L2_DEC_VBI_OFFSET,
 139                 PCI_DMA_NONE, 1,
 140                 V4L2_CAP_SLICED_VBI_CAPTURE | V4L2_CAP_READWRITE,
 141                 &ivtv_v4l2_enc_fops
 142         },
 143         {       /* IVTV_DEC_STREAM_TYPE_VOUT */
 144                 "decoder VOUT",
 145                 VFL_TYPE_VBI, IVTV_V4L2_DEC_VOUT_OFFSET,
 146                 PCI_DMA_NONE, 1,
 147                 V4L2_CAP_SLICED_VBI_OUTPUT | V4L2_CAP_AUDIO | V4L2_CAP_READWRITE,
 148                 &ivtv_v4l2_dec_fops
 149         },
 150         {       /* IVTV_DEC_STREAM_TYPE_YUV */
 151                 "decoder YUV",
 152                 VFL_TYPE_GRABBER, IVTV_V4L2_DEC_YUV_OFFSET,
 153                 PCI_DMA_TODEVICE, 0,
 154                 V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_AUDIO | V4L2_CAP_READWRITE,
 155                 &ivtv_v4l2_dec_fops
 156         }
 157 };
 158
 159 static void ivtv_stream_init(struct ivtv *itv, int type)
 160 {
 161         struct ivtv_stream *s = &itv->streams[type];
 162         struct video_device *vdev = s->vdev;
 163
 164         /* we need to keep vdev, so restore it afterwards */
 165         memset(s, 0, sizeof(*s));
 166         s->vdev = vdev;
 167
 168         /* initialize ivtv_stream fields */
 169         s->itv = itv;
 170         s->type = type;
 171         s->name = ivtv_stream_info[type].name;
 172         s->caps = ivtv_stream_info[type].v4l2_caps;
 173
 174         if (ivtv_stream_info[type].pio)
 175                 s->dma = PCI_DMA_NONE;
 176         else
 177                 s->dma = ivtv_stream_info[type].dma;
 178         s->buf_size = itv->stream_buf_size[type];
 179         if (s->buf_size)
 180                 s->buffers = (itv->options.kilobytes[type] * 1024 + s->buf_size - 1) / s->buf_size;
 181         spin_lock_init(&s->qlock);
 182         init_waitqueue_head(&s->waitq);
 183         s->sg_handle = IVTV_DMA_UNMAPPED;
 184         ivtv_queue_init(&s->q_free);
 185         ivtv_queue_init(&s->q_full);
 186         ivtv_queue_init(&s->q_dma);
 187         ivtv_queue_init(&s->q_predma);
 188         ivtv_queue_init(&s->q_io);
 189 }
 190
 191 static int ivtv_prep_dev(struct ivtv *itv, int type)
 192 {
 193         struct ivtv_stream *s = &itv->streams[type];
 194         int num_offset = ivtv_stream_info[type].num_offset;
 195         int num = itv->instance + ivtv_first_minor + num_offset;
 196
 197         /* These four fields are always initialized. If vdev == NULL, then
 198            this stream is not in use. In that case no other fields but these
 199            four can be used. */
 200         s->vdev = NULL;
 201         s->itv = itv;
 202         s->type = type;
 203         s->name = ivtv_stream_info[type].name;
 204
 205         /* Check whether the radio is supported */
 206         if (type == IVTV_ENC_STREAM_TYPE_RAD && !(itv->v4l2_cap & V4L2_CAP_RADIO))
 207                 return 0;
 208         if (type >= IVTV_DEC_STREAM_TYPE_MPG && !(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
 209                 return 0;
 210
 211         /* User explicitly selected 0 buffers for these streams, so don't
 212            create them. */
 213         if (ivtv_stream_info[type].dma != PCI_DMA_NONE &&
 214             itv->options.kilobytes[type] == 0) {
 215                 IVTV_INFO("Disabled %s device\n", ivtv_stream_info[type].name);
 216                 return 0;
 217         }
 218
 219         ivtv_stream_init(itv, type);
 220
 221         /* allocate and initialize the v4l2 video device structure */
 222         s->vdev = video_device_alloc();
 223         if (s->vdev == NULL) {
 224                 IVTV_ERR("Couldn't allocate v4l2 video_device for %s\n", s->name);
 225                 return -ENOMEM;
 226         }
 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;
 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         set_bit(V4L2_FL_USE_FH_PRIO, &s->vdev->flags);
 255         ivtv_set_funcs(s->vdev);
 256         return 0;
 257 }
 258
 259 /* Initialize v4l2 variables and prepare v4l2 devices */
 260 int ivtv_streams_setup(struct ivtv *itv)
 261 {
 262         int type;
 263
 264         /* Setup V4L2 Devices */
 265         for (type = 0; type < IVTV_MAX_STREAMS; type++) {
 266                 /* Prepare device */
 267                 if (ivtv_prep_dev(itv, type))
 268                         break;
 269
 270                 if (itv->streams[type].vdev == NULL)
 271                         continue;
 272
 273                 /* Allocate Stream */
 274                 if (ivtv_stream_alloc(&itv->streams[type]))
 275                         break;
 276         }
 277         if (type == IVTV_MAX_STREAMS)
 278                 return 0;
 279
 280         /* One or more streams could not be initialized. Clean 'em all up. */
 281         ivtv_streams_cleanup(itv, 0);
 282         return -ENOMEM;
 283 }
 284
 285 static int ivtv_reg_dev(struct ivtv *itv, int type)
 286 {
 287         struct ivtv_stream *s = &itv->streams[type];
 288         int vfl_type = ivtv_stream_info[type].vfl_type;
 289         const char *name;
 290         int num;
 291
 292         if (s->vdev == NULL)
 293                 return 0;
 294
 295         num = s->vdev->num;
 296         /* card number + user defined offset + device offset */
 297         if (type != IVTV_ENC_STREAM_TYPE_MPG) {
 298                 struct ivtv_stream *s_mpg = &itv->streams[IVTV_ENC_STREAM_TYPE_MPG];
 299
 300                 if (s_mpg->vdev)
 301                         num = s_mpg->vdev->num + ivtv_stream_info[type].num_offset;
 302         }
 303         video_set_drvdata(s->vdev, s);
 304
 305         /* Register device. First try the desired minor, then any free one. */
 306         if (video_register_device_no_warn(s->vdev, vfl_type, num)) {
 307                 IVTV_ERR("Couldn't register v4l2 device for %s (device node number %d)\n",
 308                                 s->name, num);
 309                 video_device_release(s->vdev);
 310                 s->vdev = NULL;
 311                 return -ENOMEM;
 312         }
 313         name = video_device_node_name(s->vdev);
 314
 315         switch (vfl_type) {
 316         case VFL_TYPE_GRABBER:
 317                 IVTV_INFO("Registered device %s for %s (%d kB)\n",
 318                         name, s->name, itv->options.kilobytes[type]);
 319                 break;
 320         case VFL_TYPE_RADIO:
 321                 IVTV_INFO("Registered device %s for %s\n",
 322                         name, s->name);
 323                 break;
 324         case VFL_TYPE_VBI:
 325                 if (itv->options.kilobytes[type])
 326                         IVTV_INFO("Registered device %s for %s (%d kB)\n",
 327                                 name, s->name, itv->options.kilobytes[type]);
 328                 else
 329                         IVTV_INFO("Registered device %s for %s\n",
 330                                 name, s->name);
 331                 break;
 332         }
 333         return 0;
 334 }
 335
 336 /* Register v4l2 devices */
 337 int ivtv_streams_register(struct ivtv *itv)
 338 {
 339         int type;
 340         int err = 0;
 341
 342         /* Register V4L2 devices */
 343         for (type = 0; type < IVTV_MAX_STREAMS; type++)
 344                 err |= ivtv_reg_dev(itv, type);
 345
 346         if (err == 0)
 347                 return 0;
 348
 349         /* One or more streams could not be initialized. Clean 'em all up. */
 350         ivtv_streams_cleanup(itv, 1);
 351         return -ENOMEM;
 352 }
 353
 354 /* Unregister v4l2 devices */
 355 void ivtv_streams_cleanup(struct ivtv *itv, int unregister)
 356 {
 357         int type;
 358
 359         /* Teardown all streams */
 360         for (type = 0; type < IVTV_MAX_STREAMS; type++) {
 361                 struct video_device *vdev = itv->streams[type].vdev;
 362
 363                 itv->streams[type].vdev = NULL;
 364                 if (vdev == NULL)
 365                         continue;
 366
 367                 ivtv_stream_free(&itv->streams[type]);
 368                 /* Unregister or release device */
 369                 if (unregister)
 370                         video_unregister_device(vdev);
 371                 else
 372                         video_device_release(vdev);
 373         }
 374 }
 375
 376 static void ivtv_vbi_setup(struct ivtv *itv)
 377 {
 378         int raw = ivtv_raw_vbi(itv);
 379         u32 data[CX2341X_MBOX_MAX_DATA];
 380         int lines;
 381         int i;
 382
 383         /* Reset VBI */
 384         ivtv_vapi(itv, CX2341X_ENC_SET_VBI_LINE, 5, 0xffff , 0, 0, 0, 0);
 385
 386         /* setup VBI registers */
 387         if (raw)
 388                 v4l2_subdev_call(itv->sd_video, vbi, s_raw_fmt, &itv->vbi.in.fmt.vbi);
 389         else
 390                 v4l2_subdev_call(itv->sd_video, vbi, s_sliced_fmt, &itv->vbi.in.fmt.sliced);
 391
 392         /* determine number of lines and total number of VBI bytes.
 393            A raw line takes 1443 bytes: 2 * 720 + 4 byte frame header - 1
 394            The '- 1' byte is probably an unused U or V byte. Or something...
 395            A sliced line takes 51 bytes: 4 byte frame header, 4 byte internal
 396            header, 42 data bytes + checksum (to be confirmed) */
 397         if (raw) {
 398                 lines = itv->vbi.count * 2;
 399         } else {
 400                 lines = itv->is_60hz ? 24 : 38;
 401                 if (itv->is_60hz && (itv->hw_flags & IVTV_HW_CX25840))
 402                         lines += 2;
 403         }
 404
 405         itv->vbi.enc_size = lines * (raw ? itv->vbi.raw_size : itv->vbi.sliced_size);
 406
 407         /* Note: sliced vs raw flag doesn't seem to have any effect
 408            TODO: check mode (0x02) value with older ivtv versions. */
 409         data[0] = raw | 0x02 | (0xbd << 8);
 410
 411         /* Every X number of frames a VBI interrupt arrives (frames as in 25 or 30 fps) */
 412         data[1] = 1;
 413         /* The VBI frames are stored in a ringbuffer with this size (with a VBI frame as unit) */
 414         data[2] = raw ? 4 : 4 * (itv->vbi.raw_size / itv->vbi.enc_size);
 415         /* The start/stop codes determine which VBI lines end up in the raw VBI data area.
 416            The codes are from table 24 in the saa7115 datasheet. Each raw/sliced/video line
 417            is framed with codes FF0000XX where XX is the SAV/EAV (Start/End of Active Video)
 418            code. These values for raw VBI are obtained from a driver disassembly. The sliced
 419            start/stop codes was deduced from this, but they do not appear in the driver.
 420            Other code pairs that I found are: 0x250E6249/0x13545454 and 0x25256262/0x38137F54.
 421            However, I have no idea what these values are for. */
 422         if (itv->hw_flags & IVTV_HW_CX25840) {
 423                 /* Setup VBI for the cx25840 digitizer */
 424                 if (raw) {
 425                         data[3] = 0x20602060;
 426                         data[4] = 0x30703070;
 427                 } else {
 428                         data[3] = 0xB0F0B0F0;
 429                         data[4] = 0xA0E0A0E0;
 430                 }
 431                 /* Lines per frame */
 432                 data[5] = lines;
 433                 /* bytes per line */
 434                 data[6] = (raw ? itv->vbi.raw_size : itv->vbi.sliced_size);
 435         } else {
 436                 /* Setup VBI for the saa7115 digitizer */
 437                 if (raw) {
 438                         data[3] = 0x25256262;
 439                         data[4] = 0x387F7F7F;
 440                 } else {
 441                         data[3] = 0xABABECEC;
 442                         data[4] = 0xB6F1F1F1;
 443                 }
 444                 /* Lines per frame */
 445                 data[5] = lines;
 446                 /* bytes per line */
 447                 data[6] = itv->vbi.enc_size / lines;
 448         }
 449
 450         IVTV_DEBUG_INFO(
 451                 "Setup VBI API header 0x%08x pkts %d buffs %d ln %d sz %d\n",
 452                         data[0], data[1], data[2], data[5], data[6]);
 453
 454         ivtv_api(itv, CX2341X_ENC_SET_VBI_CONFIG, 7, data);
 455
 456         /* returns the VBI encoder memory area. */
 457         itv->vbi.enc_start = data[2];
 458         itv->vbi.fpi = data[0];
 459         if (!itv->vbi.fpi)
 460                 itv->vbi.fpi = 1;
 461
 462         IVTV_DEBUG_INFO("Setup VBI start 0x%08x frames %d fpi %d\n",
 463                 itv->vbi.enc_start, data[1], itv->vbi.fpi);
 464
 465         /* select VBI lines.
 466            Note that the sliced argument seems to have no effect. */
 467         for (i = 2; i <= 24; i++) {
 468                 int valid;
 469
 470                 if (itv->is_60hz) {
 471                         valid = i >= 10 && i < 22;
 472                 } else {
 473                         valid = i >= 6 && i < 24;
 474                 }
 475                 ivtv_vapi(itv, CX2341X_ENC_SET_VBI_LINE, 5, i - 1,
 476                                 valid, 0 , 0, 0);
 477                 ivtv_vapi(itv, CX2341X_ENC_SET_VBI_LINE, 5, (i - 1) | 0x80000000,
 478                                 valid, 0, 0, 0);
 479         }
 480
 481         /* Remaining VBI questions:
 482            - Is it possible to select particular VBI lines only for inclusion in the MPEG
 483            stream? Currently you can only get the first X lines.
 484            - Is mixed raw and sliced VBI possible?
 485            - What's the meaning of the raw/sliced flag?
 486            - What's the meaning of params 2, 3 & 4 of the Select VBI command? */
 487 }
 488
 489 int ivtv_start_v4l2_encode_stream(struct ivtv_stream *s)
 490 {
 491         u32 data[CX2341X_MBOX_MAX_DATA];
 492         struct ivtv *itv = s->itv;
 493         int captype = 0, subtype = 0;
 494         int enable_passthrough = 0;
 495
 496         if (s->vdev == NULL)
 497                 return -EINVAL;
 498
 499         IVTV_DEBUG_INFO("Start encoder stream %s\n", s->name);
 500
 501         switch (s->type) {
 502         case IVTV_ENC_STREAM_TYPE_MPG:
 503                 captype = 0;
 504                 subtype = 3;
 505
 506                 /* Stop Passthrough */
 507                 if (itv->output_mode == OUT_PASSTHROUGH) {
 508                         ivtv_passthrough_mode(itv, 0);
 509                         enable_passthrough = 1;
 510                 }
 511                 itv->mpg_data_received = itv->vbi_data_inserted = 0;
 512                 itv->dualwatch_jiffies = jiffies;
 513                 itv->dualwatch_stereo_mode = v4l2_ctrl_g_ctrl(itv->cxhdl.audio_mode);
 514                 itv->search_pack_header = 0;
 515                 break;
 516
 517         case IVTV_ENC_STREAM_TYPE_YUV:
 518                 if (itv->output_mode == OUT_PASSTHROUGH) {
 519                         captype = 2;
 520                         subtype = 11;   /* video+audio+decoder */
 521                         break;
 522                 }
 523                 captype = 1;
 524                 subtype = 1;
 525                 break;
 526         case IVTV_ENC_STREAM_TYPE_PCM:
 527                 captype = 1;
 528                 subtype = 2;
 529                 break;
 530         case IVTV_ENC_STREAM_TYPE_VBI:
 531                 captype = 1;
 532                 subtype = 4;
 533
 534                 itv->vbi.frame = 0;
 535                 itv->vbi.inserted_frame = 0;
 536                 memset(itv->vbi.sliced_mpeg_size,
 537                         0, sizeof(itv->vbi.sliced_mpeg_size));
 538                 break;
 539         default:
 540                 return -EINVAL;
 541         }
 542         s->subtype = subtype;
 543         s->buffers_stolen = 0;
 544
 545         /* Clear Streamoff flags in case left from last capture */
 546         clear_bit(IVTV_F_S_STREAMOFF, &s->s_flags);
 547
 548         if (atomic_read(&itv->capturing) == 0) {
 549                 int digitizer;
 550
 551                 /* Always use frame based mode. Experiments have demonstrated that byte
 552                    stream based mode results in dropped frames and corruption. Not often,
 553                    but occasionally. Many thanks go to Leonard Orb who spent a lot of
 554                    effort and time trying to trace the cause of the drop outs. */
 555                 /* 1 frame per DMA */
 556                 /*ivtv_vapi(itv, CX2341X_ENC_SET_DMA_BLOCK_SIZE, 2, 128, 0); */
 557                 ivtv_vapi(itv, CX2341X_ENC_SET_DMA_BLOCK_SIZE, 2, 1, 1);
 558
 559                 /* Stuff from Windows, we don't know what it is */
 560                 ivtv_vapi(itv, CX2341X_ENC_SET_VERT_CROP_LINE, 1, 0);
 561                 /* According to the docs, this should be correct. However, this is
 562                    untested. I don't dare enable this without having tested it.
 563                    Only very few old cards actually have this hardware combination.
 564                 ivtv_vapi(itv, CX2341X_ENC_SET_VERT_CROP_LINE, 1,
 565                         ((itv->hw_flags & IVTV_HW_SAA7114) && itv->is_60hz) ? 10001 : 0);
 566                 */
 567                 ivtv_vapi(itv, CX2341X_ENC_MISC, 2, 3, !itv->has_cx23415);
 568                 ivtv_vapi(itv, CX2341X_ENC_MISC, 2, 8, 0);
 569                 ivtv_vapi(itv, CX2341X_ENC_MISC, 2, 4, 1);
 570                 ivtv_vapi(itv, CX2341X_ENC_MISC, 1, 12);
 571
 572                 /* assign placeholder */
 573                 ivtv_vapi(itv, CX2341X_ENC_SET_PLACEHOLDER, 12,
 574                         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
 575
 576                 if (itv->card->hw_all & (IVTV_HW_SAA7115 | IVTV_HW_SAA717X))
 577                     digitizer = 0xF1;
 578                 else if (itv->card->hw_all & IVTV_HW_SAA7114)
 579                     digitizer = 0xEF;
 580                 else /* cx25840 */
 581                     digitizer = 0x140;
 582
 583                 ivtv_vapi(itv, CX2341X_ENC_SET_NUM_VSYNC_LINES, 2, digitizer, digitizer);
 584
 585                 /* Setup VBI */
 586                 if (itv->v4l2_cap & V4L2_CAP_VBI_CAPTURE) {
 587                         ivtv_vbi_setup(itv);
 588                 }
 589
 590                 /* assign program index info. Mask 7: select I/P/B, Num_req: 400 max */
 591                 ivtv_vapi_result(itv, data, CX2341X_ENC_SET_PGM_INDEX_INFO, 2, 7, 400);
 592                 itv->pgm_info_offset = data[0];
 593                 itv->pgm_info_num = data[1];
 594                 itv->pgm_info_write_idx = 0;
 595                 itv->pgm_info_read_idx = 0;
 596
 597                 IVTV_DEBUG_INFO("PGM Index at 0x%08x with %d elements\n",
 598                                 itv->pgm_info_offset, itv->pgm_info_num);
 599
 600                 /* Setup API for Stream */
 601                 cx2341x_handler_setup(&itv->cxhdl);
 602
 603                 /* mute if capturing radio */
 604                 if (test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags))
 605                         ivtv_vapi(itv, CX2341X_ENC_MUTE_VIDEO, 1,
 606                                 1 | (v4l2_ctrl_g_ctrl(itv->cxhdl.video_mute_yuv) << 8));
 607         }
 608
 609         /* Vsync Setup */
 610         if (itv->has_cx23415 && !test_and_set_bit(IVTV_F_I_DIG_RST, &itv->i_flags)) {
 611                 /* event notification (on) */
 612                 ivtv_vapi(itv, CX2341X_ENC_SET_EVENT_NOTIFICATION, 4, 0, 1, IVTV_IRQ_ENC_VIM_RST, -1);
 613                 ivtv_clear_irq_mask(itv, IVTV_IRQ_ENC_VIM_RST);
 614         }
 615
 616         if (atomic_read(&itv->capturing) == 0) {
 617                 /* Clear all Pending Interrupts */
 618                 ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE);
 619
 620                 clear_bit(IVTV_F_I_EOS, &itv->i_flags);
 621
 622                 cx2341x_handler_set_busy(&itv->cxhdl, 1);
 623
 624                 /* Initialize Digitizer for Capture */
 625                 /* Avoid tinny audio problem - ensure audio clocks are going */
 626                 v4l2_subdev_call(itv->sd_audio, audio, s_stream, 1);
 627                 /* Avoid unpredictable PCI bus hang - disable video clocks */
 628                 v4l2_subdev_call(itv->sd_video, video, s_stream, 0);
 629                 ivtv_msleep_timeout(300, 0);
 630                 ivtv_vapi(itv, CX2341X_ENC_INITIALIZE_INPUT, 0);
 631                 v4l2_subdev_call(itv->sd_video, video, s_stream, 1);
 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 == 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 == 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 == 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 == 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 == 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 == NULL || dec_stream->vdev == 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 }