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