drivers/media/video/ivtv/ivtv-streams.c

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