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 19 #ifndef _MEDIA_ENTITY_H 20 #define _MEDIA_ENTITY_H 21 22 #include <linux/bitmap.h> 23 #include <linux/bug.h> 24 #include <linux/fwnode.h> 25 #include <linux/kernel.h> 26 #include <linux/list.h> 27 #include <linux/media.h> 28 29 /* Enums used internally at the media controller to represent graphs */ 30 31 /** 32 * enum media_gobj_type - type of a graph object 33 * 34 * @MEDIA_GRAPH_ENTITY: Identify a media entity 35 * @MEDIA_GRAPH_PAD: Identify a media pad 36 * @MEDIA_GRAPH_LINK: Identify a media link 37 * @MEDIA_GRAPH_INTF_DEVNODE: Identify a media Kernel API interface via 38 * a device node 39 */ 40 enum media_gobj_type { 41 MEDIA_GRAPH_ENTITY, 42 MEDIA_GRAPH_PAD, 43 MEDIA_GRAPH_LINK, 44 MEDIA_GRAPH_INTF_DEVNODE, 45 }; 46 47 #define MEDIA_BITS_PER_TYPE 8 48 #define MEDIA_BITS_PER_ID (32 - MEDIA_BITS_PER_TYPE) 49 #define MEDIA_ID_MASK GENMASK_ULL(MEDIA_BITS_PER_ID - 1, 0) 50 51 /* Structs to represent the objects that belong to a media graph */ 52 53 /** 54 * struct media_gobj - Define a graph object. 55 * 56 * @mdev: Pointer to the struct &media_device that owns the object 57 * @id: Non-zero object ID identifier. The ID should be unique 58 * inside a media_device, as it is composed by 59 * %MEDIA_BITS_PER_TYPE to store the type plus 60 * %MEDIA_BITS_PER_ID to store the ID 61 * @list: List entry stored in one of the per-type mdev object lists 62 * 63 * All objects on the media graph should have this struct embedded 64 */ 65 struct media_gobj { 66 struct media_device *mdev; 67 u32 id; 68 struct list_head list; 69 }; 70 71 #define MEDIA_ENTITY_ENUM_MAX_DEPTH 16 72 73 /** 74 * struct media_entity_enum - An enumeration of media entities. 75 * 76 * @bmap: Bit map in which each bit represents one entity at struct 77 * media_entity->internal_idx. 78 * @idx_max: Number of bits in bmap 79 */ 80 struct media_entity_enum { 81 unsigned long *bmap; 82 int idx_max; 83 }; 84 85 /** 86 * struct media_graph - Media graph traversal state 87 * 88 * @stack: Graph traversal stack; the stack contains information 89 * on the path the media entities to be walked and the 90 * links through which they were reached. 91 * @stack.entity: pointer to &struct media_entity at the graph. 92 * @stack.link: pointer to &struct list_head. 93 * @ent_enum: Visited entities 94 * @top: The top of the stack 95 */ 96 struct media_graph { 97 struct { 98 struct media_entity *entity; 99 struct list_head *link; 100 } stack[MEDIA_ENTITY_ENUM_MAX_DEPTH]; 101 102 struct media_entity_enum ent_enum; 103 int top; 104 }; 105 106 /** 107 * struct media_pipeline - Media pipeline related information 108 * 109 * @streaming_count: Streaming start count - streaming stop count 110 * @graph: Media graph walk during pipeline start / stop 111 */ 112 struct media_pipeline { 113 int streaming_count; 114 struct media_graph graph; 115 }; 116 117 /** 118 * struct media_link - A link object part of a media graph. 119 * 120 * @graph_obj: Embedded structure containing the media object common data 121 * @list: Linked list associated with an entity or an interface that 122 * owns the link. 123 * @gobj0: Part of a union. Used to get the pointer for the first 124 * graph_object of the link. 125 * @source: Part of a union. Used only if the first object (gobj0) is 126 * a pad. In that case, it represents the source pad. 127 * @intf: Part of a union. Used only if the first object (gobj0) is 128 * an interface. 129 * @gobj1: Part of a union. Used to get the pointer for the second 130 * graph_object of the link. 131 * @sink: Part of a union. Used only if the second object (gobj1) is 132 * a pad. In that case, it represents the sink pad. 133 * @entity: Part of a union. Used only if the second object (gobj1) is 134 * an entity. 135 * @reverse: Pointer to the link for the reverse direction of a pad to pad 136 * link. 137 * @flags: Link flags, as defined in uapi/media.h (MEDIA_LNK_FL_*) 138 * @is_backlink: Indicate if the link is a backlink. 139 */ 140 struct media_link { 141 struct media_gobj graph_obj; 142 struct list_head list; 143 union { 144 struct media_gobj *gobj0; 145 struct media_pad *source; 146 struct media_interface *intf; 147 }; 148 union { 149 struct media_gobj *gobj1; 150 struct media_pad *sink; 151 struct media_entity *entity; 152 }; 153 struct media_link *reverse; 154 unsigned long flags; 155 bool is_backlink; 156 }; 157 158 /** 159 * enum media_pad_signal_type - type of the signal inside a media pad 160 * 161 * @PAD_SIGNAL_DEFAULT: 162 * Default signal. Use this when all inputs or all outputs are 163 * uniquely identified by the pad number. 164 * @PAD_SIGNAL_ANALOG: 165 * The pad contains an analog signal. It can be Radio Frequency, 166 * Intermediate Frequency, a baseband signal or sub-cariers. 167 * Tuner inputs, IF-PLL demodulators, composite and s-video signals 168 * should use it. 169 * @PAD_SIGNAL_DV: 170 * Contains a digital video signal, with can be a bitstream of samples 171 * taken from an analog TV video source. On such case, it usually 172 * contains the VBI data on it. 173 * @PAD_SIGNAL_AUDIO: 174 * Contains an Intermediate Frequency analog signal from an audio 175 * sub-carrier or an audio bitstream. IF signals are provided by tuners 176 * and consumed by audio AM/FM decoders. Bitstream audio is provided by 177 * an audio decoder. 178 */ 179 enum media_pad_signal_type { 180 PAD_SIGNAL_DEFAULT = 0, 181 PAD_SIGNAL_ANALOG, 182 PAD_SIGNAL_DV, 183 PAD_SIGNAL_AUDIO, 184 }; 185 186 /** 187 * struct media_pad - A media pad graph object. 188 * 189 * @graph_obj: Embedded structure containing the media object common data 190 * @entity: Entity this pad belongs to 191 * @index: Pad index in the entity pads array, numbered from 0 to n 192 * @sig_type: Type of the signal inside a media pad 193 * @flags: Pad flags, as defined in 194 * :ref:`include/uapi/linux/media.h <media_header>` 195 * (seek for ``MEDIA_PAD_FL_*``) 196 */ 197 struct media_pad { 198 struct media_gobj graph_obj; /* must be first field in struct */ 199 struct media_entity *entity; 200 u16 index; 201 enum media_pad_signal_type sig_type; 202 unsigned long flags; 203 }; 204 205 /** 206 * struct media_entity_operations - Media entity operations 207 * @get_fwnode_pad: Return the pad number based on a fwnode endpoint or 208 * a negative value on error. This operation can be used 209 * to map a fwnode to a media pad number. Optional. 210 * @link_setup: Notify the entity of link changes. The operation can 211 * return an error, in which case link setup will be 212 * cancelled. Optional. 213 * @link_validate: Return whether a link is valid from the entity point of 214 * view. The media_pipeline_start() function 215 * validates all links by calling this operation. Optional. 216 * 217 * .. note:: 218 * 219 * Those these callbacks are called with struct &media_device.graph_mutex 220 * mutex held. 221 */ 222 struct media_entity_operations { 223 int (*get_fwnode_pad)(struct fwnode_endpoint *endpoint); 224 int (*link_setup)(struct media_entity *entity, 225 const struct media_pad *local, 226 const struct media_pad *remote, u32 flags); 227 int (*link_validate)(struct media_link *link); 228 }; 229 230 /** 231 * enum media_entity_type - Media entity type 232 * 233 * @MEDIA_ENTITY_TYPE_BASE: 234 * The entity isn't embedded in another subsystem structure. 235 * @MEDIA_ENTITY_TYPE_VIDEO_DEVICE: 236 * The entity is embedded in a struct video_device instance. 237 * @MEDIA_ENTITY_TYPE_V4L2_SUBDEV: 238 * The entity is embedded in a struct v4l2_subdev instance. 239 * 240 * Media entity objects are often not instantiated directly, but the media 241 * entity structure is inherited by (through embedding) other subsystem-specific 242 * structures. The media entity type identifies the type of the subclass 243 * structure that implements a media entity instance. 244 * 245 * This allows runtime type identification of media entities and safe casting to 246 * the correct object type. For instance, a media entity structure instance 247 * embedded in a v4l2_subdev structure instance will have the type 248 * %MEDIA_ENTITY_TYPE_V4L2_SUBDEV and can safely be cast to a &v4l2_subdev 249 * structure using the container_of() macro. 250 */ 251 enum media_entity_type { 252 MEDIA_ENTITY_TYPE_BASE, 253 MEDIA_ENTITY_TYPE_VIDEO_DEVICE, 254 MEDIA_ENTITY_TYPE_V4L2_SUBDEV, 255 }; 256 257 /** 258 * struct media_entity - A media entity graph object. 259 * 260 * @graph_obj: Embedded structure containing the media object common data. 261 * @name: Entity name. 262 * @obj_type: Type of the object that implements the media_entity. 263 * @function: Entity main function, as defined in 264 * :ref:`include/uapi/linux/media.h <media_header>` 265 * (seek for ``MEDIA_ENT_F_*``) 266 * @flags: Entity flags, as defined in 267 * :ref:`include/uapi/linux/media.h <media_header>` 268 * (seek for ``MEDIA_ENT_FL_*``) 269 * @num_pads: Number of sink and source pads. 270 * @num_links: Total number of links, forward and back, enabled and disabled. 271 * @num_backlinks: Number of backlinks 272 * @internal_idx: An unique internal entity specific number. The numbers are 273 * re-used if entities are unregistered or registered again. 274 * @pads: Pads array with the size defined by @num_pads. 275 * @links: List of data links. 276 * @ops: Entity operations. 277 * @stream_count: Stream count for the entity. 278 * @use_count: Use count for the entity. 279 * @pipe: Pipeline this entity belongs to. 280 * @info: Union with devnode information. Kept just for backward 281 * compatibility. 282 * @info.dev: Contains device major and minor info. 283 * @info.dev.major: device node major, if the device is a devnode. 284 * @info.dev.minor: device node minor, if the device is a devnode. 285 * @major: Devnode major number (zero if not applicable). Kept just 286 * for backward compatibility. 287 * @minor: Devnode minor number (zero if not applicable). Kept just 288 * for backward compatibility. 289 * 290 * .. note:: 291 * 292 * @stream_count and @use_count reference counts must never be 293 * negative, but are signed integers on purpose: a simple ``WARN_ON(<0)`` 294 * check can be used to detect reference count bugs that would make them 295 * negative. 296 */ 297 struct media_entity { 298 struct media_gobj graph_obj; /* must be first field in struct */ 299 const char *name; 300 enum media_entity_type obj_type; 301 u32 function; 302 unsigned long flags; 303 304 u16 num_pads; 305 u16 num_links; 306 u16 num_backlinks; 307 int internal_idx; 308 309 struct media_pad *pads; 310 struct list_head links; 311 312 const struct media_entity_operations *ops; 313 314 int stream_count; 315 int use_count; 316 317 struct media_pipeline *pipe; 318 319 union { 320 struct { 321 u32 major; 322 u32 minor; 323 } dev; 324 } info; 325 }; 326 327 /** 328 * struct media_interface - A media interface graph object. 329 * 330 * @graph_obj: embedded graph object 331 * @links: List of links pointing to graph entities 332 * @type: Type of the interface as defined in 333 * :ref:`include/uapi/linux/media.h <media_header>` 334 * (seek for ``MEDIA_INTF_T_*``) 335 * @flags: Interface flags as defined in 336 * :ref:`include/uapi/linux/media.h <media_header>` 337 * (seek for ``MEDIA_INTF_FL_*``) 338 * 339 * .. note:: 340 * 341 * Currently, no flags for &media_interface is defined. 342 */ 343 struct media_interface { 344 struct media_gobj graph_obj; 345 struct list_head links; 346 u32 type; 347 u32 flags; 348 }; 349 350 /** 351 * struct media_intf_devnode - A media interface via a device node. 352 * 353 * @intf: embedded interface object 354 * @major: Major number of a device node 355 * @minor: Minor number of a device node 356 */ 357 struct media_intf_devnode { 358 struct media_interface intf; 359 360 /* Should match the fields at media_v2_intf_devnode */ 361 u32 major; 362 u32 minor; 363 }; 364 365 /** 366 * media_entity_id() - return the media entity graph object id 367 * 368 * @entity: pointer to &media_entity 369 */ 370 static inline u32 media_entity_id(struct media_entity *entity) 371 { 372 return entity->graph_obj.id; 373 } 374 375 /** 376 * media_type() - return the media object type 377 * 378 * @gobj: Pointer to the struct &media_gobj graph object 379 */ 380 static inline enum media_gobj_type media_type(struct media_gobj *gobj) 381 { 382 return gobj->id >> MEDIA_BITS_PER_ID; 383 } 384 385 /** 386 * media_id() - return the media object ID 387 * 388 * @gobj: Pointer to the struct &media_gobj graph object 389 */ 390 static inline u32 media_id(struct media_gobj *gobj) 391 { 392 return gobj->id & MEDIA_ID_MASK; 393 } 394 395 /** 396 * media_gobj_gen_id() - encapsulates type and ID on at the object ID 397 * 398 * @type: object type as define at enum &media_gobj_type. 399 * @local_id: next ID, from struct &media_device.id. 400 */ 401 static inline u32 media_gobj_gen_id(enum media_gobj_type type, u64 local_id) 402 { 403 u32 id; 404 405 id = type << MEDIA_BITS_PER_ID; 406 id |= local_id & MEDIA_ID_MASK; 407 408 return id; 409 } 410 411 /** 412 * is_media_entity_v4l2_video_device() - Check if the entity is a video_device 413 * @entity: pointer to entity 414 * 415 * Return: %true if the entity is an instance of a video_device object and can 416 * safely be cast to a struct video_device using the container_of() macro, or 417 * %false otherwise. 418 */ 419 static inline bool is_media_entity_v4l2_video_device(struct media_entity *entity) 420 { 421 return entity && entity->obj_type == MEDIA_ENTITY_TYPE_VIDEO_DEVICE; 422 } 423 424 /** 425 * is_media_entity_v4l2_subdev() - Check if the entity is a v4l2_subdev 426 * @entity: pointer to entity 427 * 428 * Return: %true if the entity is an instance of a &v4l2_subdev object and can 429 * safely be cast to a struct &v4l2_subdev using the container_of() macro, or 430 * %false otherwise. 431 */ 432 static inline bool is_media_entity_v4l2_subdev(struct media_entity *entity) 433 { 434 return entity && entity->obj_type == MEDIA_ENTITY_TYPE_V4L2_SUBDEV; 435 } 436 437 /** 438 * __media_entity_enum_init - Initialise an entity enumeration 439 * 440 * @ent_enum: Entity enumeration to be initialised 441 * @idx_max: Maximum number of entities in the enumeration 442 * 443 * Return: Returns zero on success or a negative error code. 444 */ 445 __must_check int __media_entity_enum_init(struct media_entity_enum *ent_enum, 446 int idx_max); 447 448 /** 449 * media_entity_enum_cleanup - Release resources of an entity enumeration 450 * 451 * @ent_enum: Entity enumeration to be released 452 */ 453 void media_entity_enum_cleanup(struct media_entity_enum *ent_enum); 454 455 /** 456 * media_entity_enum_zero - Clear the entire enum 457 * 458 * @ent_enum: Entity enumeration to be cleared 459 */ 460 static inline void media_entity_enum_zero(struct media_entity_enum *ent_enum) 461 { 462 bitmap_zero(ent_enum->bmap, ent_enum->idx_max); 463 } 464 465 /** 466 * media_entity_enum_set - Mark a single entity in the enum 467 * 468 * @ent_enum: Entity enumeration 469 * @entity: Entity to be marked 470 */ 471 static inline void media_entity_enum_set(struct media_entity_enum *ent_enum, 472 struct media_entity *entity) 473 { 474 if (WARN_ON(entity->internal_idx >= ent_enum->idx_max)) 475 return; 476 477 __set_bit(entity->internal_idx, ent_enum->bmap); 478 } 479 480 /** 481 * media_entity_enum_clear - Unmark a single entity in the enum 482 * 483 * @ent_enum: Entity enumeration 484 * @entity: Entity to be unmarked 485 */ 486 static inline void media_entity_enum_clear(struct media_entity_enum *ent_enum, 487 struct media_entity *entity) 488 { 489 if (WARN_ON(entity->internal_idx >= ent_enum->idx_max)) 490 return; 491 492 __clear_bit(entity->internal_idx, ent_enum->bmap); 493 } 494 495 /** 496 * media_entity_enum_test - Test whether the entity is marked 497 * 498 * @ent_enum: Entity enumeration 499 * @entity: Entity to be tested 500 * 501 * Returns %true if the entity was marked. 502 */ 503 static inline bool media_entity_enum_test(struct media_entity_enum *ent_enum, 504 struct media_entity *entity) 505 { 506 if (WARN_ON(entity->internal_idx >= ent_enum->idx_max)) 507 return true; 508 509 return test_bit(entity->internal_idx, ent_enum->bmap); 510 } 511 512 /** 513 * media_entity_enum_test_and_set - Test whether the entity is marked, 514 * and mark it 515 * 516 * @ent_enum: Entity enumeration 517 * @entity: Entity to be tested 518 * 519 * Returns %true if the entity was marked, and mark it before doing so. 520 */ 521 static inline bool 522 media_entity_enum_test_and_set(struct media_entity_enum *ent_enum, 523 struct media_entity *entity) 524 { 525 if (WARN_ON(entity->internal_idx >= ent_enum->idx_max)) 526 return true; 527 528 return __test_and_set_bit(entity->internal_idx, ent_enum->bmap); 529 } 530 531 /** 532 * media_entity_enum_empty - Test whether the entire enum is empty 533 * 534 * @ent_enum: Entity enumeration 535 * 536 * Return: %true if the entity was empty. 537 */ 538 static inline bool media_entity_enum_empty(struct media_entity_enum *ent_enum) 539 { 540 return bitmap_empty(ent_enum->bmap, ent_enum->idx_max); 541 } 542 543 /** 544 * media_entity_enum_intersects - Test whether two enums intersect 545 * 546 * @ent_enum1: First entity enumeration 547 * @ent_enum2: Second entity enumeration 548 * 549 * Return: %true if entity enumerations @ent_enum1 and @ent_enum2 intersect, 550 * otherwise %false. 551 */ 552 static inline bool media_entity_enum_intersects( 553 struct media_entity_enum *ent_enum1, 554 struct media_entity_enum *ent_enum2) 555 { 556 WARN_ON(ent_enum1->idx_max != ent_enum2->idx_max); 557 558 return bitmap_intersects(ent_enum1->bmap, ent_enum2->bmap, 559 min(ent_enum1->idx_max, ent_enum2->idx_max)); 560 } 561 562 /** 563 * gobj_to_entity - returns the struct &media_entity pointer from the 564 * @gobj contained on it. 565 * 566 * @gobj: Pointer to the struct &media_gobj graph object 567 */ 568 #define gobj_to_entity(gobj) \ 569 container_of(gobj, struct media_entity, graph_obj) 570 571 /** 572 * gobj_to_pad - returns the struct &media_pad pointer from the 573 * @gobj contained on it. 574 * 575 * @gobj: Pointer to the struct &media_gobj graph object 576 */ 577 #define gobj_to_pad(gobj) \ 578 container_of(gobj, struct media_pad, graph_obj) 579 580 /** 581 * gobj_to_link - returns the struct &media_link pointer from the 582 * @gobj contained on it. 583 * 584 * @gobj: Pointer to the struct &media_gobj graph object 585 */ 586 #define gobj_to_link(gobj) \ 587 container_of(gobj, struct media_link, graph_obj) 588 589 /** 590 * gobj_to_intf - returns the struct &media_interface pointer from the 591 * @gobj contained on it. 592 * 593 * @gobj: Pointer to the struct &media_gobj graph object 594 */ 595 #define gobj_to_intf(gobj) \ 596 container_of(gobj, struct media_interface, graph_obj) 597 598 /** 599 * intf_to_devnode - returns the struct media_intf_devnode pointer from the 600 * @intf contained on it. 601 * 602 * @intf: Pointer to struct &media_intf_devnode 603 */ 604 #define intf_to_devnode(intf) \ 605 container_of(intf, struct media_intf_devnode, intf) 606 607 /** 608 * media_gobj_create - Initialize a graph object 609 * 610 * @mdev: Pointer to the &media_device that contains the object 611 * @type: Type of the object 612 * @gobj: Pointer to the struct &media_gobj graph object 613 * 614 * This routine initializes the embedded struct &media_gobj inside a 615 * media graph object. It is called automatically if ``media_*_create`` 616 * function calls are used. However, if the object (entity, link, pad, 617 * interface) is embedded on some other object, this function should be 618 * called before registering the object at the media controller. 619 */ 620 void media_gobj_create(struct media_device *mdev, 621 enum media_gobj_type type, 622 struct media_gobj *gobj); 623 624 /** 625 * media_gobj_destroy - Stop using a graph object on a media device 626 * 627 * @gobj: Pointer to the struct &media_gobj graph object 628 * 629 * This should be called by all routines like media_device_unregister() 630 * that remove/destroy media graph objects. 631 */ 632 void media_gobj_destroy(struct media_gobj *gobj); 633 634 /** 635 * media_entity_pads_init() - Initialize the entity pads 636 * 637 * @entity: entity where the pads belong 638 * @num_pads: total number of sink and source pads 639 * @pads: Array of @num_pads pads. 640 * 641 * The pads array is managed by the entity driver and passed to 642 * media_entity_pads_init() where its pointer will be stored in the 643 * &media_entity structure. 644 * 645 * If no pads are needed, drivers could either directly fill 646 * &media_entity->num_pads with 0 and &media_entity->pads with %NULL or call 647 * this function that will do the same. 648 * 649 * As the number of pads is known in advance, the pads array is not allocated 650 * dynamically but is managed by the entity driver. Most drivers will embed the 651 * pads array in a driver-specific structure, avoiding dynamic allocation. 652 * 653 * Drivers must set the direction of every pad in the pads array before calling 654 * media_entity_pads_init(). The function will initialize the other pads fields. 655 */ 656 int media_entity_pads_init(struct media_entity *entity, u16 num_pads, 657 struct media_pad *pads); 658 659 /** 660 * media_entity_cleanup() - free resources associated with an entity 661 * 662 * @entity: entity where the pads belong 663 * 664 * This function must be called during the cleanup phase after unregistering 665 * the entity (currently, it does nothing). 666 */ 667 #if IS_ENABLED(CONFIG_MEDIA_CONTROLLER) 668 static inline void media_entity_cleanup(struct media_entity *entity) {} 669 #else 670 #define media_entity_cleanup(entity) do { } while (false) 671 #endif 672 673 /** 674 * media_get_pad_index() - retrieves a pad index from an entity 675 * 676 * @entity: entity where the pads belong 677 * @is_sink: true if the pad is a sink, false if it is a source 678 * @sig_type: type of signal of the pad to be search 679 * 680 * This helper function finds the first pad index inside an entity that 681 * satisfies both @is_sink and @sig_type conditions. 682 * 683 * Return: 684 * 685 * On success, return the pad number. If the pad was not found or the media 686 * entity is a NULL pointer, return -EINVAL. 687 */ 688 int media_get_pad_index(struct media_entity *entity, bool is_sink, 689 enum media_pad_signal_type sig_type); 690 691 /** 692 * media_create_pad_link() - creates a link between two entities. 693 * 694 * @source: pointer to &media_entity of the source pad. 695 * @source_pad: number of the source pad in the pads array 696 * @sink: pointer to &media_entity of the sink pad. 697 * @sink_pad: number of the sink pad in the pads array. 698 * @flags: Link flags, as defined in 699 * :ref:`include/uapi/linux/media.h <media_header>` 700 * ( seek for ``MEDIA_LNK_FL_*``) 701 * 702 * Valid values for flags: 703 * 704 * %MEDIA_LNK_FL_ENABLED 705 * Indicates that the link is enabled and can be used to transfer media data. 706 * When two or more links target a sink pad, only one of them can be 707 * enabled at a time. 708 * 709 * %MEDIA_LNK_FL_IMMUTABLE 710 * Indicates that the link enabled state can't be modified at runtime. If 711 * %MEDIA_LNK_FL_IMMUTABLE is set, then %MEDIA_LNK_FL_ENABLED must also be 712 * set, since an immutable link is always enabled. 713 * 714 * .. note:: 715 * 716 * Before calling this function, media_entity_pads_init() and 717 * media_device_register_entity() should be called previously for both ends. 718 */ 719 __must_check int media_create_pad_link(struct media_entity *source, 720 u16 source_pad, struct media_entity *sink, 721 u16 sink_pad, u32 flags); 722 723 /** 724 * media_create_pad_links() - creates a link between two entities. 725 * 726 * @mdev: Pointer to the media_device that contains the object 727 * @source_function: Function of the source entities. Used only if @source is 728 * NULL. 729 * @source: pointer to &media_entity of the source pad. If NULL, it will use 730 * all entities that matches the @sink_function. 731 * @source_pad: number of the source pad in the pads array 732 * @sink_function: Function of the sink entities. Used only if @sink is NULL. 733 * @sink: pointer to &media_entity of the sink pad. If NULL, it will use 734 * all entities that matches the @sink_function. 735 * @sink_pad: number of the sink pad in the pads array. 736 * @flags: Link flags, as defined in include/uapi/linux/media.h. 737 * @allow_both_undefined: if %true, then both @source and @sink can be NULL. 738 * In such case, it will create a crossbar between all entities that 739 * matches @source_function to all entities that matches @sink_function. 740 * If %false, it will return 0 and won't create any link if both @source 741 * and @sink are NULL. 742 * 743 * Valid values for flags: 744 * 745 * A %MEDIA_LNK_FL_ENABLED flag indicates that the link is enabled and can be 746 * used to transfer media data. If multiple links are created and this 747 * flag is passed as an argument, only the first created link will have 748 * this flag. 749 * 750 * A %MEDIA_LNK_FL_IMMUTABLE flag indicates that the link enabled state can't 751 * be modified at runtime. If %MEDIA_LNK_FL_IMMUTABLE is set, then 752 * %MEDIA_LNK_FL_ENABLED must also be set since an immutable link is 753 * always enabled. 754 * 755 * It is common for some devices to have multiple source and/or sink entities 756 * of the same type that should be linked. While media_create_pad_link() 757 * creates link by link, this function is meant to allow 1:n, n:1 and even 758 * cross-bar (n:n) links. 759 * 760 * .. note:: 761 * 762 * Before calling this function, media_entity_pads_init() and 763 * media_device_register_entity() should be called previously for the 764 * entities to be linked. 765 */ 766 int media_create_pad_links(const struct media_device *mdev, 767 const u32 source_function, 768 struct media_entity *source, 769 const u16 source_pad, 770 const u32 sink_function, 771 struct media_entity *sink, 772 const u16 sink_pad, 773 u32 flags, 774 const bool allow_both_undefined); 775 776 void __media_entity_remove_links(struct media_entity *entity); 777 778 /** 779 * media_entity_remove_links() - remove all links associated with an entity 780 * 781 * @entity: pointer to &media_entity 782 * 783 * .. note:: 784 * 785 * This is called automatically when an entity is unregistered via 786 * media_device_register_entity(). 787 */ 788 void media_entity_remove_links(struct media_entity *entity); 789 790 /** 791 * __media_entity_setup_link - Configure a media link without locking 792 * @link: The link being configured 793 * @flags: Link configuration flags 794 * 795 * The bulk of link setup is handled by the two entities connected through the 796 * link. This function notifies both entities of the link configuration change. 797 * 798 * If the link is immutable or if the current and new configuration are 799 * identical, return immediately. 800 * 801 * The user is expected to hold link->source->parent->mutex. If not, 802 * media_entity_setup_link() should be used instead. 803 */ 804 int __media_entity_setup_link(struct media_link *link, u32 flags); 805 806 /** 807 * media_entity_setup_link() - changes the link flags properties in runtime 808 * 809 * @link: pointer to &media_link 810 * @flags: the requested new link flags 811 * 812 * The only configurable property is the %MEDIA_LNK_FL_ENABLED link flag 813 * flag to enable/disable a link. Links marked with the 814 * %MEDIA_LNK_FL_IMMUTABLE link flag can not be enabled or disabled. 815 * 816 * When a link is enabled or disabled, the media framework calls the 817 * link_setup operation for the two entities at the source and sink of the 818 * link, in that order. If the second link_setup call fails, another 819 * link_setup call is made on the first entity to restore the original link 820 * flags. 821 * 822 * Media device drivers can be notified of link setup operations by setting the 823 * &media_device.link_notify pointer to a callback function. If provided, the 824 * notification callback will be called before enabling and after disabling 825 * links. 826 * 827 * Entity drivers must implement the link_setup operation if any of their links 828 * is non-immutable. The operation must either configure the hardware or store 829 * the configuration information to be applied later. 830 * 831 * Link configuration must not have any side effect on other links. If an 832 * enabled link at a sink pad prevents another link at the same pad from 833 * being enabled, the link_setup operation must return %-EBUSY and can't 834 * implicitly disable the first enabled link. 835 * 836 * .. note:: 837 * 838 * The valid values of the flags for the link is the same as described 839 * on media_create_pad_link(), for pad to pad links or the same as described 840 * on media_create_intf_link(), for interface to entity links. 841 */ 842 int media_entity_setup_link(struct media_link *link, u32 flags); 843 844 /** 845 * media_entity_find_link - Find a link between two pads 846 * @source: Source pad 847 * @sink: Sink pad 848 * 849 * Return: returns a pointer to the link between the two entities. If no 850 * such link exists, return %NULL. 851 */ 852 struct media_link *media_entity_find_link(struct media_pad *source, 853 struct media_pad *sink); 854 855 /** 856 * media_entity_remote_pad - Find the pad at the remote end of a link 857 * @pad: Pad at the local end of the link 858 * 859 * Search for a remote pad connected to the given pad by iterating over all 860 * links originating or terminating at that pad until an enabled link is found. 861 * 862 * Return: returns a pointer to the pad at the remote end of the first found 863 * enabled link, or %NULL if no enabled link has been found. 864 */ 865 struct media_pad *media_entity_remote_pad(const struct media_pad *pad); 866 867 /** 868 * media_entity_get_fwnode_pad - Get pad number from fwnode 869 * 870 * @entity: The entity 871 * @fwnode: Pointer to the fwnode_handle which should be used to find the pad 872 * @direction_flags: Expected direction of the pad, as defined in 873 * :ref:`include/uapi/linux/media.h <media_header>` 874 * (seek for ``MEDIA_PAD_FL_*``) 875 * 876 * This function can be used to resolve the media pad number from 877 * a fwnode. This is useful for devices which use more complex 878 * mappings of media pads. 879 * 880 * If the entity does not implement the get_fwnode_pad() operation 881 * then this function searches the entity for the first pad that 882 * matches the @direction_flags. 883 * 884 * Return: returns the pad number on success or a negative error code. 885 */ 886 int media_entity_get_fwnode_pad(struct media_entity *entity, 887 struct fwnode_handle *fwnode, 888 unsigned long direction_flags); 889 890 /** 891 * media_graph_walk_init - Allocate resources used by graph walk. 892 * 893 * @graph: Media graph structure that will be used to walk the graph 894 * @mdev: Pointer to the &media_device that contains the object 895 */ 896 __must_check int media_graph_walk_init( 897 struct media_graph *graph, struct media_device *mdev); 898 899 /** 900 * media_graph_walk_cleanup - Release resources used by graph walk. 901 * 902 * @graph: Media graph structure that will be used to walk the graph 903 */ 904 void media_graph_walk_cleanup(struct media_graph *graph); 905 906 /** 907 * media_graph_walk_start - Start walking the media graph at a 908 * given entity 909 * 910 * @graph: Media graph structure that will be used to walk the graph 911 * @entity: Starting entity 912 * 913 * Before using this function, media_graph_walk_init() must be 914 * used to allocate resources used for walking the graph. This 915 * function initializes the graph traversal structure to walk the 916 * entities graph starting at the given entity. The traversal 917 * structure must not be modified by the caller during graph 918 * traversal. After the graph walk, the resources must be released 919 * using media_graph_walk_cleanup(). 920 */ 921 void media_graph_walk_start(struct media_graph *graph, 922 struct media_entity *entity); 923 924 /** 925 * media_graph_walk_next - Get the next entity in the graph 926 * @graph: Media graph structure 927 * 928 * Perform a depth-first traversal of the given media entities graph. 929 * 930 * The graph structure must have been previously initialized with a call to 931 * media_graph_walk_start(). 932 * 933 * Return: returns the next entity in the graph or %NULL if the whole graph 934 * have been traversed. 935 */ 936 struct media_entity *media_graph_walk_next(struct media_graph *graph); 937 938 /** 939 * media_pipeline_start - Mark a pipeline as streaming 940 * @entity: Starting entity 941 * @pipe: Media pipeline to be assigned to all entities in the pipeline. 942 * 943 * Mark all entities connected to a given entity through enabled links, either 944 * directly or indirectly, as streaming. The given pipeline object is assigned 945 * to every entity in the pipeline and stored in the media_entity pipe field. 946 * 947 * Calls to this function can be nested, in which case the same number of 948 * media_pipeline_stop() calls will be required to stop streaming. The 949 * pipeline pointer must be identical for all nested calls to 950 * media_pipeline_start(). 951 */ 952 __must_check int media_pipeline_start(struct media_entity *entity, 953 struct media_pipeline *pipe); 954 /** 955 * __media_pipeline_start - Mark a pipeline as streaming 956 * 957 * @entity: Starting entity 958 * @pipe: Media pipeline to be assigned to all entities in the pipeline. 959 * 960 * ..note:: This is the non-locking version of media_pipeline_start() 961 */ 962 __must_check int __media_pipeline_start(struct media_entity *entity, 963 struct media_pipeline *pipe); 964 965 /** 966 * media_pipeline_stop - Mark a pipeline as not streaming 967 * @entity: Starting entity 968 * 969 * Mark all entities connected to a given entity through enabled links, either 970 * directly or indirectly, as not streaming. The media_entity pipe field is 971 * reset to %NULL. 972 * 973 * If multiple calls to media_pipeline_start() have been made, the same 974 * number of calls to this function are required to mark the pipeline as not 975 * streaming. 976 */ 977 void media_pipeline_stop(struct media_entity *entity); 978 979 /** 980 * __media_pipeline_stop - Mark a pipeline as not streaming 981 * 982 * @entity: Starting entity 983 * 984 * .. note:: This is the non-locking version of media_pipeline_stop() 985 */ 986 void __media_pipeline_stop(struct media_entity *entity); 987 988 /** 989 * media_devnode_create() - creates and initializes a device node interface 990 * 991 * @mdev: pointer to struct &media_device 992 * @type: type of the interface, as given by 993 * :ref:`include/uapi/linux/media.h <media_header>` 994 * ( seek for ``MEDIA_INTF_T_*``) macros. 995 * @flags: Interface flags, as defined in 996 * :ref:`include/uapi/linux/media.h <media_header>` 997 * ( seek for ``MEDIA_INTF_FL_*``) 998 * @major: Device node major number. 999 * @minor: Device node minor number. 1000 * 1001 * Return: if succeeded, returns a pointer to the newly allocated 1002 * &media_intf_devnode pointer. 1003 * 1004 * .. note:: 1005 * 1006 * Currently, no flags for &media_interface is defined. 1007 */ 1008 struct media_intf_devnode * 1009 __must_check media_devnode_create(struct media_device *mdev, 1010 u32 type, u32 flags, 1011 u32 major, u32 minor); 1012 /** 1013 * media_devnode_remove() - removes a device node interface 1014 * 1015 * @devnode: pointer to &media_intf_devnode to be freed. 1016 * 1017 * When a device node interface is removed, all links to it are automatically 1018 * removed. 1019 */ 1020 void media_devnode_remove(struct media_intf_devnode *devnode); 1021 struct media_link * 1022 1023 /** 1024 * media_create_intf_link() - creates a link between an entity and an interface 1025 * 1026 * @entity: pointer to %media_entity 1027 * @intf: pointer to %media_interface 1028 * @flags: Link flags, as defined in 1029 * :ref:`include/uapi/linux/media.h <media_header>` 1030 * ( seek for ``MEDIA_LNK_FL_*``) 1031 * 1032 * 1033 * Valid values for flags: 1034 * 1035 * %MEDIA_LNK_FL_ENABLED 1036 * Indicates that the interface is connected to the entity hardware. 1037 * That's the default value for interfaces. An interface may be disabled if 1038 * the hardware is busy due to the usage of some other interface that it is 1039 * currently controlling the hardware. 1040 * 1041 * A typical example is an hybrid TV device that handle only one type of 1042 * stream on a given time. So, when the digital TV is streaming, 1043 * the V4L2 interfaces won't be enabled, as such device is not able to 1044 * also stream analog TV or radio. 1045 * 1046 * .. note:: 1047 * 1048 * Before calling this function, media_devnode_create() should be called for 1049 * the interface and media_device_register_entity() should be called for the 1050 * interface that will be part of the link. 1051 */ 1052 __must_check media_create_intf_link(struct media_entity *entity, 1053 struct media_interface *intf, 1054 u32 flags); 1055 /** 1056 * __media_remove_intf_link() - remove a single interface link 1057 * 1058 * @link: pointer to &media_link. 1059 * 1060 * .. note:: This is an unlocked version of media_remove_intf_link() 1061 */ 1062 void __media_remove_intf_link(struct media_link *link); 1063 1064 /** 1065 * media_remove_intf_link() - remove a single interface link 1066 * 1067 * @link: pointer to &media_link. 1068 * 1069 * .. note:: Prefer to use this one, instead of __media_remove_intf_link() 1070 */ 1071 void media_remove_intf_link(struct media_link *link); 1072 1073 /** 1074 * __media_remove_intf_links() - remove all links associated with an interface 1075 * 1076 * @intf: pointer to &media_interface 1077 * 1078 * .. note:: This is an unlocked version of media_remove_intf_links(). 1079 */ 1080 void __media_remove_intf_links(struct media_interface *intf); 1081 1082 /** 1083 * media_remove_intf_links() - remove all links associated with an interface 1084 * 1085 * @intf: pointer to &media_interface 1086 * 1087 * .. note:: 1088 * 1089 * #) This is called automatically when an entity is unregistered via 1090 * media_device_register_entity() and by media_devnode_remove(). 1091 * 1092 * #) Prefer to use this one, instead of __media_remove_intf_links(). 1093 */ 1094 void media_remove_intf_links(struct media_interface *intf); 1095 1096 /** 1097 * media_entity_call - Calls a struct media_entity_operations operation on 1098 * an entity 1099 * 1100 * @entity: entity where the @operation will be called 1101 * @operation: type of the operation. Should be the name of a member of 1102 * struct &media_entity_operations. 1103 * 1104 * This helper function will check if @operation is not %NULL. On such case, 1105 * it will issue a call to @operation\(@entity, @args\). 1106 */ 1107 1108 #define media_entity_call(entity, operation, args...) \ 1109 (((entity)->ops && (entity)->ops->operation) ? \ 1110 (entity)->ops->operation((entity) , ##args) : -ENOIOCTLCMD) 1111 1112 #endif 1113