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 = to_saa7164_encoder_fh(file); 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 = to_saa7164_encoder_fh(file); 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 = to_saa7164_encoder_fh(file); 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 = to_saa7164_encoder_fh(file); 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 = to_saa7164_encoder_fh(file); 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 = to_saa7164_encoder_fh(file); 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 return -EINVAL; /* should not happen */ 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, ¶ms); 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 = to_saa7164_encoder_fh(file); 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 = to_saa7164_encoder_fh(file); 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 cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE | 494 V4L2_CAP_TUNER | V4L2_CAP_VBI_CAPTURE | 495 V4L2_CAP_DEVICE_CAPS; 496 return 0; 497 } 498 499 static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv, 500 struct v4l2_fmtdesc *f) 501 { 502 if (f->index != 0) 503 return -EINVAL; 504 505 f->pixelformat = V4L2_PIX_FMT_MPEG; 506 507 return 0; 508 } 509 510 static int vidioc_fmt_vid_cap(struct file *file, void *priv, 511 struct v4l2_format *f) 512 { 513 struct saa7164_encoder_fh *fh = to_saa7164_encoder_fh(file); 514 struct saa7164_port *port = fh->port; 515 516 f->fmt.pix.pixelformat = V4L2_PIX_FMT_MPEG; 517 f->fmt.pix.bytesperline = 0; 518 f->fmt.pix.sizeimage = SAA7164_SIZEIMAGE; 519 f->fmt.pix.field = V4L2_FIELD_INTERLACED; 520 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M; 521 f->fmt.pix.width = port->width; 522 f->fmt.pix.height = port->height; 523 return 0; 524 } 525 526 static int saa7164_encoder_stop_port(struct saa7164_port *port) 527 { 528 struct saa7164_dev *dev = port->dev; 529 int ret; 530 531 ret = saa7164_api_transition_port(port, SAA_DMASTATE_STOP); 532 if ((ret != SAA_OK) && (ret != SAA_ERR_ALREADY_STOPPED)) { 533 printk(KERN_ERR "%s() stop transition failed, ret = 0x%x\n", 534 __func__, ret); 535 ret = -EIO; 536 } else { 537 dprintk(DBGLVL_ENC, "%s() Stopped\n", __func__); 538 ret = 0; 539 } 540 541 return ret; 542 } 543 544 static int saa7164_encoder_acquire_port(struct saa7164_port *port) 545 { 546 struct saa7164_dev *dev = port->dev; 547 int ret; 548 549 ret = saa7164_api_transition_port(port, SAA_DMASTATE_ACQUIRE); 550 if ((ret != SAA_OK) && (ret != SAA_ERR_ALREADY_STOPPED)) { 551 printk(KERN_ERR "%s() acquire transition failed, ret = 0x%x\n", 552 __func__, ret); 553 ret = -EIO; 554 } else { 555 dprintk(DBGLVL_ENC, "%s() Acquired\n", __func__); 556 ret = 0; 557 } 558 559 return ret; 560 } 561 562 static int saa7164_encoder_pause_port(struct saa7164_port *port) 563 { 564 struct saa7164_dev *dev = port->dev; 565 int ret; 566 567 ret = saa7164_api_transition_port(port, SAA_DMASTATE_PAUSE); 568 if ((ret != SAA_OK) && (ret != SAA_ERR_ALREADY_STOPPED)) { 569 printk(KERN_ERR "%s() pause transition failed, ret = 0x%x\n", 570 __func__, ret); 571 ret = -EIO; 572 } else { 573 dprintk(DBGLVL_ENC, "%s() Paused\n", __func__); 574 ret = 0; 575 } 576 577 return ret; 578 } 579 580 /* Firmware is very windows centric, meaning you have to transition 581 * the part through AVStream / KS Windows stages, forwards or backwards. 582 * States are: stopped, acquired (h/w), paused, started. 583 * We have to leave here will all of the soft buffers on the free list, 584 * else the cfg_post() func won't have soft buffers to correctly configure. 585 */ 586 static int saa7164_encoder_stop_streaming(struct saa7164_port *port) 587 { 588 struct saa7164_dev *dev = port->dev; 589 struct saa7164_buffer *buf; 590 struct saa7164_user_buffer *ubuf; 591 struct list_head *c, *n; 592 int ret; 593 594 dprintk(DBGLVL_ENC, "%s(port=%d)\n", __func__, port->nr); 595 596 ret = saa7164_encoder_pause_port(port); 597 ret = saa7164_encoder_acquire_port(port); 598 ret = saa7164_encoder_stop_port(port); 599 600 dprintk(DBGLVL_ENC, "%s(port=%d) Hardware stopped\n", __func__, 601 port->nr); 602 603 /* Reset the state of any allocated buffer resources */ 604 mutex_lock(&port->dmaqueue_lock); 605 606 /* Reset the hard and soft buffer state */ 607 list_for_each_safe(c, n, &port->dmaqueue.list) { 608 buf = list_entry(c, struct saa7164_buffer, list); 609 buf->flags = SAA7164_BUFFER_FREE; 610 buf->pos = 0; 611 } 612 613 list_for_each_safe(c, n, &port->list_buf_used.list) { 614 ubuf = list_entry(c, struct saa7164_user_buffer, list); 615 ubuf->pos = 0; 616 list_move_tail(&ubuf->list, &port->list_buf_free.list); 617 } 618 619 mutex_unlock(&port->dmaqueue_lock); 620 621 /* Free any allocated resources */ 622 saa7164_encoder_buffers_dealloc(port); 623 624 dprintk(DBGLVL_ENC, "%s(port=%d) Released\n", __func__, port->nr); 625 626 return ret; 627 } 628 629 static int saa7164_encoder_start_streaming(struct saa7164_port *port) 630 { 631 struct saa7164_dev *dev = port->dev; 632 int result, ret = 0; 633 634 dprintk(DBGLVL_ENC, "%s(port=%d)\n", __func__, port->nr); 635 636 port->done_first_interrupt = 0; 637 638 /* allocate all of the PCIe DMA buffer resources on the fly, 639 * allowing switching between TS and PS payloads without 640 * requiring a complete driver reload. 641 */ 642 saa7164_encoder_buffers_alloc(port); 643 644 /* Configure the encoder with any cache values */ 645 saa7164_api_set_encoder(port); 646 saa7164_api_get_encoder(port); 647 648 /* Place the empty buffers on the hardware */ 649 saa7164_buffer_cfg_port(port); 650 651 /* Acquire the hardware */ 652 result = saa7164_api_transition_port(port, SAA_DMASTATE_ACQUIRE); 653 if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) { 654 printk(KERN_ERR "%s() acquire transition failed, res = 0x%x\n", 655 __func__, result); 656 657 /* Stop the hardware, regardless */ 658 result = saa7164_api_transition_port(port, SAA_DMASTATE_STOP); 659 if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) { 660 printk(KERN_ERR "%s() acquire/forced stop transition failed, res = 0x%x\n", 661 __func__, result); 662 } 663 ret = -EIO; 664 goto out; 665 } else 666 dprintk(DBGLVL_ENC, "%s() Acquired\n", __func__); 667 668 /* Pause the hardware */ 669 result = saa7164_api_transition_port(port, SAA_DMASTATE_PAUSE); 670 if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) { 671 printk(KERN_ERR "%s() pause transition failed, res = 0x%x\n", 672 __func__, result); 673 674 /* Stop the hardware, regardless */ 675 result = saa7164_api_transition_port(port, SAA_DMASTATE_STOP); 676 if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) { 677 printk(KERN_ERR "%s() pause/forced stop transition failed, res = 0x%x\n", 678 __func__, result); 679 } 680 681 ret = -EIO; 682 goto out; 683 } else 684 dprintk(DBGLVL_ENC, "%s() Paused\n", __func__); 685 686 /* Start the hardware */ 687 result = saa7164_api_transition_port(port, SAA_DMASTATE_RUN); 688 if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) { 689 printk(KERN_ERR "%s() run transition failed, result = 0x%x\n", 690 __func__, result); 691 692 /* Stop the hardware, regardless */ 693 result = saa7164_api_transition_port(port, SAA_DMASTATE_STOP); 694 if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) { 695 printk(KERN_ERR "%s() run/forced stop transition failed, res = 0x%x\n", 696 __func__, result); 697 } 698 699 ret = -EIO; 700 } else 701 dprintk(DBGLVL_ENC, "%s() Running\n", __func__); 702 703 out: 704 return ret; 705 } 706 707 static int fops_open(struct file *file) 708 { 709 struct saa7164_dev *dev; 710 struct saa7164_port *port; 711 struct saa7164_encoder_fh *fh; 712 713 port = (struct saa7164_port *)video_get_drvdata(video_devdata(file)); 714 if (!port) 715 return -ENODEV; 716 717 dev = port->dev; 718 719 dprintk(DBGLVL_ENC, "%s()\n", __func__); 720 721 /* allocate + initialize per filehandle data */ 722 fh = kzalloc(sizeof(*fh), GFP_KERNEL); 723 if (NULL == fh) 724 return -ENOMEM; 725 726 fh->port = port; 727 v4l2_fh_init(&fh->fh, video_devdata(file)); 728 v4l2_fh_add(&fh->fh, file); 729 730 return 0; 731 } 732 733 static int fops_release(struct file *file) 734 { 735 struct saa7164_encoder_fh *fh = to_saa7164_encoder_fh(file); 736 struct saa7164_port *port = fh->port; 737 struct saa7164_dev *dev = port->dev; 738 739 dprintk(DBGLVL_ENC, "%s()\n", __func__); 740 741 /* Shut device down on last close */ 742 if (atomic_cmpxchg(&fh->v4l_reading, 1, 0) == 1) { 743 if (atomic_dec_return(&port->v4l_reader_count) == 0) { 744 /* stop mpeg capture then cancel buffers */ 745 saa7164_encoder_stop_streaming(port); 746 } 747 } 748 749 v4l2_fh_del(&fh->fh, file); 750 v4l2_fh_exit(&fh->fh); 751 kfree(fh); 752 753 return 0; 754 } 755 756 static struct 757 saa7164_user_buffer *saa7164_enc_next_buf(struct saa7164_port *port) 758 { 759 struct saa7164_user_buffer *ubuf = NULL; 760 struct saa7164_dev *dev = port->dev; 761 u32 crc; 762 763 mutex_lock(&port->dmaqueue_lock); 764 if (!list_empty(&port->list_buf_used.list)) { 765 ubuf = list_first_entry(&port->list_buf_used.list, 766 struct saa7164_user_buffer, list); 767 768 if (crc_checking) { 769 crc = crc32(0, ubuf->data, ubuf->actual_size); 770 if (crc != ubuf->crc) { 771 printk(KERN_ERR 772 "%s() ubuf %p crc became invalid, was 0x%x became 0x%x\n", 773 __func__, 774 ubuf, ubuf->crc, crc); 775 } 776 } 777 778 } 779 mutex_unlock(&port->dmaqueue_lock); 780 781 dprintk(DBGLVL_ENC, "%s() returns %p\n", __func__, ubuf); 782 783 return ubuf; 784 } 785 786 static ssize_t fops_read(struct file *file, char __user *buffer, 787 size_t count, loff_t *pos) 788 { 789 struct saa7164_encoder_fh *fh = to_saa7164_encoder_fh(file); 790 struct saa7164_port *port = fh->port; 791 struct saa7164_user_buffer *ubuf = NULL; 792 struct saa7164_dev *dev = port->dev; 793 int ret = 0; 794 int rem, cnt; 795 u8 *p; 796 797 port->last_read_msecs_diff = port->last_read_msecs; 798 port->last_read_msecs = jiffies_to_msecs(jiffies); 799 port->last_read_msecs_diff = port->last_read_msecs - 800 port->last_read_msecs_diff; 801 802 saa7164_histogram_update(&port->read_interval, 803 port->last_read_msecs_diff); 804 805 if (*pos) { 806 printk(KERN_ERR "%s() ESPIPE\n", __func__); 807 return -ESPIPE; 808 } 809 810 if (atomic_cmpxchg(&fh->v4l_reading, 0, 1) == 0) { 811 if (atomic_inc_return(&port->v4l_reader_count) == 1) { 812 813 if (saa7164_encoder_initialize(port) < 0) { 814 printk(KERN_ERR "%s() EINVAL\n", __func__); 815 return -EINVAL; 816 } 817 818 saa7164_encoder_start_streaming(port); 819 msleep(200); 820 } 821 } 822 823 /* blocking wait for buffer */ 824 if ((file->f_flags & O_NONBLOCK) == 0) { 825 if (wait_event_interruptible(port->wait_read, 826 saa7164_enc_next_buf(port))) { 827 printk(KERN_ERR "%s() ERESTARTSYS\n", __func__); 828 return -ERESTARTSYS; 829 } 830 } 831 832 /* Pull the first buffer from the used list */ 833 ubuf = saa7164_enc_next_buf(port); 834 835 while ((count > 0) && ubuf) { 836 837 /* set remaining bytes to copy */ 838 rem = ubuf->actual_size - ubuf->pos; 839 cnt = rem > count ? count : rem; 840 841 p = ubuf->data + ubuf->pos; 842 843 dprintk(DBGLVL_ENC, 844 "%s() count=%d cnt=%d rem=%d buf=%p buf->pos=%d\n", 845 __func__, (int)count, cnt, rem, ubuf, ubuf->pos); 846 847 if (copy_to_user(buffer, p, cnt)) { 848 printk(KERN_ERR "%s() copy_to_user failed\n", __func__); 849 if (!ret) { 850 printk(KERN_ERR "%s() EFAULT\n", __func__); 851 ret = -EFAULT; 852 } 853 goto err; 854 } 855 856 ubuf->pos += cnt; 857 count -= cnt; 858 buffer += cnt; 859 ret += cnt; 860 861 if (ubuf->pos > ubuf->actual_size) 862 printk(KERN_ERR "read() pos > actual, huh?\n"); 863 864 if (ubuf->pos == ubuf->actual_size) { 865 866 /* finished with current buffer, take next buffer */ 867 868 /* Requeue the buffer on the free list */ 869 ubuf->pos = 0; 870 871 mutex_lock(&port->dmaqueue_lock); 872 list_move_tail(&ubuf->list, &port->list_buf_free.list); 873 mutex_unlock(&port->dmaqueue_lock); 874 875 /* Dequeue next */ 876 if ((file->f_flags & O_NONBLOCK) == 0) { 877 if (wait_event_interruptible(port->wait_read, 878 saa7164_enc_next_buf(port))) { 879 break; 880 } 881 } 882 ubuf = saa7164_enc_next_buf(port); 883 } 884 } 885 err: 886 if (!ret && !ubuf) 887 ret = -EAGAIN; 888 889 return ret; 890 } 891 892 static __poll_t fops_poll(struct file *file, poll_table *wait) 893 { 894 __poll_t req_events = poll_requested_events(wait); 895 struct saa7164_encoder_fh *fh = to_saa7164_encoder_fh(file); 896 struct saa7164_port *port = fh->port; 897 __poll_t mask = v4l2_ctrl_poll(file, wait); 898 899 port->last_poll_msecs_diff = port->last_poll_msecs; 900 port->last_poll_msecs = jiffies_to_msecs(jiffies); 901 port->last_poll_msecs_diff = port->last_poll_msecs - 902 port->last_poll_msecs_diff; 903 904 saa7164_histogram_update(&port->poll_interval, 905 port->last_poll_msecs_diff); 906 907 if (!(req_events & (EPOLLIN | EPOLLRDNORM))) 908 return mask; 909 910 if (atomic_cmpxchg(&fh->v4l_reading, 0, 1) == 0) { 911 if (atomic_inc_return(&port->v4l_reader_count) == 1) { 912 if (saa7164_encoder_initialize(port) < 0) 913 return mask | EPOLLERR; 914 saa7164_encoder_start_streaming(port); 915 msleep(200); 916 } 917 } 918 919 /* Pull the first buffer from the used list */ 920 if (!list_empty(&port->list_buf_used.list)) 921 mask |= EPOLLIN | EPOLLRDNORM; 922 923 return mask; 924 } 925 926 static const struct v4l2_ctrl_ops saa7164_ctrl_ops = { 927 .s_ctrl = saa7164_s_ctrl, 928 }; 929 930 static const struct v4l2_file_operations mpeg_fops = { 931 .owner = THIS_MODULE, 932 .open = fops_open, 933 .release = fops_release, 934 .read = fops_read, 935 .poll = fops_poll, 936 .unlocked_ioctl = video_ioctl2, 937 }; 938 939 static const struct v4l2_ioctl_ops mpeg_ioctl_ops = { 940 .vidioc_s_std = vidioc_s_std, 941 .vidioc_g_std = vidioc_g_std, 942 .vidioc_enum_input = saa7164_enum_input, 943 .vidioc_g_input = vidioc_g_input, 944 .vidioc_s_input = vidioc_s_input, 945 .vidioc_g_tuner = saa7164_g_tuner, 946 .vidioc_s_tuner = saa7164_s_tuner, 947 .vidioc_g_frequency = vidioc_g_frequency, 948 .vidioc_s_frequency = vidioc_s_frequency, 949 .vidioc_querycap = vidioc_querycap, 950 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap, 951 .vidioc_g_fmt_vid_cap = vidioc_fmt_vid_cap, 952 .vidioc_try_fmt_vid_cap = vidioc_fmt_vid_cap, 953 .vidioc_s_fmt_vid_cap = vidioc_fmt_vid_cap, 954 .vidioc_log_status = v4l2_ctrl_log_status, 955 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event, 956 .vidioc_unsubscribe_event = v4l2_event_unsubscribe, 957 }; 958 959 static struct video_device saa7164_mpeg_template = { 960 .name = "saa7164", 961 .fops = &mpeg_fops, 962 .ioctl_ops = &mpeg_ioctl_ops, 963 .minor = -1, 964 .tvnorms = SAA7164_NORMS, 965 .device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE | 966 V4L2_CAP_TUNER, 967 }; 968 969 static struct video_device *saa7164_encoder_alloc( 970 struct saa7164_port *port, 971 struct pci_dev *pci, 972 struct video_device *template, 973 char *type) 974 { 975 struct video_device *vfd; 976 struct saa7164_dev *dev = port->dev; 977 978 dprintk(DBGLVL_ENC, "%s()\n", __func__); 979 980 vfd = video_device_alloc(); 981 if (NULL == vfd) 982 return NULL; 983 984 *vfd = *template; 985 snprintf(vfd->name, sizeof(vfd->name), "%s %s (%s)", dev->name, 986 type, saa7164_boards[dev->board].name); 987 988 vfd->v4l2_dev = &dev->v4l2_dev; 989 vfd->release = video_device_release; 990 return vfd; 991 } 992 993 int saa7164_encoder_register(struct saa7164_port *port) 994 { 995 struct saa7164_dev *dev = port->dev; 996 struct v4l2_ctrl_handler *hdl = &port->ctrl_handler; 997 int result = -ENODEV; 998 999 dprintk(DBGLVL_ENC, "%s()\n", __func__); 1000 1001 BUG_ON(port->type != SAA7164_MPEG_ENCODER); 1002 1003 /* Sanity check that the PCI configuration space is active */ 1004 if (port->hwcfg.BARLocation == 0) { 1005 printk(KERN_ERR "%s() failed (errno = %d), NO PCI configuration\n", 1006 __func__, result); 1007 result = -ENOMEM; 1008 goto fail_pci; 1009 } 1010 1011 /* Establish encoder defaults here */ 1012 /* Set default TV standard */ 1013 port->encodernorm = saa7164_tvnorms[0]; 1014 port->width = 720; 1015 port->mux_input = 1; /* Composite */ 1016 port->video_format = EU_VIDEO_FORMAT_MPEG_2; 1017 port->audio_format = 0; 1018 port->video_resolution = 0; 1019 port->freq = SAA7164_TV_MIN_FREQ; 1020 1021 v4l2_ctrl_handler_init(hdl, 14); 1022 v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops, 1023 V4L2_CID_BRIGHTNESS, 0, 255, 1, 127); 1024 v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops, 1025 V4L2_CID_CONTRAST, 0, 255, 1, 66); 1026 v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops, 1027 V4L2_CID_SATURATION, 0, 255, 1, 62); 1028 v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops, 1029 V4L2_CID_HUE, 0, 255, 1, 128); 1030 v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops, 1031 V4L2_CID_SHARPNESS, 0x0, 0x0f, 1, 8); 1032 v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops, 1033 V4L2_CID_MPEG_AUDIO_MUTE, 0x0, 0x01, 1, 0); 1034 v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops, 1035 V4L2_CID_AUDIO_VOLUME, -83, 24, 1, 20); 1036 v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops, 1037 V4L2_CID_MPEG_VIDEO_BITRATE, 1038 ENCODER_MIN_BITRATE, ENCODER_MAX_BITRATE, 1039 100000, ENCODER_DEF_BITRATE); 1040 v4l2_ctrl_new_std_menu(hdl, &saa7164_ctrl_ops, 1041 V4L2_CID_MPEG_STREAM_TYPE, 1042 V4L2_MPEG_STREAM_TYPE_MPEG2_TS, 0, 1043 V4L2_MPEG_STREAM_TYPE_MPEG2_PS); 1044 v4l2_ctrl_new_std_menu(hdl, &saa7164_ctrl_ops, 1045 V4L2_CID_MPEG_VIDEO_ASPECT, 1046 V4L2_MPEG_VIDEO_ASPECT_221x100, 0, 1047 V4L2_MPEG_VIDEO_ASPECT_4x3); 1048 v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops, 1049 V4L2_CID_MPEG_VIDEO_GOP_SIZE, 1, 255, 1, 15); 1050 v4l2_ctrl_new_std_menu(hdl, &saa7164_ctrl_ops, 1051 V4L2_CID_MPEG_VIDEO_BITRATE_MODE, 1052 V4L2_MPEG_VIDEO_BITRATE_MODE_CBR, 0, 1053 V4L2_MPEG_VIDEO_BITRATE_MODE_VBR); 1054 v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops, 1055 V4L2_CID_MPEG_VIDEO_B_FRAMES, 1, 3, 1, 1); 1056 v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops, 1057 V4L2_CID_MPEG_VIDEO_BITRATE_PEAK, 1058 ENCODER_MIN_BITRATE, ENCODER_MAX_BITRATE, 1059 100000, ENCODER_DEF_BITRATE); 1060 if (hdl->error) { 1061 result = hdl->error; 1062 goto fail_hdl; 1063 } 1064 1065 port->std = V4L2_STD_NTSC_M; 1066 1067 if (port->encodernorm.id & V4L2_STD_525_60) 1068 port->height = 480; 1069 else 1070 port->height = 576; 1071 1072 /* Allocate and register the video device node */ 1073 port->v4l_device = saa7164_encoder_alloc(port, 1074 dev->pci, &saa7164_mpeg_template, "mpeg"); 1075 1076 if (!port->v4l_device) { 1077 printk(KERN_INFO "%s: can't allocate mpeg device\n", 1078 dev->name); 1079 result = -ENOMEM; 1080 goto fail_hdl; 1081 } 1082 1083 port->v4l_device->ctrl_handler = hdl; 1084 v4l2_ctrl_handler_setup(hdl); 1085 video_set_drvdata(port->v4l_device, port); 1086 result = video_register_device(port->v4l_device, 1087 VFL_TYPE_VIDEO, -1); 1088 if (result < 0) { 1089 printk(KERN_INFO "%s: can't register mpeg device\n", 1090 dev->name); 1091 goto fail_reg; 1092 } 1093 1094 printk(KERN_INFO "%s: registered device video%d [mpeg]\n", 1095 dev->name, port->v4l_device->num); 1096 1097 /* Configure the hardware defaults */ 1098 saa7164_api_set_videomux(port); 1099 saa7164_api_set_usercontrol(port, PU_BRIGHTNESS_CONTROL); 1100 saa7164_api_set_usercontrol(port, PU_CONTRAST_CONTROL); 1101 saa7164_api_set_usercontrol(port, PU_HUE_CONTROL); 1102 saa7164_api_set_usercontrol(port, PU_SATURATION_CONTROL); 1103 saa7164_api_set_usercontrol(port, PU_SHARPNESS_CONTROL); 1104 saa7164_api_audio_mute(port, 0); 1105 saa7164_api_set_audio_volume(port, 20); 1106 saa7164_api_set_aspect_ratio(port); 1107 1108 /* Disable audio standard detection, it's buggy */ 1109 saa7164_api_set_audio_detection(port, 0); 1110 1111 saa7164_api_set_encoder(port); 1112 saa7164_api_get_encoder(port); 1113 return 0; 1114 1115 fail_reg: 1116 video_device_release(port->v4l_device); 1117 port->v4l_device = NULL; 1118 fail_hdl: 1119 v4l2_ctrl_handler_free(hdl); 1120 fail_pci: 1121 return result; 1122 } 1123 1124 void saa7164_encoder_unregister(struct saa7164_port *port) 1125 { 1126 struct saa7164_dev *dev = port->dev; 1127 1128 dprintk(DBGLVL_ENC, "%s(port=%d)\n", __func__, port->nr); 1129 1130 BUG_ON(port->type != SAA7164_MPEG_ENCODER); 1131 1132 if (port->v4l_device) { 1133 if (port->v4l_device->minor != -1) 1134 video_unregister_device(port->v4l_device); 1135 else 1136 video_device_release(port->v4l_device); 1137 1138 port->v4l_device = NULL; 1139 } 1140 v4l2_ctrl_handler_free(&port->ctrl_handler); 1141 1142 dprintk(DBGLVL_ENC, "%s(port=%d) done\n", __func__, port->nr); 1143 } 1144 1145