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