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

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

DEFINITIONS
