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