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