drivers/media/pci/saa7164/saa7164-encoder.c

   1 /*
   2  *  Driver for the NXP SAA7164 PCIe bridge
   3  *
   4  *  Copyright (c) 2010-2015 Steven Toth <stoth@kernellabs.com>
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *
  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., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  */
  21
  22 #include "saa7164.h"
  23
  24 #define ENCODER_MAX_BITRATE 6500000
  25 #define ENCODER_MIN_BITRATE 1000000
  26 #define ENCODER_DEF_BITRATE 5000000
  27
  28 /*
  29  * This is a dummy non-zero value for the sizeimage field of v4l2_pix_format.
  30  * It is not actually used for anything since this driver does not support
  31  * stream I/O, only read(), and because this driver produces an MPEG stream
  32  * and not discrete frames. But the V4L2 spec doesn't allow for this value
  33  * to be 0, so set it to 0x10000 instead.
  34  *
  35  * If we ever change this driver to support stream I/O, then this field
  36  * will be the size of the streaming buffers.
  37  */
  38 #define SAA7164_SIZEIMAGE (0x10000)
  39
  40 static struct saa7164_tvnorm saa7164_tvnorms[] = {
  41         {
  42                 .name      = "NTSC-M",
  43                 .id        = V4L2_STD_NTSC_M,
  44         }, {
  45                 .name      = "NTSC-JP",
  46                 .id        = V4L2_STD_NTSC_M_JP,
  47         }
  48 };
  49
  50 /* Take the encoder configuration form the port struct and
  51  * flush it to the hardware.
  52  */
  53 static void saa7164_encoder_configure(struct saa7164_port *port)
  54 {
  55         struct saa7164_dev *dev = port->dev;
  56         dprintk(DBGLVL_ENC, "%s()\n", __func__);
  57
  58         port->encoder_params.width = port->width;
  59         port->encoder_params.height = port->height;
  60         port->encoder_params.is_50hz =
  61                 (port->encodernorm.id & V4L2_STD_625_50) != 0;
  62
  63         /* Set up the DIF (enable it) for analog mode by default */
  64         saa7164_api_initialize_dif(port);
  65
  66         /* Configure the correct video standard */
  67         saa7164_api_configure_dif(port, port->encodernorm.id);
  68
  69         /* Ensure the audio decoder is correct configured */
  70         saa7164_api_set_audio_std(port);
  71 }
  72
  73 static int saa7164_encoder_buffers_dealloc(struct saa7164_port *port)
  74 {
  75         struct list_head *c, *n, *p, *q, *l, *v;
  76         struct saa7164_dev *dev = port->dev;
  77         struct saa7164_buffer *buf;
  78         struct saa7164_user_buffer *ubuf;
  79
  80         /* Remove any allocated buffers */
  81         mutex_lock(&port->dmaqueue_lock);
  82
  83         dprintk(DBGLVL_ENC, "%s(port=%d) dmaqueue\n", __func__, port->nr);
  84         list_for_each_safe(c, n, &port->dmaqueue.list) {
  85                 buf = list_entry(c, struct saa7164_buffer, list);
  86                 list_del(c);
  87                 saa7164_buffer_dealloc(buf);
  88         }
  89
  90         dprintk(DBGLVL_ENC, "%s(port=%d) used\n", __func__, port->nr);
  91         list_for_each_safe(p, q, &port->list_buf_used.list) {
  92                 ubuf = list_entry(p, struct saa7164_user_buffer, list);
  93                 list_del(p);
  94                 saa7164_buffer_dealloc_user(ubuf);
  95         }
  96
  97         dprintk(DBGLVL_ENC, "%s(port=%d) free\n", __func__, port->nr);
  98         list_for_each_safe(l, v, &port->list_buf_free.list) {
  99                 ubuf = list_entry(l, struct saa7164_user_buffer, list);
 100                 list_del(l);
 101                 saa7164_buffer_dealloc_user(ubuf);
 102         }
 103
 104         mutex_unlock(&port->dmaqueue_lock);
 105         dprintk(DBGLVL_ENC, "%s(port=%d) done\n", __func__, port->nr);
 106
 107         return 0;
 108 }
 109
 110 /* Dynamic buffer switch at encoder start time */
 111 static int saa7164_encoder_buffers_alloc(struct saa7164_port *port)
 112 {
 113         struct saa7164_dev *dev = port->dev;
 114         struct saa7164_buffer *buf;
 115         struct saa7164_user_buffer *ubuf;
 116         struct tmHWStreamParameters *params = &port->hw_streamingparams;
 117         int result = -ENODEV, i;
 118         int len = 0;
 119
 120         dprintk(DBGLVL_ENC, "%s()\n", __func__);
 121
 122         if (port->encoder_params.stream_type ==
 123                 V4L2_MPEG_STREAM_TYPE_MPEG2_PS) {
 124                 dprintk(DBGLVL_ENC,
 125                         "%s() type=V4L2_MPEG_STREAM_TYPE_MPEG2_PS\n",
 126                         __func__);
 127                 params->samplesperline = 128;
 128                 params->numberoflines = 256;
 129                 params->pitch = 128;
 130                 params->numpagetables = 2 +
 131                         ((SAA7164_PS_NUMBER_OF_LINES * 128) / PAGE_SIZE);
 132         } else
 133         if (port->encoder_params.stream_type ==
 134                 V4L2_MPEG_STREAM_TYPE_MPEG2_TS) {
 135                 dprintk(DBGLVL_ENC,
 136                         "%s() type=V4L2_MPEG_STREAM_TYPE_MPEG2_TS\n",
 137                         __func__);
 138                 params->samplesperline = 188;
 139                 params->numberoflines = 312;
 140                 params->pitch = 188;
 141                 params->numpagetables = 2 +
 142                         ((SAA7164_TS_NUMBER_OF_LINES * 188) / PAGE_SIZE);
 143         } else
 144                 BUG();
 145
 146         /* Init and establish defaults */
 147         params->bitspersample = 8;
 148         params->linethreshold = 0;
 149         params->pagetablelistvirt = NULL;
 150         params->pagetablelistphys = NULL;
 151         params->numpagetableentries = port->hwcfg.buffercount;
 152
 153         /* Allocate the PCI resources, buffers (hard) */
 154         for (i = 0; i < port->hwcfg.buffercount; i++) {
 155                 buf = saa7164_buffer_alloc(port,
 156                         params->numberoflines *
 157                         params->pitch);
 158
 159                 if (!buf) {
 160                         printk(KERN_ERR "%s() failed "
 161                                "(errno = %d), unable to allocate buffer\n",
 162                                 __func__, result);
 163                         result = -ENOMEM;
 164                         goto failed;
 165                 } else {
 166
 167                         mutex_lock(&port->dmaqueue_lock);
 168                         list_add_tail(&buf->list, &port->dmaqueue.list);
 169                         mutex_unlock(&port->dmaqueue_lock);
 170
 171                 }
 172         }
 173
 174         /* Allocate some kernel buffers for copying
 175          * to userpsace.
 176          */
 177         len = params->numberoflines * params->pitch;
 178
 179         if (encoder_buffers < 16)
 180                 encoder_buffers = 16;
 181         if (encoder_buffers > 512)
 182                 encoder_buffers = 512;
 183
 184         for (i = 0; i < encoder_buffers; i++) {
 185
 186                 ubuf = saa7164_buffer_alloc_user(dev, len);
 187                 if (ubuf) {
 188                         mutex_lock(&port->dmaqueue_lock);
 189                         list_add_tail(&ubuf->list, &port->list_buf_free.list);
 190                         mutex_unlock(&port->dmaqueue_lock);
 191                 }
 192
 193         }
 194
 195         result = 0;
 196
 197 failed:
 198         return result;
 199 }
 200
 201 static int saa7164_encoder_initialize(struct saa7164_port *port)
 202 {
 203         saa7164_encoder_configure(port);
 204         return 0;
 205 }
 206
 207 /* -- V4L2 --------------------------------------------------------- */
 208 int saa7164_s_std(struct saa7164_port *port, v4l2_std_id id)
 209 {
 210         struct saa7164_dev *dev = port->dev;
 211         unsigned int i;
 212
 213         dprintk(DBGLVL_ENC, "%s(id=0x%x)\n", __func__, (u32)id);
 214
 215         for (i = 0; i < ARRAY_SIZE(saa7164_tvnorms); i++) {
 216                 if (id & saa7164_tvnorms[i].id)
 217                         break;
 218         }
 219         if (i == ARRAY_SIZE(saa7164_tvnorms))
 220                 return -EINVAL;
 221
 222         port->encodernorm = saa7164_tvnorms[i];
 223         port->std = id;
 224
 225         /* Update the audio decoder while is not running in
 226          * auto detect mode.
 227          */
 228         saa7164_api_set_audio_std(port);
 229
 230         dprintk(DBGLVL_ENC, "%s(id=0x%x) OK\n", __func__, (u32)id);
 231
 232         return 0;
 233 }
 234
 235 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id id)
 236 {
 237         struct saa7164_encoder_fh *fh = file->private_data;
 238
 239         return saa7164_s_std(fh->port, id);
 240 }
 241
 242 int saa7164_g_std(struct saa7164_port *port, v4l2_std_id *id)
 243 {
 244         *id = port->std;
 245         return 0;
 246 }
 247
 248 static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *id)
 249 {
 250         struct saa7164_encoder_fh *fh = file->private_data;
 251
 252         return saa7164_g_std(fh->port, id);
 253 }
 254
 255 int saa7164_enum_input(struct file *file, void *priv, struct v4l2_input *i)
 256 {
 257         static const char * const inputs[] = {
 258                 "tuner", "composite", "svideo", "aux",
 259                 "composite 2", "svideo 2", "aux 2"
 260         };
 261         int n;
 262
 263         if (i->index >= 7)
 264                 return -EINVAL;
 265
 266         strcpy(i->name, inputs[i->index]);
 267
 268         if (i->index == 0)
 269                 i->type = V4L2_INPUT_TYPE_TUNER;
 270         else
 271                 i->type  = V4L2_INPUT_TYPE_CAMERA;
 272
 273         for (n = 0; n < ARRAY_SIZE(saa7164_tvnorms); n++)
 274                 i->std |= saa7164_tvnorms[n].id;
 275
 276         return 0;
 277 }
 278
 279 int saa7164_g_input(struct saa7164_port *port, unsigned int *i)
 280 {
 281         struct saa7164_dev *dev = port->dev;
 282
 283         if (saa7164_api_get_videomux(port) != SAA_OK)
 284                 return -EIO;
 285
 286         *i = (port->mux_input - 1);
 287
 288         dprintk(DBGLVL_ENC, "%s() input=%d\n", __func__, *i);
 289
 290         return 0;
 291 }
 292
 293 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
 294 {
 295         struct saa7164_encoder_fh *fh = file->private_data;
 296
 297         return saa7164_g_input(fh->port, i);
 298 }
 299
 300 int saa7164_s_input(struct saa7164_port *port, unsigned int i)
 301 {
 302         struct saa7164_dev *dev = port->dev;
 303
 304         dprintk(DBGLVL_ENC, "%s() input=%d\n", __func__, i);
 305
 306         if (i >= 7)
 307                 return -EINVAL;
 308
 309         port->mux_input = i + 1;
 310
 311         if (saa7164_api_set_videomux(port) != SAA_OK)
 312                 return -EIO;
 313
 314         return 0;
 315 }
 316
 317 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
 318 {
 319         struct saa7164_encoder_fh *fh = file->private_data;
 320
 321         return saa7164_s_input(fh->port, i);
 322 }
 323
 324 int saa7164_g_tuner(struct file *file, void *priv, struct v4l2_tuner *t)
 325 {
 326         struct saa7164_encoder_fh *fh = file->private_data;
 327         struct saa7164_port *port = fh->port;
 328         struct saa7164_dev *dev = port->dev;
 329
 330         if (0 != t->index)
 331                 return -EINVAL;
 332
 333         strcpy(t->name, "tuner");
 334         t->capability = V4L2_TUNER_CAP_NORM | V4L2_TUNER_CAP_STEREO;
 335         t->rangelow = SAA7164_TV_MIN_FREQ;
 336         t->rangehigh = SAA7164_TV_MAX_FREQ;
 337
 338         dprintk(DBGLVL_ENC, "VIDIOC_G_TUNER: tuner type %d\n", t->type);
 339
 340         return 0;
 341 }
 342
 343 int saa7164_s_tuner(struct file *file, void *priv,
 344                            const struct v4l2_tuner *t)
 345 {
 346         if (0 != t->index)
 347                 return -EINVAL;
 348
 349         /* Update the A/V core */
 350         return 0;
 351 }
 352
 353 int saa7164_g_frequency(struct saa7164_port *port, struct v4l2_frequency *f)
 354 {
 355         if (f->tuner)
 356                 return -EINVAL;
 357
 358         f->frequency = port->freq;
 359         return 0;
 360 }
 361
 362 static int vidioc_g_frequency(struct file *file, void *priv,
 363         struct v4l2_frequency *f)
 364 {
 365         struct saa7164_encoder_fh *fh = file->private_data;
 366
 367         return saa7164_g_frequency(fh->port, f);
 368 }
 369
 370 int saa7164_s_frequency(struct saa7164_port *port,
 371                         const struct v4l2_frequency *f)
 372 {
 373         struct saa7164_dev *dev = port->dev;
 374         struct saa7164_port *tsport;
 375         struct dvb_frontend *fe;
 376
 377         /* TODO: Pull this for the std */
 378         struct analog_parameters params = {
 379                 .mode      = V4L2_TUNER_ANALOG_TV,
 380                 .audmode   = V4L2_TUNER_MODE_STEREO,
 381                 .std       = port->encodernorm.id,
 382                 .frequency = f->frequency
 383         };
 384
 385         /* Stop the encoder */
 386         dprintk(DBGLVL_ENC, "%s() frequency=%d tuner=%d\n", __func__,
 387                 f->frequency, f->tuner);
 388
 389         if (f->tuner != 0)
 390                 return -EINVAL;
 391
 392         port->freq = clamp(f->frequency,
 393                            SAA7164_TV_MIN_FREQ, SAA7164_TV_MAX_FREQ);
 394
 395         /* Update the hardware */
 396         if (port->nr == SAA7164_PORT_ENC1)
 397                 tsport = &dev->ports[SAA7164_PORT_TS1];
 398         else if (port->nr == SAA7164_PORT_ENC2)
 399                 tsport = &dev->ports[SAA7164_PORT_TS2];
 400         else
 401                 BUG();
 402
 403         fe = tsport->dvb.frontend;
 404
 405         if (fe && fe->ops.tuner_ops.set_analog_params)
 406                 fe->ops.tuner_ops.set_analog_params(fe, &params);
 407         else
 408                 printk(KERN_ERR "%s() No analog tuner, aborting\n", __func__);
 409
 410         saa7164_encoder_initialize(port);
 411
 412         return 0;
 413 }
 414
 415 static int vidioc_s_frequency(struct file *file, void *priv,
 416                               const struct v4l2_frequency *f)
 417 {
 418         struct saa7164_encoder_fh *fh = file->private_data;
 419
 420         return saa7164_s_frequency(fh->port, f);
 421 }
 422
 423 static int saa7164_s_ctrl(struct v4l2_ctrl *ctrl)
 424 {
 425         struct saa7164_port *port =
 426                 container_of(ctrl->handler, struct saa7164_port, ctrl_handler);
 427         struct saa7164_encoder_params *params = &port->encoder_params;
 428         int ret = 0;
 429
 430         switch (ctrl->id) {
 431         case V4L2_CID_BRIGHTNESS:
 432                 port->ctl_brightness = ctrl->val;
 433                 saa7164_api_set_usercontrol(port, PU_BRIGHTNESS_CONTROL);
 434                 break;
 435         case V4L2_CID_CONTRAST:
 436                 port->ctl_contrast = ctrl->val;
 437                 saa7164_api_set_usercontrol(port, PU_CONTRAST_CONTROL);
 438                 break;
 439         case V4L2_CID_SATURATION:
 440                 port->ctl_saturation = ctrl->val;
 441                 saa7164_api_set_usercontrol(port, PU_SATURATION_CONTROL);
 442                 break;
 443         case V4L2_CID_HUE:
 444                 port->ctl_hue = ctrl->val;
 445                 saa7164_api_set_usercontrol(port, PU_HUE_CONTROL);
 446                 break;
 447         case V4L2_CID_SHARPNESS:
 448                 port->ctl_sharpness = ctrl->val;
 449                 saa7164_api_set_usercontrol(port, PU_SHARPNESS_CONTROL);
 450                 break;
 451         case V4L2_CID_AUDIO_VOLUME:
 452                 port->ctl_volume = ctrl->val;
 453                 saa7164_api_set_audio_volume(port, port->ctl_volume);
 454                 break;
 455         case V4L2_CID_MPEG_VIDEO_BITRATE:
 456                 params->bitrate = ctrl->val;
 457                 break;
 458         case V4L2_CID_MPEG_STREAM_TYPE:
 459                 params->stream_type = ctrl->val;
 460                 break;
 461         case V4L2_CID_MPEG_AUDIO_MUTE:
 462                 params->ctl_mute = ctrl->val;
 463                 ret = saa7164_api_audio_mute(port, params->ctl_mute);
 464                 if (ret != SAA_OK) {
 465                         printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__,
 466                                 ret);
 467                         ret = -EIO;
 468                 }
 469                 break;
 470         case V4L2_CID_MPEG_VIDEO_ASPECT:
 471                 params->ctl_aspect = ctrl->val;
 472                 ret = saa7164_api_set_aspect_ratio(port);
 473                 if (ret != SAA_OK) {
 474                         printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__,
 475                                 ret);
 476                         ret = -EIO;
 477                 }
 478                 break;
 479         case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
 480                 params->bitrate_mode = ctrl->val;
 481                 break;
 482         case V4L2_CID_MPEG_VIDEO_B_FRAMES:
 483                 params->refdist = ctrl->val;
 484                 break;
 485         case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
 486                 params->bitrate_peak = ctrl->val;
 487                 break;
 488         case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
 489                 params->gop_size = ctrl->val;
 490                 break;
 491         default:
 492                 ret = -EINVAL;
 493         }
 494
 495         return ret;
 496 }
 497
 498 static int vidioc_querycap(struct file *file, void  *priv,
 499         struct v4l2_capability *cap)
 500 {
 501         struct saa7164_encoder_fh *fh = file->private_data;
 502         struct saa7164_port *port = fh->port;
 503         struct saa7164_dev *dev = port->dev;
 504
 505         strcpy(cap->driver, dev->name);
 506         strlcpy(cap->card, saa7164_boards[dev->board].name,
 507                 sizeof(cap->card));
 508         sprintf(cap->bus_info, "PCI:%s", pci_name(dev->pci));
 509
 510         cap->device_caps =
 511                 V4L2_CAP_VIDEO_CAPTURE |
 512                 V4L2_CAP_READWRITE |
 513                 V4L2_CAP_TUNER;
 514
 515         cap->capabilities = cap->device_caps |
 516                 V4L2_CAP_VBI_CAPTURE |
 517                 V4L2_CAP_DEVICE_CAPS;
 518
 519         return 0;
 520 }
 521
 522 static int vidioc_enum_fmt_vid_cap(struct file *file, void  *priv,
 523         struct v4l2_fmtdesc *f)
 524 {
 525         if (f->index != 0)
 526                 return -EINVAL;
 527
 528         strlcpy(f->description, "MPEG", sizeof(f->description));
 529         f->pixelformat = V4L2_PIX_FMT_MPEG;
 530
 531         return 0;
 532 }
 533
 534 static int vidioc_fmt_vid_cap(struct file *file, void *priv,
 535                                 struct v4l2_format *f)
 536 {
 537         struct saa7164_encoder_fh *fh = file->private_data;
 538         struct saa7164_port *port = fh->port;
 539
 540         f->fmt.pix.pixelformat  = V4L2_PIX_FMT_MPEG;
 541         f->fmt.pix.bytesperline = 0;
 542         f->fmt.pix.sizeimage    = SAA7164_SIZEIMAGE;
 543         f->fmt.pix.field        = V4L2_FIELD_INTERLACED;
 544         f->fmt.pix.colorspace   = V4L2_COLORSPACE_SMPTE170M;
 545         f->fmt.pix.width        = port->width;
 546         f->fmt.pix.height       = port->height;
 547         return 0;
 548 }
 549
 550 static int saa7164_encoder_stop_port(struct saa7164_port *port)
 551 {
 552         struct saa7164_dev *dev = port->dev;
 553         int ret;
 554
 555         ret = saa7164_api_transition_port(port, SAA_DMASTATE_STOP);
 556         if ((ret != SAA_OK) && (ret != SAA_ERR_ALREADY_STOPPED)) {
 557                 printk(KERN_ERR "%s() stop transition failed, ret = 0x%x\n",
 558                         __func__, ret);
 559                 ret = -EIO;
 560         } else {
 561                 dprintk(DBGLVL_ENC, "%s()    Stopped\n", __func__);
 562                 ret = 0;
 563         }
 564
 565         return ret;
 566 }
 567
 568 static int saa7164_encoder_acquire_port(struct saa7164_port *port)
 569 {
 570         struct saa7164_dev *dev = port->dev;
 571         int ret;
 572
 573         ret = saa7164_api_transition_port(port, SAA_DMASTATE_ACQUIRE);
 574         if ((ret != SAA_OK) && (ret != SAA_ERR_ALREADY_STOPPED)) {
 575                 printk(KERN_ERR "%s() acquire transition failed, ret = 0x%x\n",
 576                         __func__, ret);
 577                 ret = -EIO;
 578         } else {
 579                 dprintk(DBGLVL_ENC, "%s() Acquired\n", __func__);
 580                 ret = 0;
 581         }
 582
 583         return ret;
 584 }
 585
 586 static int saa7164_encoder_pause_port(struct saa7164_port *port)
 587 {
 588         struct saa7164_dev *dev = port->dev;
 589         int ret;
 590
 591         ret = saa7164_api_transition_port(port, SAA_DMASTATE_PAUSE);
 592         if ((ret != SAA_OK) && (ret != SAA_ERR_ALREADY_STOPPED)) {
 593                 printk(KERN_ERR "%s() pause transition failed, ret = 0x%x\n",
 594                         __func__, ret);
 595                 ret = -EIO;
 596         } else {
 597                 dprintk(DBGLVL_ENC, "%s()   Paused\n", __func__);
 598                 ret = 0;
 599         }
 600
 601         return ret;
 602 }
 603
 604 /* Firmware is very windows centric, meaning you have to transition
 605  * the part through AVStream / KS Windows stages, forwards or backwards.
 606  * States are: stopped, acquired (h/w), paused, started.
 607  * We have to leave here will all of the soft buffers on the free list,
 608  * else the cfg_post() func won't have soft buffers to correctly configure.
 609  */
 610 static int saa7164_encoder_stop_streaming(struct saa7164_port *port)
 611 {
 612         struct saa7164_dev *dev = port->dev;
 613         struct saa7164_buffer *buf;
 614         struct saa7164_user_buffer *ubuf;
 615         struct list_head *c, *n;
 616         int ret;
 617
 618         dprintk(DBGLVL_ENC, "%s(port=%d)\n", __func__, port->nr);
 619
 620         ret = saa7164_encoder_pause_port(port);
 621         ret = saa7164_encoder_acquire_port(port);
 622         ret = saa7164_encoder_stop_port(port);
 623
 624         dprintk(DBGLVL_ENC, "%s(port=%d) Hardware stopped\n", __func__,
 625                 port->nr);
 626
 627         /* Reset the state of any allocated buffer resources */
 628         mutex_lock(&port->dmaqueue_lock);
 629
 630         /* Reset the hard and soft buffer state */
 631         list_for_each_safe(c, n, &port->dmaqueue.list) {
 632                 buf = list_entry(c, struct saa7164_buffer, list);
 633                 buf->flags = SAA7164_BUFFER_FREE;
 634                 buf->pos = 0;
 635         }
 636
 637         list_for_each_safe(c, n, &port->list_buf_used.list) {
 638                 ubuf = list_entry(c, struct saa7164_user_buffer, list);
 639                 ubuf->pos = 0;
 640                 list_move_tail(&ubuf->list, &port->list_buf_free.list);
 641         }
 642
 643         mutex_unlock(&port->dmaqueue_lock);
 644
 645         /* Free any allocated resources */
 646         saa7164_encoder_buffers_dealloc(port);
 647
 648         dprintk(DBGLVL_ENC, "%s(port=%d) Released\n", __func__, port->nr);
 649
 650         return ret;
 651 }
 652
 653 static int saa7164_encoder_start_streaming(struct saa7164_port *port)
 654 {
 655         struct saa7164_dev *dev = port->dev;
 656         int result, ret = 0;
 657
 658         dprintk(DBGLVL_ENC, "%s(port=%d)\n", __func__, port->nr);
 659
 660         port->done_first_interrupt = 0;
 661
 662         /* allocate all of the PCIe DMA buffer resources on the fly,
 663          * allowing switching between TS and PS payloads without
 664          * requiring a complete driver reload.
 665          */
 666         saa7164_encoder_buffers_alloc(port);
 667
 668         /* Configure the encoder with any cache values */
 669         saa7164_api_set_encoder(port);
 670         saa7164_api_get_encoder(port);
 671
 672         /* Place the empty buffers on the hardware */
 673         saa7164_buffer_cfg_port(port);
 674
 675         /* Acquire the hardware */
 676         result = saa7164_api_transition_port(port, SAA_DMASTATE_ACQUIRE);
 677         if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
 678                 printk(KERN_ERR "%s() acquire transition failed, res = 0x%x\n",
 679                         __func__, result);
 680
 681                 /* Stop the hardware, regardless */
 682                 result = saa7164_api_transition_port(port, SAA_DMASTATE_STOP);
 683                 if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
 684                         printk(KERN_ERR "%s() acquire/forced stop transition "
 685                                 "failed, res = 0x%x\n", __func__, result);
 686                 }
 687                 ret = -EIO;
 688                 goto out;
 689         } else
 690                 dprintk(DBGLVL_ENC, "%s()   Acquired\n", __func__);
 691
 692         /* Pause the hardware */
 693         result = saa7164_api_transition_port(port, SAA_DMASTATE_PAUSE);
 694         if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
 695                 printk(KERN_ERR "%s() pause transition failed, res = 0x%x\n",
 696                                 __func__, result);
 697
 698                 /* Stop the hardware, regardless */
 699                 result = saa7164_api_transition_port(port, SAA_DMASTATE_STOP);
 700                 if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
 701                         printk(KERN_ERR "%s() pause/forced stop transition "
 702                                 "failed, res = 0x%x\n", __func__, result);
 703                 }
 704
 705                 ret = -EIO;
 706                 goto out;
 707         } else
 708                 dprintk(DBGLVL_ENC, "%s()   Paused\n", __func__);
 709
 710         /* Start the hardware */
 711         result = saa7164_api_transition_port(port, SAA_DMASTATE_RUN);
 712         if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
 713                 printk(KERN_ERR "%s() run transition failed, result = 0x%x\n",
 714                                 __func__, result);
 715
 716                 /* Stop the hardware, regardless */
 717                 result = saa7164_api_transition_port(port, SAA_DMASTATE_STOP);
 718                 if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
 719                         printk(KERN_ERR "%s() run/forced stop transition "
 720                                 "failed, res = 0x%x\n", __func__, result);
 721                 }
 722
 723                 ret = -EIO;
 724         } else
 725                 dprintk(DBGLVL_ENC, "%s()   Running\n", __func__);
 726
 727 out:
 728         return ret;
 729 }
 730
 731 static int fops_open(struct file *file)
 732 {
 733         struct saa7164_dev *dev;
 734         struct saa7164_port *port;
 735         struct saa7164_encoder_fh *fh;
 736
 737         port = (struct saa7164_port *)video_get_drvdata(video_devdata(file));
 738         if (!port)
 739                 return -ENODEV;
 740
 741         dev = port->dev;
 742
 743         dprintk(DBGLVL_ENC, "%s()\n", __func__);
 744
 745         /* allocate + initialize per filehandle data */
 746         fh = kzalloc(sizeof(*fh), GFP_KERNEL);
 747         if (NULL == fh)
 748                 return -ENOMEM;
 749
 750         fh->port = port;
 751         v4l2_fh_init(&fh->fh, video_devdata(file));
 752         v4l2_fh_add(&fh->fh);
 753         file->private_data = fh;
 754
 755         return 0;
 756 }
 757
 758 static int fops_release(struct file *file)
 759 {
 760         struct saa7164_encoder_fh *fh = file->private_data;
 761         struct saa7164_port *port = fh->port;
 762         struct saa7164_dev *dev = port->dev;
 763
 764         dprintk(DBGLVL_ENC, "%s()\n", __func__);
 765
 766         /* Shut device down on last close */
 767         if (atomic_cmpxchg(&fh->v4l_reading, 1, 0) == 1) {
 768                 if (atomic_dec_return(&port->v4l_reader_count) == 0) {
 769                         /* stop mpeg capture then cancel buffers */
 770                         saa7164_encoder_stop_streaming(port);
 771                 }
 772         }
 773
 774         v4l2_fh_del(&fh->fh);
 775         v4l2_fh_exit(&fh->fh);
 776         kfree(fh);
 777
 778         return 0;
 779 }
 780
 781 static struct
 782 saa7164_user_buffer *saa7164_enc_next_buf(struct saa7164_port *port)
 783 {
 784         struct saa7164_user_buffer *ubuf = NULL;
 785         struct saa7164_dev *dev = port->dev;
 786         u32 crc;
 787
 788         mutex_lock(&port->dmaqueue_lock);
 789         if (!list_empty(&port->list_buf_used.list)) {
 790                 ubuf = list_first_entry(&port->list_buf_used.list,
 791                         struct saa7164_user_buffer, list);
 792
 793                 if (crc_checking) {
 794                         crc = crc32(0, ubuf->data, ubuf->actual_size);
 795                         if (crc != ubuf->crc) {
 796                                 printk(KERN_ERR
 797                 "%s() ubuf %p crc became invalid, was 0x%x became 0x%x\n",
 798                                         __func__,
 799                                         ubuf, ubuf->crc, crc);
 800                         }
 801                 }
 802
 803         }
 804         mutex_unlock(&port->dmaqueue_lock);
 805
 806         dprintk(DBGLVL_ENC, "%s() returns %p\n", __func__, ubuf);
 807
 808         return ubuf;
 809 }
 810
 811 static ssize_t fops_read(struct file *file, char __user *buffer,
 812         size_t count, loff_t *pos)
 813 {
 814         struct saa7164_encoder_fh *fh = file->private_data;
 815         struct saa7164_port *port = fh->port;
 816         struct saa7164_user_buffer *ubuf = NULL;
 817         struct saa7164_dev *dev = port->dev;
 818         int ret = 0;
 819         int rem, cnt;
 820         u8 *p;
 821
 822         port->last_read_msecs_diff = port->last_read_msecs;
 823         port->last_read_msecs = jiffies_to_msecs(jiffies);
 824         port->last_read_msecs_diff = port->last_read_msecs -
 825                 port->last_read_msecs_diff;
 826
 827         saa7164_histogram_update(&port->read_interval,
 828                 port->last_read_msecs_diff);
 829
 830         if (*pos) {
 831                 printk(KERN_ERR "%s() ESPIPE\n", __func__);
 832                 return -ESPIPE;
 833         }
 834
 835         if (atomic_cmpxchg(&fh->v4l_reading, 0, 1) == 0) {
 836                 if (atomic_inc_return(&port->v4l_reader_count) == 1) {
 837
 838                         if (saa7164_encoder_initialize(port) < 0) {
 839                                 printk(KERN_ERR "%s() EINVAL\n", __func__);
 840                                 return -EINVAL;
 841                         }
 842
 843                         saa7164_encoder_start_streaming(port);
 844                         msleep(200);
 845                 }
 846         }
 847
 848         /* blocking wait for buffer */
 849         if ((file->f_flags & O_NONBLOCK) == 0) {
 850                 if (wait_event_interruptible(port->wait_read,
 851                         saa7164_enc_next_buf(port))) {
 852                                 printk(KERN_ERR "%s() ERESTARTSYS\n", __func__);
 853                                 return -ERESTARTSYS;
 854                 }
 855         }
 856
 857         /* Pull the first buffer from the used list */
 858         ubuf = saa7164_enc_next_buf(port);
 859
 860         while ((count > 0) && ubuf) {
 861
 862                 /* set remaining bytes to copy */
 863                 rem = ubuf->actual_size - ubuf->pos;
 864                 cnt = rem > count ? count : rem;
 865
 866                 p = ubuf->data + ubuf->pos;
 867
 868                 dprintk(DBGLVL_ENC,
 869                         "%s() count=%d cnt=%d rem=%d buf=%p buf->pos=%d\n",
 870                         __func__, (int)count, cnt, rem, ubuf, ubuf->pos);
 871
 872                 if (copy_to_user(buffer, p, cnt)) {
 873                         printk(KERN_ERR "%s() copy_to_user failed\n", __func__);
 874                         if (!ret) {
 875                                 printk(KERN_ERR "%s() EFAULT\n", __func__);
 876                                 ret = -EFAULT;
 877                         }
 878                         goto err;
 879                 }
 880
 881                 ubuf->pos += cnt;
 882                 count -= cnt;
 883                 buffer += cnt;
 884                 ret += cnt;
 885
 886                 if (ubuf->pos > ubuf->actual_size)
 887                         printk(KERN_ERR "read() pos > actual, huh?\n");
 888
 889                 if (ubuf->pos == ubuf->actual_size) {
 890
 891                         /* finished with current buffer, take next buffer */
 892
 893                         /* Requeue the buffer on the free list */
 894                         ubuf->pos = 0;
 895
 896                         mutex_lock(&port->dmaqueue_lock);
 897                         list_move_tail(&ubuf->list, &port->list_buf_free.list);
 898                         mutex_unlock(&port->dmaqueue_lock);
 899
 900                         /* Dequeue next */
 901                         if ((file->f_flags & O_NONBLOCK) == 0) {
 902                                 if (wait_event_interruptible(port->wait_read,
 903                                         saa7164_enc_next_buf(port))) {
 904                                                 break;
 905                                 }
 906                         }
 907                         ubuf = saa7164_enc_next_buf(port);
 908                 }
 909         }
 910 err:
 911         if (!ret && !ubuf)
 912                 ret = -EAGAIN;
 913
 914         return ret;
 915 }
 916
 917 static unsigned int fops_poll(struct file *file, poll_table *wait)
 918 {
 919         unsigned long req_events = poll_requested_events(wait);
 920         struct saa7164_encoder_fh *fh =
 921                 (struct saa7164_encoder_fh *)file->private_data;
 922         struct saa7164_port *port = fh->port;
 923         unsigned int mask = v4l2_ctrl_poll(file, wait);
 924
 925         port->last_poll_msecs_diff = port->last_poll_msecs;
 926         port->last_poll_msecs = jiffies_to_msecs(jiffies);
 927         port->last_poll_msecs_diff = port->last_poll_msecs -
 928                 port->last_poll_msecs_diff;
 929
 930         saa7164_histogram_update(&port->poll_interval,
 931                 port->last_poll_msecs_diff);
 932
 933         if (!(req_events & (POLLIN | POLLRDNORM)))
 934                 return mask;
 935
 936         if (atomic_cmpxchg(&fh->v4l_reading, 0, 1) == 0) {
 937                 if (atomic_inc_return(&port->v4l_reader_count) == 1) {
 938                         if (saa7164_encoder_initialize(port) < 0)
 939                                 return mask | POLLERR;
 940                         saa7164_encoder_start_streaming(port);
 941                         msleep(200);
 942                 }
 943         }
 944
 945         /* Pull the first buffer from the used list */
 946         if (!list_empty(&port->list_buf_used.list))
 947                 mask |= POLLIN | POLLRDNORM;
 948
 949         return mask;
 950 }
 951
 952 static const struct v4l2_ctrl_ops saa7164_ctrl_ops = {
 953         .s_ctrl = saa7164_s_ctrl,
 954 };
 955
 956 static const struct v4l2_file_operations mpeg_fops = {
 957         .owner          = THIS_MODULE,
 958         .open           = fops_open,
 959         .release        = fops_release,
 960         .read           = fops_read,
 961         .poll           = fops_poll,
 962         .unlocked_ioctl = video_ioctl2,
 963 };
 964
 965 static const struct v4l2_ioctl_ops mpeg_ioctl_ops = {
 966         .vidioc_s_std            = vidioc_s_std,
 967         .vidioc_g_std            = vidioc_g_std,
 968         .vidioc_enum_input       = saa7164_enum_input,
 969         .vidioc_g_input          = vidioc_g_input,
 970         .vidioc_s_input          = vidioc_s_input,
 971         .vidioc_g_tuner          = saa7164_g_tuner,
 972         .vidioc_s_tuner          = saa7164_s_tuner,
 973         .vidioc_g_frequency      = vidioc_g_frequency,
 974         .vidioc_s_frequency      = vidioc_s_frequency,
 975         .vidioc_querycap         = vidioc_querycap,
 976         .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
 977         .vidioc_g_fmt_vid_cap    = vidioc_fmt_vid_cap,
 978         .vidioc_try_fmt_vid_cap  = vidioc_fmt_vid_cap,
 979         .vidioc_s_fmt_vid_cap    = vidioc_fmt_vid_cap,
 980         .vidioc_log_status       = v4l2_ctrl_log_status,
 981         .vidioc_subscribe_event  = v4l2_ctrl_subscribe_event,
 982         .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
 983 };
 984
 985 static struct video_device saa7164_mpeg_template = {
 986         .name          = "saa7164",
 987         .fops          = &mpeg_fops,
 988         .ioctl_ops     = &mpeg_ioctl_ops,
 989         .minor         = -1,
 990         .tvnorms       = SAA7164_NORMS,
 991 };
 992
 993 static struct video_device *saa7164_encoder_alloc(
 994         struct saa7164_port *port,
 995         struct pci_dev *pci,
 996         struct video_device *template,
 997         char *type)
 998 {
 999         struct video_device *vfd;
1000         struct saa7164_dev *dev = port->dev;
1001
1002         dprintk(DBGLVL_ENC, "%s()\n", __func__);
1003
1004         vfd = video_device_alloc();
1005         if (NULL == vfd)
1006                 return NULL;
1007
1008         *vfd = *template;
1009         snprintf(vfd->name, sizeof(vfd->name), "%s %s (%s)", dev->name,
1010                 type, saa7164_boards[dev->board].name);
1011
1012         vfd->v4l2_dev  = &dev->v4l2_dev;
1013         vfd->release = video_device_release;
1014         return vfd;
1015 }
1016
1017 int saa7164_encoder_register(struct saa7164_port *port)
1018 {
1019         struct saa7164_dev *dev = port->dev;
1020         struct v4l2_ctrl_handler *hdl = &port->ctrl_handler;
1021         int result = -ENODEV;
1022
1023         dprintk(DBGLVL_ENC, "%s()\n", __func__);
1024
1025         if (port->type != SAA7164_MPEG_ENCODER)
1026                 BUG();
1027
1028         /* Sanity check that the PCI configuration space is active */
1029         if (port->hwcfg.BARLocation == 0) {
1030                 printk(KERN_ERR "%s() failed "
1031                        "(errno = %d), NO PCI configuration\n",
1032                         __func__, result);
1033                 result = -ENOMEM;
1034                 goto failed;
1035         }
1036
1037         /* Establish encoder defaults here */
1038         /* Set default TV standard */
1039         port->encodernorm = saa7164_tvnorms[0];
1040         port->width = 720;
1041         port->mux_input = 1; /* Composite */
1042         port->video_format = EU_VIDEO_FORMAT_MPEG_2;
1043         port->audio_format = 0;
1044         port->video_resolution = 0;
1045         port->freq = SAA7164_TV_MIN_FREQ;
1046
1047         v4l2_ctrl_handler_init(hdl, 14);
1048         v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops,
1049                           V4L2_CID_BRIGHTNESS, 0, 255, 1, 127);
1050         v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops,
1051                           V4L2_CID_CONTRAST, 0, 255, 1, 66);
1052         v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops,
1053                           V4L2_CID_SATURATION, 0, 255, 1, 62);
1054         v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops,
1055                           V4L2_CID_HUE, 0, 255, 1, 128);
1056         v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops,
1057                           V4L2_CID_SHARPNESS, 0x0, 0x0f, 1, 8);
1058         v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops,
1059                           V4L2_CID_MPEG_AUDIO_MUTE, 0x0, 0x01, 1, 0);
1060         v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops,
1061                           V4L2_CID_AUDIO_VOLUME, -83, 24, 1, 20);
1062         v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops,
1063                           V4L2_CID_MPEG_VIDEO_BITRATE,
1064                           ENCODER_MIN_BITRATE, ENCODER_MAX_BITRATE,
1065                           100000, ENCODER_DEF_BITRATE);
1066         v4l2_ctrl_new_std_menu(hdl, &saa7164_ctrl_ops,
1067                                V4L2_CID_MPEG_STREAM_TYPE,
1068                                V4L2_MPEG_STREAM_TYPE_MPEG2_TS, 0,
1069                                V4L2_MPEG_STREAM_TYPE_MPEG2_PS);
1070         v4l2_ctrl_new_std_menu(hdl, &saa7164_ctrl_ops,
1071                                V4L2_CID_MPEG_VIDEO_ASPECT,
1072                                V4L2_MPEG_VIDEO_ASPECT_221x100, 0,
1073                                V4L2_MPEG_VIDEO_ASPECT_4x3);
1074         v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops,
1075                           V4L2_CID_MPEG_VIDEO_GOP_SIZE, 1, 255, 1, 15);
1076         v4l2_ctrl_new_std_menu(hdl, &saa7164_ctrl_ops,
1077                                V4L2_CID_MPEG_VIDEO_BITRATE_MODE,
1078                                V4L2_MPEG_VIDEO_BITRATE_MODE_CBR, 0,
1079                                V4L2_MPEG_VIDEO_BITRATE_MODE_VBR);
1080         v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops,
1081                           V4L2_CID_MPEG_VIDEO_B_FRAMES, 1, 3, 1, 1);
1082         v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops,
1083                           V4L2_CID_MPEG_VIDEO_BITRATE_PEAK,
1084                           ENCODER_MIN_BITRATE, ENCODER_MAX_BITRATE,
1085                           100000, ENCODER_DEF_BITRATE);
1086         if (hdl->error) {
1087                 result = hdl->error;
1088                 goto failed;
1089         }
1090
1091         port->std = V4L2_STD_NTSC_M;
1092
1093         if (port->encodernorm.id & V4L2_STD_525_60)
1094                 port->height = 480;
1095         else
1096                 port->height = 576;
1097
1098         /* Allocate and register the video device node */
1099         port->v4l_device = saa7164_encoder_alloc(port,
1100                 dev->pci, &saa7164_mpeg_template, "mpeg");
1101
1102         if (!port->v4l_device) {
1103                 printk(KERN_INFO "%s: can't allocate mpeg device\n",
1104                         dev->name);
1105                 result = -ENOMEM;
1106                 goto failed;
1107         }
1108
1109         port->v4l_device->ctrl_handler = hdl;
1110         v4l2_ctrl_handler_setup(hdl);
1111         video_set_drvdata(port->v4l_device, port);
1112         result = video_register_device(port->v4l_device,
1113                 VFL_TYPE_GRABBER, -1);
1114         if (result < 0) {
1115                 printk(KERN_INFO "%s: can't register mpeg device\n",
1116                         dev->name);
1117                 /* TODO: We're going to leak here if we don't dealloc
1118                  The buffers above. The unreg function can't deal wit it.
1119                 */
1120                 goto failed;
1121         }
1122
1123         printk(KERN_INFO "%s: registered device video%d [mpeg]\n",
1124                 dev->name, port->v4l_device->num);
1125
1126         /* Configure the hardware defaults */
1127         saa7164_api_set_videomux(port);
1128         saa7164_api_set_usercontrol(port, PU_BRIGHTNESS_CONTROL);
1129         saa7164_api_set_usercontrol(port, PU_CONTRAST_CONTROL);
1130         saa7164_api_set_usercontrol(port, PU_HUE_CONTROL);
1131         saa7164_api_set_usercontrol(port, PU_SATURATION_CONTROL);
1132         saa7164_api_set_usercontrol(port, PU_SHARPNESS_CONTROL);
1133         saa7164_api_audio_mute(port, 0);
1134         saa7164_api_set_audio_volume(port, 20);
1135         saa7164_api_set_aspect_ratio(port);
1136
1137         /* Disable audio standard detection, it's buggy */
1138         saa7164_api_set_audio_detection(port, 0);
1139
1140         saa7164_api_set_encoder(port);
1141         saa7164_api_get_encoder(port);
1142
1143         result = 0;
1144 failed:
1145         return result;
1146 }
1147
1148 void saa7164_encoder_unregister(struct saa7164_port *port)
1149 {
1150         struct saa7164_dev *dev = port->dev;
1151
1152         dprintk(DBGLVL_ENC, "%s(port=%d)\n", __func__, port->nr);
1153
1154         if (port->type != SAA7164_MPEG_ENCODER)
1155                 BUG();
1156
1157         if (port->v4l_device) {
1158                 if (port->v4l_device->minor != -1)
1159                         video_unregister_device(port->v4l_device);
1160                 else
1161                         video_device_release(port->v4l_device);
1162
1163                 port->v4l_device = NULL;
1164         }
1165         v4l2_ctrl_handler_free(&port->ctrl_handler);
1166
1167         dprintk(DBGLVL_ENC, "%s(port=%d) done\n", __func__, port->nr);
1168 }
1169