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         if (ivtv_firmware_check(itv, "ivtv_setup_v4l2_decode_stream") < 0)
 680                 return -EIO;
 681
 682         return 0;
 683 }
 684
 685 int ivtv_start_v4l2_decode_stream(struct ivtv_stream *s, int gop_offset)
 686 {
 687         struct ivtv *itv = s->itv;
 688         int rc;
 689
 690         if (s->vdev == NULL)
 691                 return -EINVAL;
 692
 693         if (test_and_set_bit(IVTV_F_S_STREAMING, &s->s_flags))
 694                 return 0;       /* already started */
 695
 696         IVTV_DEBUG_INFO("Starting decode stream %s (gop_offset %d)\n", s->name, gop_offset);
 697
 698         rc = ivtv_setup_v4l2_decode_stream(s);
 699         if (rc < 0) {
 700                 clear_bit(IVTV_F_S_STREAMING, &s->s_flags);
 701                 return rc;
 702         }
 703
 704         /* set dma size to 65536 bytes */
 705         ivtv_vapi(itv, CX2341X_DEC_SET_DMA_BLOCK_SIZE, 1, 65536);
 706
 707         /* Clear Streamoff */
 708         clear_bit(IVTV_F_S_STREAMOFF, &s->s_flags);
 709
 710         /* Zero out decoder counters */
 711         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[0]);
 712         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[1]);
 713         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[2]);
 714         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[3]);
 715         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[0]);
 716         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[1]);
 717         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[2]);
 718         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[3]);
 719
 720         /* turn on notification of dual/stereo mode change */
 721         ivtv_vapi(itv, CX2341X_DEC_SET_EVENT_NOTIFICATION, 4, 0, 1, IVTV_IRQ_DEC_AUD_MODE_CHG, -1);
 722
 723         /* start playback */
 724         ivtv_vapi(itv, CX2341X_DEC_START_PLAYBACK, 2, gop_offset, 0);
 725
 726         /* Let things settle before we actually start */
 727         ivtv_msleep_timeout(10, 0);
 728
 729         /* Clear the following Interrupt mask bits for decoding */
 730         ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_DECODE);
 731         IVTV_DEBUG_IRQ("IRQ Mask is now: 0x%08x\n", itv->irqmask);
 732
 733         /* you're live! sit back and await interrupts :) */
 734         atomic_inc(&itv->decoding);
 735         return 0;
 736 }
 737
 738 void ivtv_stop_all_captures(struct ivtv *itv)
 739 {
 740         int i;
 741
 742         for (i = IVTV_MAX_STREAMS - 1; i >= 0; i--) {
 743                 struct ivtv_stream *s = &itv->streams[i];
 744
 745                 if (s->vdev == NULL)
 746                         continue;
 747                 if (test_bit(IVTV_F_S_STREAMING, &s->s_flags)) {
 748                         ivtv_stop_v4l2_encode_stream(s, 0);
 749                 }
 750         }
 751 }
 752
 753 int ivtv_stop_v4l2_encode_stream(struct ivtv_stream *s, int gop_end)
 754 {
 755         struct ivtv *itv = s->itv;
 756         DECLARE_WAITQUEUE(wait, current);
 757         int cap_type;
 758         int stopmode;
 759
 760         if (s->vdev == NULL)
 761                 return -EINVAL;
 762
 763         /* This function assumes that you are allowed to stop the capture
 764            and that we are actually capturing */
 765
 766         IVTV_DEBUG_INFO("Stop Capture\n");
 767
 768         if (s->type == IVTV_DEC_STREAM_TYPE_VOUT)
 769                 return 0;
 770         if (atomic_read(&itv->capturing) == 0)
 771                 return 0;
 772
 773         switch (s->type) {
 774         case IVTV_ENC_STREAM_TYPE_YUV:
 775                 cap_type = 1;
 776                 break;
 777         case IVTV_ENC_STREAM_TYPE_PCM:
 778                 cap_type = 1;
 779                 break;
 780         case IVTV_ENC_STREAM_TYPE_VBI:
 781                 cap_type = 1;
 782                 break;
 783         case IVTV_ENC_STREAM_TYPE_MPG:
 784         default:
 785                 cap_type = 0;
 786                 break;
 787         }
 788
 789         /* Stop Capture Mode */
 790         if (s->type == IVTV_ENC_STREAM_TYPE_MPG && gop_end) {
 791                 stopmode = 0;
 792         } else {
 793                 stopmode = 1;
 794         }
 795
 796         /* end_capture */
 797         /* when: 0 =  end of GOP  1 = NOW!, type: 0 = mpeg, subtype: 3 = video+audio */
 798         ivtv_vapi(itv, CX2341X_ENC_STOP_CAPTURE, 3, stopmode, cap_type, s->subtype);
 799
 800         if (!test_bit(IVTV_F_S_PASSTHROUGH, &s->s_flags)) {
 801                 if (s->type == IVTV_ENC_STREAM_TYPE_MPG && gop_end) {
 802                         /* only run these if we're shutting down the last cap */
 803                         unsigned long duration;
 804                         unsigned long then = jiffies;
 805
 806                         add_wait_queue(&itv->eos_waitq, &wait);
 807
 808                         set_current_state(TASK_INTERRUPTIBLE);
 809
 810                         /* wait 2s for EOS interrupt */
 811                         while (!test_bit(IVTV_F_I_EOS, &itv->i_flags) &&
 812                                 time_before(jiffies,
 813                                             then + msecs_to_jiffies(2000))) {
 814                                 schedule_timeout(msecs_to_jiffies(10));
 815                         }
 816
 817                         /* To convert jiffies to ms, we must multiply by 1000
 818                          * and divide by HZ.  To avoid runtime division, we
 819                          * convert this to multiplication by 1000/HZ.
 820                          * Since integer division truncates, we get the best
 821                          * accuracy if we do a rounding calculation of the constant.
 822                          * Think of the case where HZ is 1024.
 823                          */
 824                         duration = ((1000 + HZ / 2) / HZ) * (jiffies - then);
 825
 826                         if (!test_bit(IVTV_F_I_EOS, &itv->i_flags)) {
 827                                 IVTV_DEBUG_WARN("%s: EOS interrupt not received! stopping anyway.\n", s->name);
 828                                 IVTV_DEBUG_WARN("%s: waited %lu ms.\n", s->name, duration);
 829                         } else {
 830                                 IVTV_DEBUG_INFO("%s: EOS took %lu ms to occur.\n", s->name, duration);
 831                         }
 832                         set_current_state(TASK_RUNNING);
 833                         remove_wait_queue(&itv->eos_waitq, &wait);
 834                         set_bit(IVTV_F_S_STREAMOFF, &s->s_flags);
 835                 }
 836
 837                 /* Handle any pending interrupts */
 838                 ivtv_msleep_timeout(100, 1);
 839         }
 840
 841         atomic_dec(&itv->capturing);
 842
 843         /* Clear capture and no-read bits */
 844         clear_bit(IVTV_F_S_STREAMING, &s->s_flags);
 845
 846         if (s->type == IVTV_ENC_STREAM_TYPE_VBI)
 847                 ivtv_set_irq_mask(itv, IVTV_IRQ_ENC_VBI_CAP);
 848
 849         if (atomic_read(&itv->capturing) > 0) {
 850                 return 0;
 851         }
 852
 853         /* Set the following Interrupt mask bits for capture */
 854         ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE);
 855         del_timer(&itv->dma_timer);
 856
 857         /* event notification (off) */
 858         if (test_and_clear_bit(IVTV_F_I_DIG_RST, &itv->i_flags)) {
 859                 /* type: 0 = refresh */
 860                 /* on/off: 0 = off, intr: 0x10000000, mbox_id: -1: none */
 861                 ivtv_vapi(itv, CX2341X_ENC_SET_EVENT_NOTIFICATION, 4, 0, 0, IVTV_IRQ_ENC_VIM_RST, -1);
 862                 ivtv_set_irq_mask(itv, IVTV_IRQ_ENC_VIM_RST);
 863         }
 864
 865         /* Raw-passthrough is implied on start. Make sure it's stopped so
 866            the encoder will re-initialize when next started */
 867         ivtv_vapi(itv, CX2341X_ENC_STOP_CAPTURE, 3, 1, 2, 7);
 868
 869         wake_up(&s->waitq);
 870
 871         return 0;
 872 }
 873
 874 int ivtv_stop_v4l2_decode_stream(struct ivtv_stream *s, int flags, u64 pts)
 875 {
 876         static const struct v4l2_event ev = {
 877                 .type = V4L2_EVENT_EOS,
 878         };
 879         struct ivtv *itv = s->itv;
 880
 881         if (s->vdev == NULL)
 882                 return -EINVAL;
 883
 884         if (s->type != IVTV_DEC_STREAM_TYPE_YUV && s->type != IVTV_DEC_STREAM_TYPE_MPG)
 885                 return -EINVAL;
 886
 887         if (!test_bit(IVTV_F_S_STREAMING, &s->s_flags))
 888                 return 0;
 889
 890         IVTV_DEBUG_INFO("Stop Decode at %llu, flags: %x\n", (unsigned long long)pts, flags);
 891
 892         /* Stop Decoder */
 893         if (!(flags & VIDEO_CMD_STOP_IMMEDIATELY) || pts) {
 894                 u32 tmp = 0;
 895
 896                 /* Wait until the decoder is no longer running */
 897                 if (pts) {
 898                         ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3,
 899                                 0, (u32)(pts & 0xffffffff), (u32)(pts >> 32));
 900                 }
 901                 while (1) {
 902                         u32 data[CX2341X_MBOX_MAX_DATA];
 903                         ivtv_vapi_result(itv, data, CX2341X_DEC_GET_XFER_INFO, 0);
 904                         if (s->q_full.buffers + s->q_dma.buffers == 0) {
 905                                 if (tmp == data[3])
 906                                         break;
 907                                 tmp = data[3];
 908                         }
 909                         if (ivtv_msleep_timeout(100, 1))
 910                                 break;
 911                 }
 912         }
 913         ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3, flags & VIDEO_CMD_STOP_TO_BLACK, 0, 0);
 914
 915         /* turn off notification of dual/stereo mode change */
 916         ivtv_vapi(itv, CX2341X_DEC_SET_EVENT_NOTIFICATION, 4, 0, 0, IVTV_IRQ_DEC_AUD_MODE_CHG, -1);
 917
 918         ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_DECODE);
 919         del_timer(&itv->dma_timer);
 920
 921         clear_bit(IVTV_F_S_NEEDS_DATA, &s->s_flags);
 922         clear_bit(IVTV_F_S_STREAMING, &s->s_flags);
 923         ivtv_flush_queues(s);
 924
 925         /* decoder needs time to settle */
 926         ivtv_msleep_timeout(40, 0);
 927
 928         /* decrement decoding */
 929         atomic_dec(&itv->decoding);
 930
 931         set_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags);
 932         wake_up(&itv->event_waitq);
 933         v4l2_event_queue(s->vdev, &ev);
 934
 935         /* wake up wait queues */
 936         wake_up(&s->waitq);
 937
 938         return 0;
 939 }
 940
 941 int ivtv_passthrough_mode(struct ivtv *itv, int enable)
 942 {
 943         struct ivtv_stream *yuv_stream = &itv->streams[IVTV_ENC_STREAM_TYPE_YUV];
 944         struct ivtv_stream *dec_stream = &itv->streams[IVTV_DEC_STREAM_TYPE_YUV];
 945
 946         if (yuv_stream->vdev == NULL || dec_stream->vdev == NULL)
 947                 return -EINVAL;
 948
 949         IVTV_DEBUG_INFO("ivtv ioctl: Select passthrough mode\n");
 950
 951         /* Prevent others from starting/stopping streams while we
 952            initiate/terminate passthrough mode */
 953         if (enable) {
 954                 if (itv->output_mode == OUT_PASSTHROUGH) {
 955                         return 0;
 956                 }
 957                 if (ivtv_set_output_mode(itv, OUT_PASSTHROUGH) != OUT_PASSTHROUGH)
 958                         return -EBUSY;
 959
 960                 /* Fully initialize stream, and then unflag init */
 961                 set_bit(IVTV_F_S_PASSTHROUGH, &dec_stream->s_flags);
 962                 set_bit(IVTV_F_S_STREAMING, &dec_stream->s_flags);
 963
 964                 /* Setup YUV Decoder */
 965                 ivtv_setup_v4l2_decode_stream(dec_stream);
 966
 967                 /* Start Decoder */
 968                 ivtv_vapi(itv, CX2341X_DEC_START_PLAYBACK, 2, 0, 1);
 969                 atomic_inc(&itv->decoding);
 970
 971                 /* Setup capture if not already done */
 972                 if (atomic_read(&itv->capturing) == 0) {
 973                         cx2341x_update(itv, ivtv_api_func, NULL, &itv->params);
 974                 }
 975
 976                 /* Start Passthrough Mode */
 977                 ivtv_vapi(itv, CX2341X_ENC_START_CAPTURE, 2, 2, 11);
 978                 atomic_inc(&itv->capturing);
 979                 return 0;
 980         }
 981
 982         if (itv->output_mode != OUT_PASSTHROUGH)
 983                 return 0;
 984
 985         /* Stop Passthrough Mode */
 986         ivtv_vapi(itv, CX2341X_ENC_STOP_CAPTURE, 3, 1, 2, 11);
 987         ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3, 1, 0, 0);
 988
 989         atomic_dec(&itv->capturing);
 990         atomic_dec(&itv->decoding);
 991         clear_bit(IVTV_F_S_PASSTHROUGH, &dec_stream->s_flags);
 992         clear_bit(IVTV_F_S_STREAMING, &dec_stream->s_flags);
 993         itv->output_mode = OUT_NONE;
 994
 995         return 0;
 996 }