1 /* 2 * Driver for the NXP SAA7164 PCIe bridge 3 * 4 * Copyright (c) 2010 Steven Toth <stoth@kernellabs.com> 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * 15 * GNU General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, write to the Free Software 19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 */ 21 22 #include "saa7164.h" 23 24 static struct saa7164_tvnorm saa7164_tvnorms[] = { 25 { 26 .name = "NTSC-M", 27 .id = V4L2_STD_NTSC_M, 28 }, { 29 .name = "NTSC-JP", 30 .id = V4L2_STD_NTSC_M_JP, 31 } 32 }; 33 34 static const u32 saa7164_v4l2_ctrls[] = { 35 0 36 }; 37 38 /* Take the encoder configuration from the port struct and 39 * flush it to the hardware. 40 */ 41 static void saa7164_vbi_configure(struct saa7164_port *port) 42 { 43 struct saa7164_dev *dev = port->dev; 44 dprintk(DBGLVL_VBI, "%s()\n", __func__); 45 46 port->vbi_params.width = port->width; 47 port->vbi_params.height = port->height; 48 port->vbi_params.is_50hz = 49 (port->encodernorm.id & V4L2_STD_625_50) != 0; 50 51 /* Set up the DIF (enable it) for analog mode by default */ 52 saa7164_api_initialize_dif(port); 53 54 /* Configure the correct video standard */ 55 #if 0 56 saa7164_api_configure_dif(port, port->encodernorm.id); 57 #endif 58 59 #if 0 60 /* Ensure the audio decoder is correct configured */ 61 saa7164_api_set_audio_std(port); 62 #endif 63 dprintk(DBGLVL_VBI, "%s() ends\n", __func__); 64 } 65 66 static int saa7164_vbi_buffers_dealloc(struct saa7164_port *port) 67 { 68 struct list_head *c, *n, *p, *q, *l, *v; 69 struct saa7164_dev *dev = port->dev; 70 struct saa7164_buffer *buf; 71 struct saa7164_user_buffer *ubuf; 72 73 /* Remove any allocated buffers */ 74 mutex_lock(&port->dmaqueue_lock); 75 76 dprintk(DBGLVL_VBI, "%s(port=%d) dmaqueue\n", __func__, port->nr); 77 list_for_each_safe(c, n, &port->dmaqueue.list) { 78 buf = list_entry(c, struct saa7164_buffer, list); 79 list_del(c); 80 saa7164_buffer_dealloc(buf); 81 } 82 83 dprintk(DBGLVL_VBI, "%s(port=%d) used\n", __func__, port->nr); 84 list_for_each_safe(p, q, &port->list_buf_used.list) { 85 ubuf = list_entry(p, struct saa7164_user_buffer, list); 86 list_del(p); 87 saa7164_buffer_dealloc_user(ubuf); 88 } 89 90 dprintk(DBGLVL_VBI, "%s(port=%d) free\n", __func__, port->nr); 91 list_for_each_safe(l, v, &port->list_buf_free.list) { 92 ubuf = list_entry(l, struct saa7164_user_buffer, list); 93 list_del(l); 94 saa7164_buffer_dealloc_user(ubuf); 95 } 96 97 mutex_unlock(&port->dmaqueue_lock); 98 dprintk(DBGLVL_VBI, "%s(port=%d) done\n", __func__, port->nr); 99 100 return 0; 101 } 102 103 /* Dynamic buffer switch at vbi start time */ 104 static int saa7164_vbi_buffers_alloc(struct saa7164_port *port) 105 { 106 struct saa7164_dev *dev = port->dev; 107 struct saa7164_buffer *buf; 108 struct saa7164_user_buffer *ubuf; 109 struct tmHWStreamParameters *params = &port->hw_streamingparams; 110 int result = -ENODEV, i; 111 int len = 0; 112 113 dprintk(DBGLVL_VBI, "%s()\n", __func__); 114 115 /* TODO: NTSC SPECIFIC */ 116 /* Init and establish defaults */ 117 params->samplesperline = 1440; 118 params->numberoflines = 12; 119 params->numberoflines = 18; 120 params->pitch = 1600; 121 params->pitch = 1440; 122 params->numpagetables = 2 + 123 ((params->numberoflines * params->pitch) / PAGE_SIZE); 124 params->bitspersample = 8; 125 params->linethreshold = 0; 126 params->pagetablelistvirt = NULL; 127 params->pagetablelistphys = NULL; 128 params->numpagetableentries = port->hwcfg.buffercount; 129 130 /* Allocate the PCI resources, buffers (hard) */ 131 for (i = 0; i < port->hwcfg.buffercount; i++) { 132 buf = saa7164_buffer_alloc(port, 133 params->numberoflines * 134 params->pitch); 135 136 if (!buf) { 137 printk(KERN_ERR "%s() failed " 138 "(errno = %d), unable to allocate buffer\n", 139 __func__, result); 140 result = -ENOMEM; 141 goto failed; 142 } else { 143 144 mutex_lock(&port->dmaqueue_lock); 145 list_add_tail(&buf->list, &port->dmaqueue.list); 146 mutex_unlock(&port->dmaqueue_lock); 147 148 } 149 } 150 151 /* Allocate some kernel buffers for copying 152 * to userpsace. 153 */ 154 len = params->numberoflines * params->pitch; 155 156 if (vbi_buffers < 16) 157 vbi_buffers = 16; 158 if (vbi_buffers > 512) 159 vbi_buffers = 512; 160 161 for (i = 0; i < vbi_buffers; i++) { 162 163 ubuf = saa7164_buffer_alloc_user(dev, len); 164 if (ubuf) { 165 mutex_lock(&port->dmaqueue_lock); 166 list_add_tail(&ubuf->list, &port->list_buf_free.list); 167 mutex_unlock(&port->dmaqueue_lock); 168 } 169 170 } 171 172 result = 0; 173 174 failed: 175 return result; 176 } 177 178 179 static int saa7164_vbi_initialize(struct saa7164_port *port) 180 { 181 saa7164_vbi_configure(port); 182 return 0; 183 } 184 185 /* -- V4L2 --------------------------------------------------------- */ 186 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id *id) 187 { 188 struct saa7164_vbi_fh *fh = file->private_data; 189 struct saa7164_port *port = fh->port; 190 struct saa7164_dev *dev = port->dev; 191 unsigned int i; 192 193 dprintk(DBGLVL_VBI, "%s(id=0x%x)\n", __func__, (u32)*id); 194 195 for (i = 0; i < ARRAY_SIZE(saa7164_tvnorms); i++) { 196 if (*id & saa7164_tvnorms[i].id) 197 break; 198 } 199 if (i == ARRAY_SIZE(saa7164_tvnorms)) 200 return -EINVAL; 201 202 port->encodernorm = saa7164_tvnorms[i]; 203 204 /* Update the audio decoder while is not running in 205 * auto detect mode. 206 */ 207 saa7164_api_set_audio_std(port); 208 209 dprintk(DBGLVL_VBI, "%s(id=0x%x) OK\n", __func__, (u32)*id); 210 211 return 0; 212 } 213 214 static int vidioc_enum_input(struct file *file, void *priv, 215 struct v4l2_input *i) 216 { 217 int n; 218 219 char *inputs[] = { "tuner", "composite", "svideo", "aux", 220 "composite 2", "svideo 2", "aux 2" }; 221 222 if (i->index >= 7) 223 return -EINVAL; 224 225 strcpy(i->name, inputs[i->index]); 226 227 if (i->index == 0) 228 i->type = V4L2_INPUT_TYPE_TUNER; 229 else 230 i->type = V4L2_INPUT_TYPE_CAMERA; 231 232 for (n = 0; n < ARRAY_SIZE(saa7164_tvnorms); n++) 233 i->std |= saa7164_tvnorms[n].id; 234 235 return 0; 236 } 237 238 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i) 239 { 240 struct saa7164_vbi_fh *fh = file->private_data; 241 struct saa7164_port *port = fh->port; 242 struct saa7164_dev *dev = port->dev; 243 244 if (saa7164_api_get_videomux(port) != SAA_OK) 245 return -EIO; 246 247 *i = (port->mux_input - 1); 248 249 dprintk(DBGLVL_VBI, "%s() input=%d\n", __func__, *i); 250 251 return 0; 252 } 253 254 static int vidioc_s_input(struct file *file, void *priv, unsigned int i) 255 { 256 struct saa7164_vbi_fh *fh = file->private_data; 257 struct saa7164_port *port = fh->port; 258 struct saa7164_dev *dev = port->dev; 259 260 dprintk(DBGLVL_VBI, "%s() input=%d\n", __func__, i); 261 262 if (i >= 7) 263 return -EINVAL; 264 265 port->mux_input = i + 1; 266 267 if (saa7164_api_set_videomux(port) != SAA_OK) 268 return -EIO; 269 270 return 0; 271 } 272 273 static int vidioc_g_tuner(struct file *file, void *priv, 274 struct v4l2_tuner *t) 275 { 276 struct saa7164_vbi_fh *fh = file->private_data; 277 struct saa7164_port *port = fh->port; 278 struct saa7164_dev *dev = port->dev; 279 280 if (0 != t->index) 281 return -EINVAL; 282 283 strcpy(t->name, "tuner"); 284 t->type = V4L2_TUNER_ANALOG_TV; 285 t->capability = V4L2_TUNER_CAP_NORM | V4L2_TUNER_CAP_STEREO; 286 287 dprintk(DBGLVL_VBI, "VIDIOC_G_TUNER: tuner type %d\n", t->type); 288 289 return 0; 290 } 291 292 static int vidioc_s_tuner(struct file *file, void *priv, 293 struct v4l2_tuner *t) 294 { 295 /* Update the A/V core */ 296 return 0; 297 } 298 299 static int vidioc_g_frequency(struct file *file, void *priv, 300 struct v4l2_frequency *f) 301 { 302 struct saa7164_vbi_fh *fh = file->private_data; 303 struct saa7164_port *port = fh->port; 304 305 f->type = V4L2_TUNER_ANALOG_TV; 306 f->frequency = port->freq; 307 308 return 0; 309 } 310 311 static int vidioc_s_frequency(struct file *file, void *priv, 312 struct v4l2_frequency *f) 313 { 314 struct saa7164_vbi_fh *fh = file->private_data; 315 struct saa7164_port *port = fh->port; 316 struct saa7164_dev *dev = port->dev; 317 struct saa7164_port *tsport; 318 struct dvb_frontend *fe; 319 320 /* TODO: Pull this for the std */ 321 struct analog_parameters params = { 322 .mode = V4L2_TUNER_ANALOG_TV, 323 .audmode = V4L2_TUNER_MODE_STEREO, 324 .std = port->encodernorm.id, 325 .frequency = f->frequency 326 }; 327 328 /* Stop the encoder */ 329 dprintk(DBGLVL_VBI, "%s() frequency=%d tuner=%d\n", __func__, 330 f->frequency, f->tuner); 331 332 if (f->tuner != 0) 333 return -EINVAL; 334 335 if (f->type != V4L2_TUNER_ANALOG_TV) 336 return -EINVAL; 337 338 port->freq = f->frequency; 339 340 /* Update the hardware */ 341 if (port->nr == SAA7164_PORT_VBI1) 342 tsport = &dev->ports[SAA7164_PORT_TS1]; 343 else 344 if (port->nr == SAA7164_PORT_VBI2) 345 tsport = &dev->ports[SAA7164_PORT_TS2]; 346 else 347 BUG(); 348 349 fe = tsport->dvb.frontend; 350 351 if (fe && fe->ops.tuner_ops.set_analog_params) 352 fe->ops.tuner_ops.set_analog_params(fe, ¶ms); 353 else 354 printk(KERN_ERR "%s() No analog tuner, aborting\n", __func__); 355 356 saa7164_vbi_initialize(port); 357 358 return 0; 359 } 360 361 static int vidioc_g_ctrl(struct file *file, void *priv, 362 struct v4l2_control *ctl) 363 { 364 struct saa7164_vbi_fh *fh = file->private_data; 365 struct saa7164_port *port = fh->port; 366 struct saa7164_dev *dev = port->dev; 367 368 dprintk(DBGLVL_VBI, "%s(id=%d, value=%d)\n", __func__, 369 ctl->id, ctl->value); 370 371 switch (ctl->id) { 372 case V4L2_CID_BRIGHTNESS: 373 ctl->value = port->ctl_brightness; 374 break; 375 case V4L2_CID_CONTRAST: 376 ctl->value = port->ctl_contrast; 377 break; 378 case V4L2_CID_SATURATION: 379 ctl->value = port->ctl_saturation; 380 break; 381 case V4L2_CID_HUE: 382 ctl->value = port->ctl_hue; 383 break; 384 case V4L2_CID_SHARPNESS: 385 ctl->value = port->ctl_sharpness; 386 break; 387 case V4L2_CID_AUDIO_VOLUME: 388 ctl->value = port->ctl_volume; 389 break; 390 default: 391 return -EINVAL; 392 } 393 394 return 0; 395 } 396 397 static int vidioc_s_ctrl(struct file *file, void *priv, 398 struct v4l2_control *ctl) 399 { 400 struct saa7164_vbi_fh *fh = file->private_data; 401 struct saa7164_port *port = fh->port; 402 struct saa7164_dev *dev = port->dev; 403 int ret = 0; 404 405 dprintk(DBGLVL_VBI, "%s(id=%d, value=%d)\n", __func__, 406 ctl->id, ctl->value); 407 408 switch (ctl->id) { 409 case V4L2_CID_BRIGHTNESS: 410 if ((ctl->value >= 0) && (ctl->value <= 255)) { 411 port->ctl_brightness = ctl->value; 412 saa7164_api_set_usercontrol(port, 413 PU_BRIGHTNESS_CONTROL); 414 } else 415 ret = -EINVAL; 416 break; 417 case V4L2_CID_CONTRAST: 418 if ((ctl->value >= 0) && (ctl->value <= 255)) { 419 port->ctl_contrast = ctl->value; 420 saa7164_api_set_usercontrol(port, PU_CONTRAST_CONTROL); 421 } else 422 ret = -EINVAL; 423 break; 424 case V4L2_CID_SATURATION: 425 if ((ctl->value >= 0) && (ctl->value <= 255)) { 426 port->ctl_saturation = ctl->value; 427 saa7164_api_set_usercontrol(port, 428 PU_SATURATION_CONTROL); 429 } else 430 ret = -EINVAL; 431 break; 432 case V4L2_CID_HUE: 433 if ((ctl->value >= 0) && (ctl->value <= 255)) { 434 port->ctl_hue = ctl->value; 435 saa7164_api_set_usercontrol(port, PU_HUE_CONTROL); 436 } else 437 ret = -EINVAL; 438 break; 439 case V4L2_CID_SHARPNESS: 440 if ((ctl->value >= 0) && (ctl->value <= 255)) { 441 port->ctl_sharpness = ctl->value; 442 saa7164_api_set_usercontrol(port, PU_SHARPNESS_CONTROL); 443 } else 444 ret = -EINVAL; 445 break; 446 case V4L2_CID_AUDIO_VOLUME: 447 if ((ctl->value >= -83) && (ctl->value <= 24)) { 448 port->ctl_volume = ctl->value; 449 saa7164_api_set_audio_volume(port, port->ctl_volume); 450 } else 451 ret = -EINVAL; 452 break; 453 default: 454 ret = -EINVAL; 455 } 456 457 return ret; 458 } 459 460 static int saa7164_get_ctrl(struct saa7164_port *port, 461 struct v4l2_ext_control *ctrl) 462 { 463 struct saa7164_vbi_params *params = &port->vbi_params; 464 465 switch (ctrl->id) { 466 case V4L2_CID_MPEG_STREAM_TYPE: 467 ctrl->value = params->stream_type; 468 break; 469 case V4L2_CID_MPEG_AUDIO_MUTE: 470 ctrl->value = params->ctl_mute; 471 break; 472 case V4L2_CID_MPEG_VIDEO_ASPECT: 473 ctrl->value = params->ctl_aspect; 474 break; 475 case V4L2_CID_MPEG_VIDEO_B_FRAMES: 476 ctrl->value = params->refdist; 477 break; 478 case V4L2_CID_MPEG_VIDEO_GOP_SIZE: 479 ctrl->value = params->gop_size; 480 break; 481 default: 482 return -EINVAL; 483 } 484 return 0; 485 } 486 487 static int vidioc_g_ext_ctrls(struct file *file, void *priv, 488 struct v4l2_ext_controls *ctrls) 489 { 490 struct saa7164_vbi_fh *fh = file->private_data; 491 struct saa7164_port *port = fh->port; 492 int i, err = 0; 493 494 if (ctrls->ctrl_class == V4L2_CTRL_CLASS_MPEG) { 495 for (i = 0; i < ctrls->count; i++) { 496 struct v4l2_ext_control *ctrl = ctrls->controls + i; 497 498 err = saa7164_get_ctrl(port, ctrl); 499 if (err) { 500 ctrls->error_idx = i; 501 break; 502 } 503 } 504 return err; 505 506 } 507 508 return -EINVAL; 509 } 510 511 static int saa7164_try_ctrl(struct v4l2_ext_control *ctrl, int ac3) 512 { 513 int ret = -EINVAL; 514 515 switch (ctrl->id) { 516 case V4L2_CID_MPEG_STREAM_TYPE: 517 if ((ctrl->value == V4L2_MPEG_STREAM_TYPE_MPEG2_PS) || 518 (ctrl->value == V4L2_MPEG_STREAM_TYPE_MPEG2_TS)) 519 ret = 0; 520 break; 521 case V4L2_CID_MPEG_AUDIO_MUTE: 522 if ((ctrl->value >= 0) && 523 (ctrl->value <= 1)) 524 ret = 0; 525 break; 526 case V4L2_CID_MPEG_VIDEO_ASPECT: 527 if ((ctrl->value >= V4L2_MPEG_VIDEO_ASPECT_1x1) && 528 (ctrl->value <= V4L2_MPEG_VIDEO_ASPECT_221x100)) 529 ret = 0; 530 break; 531 case V4L2_CID_MPEG_VIDEO_GOP_SIZE: 532 if ((ctrl->value >= 0) && 533 (ctrl->value <= 255)) 534 ret = 0; 535 break; 536 case V4L2_CID_MPEG_VIDEO_B_FRAMES: 537 if ((ctrl->value >= 1) && 538 (ctrl->value <= 3)) 539 ret = 0; 540 break; 541 default: 542 ret = -EINVAL; 543 } 544 545 return ret; 546 } 547 548 static int vidioc_try_ext_ctrls(struct file *file, void *priv, 549 struct v4l2_ext_controls *ctrls) 550 { 551 int i, err = 0; 552 553 if (ctrls->ctrl_class == V4L2_CTRL_CLASS_MPEG) { 554 for (i = 0; i < ctrls->count; i++) { 555 struct v4l2_ext_control *ctrl = ctrls->controls + i; 556 557 err = saa7164_try_ctrl(ctrl, 0); 558 if (err) { 559 ctrls->error_idx = i; 560 break; 561 } 562 } 563 return err; 564 } 565 566 return -EINVAL; 567 } 568 569 static int saa7164_set_ctrl(struct saa7164_port *port, 570 struct v4l2_ext_control *ctrl) 571 { 572 struct saa7164_vbi_params *params = &port->vbi_params; 573 int ret = 0; 574 575 switch (ctrl->id) { 576 case V4L2_CID_MPEG_STREAM_TYPE: 577 params->stream_type = ctrl->value; 578 break; 579 case V4L2_CID_MPEG_AUDIO_MUTE: 580 params->ctl_mute = ctrl->value; 581 ret = saa7164_api_audio_mute(port, params->ctl_mute); 582 if (ret != SAA_OK) { 583 printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__, 584 ret); 585 ret = -EIO; 586 } 587 break; 588 case V4L2_CID_MPEG_VIDEO_ASPECT: 589 params->ctl_aspect = ctrl->value; 590 ret = saa7164_api_set_aspect_ratio(port); 591 if (ret != SAA_OK) { 592 printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__, 593 ret); 594 ret = -EIO; 595 } 596 break; 597 case V4L2_CID_MPEG_VIDEO_B_FRAMES: 598 params->refdist = ctrl->value; 599 break; 600 case V4L2_CID_MPEG_VIDEO_GOP_SIZE: 601 params->gop_size = ctrl->value; 602 break; 603 default: 604 return -EINVAL; 605 } 606 607 /* TODO: Update the hardware */ 608 609 return ret; 610 } 611 612 static int vidioc_s_ext_ctrls(struct file *file, void *priv, 613 struct v4l2_ext_controls *ctrls) 614 { 615 struct saa7164_vbi_fh *fh = file->private_data; 616 struct saa7164_port *port = fh->port; 617 int i, err = 0; 618 619 if (ctrls->ctrl_class == V4L2_CTRL_CLASS_MPEG) { 620 for (i = 0; i < ctrls->count; i++) { 621 struct v4l2_ext_control *ctrl = ctrls->controls + i; 622 623 err = saa7164_try_ctrl(ctrl, 0); 624 if (err) { 625 ctrls->error_idx = i; 626 break; 627 } 628 err = saa7164_set_ctrl(port, ctrl); 629 if (err) { 630 ctrls->error_idx = i; 631 break; 632 } 633 } 634 return err; 635 636 } 637 638 return -EINVAL; 639 } 640 641 static int vidioc_querycap(struct file *file, void *priv, 642 struct v4l2_capability *cap) 643 { 644 struct saa7164_vbi_fh *fh = file->private_data; 645 struct saa7164_port *port = fh->port; 646 struct saa7164_dev *dev = port->dev; 647 648 strcpy(cap->driver, dev->name); 649 strlcpy(cap->card, saa7164_boards[dev->board].name, 650 sizeof(cap->card)); 651 sprintf(cap->bus_info, "PCI:%s", pci_name(dev->pci)); 652 653 cap->capabilities = 654 V4L2_CAP_VBI_CAPTURE | 655 V4L2_CAP_READWRITE | 656 0; 657 658 cap->capabilities |= V4L2_CAP_TUNER; 659 cap->version = 0; 660 661 return 0; 662 } 663 664 static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv, 665 struct v4l2_fmtdesc *f) 666 { 667 if (f->index != 0) 668 return -EINVAL; 669 670 strlcpy(f->description, "VBI", sizeof(f->description)); 671 f->pixelformat = V4L2_PIX_FMT_MPEG; 672 673 return 0; 674 } 675 676 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv, 677 struct v4l2_format *f) 678 { 679 struct saa7164_vbi_fh *fh = file->private_data; 680 struct saa7164_port *port = fh->port; 681 struct saa7164_dev *dev = port->dev; 682 683 f->fmt.pix.pixelformat = V4L2_PIX_FMT_MPEG; 684 f->fmt.pix.bytesperline = 0; 685 f->fmt.pix.sizeimage = 686 port->ts_packet_size * port->ts_packet_count; 687 f->fmt.pix.colorspace = 0; 688 f->fmt.pix.width = port->width; 689 f->fmt.pix.height = port->height; 690 691 dprintk(DBGLVL_VBI, "VIDIOC_G_FMT: w: %d, h: %d\n", 692 port->width, port->height); 693 694 return 0; 695 } 696 697 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv, 698 struct v4l2_format *f) 699 { 700 struct saa7164_vbi_fh *fh = file->private_data; 701 struct saa7164_port *port = fh->port; 702 struct saa7164_dev *dev = port->dev; 703 704 f->fmt.pix.pixelformat = V4L2_PIX_FMT_MPEG; 705 f->fmt.pix.bytesperline = 0; 706 f->fmt.pix.sizeimage = 707 port->ts_packet_size * port->ts_packet_count; 708 f->fmt.pix.colorspace = 0; 709 dprintk(DBGLVL_VBI, "VIDIOC_TRY_FMT: w: %d, h: %d\n", 710 port->width, port->height); 711 return 0; 712 } 713 714 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv, 715 struct v4l2_format *f) 716 { 717 struct saa7164_vbi_fh *fh = file->private_data; 718 struct saa7164_port *port = fh->port; 719 struct saa7164_dev *dev = port->dev; 720 721 f->fmt.pix.pixelformat = V4L2_PIX_FMT_MPEG; 722 f->fmt.pix.bytesperline = 0; 723 f->fmt.pix.sizeimage = 724 port->ts_packet_size * port->ts_packet_count; 725 f->fmt.pix.colorspace = 0; 726 727 dprintk(DBGLVL_VBI, "VIDIOC_S_FMT: w: %d, h: %d, f: %d\n", 728 f->fmt.pix.width, f->fmt.pix.height, f->fmt.pix.field); 729 730 return 0; 731 } 732 733 static int fill_queryctrl(struct saa7164_vbi_params *params, 734 struct v4l2_queryctrl *c) 735 { 736 switch (c->id) { 737 case V4L2_CID_BRIGHTNESS: 738 return v4l2_ctrl_query_fill(c, 0x0, 0xff, 1, 127); 739 case V4L2_CID_CONTRAST: 740 return v4l2_ctrl_query_fill(c, 0x0, 0xff, 1, 66); 741 case V4L2_CID_SATURATION: 742 return v4l2_ctrl_query_fill(c, 0x0, 0xff, 1, 62); 743 case V4L2_CID_HUE: 744 return v4l2_ctrl_query_fill(c, 0x0, 0xff, 1, 128); 745 case V4L2_CID_SHARPNESS: 746 return v4l2_ctrl_query_fill(c, 0x0, 0x0f, 1, 8); 747 case V4L2_CID_MPEG_AUDIO_MUTE: 748 return v4l2_ctrl_query_fill(c, 0x0, 0x01, 1, 0); 749 case V4L2_CID_AUDIO_VOLUME: 750 return v4l2_ctrl_query_fill(c, -83, 24, 1, 20); 751 case V4L2_CID_MPEG_STREAM_TYPE: 752 return v4l2_ctrl_query_fill(c, 753 V4L2_MPEG_STREAM_TYPE_MPEG2_PS, 754 V4L2_MPEG_STREAM_TYPE_MPEG2_TS, 755 1, V4L2_MPEG_STREAM_TYPE_MPEG2_PS); 756 case V4L2_CID_MPEG_VIDEO_ASPECT: 757 return v4l2_ctrl_query_fill(c, 758 V4L2_MPEG_VIDEO_ASPECT_1x1, 759 V4L2_MPEG_VIDEO_ASPECT_221x100, 760 1, V4L2_MPEG_VIDEO_ASPECT_4x3); 761 case V4L2_CID_MPEG_VIDEO_GOP_SIZE: 762 return v4l2_ctrl_query_fill(c, 1, 255, 1, 15); 763 case V4L2_CID_MPEG_VIDEO_B_FRAMES: 764 return v4l2_ctrl_query_fill(c, 765 1, 3, 1, 1); 766 default: 767 return -EINVAL; 768 } 769 } 770 771 static int vidioc_queryctrl(struct file *file, void *priv, 772 struct v4l2_queryctrl *c) 773 { 774 struct saa7164_vbi_fh *fh = priv; 775 struct saa7164_port *port = fh->port; 776 int i, next; 777 u32 id = c->id; 778 779 memset(c, 0, sizeof(*c)); 780 781 next = !!(id & V4L2_CTRL_FLAG_NEXT_CTRL); 782 c->id = id & ~V4L2_CTRL_FLAG_NEXT_CTRL; 783 784 for (i = 0; i < ARRAY_SIZE(saa7164_v4l2_ctrls); i++) { 785 if (next) { 786 if (c->id < saa7164_v4l2_ctrls[i]) 787 c->id = saa7164_v4l2_ctrls[i]; 788 else 789 continue; 790 } 791 792 if (c->id == saa7164_v4l2_ctrls[i]) 793 return fill_queryctrl(&port->vbi_params, c); 794 795 if (c->id < saa7164_v4l2_ctrls[i]) 796 break; 797 } 798 799 return -EINVAL; 800 } 801 802 static int saa7164_vbi_stop_port(struct saa7164_port *port) 803 { 804 struct saa7164_dev *dev = port->dev; 805 int ret; 806 807 ret = saa7164_api_transition_port(port, SAA_DMASTATE_STOP); 808 if ((ret != SAA_OK) && (ret != SAA_ERR_ALREADY_STOPPED)) { 809 printk(KERN_ERR "%s() stop transition failed, ret = 0x%x\n", 810 __func__, ret); 811 ret = -EIO; 812 } else { 813 dprintk(DBGLVL_VBI, "%s() Stopped\n", __func__); 814 ret = 0; 815 } 816 817 return ret; 818 } 819 820 static int saa7164_vbi_acquire_port(struct saa7164_port *port) 821 { 822 struct saa7164_dev *dev = port->dev; 823 int ret; 824 825 ret = saa7164_api_transition_port(port, SAA_DMASTATE_ACQUIRE); 826 if ((ret != SAA_OK) && (ret != SAA_ERR_ALREADY_STOPPED)) { 827 printk(KERN_ERR "%s() acquire transition failed, ret = 0x%x\n", 828 __func__, ret); 829 ret = -EIO; 830 } else { 831 dprintk(DBGLVL_VBI, "%s() Acquired\n", __func__); 832 ret = 0; 833 } 834 835 return ret; 836 } 837 838 static int saa7164_vbi_pause_port(struct saa7164_port *port) 839 { 840 struct saa7164_dev *dev = port->dev; 841 int ret; 842 843 ret = saa7164_api_transition_port(port, SAA_DMASTATE_PAUSE); 844 if ((ret != SAA_OK) && (ret != SAA_ERR_ALREADY_STOPPED)) { 845 printk(KERN_ERR "%s() pause transition failed, ret = 0x%x\n", 846 __func__, ret); 847 ret = -EIO; 848 } else { 849 dprintk(DBGLVL_VBI, "%s() Paused\n", __func__); 850 ret = 0; 851 } 852 853 return ret; 854 } 855 856 /* Firmware is very windows centric, meaning you have to transition 857 * the part through AVStream / KS Windows stages, forwards or backwards. 858 * States are: stopped, acquired (h/w), paused, started. 859 * We have to leave here will all of the soft buffers on the free list, 860 * else the cfg_post() func won't have soft buffers to correctly configure. 861 */ 862 static int saa7164_vbi_stop_streaming(struct saa7164_port *port) 863 { 864 struct saa7164_dev *dev = port->dev; 865 struct saa7164_buffer *buf; 866 struct saa7164_user_buffer *ubuf; 867 struct list_head *c, *n; 868 int ret; 869 870 dprintk(DBGLVL_VBI, "%s(port=%d)\n", __func__, port->nr); 871 872 ret = saa7164_vbi_pause_port(port); 873 ret = saa7164_vbi_acquire_port(port); 874 ret = saa7164_vbi_stop_port(port); 875 876 dprintk(DBGLVL_VBI, "%s(port=%d) Hardware stopped\n", __func__, 877 port->nr); 878 879 /* Reset the state of any allocated buffer resources */ 880 mutex_lock(&port->dmaqueue_lock); 881 882 /* Reset the hard and soft buffer state */ 883 list_for_each_safe(c, n, &port->dmaqueue.list) { 884 buf = list_entry(c, struct saa7164_buffer, list); 885 buf->flags = SAA7164_BUFFER_FREE; 886 buf->pos = 0; 887 } 888 889 list_for_each_safe(c, n, &port->list_buf_used.list) { 890 ubuf = list_entry(c, struct saa7164_user_buffer, list); 891 ubuf->pos = 0; 892 list_move_tail(&ubuf->list, &port->list_buf_free.list); 893 } 894 895 mutex_unlock(&port->dmaqueue_lock); 896 897 /* Free any allocated resources */ 898 saa7164_vbi_buffers_dealloc(port); 899 900 dprintk(DBGLVL_VBI, "%s(port=%d) Released\n", __func__, port->nr); 901 902 return ret; 903 } 904 905 static int saa7164_vbi_start_streaming(struct saa7164_port *port) 906 { 907 struct saa7164_dev *dev = port->dev; 908 int result, ret = 0; 909 910 dprintk(DBGLVL_VBI, "%s(port=%d)\n", __func__, port->nr); 911 912 port->done_first_interrupt = 0; 913 914 /* allocate all of the PCIe DMA buffer resources on the fly, 915 * allowing switching between TS and PS payloads without 916 * requiring a complete driver reload. 917 */ 918 saa7164_vbi_buffers_alloc(port); 919 920 /* Configure the encoder with any cache values */ 921 #if 0 922 saa7164_api_set_encoder(port); 923 saa7164_api_get_encoder(port); 924 #endif 925 926 /* Place the empty buffers on the hardware */ 927 saa7164_buffer_cfg_port(port); 928 929 /* Negotiate format */ 930 if (saa7164_api_set_vbi_format(port) != SAA_OK) { 931 printk(KERN_ERR "%s() No supported VBI format\n", __func__); 932 ret = -EIO; 933 goto out; 934 } 935 936 /* Acquire the hardware */ 937 result = saa7164_api_transition_port(port, SAA_DMASTATE_ACQUIRE); 938 if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) { 939 printk(KERN_ERR "%s() acquire transition failed, res = 0x%x\n", 940 __func__, result); 941 942 ret = -EIO; 943 goto out; 944 } else 945 dprintk(DBGLVL_VBI, "%s() Acquired\n", __func__); 946 947 /* Pause the hardware */ 948 result = saa7164_api_transition_port(port, SAA_DMASTATE_PAUSE); 949 if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) { 950 printk(KERN_ERR "%s() pause transition failed, res = 0x%x\n", 951 __func__, result); 952 953 /* Stop the hardware, regardless */ 954 result = saa7164_vbi_stop_port(port); 955 if (result != SAA_OK) { 956 printk(KERN_ERR "%s() pause/forced stop transition " 957 "failed, res = 0x%x\n", __func__, result); 958 } 959 960 ret = -EIO; 961 goto out; 962 } else 963 dprintk(DBGLVL_VBI, "%s() Paused\n", __func__); 964 965 /* Start the hardware */ 966 result = saa7164_api_transition_port(port, SAA_DMASTATE_RUN); 967 if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) { 968 printk(KERN_ERR "%s() run transition failed, result = 0x%x\n", 969 __func__, result); 970 971 /* Stop the hardware, regardless */ 972 result = saa7164_vbi_acquire_port(port); 973 result = saa7164_vbi_stop_port(port); 974 if (result != SAA_OK) { 975 printk(KERN_ERR "%s() run/forced stop transition " 976 "failed, res = 0x%x\n", __func__, result); 977 } 978 979 ret = -EIO; 980 } else 981 dprintk(DBGLVL_VBI, "%s() Running\n", __func__); 982 983 out: 984 return ret; 985 } 986 987 static int saa7164_vbi_fmt(struct file *file, void *priv, 988 struct v4l2_format *f) 989 { 990 /* ntsc */ 991 f->fmt.vbi.samples_per_line = 1600; 992 f->fmt.vbi.samples_per_line = 1440; 993 f->fmt.vbi.sampling_rate = 27000000; 994 f->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY; 995 f->fmt.vbi.offset = 0; 996 f->fmt.vbi.flags = 0; 997 f->fmt.vbi.start[0] = 10; 998 f->fmt.vbi.count[0] = 18; 999 f->fmt.vbi.start[1] = 263 + 10 + 1; 1000 f->fmt.vbi.count[1] = 18; 1001 return 0; 1002 } 1003 1004 static int fops_open(struct file *file) 1005 { 1006 struct saa7164_dev *dev; 1007 struct saa7164_port *port; 1008 struct saa7164_vbi_fh *fh; 1009 1010 port = (struct saa7164_port *)video_get_drvdata(video_devdata(file)); 1011 if (!port) 1012 return -ENODEV; 1013 1014 dev = port->dev; 1015 1016 dprintk(DBGLVL_VBI, "%s()\n", __func__); 1017 1018 /* allocate + initialize per filehandle data */ 1019 fh = kzalloc(sizeof(*fh), GFP_KERNEL); 1020 if (NULL == fh) 1021 return -ENOMEM; 1022 1023 file->private_data = fh; 1024 fh->port = port; 1025 1026 return 0; 1027 } 1028 1029 static int fops_release(struct file *file) 1030 { 1031 struct saa7164_vbi_fh *fh = file->private_data; 1032 struct saa7164_port *port = fh->port; 1033 struct saa7164_dev *dev = port->dev; 1034 1035 dprintk(DBGLVL_VBI, "%s()\n", __func__); 1036 1037 /* Shut device down on last close */ 1038 if (atomic_cmpxchg(&fh->v4l_reading, 1, 0) == 1) { 1039 if (atomic_dec_return(&port->v4l_reader_count) == 0) { 1040 /* stop vbi capture then cancel buffers */ 1041 saa7164_vbi_stop_streaming(port); 1042 } 1043 } 1044 1045 file->private_data = NULL; 1046 kfree(fh); 1047 1048 return 0; 1049 } 1050 1051 static struct 1052 saa7164_user_buffer *saa7164_vbi_next_buf(struct saa7164_port *port) 1053 { 1054 struct saa7164_user_buffer *ubuf = NULL; 1055 struct saa7164_dev *dev = port->dev; 1056 u32 crc; 1057 1058 mutex_lock(&port->dmaqueue_lock); 1059 if (!list_empty(&port->list_buf_used.list)) { 1060 ubuf = list_first_entry(&port->list_buf_used.list, 1061 struct saa7164_user_buffer, list); 1062 1063 if (crc_checking) { 1064 crc = crc32(0, ubuf->data, ubuf->actual_size); 1065 if (crc != ubuf->crc) { 1066 printk(KERN_ERR "%s() ubuf %p crc became invalid, was 0x%x became 0x%x\n", 1067 __func__, 1068 ubuf, ubuf->crc, crc); 1069 } 1070 } 1071 1072 } 1073 mutex_unlock(&port->dmaqueue_lock); 1074 1075 dprintk(DBGLVL_VBI, "%s() returns %p\n", __func__, ubuf); 1076 1077 return ubuf; 1078 } 1079 1080 static ssize_t fops_read(struct file *file, char __user *buffer, 1081 size_t count, loff_t *pos) 1082 { 1083 struct saa7164_vbi_fh *fh = file->private_data; 1084 struct saa7164_port *port = fh->port; 1085 struct saa7164_user_buffer *ubuf = NULL; 1086 struct saa7164_dev *dev = port->dev; 1087 int ret = 0; 1088 int rem, cnt; 1089 u8 *p; 1090 1091 port->last_read_msecs_diff = port->last_read_msecs; 1092 port->last_read_msecs = jiffies_to_msecs(jiffies); 1093 port->last_read_msecs_diff = port->last_read_msecs - 1094 port->last_read_msecs_diff; 1095 1096 saa7164_histogram_update(&port->read_interval, 1097 port->last_read_msecs_diff); 1098 1099 if (*pos) { 1100 printk(KERN_ERR "%s() ESPIPE\n", __func__); 1101 return -ESPIPE; 1102 } 1103 1104 if (atomic_cmpxchg(&fh->v4l_reading, 0, 1) == 0) { 1105 if (atomic_inc_return(&port->v4l_reader_count) == 1) { 1106 1107 if (saa7164_vbi_initialize(port) < 0) { 1108 printk(KERN_ERR "%s() EINVAL\n", __func__); 1109 return -EINVAL; 1110 } 1111 1112 saa7164_vbi_start_streaming(port); 1113 msleep(200); 1114 } 1115 } 1116 1117 /* blocking wait for buffer */ 1118 if ((file->f_flags & O_NONBLOCK) == 0) { 1119 if (wait_event_interruptible(port->wait_read, 1120 saa7164_vbi_next_buf(port))) { 1121 printk(KERN_ERR "%s() ERESTARTSYS\n", __func__); 1122 return -ERESTARTSYS; 1123 } 1124 } 1125 1126 /* Pull the first buffer from the used list */ 1127 ubuf = saa7164_vbi_next_buf(port); 1128 1129 while ((count > 0) && ubuf) { 1130 1131 /* set remaining bytes to copy */ 1132 rem = ubuf->actual_size - ubuf->pos; 1133 cnt = rem > count ? count : rem; 1134 1135 p = ubuf->data + ubuf->pos; 1136 1137 dprintk(DBGLVL_VBI, 1138 "%s() count=%d cnt=%d rem=%d buf=%p buf->pos=%d\n", 1139 __func__, (int)count, cnt, rem, ubuf, ubuf->pos); 1140 1141 if (copy_to_user(buffer, p, cnt)) { 1142 printk(KERN_ERR "%s() copy_to_user failed\n", __func__); 1143 if (!ret) { 1144 printk(KERN_ERR "%s() EFAULT\n", __func__); 1145 ret = -EFAULT; 1146 } 1147 goto err; 1148 } 1149 1150 ubuf->pos += cnt; 1151 count -= cnt; 1152 buffer += cnt; 1153 ret += cnt; 1154 1155 if (ubuf->pos > ubuf->actual_size) 1156 printk(KERN_ERR "read() pos > actual, huh?\n"); 1157 1158 if (ubuf->pos == ubuf->actual_size) { 1159 1160 /* finished with current buffer, take next buffer */ 1161 1162 /* Requeue the buffer on the free list */ 1163 ubuf->pos = 0; 1164 1165 mutex_lock(&port->dmaqueue_lock); 1166 list_move_tail(&ubuf->list, &port->list_buf_free.list); 1167 mutex_unlock(&port->dmaqueue_lock); 1168 1169 /* Dequeue next */ 1170 if ((file->f_flags & O_NONBLOCK) == 0) { 1171 if (wait_event_interruptible(port->wait_read, 1172 saa7164_vbi_next_buf(port))) { 1173 break; 1174 } 1175 } 1176 ubuf = saa7164_vbi_next_buf(port); 1177 } 1178 } 1179 err: 1180 if (!ret && !ubuf) { 1181 printk(KERN_ERR "%s() EAGAIN\n", __func__); 1182 ret = -EAGAIN; 1183 } 1184 1185 return ret; 1186 } 1187 1188 static unsigned int fops_poll(struct file *file, poll_table *wait) 1189 { 1190 struct saa7164_vbi_fh *fh = (struct saa7164_vbi_fh *)file->private_data; 1191 struct saa7164_port *port = fh->port; 1192 unsigned int mask = 0; 1193 1194 port->last_poll_msecs_diff = port->last_poll_msecs; 1195 port->last_poll_msecs = jiffies_to_msecs(jiffies); 1196 port->last_poll_msecs_diff = port->last_poll_msecs - 1197 port->last_poll_msecs_diff; 1198 1199 saa7164_histogram_update(&port->poll_interval, 1200 port->last_poll_msecs_diff); 1201 1202 if (!video_is_registered(port->v4l_device)) 1203 return -EIO; 1204 1205 if (atomic_cmpxchg(&fh->v4l_reading, 0, 1) == 0) { 1206 if (atomic_inc_return(&port->v4l_reader_count) == 1) { 1207 if (saa7164_vbi_initialize(port) < 0) 1208 return -EINVAL; 1209 saa7164_vbi_start_streaming(port); 1210 msleep(200); 1211 } 1212 } 1213 1214 /* blocking wait for buffer */ 1215 if ((file->f_flags & O_NONBLOCK) == 0) { 1216 if (wait_event_interruptible(port->wait_read, 1217 saa7164_vbi_next_buf(port))) { 1218 return -ERESTARTSYS; 1219 } 1220 } 1221 1222 /* Pull the first buffer from the used list */ 1223 if (!list_empty(&port->list_buf_used.list)) 1224 mask |= POLLIN | POLLRDNORM; 1225 1226 return mask; 1227 } 1228 static const struct v4l2_file_operations vbi_fops = { 1229 .owner = THIS_MODULE, 1230 .open = fops_open, 1231 .release = fops_release, 1232 .read = fops_read, 1233 .poll = fops_poll, 1234 .unlocked_ioctl = video_ioctl2, 1235 }; 1236 1237 static const struct v4l2_ioctl_ops vbi_ioctl_ops = { 1238 .vidioc_s_std = vidioc_s_std, 1239 .vidioc_enum_input = vidioc_enum_input, 1240 .vidioc_g_input = vidioc_g_input, 1241 .vidioc_s_input = vidioc_s_input, 1242 .vidioc_g_tuner = vidioc_g_tuner, 1243 .vidioc_s_tuner = vidioc_s_tuner, 1244 .vidioc_g_frequency = vidioc_g_frequency, 1245 .vidioc_s_frequency = vidioc_s_frequency, 1246 .vidioc_s_ctrl = vidioc_s_ctrl, 1247 .vidioc_g_ctrl = vidioc_g_ctrl, 1248 .vidioc_querycap = vidioc_querycap, 1249 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap, 1250 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap, 1251 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap, 1252 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap, 1253 .vidioc_g_ext_ctrls = vidioc_g_ext_ctrls, 1254 .vidioc_s_ext_ctrls = vidioc_s_ext_ctrls, 1255 .vidioc_try_ext_ctrls = vidioc_try_ext_ctrls, 1256 .vidioc_queryctrl = vidioc_queryctrl, 1257 #if 0 1258 .vidioc_g_chip_ident = saa7164_g_chip_ident, 1259 #endif 1260 #ifdef CONFIG_VIDEO_ADV_DEBUG 1261 #if 0 1262 .vidioc_g_register = saa7164_g_register, 1263 .vidioc_s_register = saa7164_s_register, 1264 #endif 1265 #endif 1266 .vidioc_g_fmt_vbi_cap = saa7164_vbi_fmt, 1267 .vidioc_try_fmt_vbi_cap = saa7164_vbi_fmt, 1268 .vidioc_s_fmt_vbi_cap = saa7164_vbi_fmt, 1269 }; 1270 1271 static struct video_device saa7164_vbi_template = { 1272 .name = "saa7164", 1273 .fops = &vbi_fops, 1274 .ioctl_ops = &vbi_ioctl_ops, 1275 .minor = -1, 1276 .tvnorms = SAA7164_NORMS, 1277 .current_norm = V4L2_STD_NTSC_M, 1278 }; 1279 1280 static struct video_device *saa7164_vbi_alloc( 1281 struct saa7164_port *port, 1282 struct pci_dev *pci, 1283 struct video_device *template, 1284 char *type) 1285 { 1286 struct video_device *vfd; 1287 struct saa7164_dev *dev = port->dev; 1288 1289 dprintk(DBGLVL_VBI, "%s()\n", __func__); 1290 1291 vfd = video_device_alloc(); 1292 if (NULL == vfd) 1293 return NULL; 1294 1295 *vfd = *template; 1296 snprintf(vfd->name, sizeof(vfd->name), "%s %s (%s)", dev->name, 1297 type, saa7164_boards[dev->board].name); 1298 1299 vfd->parent = &pci->dev; 1300 vfd->release = video_device_release; 1301 return vfd; 1302 } 1303 1304 int saa7164_vbi_register(struct saa7164_port *port) 1305 { 1306 struct saa7164_dev *dev = port->dev; 1307 int result = -ENODEV; 1308 1309 dprintk(DBGLVL_VBI, "%s()\n", __func__); 1310 1311 if (port->type != SAA7164_MPEG_VBI) 1312 BUG(); 1313 1314 /* Sanity check that the PCI configuration space is active */ 1315 if (port->hwcfg.BARLocation == 0) { 1316 printk(KERN_ERR "%s() failed " 1317 "(errno = %d), NO PCI configuration\n", 1318 __func__, result); 1319 result = -ENOMEM; 1320 goto failed; 1321 } 1322 1323 /* Establish VBI defaults here */ 1324 1325 /* Allocate and register the video device node */ 1326 port->v4l_device = saa7164_vbi_alloc(port, 1327 dev->pci, &saa7164_vbi_template, "vbi"); 1328 1329 if (!port->v4l_device) { 1330 printk(KERN_INFO "%s: can't allocate vbi device\n", 1331 dev->name); 1332 result = -ENOMEM; 1333 goto failed; 1334 } 1335 1336 video_set_drvdata(port->v4l_device, port); 1337 result = video_register_device(port->v4l_device, 1338 VFL_TYPE_VBI, -1); 1339 if (result < 0) { 1340 printk(KERN_INFO "%s: can't register vbi device\n", 1341 dev->name); 1342 /* TODO: We're going to leak here if we don't dealloc 1343 The buffers above. The unreg function can't deal wit it. 1344 */ 1345 goto failed; 1346 } 1347 1348 printk(KERN_INFO "%s: registered device vbi%d [vbi]\n", 1349 dev->name, port->v4l_device->num); 1350 1351 /* Configure the hardware defaults */ 1352 1353 result = 0; 1354 failed: 1355 return result; 1356 } 1357 1358 void saa7164_vbi_unregister(struct saa7164_port *port) 1359 { 1360 struct saa7164_dev *dev = port->dev; 1361 1362 dprintk(DBGLVL_VBI, "%s(port=%d)\n", __func__, port->nr); 1363 1364 if (port->type != SAA7164_MPEG_VBI) 1365 BUG(); 1366 1367 if (port->v4l_device) { 1368 if (port->v4l_device->minor != -1) 1369 video_unregister_device(port->v4l_device); 1370 else 1371 video_device_release(port->v4l_device); 1372 1373 port->v4l_device = NULL; 1374 } 1375 1376 } 1377