diff options
Diffstat (limited to 'extras/recipes-kernel/linux/linux-omap/media/0010-media-Entities-pads-and-links.patch')
| -rw-r--r-- | extras/recipes-kernel/linux/linux-omap/media/0010-media-Entities-pads-and-links.patch | 690 |
1 files changed, 690 insertions, 0 deletions
diff --git a/extras/recipes-kernel/linux/linux-omap/media/0010-media-Entities-pads-and-links.patch b/extras/recipes-kernel/linux/linux-omap/media/0010-media-Entities-pads-and-links.patch new file mode 100644 index 00000000..be762331 --- /dev/null +++ b/extras/recipes-kernel/linux/linux-omap/media/0010-media-Entities-pads-and-links.patch @@ -0,0 +1,690 @@ +From b4697e5a8ad1e564ea378d435c2ce190318c1027 Mon Sep 17 00:00:00 2001 +From: Laurent Pinchart <laurent.pinchart@ideasonboard.com> +Date: Wed, 9 Dec 2009 12:40:00 +0100 +Subject: [PATCH 10/43] media: Entities, pads and links + +As video hardware pipelines become increasingly complex and +configurable, the current hardware description through v4l2 subdevices +reaches its limits. In addition to enumerating and configuring +subdevices, video camera drivers need a way to discover and modify at +runtime how those subdevices are connected. This is done through new +elements called entities, pads and links. + +An entity is a basic media hardware building block. It can correspond to +a large variety of logical blocks such as physical hardware devices +(CMOS sensor for instance), logical hardware devices (a building block +in a System-on-Chip image processing pipeline), DMA channels or physical +connectors. + +A pad is a connection endpoint through which an entity can interact with +other entities. Data (not restricted to video) produced by an entity +flows from the entity's output to one or more entity inputs. Pads should +not be confused with physical pins at chip boundaries. + +A link is a point-to-point oriented connection between two pads, either +on the same entity or on different entities. Data flows from a source +pad to a sink pad. + +Links are stored in the source entity. To make backwards graph walk +faster, a copy of all links is also stored in the sink entity. The copy +is known as a backlink and is only used to help graph traversal. + +The entity API is made of three functions: + +- media_entity_init() initializes an entity. The caller must provide an +array of pads as well as an estimated number of links. The links array +is allocated dynamically and will be reallocated if it grows beyond the +initial estimate. + +- media_entity_cleanup() frees resources allocated for an entity. It +must be called during the cleanup phase after unregistering the entity +and before freeing it. + +- media_entity_create_link() creates a link between two entities. An +entry in the link array of each entity is allocated and stores pointers +to source and sink pads. + +When a media device is unregistered, all its entities are unregistered +automatically. + +The code is based on Hans Verkuil <hverkuil@xs4all.nl> initial work. + +Signed-off-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com> +Signed-off-by: Sakari Ailus <sakari.ailus@maxwell.research.nokia.com> +--- + Documentation/DocBook/v4l/media-controller.xml | 20 +++ + Documentation/media-framework.txt | 151 ++++++++++++++++++++++++ + drivers/media/Makefile | 2 +- + drivers/media/media-device.c | 56 +++++++++ + drivers/media/media-entity.c | 147 +++++++++++++++++++++++ + include/media/media-device.h | 19 +++ + include/media/media-entity.h | 122 +++++++++++++++++++ + 7 files changed, 516 insertions(+), 1 deletions(-) + create mode 100644 drivers/media/media-entity.c + create mode 100644 include/media/media-entity.h + +diff --git a/Documentation/DocBook/v4l/media-controller.xml b/Documentation/DocBook/v4l/media-controller.xml +index 253ddb4..f89228d 100644 +--- a/Documentation/DocBook/v4l/media-controller.xml ++++ b/Documentation/DocBook/v4l/media-controller.xml +@@ -53,4 +53,24 @@ + implementing policies that belong to userspace.</para> + <para>The media controller API aims at solving those problems.</para> + </section> ++ ++ <section id="media-controller-model"> ++ <title>Media device model</title> ++ <para>Discovering a device internal topology, and configuring it at runtime, ++ is one of the goals of the media controller API. To achieve this, hardware ++ devices are modelled as an oriented graph of building blocks called entities ++ connected through pads.</para> ++ <para>An entity is a basic media hardware or software building block. It can ++ correspond to a large variety of logical blocks such as physical hardware ++ devices (CMOS sensor for instance), logical hardware devices (a building ++ block in a System-on-Chip image processing pipeline), DMA channels or ++ physical connectors.</para> ++ <para>A pad is a connection endpoint through which an entity can interact ++ with other entities. Data (not restricted to video) produced by an entity ++ flows from the entity's output to one or more entity inputs. Pads should not ++ be confused with physical pins at chip boundaries.</para> ++ <para>A link is a point-to-point oriented connection between two pads, ++ either on the same entity or on different entities. Data flows from a source ++ pad to a sink pad.</para> ++ </section> + </chapter> +diff --git a/Documentation/media-framework.txt b/Documentation/media-framework.txt +index 1844c3f..b252cf9 100644 +--- a/Documentation/media-framework.txt ++++ b/Documentation/media-framework.txt +@@ -13,6 +13,30 @@ Documentation/DocBook/v4l/media-controller.xml. This document will focus on + the kernel-side implementation of the media framework. + + ++Abstract media device model ++--------------------------- ++ ++Discovering a device internal topology, and configuring it at runtime, is one ++of the goals of the media framework. To achieve this, hardware devices are ++modeled as an oriented graph of building blocks called entities connected ++through pads. ++ ++An entity is a basic media hardware building block. It can correspond to ++a large variety of logical blocks such as physical hardware devices ++(CMOS sensor for instance), logical hardware devices (a building block ++in a System-on-Chip image processing pipeline), DMA channels or physical ++connectors. ++ ++A pad is a connection endpoint through which an entity can interact with ++other entities. Data (not restricted to video) produced by an entity ++flows from the entity's output to one or more entity inputs. Pads should ++not be confused with physical pins at chip boundaries. ++ ++A link is a point-to-point oriented connection between two pads, either ++on the same entity or on different entities. Data flows from a source ++pad to a sink pad. ++ ++ + Media device + ------------ + +@@ -65,3 +89,130 @@ Drivers unregister media device instances by calling + media_device_unregister(struct media_device *mdev); + + Unregistering a media device that hasn't been registered is *NOT* safe. ++ ++ ++Entities, pads and links ++------------------------ ++ ++- Entities ++ ++Entities are represented by a struct media_entity instance, defined in ++include/media/media-entity.h. The structure is usually embedded into a ++higher-level structure, such as a v4l2_subdev or video_device instance, ++although drivers can allocate entities directly. ++ ++Drivers initialize entities by calling ++ ++ media_entity_init(struct media_entity *entity, u16 num_pads, ++ struct media_pad *pads, u16 extra_links); ++ ++The media_entity name, type, flags, revision and group_id fields can be ++initialized before or after calling media_entity_init. Entities embedded in ++higher-level standard structures can have some of those fields set by the ++higher-level framework. ++ ++As the number of pads is known in advance, the pads array is not allocated ++dynamically but is managed by the entity driver. Most drivers will embed the ++pads array in a driver-specific structure, avoiding dynamic allocation. ++ ++Drivers must set the direction of every pad in the pads array before calling ++media_entity_init. The function will initialize the other pads fields. ++ ++Unlike the number of pads, the total number of links isn't always known in ++advance by the entity driver. As an initial estimate, media_entity_init ++pre-allocates a number of links equal to the number of pads plus an optional ++number of extra links. The links array will be reallocated if it grows beyond ++the initial estimate. ++ ++Drivers register entities with a media device by calling ++ ++ media_device_register_entity(struct media_device *mdev, ++ struct media_entity *entity); ++ ++Entities are identified by a unique positive integer ID. Drivers can provide an ++ID by filling the media_entity id field prior to registration, or request the ++media controller framework to assign an ID automatically. Drivers that provide ++IDs manually must ensure that all IDs are unique. IDs are not guaranteed to be ++contiguous even when they are all assigned automatically by the framework. ++ ++Drivers unregister entities by calling ++ ++ media_device_unregister_entity(struct media_entity *entity); ++ ++Unregistering an entity will not change the IDs of the other entities, and the ++ID will never be reused for a newly registered entity. ++ ++When a media device is unregistered, all its entities are unregistered ++automatically. No manual entities unregistration is then required. ++ ++Drivers free resources associated with an entity by calling ++ ++ media_entity_cleanup(struct media_entity *entity); ++ ++This function must be called during the cleanup phase after unregistering the ++entity. Note that the media_entity instance itself must be freed explicitly by ++the driver if required. ++ ++Entities have flags that describe the entity capabilities and state. ++ ++ MEDIA_ENT_FL_DEFAULT indicates the default entity for a given type. ++ This can be used to report the default audio and video devices or the ++ default camera sensor. ++ ++Logical entity groups can be defined by setting the group ID of all member ++entities to the same non-zero value. An entity group serves no purpose in the ++kernel, but is reported to userspace during entities enumeration. The group_id ++field belongs to the media device driver and must not by touched by entity ++drivers. ++ ++Media device drivers should define groups if several entities are logically ++bound together. Example usages include reporting ++ ++ - ALSA, VBI and video nodes that carry the same media stream ++ - lens and flash controllers associated with a sensor ++ ++- Pads ++ ++Pads are represented by a struct media_pad instance, defined in ++include/media/media-entity.h. Each entity stores its pads in a pads array ++managed by the entity driver. Drivers usually embed the array in a ++driver-specific structure. ++ ++Pads are identified by their entity and their 0-based index in the pads array. ++Both information are stored in the media_pad structure, making the media_pad ++pointer the canonical way to store and pass link references. ++ ++Pads have flags that describe the pad capabilities and state. ++ ++ MEDIA_PAD_FL_INPUT indicates that the pad supports sinking data. ++ MEDIA_PAD_FL_OUTPUT indicates that the pad supports sourcing data. ++ ++One and only one of MEDIA_PAD_FL_INPUT and MEDIA_PAD_FL_OUTPUT must be set for ++each pad. ++ ++- Links ++ ++Links are represented by a struct media_link instance, defined in ++include/media/media-entity.h. Each entity stores all links originating at or ++targetting any of its pads in a links array. A given link is thus stored ++twice, once in the source entity and once in the target entity. The array is ++pre-allocated and grows dynamically as needed. ++ ++Drivers create links by calling ++ ++ media_entity_create_link(struct media_entity *source, u16 source_pad, ++ struct media_entity *sink, u16 sink_pad, ++ u32 flags); ++ ++An entry in the link array of each entity is allocated and stores pointers ++to source and sink pads. ++ ++Links have flags that describe the link capabilities and state. ++ ++ MEDIA_LNK_FL_ENABLED indicates that the link is enabled and can be used ++ to transfer media data. When two or more links target a sink pad, only ++ one of them can be enabled at a time. ++ MEDIA_LNK_FL_IMMUTABLE indicates that the link enabled state can't be ++ modified at runtime. If MEDIA_LNK_FL_IMMUTABLE is set, then ++ MEDIA_LNK_FL_ENABLED must also be set since an immutable link is always ++ enabled. +diff --git a/drivers/media/Makefile b/drivers/media/Makefile +index 019d3e0..b890248 100644 +--- a/drivers/media/Makefile ++++ b/drivers/media/Makefile +@@ -2,7 +2,7 @@ + # Makefile for the kernel multimedia device drivers. + # + +-media-objs := media-device.o media-devnode.o ++media-objs := media-device.o media-devnode.o media-entity.o + + ifeq ($(CONFIG_MEDIA_CONTROLLER),y) + obj-$(CONFIG_MEDIA_SUPPORT) += media.o +diff --git a/drivers/media/media-device.c b/drivers/media/media-device.c +index 57a9c6b..b8a3ace 100644 +--- a/drivers/media/media-device.c ++++ b/drivers/media/media-device.c +@@ -25,6 +25,7 @@ + + #include <media/media-device.h> + #include <media/media-devnode.h> ++#include <media/media-entity.h> + + static const struct media_file_operations media_device_fops = { + .owner = THIS_MODULE, +@@ -69,6 +70,10 @@ int __must_check media_device_register(struct media_device *mdev) + if (WARN_ON(mdev->dev == NULL || mdev->model[0] == 0)) + return -EINVAL; + ++ mdev->entity_id = 1; ++ INIT_LIST_HEAD(&mdev->entities); ++ spin_lock_init(&mdev->lock); ++ + /* Register the device node. */ + mdev->devnode.fops = &media_device_fops; + mdev->devnode.parent = mdev->dev; +@@ -94,7 +99,58 @@ EXPORT_SYMBOL_GPL(media_device_register); + */ + void media_device_unregister(struct media_device *mdev) + { ++ struct media_entity *entity; ++ struct media_entity *next; ++ ++ list_for_each_entry_safe(entity, next, &mdev->entities, list) ++ media_device_unregister_entity(entity); ++ + device_remove_file(&mdev->devnode.dev, &dev_attr_model); + media_devnode_unregister(&mdev->devnode); + } + EXPORT_SYMBOL_GPL(media_device_unregister); ++ ++/** ++ * media_device_register_entity - Register an entity with a media device ++ * @mdev: The media device ++ * @entity: The entity ++ */ ++int __must_check media_device_register_entity(struct media_device *mdev, ++ struct media_entity *entity) ++{ ++ /* Warn if we apparently re-register an entity */ ++ WARN_ON(entity->parent != NULL); ++ entity->parent = mdev; ++ ++ spin_lock(&mdev->lock); ++ if (entity->id == 0) ++ entity->id = mdev->entity_id++; ++ else ++ mdev->entity_id = max(entity->id + 1, mdev->entity_id); ++ list_add_tail(&entity->list, &mdev->entities); ++ spin_unlock(&mdev->lock); ++ ++ return 0; ++} ++EXPORT_SYMBOL_GPL(media_device_register_entity); ++ ++/** ++ * media_device_unregister_entity - Unregister an entity ++ * @entity: The entity ++ * ++ * If the entity has never been registered this function will return ++ * immediately. ++ */ ++void media_device_unregister_entity(struct media_entity *entity) ++{ ++ struct media_device *mdev = entity->parent; ++ ++ if (mdev == NULL) ++ return; ++ ++ spin_lock(&mdev->lock); ++ list_del(&entity->list); ++ spin_unlock(&mdev->lock); ++ entity->parent = NULL; ++} ++EXPORT_SYMBOL_GPL(media_device_unregister_entity); +diff --git a/drivers/media/media-entity.c b/drivers/media/media-entity.c +new file mode 100644 +index 0000000..e4ba2bc +--- /dev/null ++++ b/drivers/media/media-entity.c +@@ -0,0 +1,147 @@ ++/* ++ * Media entity ++ * ++ * Copyright (C) 2010 Nokia Corporation ++ * ++ * Contacts: Laurent Pinchart <laurent.pinchart@ideasonboard.com> ++ * Sakari Ailus <sakari.ailus@maxwell.research.nokia.com> ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA ++ */ ++ ++#include <linux/module.h> ++#include <linux/slab.h> ++#include <media/media-entity.h> ++ ++/** ++ * media_entity_init - Initialize a media entity ++ * ++ * @num_pads: Total number of input and output pads. ++ * @extra_links: Initial estimate of the number of extra links. ++ * @pads: Array of 'num_pads' pads. ++ * ++ * The total number of pads is an intrinsic property of entities known by the ++ * entity driver, while the total number of links depends on hardware design ++ * and is an extrinsic property unknown to the entity driver. However, in most ++ * use cases the entity driver can guess the number of links which can safely ++ * be assumed to be equal to or larger than the number of pads. ++ * ++ * For those reasons the links array can be preallocated based on the entity ++ * driver guess and will be reallocated later if extra links need to be ++ * created. ++ * ++ * This function allocates a links array with enough space to hold at least ++ * 'num_pads' + 'extra_links' elements. The media_entity::max_links field will ++ * be set to the number of allocated elements. ++ * ++ * The pads array is managed by the entity driver and passed to ++ * media_entity_init() where its pointer will be stored in the entity structure. ++ */ ++int ++media_entity_init(struct media_entity *entity, u16 num_pads, ++ struct media_pad *pads, u16 extra_links) ++{ ++ struct media_link *links; ++ unsigned int max_links = num_pads + extra_links; ++ unsigned int i; ++ ++ links = kzalloc(max_links * sizeof(links[0]), GFP_KERNEL); ++ if (links == NULL) ++ return -ENOMEM; ++ ++ entity->group_id = 0; ++ entity->max_links = max_links; ++ entity->num_links = 0; ++ entity->num_backlinks = 0; ++ entity->num_pads = num_pads; ++ entity->pads = pads; ++ entity->links = links; ++ ++ for (i = 0; i < num_pads; i++) { ++ pads[i].entity = entity; ++ pads[i].index = i; ++ } ++ ++ return 0; ++} ++EXPORT_SYMBOL_GPL(media_entity_init); ++ ++void ++media_entity_cleanup(struct media_entity *entity) ++{ ++ kfree(entity->links); ++} ++EXPORT_SYMBOL_GPL(media_entity_cleanup); ++ ++static struct media_link *media_entity_add_link(struct media_entity *entity) ++{ ++ if (entity->num_links >= entity->max_links) { ++ struct media_link *links = entity->links; ++ unsigned int max_links = entity->max_links + 2; ++ unsigned int i; ++ ++ links = krealloc(links, max_links * sizeof(*links), GFP_KERNEL); ++ if (links == NULL) ++ return NULL; ++ ++ for (i = 0; i < entity->num_links; i++) ++ links[i].reverse->reverse = &links[i]; ++ ++ entity->max_links = max_links; ++ entity->links = links; ++ } ++ ++ return &entity->links[entity->num_links++]; ++} ++ ++int ++media_entity_create_link(struct media_entity *source, u16 source_pad, ++ struct media_entity *sink, u16 sink_pad, u32 flags) ++{ ++ struct media_link *link; ++ struct media_link *backlink; ++ ++ BUG_ON(source == NULL || sink == NULL); ++ BUG_ON(source_pad >= source->num_pads); ++ BUG_ON(sink_pad >= sink->num_pads); ++ ++ link = media_entity_add_link(source); ++ if (link == NULL) ++ return -ENOMEM; ++ ++ link->source = &source->pads[source_pad]; ++ link->sink = &sink->pads[sink_pad]; ++ link->flags = flags; ++ ++ /* Create the backlink. Backlinks are used to help graph traversal and ++ * are not reported to userspace. ++ */ ++ backlink = media_entity_add_link(sink); ++ if (backlink == NULL) { ++ source->num_links--; ++ return -ENOMEM; ++ } ++ ++ backlink->source = &source->pads[source_pad]; ++ backlink->sink = &sink->pads[sink_pad]; ++ backlink->flags = flags; ++ ++ link->reverse = backlink; ++ backlink->reverse = link; ++ ++ sink->num_backlinks++; ++ ++ return 0; ++} ++EXPORT_SYMBOL_GPL(media_entity_create_link); +diff --git a/include/media/media-device.h b/include/media/media-device.h +index e11f01a..0b1ecf5 100644 +--- a/include/media/media-device.h ++++ b/include/media/media-device.h +@@ -25,8 +25,10 @@ + + #include <linux/device.h> + #include <linux/list.h> ++#include <linux/spinlock.h> + + #include <media/media-devnode.h> ++#include <media/media-entity.h> + + /** + * struct media_device - Media device +@@ -37,6 +39,9 @@ + * @bus_info: Unique and stable device location identifier + * @hw_revision: Hardware device revision + * @driver_version: Device driver version ++ * @entity_id: ID of the next entity to be registered ++ * @entities: List of registered entities ++ * @lock: Entities list lock + * + * This structure represents an abstract high-level media device. It allows easy + * access to entities and provides basic media device-level support. The +@@ -58,6 +63,12 @@ struct media_device { + char bus_info[32]; + u32 hw_revision; + u32 driver_version; ++ ++ u32 entity_id; ++ struct list_head entities; ++ ++ /* Protects the entities list */ ++ spinlock_t lock; + }; + + /* media_devnode to media_device */ +@@ -66,4 +77,12 @@ struct media_device { + int __must_check media_device_register(struct media_device *mdev); + void media_device_unregister(struct media_device *mdev); + ++int __must_check media_device_register_entity(struct media_device *mdev, ++ struct media_entity *entity); ++void media_device_unregister_entity(struct media_entity *entity); ++ ++/* Iterate over all entities. */ ++#define media_device_for_each_entity(entity, mdev) \ ++ list_for_each_entry(entity, &(mdev)->entities, list) ++ + #endif +diff --git a/include/media/media-entity.h b/include/media/media-entity.h +new file mode 100644 +index 0000000..7cf9135 +--- /dev/null ++++ b/include/media/media-entity.h +@@ -0,0 +1,122 @@ ++/* ++ * Media entity ++ * ++ * Copyright (C) 2010 Nokia Corporation ++ * ++ * Contacts: Laurent Pinchart <laurent.pinchart@ideasonboard.com> ++ * Sakari Ailus <sakari.ailus@maxwell.research.nokia.com> ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA ++ */ ++ ++#ifndef _MEDIA_ENTITY_H ++#define _MEDIA_ENTITY_H ++ ++#include <linux/list.h> ++ ++#define MEDIA_ENT_TYPE_SHIFT 16 ++#define MEDIA_ENT_TYPE_MASK 0x00ff0000 ++#define MEDIA_ENT_SUBTYPE_MASK 0x0000ffff ++ ++#define MEDIA_ENT_T_DEVNODE (1 << MEDIA_ENTITY_TYPE_SHIFT) ++#define MEDIA_ENT_T_DEVNODE_V4L (MEDIA_ENTITY_T_DEVNODE + 1) ++#define MEDIA_ENT_T_DEVNODE_FB (MEDIA_ENTITY_T_DEVNODE + 2) ++#define MEDIA_ENT_T_DEVNODE_ALSA (MEDIA_ENTITY_T_DEVNODE + 3) ++#define MEDIA_ENT_T_DEVNODE_DVB (MEDIA_ENTITY_T_DEVNODE + 4) ++ ++#define MEDIA_ENT_T_V4L2_SUBDEV (2 << MEDIA_ENTITY_TYPE_SHIFT) ++#define MEDIA_ENT_T_V4L2_SUBDEV_SENSOR (MEDIA_ENTITY_T_V4L2_SUBDEV + 1) ++#define MEDIA_ENT_T_V4L2_SUBDEV_FLASH (MEDIA_ENTITY_T_V4L2_SUBDEV + 2) ++#define MEDIA_ENT_T_V4L2_SUBDEV_LENS (MEDIA_ENTITY_T_V4L2_SUBDEV + 3) ++ ++#define MEDIA_ENT_FL_DEFAULT (1 << 0) ++ ++#define MEDIA_LNK_FL_ENABLED (1 << 0) ++#define MEDIA_LNK_FL_IMMUTABLE (1 << 1) ++ ++#define MEDIA_PAD_FL_INPUT (1 << 0) ++#define MEDIA_PAD_FL_OUTPUT (1 << 1) ++ ++struct media_link { ++ struct media_pad *source; /* Source pad */ ++ struct media_pad *sink; /* Sink pad */ ++ struct media_link *reverse; /* Link in the reverse direction */ ++ unsigned long flags; /* Link flags (MEDIA_LNK_FL_*) */ ++}; ++ ++struct media_pad { ++ struct media_entity *entity; /* Entity this pad belongs to */ ++ u16 index; /* Pad index in the entity pads array */ ++ unsigned long flags; /* Pad flags (MEDIA_PAD_FL_*) */ ++}; ++ ++struct media_entity { ++ struct list_head list; ++ struct media_device *parent; /* Media device this entity belongs to*/ ++ u32 id; /* Entity ID, unique in the parent media ++ * device context */ ++ const char *name; /* Entity name */ ++ u32 type; /* Entity type (MEDIA_ENT_T_*) */ ++ u32 revision; /* Entity revision, driver specific */ ++ unsigned long flags; /* Entity flags (MEDIA_ENT_FL_*) */ ++ u32 group_id; /* Entity group ID */ ++ ++ u16 num_pads; /* Number of input and output pads */ ++ u16 num_links; /* Number of existing links, both ++ * enabled and disabled */ ++ u16 num_backlinks; /* Number of backlinks */ ++ u16 max_links; /* Maximum number of links */ ++ ++ struct media_pad *pads; /* Pads array (num_pads elements) */ ++ struct media_link *links; /* Links array (max_links elements)*/ ++ ++ union { ++ /* Node specifications */ ++ struct { ++ u32 major; ++ u32 minor; ++ } v4l; ++ struct { ++ u32 major; ++ u32 minor; ++ } fb; ++ struct { ++ u32 card; ++ u32 device; ++ u32 subdevice; ++ } alsa; ++ int dvb; ++ ++ /* Sub-device specifications */ ++ /* Nothing needed yet */ ++ }; ++}; ++ ++static inline u32 media_entity_type(struct media_entity *entity) ++{ ++ return entity->type & MEDIA_ENT_TYPE_MASK; ++} ++ ++static inline u32 media_entity_subtype(struct media_entity *entity) ++{ ++ return entity->type & MEDIA_ENT_SUBTYPE_MASK; ++} ++ ++int media_entity_init(struct media_entity *entity, u16 num_pads, ++ struct media_pad *pads, u16 extra_links); ++void media_entity_cleanup(struct media_entity *entity); ++int media_entity_create_link(struct media_entity *source, u16 source_pad, ++ struct media_entity *sink, u16 sink_pad, u32 flags); ++ ++#endif +-- +1.6.6.1 + |