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