1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Media entity 4 * 5 * Copyright (C) 2010 Nokia Corporation 6 * 7 * Contacts: Laurent Pinchart <laurent.pinchart@ideasonboard.com> 8 * Sakari Ailus <sakari.ailus@iki.fi> 9 */ 10 11 #include <linux/bitmap.h> 12 #include <linux/property.h> 13 #include <linux/slab.h> 14 #include <media/media-entity.h> 15 #include <media/media-device.h> 16 17 static inline const char *gobj_type(enum media_gobj_type type) 18 { 19 switch (type) { 20 case MEDIA_GRAPH_ENTITY: 21 return "entity"; 22 case MEDIA_GRAPH_PAD: 23 return "pad"; 24 case MEDIA_GRAPH_LINK: 25 return "link"; 26 case MEDIA_GRAPH_INTF_DEVNODE: 27 return "intf-devnode"; 28 default: 29 return "unknown"; 30 } 31 } 32 33 static inline const char *intf_type(struct media_interface *intf) 34 { 35 switch (intf->type) { 36 case MEDIA_INTF_T_DVB_FE: 37 return "dvb-frontend"; 38 case MEDIA_INTF_T_DVB_DEMUX: 39 return "dvb-demux"; 40 case MEDIA_INTF_T_DVB_DVR: 41 return "dvb-dvr"; 42 case MEDIA_INTF_T_DVB_CA: 43 return "dvb-ca"; 44 case MEDIA_INTF_T_DVB_NET: 45 return "dvb-net"; 46 case MEDIA_INTF_T_V4L_VIDEO: 47 return "v4l-video"; 48 case MEDIA_INTF_T_V4L_VBI: 49 return "v4l-vbi"; 50 case MEDIA_INTF_T_V4L_RADIO: 51 return "v4l-radio"; 52 case MEDIA_INTF_T_V4L_SUBDEV: 53 return "v4l-subdev"; 54 case MEDIA_INTF_T_V4L_SWRADIO: 55 return "v4l-swradio"; 56 case MEDIA_INTF_T_V4L_TOUCH: 57 return "v4l-touch"; 58 default: 59 return "unknown-intf"; 60 } 61 }; 62 63 __must_check int __media_entity_enum_init(struct media_entity_enum *ent_enum, 64 int idx_max) 65 { 66 idx_max = ALIGN(idx_max, BITS_PER_LONG); 67 ent_enum->bmap = kcalloc(idx_max / BITS_PER_LONG, sizeof(long), 68 GFP_KERNEL); 69 if (!ent_enum->bmap) 70 return -ENOMEM; 71 72 bitmap_zero(ent_enum->bmap, idx_max); 73 ent_enum->idx_max = idx_max; 74 75 return 0; 76 } 77 EXPORT_SYMBOL_GPL(__media_entity_enum_init); 78 79 void media_entity_enum_cleanup(struct media_entity_enum *ent_enum) 80 { 81 kfree(ent_enum->bmap); 82 } 83 EXPORT_SYMBOL_GPL(media_entity_enum_cleanup); 84 85 /** 86 * dev_dbg_obj - Prints in debug mode a change on some object 87 * 88 * @event_name: Name of the event to report. Could be __func__ 89 * @gobj: Pointer to the object 90 * 91 * Enabled only if DEBUG or CONFIG_DYNAMIC_DEBUG. Otherwise, it 92 * won't produce any code. 93 */ 94 static void dev_dbg_obj(const char *event_name, struct media_gobj *gobj) 95 { 96 #if defined(DEBUG) || defined (CONFIG_DYNAMIC_DEBUG) 97 switch (media_type(gobj)) { 98 case MEDIA_GRAPH_ENTITY: 99 dev_dbg(gobj->mdev->dev, 100 "%s id %u: entity '%s'\n", 101 event_name, media_id(gobj), 102 gobj_to_entity(gobj)->name); 103 break; 104 case MEDIA_GRAPH_LINK: 105 { 106 struct media_link *link = gobj_to_link(gobj); 107 108 dev_dbg(gobj->mdev->dev, 109 "%s id %u: %s link id %u ==> id %u\n", 110 event_name, media_id(gobj), 111 media_type(link->gobj0) == MEDIA_GRAPH_PAD ? 112 "data" : "interface", 113 media_id(link->gobj0), 114 media_id(link->gobj1)); 115 break; 116 } 117 case MEDIA_GRAPH_PAD: 118 { 119 struct media_pad *pad = gobj_to_pad(gobj); 120 121 dev_dbg(gobj->mdev->dev, 122 "%s id %u: %s%spad '%s':%d\n", 123 event_name, media_id(gobj), 124 pad->flags & MEDIA_PAD_FL_SINK ? "sink " : "", 125 pad->flags & MEDIA_PAD_FL_SOURCE ? "source " : "", 126 pad->entity->name, pad->index); 127 break; 128 } 129 case MEDIA_GRAPH_INTF_DEVNODE: 130 { 131 struct media_interface *intf = gobj_to_intf(gobj); 132 struct media_intf_devnode *devnode = intf_to_devnode(intf); 133 134 dev_dbg(gobj->mdev->dev, 135 "%s id %u: intf_devnode %s - major: %d, minor: %d\n", 136 event_name, media_id(gobj), 137 intf_type(intf), 138 devnode->major, devnode->minor); 139 break; 140 } 141 } 142 #endif 143 } 144 145 void media_gobj_create(struct media_device *mdev, 146 enum media_gobj_type type, 147 struct media_gobj *gobj) 148 { 149 BUG_ON(!mdev); 150 151 gobj->mdev = mdev; 152 153 /* Create a per-type unique object ID */ 154 gobj->id = media_gobj_gen_id(type, ++mdev->id); 155 156 switch (type) { 157 case MEDIA_GRAPH_ENTITY: 158 list_add_tail(&gobj->list, &mdev->entities); 159 break; 160 case MEDIA_GRAPH_PAD: 161 list_add_tail(&gobj->list, &mdev->pads); 162 break; 163 case MEDIA_GRAPH_LINK: 164 list_add_tail(&gobj->list, &mdev->links); 165 break; 166 case MEDIA_GRAPH_INTF_DEVNODE: 167 list_add_tail(&gobj->list, &mdev->interfaces); 168 break; 169 } 170 171 mdev->topology_version++; 172 173 dev_dbg_obj(__func__, gobj); 174 } 175 176 void media_gobj_destroy(struct media_gobj *gobj) 177 { 178 /* Do nothing if the object is not linked. */ 179 if (gobj->mdev == NULL) 180 return; 181 182 dev_dbg_obj(__func__, gobj); 183 184 gobj->mdev->topology_version++; 185 186 /* Remove the object from mdev list */ 187 list_del(&gobj->list); 188 189 gobj->mdev = NULL; 190 } 191 192 /* 193 * TODO: Get rid of this. 194 */ 195 #define MEDIA_ENTITY_MAX_PADS 512 196 197 int media_entity_pads_init(struct media_entity *entity, u16 num_pads, 198 struct media_pad *pads) 199 { 200 struct media_device *mdev = entity->graph_obj.mdev; 201 unsigned int i; 202 203 if (num_pads >= MEDIA_ENTITY_MAX_PADS) 204 return -E2BIG; 205 206 entity->num_pads = num_pads; 207 entity->pads = pads; 208 209 if (mdev) 210 mutex_lock(&mdev->graph_mutex); 211 212 for (i = 0; i < num_pads; i++) { 213 pads[i].entity = entity; 214 pads[i].index = i; 215 if (mdev) 216 media_gobj_create(mdev, MEDIA_GRAPH_PAD, 217 &entity->pads[i].graph_obj); 218 } 219 220 if (mdev) 221 mutex_unlock(&mdev->graph_mutex); 222 223 return 0; 224 } 225 EXPORT_SYMBOL_GPL(media_entity_pads_init); 226 227 /* ----------------------------------------------------------------------------- 228 * Graph traversal 229 */ 230 231 static struct media_entity * 232 media_entity_other(struct media_entity *entity, struct media_link *link) 233 { 234 if (link->source->entity == entity) 235 return link->sink->entity; 236 else 237 return link->source->entity; 238 } 239 240 /* push an entity to traversal stack */ 241 static void stack_push(struct media_graph *graph, 242 struct media_entity *entity) 243 { 244 if (graph->top == MEDIA_ENTITY_ENUM_MAX_DEPTH - 1) { 245 WARN_ON(1); 246 return; 247 } 248 graph->top++; 249 graph->stack[graph->top].link = entity->links.next; 250 graph->stack[graph->top].entity = entity; 251 } 252 253 static struct media_entity *stack_pop(struct media_graph *graph) 254 { 255 struct media_entity *entity; 256 257 entity = graph->stack[graph->top].entity; 258 graph->top--; 259 260 return entity; 261 } 262 263 #define link_top(en) ((en)->stack[(en)->top].link) 264 #define stack_top(en) ((en)->stack[(en)->top].entity) 265 266 /** 267 * media_graph_walk_init - Allocate resources for graph walk 268 * @graph: Media graph structure that will be used to walk the graph 269 * @mdev: Media device 270 * 271 * Reserve resources for graph walk in media device's current 272 * state. The memory must be released using 273 * media_graph_walk_free(). 274 * 275 * Returns error on failure, zero on success. 276 */ 277 __must_check int media_graph_walk_init( 278 struct media_graph *graph, struct media_device *mdev) 279 { 280 return media_entity_enum_init(&graph->ent_enum, mdev); 281 } 282 EXPORT_SYMBOL_GPL(media_graph_walk_init); 283 284 /** 285 * media_graph_walk_cleanup - Release resources related to graph walking 286 * @graph: Media graph structure that was used to walk the graph 287 */ 288 void media_graph_walk_cleanup(struct media_graph *graph) 289 { 290 media_entity_enum_cleanup(&graph->ent_enum); 291 } 292 EXPORT_SYMBOL_GPL(media_graph_walk_cleanup); 293 294 void media_graph_walk_start(struct media_graph *graph, 295 struct media_entity *entity) 296 { 297 media_entity_enum_zero(&graph->ent_enum); 298 media_entity_enum_set(&graph->ent_enum, entity); 299 300 graph->top = 0; 301 graph->stack[graph->top].entity = NULL; 302 stack_push(graph, entity); 303 dev_dbg(entity->graph_obj.mdev->dev, 304 "begin graph walk at '%s'\n", entity->name); 305 } 306 EXPORT_SYMBOL_GPL(media_graph_walk_start); 307 308 static void media_graph_walk_iter(struct media_graph *graph) 309 { 310 struct media_entity *entity = stack_top(graph); 311 struct media_link *link; 312 struct media_entity *next; 313 314 link = list_entry(link_top(graph), typeof(*link), list); 315 316 /* The link is not enabled so we do not follow. */ 317 if (!(link->flags & MEDIA_LNK_FL_ENABLED)) { 318 link_top(graph) = link_top(graph)->next; 319 dev_dbg(entity->graph_obj.mdev->dev, 320 "walk: skipping disabled link '%s':%u -> '%s':%u\n", 321 link->source->entity->name, link->source->index, 322 link->sink->entity->name, link->sink->index); 323 return; 324 } 325 326 /* Get the entity in the other end of the link . */ 327 next = media_entity_other(entity, link); 328 329 /* Has the entity already been visited? */ 330 if (media_entity_enum_test_and_set(&graph->ent_enum, next)) { 331 link_top(graph) = link_top(graph)->next; 332 dev_dbg(entity->graph_obj.mdev->dev, 333 "walk: skipping entity '%s' (already seen)\n", 334 next->name); 335 return; 336 } 337 338 /* Push the new entity to stack and start over. */ 339 link_top(graph) = link_top(graph)->next; 340 stack_push(graph, next); 341 dev_dbg(entity->graph_obj.mdev->dev, "walk: pushing '%s' on stack\n", 342 next->name); 343 } 344 345 struct media_entity *media_graph_walk_next(struct media_graph *graph) 346 { 347 struct media_entity *entity; 348 349 if (stack_top(graph) == NULL) 350 return NULL; 351 352 /* 353 * Depth first search. Push entity to stack and continue from 354 * top of the stack until no more entities on the level can be 355 * found. 356 */ 357 while (link_top(graph) != &stack_top(graph)->links) 358 media_graph_walk_iter(graph); 359 360 entity = stack_pop(graph); 361 dev_dbg(entity->graph_obj.mdev->dev, 362 "walk: returning entity '%s'\n", entity->name); 363 364 return entity; 365 } 366 EXPORT_SYMBOL_GPL(media_graph_walk_next); 367 368 int media_entity_get_fwnode_pad(struct media_entity *entity, 369 struct fwnode_handle *fwnode, 370 unsigned long direction_flags) 371 { 372 struct fwnode_endpoint endpoint; 373 unsigned int i; 374 int ret; 375 376 if (!entity->ops || !entity->ops->get_fwnode_pad) { 377 for (i = 0; i < entity->num_pads; i++) { 378 if (entity->pads[i].flags & direction_flags) 379 return i; 380 } 381 382 return -ENXIO; 383 } 384 385 ret = fwnode_graph_parse_endpoint(fwnode, &endpoint); 386 if (ret) 387 return ret; 388 389 ret = entity->ops->get_fwnode_pad(entity, &endpoint); 390 if (ret < 0) 391 return ret; 392 393 if (ret >= entity->num_pads) 394 return -ENXIO; 395 396 if (!(entity->pads[ret].flags & direction_flags)) 397 return -ENXIO; 398 399 return ret; 400 } 401 EXPORT_SYMBOL_GPL(media_entity_get_fwnode_pad); 402 403 /* ----------------------------------------------------------------------------- 404 * Pipeline management 405 */ 406 407 __must_check int __media_pipeline_start(struct media_entity *entity, 408 struct media_pipeline *pipe) 409 { 410 struct media_device *mdev = entity->graph_obj.mdev; 411 struct media_graph *graph = &pipe->graph; 412 struct media_entity *entity_err = entity; 413 struct media_link *link; 414 int ret; 415 416 if (!pipe->streaming_count++) { 417 ret = media_graph_walk_init(&pipe->graph, mdev); 418 if (ret) 419 goto error_graph_walk_start; 420 } 421 422 media_graph_walk_start(&pipe->graph, entity); 423 424 while ((entity = media_graph_walk_next(graph))) { 425 DECLARE_BITMAP(active, MEDIA_ENTITY_MAX_PADS); 426 DECLARE_BITMAP(has_no_links, MEDIA_ENTITY_MAX_PADS); 427 428 entity->stream_count++; 429 430 if (entity->pipe && entity->pipe != pipe) { 431 pr_err("Pipe active for %s. Can't start for %s\n", 432 entity->name, 433 entity_err->name); 434 ret = -EBUSY; 435 goto error; 436 } 437 438 entity->pipe = pipe; 439 440 /* Already streaming --- no need to check. */ 441 if (entity->stream_count > 1) 442 continue; 443 444 if (!entity->ops || !entity->ops->link_validate) 445 continue; 446 447 bitmap_zero(active, entity->num_pads); 448 bitmap_fill(has_no_links, entity->num_pads); 449 450 list_for_each_entry(link, &entity->links, list) { 451 struct media_pad *pad = link->sink->entity == entity 452 ? link->sink : link->source; 453 454 /* Mark that a pad is connected by a link. */ 455 bitmap_clear(has_no_links, pad->index, 1); 456 457 /* 458 * Pads that either do not need to connect or 459 * are connected through an enabled link are 460 * fine. 461 */ 462 if (!(pad->flags & MEDIA_PAD_FL_MUST_CONNECT) || 463 link->flags & MEDIA_LNK_FL_ENABLED) 464 bitmap_set(active, pad->index, 1); 465 466 /* 467 * Link validation will only take place for 468 * sink ends of the link that are enabled. 469 */ 470 if (link->sink != pad || 471 !(link->flags & MEDIA_LNK_FL_ENABLED)) 472 continue; 473 474 ret = entity->ops->link_validate(link); 475 if (ret < 0 && ret != -ENOIOCTLCMD) { 476 dev_dbg(entity->graph_obj.mdev->dev, 477 "link validation failed for '%s':%u -> '%s':%u, error %d\n", 478 link->source->entity->name, 479 link->source->index, 480 entity->name, link->sink->index, ret); 481 goto error; 482 } 483 } 484 485 /* Either no links or validated links are fine. */ 486 bitmap_or(active, active, has_no_links, entity->num_pads); 487 488 if (!bitmap_full(active, entity->num_pads)) { 489 ret = -ENOLINK; 490 dev_dbg(entity->graph_obj.mdev->dev, 491 "'%s':%u must be connected by an enabled link\n", 492 entity->name, 493 (unsigned)find_first_zero_bit( 494 active, entity->num_pads)); 495 goto error; 496 } 497 } 498 499 return 0; 500 501 error: 502 /* 503 * Link validation on graph failed. We revert what we did and 504 * return the error. 505 */ 506 media_graph_walk_start(graph, entity_err); 507 508 while ((entity_err = media_graph_walk_next(graph))) { 509 /* Sanity check for negative stream_count */ 510 if (!WARN_ON_ONCE(entity_err->stream_count <= 0)) { 511 entity_err->stream_count--; 512 if (entity_err->stream_count == 0) 513 entity_err->pipe = NULL; 514 } 515 516 /* 517 * We haven't increased stream_count further than this 518 * so we quit here. 519 */ 520 if (entity_err == entity) 521 break; 522 } 523 524 error_graph_walk_start: 525 if (!--pipe->streaming_count) 526 media_graph_walk_cleanup(graph); 527 528 return ret; 529 } 530 EXPORT_SYMBOL_GPL(__media_pipeline_start); 531 532 __must_check int media_pipeline_start(struct media_entity *entity, 533 struct media_pipeline *pipe) 534 { 535 struct media_device *mdev = entity->graph_obj.mdev; 536 int ret; 537 538 mutex_lock(&mdev->graph_mutex); 539 ret = __media_pipeline_start(entity, pipe); 540 mutex_unlock(&mdev->graph_mutex); 541 return ret; 542 } 543 EXPORT_SYMBOL_GPL(media_pipeline_start); 544 545 void __media_pipeline_stop(struct media_entity *entity) 546 { 547 struct media_graph *graph = &entity->pipe->graph; 548 struct media_pipeline *pipe = entity->pipe; 549 550 /* 551 * If the following check fails, the driver has performed an 552 * unbalanced call to media_pipeline_stop() 553 */ 554 if (WARN_ON(!pipe)) 555 return; 556 557 media_graph_walk_start(graph, entity); 558 559 while ((entity = media_graph_walk_next(graph))) { 560 /* Sanity check for negative stream_count */ 561 if (!WARN_ON_ONCE(entity->stream_count <= 0)) { 562 entity->stream_count--; 563 if (entity->stream_count == 0) 564 entity->pipe = NULL; 565 } 566 } 567 568 if (!--pipe->streaming_count) 569 media_graph_walk_cleanup(graph); 570 571 } 572 EXPORT_SYMBOL_GPL(__media_pipeline_stop); 573 574 void media_pipeline_stop(struct media_entity *entity) 575 { 576 struct media_device *mdev = entity->graph_obj.mdev; 577 578 mutex_lock(&mdev->graph_mutex); 579 __media_pipeline_stop(entity); 580 mutex_unlock(&mdev->graph_mutex); 581 } 582 EXPORT_SYMBOL_GPL(media_pipeline_stop); 583 584 /* ----------------------------------------------------------------------------- 585 * Links management 586 */ 587 588 static struct media_link *media_add_link(struct list_head *head) 589 { 590 struct media_link *link; 591 592 link = kzalloc(sizeof(*link), GFP_KERNEL); 593 if (link == NULL) 594 return NULL; 595 596 list_add_tail(&link->list, head); 597 598 return link; 599 } 600 601 static void __media_entity_remove_link(struct media_entity *entity, 602 struct media_link *link) 603 { 604 struct media_link *rlink, *tmp; 605 struct media_entity *remote; 606 607 if (link->source->entity == entity) 608 remote = link->sink->entity; 609 else 610 remote = link->source->entity; 611 612 list_for_each_entry_safe(rlink, tmp, &remote->links, list) { 613 if (rlink != link->reverse) 614 continue; 615 616 if (link->source->entity == entity) 617 remote->num_backlinks--; 618 619 /* Remove the remote link */ 620 list_del(&rlink->list); 621 media_gobj_destroy(&rlink->graph_obj); 622 kfree(rlink); 623 624 if (--remote->num_links == 0) 625 break; 626 } 627 list_del(&link->list); 628 media_gobj_destroy(&link->graph_obj); 629 kfree(link); 630 } 631 632 int media_get_pad_index(struct media_entity *entity, bool is_sink, 633 enum media_pad_signal_type sig_type) 634 { 635 int i; 636 bool pad_is_sink; 637 638 if (!entity) 639 return -EINVAL; 640 641 for (i = 0; i < entity->num_pads; i++) { 642 if (entity->pads[i].flags & MEDIA_PAD_FL_SINK) 643 pad_is_sink = true; 644 else if (entity->pads[i].flags & MEDIA_PAD_FL_SOURCE) 645 pad_is_sink = false; 646 else 647 continue; /* This is an error! */ 648 649 if (pad_is_sink != is_sink) 650 continue; 651 if (entity->pads[i].sig_type == sig_type) 652 return i; 653 } 654 return -EINVAL; 655 } 656 EXPORT_SYMBOL_GPL(media_get_pad_index); 657 658 int 659 media_create_pad_link(struct media_entity *source, u16 source_pad, 660 struct media_entity *sink, u16 sink_pad, u32 flags) 661 { 662 struct media_link *link; 663 struct media_link *backlink; 664 665 if (WARN_ON(!source || !sink) || 666 WARN_ON(source_pad >= source->num_pads) || 667 WARN_ON(sink_pad >= sink->num_pads)) 668 return -EINVAL; 669 if (WARN_ON(!(source->pads[source_pad].flags & MEDIA_PAD_FL_SOURCE))) 670 return -EINVAL; 671 if (WARN_ON(!(sink->pads[sink_pad].flags & MEDIA_PAD_FL_SINK))) 672 return -EINVAL; 673 674 link = media_add_link(&source->links); 675 if (link == NULL) 676 return -ENOMEM; 677 678 link->source = &source->pads[source_pad]; 679 link->sink = &sink->pads[sink_pad]; 680 link->flags = flags & ~MEDIA_LNK_FL_INTERFACE_LINK; 681 682 /* Initialize graph object embedded at the new link */ 683 media_gobj_create(source->graph_obj.mdev, MEDIA_GRAPH_LINK, 684 &link->graph_obj); 685 686 /* Create the backlink. Backlinks are used to help graph traversal and 687 * are not reported to userspace. 688 */ 689 backlink = media_add_link(&sink->links); 690 if (backlink == NULL) { 691 __media_entity_remove_link(source, link); 692 return -ENOMEM; 693 } 694 695 backlink->source = &source->pads[source_pad]; 696 backlink->sink = &sink->pads[sink_pad]; 697 backlink->flags = flags; 698 backlink->is_backlink = true; 699 700 /* Initialize graph object embedded at the new link */ 701 media_gobj_create(sink->graph_obj.mdev, MEDIA_GRAPH_LINK, 702 &backlink->graph_obj); 703 704 link->reverse = backlink; 705 backlink->reverse = link; 706 707 sink->num_backlinks++; 708 sink->num_links++; 709 source->num_links++; 710 711 return 0; 712 } 713 EXPORT_SYMBOL_GPL(media_create_pad_link); 714 715 int media_create_pad_links(const struct media_device *mdev, 716 const u32 source_function, 717 struct media_entity *source, 718 const u16 source_pad, 719 const u32 sink_function, 720 struct media_entity *sink, 721 const u16 sink_pad, 722 u32 flags, 723 const bool allow_both_undefined) 724 { 725 struct media_entity *entity; 726 unsigned function; 727 int ret; 728 729 /* Trivial case: 1:1 relation */ 730 if (source && sink) 731 return media_create_pad_link(source, source_pad, 732 sink, sink_pad, flags); 733 734 /* Worse case scenario: n:n relation */ 735 if (!source && !sink) { 736 if (!allow_both_undefined) 737 return 0; 738 media_device_for_each_entity(source, mdev) { 739 if (source->function != source_function) 740 continue; 741 media_device_for_each_entity(sink, mdev) { 742 if (sink->function != sink_function) 743 continue; 744 ret = media_create_pad_link(source, source_pad, 745 sink, sink_pad, 746 flags); 747 if (ret) 748 return ret; 749 flags &= ~(MEDIA_LNK_FL_ENABLED | 750 MEDIA_LNK_FL_IMMUTABLE); 751 } 752 } 753 return 0; 754 } 755 756 /* Handle 1:n and n:1 cases */ 757 if (source) 758 function = sink_function; 759 else 760 function = source_function; 761 762 media_device_for_each_entity(entity, mdev) { 763 if (entity->function != function) 764 continue; 765 766 if (source) 767 ret = media_create_pad_link(source, source_pad, 768 entity, sink_pad, flags); 769 else 770 ret = media_create_pad_link(entity, source_pad, 771 sink, sink_pad, flags); 772 if (ret) 773 return ret; 774 flags &= ~(MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE); 775 } 776 return 0; 777 } 778 EXPORT_SYMBOL_GPL(media_create_pad_links); 779 780 void __media_entity_remove_links(struct media_entity *entity) 781 { 782 struct media_link *link, *tmp; 783 784 list_for_each_entry_safe(link, tmp, &entity->links, list) 785 __media_entity_remove_link(entity, link); 786 787 entity->num_links = 0; 788 entity->num_backlinks = 0; 789 } 790 EXPORT_SYMBOL_GPL(__media_entity_remove_links); 791 792 void media_entity_remove_links(struct media_entity *entity) 793 { 794 struct media_device *mdev = entity->graph_obj.mdev; 795 796 /* Do nothing if the entity is not registered. */ 797 if (mdev == NULL) 798 return; 799 800 mutex_lock(&mdev->graph_mutex); 801 __media_entity_remove_links(entity); 802 mutex_unlock(&mdev->graph_mutex); 803 } 804 EXPORT_SYMBOL_GPL(media_entity_remove_links); 805 806 static int __media_entity_setup_link_notify(struct media_link *link, u32 flags) 807 { 808 int ret; 809 810 /* Notify both entities. */ 811 ret = media_entity_call(link->source->entity, link_setup, 812 link->source, link->sink, flags); 813 if (ret < 0 && ret != -ENOIOCTLCMD) 814 return ret; 815 816 ret = media_entity_call(link->sink->entity, link_setup, 817 link->sink, link->source, flags); 818 if (ret < 0 && ret != -ENOIOCTLCMD) { 819 media_entity_call(link->source->entity, link_setup, 820 link->source, link->sink, link->flags); 821 return ret; 822 } 823 824 link->flags = flags; 825 link->reverse->flags = link->flags; 826 827 return 0; 828 } 829 830 int __media_entity_setup_link(struct media_link *link, u32 flags) 831 { 832 const u32 mask = MEDIA_LNK_FL_ENABLED; 833 struct media_device *mdev; 834 struct media_entity *source, *sink; 835 int ret = -EBUSY; 836 837 if (link == NULL) 838 return -EINVAL; 839 840 /* The non-modifiable link flags must not be modified. */ 841 if ((link->flags & ~mask) != (flags & ~mask)) 842 return -EINVAL; 843 844 if (link->flags & MEDIA_LNK_FL_IMMUTABLE) 845 return link->flags == flags ? 0 : -EINVAL; 846 847 if (link->flags == flags) 848 return 0; 849 850 source = link->source->entity; 851 sink = link->sink->entity; 852 853 if (!(link->flags & MEDIA_LNK_FL_DYNAMIC) && 854 (source->stream_count || sink->stream_count)) 855 return -EBUSY; 856 857 mdev = source->graph_obj.mdev; 858 859 if (mdev->ops && mdev->ops->link_notify) { 860 ret = mdev->ops->link_notify(link, flags, 861 MEDIA_DEV_NOTIFY_PRE_LINK_CH); 862 if (ret < 0) 863 return ret; 864 } 865 866 ret = __media_entity_setup_link_notify(link, flags); 867 868 if (mdev->ops && mdev->ops->link_notify) 869 mdev->ops->link_notify(link, flags, 870 MEDIA_DEV_NOTIFY_POST_LINK_CH); 871 872 return ret; 873 } 874 EXPORT_SYMBOL_GPL(__media_entity_setup_link); 875 876 int media_entity_setup_link(struct media_link *link, u32 flags) 877 { 878 int ret; 879 880 mutex_lock(&link->graph_obj.mdev->graph_mutex); 881 ret = __media_entity_setup_link(link, flags); 882 mutex_unlock(&link->graph_obj.mdev->graph_mutex); 883 884 return ret; 885 } 886 EXPORT_SYMBOL_GPL(media_entity_setup_link); 887 888 struct media_link * 889 media_entity_find_link(struct media_pad *source, struct media_pad *sink) 890 { 891 struct media_link *link; 892 893 list_for_each_entry(link, &source->entity->links, list) { 894 if (link->source->entity == source->entity && 895 link->source->index == source->index && 896 link->sink->entity == sink->entity && 897 link->sink->index == sink->index) 898 return link; 899 } 900 901 return NULL; 902 } 903 EXPORT_SYMBOL_GPL(media_entity_find_link); 904 905 struct media_pad *media_entity_remote_pad(const struct media_pad *pad) 906 { 907 struct media_link *link; 908 909 list_for_each_entry(link, &pad->entity->links, list) { 910 if (!(link->flags & MEDIA_LNK_FL_ENABLED)) 911 continue; 912 913 if (link->source == pad) 914 return link->sink; 915 916 if (link->sink == pad) 917 return link->source; 918 } 919 920 return NULL; 921 922 } 923 EXPORT_SYMBOL_GPL(media_entity_remote_pad); 924 925 static void media_interface_init(struct media_device *mdev, 926 struct media_interface *intf, 927 u32 gobj_type, 928 u32 intf_type, u32 flags) 929 { 930 intf->type = intf_type; 931 intf->flags = flags; 932 INIT_LIST_HEAD(&intf->links); 933 934 media_gobj_create(mdev, gobj_type, &intf->graph_obj); 935 } 936 937 /* Functions related to the media interface via device nodes */ 938 939 struct media_intf_devnode *media_devnode_create(struct media_device *mdev, 940 u32 type, u32 flags, 941 u32 major, u32 minor) 942 { 943 struct media_intf_devnode *devnode; 944 945 devnode = kzalloc(sizeof(*devnode), GFP_KERNEL); 946 if (!devnode) 947 return NULL; 948 949 devnode->major = major; 950 devnode->minor = minor; 951 952 media_interface_init(mdev, &devnode->intf, MEDIA_GRAPH_INTF_DEVNODE, 953 type, flags); 954 955 return devnode; 956 } 957 EXPORT_SYMBOL_GPL(media_devnode_create); 958 959 void media_devnode_remove(struct media_intf_devnode *devnode) 960 { 961 media_remove_intf_links(&devnode->intf); 962 media_gobj_destroy(&devnode->intf.graph_obj); 963 kfree(devnode); 964 } 965 EXPORT_SYMBOL_GPL(media_devnode_remove); 966 967 struct media_link *media_create_intf_link(struct media_entity *entity, 968 struct media_interface *intf, 969 u32 flags) 970 { 971 struct media_link *link; 972 973 link = media_add_link(&intf->links); 974 if (link == NULL) 975 return NULL; 976 977 link->intf = intf; 978 link->entity = entity; 979 link->flags = flags | MEDIA_LNK_FL_INTERFACE_LINK; 980 981 /* Initialize graph object embedded at the new link */ 982 media_gobj_create(intf->graph_obj.mdev, MEDIA_GRAPH_LINK, 983 &link->graph_obj); 984 985 return link; 986 } 987 EXPORT_SYMBOL_GPL(media_create_intf_link); 988 989 void __media_remove_intf_link(struct media_link *link) 990 { 991 list_del(&link->list); 992 media_gobj_destroy(&link->graph_obj); 993 kfree(link); 994 } 995 EXPORT_SYMBOL_GPL(__media_remove_intf_link); 996 997 void media_remove_intf_link(struct media_link *link) 998 { 999 struct media_device *mdev = link->graph_obj.mdev; 1000 1001 /* Do nothing if the intf is not registered. */ 1002 if (mdev == NULL) 1003 return; 1004 1005 mutex_lock(&mdev->graph_mutex); 1006 __media_remove_intf_link(link); 1007 mutex_unlock(&mdev->graph_mutex); 1008 } 1009 EXPORT_SYMBOL_GPL(media_remove_intf_link); 1010 1011 void __media_remove_intf_links(struct media_interface *intf) 1012 { 1013 struct media_link *link, *tmp; 1014 1015 list_for_each_entry_safe(link, tmp, &intf->links, list) 1016 __media_remove_intf_link(link); 1017 1018 } 1019 EXPORT_SYMBOL_GPL(__media_remove_intf_links); 1020 1021 void media_remove_intf_links(struct media_interface *intf) 1022 { 1023 struct media_device *mdev = intf->graph_obj.mdev; 1024 1025 /* Do nothing if the intf is not registered. */ 1026 if (mdev == NULL) 1027 return; 1028 1029 mutex_lock(&mdev->graph_mutex); 1030 __media_remove_intf_links(intf); 1031 mutex_unlock(&mdev->graph_mutex); 1032 } 1033 EXPORT_SYMBOL_GPL(media_remove_intf_links); 1034