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