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

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