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 * 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 /* Take the encoder configuration from the port struct and 25 * flush it to the hardware. 26 */ 27 static void saa7164_vbi_configure(struct saa7164_port *port) 28 { 29 struct saa7164_dev *dev = port->dev; 30 dprintk(DBGLVL_VBI, "%s()\n", __func__); 31 32 port->vbi_params.width = port->enc_port->width; 33 port->vbi_params.height = port->enc_port->height; 34 port->vbi_params.is_50hz = 35 (port->enc_port->encodernorm.id & V4L2_STD_625_50) != 0; 36 37 /* Set up the DIF (enable it) for analog mode by default */ 38 saa7164_api_initialize_dif(port); 39 dprintk(DBGLVL_VBI, "%s() ends\n", __func__); 40 } 41 42 static int saa7164_vbi_buffers_dealloc(struct saa7164_port *port) 43 { 44 struct list_head *c, *n, *p, *q, *l, *v; 45 struct saa7164_dev *dev = port->dev; 46 struct saa7164_buffer *buf; 47 struct saa7164_user_buffer *ubuf; 48 49 /* Remove any allocated buffers */ 50 mutex_lock(&port->dmaqueue_lock); 51 52 dprintk(DBGLVL_VBI, "%s(port=%d) dmaqueue\n", __func__, port->nr); 53 list_for_each_safe(c, n, &port->dmaqueue.list) { 54 buf = list_entry(c, struct saa7164_buffer, list); 55 list_del(c); 56 saa7164_buffer_dealloc(buf); 57 } 58 59 dprintk(DBGLVL_VBI, "%s(port=%d) used\n", __func__, port->nr); 60 list_for_each_safe(p, q, &port->list_buf_used.list) { 61 ubuf = list_entry(p, struct saa7164_user_buffer, list); 62 list_del(p); 63 saa7164_buffer_dealloc_user(ubuf); 64 } 65 66 dprintk(DBGLVL_VBI, "%s(port=%d) free\n", __func__, port->nr); 67 list_for_each_safe(l, v, &port->list_buf_free.list) { 68 ubuf = list_entry(l, struct saa7164_user_buffer, list); 69 list_del(l); 70 saa7164_buffer_dealloc_user(ubuf); 71 } 72 73 mutex_unlock(&port->dmaqueue_lock); 74 dprintk(DBGLVL_VBI, "%s(port=%d) done\n", __func__, port->nr); 75 76 return 0; 77 } 78 79 /* Dynamic buffer switch at vbi start time */ 80 static int saa7164_vbi_buffers_alloc(struct saa7164_port *port) 81 { 82 struct saa7164_dev *dev = port->dev; 83 struct saa7164_buffer *buf; 84 struct saa7164_user_buffer *ubuf; 85 struct tmHWStreamParameters *params = &port->hw_streamingparams; 86 int result = -ENODEV, i; 87 int len = 0; 88 89 dprintk(DBGLVL_VBI, "%s()\n", __func__); 90 91 /* TODO: NTSC SPECIFIC */ 92 /* Init and establish defaults */ 93 params->samplesperline = 1440; 94 params->numberoflines = 12; 95 params->numberoflines = 18; 96 params->pitch = 1600; 97 params->pitch = 1440; 98 params->numpagetables = 2 + 99 ((params->numberoflines * params->pitch) / PAGE_SIZE); 100 params->bitspersample = 8; 101 params->linethreshold = 0; 102 params->pagetablelistvirt = NULL; 103 params->pagetablelistphys = NULL; 104 params->numpagetableentries = port->hwcfg.buffercount; 105 106 /* Allocate the PCI resources, buffers (hard) */ 107 for (i = 0; i < port->hwcfg.buffercount; i++) { 108 buf = saa7164_buffer_alloc(port, 109 params->numberoflines * 110 params->pitch); 111 112 if (!buf) { 113 printk(KERN_ERR "%s() failed " 114 "(errno = %d), unable to allocate buffer\n", 115 __func__, result); 116 result = -ENOMEM; 117 goto failed; 118 } else { 119 120 mutex_lock(&port->dmaqueue_lock); 121 list_add_tail(&buf->list, &port->dmaqueue.list); 122 mutex_unlock(&port->dmaqueue_lock); 123 124 } 125 } 126 127 /* Allocate some kernel buffers for copying 128 * to userpsace. 129 */ 130 len = params->numberoflines * params->pitch; 131 132 if (vbi_buffers < 16) 133 vbi_buffers = 16; 134 if (vbi_buffers > 512) 135 vbi_buffers = 512; 136 137 for (i = 0; i < vbi_buffers; i++) { 138 139 ubuf = saa7164_buffer_alloc_user(dev, len); 140 if (ubuf) { 141 mutex_lock(&port->dmaqueue_lock); 142 list_add_tail(&ubuf->list, &port->list_buf_free.list); 143 mutex_unlock(&port->dmaqueue_lock); 144 } 145 146 } 147 148 result = 0; 149 150 failed: 151 return result; 152 } 153 154 155 static int saa7164_vbi_initialize(struct saa7164_port *port) 156 { 157 saa7164_vbi_configure(port); 158 return 0; 159 } 160 161 /* -- V4L2 --------------------------------------------------------- */ 162 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id id) 163 { 164 struct saa7164_vbi_fh *fh = file->private_data; 165 166 return saa7164_s_std(fh->port->enc_port, id); 167 } 168 169 static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *id) 170 { 171 struct saa7164_encoder_fh *fh = file->private_data; 172 173 return saa7164_g_std(fh->port->enc_port, id); 174 } 175 176 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i) 177 { 178 struct saa7164_vbi_fh *fh = file->private_data; 179 180 return saa7164_g_input(fh->port->enc_port, i); 181 } 182 183 static int vidioc_s_input(struct file *file, void *priv, unsigned int i) 184 { 185 struct saa7164_vbi_fh *fh = file->private_data; 186 187 return saa7164_s_input(fh->port->enc_port, i); 188 } 189 190 static int vidioc_g_frequency(struct file *file, void *priv, 191 struct v4l2_frequency *f) 192 { 193 struct saa7164_vbi_fh *fh = file->private_data; 194 195 return saa7164_g_frequency(fh->port->enc_port, f); 196 } 197 198 static int vidioc_s_frequency(struct file *file, void *priv, 199 const struct v4l2_frequency *f) 200 { 201 struct saa7164_vbi_fh *fh = file->private_data; 202 int ret = saa7164_s_frequency(fh->port->enc_port, f); 203 204 if (ret == 0) 205 saa7164_vbi_initialize(fh->port); 206 return ret; 207 } 208 209 static int vidioc_querycap(struct file *file, void *priv, 210 struct v4l2_capability *cap) 211 { 212 struct saa7164_vbi_fh *fh = file->private_data; 213 struct saa7164_port *port = fh->port; 214 struct saa7164_dev *dev = port->dev; 215 216 strcpy(cap->driver, dev->name); 217 strlcpy(cap->card, saa7164_boards[dev->board].name, 218 sizeof(cap->card)); 219 sprintf(cap->bus_info, "PCI:%s", pci_name(dev->pci)); 220 221 cap->device_caps = 222 V4L2_CAP_VBI_CAPTURE | 223 V4L2_CAP_READWRITE | 224 V4L2_CAP_TUNER; 225 226 cap->capabilities = cap->device_caps | 227 V4L2_CAP_VIDEO_CAPTURE | 228 V4L2_CAP_DEVICE_CAPS; 229 230 return 0; 231 } 232 233 static int saa7164_vbi_stop_port(struct saa7164_port *port) 234 { 235 struct saa7164_dev *dev = port->dev; 236 int ret; 237 238 ret = saa7164_api_transition_port(port, SAA_DMASTATE_STOP); 239 if ((ret != SAA_OK) && (ret != SAA_ERR_ALREADY_STOPPED)) { 240 printk(KERN_ERR "%s() stop transition failed, ret = 0x%x\n", 241 __func__, ret); 242 ret = -EIO; 243 } else { 244 dprintk(DBGLVL_VBI, "%s() Stopped\n", __func__); 245 ret = 0; 246 } 247 248 return ret; 249 } 250 251 static int saa7164_vbi_acquire_port(struct saa7164_port *port) 252 { 253 struct saa7164_dev *dev = port->dev; 254 int ret; 255 256 ret = saa7164_api_transition_port(port, SAA_DMASTATE_ACQUIRE); 257 if ((ret != SAA_OK) && (ret != SAA_ERR_ALREADY_STOPPED)) { 258 printk(KERN_ERR "%s() acquire transition failed, ret = 0x%x\n", 259 __func__, ret); 260 ret = -EIO; 261 } else { 262 dprintk(DBGLVL_VBI, "%s() Acquired\n", __func__); 263 ret = 0; 264 } 265 266 return ret; 267 } 268 269 static int saa7164_vbi_pause_port(struct saa7164_port *port) 270 { 271 struct saa7164_dev *dev = port->dev; 272 int ret; 273 274 ret = saa7164_api_transition_port(port, SAA_DMASTATE_PAUSE); 275 if ((ret != SAA_OK) && (ret != SAA_ERR_ALREADY_STOPPED)) { 276 printk(KERN_ERR "%s() pause transition failed, ret = 0x%x\n", 277 __func__, ret); 278 ret = -EIO; 279 } else { 280 dprintk(DBGLVL_VBI, "%s() Paused\n", __func__); 281 ret = 0; 282 } 283 284 return ret; 285 } 286 287 /* Firmware is very windows centric, meaning you have to transition 288 * the part through AVStream / KS Windows stages, forwards or backwards. 289 * States are: stopped, acquired (h/w), paused, started. 290 * We have to leave here will all of the soft buffers on the free list, 291 * else the cfg_post() func won't have soft buffers to correctly configure. 292 */ 293 static int saa7164_vbi_stop_streaming(struct saa7164_port *port) 294 { 295 struct saa7164_dev *dev = port->dev; 296 struct saa7164_buffer *buf; 297 struct saa7164_user_buffer *ubuf; 298 struct list_head *c, *n; 299 int ret; 300 301 dprintk(DBGLVL_VBI, "%s(port=%d)\n", __func__, port->nr); 302 303 ret = saa7164_vbi_pause_port(port); 304 ret = saa7164_vbi_acquire_port(port); 305 ret = saa7164_vbi_stop_port(port); 306 307 dprintk(DBGLVL_VBI, "%s(port=%d) Hardware stopped\n", __func__, 308 port->nr); 309 310 /* Reset the state of any allocated buffer resources */ 311 mutex_lock(&port->dmaqueue_lock); 312 313 /* Reset the hard and soft buffer state */ 314 list_for_each_safe(c, n, &port->dmaqueue.list) { 315 buf = list_entry(c, struct saa7164_buffer, list); 316 buf->flags = SAA7164_BUFFER_FREE; 317 buf->pos = 0; 318 } 319 320 list_for_each_safe(c, n, &port->list_buf_used.list) { 321 ubuf = list_entry(c, struct saa7164_user_buffer, list); 322 ubuf->pos = 0; 323 list_move_tail(&ubuf->list, &port->list_buf_free.list); 324 } 325 326 mutex_unlock(&port->dmaqueue_lock); 327 328 /* Free any allocated resources */ 329 saa7164_vbi_buffers_dealloc(port); 330 331 dprintk(DBGLVL_VBI, "%s(port=%d) Released\n", __func__, port->nr); 332 333 return ret; 334 } 335 336 static int saa7164_vbi_start_streaming(struct saa7164_port *port) 337 { 338 struct saa7164_dev *dev = port->dev; 339 int result, ret = 0; 340 341 dprintk(DBGLVL_VBI, "%s(port=%d)\n", __func__, port->nr); 342 343 port->done_first_interrupt = 0; 344 345 /* allocate all of the PCIe DMA buffer resources on the fly, 346 * allowing switching between TS and PS payloads without 347 * requiring a complete driver reload. 348 */ 349 saa7164_vbi_buffers_alloc(port); 350 351 /* Configure the encoder with any cache values */ 352 #if 0 353 saa7164_api_set_encoder(port); 354 saa7164_api_get_encoder(port); 355 #endif 356 357 /* Place the empty buffers on the hardware */ 358 saa7164_buffer_cfg_port(port); 359 360 /* Negotiate format */ 361 if (saa7164_api_set_vbi_format(port) != SAA_OK) { 362 printk(KERN_ERR "%s() No supported VBI format\n", __func__); 363 ret = -EIO; 364 goto out; 365 } 366 367 /* Acquire the hardware */ 368 result = saa7164_api_transition_port(port, SAA_DMASTATE_ACQUIRE); 369 if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) { 370 printk(KERN_ERR "%s() acquire transition failed, res = 0x%x\n", 371 __func__, result); 372 373 ret = -EIO; 374 goto out; 375 } else 376 dprintk(DBGLVL_VBI, "%s() Acquired\n", __func__); 377 378 /* Pause the hardware */ 379 result = saa7164_api_transition_port(port, SAA_DMASTATE_PAUSE); 380 if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) { 381 printk(KERN_ERR "%s() pause transition failed, res = 0x%x\n", 382 __func__, result); 383 384 /* Stop the hardware, regardless */ 385 result = saa7164_vbi_stop_port(port); 386 if (result != SAA_OK) { 387 printk(KERN_ERR "%s() pause/forced stop transition " 388 "failed, res = 0x%x\n", __func__, result); 389 } 390 391 ret = -EIO; 392 goto out; 393 } else 394 dprintk(DBGLVL_VBI, "%s() Paused\n", __func__); 395 396 /* Start the hardware */ 397 result = saa7164_api_transition_port(port, SAA_DMASTATE_RUN); 398 if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) { 399 printk(KERN_ERR "%s() run transition failed, result = 0x%x\n", 400 __func__, result); 401 402 /* Stop the hardware, regardless */ 403 result = saa7164_vbi_acquire_port(port); 404 result = saa7164_vbi_stop_port(port); 405 if (result != SAA_OK) { 406 printk(KERN_ERR "%s() run/forced stop transition " 407 "failed, res = 0x%x\n", __func__, result); 408 } 409 410 ret = -EIO; 411 } else 412 dprintk(DBGLVL_VBI, "%s() Running\n", __func__); 413 414 out: 415 return ret; 416 } 417 418 static int saa7164_vbi_fmt(struct file *file, void *priv, 419 struct v4l2_format *f) 420 { 421 /* ntsc */ 422 f->fmt.vbi.samples_per_line = 1440; 423 f->fmt.vbi.sampling_rate = 27000000; 424 f->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY; 425 f->fmt.vbi.offset = 0; 426 f->fmt.vbi.flags = 0; 427 f->fmt.vbi.start[0] = 10; 428 f->fmt.vbi.count[0] = 18; 429 f->fmt.vbi.start[1] = 263 + 10 + 1; 430 f->fmt.vbi.count[1] = 18; 431 memset(f->fmt.vbi.reserved, 0, sizeof(f->fmt.vbi.reserved)); 432 return 0; 433 } 434 435 static int fops_open(struct file *file) 436 { 437 struct saa7164_dev *dev; 438 struct saa7164_port *port; 439 struct saa7164_vbi_fh *fh; 440 441 port = (struct saa7164_port *)video_get_drvdata(video_devdata(file)); 442 if (!port) 443 return -ENODEV; 444 445 dev = port->dev; 446 447 dprintk(DBGLVL_VBI, "%s()\n", __func__); 448 449 /* allocate + initialize per filehandle data */ 450 fh = kzalloc(sizeof(*fh), GFP_KERNEL); 451 if (NULL == fh) 452 return -ENOMEM; 453 454 fh->port = port; 455 v4l2_fh_init(&fh->fh, video_devdata(file)); 456 v4l2_fh_add(&fh->fh); 457 file->private_data = fh; 458 459 return 0; 460 } 461 462 static int fops_release(struct file *file) 463 { 464 struct saa7164_vbi_fh *fh = file->private_data; 465 struct saa7164_port *port = fh->port; 466 struct saa7164_dev *dev = port->dev; 467 468 dprintk(DBGLVL_VBI, "%s()\n", __func__); 469 470 /* Shut device down on last close */ 471 if (atomic_cmpxchg(&fh->v4l_reading, 1, 0) == 1) { 472 if (atomic_dec_return(&port->v4l_reader_count) == 0) { 473 /* stop vbi capture then cancel buffers */ 474 saa7164_vbi_stop_streaming(port); 475 } 476 } 477 478 v4l2_fh_del(&fh->fh); 479 v4l2_fh_exit(&fh->fh); 480 kfree(fh); 481 482 return 0; 483 } 484 485 static struct 486 saa7164_user_buffer *saa7164_vbi_next_buf(struct saa7164_port *port) 487 { 488 struct saa7164_user_buffer *ubuf = NULL; 489 struct saa7164_dev *dev = port->dev; 490 u32 crc; 491 492 mutex_lock(&port->dmaqueue_lock); 493 if (!list_empty(&port->list_buf_used.list)) { 494 ubuf = list_first_entry(&port->list_buf_used.list, 495 struct saa7164_user_buffer, list); 496 497 if (crc_checking) { 498 crc = crc32(0, ubuf->data, ubuf->actual_size); 499 if (crc != ubuf->crc) { 500 printk(KERN_ERR "%s() ubuf %p crc became invalid, was 0x%x became 0x%x\n", 501 __func__, 502 ubuf, ubuf->crc, crc); 503 } 504 } 505 506 } 507 mutex_unlock(&port->dmaqueue_lock); 508 509 dprintk(DBGLVL_VBI, "%s() returns %p\n", __func__, ubuf); 510 511 return ubuf; 512 } 513 514 static ssize_t fops_read(struct file *file, char __user *buffer, 515 size_t count, loff_t *pos) 516 { 517 struct saa7164_vbi_fh *fh = file->private_data; 518 struct saa7164_port *port = fh->port; 519 struct saa7164_user_buffer *ubuf = NULL; 520 struct saa7164_dev *dev = port->dev; 521 int ret = 0; 522 int rem, cnt; 523 u8 *p; 524 525 port->last_read_msecs_diff = port->last_read_msecs; 526 port->last_read_msecs = jiffies_to_msecs(jiffies); 527 port->last_read_msecs_diff = port->last_read_msecs - 528 port->last_read_msecs_diff; 529 530 saa7164_histogram_update(&port->read_interval, 531 port->last_read_msecs_diff); 532 533 if (*pos) { 534 printk(KERN_ERR "%s() ESPIPE\n", __func__); 535 return -ESPIPE; 536 } 537 538 if (atomic_cmpxchg(&fh->v4l_reading, 0, 1) == 0) { 539 if (atomic_inc_return(&port->v4l_reader_count) == 1) { 540 541 if (saa7164_vbi_initialize(port) < 0) { 542 printk(KERN_ERR "%s() EINVAL\n", __func__); 543 return -EINVAL; 544 } 545 546 saa7164_vbi_start_streaming(port); 547 msleep(200); 548 } 549 } 550 551 /* blocking wait for buffer */ 552 if ((file->f_flags & O_NONBLOCK) == 0) { 553 if (wait_event_interruptible(port->wait_read, 554 saa7164_vbi_next_buf(port))) { 555 printk(KERN_ERR "%s() ERESTARTSYS\n", __func__); 556 return -ERESTARTSYS; 557 } 558 } 559 560 /* Pull the first buffer from the used list */ 561 ubuf = saa7164_vbi_next_buf(port); 562 563 while ((count > 0) && ubuf) { 564 565 /* set remaining bytes to copy */ 566 rem = ubuf->actual_size - ubuf->pos; 567 cnt = rem > count ? count : rem; 568 569 p = ubuf->data + ubuf->pos; 570 571 dprintk(DBGLVL_VBI, 572 "%s() count=%d cnt=%d rem=%d buf=%p buf->pos=%d\n", 573 __func__, (int)count, cnt, rem, ubuf, ubuf->pos); 574 575 if (copy_to_user(buffer, p, cnt)) { 576 printk(KERN_ERR "%s() copy_to_user failed\n", __func__); 577 if (!ret) { 578 printk(KERN_ERR "%s() EFAULT\n", __func__); 579 ret = -EFAULT; 580 } 581 goto err; 582 } 583 584 ubuf->pos += cnt; 585 count -= cnt; 586 buffer += cnt; 587 ret += cnt; 588 589 if (ubuf->pos > ubuf->actual_size) 590 printk(KERN_ERR "read() pos > actual, huh?\n"); 591 592 if (ubuf->pos == ubuf->actual_size) { 593 594 /* finished with current buffer, take next buffer */ 595 596 /* Requeue the buffer on the free list */ 597 ubuf->pos = 0; 598 599 mutex_lock(&port->dmaqueue_lock); 600 list_move_tail(&ubuf->list, &port->list_buf_free.list); 601 mutex_unlock(&port->dmaqueue_lock); 602 603 /* Dequeue next */ 604 if ((file->f_flags & O_NONBLOCK) == 0) { 605 if (wait_event_interruptible(port->wait_read, 606 saa7164_vbi_next_buf(port))) { 607 break; 608 } 609 } 610 ubuf = saa7164_vbi_next_buf(port); 611 } 612 } 613 err: 614 if (!ret && !ubuf) { 615 printk(KERN_ERR "%s() EAGAIN\n", __func__); 616 ret = -EAGAIN; 617 } 618 619 return ret; 620 } 621 622 static unsigned int fops_poll(struct file *file, poll_table *wait) 623 { 624 struct saa7164_vbi_fh *fh = (struct saa7164_vbi_fh *)file->private_data; 625 struct saa7164_port *port = fh->port; 626 unsigned int mask = 0; 627 628 port->last_poll_msecs_diff = port->last_poll_msecs; 629 port->last_poll_msecs = jiffies_to_msecs(jiffies); 630 port->last_poll_msecs_diff = port->last_poll_msecs - 631 port->last_poll_msecs_diff; 632 633 saa7164_histogram_update(&port->poll_interval, 634 port->last_poll_msecs_diff); 635 636 if (!video_is_registered(port->v4l_device)) 637 return -EIO; 638 639 if (atomic_cmpxchg(&fh->v4l_reading, 0, 1) == 0) { 640 if (atomic_inc_return(&port->v4l_reader_count) == 1) { 641 if (saa7164_vbi_initialize(port) < 0) 642 return -EINVAL; 643 saa7164_vbi_start_streaming(port); 644 msleep(200); 645 } 646 } 647 648 /* blocking wait for buffer */ 649 if ((file->f_flags & O_NONBLOCK) == 0) { 650 if (wait_event_interruptible(port->wait_read, 651 saa7164_vbi_next_buf(port))) { 652 return -ERESTARTSYS; 653 } 654 } 655 656 /* Pull the first buffer from the used list */ 657 if (!list_empty(&port->list_buf_used.list)) 658 mask |= POLLIN | POLLRDNORM; 659 660 return mask; 661 } 662 static const struct v4l2_file_operations vbi_fops = { 663 .owner = THIS_MODULE, 664 .open = fops_open, 665 .release = fops_release, 666 .read = fops_read, 667 .poll = fops_poll, 668 .unlocked_ioctl = video_ioctl2, 669 }; 670 671 static const struct v4l2_ioctl_ops vbi_ioctl_ops = { 672 .vidioc_s_std = vidioc_s_std, 673 .vidioc_g_std = vidioc_g_std, 674 .vidioc_enum_input = saa7164_enum_input, 675 .vidioc_g_input = vidioc_g_input, 676 .vidioc_s_input = vidioc_s_input, 677 .vidioc_g_tuner = saa7164_g_tuner, 678 .vidioc_s_tuner = saa7164_s_tuner, 679 .vidioc_g_frequency = vidioc_g_frequency, 680 .vidioc_s_frequency = vidioc_s_frequency, 681 .vidioc_querycap = vidioc_querycap, 682 .vidioc_g_fmt_vbi_cap = saa7164_vbi_fmt, 683 .vidioc_try_fmt_vbi_cap = saa7164_vbi_fmt, 684 .vidioc_s_fmt_vbi_cap = saa7164_vbi_fmt, 685 }; 686 687 static struct video_device saa7164_vbi_template = { 688 .name = "saa7164", 689 .fops = &vbi_fops, 690 .ioctl_ops = &vbi_ioctl_ops, 691 .minor = -1, 692 .tvnorms = SAA7164_NORMS, 693 }; 694 695 static struct video_device *saa7164_vbi_alloc( 696 struct saa7164_port *port, 697 struct pci_dev *pci, 698 struct video_device *template, 699 char *type) 700 { 701 struct video_device *vfd; 702 struct saa7164_dev *dev = port->dev; 703 704 dprintk(DBGLVL_VBI, "%s()\n", __func__); 705 706 vfd = video_device_alloc(); 707 if (NULL == vfd) 708 return NULL; 709 710 *vfd = *template; 711 snprintf(vfd->name, sizeof(vfd->name), "%s %s (%s)", dev->name, 712 type, saa7164_boards[dev->board].name); 713 714 vfd->v4l2_dev = &dev->v4l2_dev; 715 vfd->release = video_device_release; 716 return vfd; 717 } 718 719 int saa7164_vbi_register(struct saa7164_port *port) 720 { 721 struct saa7164_dev *dev = port->dev; 722 int result = -ENODEV; 723 724 dprintk(DBGLVL_VBI, "%s()\n", __func__); 725 726 if (port->type != SAA7164_MPEG_VBI) 727 BUG(); 728 729 /* Sanity check that the PCI configuration space is active */ 730 if (port->hwcfg.BARLocation == 0) { 731 printk(KERN_ERR "%s() failed " 732 "(errno = %d), NO PCI configuration\n", 733 __func__, result); 734 result = -ENOMEM; 735 goto failed; 736 } 737 738 /* Establish VBI defaults here */ 739 740 /* Allocate and register the video device node */ 741 port->v4l_device = saa7164_vbi_alloc(port, 742 dev->pci, &saa7164_vbi_template, "vbi"); 743 744 if (!port->v4l_device) { 745 printk(KERN_INFO "%s: can't allocate vbi device\n", 746 dev->name); 747 result = -ENOMEM; 748 goto failed; 749 } 750 751 port->enc_port = &dev->ports[port->nr - 2]; 752 video_set_drvdata(port->v4l_device, port); 753 result = video_register_device(port->v4l_device, 754 VFL_TYPE_VBI, -1); 755 if (result < 0) { 756 printk(KERN_INFO "%s: can't register vbi device\n", 757 dev->name); 758 /* TODO: We're going to leak here if we don't dealloc 759 The buffers above. The unreg function can't deal wit it. 760 */ 761 goto failed; 762 } 763 764 printk(KERN_INFO "%s: registered device vbi%d [vbi]\n", 765 dev->name, port->v4l_device->num); 766 767 /* Configure the hardware defaults */ 768 769 result = 0; 770 failed: 771 return result; 772 } 773 774 void saa7164_vbi_unregister(struct saa7164_port *port) 775 { 776 struct saa7164_dev *dev = port->dev; 777 778 dprintk(DBGLVL_VBI, "%s(port=%d)\n", __func__, port->nr); 779 780 if (port->type != SAA7164_MPEG_VBI) 781 BUG(); 782 783 if (port->v4l_device) { 784 if (port->v4l_device->minor != -1) 785 video_unregister_device(port->v4l_device); 786 else 787 video_device_release(port->v4l_device); 788 789 port->v4l_device = NULL; 790 } 791 792 } 793