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