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