1/* 2 * dvbdev.c 3 * 4 * Copyright (C) 2000 Ralph Metzler <ralph@convergence.de> 5 * & Marcus Metzler <marcus@convergence.de> 6 * for convergence integrated media GmbH 7 * 8 * This program is free software; you can redistribute it and/or 9 * modify it under the terms of the GNU Lesser General Public License 10 * as published by the Free Software Foundation; either version 2.1 11 * of the License, or (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 */ 19 20#define pr_fmt(fmt) "dvbdev: " fmt 21 22#include <linux/types.h> 23#include <linux/errno.h> 24#include <linux/string.h> 25#include <linux/module.h> 26#include <linux/kernel.h> 27#include <linux/i2c.h> 28#include <linux/init.h> 29#include <linux/slab.h> 30#include <linux/device.h> 31#include <linux/fs.h> 32#include <linux/cdev.h> 33#include <linux/mutex.h> 34#include <media/dvbdev.h> 35 36/* Due to enum tuner_pad_index */ 37#include <media/tuner.h> 38 39static DEFINE_MUTEX(dvbdev_mutex); 40static LIST_HEAD(dvbdevfops_list); 41static int dvbdev_debug; 42 43module_param(dvbdev_debug, int, 0644); 44MODULE_PARM_DESC(dvbdev_debug, "Turn on/off device debugging (default:off)."); 45 46#define dprintk(fmt, arg...) do { \ 47 if (dvbdev_debug) \ 48 printk(KERN_DEBUG pr_fmt("%s: " fmt), \ 49 __func__, ##arg); \ 50} while (0) 51 52static LIST_HEAD(dvb_adapter_list); 53static DEFINE_MUTEX(dvbdev_register_lock); 54 55static const char * const dnames[] = { 56 [DVB_DEVICE_VIDEO] = "video", 57 [DVB_DEVICE_AUDIO] = "audio", 58 [DVB_DEVICE_SEC] = "sec", 59 [DVB_DEVICE_FRONTEND] = "frontend", 60 [DVB_DEVICE_DEMUX] = "demux", 61 [DVB_DEVICE_DVR] = "dvr", 62 [DVB_DEVICE_CA] = "ca", 63 [DVB_DEVICE_NET] = "net", 64 [DVB_DEVICE_OSD] = "osd" 65}; 66 67#ifdef CONFIG_DVB_DYNAMIC_MINORS 68#define MAX_DVB_MINORS 256 69#define DVB_MAX_IDS MAX_DVB_MINORS 70#else 71#define DVB_MAX_IDS 4 72 73static const u8 minor_type[] = { 74 [DVB_DEVICE_VIDEO] = 0, 75 [DVB_DEVICE_AUDIO] = 1, 76 [DVB_DEVICE_SEC] = 2, 77 [DVB_DEVICE_FRONTEND] = 3, 78 [DVB_DEVICE_DEMUX] = 4, 79 [DVB_DEVICE_DVR] = 5, 80 [DVB_DEVICE_CA] = 6, 81 [DVB_DEVICE_NET] = 7, 82 [DVB_DEVICE_OSD] = 8, 83}; 84 85#define nums2minor(num, type, id) \ 86 (((num) << 6) | ((id) << 4) | minor_type[type]) 87 88#define MAX_DVB_MINORS (DVB_MAX_ADAPTERS*64) 89#endif 90 91static struct class *dvb_class; 92 93static struct dvb_device *dvb_minors[MAX_DVB_MINORS]; 94static DECLARE_RWSEM(minor_rwsem); 95 96static int dvb_device_open(struct inode *inode, struct file *file) 97{ 98 struct dvb_device *dvbdev; 99 100 mutex_lock(&dvbdev_mutex); 101 down_read(&minor_rwsem); 102 dvbdev = dvb_minors[iminor(inode)]; 103 104 if (dvbdev && dvbdev->fops) { 105 int err = 0; 106 const struct file_operations *new_fops; 107 108 new_fops = fops_get(dvbdev->fops); 109 if (!new_fops) 110 goto fail; 111 file->private_data = dvb_device_get(dvbdev); 112 replace_fops(file, new_fops); 113 if (file->f_op->open) 114 err = file->f_op->open(inode, file); 115 up_read(&minor_rwsem); 116 mutex_unlock(&dvbdev_mutex); 117 if (err) 118 dvb_device_put(dvbdev); 119 return err; 120 } 121fail: 122 up_read(&minor_rwsem); 123 mutex_unlock(&dvbdev_mutex); 124 return -ENODEV; 125} 126 127 128static const struct file_operations dvb_device_fops = 129{ 130 .owner = THIS_MODULE, 131 .open = dvb_device_open, 132 .llseek = noop_llseek, 133}; 134 135static struct cdev dvb_device_cdev; 136 137int dvb_generic_open(struct inode *inode, struct file *file) 138{ 139 struct dvb_device *dvbdev = file->private_data; 140 141 if (!dvbdev) 142 return -ENODEV; 143 144 if (!dvbdev->users) 145 return -EBUSY; 146 147 if ((file->f_flags & O_ACCMODE) == O_RDONLY) { 148 if (!dvbdev->readers) 149 return -EBUSY; 150 dvbdev->readers--; 151 } else { 152 if (!dvbdev->writers) 153 return -EBUSY; 154 dvbdev->writers--; 155 } 156 157 dvbdev->users--; 158 return 0; 159} 160EXPORT_SYMBOL(dvb_generic_open); 161 162 163int dvb_generic_release(struct inode *inode, struct file *file) 164{ 165 struct dvb_device *dvbdev = file->private_data; 166 167 if (!dvbdev) 168 return -ENODEV; 169 170 if ((file->f_flags & O_ACCMODE) == O_RDONLY) { 171 dvbdev->readers++; 172 } else { 173 dvbdev->writers++; 174 } 175 176 dvbdev->users++; 177 178 dvb_device_put(dvbdev); 179 180 return 0; 181} 182EXPORT_SYMBOL(dvb_generic_release); 183 184 185long dvb_generic_ioctl(struct file *file, 186 unsigned int cmd, unsigned long arg) 187{ 188 struct dvb_device *dvbdev = file->private_data; 189 190 if (!dvbdev) 191 return -ENODEV; 192 193 if (!dvbdev->kernel_ioctl) 194 return -EINVAL; 195 196 return dvb_usercopy(file, cmd, arg, dvbdev->kernel_ioctl); 197} 198EXPORT_SYMBOL(dvb_generic_ioctl); 199 200 201static int dvbdev_get_free_id (struct dvb_adapter *adap, int type) 202{ 203 u32 id = 0; 204 205 while (id < DVB_MAX_IDS) { 206 struct dvb_device *dev; 207 list_for_each_entry(dev, &adap->device_list, list_head) 208 if (dev->type == type && dev->id == id) 209 goto skip; 210 return id; 211skip: 212 id++; 213 } 214 return -ENFILE; 215} 216 217static void dvb_media_device_free(struct dvb_device *dvbdev) 218{ 219#if defined(CONFIG_MEDIA_CONTROLLER_DVB) 220 if (dvbdev->entity) { 221 media_device_unregister_entity(dvbdev->entity); 222 kfree(dvbdev->entity); 223 kfree(dvbdev->pads); 224 dvbdev->entity = NULL; 225 dvbdev->pads = NULL; 226 } 227 228 if (dvbdev->tsout_entity) { 229 int i; 230 231 for (i = 0; i < dvbdev->tsout_num_entities; i++) { 232 media_device_unregister_entity(&dvbdev->tsout_entity[i]); 233 kfree(dvbdev->tsout_entity[i].name); 234 } 235 kfree(dvbdev->tsout_entity); 236 kfree(dvbdev->tsout_pads); 237 dvbdev->tsout_entity = NULL; 238 dvbdev->tsout_pads = NULL; 239 240 dvbdev->tsout_num_entities = 0; 241 } 242 243 if (dvbdev->intf_devnode) { 244 media_devnode_remove(dvbdev->intf_devnode); 245 dvbdev->intf_devnode = NULL; 246 } 247 248 if (dvbdev->adapter->conn) { 249 media_device_unregister_entity(dvbdev->adapter->conn); 250 kfree(dvbdev->adapter->conn); 251 dvbdev->adapter->conn = NULL; 252 kfree(dvbdev->adapter->conn_pads); 253 dvbdev->adapter->conn_pads = NULL; 254 } 255#endif 256} 257 258#if defined(CONFIG_MEDIA_CONTROLLER_DVB) 259static int dvb_create_tsout_entity(struct dvb_device *dvbdev, 260 const char *name, int npads) 261{ 262 int i, ret = 0; 263 264 dvbdev->tsout_pads = kcalloc(npads, sizeof(*dvbdev->tsout_pads), 265 GFP_KERNEL); 266 if (!dvbdev->tsout_pads) 267 return -ENOMEM; 268 269 dvbdev->tsout_entity = kcalloc(npads, sizeof(*dvbdev->tsout_entity), 270 GFP_KERNEL); 271 if (!dvbdev->tsout_entity) 272 return -ENOMEM; 273 274 dvbdev->tsout_num_entities = npads; 275 276 for (i = 0; i < npads; i++) { 277 struct media_pad *pads = &dvbdev->tsout_pads[i]; 278 struct media_entity *entity = &dvbdev->tsout_entity[i]; 279 280 entity->name = kasprintf(GFP_KERNEL, "%s #%d", name, i); 281 if (!entity->name) 282 return -ENOMEM; 283 284 entity->function = MEDIA_ENT_F_IO_DTV; 285 pads->flags = MEDIA_PAD_FL_SINK; 286 287 ret = media_entity_pads_init(entity, 1, pads); 288 if (ret < 0) 289 return ret; 290 291 ret = media_device_register_entity(dvbdev->adapter->mdev, 292 entity); 293 if (ret < 0) 294 return ret; 295 } 296 return 0; 297} 298 299#define DEMUX_TSOUT "demux-tsout" 300#define DVR_TSOUT "dvr-tsout" 301 302static int dvb_create_media_entity(struct dvb_device *dvbdev, 303 int type, int demux_sink_pads) 304{ 305 int i, ret, npads; 306 307 switch (type) { 308 case DVB_DEVICE_FRONTEND: 309 npads = 2; 310 break; 311 case DVB_DEVICE_DVR: 312 ret = dvb_create_tsout_entity(dvbdev, DVR_TSOUT, 313 demux_sink_pads); 314 return ret; 315 case DVB_DEVICE_DEMUX: 316 npads = 1 + demux_sink_pads; 317 ret = dvb_create_tsout_entity(dvbdev, DEMUX_TSOUT, 318 demux_sink_pads); 319 if (ret < 0) 320 return ret; 321 break; 322 case DVB_DEVICE_CA: 323 npads = 2; 324 break; 325 case DVB_DEVICE_NET: 326 /* 327 * We should be creating entities for the MPE/ULE 328 * decapsulation hardware (or software implementation). 329 * 330 * However, the number of for the MPE/ULE decaps may not be 331 * fixed. As we don't have yet dynamic support for PADs at 332 * the Media Controller, let's not create the decap 333 * entities yet. 334 */ 335 return 0; 336 default: 337 return 0; 338 } 339 340 dvbdev->entity = kzalloc(sizeof(*dvbdev->entity), GFP_KERNEL); 341 if (!dvbdev->entity) 342 return -ENOMEM; 343 344 dvbdev->entity->name = dvbdev->name; 345 346 if (npads) { 347 dvbdev->pads = kcalloc(npads, sizeof(*dvbdev->pads), 348 GFP_KERNEL); 349 if (!dvbdev->pads) { 350 kfree(dvbdev->entity); 351 dvbdev->entity = NULL; 352 return -ENOMEM; 353 } 354 } 355 356 switch (type) { 357 case DVB_DEVICE_FRONTEND: 358 dvbdev->entity->function = MEDIA_ENT_F_DTV_DEMOD; 359 dvbdev->pads[0].flags = MEDIA_PAD_FL_SINK; 360 dvbdev->pads[1].flags = MEDIA_PAD_FL_SOURCE; 361 break; 362 case DVB_DEVICE_DEMUX: 363 dvbdev->entity->function = MEDIA_ENT_F_TS_DEMUX; 364 dvbdev->pads[0].flags = MEDIA_PAD_FL_SINK; 365 for (i = 1; i < npads; i++) 366 dvbdev->pads[i].flags = MEDIA_PAD_FL_SOURCE; 367 break; 368 case DVB_DEVICE_CA: 369 dvbdev->entity->function = MEDIA_ENT_F_DTV_CA; 370 dvbdev->pads[0].flags = MEDIA_PAD_FL_SINK; 371 dvbdev->pads[1].flags = MEDIA_PAD_FL_SOURCE; 372 break; 373 default: 374 /* Should never happen, as the first switch prevents it */ 375 kfree(dvbdev->entity); 376 kfree(dvbdev->pads); 377 dvbdev->entity = NULL; 378 dvbdev->pads = NULL; 379 return 0; 380 } 381 382 if (npads) { 383 ret = media_entity_pads_init(dvbdev->entity, npads, dvbdev->pads); 384 if (ret) 385 return ret; 386 } 387 ret = media_device_register_entity(dvbdev->adapter->mdev, 388 dvbdev->entity); 389 if (ret) 390 return ret; 391 392 pr_info("%s: media entity '%s' registered.\n", 393 __func__, dvbdev->entity->name); 394 395 return 0; 396} 397#endif 398 399static int dvb_register_media_device(struct dvb_device *dvbdev, 400 int type, int minor, 401 unsigned demux_sink_pads) 402{ 403#if defined(CONFIG_MEDIA_CONTROLLER_DVB) 404 struct media_link *link; 405 u32 intf_type; 406 int ret; 407 408 if (!dvbdev->adapter->mdev) 409 return 0; 410 411 ret = dvb_create_media_entity(dvbdev, type, demux_sink_pads); 412 if (ret) 413 return ret; 414 415 switch (type) { 416 case DVB_DEVICE_FRONTEND: 417 intf_type = MEDIA_INTF_T_DVB_FE; 418 break; 419 case DVB_DEVICE_DEMUX: 420 intf_type = MEDIA_INTF_T_DVB_DEMUX; 421 break; 422 case DVB_DEVICE_DVR: 423 intf_type = MEDIA_INTF_T_DVB_DVR; 424 break; 425 case DVB_DEVICE_CA: 426 intf_type = MEDIA_INTF_T_DVB_CA; 427 break; 428 case DVB_DEVICE_NET: 429 intf_type = MEDIA_INTF_T_DVB_NET; 430 break; 431 default: 432 return 0; 433 } 434 435 dvbdev->intf_devnode = media_devnode_create(dvbdev->adapter->mdev, 436 intf_type, 0, 437 DVB_MAJOR, minor); 438 439 if (!dvbdev->intf_devnode) 440 return -ENOMEM; 441 442 /* 443 * Create the "obvious" link, e. g. the ones that represent 444 * a direct association between an interface and an entity. 445 * Other links should be created elsewhere, like: 446 * DVB FE intf -> tuner 447 * DVB demux intf -> dvr 448 */ 449 450 if (!dvbdev->entity) 451 return 0; 452 453 link = media_create_intf_link(dvbdev->entity, 454 &dvbdev->intf_devnode->intf, 455 MEDIA_LNK_FL_ENABLED | 456 MEDIA_LNK_FL_IMMUTABLE); 457 if (!link) 458 return -ENOMEM; 459#endif 460 return 0; 461} 462 463int dvb_register_device(struct dvb_adapter *adap, struct dvb_device **pdvbdev, 464 const struct dvb_device *template, void *priv, 465 enum dvb_device_type type, int demux_sink_pads) 466{ 467 struct dvb_device *dvbdev; 468 struct file_operations *dvbdevfops = NULL; 469 struct dvbdevfops_node *node = NULL, *new_node = NULL; 470 struct device *clsdev; 471 int minor; 472 int id, ret; 473 474 mutex_lock(&dvbdev_register_lock); 475 476 if ((id = dvbdev_get_free_id (adap, type)) < 0) { 477 mutex_unlock(&dvbdev_register_lock); 478 *pdvbdev = NULL; 479 pr_err("%s: couldn't find free device id\n", __func__); 480 return -ENFILE; 481 } 482 483 *pdvbdev = dvbdev = kzalloc(sizeof(*dvbdev), GFP_KERNEL); 484 if (!dvbdev){ 485 mutex_unlock(&dvbdev_register_lock); 486 return -ENOMEM; 487 } 488 489 /* 490 * When a device of the same type is probe()d more than once, 491 * the first allocated fops are used. This prevents memory leaks 492 * that can occur when the same device is probe()d repeatedly. 493 */ 494 list_for_each_entry(node, &dvbdevfops_list, list_head) { 495 if (node->fops->owner == adap->module && 496 node->type == type && 497 node->template == template) { 498 dvbdevfops = node->fops; 499 break; 500 } 501 } 502 503 if (dvbdevfops == NULL) { 504 dvbdevfops = kmemdup(template->fops, sizeof(*dvbdevfops), GFP_KERNEL); 505 if (!dvbdevfops) { 506 kfree(dvbdev); 507 *pdvbdev = NULL; 508 mutex_unlock(&dvbdev_register_lock); 509 return -ENOMEM; 510 } 511 512 new_node = kzalloc(sizeof(struct dvbdevfops_node), GFP_KERNEL); 513 if (!new_node) { 514 kfree(dvbdevfops); 515 kfree(dvbdev); 516 *pdvbdev = NULL; 517 mutex_unlock(&dvbdev_register_lock); 518 return -ENOMEM; 519 } 520 521 new_node->fops = dvbdevfops; 522 new_node->type = type; 523 new_node->template = template; 524 list_add_tail (&new_node->list_head, &dvbdevfops_list); 525 } 526 527 memcpy(dvbdev, template, sizeof(struct dvb_device)); 528 kref_init(&dvbdev->ref); 529 dvbdev->type = type; 530 dvbdev->id = id; 531 dvbdev->adapter = adap; 532 dvbdev->priv = priv; 533 dvbdev->fops = dvbdevfops; 534 init_waitqueue_head (&dvbdev->wait_queue); 535 dvbdevfops->owner = adap->module; 536 list_add_tail (&dvbdev->list_head, &adap->device_list); 537 down_write(&minor_rwsem); 538#ifdef CONFIG_DVB_DYNAMIC_MINORS 539 for (minor = 0; minor < MAX_DVB_MINORS; minor++) 540 if (dvb_minors[minor] == NULL) 541 break; 542 if (minor == MAX_DVB_MINORS) { 543 if (new_node) { 544 list_del (&new_node->list_head); 545 kfree(dvbdevfops); 546 kfree(new_node); 547 } 548 list_del (&dvbdev->list_head); 549 kfree(dvbdev); 550 *pdvbdev = NULL; 551 up_write(&minor_rwsem); 552 mutex_unlock(&dvbdev_register_lock); 553 return -EINVAL; 554 } 555#else 556 minor = nums2minor(adap->num, type, id); 557#endif 558 dvbdev->minor = minor; 559 dvb_minors[minor] = dvb_device_get(dvbdev); 560 up_write(&minor_rwsem); 561 ret = dvb_register_media_device(dvbdev, type, minor, demux_sink_pads); 562 if (ret) { 563 pr_err("%s: dvb_register_media_device failed to create the mediagraph\n", 564 __func__); 565 if (new_node) { 566 list_del (&new_node->list_head); 567 kfree(dvbdevfops); 568 kfree(new_node); 569 } 570 dvb_media_device_free(dvbdev); 571 list_del (&dvbdev->list_head); 572 kfree(dvbdev); 573 *pdvbdev = NULL; 574 mutex_unlock(&dvbdev_register_lock); 575 return ret; 576 } 577 578 clsdev = device_create(dvb_class, adap->device, 579 MKDEV(DVB_MAJOR, minor), 580 dvbdev, "dvb%d.%s%d", adap->num, dnames[type], id); 581 if (IS_ERR(clsdev)) { 582 pr_err("%s: failed to create device dvb%d.%s%d (%ld)\n", 583 __func__, adap->num, dnames[type], id, PTR_ERR(clsdev)); 584 if (new_node) { 585 list_del (&new_node->list_head); 586 kfree(dvbdevfops); 587 kfree(new_node); 588 } 589 dvb_media_device_free(dvbdev); 590 list_del (&dvbdev->list_head); 591 kfree(dvbdev); 592 *pdvbdev = NULL; 593 mutex_unlock(&dvbdev_register_lock); 594 return PTR_ERR(clsdev); 595 } 596 597 dprintk("DVB: register adapter%d/%s%d @ minor: %i (0x%02x)\n", 598 adap->num, dnames[type], id, minor, minor); 599 600 mutex_unlock(&dvbdev_register_lock); 601 return 0; 602} 603EXPORT_SYMBOL(dvb_register_device); 604 605 606void dvb_remove_device(struct dvb_device *dvbdev) 607{ 608 if (!dvbdev) 609 return; 610 611 down_write(&minor_rwsem); 612 dvb_minors[dvbdev->minor] = NULL; 613 dvb_device_put(dvbdev); 614 up_write(&minor_rwsem); 615 616 dvb_media_device_free(dvbdev); 617 618 device_destroy(dvb_class, MKDEV(DVB_MAJOR, dvbdev->minor)); 619 620 list_del (&dvbdev->list_head); 621} 622EXPORT_SYMBOL(dvb_remove_device); 623 624 625static void dvb_free_device(struct kref *ref) 626{ 627 struct dvb_device *dvbdev = container_of(ref, struct dvb_device, ref); 628 629 kfree (dvbdev); 630} 631 632 633struct dvb_device *dvb_device_get(struct dvb_device *dvbdev) 634{ 635 kref_get(&dvbdev->ref); 636 return dvbdev; 637} 638EXPORT_SYMBOL(dvb_device_get); 639 640 641void dvb_device_put(struct dvb_device *dvbdev) 642{ 643 if (dvbdev) 644 kref_put(&dvbdev->ref, dvb_free_device); 645} 646 647 648void dvb_unregister_device(struct dvb_device *dvbdev) 649{ 650 dvb_remove_device(dvbdev); 651 dvb_device_put(dvbdev); 652} 653EXPORT_SYMBOL(dvb_unregister_device); 654 655 656#ifdef CONFIG_MEDIA_CONTROLLER_DVB 657 658static int dvb_create_io_intf_links(struct dvb_adapter *adap, 659 struct media_interface *intf, 660 char *name) 661{ 662 struct media_device *mdev = adap->mdev; 663 struct media_entity *entity; 664 struct media_link *link; 665 666 media_device_for_each_entity(entity, mdev) { 667 if (entity->function == MEDIA_ENT_F_IO_DTV) { 668 if (strncmp(entity->name, name, strlen(name))) 669 continue; 670 link = media_create_intf_link(entity, intf, 671 MEDIA_LNK_FL_ENABLED | 672 MEDIA_LNK_FL_IMMUTABLE); 673 if (!link) 674 return -ENOMEM; 675 } 676 } 677 return 0; 678} 679 680int dvb_create_media_graph(struct dvb_adapter *adap, 681 bool create_rf_connector) 682{ 683 struct media_device *mdev = adap->mdev; 684 struct media_entity *entity, *tuner = NULL, *demod = NULL, *conn; 685 struct media_entity *demux = NULL, *ca = NULL; 686 struct media_link *link; 687 struct media_interface *intf; 688 unsigned demux_pad = 0; 689 unsigned dvr_pad = 0; 690 unsigned ntuner = 0, ndemod = 0; 691 int ret, pad_source, pad_sink; 692 static const char *connector_name = "Television"; 693 694 if (!mdev) 695 return 0; 696 697 media_device_for_each_entity(entity, mdev) { 698 switch (entity->function) { 699 case MEDIA_ENT_F_TUNER: 700 tuner = entity; 701 ntuner++; 702 break; 703 case MEDIA_ENT_F_DTV_DEMOD: 704 demod = entity; 705 ndemod++; 706 break; 707 case MEDIA_ENT_F_TS_DEMUX: 708 demux = entity; 709 break; 710 case MEDIA_ENT_F_DTV_CA: 711 ca = entity; 712 break; 713 } 714 } 715 716 /* 717 * Prepare to signalize to media_create_pad_links() that multiple 718 * entities of the same type exists and a 1:n or n:1 links need to be 719 * created. 720 * NOTE: if both tuner and demod have multiple instances, it is up 721 * to the caller driver to create such links. 722 */ 723 if (ntuner > 1) 724 tuner = NULL; 725 if (ndemod > 1) 726 demod = NULL; 727 728 if (create_rf_connector) { 729 conn = kzalloc(sizeof(*conn), GFP_KERNEL); 730 if (!conn) 731 return -ENOMEM; 732 adap->conn = conn; 733 734 adap->conn_pads = kzalloc(sizeof(*adap->conn_pads), GFP_KERNEL); 735 if (!adap->conn_pads) 736 return -ENOMEM; 737 738 conn->flags = MEDIA_ENT_FL_CONNECTOR; 739 conn->function = MEDIA_ENT_F_CONN_RF; 740 conn->name = connector_name; 741 adap->conn_pads->flags = MEDIA_PAD_FL_SOURCE; 742 743 ret = media_entity_pads_init(conn, 1, adap->conn_pads); 744 if (ret) 745 return ret; 746 747 ret = media_device_register_entity(mdev, conn); 748 if (ret) 749 return ret; 750 751 if (!ntuner) { 752 ret = media_create_pad_links(mdev, 753 MEDIA_ENT_F_CONN_RF, 754 conn, 0, 755 MEDIA_ENT_F_DTV_DEMOD, 756 demod, 0, 757 MEDIA_LNK_FL_ENABLED, 758 false); 759 } else { 760 pad_sink = media_get_pad_index(tuner, true, 761 PAD_SIGNAL_ANALOG); 762 if (pad_sink < 0) 763 return -EINVAL; 764 ret = media_create_pad_links(mdev, 765 MEDIA_ENT_F_CONN_RF, 766 conn, 0, 767 MEDIA_ENT_F_TUNER, 768 tuner, pad_sink, 769 MEDIA_LNK_FL_ENABLED, 770 false); 771 } 772 if (ret) 773 return ret; 774 } 775 776 if (ntuner && ndemod) { 777 /* NOTE: first found tuner source pad presumed correct */ 778 pad_source = media_get_pad_index(tuner, false, 779 PAD_SIGNAL_ANALOG); 780 if (pad_source < 0) 781 return -EINVAL; 782 ret = media_create_pad_links(mdev, 783 MEDIA_ENT_F_TUNER, 784 tuner, pad_source, 785 MEDIA_ENT_F_DTV_DEMOD, 786 demod, 0, MEDIA_LNK_FL_ENABLED, 787 false); 788 if (ret) 789 return ret; 790 } 791 792 if (ndemod && demux) { 793 ret = media_create_pad_links(mdev, 794 MEDIA_ENT_F_DTV_DEMOD, 795 demod, 1, 796 MEDIA_ENT_F_TS_DEMUX, 797 demux, 0, MEDIA_LNK_FL_ENABLED, 798 false); 799 if (ret) 800 return ret; 801 } 802 if (demux && ca) { 803 ret = media_create_pad_link(demux, 1, ca, 804 0, MEDIA_LNK_FL_ENABLED); 805 if (ret) 806 return ret; 807 } 808 809 /* Create demux links for each ringbuffer/pad */ 810 if (demux) { 811 media_device_for_each_entity(entity, mdev) { 812 if (entity->function == MEDIA_ENT_F_IO_DTV) { 813 if (!strncmp(entity->name, DVR_TSOUT, 814 strlen(DVR_TSOUT))) { 815 ret = media_create_pad_link(demux, 816 ++dvr_pad, 817 entity, 0, 0); 818 if (ret) 819 return ret; 820 } 821 if (!strncmp(entity->name, DEMUX_TSOUT, 822 strlen(DEMUX_TSOUT))) { 823 ret = media_create_pad_link(demux, 824 ++demux_pad, 825 entity, 0, 0); 826 if (ret) 827 return ret; 828 } 829 } 830 } 831 } 832 833 /* Create interface links for FE->tuner, DVR->demux and CA->ca */ 834 media_device_for_each_intf(intf, mdev) { 835 if (intf->type == MEDIA_INTF_T_DVB_CA && ca) { 836 link = media_create_intf_link(ca, intf, 837 MEDIA_LNK_FL_ENABLED | 838 MEDIA_LNK_FL_IMMUTABLE); 839 if (!link) 840 return -ENOMEM; 841 } 842 843 if (intf->type == MEDIA_INTF_T_DVB_FE && tuner) { 844 link = media_create_intf_link(tuner, intf, 845 MEDIA_LNK_FL_ENABLED | 846 MEDIA_LNK_FL_IMMUTABLE); 847 if (!link) 848 return -ENOMEM; 849 } 850#if 0 851 /* 852 * Indirect link - let's not create yet, as we don't know how 853 * to handle indirect links, nor if this will 854 * actually be needed. 855 */ 856 if (intf->type == MEDIA_INTF_T_DVB_DVR && demux) { 857 link = media_create_intf_link(demux, intf, 858 MEDIA_LNK_FL_ENABLED | 859 MEDIA_LNK_FL_IMMUTABLE); 860 if (!link) 861 return -ENOMEM; 862 } 863#endif 864 if (intf->type == MEDIA_INTF_T_DVB_DVR) { 865 ret = dvb_create_io_intf_links(adap, intf, DVR_TSOUT); 866 if (ret) 867 return ret; 868 } 869 if (intf->type == MEDIA_INTF_T_DVB_DEMUX) { 870 ret = dvb_create_io_intf_links(adap, intf, DEMUX_TSOUT); 871 if (ret) 872 return ret; 873 } 874 } 875 return 0; 876} 877EXPORT_SYMBOL_GPL(dvb_create_media_graph); 878#endif 879 880static int dvbdev_check_free_adapter_num(int num) 881{ 882 struct list_head *entry; 883 list_for_each(entry, &dvb_adapter_list) { 884 struct dvb_adapter *adap; 885 adap = list_entry(entry, struct dvb_adapter, list_head); 886 if (adap->num == num) 887 return 0; 888 } 889 return 1; 890} 891 892static int dvbdev_get_free_adapter_num (void) 893{ 894 int num = 0; 895 896 while (num < DVB_MAX_ADAPTERS) { 897 if (dvbdev_check_free_adapter_num(num)) 898 return num; 899 num++; 900 } 901 902 return -ENFILE; 903} 904 905 906int dvb_register_adapter(struct dvb_adapter *adap, const char *name, 907 struct module *module, struct device *device, 908 short *adapter_nums) 909{ 910 int i, num; 911 912 mutex_lock(&dvbdev_register_lock); 913 914 for (i = 0; i < DVB_MAX_ADAPTERS; ++i) { 915 num = adapter_nums[i]; 916 if (num >= 0 && num < DVB_MAX_ADAPTERS) { 917 /* use the one the driver asked for */ 918 if (dvbdev_check_free_adapter_num(num)) 919 break; 920 } else { 921 num = dvbdev_get_free_adapter_num(); 922 break; 923 } 924 num = -1; 925 } 926 927 if (num < 0) { 928 mutex_unlock(&dvbdev_register_lock); 929 return -ENFILE; 930 } 931 932 memset (adap, 0, sizeof(struct dvb_adapter)); 933 INIT_LIST_HEAD (&adap->device_list); 934 935 pr_info("DVB: registering new adapter (%s)\n", name); 936 937 adap->num = num; 938 adap->name = name; 939 adap->module = module; 940 adap->device = device; 941 adap->mfe_shared = 0; 942 adap->mfe_dvbdev = NULL; 943 mutex_init (&adap->mfe_lock); 944 945#ifdef CONFIG_MEDIA_CONTROLLER_DVB 946 mutex_init(&adap->mdev_lock); 947#endif 948 949 list_add_tail (&adap->list_head, &dvb_adapter_list); 950 951 mutex_unlock(&dvbdev_register_lock); 952 953 return num; 954} 955EXPORT_SYMBOL(dvb_register_adapter); 956 957 958int dvb_unregister_adapter(struct dvb_adapter *adap) 959{ 960 mutex_lock(&dvbdev_register_lock); 961 list_del (&adap->list_head); 962 mutex_unlock(&dvbdev_register_lock); 963 return 0; 964} 965EXPORT_SYMBOL(dvb_unregister_adapter); 966 967/* if the miracle happens and "generic_usercopy()" is included into 968 the kernel, then this can vanish. please don't make the mistake and 969 define this as video_usercopy(). this will introduce a dependency 970 to the v4l "videodev.o" module, which is unnecessary for some 971 cards (ie. the budget dvb-cards don't need the v4l module...) */ 972int dvb_usercopy(struct file *file, 973 unsigned int cmd, unsigned long arg, 974 int (*func)(struct file *file, 975 unsigned int cmd, void *arg)) 976{ 977 char sbuf[128]; 978 void *mbuf = NULL; 979 void *parg = NULL; 980 int err = -EINVAL; 981 982 /* Copy arguments into temp kernel buffer */ 983 switch (_IOC_DIR(cmd)) { 984 case _IOC_NONE: 985 /* 986 * For this command, the pointer is actually an integer 987 * argument. 988 */ 989 parg = (void *) arg; 990 break; 991 case _IOC_READ: /* some v4l ioctls are marked wrong ... */ 992 case _IOC_WRITE: 993 case (_IOC_WRITE | _IOC_READ): 994 if (_IOC_SIZE(cmd) <= sizeof(sbuf)) { 995 parg = sbuf; 996 } else { 997 /* too big to allocate from stack */ 998 mbuf = kmalloc(_IOC_SIZE(cmd), GFP_KERNEL); 999 if (NULL == mbuf) 1000 return -ENOMEM; 1001 parg = mbuf; 1002 } 1003 1004 err = -EFAULT; 1005 if (copy_from_user(parg, (void __user *)arg, _IOC_SIZE(cmd))) 1006 goto out; 1007 break; 1008 } 1009 1010 /* call driver */ 1011 if ((err = func(file, cmd, parg)) == -ENOIOCTLCMD) 1012 err = -ENOTTY; 1013 1014 if (err < 0) 1015 goto out; 1016 1017 /* Copy results into user buffer */ 1018 switch (_IOC_DIR(cmd)) 1019 { 1020 case _IOC_READ: 1021 case (_IOC_WRITE | _IOC_READ): 1022 if (copy_to_user((void __user *)arg, parg, _IOC_SIZE(cmd))) 1023 err = -EFAULT; 1024 break; 1025 } 1026 1027out: 1028 kfree(mbuf); 1029 return err; 1030} 1031 1032#if IS_ENABLED(CONFIG_I2C) 1033struct i2c_client *dvb_module_probe(const char *module_name, 1034 const char *name, 1035 struct i2c_adapter *adap, 1036 unsigned char addr, 1037 void *platform_data) 1038{ 1039 struct i2c_client *client; 1040 struct i2c_board_info *board_info; 1041 1042 board_info = kzalloc(sizeof(*board_info), GFP_KERNEL); 1043 if (!board_info) 1044 return NULL; 1045 1046 if (name) 1047 strscpy(board_info->type, name, I2C_NAME_SIZE); 1048 else 1049 strscpy(board_info->type, module_name, I2C_NAME_SIZE); 1050 1051 board_info->addr = addr; 1052 board_info->platform_data = platform_data; 1053 request_module(module_name); 1054 client = i2c_new_client_device(adap, board_info); 1055 if (!i2c_client_has_driver(client)) { 1056 kfree(board_info); 1057 return NULL; 1058 } 1059 1060 if (!try_module_get(client->dev.driver->owner)) { 1061 i2c_unregister_device(client); 1062 client = NULL; 1063 } 1064 1065 kfree(board_info); 1066 return client; 1067} 1068EXPORT_SYMBOL_GPL(dvb_module_probe); 1069 1070void dvb_module_release(struct i2c_client *client) 1071{ 1072 if (!client) 1073 return; 1074 1075 module_put(client->dev.driver->owner); 1076 i2c_unregister_device(client); 1077} 1078EXPORT_SYMBOL_GPL(dvb_module_release); 1079#endif 1080 1081static int dvb_uevent(struct device *dev, struct kobj_uevent_env *env) 1082{ 1083 struct dvb_device *dvbdev = dev_get_drvdata(dev); 1084 1085 add_uevent_var(env, "DVB_ADAPTER_NUM=%d", dvbdev->adapter->num); 1086 add_uevent_var(env, "DVB_DEVICE_TYPE=%s", dnames[dvbdev->type]); 1087 add_uevent_var(env, "DVB_DEVICE_NUM=%d", dvbdev->id); 1088 return 0; 1089} 1090 1091static char *dvb_devnode(struct device *dev, umode_t *mode) 1092{ 1093 struct dvb_device *dvbdev = dev_get_drvdata(dev); 1094 1095 return kasprintf(GFP_KERNEL, "dvb/adapter%d/%s%d", 1096 dvbdev->adapter->num, dnames[dvbdev->type], dvbdev->id); 1097} 1098 1099 1100static int __init init_dvbdev(void) 1101{ 1102 int retval; 1103 dev_t dev = MKDEV(DVB_MAJOR, 0); 1104 1105 if ((retval = register_chrdev_region(dev, MAX_DVB_MINORS, "DVB")) != 0) { 1106 pr_err("dvb-core: unable to get major %d\n", DVB_MAJOR); 1107 return retval; 1108 } 1109 1110 cdev_init(&dvb_device_cdev, &dvb_device_fops); 1111 if ((retval = cdev_add(&dvb_device_cdev, dev, MAX_DVB_MINORS)) != 0) { 1112 pr_err("dvb-core: unable register character device\n"); 1113 goto error; 1114 } 1115 1116 dvb_class = class_create(THIS_MODULE, "dvb"); 1117 if (IS_ERR(dvb_class)) { 1118 retval = PTR_ERR(dvb_class); 1119 goto error; 1120 } 1121 dvb_class->dev_uevent = dvb_uevent; 1122 dvb_class->devnode = dvb_devnode; 1123 return 0; 1124 1125error: 1126 cdev_del(&dvb_device_cdev); 1127 unregister_chrdev_region(dev, MAX_DVB_MINORS); 1128 return retval; 1129} 1130 1131 1132static void __exit exit_dvbdev(void) 1133{ 1134 struct dvbdevfops_node *node, *next; 1135 1136 class_destroy(dvb_class); 1137 cdev_del(&dvb_device_cdev); 1138 unregister_chrdev_region(MKDEV(DVB_MAJOR, 0), MAX_DVB_MINORS); 1139 1140 list_for_each_entry_safe(node, next, &dvbdevfops_list, list_head) { 1141 list_del (&node->list_head); 1142 kfree(node->fops); 1143 kfree(node); 1144 } 1145} 1146 1147subsys_initcall(init_dvbdev); 1148module_exit(exit_dvbdev); 1149 1150MODULE_DESCRIPTION("DVB Core Driver"); 1151MODULE_AUTHOR("Marcus Metzler, Ralph Metzler, Holger Waechtler"); 1152MODULE_LICENSE("GPL"); 1153