SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/media/video/ivtv/ivtv-streams.c

   1 /*
   2     init/start/stop/exit stream functions
   3     Copyright (C) 2003-2004  Kevin Thayer <nufan_wfk at yahoo.com>
   4     Copyright (C) 2004  Chris Kennedy <c@groovy.org>
   5     Copyright (C) 2005-2007  Hans Verkuil <hverkuil@xs4all.nl>
   6
   7     This program is free software; you can redistribute it and/or modify
   8     it under the terms of the GNU General Public License as published by
   9     the Free Software Foundation; either version 2 of the License, or
  10     (at your option) any later version.
  11
  12     This program is distributed in the hope that it will be useful,
  13     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15     GNU General Public License for more details.
  16
  17     You should have received a copy of the GNU General Public License
  18     along with this program; if not, write to the Free Software
  19     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 /* License: GPL
  23  * Author: Kevin Thayer <nufan_wfk at yahoo dot com>
  24  *
  25  * This file will hold API related functions, both internal (firmware api)
  26  * and external (v4l2, etc)
  27  *
  28  * -----
  29  * MPG600/MPG160 support by  T.Adachi <tadachi@tadachi-net.com>
  30  *                      and Takeru KOMORIYA<komoriya@paken.org>
  31  *
  32  * AVerMedia M179 GPIO info by Chris Pinkham <cpinkham@bc2va.org>
  33  *                using information provided by Jiun-Kuei Jung @ AVerMedia.
  34  */
  35
  36 #include "ivtv-driver.h"
  37 #include "ivtv-fileops.h"
  38 #include "ivtv-queue.h"
  39 #include "ivtv-mailbox.h"
  40 #include "ivtv-ioctl.h"
  41 #include "ivtv-irq.h"
  42 #include "ivtv-yuv.h"
  43 #include "ivtv-cards.h"
  44 #include "ivtv-streams.h"
  45 #include <media/v4l2-event.h>
  46
  47 static const struct v4l2_file_operations ivtv_v4l2_enc_fops = {
  48         .owner = THIS_MODULE,
  49         .read = ivtv_v4l2_read,
  50         .write = ivtv_v4l2_write,
  51         .open = ivtv_v4l2_open,
  52         .unlocked_ioctl = ivtv_v4l2_ioctl,
  53         .release = ivtv_v4l2_close,
  54         .poll = ivtv_v4l2_enc_poll,
  55 };
  56
  57 static const struct v4l2_file_operations ivtv_v4l2_dec_fops = {
  58         .owner = THIS_MODULE,
  59         .read = ivtv_v4l2_read,
  60         .write = ivtv_v4l2_write,
  61         .open = ivtv_v4l2_open,
  62         .unlocked_ioctl = ivtv_v4l2_ioctl,
  63         .release = ivtv_v4l2_close,
  64         .poll = ivtv_v4l2_dec_poll,
  65 };
  66
  67 #define IVTV_V4L2_DEC_MPG_OFFSET  16    /* offset from 0 to register decoder mpg v4l2 minors on */
  68 #define IVTV_V4L2_ENC_PCM_OFFSET  24    /* offset from 0 to register pcm v4l2 minors on */
  69 #define IVTV_V4L2_ENC_YUV_OFFSET  32    /* offset from 0 to register yuv v4l2 minors on */
  70 #define IVTV_V4L2_DEC_YUV_OFFSET  48    /* offset from 0 to register decoder yuv v4l2 minors on */
  71 #define IVTV_V4L2_DEC_VBI_OFFSET   8    /* offset from 0 to register decoder vbi input v4l2 minors on */
  72 #define IVTV_V4L2_DEC_VOUT_OFFSET 16    /* offset from 0 to register vbi output v4l2 minors on */
  73
  74 static struct {
  75         const char *name;
  76         int vfl_type;
  77         int num_offset;
  78         int dma, pio;
  79         enum v4l2_buf_type buf_type;
  80         const struct v4l2_file_operations *fops;
  81 } ivtv_stream_info[] = {
  82         {       /* IVTV_ENC_STREAM_TYPE_MPG */
  83                 "encoder MPG",
  84                 VFL_TYPE_GRABBER, 0,
  85                 PCI_DMA_FROMDEVICE, 0, V4L2_BUF_TYPE_VIDEO_CAPTURE,
  86                 &ivtv_v4l2_enc_fops
  87         },
  88         {       /* IVTV_ENC_STREAM_TYPE_YUV */
  89                 "encoder YUV",
  90                 VFL_TYPE_GRABBER, IVTV_V4L2_ENC_YUV_OFFSET,
  91                 PCI_DMA_FROMDEVICE, 0, V4L2_BUF_TYPE_VIDEO_CAPTURE,
  92                 &ivtv_v4l2_enc_fops
  93         },
  94         {       /* IVTV_ENC_STREAM_TYPE_VBI */
  95                 "encoder VBI",
  96                 VFL_TYPE_VBI, 0,
  97                 PCI_DMA_FROMDEVICE, 0, V4L2_BUF_TYPE_VBI_CAPTURE,
  98                 &ivtv_v4l2_enc_fops
  99         },
 100         {       /* IVTV_ENC_STREAM_TYPE_PCM */
 101                 "encoder PCM",
 102                 VFL_TYPE_GRABBER, IVTV_V4L2_ENC_PCM_OFFSET,
 103                 PCI_DMA_FROMDEVICE, 0, V4L2_BUF_TYPE_PRIVATE,
 104                 &ivtv_v4l2_enc_fops
 105         },
 106         {       /* IVTV_ENC_STREAM_TYPE_RAD */
 107                 "encoder radio",
 108                 VFL_TYPE_RADIO, 0,
 109                 PCI_DMA_NONE, 1, V4L2_BUF_TYPE_PRIVATE,
 110                 &ivtv_v4l2_enc_fops
 111         },
 112         {       /* IVTV_DEC_STREAM_TYPE_MPG */
 113                 "decoder MPG",
 114                 VFL_TYPE_GRABBER, IVTV_V4L2_DEC_MPG_OFFSET,
 115                 PCI_DMA_TODEVICE, 0, V4L2_BUF_TYPE_VIDEO_OUTPUT,
 116                 &ivtv_v4l2_dec_fops
 117         },
 118         {       /* IVTV_DEC_STREAM_TYPE_VBI */
 119                 "decoder VBI",
 120                 VFL_TYPE_VBI, IVTV_V4L2_DEC_VBI_OFFSET,
 121                 PCI_DMA_NONE, 1, V4L2_BUF_TYPE_VBI_CAPTURE,
 122                 &ivtv_v4l2_enc_fops
 123         },
 124         {       /* IVTV_DEC_STREAM_TYPE_VOUT */
 125                 "decoder VOUT",
 126                 VFL_TYPE_VBI, IVTV_V4L2_DEC_VOUT_OFFSET,
 127                 PCI_DMA_NONE, 1, V4L2_BUF_TYPE_VBI_OUTPUT,
 128                 &ivtv_v4l2_dec_fops
 129         },
 130         {       /* IVTV_DEC_STREAM_TYPE_YUV */
 131                 "decoder YUV",
 132                 VFL_TYPE_GRABBER, IVTV_V4L2_DEC_YUV_OFFSET,
 133                 PCI_DMA_TODEVICE, 0, V4L2_BUF_TYPE_VIDEO_OUTPUT,
 134                 &ivtv_v4l2_dec_fops
 135         }
 136 };
 137
 138 static void ivtv_stream_init(struct ivtv *itv, int type)
 139 {
 140         struct ivtv_stream *s = &itv->streams[type];
 141         struct video_device *vdev = s->vdev;
 142
 143         /* we need to keep vdev, so restore it afterwards */
 144         memset(s, 0, sizeof(*s));
 145         s->vdev = vdev;
 146
 147         /* initialize ivtv_stream fields */
 148         s->itv = itv;
 149         s->type = type;
 150         s->name = ivtv_stream_info[type].name;
 151
 152         if (ivtv_stream_info[type].pio)
 153                 s->dma = PCI_DMA_NONE;
 154         else
 155                 s->dma = ivtv_stream_info[type].dma;
 156         s->buf_size = itv->stream_buf_size[type];
 157         if (s->buf_size)
 158                 s->buffers = (itv->options.kilobytes[type] * 1024 + s->buf_size - 1) / s->buf_size;
 159         spin_lock_init(&s->qlock);
 160         init_waitqueue_head(&s->waitq);
 161         s->id = -1;
 162         s->sg_handle = IVTV_DMA_UNMAPPED;
 163         ivtv_queue_init(&s->q_free);
 164         ivtv_queue_init(&s->q_full);
 165         ivtv_queue_init(&s->q_dma);
 166         ivtv_queue_init(&s->q_predma);
 167         ivtv_queue_init(&s->q_io);
 168 }
 169
 170 static int ivtv_prep_dev(struct ivtv *itv, int type)
 171 {
 172         struct ivtv_stream *s = &itv->streams[type];
 173         int num_offset = ivtv_stream_info[type].num_offset;
 174         int num = itv->instance + ivtv_first_minor + num_offset;
 175
 176         /* These four fields are always initialized. If vdev == NULL, then
 177            this stream is not in use. In that case no other fields but these
 178            four can be used. */
 179         s->vdev = NULL;
 180         s->itv = itv;
 181         s->type = type;
 182         s->name = ivtv_stream_info[type].name;
 183
 184         /* Check whether the radio is supported */
 185         if (type == IVTV_ENC_STREAM_TYPE_RAD && !(itv->v4l2_cap & V4L2_CAP_RADIO))
 186                 return 0;
 187         if (type >= IVTV_DEC_STREAM_TYPE_MPG && !(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
 188                 return 0;
 189
 190         /* User explicitly selected 0 buffers for these streams, so don't
 191            create them. */
 192         if (ivtv_stream_info[type].dma != PCI_DMA_NONE &&
 193             itv->options.kilobytes[type] == 0) {
 194                 IVTV_INFO("Disabled %s device\n", ivtv_stream_info[type].name);
 195                 return 0;
 196         }
 197
 198         ivtv_stream_init(itv, type);
 199
 200         /* allocate and initialize the v4l2 video device structure */
 201         s->vdev = video_device_alloc();
 202         if (s->vdev == NULL) {
 203                 IVTV_ERR("Couldn't allocate v4l2 video_device for %s\n", s->name);
 204                 return -ENOMEM;
 205         }
 206
 207         snprintf(s->vdev->name, sizeof(s->vdev->name), "%s %s",
 208                         itv->v4l2_dev.name, s->name);
 209
 210         s->vdev->num = num;
 211         s->vdev->v4l2_dev = &itv->v4l2_dev;
 212         s->vdev->fops = ivtv_stream_info[type].fops;
 213         s->vdev->release = video_device_release;
 214         s->vdev->tvnorms = V4L2_STD_ALL;
 215         ivtv_set_funcs(s->vdev);
 216         return 0;
 217 }
 218
 219 /* Initialize v4l2 variables and prepare v4l2 devices */
 220 int ivtv_streams_setup(struct ivtv *itv)
 221 {
 222         int type;
 223
 224         /* Setup V4L2 Devices */
 225         for (type = 0; type < IVTV_MAX_STREAMS; type++) {
 226                 /* Prepare device */
 227                 if (ivtv_prep_dev(itv, type))
 228                         break;
 229
 230                 if (itv->streams[type].vdev == NULL)
 231                         continue;
 232
 233                 /* Allocate Stream */
 234                 if (ivtv_stream_alloc(&itv->streams[type]))
 235                         break;
 236         }
 237         if (type == IVTV_MAX_STREAMS)
 238                 return 0;
 239
 240         /* One or more streams could not be initialized. Clean 'em all up. */
 241         ivtv_streams_cleanup(itv, 0);
 242         return -ENOMEM;
 243 }
 244
 245 static int ivtv_reg_dev(struct ivtv *itv, int type)
 246 {
 247         struct ivtv_stream *s = &itv->streams[type];
 248         int vfl_type = ivtv_stream_info[type].vfl_type;
 249         const char *name;
 250         int num;
 251
 252         if (s->vdev == NULL)
 253                 return 0;
 254
 255         num = s->vdev->num;
 256         /* card number + user defined offset + device offset */
 257         if (type != IVTV_ENC_STREAM_TYPE_MPG) {
 258                 struct ivtv_stream *s_mpg = &itv->streams[IVTV_ENC_STREAM_TYPE_MPG];
 259
 260                 if (s_mpg->vdev)
 261                         num = s_mpg->vdev->num + ivtv_stream_info[type].num_offset;
 262         }
 263         video_set_drvdata(s->vdev, s);
 264
 265         /* Register device. First try the desired minor, then any free one. */
 266         if (video_register_device_no_warn(s->vdev, vfl_type, num)) {
 267                 IVTV_ERR("Couldn't register v4l2 device for %s (device node number %d)\n",
 268                                 s->name, num);
 269                 video_device_release(s->vdev);
 270                 s->vdev = NULL;
 271                 return -ENOMEM;
 272         }
 273         name = video_device_node_name(s->vdev);
 274
 275         switch (vfl_type) {
 276         case VFL_TYPE_GRABBER:
 277                 IVTV_INFO("Registered device %s for %s (%d kB)\n",
 278                         name, s->name, itv->options.kilobytes[type]);
 279                 break;
 280         case VFL_TYPE_RADIO:
 281                 IVTV_INFO("Registered device %s for %s\n",
 282                         name, s->name);
 283                 break;
 284         case VFL_TYPE_VBI:
 285                 if (itv->options.kilobytes[type])
 286                         IVTV_INFO("Registered device %s for %s (%d kB)\n",
 287                                 name, s->name, itv->options.kilobytes[type]);
 288                 else
 289                         IVTV_INFO("Registered device %s for %s\n",
 290                                 name, s->name);
 291                 break;
 292         }
 293         return 0;
 294 }
 295
 296 /* Register v4l2 devices */
 297 int ivtv_streams_register(struct ivtv *itv)
 298 {
 299         int type;
 300         int err = 0;
 301
 302         /* Register V4L2 devices */
 303         for (type = 0; type < IVTV_MAX_STREAMS; type++)
 304                 err |= ivtv_reg_dev(itv, type);
 305
 306         if (err == 0)
 307                 return 0;
 308
 309         /* One or more streams could not be initialized. Clean 'em all up. */
 310         ivtv_streams_cleanup(itv, 1);
 311         return -ENOMEM;
 312 }
 313
 314 /* Unregister v4l2 devices */
 315 void ivtv_streams_cleanup(struct ivtv *itv, int unregister)
 316 {
 317         int type;
 318
 319         /* Teardown all streams */
 320         for (type = 0; type < IVTV_MAX_STREAMS; type++) {
 321                 struct video_device *vdev = itv->streams[type].vdev;
 322
 323                 itv->streams[type].vdev = NULL;
 324                 if (vdev == NULL)
 325                         continue;
 326
 327                 ivtv_stream_free(&itv->streams[type]);
 328                 /* Unregister or release device */
 329                 if (unregister)
 330                         video_unregister_device(vdev);
 331                 else
 332                         video_device_release(vdev);
 333         }
 334 }
 335
 336 static void ivtv_vbi_setup(struct ivtv *itv)
 337 {
 338         int raw = ivtv_raw_vbi(itv);
 339         u32 data[CX2341X_MBOX_MAX_DATA];
 340         int lines;
 341         int i;
 342
 343         /* Reset VBI */
 344         ivtv_vapi(itv, CX2341X_ENC_SET_VBI_LINE, 5, 0xffff , 0, 0, 0, 0);
 345
 346         /* setup VBI registers */
 347         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
 622         if (s->vdev == NULL)
 623                 return -EINVAL;
 624
 625         IVTV_DEBUG_INFO("Setting some initial decoder settings\n");
 626
 627         /* set audio mode to left/stereo  for dual/stereo mode. */
 628         ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode);
 629
 630         /* set number of internal decoder buffers */
 631         ivtv_vapi(itv, CX2341X_DEC_SET_DISPLAY_BUFFERS, 1, 0);
 632
 633         /* prebuffering */
 634         ivtv_vapi(itv, CX2341X_DEC_SET_PREBUFFERING, 1, 1);
 635
 636         /* extract from user packets */
 637         ivtv_vapi_result(itv, data, CX2341X_DEC_EXTRACT_VBI, 1, 1);
 638         itv->vbi.dec_start = data[0];
 639
 640         IVTV_DEBUG_INFO("Decoder VBI RE-Insert start 0x%08x size 0x%08x\n",
 641                 itv->vbi.dec_start, data[1]);
 642
 643         /* set decoder source settings */
 644         /* Data type: 0 = mpeg from host,
 645            1 = yuv from encoder,
 646            2 = yuv_from_host */
 647         switch (s->type) {
 648         case IVTV_DEC_STREAM_TYPE_YUV:
 649                 datatype = itv->output_mode == OUT_PASSTHROUGH ? 1 : 2;
 650                 IVTV_DEBUG_INFO("Setup DEC YUV Stream data[0] = %d\n", datatype);
 651                 break;
 652         case IVTV_DEC_STREAM_TYPE_MPG:
 653         default:
 654                 datatype = 0;
 655                 break;
 656         }
 657         if (ivtv_vapi(itv, CX2341X_DEC_SET_DECODER_SOURCE, 4, datatype,
 658                         p->width, p->height, p->audio_properties)) {
 659                 IVTV_DEBUG_WARN("Couldn't initialize decoder source\n");
 660         }
 661         return 0;
 662 }
 663
 664 int ivtv_start_v4l2_decode_stream(struct ivtv_stream *s, int gop_offset)
 665 {
 666         struct ivtv *itv = s->itv;
 667
 668         if (s->vdev == NULL)
 669                 return -EINVAL;
 670
 671         if (test_and_set_bit(IVTV_F_S_STREAMING, &s->s_flags))
 672                 return 0;       /* already started */
 673
 674         IVTV_DEBUG_INFO("Starting decode stream %s (gop_offset %d)\n", s->name, gop_offset);
 675
 676         ivtv_setup_v4l2_decode_stream(s);
 677
 678         /* set dma size to 65536 bytes */
 679         ivtv_vapi(itv, CX2341X_DEC_SET_DMA_BLOCK_SIZE, 1, 65536);
 680
 681         /* Clear Streamoff */
 682         clear_bit(IVTV_F_S_STREAMOFF, &s->s_flags);
 683
 684         /* Zero out decoder counters */
 685         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[0]);
 686         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[1]);
 687         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[2]);
 688         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[3]);
 689         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[0]);
 690         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[1]);
 691         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[2]);
 692         writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[3]);
 693
 694         /* turn on notification of dual/stereo mode change */
 695         ivtv_vapi(itv, CX2341X_DEC_SET_EVENT_NOTIFICATION, 4, 0, 1, IVTV_IRQ_DEC_AUD_MODE_CHG, -1);
 696
 697         /* start playback */
 698         ivtv_vapi(itv, CX2341X_DEC_START_PLAYBACK, 2, gop_offset, 0);
 699
 700         /* Clear the following Interrupt mask bits for decoding */
 701         ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_DECODE);
 702         IVTV_DEBUG_IRQ("IRQ Mask is now: 0x%08x\n", itv->irqmask);
 703
 704         /* you're live! sit back and await interrupts :) */
 705         atomic_inc(&itv->decoding);
 706         return 0;
 707 }
 708
 709 void ivtv_stop_all_captures(struct ivtv *itv)
 710 {
 711         int i;
 712
 713         for (i = IVTV_MAX_STREAMS - 1; i >= 0; i--) {
 714                 struct ivtv_stream *s = &itv->streams[i];
 715
 716                 if (s->vdev == NULL)
 717                         continue;
 718                 if (test_bit(IVTV_F_S_STREAMING, &s->s_flags)) {
 719                         ivtv_stop_v4l2_encode_stream(s, 0);
 720                 }
 721         }
 722 }
 723
 724 int ivtv_stop_v4l2_encode_stream(struct ivtv_stream *s, int gop_end)
 725 {
 726         struct ivtv *itv = s->itv;
 727         DECLARE_WAITQUEUE(wait, current);
 728         int cap_type;
 729         int stopmode;
 730
 731         if (s->vdev == NULL)
 732                 return -EINVAL;
 733
 734         /* This function assumes that you are allowed to stop the capture
 735            and that we are actually capturing */
 736
 737         IVTV_DEBUG_INFO("Stop Capture\n");
 738
 739         if (s->type == IVTV_DEC_STREAM_TYPE_VOUT)
 740                 return 0;
 741         if (atomic_read(&itv->capturing) == 0)
 742                 return 0;
 743
 744         switch (s->type) {
 745         case IVTV_ENC_STREAM_TYPE_YUV:
 746                 cap_type = 1;
 747                 break;
 748         case IVTV_ENC_STREAM_TYPE_PCM:
 749                 cap_type = 1;
 750                 break;
 751         case IVTV_ENC_STREAM_TYPE_VBI:
 752                 cap_type = 1;
 753                 break;
 754         case IVTV_ENC_STREAM_TYPE_MPG:
 755         default:
 756                 cap_type = 0;
 757                 break;
 758         }
 759
 760         /* Stop Capture Mode */
 761         if (s->type == IVTV_ENC_STREAM_TYPE_MPG && gop_end) {
 762                 stopmode = 0;
 763         } else {
 764                 stopmode = 1;
 765         }
 766
 767         /* end_capture */
 768         /* when: 0 =  end of GOP  1 = NOW!, type: 0 = mpeg, subtype: 3 = video+audio */
 769         ivtv_vapi(itv, CX2341X_ENC_STOP_CAPTURE, 3, stopmode, cap_type, s->subtype);
 770
 771         if (!test_bit(IVTV_F_S_PASSTHROUGH, &s->s_flags)) {
 772                 if (s->type == IVTV_ENC_STREAM_TYPE_MPG && gop_end) {
 773                         /* only run these if we're shutting down the last cap */
 774                         unsigned long duration;
 775                         unsigned long then = jiffies;
 776
 777                         add_wait_queue(&itv->eos_waitq, &wait);
 778
 779                         set_current_state(TASK_INTERRUPTIBLE);
 780
 781                         /* wait 2s for EOS interrupt */
 782                         while (!test_bit(IVTV_F_I_EOS, &itv->i_flags) &&
 783                                 time_before(jiffies,
 784                                             then + msecs_to_jiffies(2000))) {
 785                                 schedule_timeout(msecs_to_jiffies(10));
 786                         }
 787
 788                         /* To convert jiffies to ms, we must multiply by 1000
 789                          * and divide by HZ.  To avoid runtime division, we
 790                          * convert this to multiplication by 1000/HZ.
 791                          * Since integer division truncates, we get the best
 792                          * accuracy if we do a rounding calculation of the constant.
 793                          * Think of the case where HZ is 1024.
 794                          */
 795                         duration = ((1000 + HZ / 2) / HZ) * (jiffies - then);
 796
 797                         if (!test_bit(IVTV_F_I_EOS, &itv->i_flags)) {
 798                                 IVTV_DEBUG_WARN("%s: EOS interrupt not received! stopping anyway.\n", s->name);
 799                                 IVTV_DEBUG_WARN("%s: waited %lu ms.\n", s->name, duration);
 800                         } else {
 801                                 IVTV_DEBUG_INFO("%s: EOS took %lu ms to occur.\n", s->name, duration);
 802                         }
 803                         set_current_state(TASK_RUNNING);
 804                         remove_wait_queue(&itv->eos_waitq, &wait);
 805                         set_bit(IVTV_F_S_STREAMOFF, &s->s_flags);
 806                 }
 807
 808                 /* Handle any pending interrupts */
 809                 ivtv_msleep_timeout(100, 1);
 810         }
 811
 812         atomic_dec(&itv->capturing);
 813
 814         /* Clear capture and no-read bits */
 815         clear_bit(IVTV_F_S_STREAMING, &s->s_flags);
 816
 817         if (s->type == IVTV_ENC_STREAM_TYPE_VBI)
 818                 ivtv_set_irq_mask(itv, IVTV_IRQ_ENC_VBI_CAP);
 819
 820         if (atomic_read(&itv->capturing) > 0) {
 821                 return 0;
 822         }
 823
 824         /* Set the following Interrupt mask bits for capture */
 825         ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE);
 826         del_timer(&itv->dma_timer);
 827
 828         /* event notification (off) */
 829         if (test_and_clear_bit(IVTV_F_I_DIG_RST, &itv->i_flags)) {
 830                 /* type: 0 = refresh */
 831                 /* on/off: 0 = off, intr: 0x10000000, mbox_id: -1: none */
 832                 ivtv_vapi(itv, CX2341X_ENC_SET_EVENT_NOTIFICATION, 4, 0, 0, IVTV_IRQ_ENC_VIM_RST, -1);
 833                 ivtv_set_irq_mask(itv, IVTV_IRQ_ENC_VIM_RST);
 834         }
 835
 836         /* Raw-passthrough is implied on start. Make sure it's stopped so
 837            the encoder will re-initialize when next started */
 838         ivtv_vapi(itv, CX2341X_ENC_STOP_CAPTURE, 3, 1, 2, 7);
 839
 840         wake_up(&s->waitq);
 841
 842         return 0;
 843 }
 844
 845 int ivtv_stop_v4l2_decode_stream(struct ivtv_stream *s, int flags, u64 pts)
 846 {
 847         static const struct v4l2_event ev = {
 848                 .type = V4L2_EVENT_EOS,
 849         };
 850         struct ivtv *itv = s->itv;
 851
 852         if (s->vdev == NULL)
 853                 return -EINVAL;
 854
 855         if (s->type != IVTV_DEC_STREAM_TYPE_YUV && s->type != IVTV_DEC_STREAM_TYPE_MPG)
 856                 return -EINVAL;
 857
 858         if (!test_bit(IVTV_F_S_STREAMING, &s->s_flags))
 859                 return 0;
 860
 861         IVTV_DEBUG_INFO("Stop Decode at %llu, flags: %x\n", (unsigned long long)pts, flags);
 862
 863         /* Stop Decoder */
 864         if (!(flags & VIDEO_CMD_STOP_IMMEDIATELY) || pts) {
 865                 u32 tmp = 0;
 866
 867                 /* Wait until the decoder is no longer running */
 868                 if (pts) {
 869                         ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3,
 870                                 0, (u32)(pts & 0xffffffff), (u32)(pts >> 32));
 871                 }
 872                 while (1) {
 873                         u32 data[CX2341X_MBOX_MAX_DATA];
 874                         ivtv_vapi_result(itv, data, CX2341X_DEC_GET_XFER_INFO, 0);
 875                         if (s->q_full.buffers + s->q_dma.buffers == 0) {
 876                                 if (tmp == data[3])
 877                                         break;
 878                                 tmp = data[3];
 879                         }
 880                         if (ivtv_msleep_timeout(100, 1))
 881                                 break;
 882                 }
 883         }
 884         ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3, flags & VIDEO_CMD_STOP_TO_BLACK, 0, 0);
 885
 886         /* turn off notification of dual/stereo mode change */
 887         ivtv_vapi(itv, CX2341X_DEC_SET_EVENT_NOTIFICATION, 4, 0, 0, IVTV_IRQ_DEC_AUD_MODE_CHG, -1);
 888
 889         ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_DECODE);
 890         del_timer(&itv->dma_timer);
 891
 892         clear_bit(IVTV_F_S_NEEDS_DATA, &s->s_flags);
 893         clear_bit(IVTV_F_S_STREAMING, &s->s_flags);
 894         ivtv_flush_queues(s);
 895
 896         /* decrement decoding */
 897         atomic_dec(&itv->decoding);
 898
 899         set_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags);
 900         wake_up(&itv->event_waitq);
 901         v4l2_event_queue(s->vdev, &ev);
 902
 903         /* wake up wait queues */
 904         wake_up(&s->waitq);
 905
 906         return 0;
 907 }
 908
 909 int ivtv_passthrough_mode(struct ivtv *itv, int enable)
 910 {
 911         struct ivtv_stream *yuv_stream = &itv->streams[IVTV_ENC_STREAM_TYPE_YUV];
 912         struct ivtv_stream *dec_stream = &itv->streams[IVTV_DEC_STREAM_TYPE_YUV];
 913
 914         if (yuv_stream->vdev == NULL || dec_stream->vdev == NULL)
 915                 return -EINVAL;
 916
 917         IVTV_DEBUG_INFO("ivtv ioctl: Select passthrough mode\n");
 918
 919         /* Prevent others from starting/stopping streams while we
 920            initiate/terminate passthrough mode */
 921         if (enable) {
 922                 if (itv->output_mode == OUT_PASSTHROUGH) {
 923                         return 0;
 924                 }
 925                 if (ivtv_set_output_mode(itv, OUT_PASSTHROUGH) != OUT_PASSTHROUGH)
 926                         return -EBUSY;
 927
 928                 /* Fully initialize stream, and then unflag init */
 929                 set_bit(IVTV_F_S_PASSTHROUGH, &dec_stream->s_flags);
 930                 set_bit(IVTV_F_S_STREAMING, &dec_stream->s_flags);
 931
 932                 /* Setup YUV Decoder */
 933                 ivtv_setup_v4l2_decode_stream(dec_stream);
 934
 935                 /* Start Decoder */
 936                 ivtv_vapi(itv, CX2341X_DEC_START_PLAYBACK, 2, 0, 1);
 937                 atomic_inc(&itv->decoding);
 938
 939                 /* Setup capture if not already done */
 940                 if (atomic_read(&itv->capturing) == 0) {
 941                         cx2341x_update(itv, ivtv_api_func, NULL, &itv->params);
 942                 }
 943
 944                 /* Start Passthrough Mode */
 945                 ivtv_vapi(itv, CX2341X_ENC_START_CAPTURE, 2, 2, 11);
 946                 atomic_inc(&itv->capturing);
 947                 return 0;
 948         }
 949
 950         if (itv->output_mode != OUT_PASSTHROUGH)
 951                 return 0;
 952
 953         /* Stop Passthrough Mode */
 954         ivtv_vapi(itv, CX2341X_ENC_STOP_CAPTURE, 3, 1, 2, 11);
 955         ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3, 1, 0, 0);
 956
 957         atomic_dec(&itv->capturing);
 958         atomic_dec(&itv->decoding);
 959         clear_bit(IVTV_F_S_PASSTHROUGH, &dec_stream->s_flags);
 960         clear_bit(IVTV_F_S_STREAMING, &dec_stream->s_flags);
 961         itv->output_mode = OUT_NONE;
 962
 963         return 0;
 964 }