drivers/media/media-entity.c

   1 /*
   2  * Media entity
   3  *
   4  * Copyright (C) 2010 Nokia Corporation
   5  *
   6  * Contacts: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
   7  *           Sakari Ailus <sakari.ailus@iki.fi>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License version 2 as
  11  * published by the Free Software Foundation.
  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  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22
  23 #include <linux/bitmap.h>
  24 #include <linux/module.h>
  25 #include <linux/slab.h>
  26 #include <media/media-entity.h>
  27 #include <media/media-device.h>
  28
  29 static inline const char *gobj_type(enum media_gobj_type type)
  30 {
  31         switch (type) {
  32         case MEDIA_GRAPH_ENTITY:
  33                 return "entity";
  34         case MEDIA_GRAPH_PAD:
  35                 return "pad";
  36         case MEDIA_GRAPH_LINK:
  37                 return "link";
  38         case MEDIA_GRAPH_INTF_DEVNODE:
  39                 return "intf-devnode";
  40         default:
  41                 return "unknown";
  42         }
  43 }
  44
  45 static inline const char *intf_type(struct media_interface *intf)
  46 {
  47         switch (intf->type) {
  48         case MEDIA_INTF_T_DVB_FE:
  49                 return "frontend";
  50         case MEDIA_INTF_T_DVB_DEMUX:
  51                 return "demux";
  52         case MEDIA_INTF_T_DVB_DVR:
  53                 return "DVR";
  54         case MEDIA_INTF_T_DVB_CA:
  55                 return  "CA";
  56         case MEDIA_INTF_T_DVB_NET:
  57                 return "dvbnet";
  58         case MEDIA_INTF_T_V4L_VIDEO:
  59                 return "video";
  60         case MEDIA_INTF_T_V4L_VBI:
  61                 return "vbi";
  62         case MEDIA_INTF_T_V4L_RADIO:
  63                 return "radio";
  64         case MEDIA_INTF_T_V4L_SUBDEV:
  65                 return "v4l2-subdev";
  66         case MEDIA_INTF_T_V4L_SWRADIO:
  67                 return "swradio";
  68         default:
  69                 return "unknown-intf";
  70         }
  71 };
  72
  73 /**
  74  *  dev_dbg_obj - Prints in debug mode a change on some object
  75  *
  76  * @event_name: Name of the event to report. Could be __func__
  77  * @gobj:       Pointer to the object
  78  *
  79  * Enabled only if DEBUG or CONFIG_DYNAMIC_DEBUG. Otherwise, it
  80  * won't produce any code.
  81  */
  82 static void dev_dbg_obj(const char *event_name,  struct media_gobj *gobj)
  83 {
  84 #if defined(DEBUG) || defined (CONFIG_DYNAMIC_DEBUG)
  85         switch (media_type(gobj)) {
  86         case MEDIA_GRAPH_ENTITY:
  87                 dev_dbg(gobj->mdev->dev,
  88                         "%s: id 0x%08x entity#%d: '%s'\n",
  89                         event_name, gobj->id, media_localid(gobj),
  90                         gobj_to_entity(gobj)->name);
  91                 break;
  92         case MEDIA_GRAPH_LINK:
  93         {
  94                 struct media_link *link = gobj_to_link(gobj);
  95
  96                 dev_dbg(gobj->mdev->dev,
  97                         "%s: id 0x%08x link#%d: %s#%d ==> %s#%d\n",
  98                         event_name, gobj->id, media_localid(gobj),
  99
 100                         gobj_type(media_type(link->gobj0)),
 101                         media_localid(link->gobj0),
 102
 103                         gobj_type(media_type(link->gobj1)),
 104                         media_localid(link->gobj1));
 105                 break;
 106         }
 107         case MEDIA_GRAPH_PAD:
 108         {
 109                 struct media_pad *pad = gobj_to_pad(gobj);
 110
 111                 dev_dbg(gobj->mdev->dev,
 112                         "%s: id 0x%08x %s%spad#%d: '%s':%d\n",
 113                         event_name, gobj->id,
 114                         pad->flags & MEDIA_PAD_FL_SINK   ? "  sink " : "",
 115                         pad->flags & MEDIA_PAD_FL_SOURCE ? "source " : "",
 116                         media_localid(gobj),
 117                         pad->entity->name, pad->index);
 118                 break;
 119         }
 120         case MEDIA_GRAPH_INTF_DEVNODE:
 121         {
 122                 struct media_interface *intf = gobj_to_intf(gobj);
 123                 struct media_intf_devnode *devnode = intf_to_devnode(intf);
 124
 125                 dev_dbg(gobj->mdev->dev,
 126                         "%s: id 0x%08x intf_devnode#%d: %s - major: %d, minor: %d\n",
 127                         event_name, gobj->id, media_localid(gobj),
 128                         intf_type(intf),
 129                         devnode->major, devnode->minor);
 130                 break;
 131         }
 132         }
 133 #endif
 134 }
 135
 136 void media_gobj_create(struct media_device *mdev,
 137                            enum media_gobj_type type,
 138                            struct media_gobj *gobj)
 139 {
 140         BUG_ON(!mdev);
 141
 142         gobj->mdev = mdev;
 143
 144         /* Create a per-type unique object ID */
 145         switch (type) {
 146         case MEDIA_GRAPH_ENTITY:
 147                 gobj->id = media_gobj_gen_id(type, ++mdev->entity_id);
 148                 list_add_tail(&gobj->list, &mdev->entities);
 149                 break;
 150         case MEDIA_GRAPH_PAD:
 151                 gobj->id = media_gobj_gen_id(type, ++mdev->pad_id);
 152                 list_add_tail(&gobj->list, &mdev->pads);
 153                 break;
 154         case MEDIA_GRAPH_LINK:
 155                 gobj->id = media_gobj_gen_id(type, ++mdev->link_id);
 156                 list_add_tail(&gobj->list, &mdev->links);
 157                 break;
 158         case MEDIA_GRAPH_INTF_DEVNODE:
 159                 gobj->id = media_gobj_gen_id(type, ++mdev->intf_devnode_id);
 160                 list_add_tail(&gobj->list, &mdev->interfaces);
 161                 break;
 162         }
 163
 164         mdev->topology_version++;
 165
 166         dev_dbg_obj(__func__, gobj);
 167 }
 168
 169 void media_gobj_destroy(struct media_gobj *gobj)
 170 {
 171         dev_dbg_obj(__func__, gobj);
 172
 173         gobj->mdev->topology_version++;
 174
 175         /* Remove the object from mdev list */
 176         list_del(&gobj->list);
 177 }
 178
 179 int media_entity_pads_init(struct media_entity *entity, u16 num_pads,
 180                            struct media_pad *pads)
 181 {
 182         struct media_device *mdev = entity->graph_obj.mdev;
 183         unsigned int i;
 184
 185         entity->num_pads = num_pads;
 186         entity->pads = pads;
 187
 188         if (mdev)
 189                 spin_lock(&mdev->lock);
 190
 191         for (i = 0; i < num_pads; i++) {
 192                 pads[i].entity = entity;
 193                 pads[i].index = i;
 194                 if (mdev)
 195                         media_gobj_create(mdev, MEDIA_GRAPH_PAD,
 196                                         &entity->pads[i].graph_obj);
 197         }
 198
 199         if (mdev)
 200                 spin_unlock(&mdev->lock);
 201
 202         return 0;
 203 }
 204 EXPORT_SYMBOL_GPL(media_entity_pads_init);
 205
 206 /* -----------------------------------------------------------------------------
 207  * Graph traversal
 208  */
 209
 210 static struct media_entity *
 211 media_entity_other(struct media_entity *entity, struct media_link *link)
 212 {
 213         if (link->source->entity == entity)
 214                 return link->sink->entity;
 215         else
 216                 return link->source->entity;
 217 }
 218
 219 /* push an entity to traversal stack */
 220 static void stack_push(struct media_entity_graph *graph,
 221                        struct media_entity *entity)
 222 {
 223         if (graph->top == MEDIA_ENTITY_ENUM_MAX_DEPTH - 1) {
 224                 WARN_ON(1);
 225                 return;
 226         }
 227         graph->top++;
 228         graph->stack[graph->top].link = (&entity->links)->next;
 229         graph->stack[graph->top].entity = entity;
 230 }
 231
 232 static struct media_entity *stack_pop(struct media_entity_graph *graph)
 233 {
 234         struct media_entity *entity;
 235
 236         entity = graph->stack[graph->top].entity;
 237         graph->top--;
 238
 239         return entity;
 240 }
 241
 242 #define link_top(en)    ((en)->stack[(en)->top].link)
 243 #define stack_top(en)   ((en)->stack[(en)->top].entity)
 244
 245 void media_entity_graph_walk_start(struct media_entity_graph *graph,
 246                                    struct media_entity *entity)
 247 {
 248         graph->top = 0;
 249         graph->stack[graph->top].entity = NULL;
 250         bitmap_zero(graph->entities, MEDIA_ENTITY_ENUM_MAX_ID);
 251
 252         if (WARN_ON(media_entity_id(entity) >= MEDIA_ENTITY_ENUM_MAX_ID))
 253                 return;
 254
 255         __set_bit(media_entity_id(entity), graph->entities);
 256         stack_push(graph, entity);
 257 }
 258 EXPORT_SYMBOL_GPL(media_entity_graph_walk_start);
 259
 260 struct media_entity *
 261 media_entity_graph_walk_next(struct media_entity_graph *graph)
 262 {
 263         if (stack_top(graph) == NULL)
 264                 return NULL;
 265
 266         /*
 267          * Depth first search. Push entity to stack and continue from
 268          * top of the stack until no more entities on the level can be
 269          * found.
 270          */
 271         while (link_top(graph) != &(stack_top(graph)->links)) {
 272                 struct media_entity *entity = stack_top(graph);
 273                 struct media_link *link;
 274                 struct media_entity *next;
 275
 276                 link = list_entry(link_top(graph), typeof(*link), list);
 277
 278                 /* The link is not enabled so we do not follow. */
 279                 if (!(link->flags & MEDIA_LNK_FL_ENABLED)) {
 280                         link_top(graph) = link_top(graph)->next;
 281                         continue;
 282                 }
 283
 284                 /* Get the entity in the other end of the link . */
 285                 next = media_entity_other(entity, link);
 286                 if (WARN_ON(media_entity_id(next) >= MEDIA_ENTITY_ENUM_MAX_ID))
 287                         return NULL;
 288
 289                 /* Has the entity already been visited? */
 290                 if (__test_and_set_bit(media_entity_id(next), graph->entities)) {
 291                         link_top(graph) = link_top(graph)->next;
 292                         continue;
 293                 }
 294
 295                 /* Push the new entity to stack and start over. */
 296                 link_top(graph) = link_top(graph)->next;
 297                 stack_push(graph, next);
 298         }
 299
 300         return stack_pop(graph);
 301 }
 302 EXPORT_SYMBOL_GPL(media_entity_graph_walk_next);
 303
 304 /* -----------------------------------------------------------------------------
 305  * Pipeline management
 306  */
 307
 308 __must_check int media_entity_pipeline_start(struct media_entity *entity,
 309                                              struct media_pipeline *pipe)
 310 {
 311         struct media_device *mdev = entity->graph_obj.mdev;
 312         struct media_entity_graph graph;
 313         struct media_entity *entity_err = entity;
 314         struct media_link *link;
 315         int ret;
 316
 317         mutex_lock(&mdev->graph_mutex);
 318
 319         media_entity_graph_walk_start(&graph, entity);
 320
 321         while ((entity = media_entity_graph_walk_next(&graph))) {
 322                 DECLARE_BITMAP(active, MEDIA_ENTITY_MAX_PADS);
 323                 DECLARE_BITMAP(has_no_links, MEDIA_ENTITY_MAX_PADS);
 324
 325                 entity->stream_count++;
 326                 WARN_ON(entity->pipe && entity->pipe != pipe);
 327                 entity->pipe = pipe;
 328
 329                 /* Already streaming --- no need to check. */
 330                 if (entity->stream_count > 1)
 331                         continue;
 332
 333                 if (!entity->ops || !entity->ops->link_validate)
 334                         continue;
 335
 336                 bitmap_zero(active, entity->num_pads);
 337                 bitmap_fill(has_no_links, entity->num_pads);
 338
 339                 list_for_each_entry(link, &entity->links, list) {
 340                         struct media_pad *pad = link->sink->entity == entity
 341                                                 ? link->sink : link->source;
 342
 343                         /* Mark that a pad is connected by a link. */
 344                         bitmap_clear(has_no_links, pad->index, 1);
 345
 346                         /*
 347                          * Pads that either do not need to connect or
 348                          * are connected through an enabled link are
 349                          * fine.
 350                          */
 351                         if (!(pad->flags & MEDIA_PAD_FL_MUST_CONNECT) ||
 352                             link->flags & MEDIA_LNK_FL_ENABLED)
 353                                 bitmap_set(active, pad->index, 1);
 354
 355                         /*
 356                          * Link validation will only take place for
 357                          * sink ends of the link that are enabled.
 358                          */
 359                         if (link->sink != pad ||
 360                             !(link->flags & MEDIA_LNK_FL_ENABLED))
 361                                 continue;
 362
 363                         ret = entity->ops->link_validate(link);
 364                         if (ret < 0 && ret != -ENOIOCTLCMD) {
 365                                 dev_dbg(entity->graph_obj.mdev->dev,
 366                                         "link validation failed for \"%s\":%u -> \"%s\":%u, error %d\n",
 367                                         link->source->entity->name,
 368                                         link->source->index,
 369                                         entity->name, link->sink->index, ret);
 370                                 goto error;
 371                         }
 372                 }
 373
 374                 /* Either no links or validated links are fine. */
 375                 bitmap_or(active, active, has_no_links, entity->num_pads);
 376
 377                 if (!bitmap_full(active, entity->num_pads)) {
 378                         ret = -EPIPE;
 379                         dev_dbg(entity->graph_obj.mdev->dev,
 380                                 "\"%s\":%u must be connected by an enabled link\n",
 381                                 entity->name,
 382                                 (unsigned)find_first_zero_bit(
 383                                         active, entity->num_pads));
 384                         goto error;
 385                 }
 386         }
 387
 388         mutex_unlock(&mdev->graph_mutex);
 389
 390         return 0;
 391
 392 error:
 393         /*
 394          * Link validation on graph failed. We revert what we did and
 395          * return the error.
 396          */
 397         media_entity_graph_walk_start(&graph, entity_err);
 398
 399         while ((entity_err = media_entity_graph_walk_next(&graph))) {
 400                 entity_err->stream_count--;
 401                 if (entity_err->stream_count == 0)
 402                         entity_err->pipe = NULL;
 403
 404                 /*
 405                  * We haven't increased stream_count further than this
 406                  * so we quit here.
 407                  */
 408                 if (entity_err == entity)
 409                         break;
 410         }
 411
 412         mutex_unlock(&mdev->graph_mutex);
 413
 414         return ret;
 415 }
 416 EXPORT_SYMBOL_GPL(media_entity_pipeline_start);
 417
 418 void media_entity_pipeline_stop(struct media_entity *entity)
 419 {
 420         struct media_device *mdev = entity->graph_obj.mdev;
 421         struct media_entity_graph graph;
 422
 423         mutex_lock(&mdev->graph_mutex);
 424
 425         media_entity_graph_walk_start(&graph, entity);
 426
 427         while ((entity = media_entity_graph_walk_next(&graph))) {
 428                 entity->stream_count--;
 429                 if (entity->stream_count == 0)
 430                         entity->pipe = NULL;
 431         }
 432
 433         mutex_unlock(&mdev->graph_mutex);
 434 }
 435 EXPORT_SYMBOL_GPL(media_entity_pipeline_stop);
 436
 437 /* -----------------------------------------------------------------------------
 438  * Module use count
 439  */
 440
 441 struct media_entity *media_entity_get(struct media_entity *entity)
 442 {
 443         if (entity == NULL)
 444                 return NULL;
 445
 446         if (entity->graph_obj.mdev->dev &&
 447             !try_module_get(entity->graph_obj.mdev->dev->driver->owner))
 448                 return NULL;
 449
 450         return entity;
 451 }
 452 EXPORT_SYMBOL_GPL(media_entity_get);
 453
 454 void media_entity_put(struct media_entity *entity)
 455 {
 456         if (entity == NULL)
 457                 return;
 458
 459         if (entity->graph_obj.mdev->dev)
 460                 module_put(entity->graph_obj.mdev->dev->driver->owner);
 461 }
 462 EXPORT_SYMBOL_GPL(media_entity_put);
 463
 464 /* -----------------------------------------------------------------------------
 465  * Links management
 466  */
 467
 468 static struct media_link *media_add_link(struct list_head *head)
 469 {
 470         struct media_link *link;
 471
 472         link = kzalloc(sizeof(*link), GFP_KERNEL);
 473         if (link == NULL)
 474                 return NULL;
 475
 476         list_add_tail(&link->list, head);
 477
 478         return link;
 479 }
 480
 481 static void __media_entity_remove_link(struct media_entity *entity,
 482                                        struct media_link *link)
 483 {
 484         struct media_link *rlink, *tmp;
 485         struct media_entity *remote;
 486
 487         if (link->source->entity == entity)
 488                 remote = link->sink->entity;
 489         else
 490                 remote = link->source->entity;
 491
 492         list_for_each_entry_safe(rlink, tmp, &remote->links, list) {
 493                 if (rlink != link->reverse)
 494                         continue;
 495
 496                 if (link->source->entity == entity)
 497                         remote->num_backlinks--;
 498
 499                 /* Remove the remote link */
 500                 list_del(&rlink->list);
 501                 media_gobj_destroy(&rlink->graph_obj);
 502                 kfree(rlink);
 503
 504                 if (--remote->num_links == 0)
 505                         break;
 506         }
 507         list_del(&link->list);
 508         media_gobj_destroy(&link->graph_obj);
 509         kfree(link);
 510 }
 511
 512 int
 513 media_create_pad_link(struct media_entity *source, u16 source_pad,
 514                          struct media_entity *sink, u16 sink_pad, u32 flags)
 515 {
 516         struct media_link *link;
 517         struct media_link *backlink;
 518
 519         BUG_ON(source == NULL || sink == NULL);
 520         BUG_ON(source_pad >= source->num_pads);
 521         BUG_ON(sink_pad >= sink->num_pads);
 522
 523         link = media_add_link(&source->links);
 524         if (link == NULL)
 525                 return -ENOMEM;
 526
 527         link->source = &source->pads[source_pad];
 528         link->sink = &sink->pads[sink_pad];
 529         link->flags = flags;
 530
 531         /* Initialize graph object embedded at the new link */
 532         media_gobj_create(source->graph_obj.mdev, MEDIA_GRAPH_LINK,
 533                         &link->graph_obj);
 534
 535         /* Create the backlink. Backlinks are used to help graph traversal and
 536          * are not reported to userspace.
 537          */
 538         backlink = media_add_link(&sink->links);
 539         if (backlink == NULL) {
 540                 __media_entity_remove_link(source, link);
 541                 return -ENOMEM;
 542         }
 543
 544         backlink->source = &source->pads[source_pad];
 545         backlink->sink = &sink->pads[sink_pad];
 546         backlink->flags = flags;
 547         backlink->is_backlink = true;
 548
 549         /* Initialize graph object embedded at the new link */
 550         media_gobj_create(sink->graph_obj.mdev, MEDIA_GRAPH_LINK,
 551                         &backlink->graph_obj);
 552
 553         link->reverse = backlink;
 554         backlink->reverse = link;
 555
 556         sink->num_backlinks++;
 557         sink->num_links++;
 558         source->num_links++;
 559
 560         return 0;
 561 }
 562 EXPORT_SYMBOL_GPL(media_create_pad_link);
 563
 564 void __media_entity_remove_links(struct media_entity *entity)
 565 {
 566         struct media_link *link, *tmp;
 567
 568         list_for_each_entry_safe(link, tmp, &entity->links, list)
 569                 __media_entity_remove_link(entity, link);
 570
 571         entity->num_links = 0;
 572         entity->num_backlinks = 0;
 573 }
 574 EXPORT_SYMBOL_GPL(__media_entity_remove_links);
 575
 576 void media_entity_remove_links(struct media_entity *entity)
 577 {
 578         /* Do nothing if the entity is not registered. */
 579         if (entity->graph_obj.mdev == NULL)
 580                 return;
 581
 582         spin_lock(&entity->graph_obj.mdev->lock);
 583         __media_entity_remove_links(entity);
 584         spin_unlock(&entity->graph_obj.mdev->lock);
 585 }
 586 EXPORT_SYMBOL_GPL(media_entity_remove_links);
 587
 588 static int __media_entity_setup_link_notify(struct media_link *link, u32 flags)
 589 {
 590         int ret;
 591
 592         /* Notify both entities. */
 593         ret = media_entity_call(link->source->entity, link_setup,
 594                                 link->source, link->sink, flags);
 595         if (ret < 0 && ret != -ENOIOCTLCMD)
 596                 return ret;
 597
 598         ret = media_entity_call(link->sink->entity, link_setup,
 599                                 link->sink, link->source, flags);
 600         if (ret < 0 && ret != -ENOIOCTLCMD) {
 601                 media_entity_call(link->source->entity, link_setup,
 602                                   link->source, link->sink, link->flags);
 603                 return ret;
 604         }
 605
 606         link->flags = flags;
 607         link->reverse->flags = link->flags;
 608
 609         return 0;
 610 }
 611
 612 int __media_entity_setup_link(struct media_link *link, u32 flags)
 613 {
 614         const u32 mask = MEDIA_LNK_FL_ENABLED;
 615         struct media_device *mdev;
 616         struct media_entity *source, *sink;
 617         int ret = -EBUSY;
 618
 619         if (link == NULL)
 620                 return -EINVAL;
 621
 622         /* The non-modifiable link flags must not be modified. */
 623         if ((link->flags & ~mask) != (flags & ~mask))
 624                 return -EINVAL;
 625
 626         if (link->flags & MEDIA_LNK_FL_IMMUTABLE)
 627                 return link->flags == flags ? 0 : -EINVAL;
 628
 629         if (link->flags == flags)
 630                 return 0;
 631
 632         source = link->source->entity;
 633         sink = link->sink->entity;
 634
 635         if (!(link->flags & MEDIA_LNK_FL_DYNAMIC) &&
 636             (source->stream_count || sink->stream_count))
 637                 return -EBUSY;
 638
 639         mdev = source->graph_obj.mdev;
 640
 641         if (mdev->link_notify) {
 642                 ret = mdev->link_notify(link, flags,
 643                                         MEDIA_DEV_NOTIFY_PRE_LINK_CH);
 644                 if (ret < 0)
 645                         return ret;
 646         }
 647
 648         ret = __media_entity_setup_link_notify(link, flags);
 649
 650         if (mdev->link_notify)
 651                 mdev->link_notify(link, flags, MEDIA_DEV_NOTIFY_POST_LINK_CH);
 652
 653         return ret;
 654 }
 655
 656 int media_entity_setup_link(struct media_link *link, u32 flags)
 657 {
 658         int ret;
 659
 660         spin_lock(&link->source->entity->graph_obj.mdev->lock);
 661         ret = __media_entity_setup_link(link, flags);
 662         spin_unlock(&link->source->entity->graph_obj.mdev->lock);
 663
 664         return ret;
 665 }
 666 EXPORT_SYMBOL_GPL(media_entity_setup_link);
 667
 668 struct media_link *
 669 media_entity_find_link(struct media_pad *source, struct media_pad *sink)
 670 {
 671         struct media_link *link;
 672
 673         list_for_each_entry(link, &source->entity->links, list) {
 674                 if (link->source->entity == source->entity &&
 675                     link->source->index == source->index &&
 676                     link->sink->entity == sink->entity &&
 677                     link->sink->index == sink->index)
 678                         return link;
 679         }
 680
 681         return NULL;
 682 }
 683 EXPORT_SYMBOL_GPL(media_entity_find_link);
 684
 685 struct media_pad *media_entity_remote_pad(struct media_pad *pad)
 686 {
 687         struct media_link *link;
 688
 689         list_for_each_entry(link, &pad->entity->links, list) {
 690                 if (!(link->flags & MEDIA_LNK_FL_ENABLED))
 691                         continue;
 692
 693                 if (link->source == pad)
 694                         return link->sink;
 695
 696                 if (link->sink == pad)
 697                         return link->source;
 698         }
 699
 700         return NULL;
 701
 702 }
 703 EXPORT_SYMBOL_GPL(media_entity_remote_pad);
 704
 705 static void media_interface_init(struct media_device *mdev,
 706                                  struct media_interface *intf,
 707                                  u32 gobj_type,
 708                                  u32 intf_type, u32 flags)
 709 {
 710         intf->type = intf_type;
 711         intf->flags = flags;
 712         INIT_LIST_HEAD(&intf->links);
 713
 714         media_gobj_create(mdev, gobj_type, &intf->graph_obj);
 715 }
 716
 717 /* Functions related to the media interface via device nodes */
 718
 719 struct media_intf_devnode *media_devnode_create(struct media_device *mdev,
 720                                                 u32 type, u32 flags,
 721                                                 u32 major, u32 minor)
 722 {
 723         struct media_intf_devnode *devnode;
 724
 725         devnode = kzalloc(sizeof(*devnode), GFP_KERNEL);
 726         if (!devnode)
 727                 return NULL;
 728
 729         devnode->major = major;
 730         devnode->minor = minor;
 731
 732         media_interface_init(mdev, &devnode->intf, MEDIA_GRAPH_INTF_DEVNODE,
 733                              type, flags);
 734
 735         return devnode;
 736 }
 737 EXPORT_SYMBOL_GPL(media_devnode_create);
 738
 739 void media_devnode_remove(struct media_intf_devnode *devnode)
 740 {
 741         media_remove_intf_links(&devnode->intf);
 742         media_gobj_destroy(&devnode->intf.graph_obj);
 743         kfree(devnode);
 744 }
 745 EXPORT_SYMBOL_GPL(media_devnode_remove);
 746
 747 struct media_link *media_create_intf_link(struct media_entity *entity,
 748                                             struct media_interface *intf,
 749                                             u32 flags)
 750 {
 751         struct media_link *link;
 752
 753         link = media_add_link(&intf->links);
 754         if (link == NULL)
 755                 return NULL;
 756
 757         link->intf = intf;
 758         link->entity = entity;
 759         link->flags = flags;
 760
 761         /* Initialize graph object embedded at the new link */
 762         media_gobj_create(intf->graph_obj.mdev, MEDIA_GRAPH_LINK,
 763                         &link->graph_obj);
 764
 765         return link;
 766 }
 767 EXPORT_SYMBOL_GPL(media_create_intf_link);
 768
 769 void __media_remove_intf_link(struct media_link *link)
 770 {
 771         list_del(&link->list);
 772         media_gobj_destroy(&link->graph_obj);
 773         kfree(link);
 774 }
 775 EXPORT_SYMBOL_GPL(__media_remove_intf_link);
 776
 777 void media_remove_intf_link(struct media_link *link)
 778 {
 779         spin_lock(&link->graph_obj.mdev->lock);
 780         __media_remove_intf_link(link);
 781         spin_unlock(&link->graph_obj.mdev->lock);
 782 }
 783 EXPORT_SYMBOL_GPL(media_remove_intf_link);
 784
 785 void __media_remove_intf_links(struct media_interface *intf)
 786 {
 787         struct media_link *link, *tmp;
 788
 789         list_for_each_entry_safe(link, tmp, &intf->links, list)
 790                 __media_remove_intf_link(link);
 791
 792 }
 793 EXPORT_SYMBOL_GPL(__media_remove_intf_links);
 794
 795 void media_remove_intf_links(struct media_interface *intf)
 796 {
 797         /* Do nothing if the intf is not registered. */
 798         if (intf->graph_obj.mdev == NULL)
 799                 return;
 800
 801         spin_lock(&intf->graph_obj.mdev->lock);
 802         __media_remove_intf_links(intf);
 803         spin_unlock(&intf->graph_obj.mdev->lock);
 804 }
 805 EXPORT_SYMBOL_GPL(media_remove_intf_links);