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, ¶ms); 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 failed; 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 failed; 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 failed; 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 /* TODO: We're going to leak here if we don't dealloc 1111 The buffers above. The unreg function can't deal wit it. 1112 */ 1113 goto failed; 1114 } 1115 1116 printk(KERN_INFO "%s: registered device video%d [mpeg]\n", 1117 dev->name, port->v4l_device->num); 1118 1119 /* Configure the hardware defaults */ 1120 saa7164_api_set_videomux(port); 1121 saa7164_api_set_usercontrol(port, PU_BRIGHTNESS_CONTROL); 1122 saa7164_api_set_usercontrol(port, PU_CONTRAST_CONTROL); 1123 saa7164_api_set_usercontrol(port, PU_HUE_CONTROL); 1124 saa7164_api_set_usercontrol(port, PU_SATURATION_CONTROL); 1125 saa7164_api_set_usercontrol(port, PU_SHARPNESS_CONTROL); 1126 saa7164_api_audio_mute(port, 0); 1127 saa7164_api_set_audio_volume(port, 20); 1128 saa7164_api_set_aspect_ratio(port); 1129 1130 /* Disable audio standard detection, it's buggy */ 1131 saa7164_api_set_audio_detection(port, 0); 1132 1133 saa7164_api_set_encoder(port); 1134 saa7164_api_get_encoder(port); 1135 1136 result = 0; 1137 failed: 1138 return result; 1139 } 1140 1141 void saa7164_encoder_unregister(struct saa7164_port *port) 1142 { 1143 struct saa7164_dev *dev = port->dev; 1144 1145 dprintk(DBGLVL_ENC, "%s(port=%d)\n", __func__, port->nr); 1146 1147 BUG_ON(port->type != SAA7164_MPEG_ENCODER); 1148 1149 if (port->v4l_device) { 1150 if (port->v4l_device->minor != -1) 1151 video_unregister_device(port->v4l_device); 1152 else 1153 video_device_release(port->v4l_device); 1154 1155 port->v4l_device = NULL; 1156 } 1157 v4l2_ctrl_handler_free(&port->ctrl_handler); 1158 1159 dprintk(DBGLVL_ENC, "%s(port=%d) done\n", __func__, port->nr); 1160 } 1161 1162