2009-12-09 18:40:00 +07:00
|
|
|
/*
|
|
|
|
* Media entity
|
|
|
|
*
|
|
|
|
* Copyright (C) 2010 Nokia Corporation
|
|
|
|
*
|
|
|
|
* Contacts: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
|
|
|
|
* Sakari Ailus <sakari.ailus@iki.fi>
|
|
|
|
*
|
|
|
|
* 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
|
|
|
|
|
2015-12-16 20:44:32 +07:00
|
|
|
#include <linux/bitmap.h>
|
2016-02-15 18:08:06 +07:00
|
|
|
#include <linux/bug.h>
|
2013-12-13 18:58:37 +07:00
|
|
|
#include <linux/kernel.h>
|
2009-12-09 18:40:00 +07:00
|
|
|
#include <linux/list.h>
|
2009-12-09 18:40:01 +07:00
|
|
|
#include <linux/media.h>
|
2009-12-09 18:40:00 +07:00
|
|
|
|
2015-08-25 20:28:36 +07:00
|
|
|
/* Enums used internally at the media controller to represent graphs */
|
|
|
|
|
|
|
|
/**
|
|
|
|
* enum media_gobj_type - type of a graph object
|
|
|
|
*
|
2015-08-14 22:47:48 +07:00
|
|
|
* @MEDIA_GRAPH_ENTITY: Identify a media entity
|
2015-08-14 22:50:08 +07:00
|
|
|
* @MEDIA_GRAPH_PAD: Identify a media pad
|
2015-08-14 22:54:36 +07:00
|
|
|
* @MEDIA_GRAPH_LINK: Identify a media link
|
2015-08-20 19:07:34 +07:00
|
|
|
* @MEDIA_GRAPH_INTF_DEVNODE: Identify a media Kernel API interface via
|
|
|
|
* a device node
|
2015-08-25 20:28:36 +07:00
|
|
|
*/
|
|
|
|
enum media_gobj_type {
|
2015-08-14 22:47:48 +07:00
|
|
|
MEDIA_GRAPH_ENTITY,
|
2015-08-14 22:50:08 +07:00
|
|
|
MEDIA_GRAPH_PAD,
|
2015-08-14 22:54:36 +07:00
|
|
|
MEDIA_GRAPH_LINK,
|
2015-08-20 19:07:34 +07:00
|
|
|
MEDIA_GRAPH_INTF_DEVNODE,
|
2015-08-25 20:28:36 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
#define MEDIA_BITS_PER_TYPE 8
|
2015-12-16 23:28:01 +07:00
|
|
|
#define MEDIA_BITS_PER_ID (32 - MEDIA_BITS_PER_TYPE)
|
|
|
|
#define MEDIA_ID_MASK GENMASK_ULL(MEDIA_BITS_PER_ID - 1, 0)
|
2015-08-25 20:28:36 +07:00
|
|
|
|
|
|
|
/* Structs to represent the objects that belong to a media graph */
|
|
|
|
|
|
|
|
/**
|
|
|
|
* struct media_gobj - Define a graph object.
|
|
|
|
*
|
2015-08-30 09:43:03 +07:00
|
|
|
* @mdev: Pointer to the struct media_device that owns the object
|
2015-08-25 20:28:36 +07:00
|
|
|
* @id: Non-zero object ID identifier. The ID should be unique
|
|
|
|
* inside a media_device, as it is composed by
|
2015-12-16 23:28:01 +07:00
|
|
|
* %MEDIA_BITS_PER_TYPE to store the type plus
|
|
|
|
* %MEDIA_BITS_PER_ID to store the ID
|
2015-08-30 09:43:03 +07:00
|
|
|
* @list: List entry stored in one of the per-type mdev object lists
|
2015-08-25 20:28:36 +07:00
|
|
|
*
|
|
|
|
* All objects on the media graph should have this struct embedded
|
|
|
|
*/
|
|
|
|
struct media_gobj {
|
2015-08-14 00:42:42 +07:00
|
|
|
struct media_device *mdev;
|
2015-08-25 20:28:36 +07:00
|
|
|
u32 id;
|
2015-08-23 17:51:33 +07:00
|
|
|
struct list_head list;
|
2015-08-25 20:28:36 +07:00
|
|
|
};
|
|
|
|
|
2015-12-16 20:44:32 +07:00
|
|
|
#define MEDIA_ENTITY_ENUM_MAX_DEPTH 16
|
|
|
|
|
|
|
|
/**
|
|
|
|
* struct media_entity_enum - An enumeration of media entities.
|
|
|
|
*
|
|
|
|
* @bmap: Bit map in which each bit represents one entity at struct
|
|
|
|
* media_entity->internal_idx.
|
|
|
|
* @idx_max: Number of bits in bmap
|
|
|
|
*/
|
|
|
|
struct media_entity_enum {
|
|
|
|
unsigned long *bmap;
|
|
|
|
int idx_max;
|
|
|
|
};
|
|
|
|
|
2015-12-16 20:32:20 +07:00
|
|
|
/**
|
|
|
|
* struct media_entity_graph - Media graph traversal state
|
|
|
|
*
|
|
|
|
* @stack: Graph traversal stack; the stack contains information
|
|
|
|
* on the path the media entities to be walked and the
|
|
|
|
* links through which they were reached.
|
2015-12-16 20:32:28 +07:00
|
|
|
* @ent_enum: Visited entities
|
2015-12-16 20:32:20 +07:00
|
|
|
* @top: The top of the stack
|
|
|
|
*/
|
2015-12-16 20:32:19 +07:00
|
|
|
struct media_entity_graph {
|
|
|
|
struct {
|
|
|
|
struct media_entity *entity;
|
|
|
|
struct list_head *link;
|
|
|
|
} stack[MEDIA_ENTITY_ENUM_MAX_DEPTH];
|
|
|
|
|
2015-12-16 20:32:28 +07:00
|
|
|
struct media_entity_enum ent_enum;
|
2015-12-16 20:32:19 +07:00
|
|
|
int top;
|
|
|
|
};
|
|
|
|
|
2016-07-17 19:18:03 +07:00
|
|
|
/**
|
2015-12-16 20:32:21 +07:00
|
|
|
* struct media_pipeline - Media pipeline related information
|
|
|
|
*
|
2015-12-16 20:32:29 +07:00
|
|
|
* @streaming_count: Streaming start count - streaming stop count
|
|
|
|
* @graph: Media graph walk during pipeline start / stop
|
2015-12-16 20:32:21 +07:00
|
|
|
*/
|
2010-08-25 19:00:41 +07:00
|
|
|
struct media_pipeline {
|
2015-12-16 20:32:29 +07:00
|
|
|
int streaming_count;
|
2015-12-16 20:32:21 +07:00
|
|
|
struct media_entity_graph graph;
|
2010-08-25 19:00:41 +07:00
|
|
|
};
|
|
|
|
|
2015-08-30 09:43:03 +07:00
|
|
|
/**
|
|
|
|
* struct media_link - A link object part of a media graph.
|
|
|
|
*
|
|
|
|
* @graph_obj: Embedded structure containing the media object common data
|
|
|
|
* @list: Linked list associated with an entity or an interface that
|
|
|
|
* owns the link.
|
|
|
|
* @gobj0: Part of a union. Used to get the pointer for the first
|
|
|
|
* graph_object of the link.
|
|
|
|
* @source: Part of a union. Used only if the first object (gobj0) is
|
|
|
|
* a pad. In that case, it represents the source pad.
|
|
|
|
* @intf: Part of a union. Used only if the first object (gobj0) is
|
|
|
|
* an interface.
|
|
|
|
* @gobj1: Part of a union. Used to get the pointer for the second
|
|
|
|
* graph_object of the link.
|
|
|
|
* @source: Part of a union. Used only if the second object (gobj1) is
|
|
|
|
* a pad. In that case, it represents the sink pad.
|
|
|
|
* @entity: Part of a union. Used only if the second object (gobj1) is
|
|
|
|
* an entity.
|
|
|
|
* @reverse: Pointer to the link for the reverse direction of a pad to pad
|
|
|
|
* link.
|
|
|
|
* @flags: Link flags, as defined in uapi/media.h (MEDIA_LNK_FL_*)
|
2015-08-30 19:53:57 +07:00
|
|
|
* @is_backlink: Indicate if the link is a backlink.
|
2015-08-30 09:43:03 +07:00
|
|
|
*/
|
2009-12-09 18:40:00 +07:00
|
|
|
struct media_link {
|
2015-08-14 22:54:36 +07:00
|
|
|
struct media_gobj graph_obj;
|
[media] media: convert links from array to list
The entire logic that represent graph links were developed on a
time where there were no needs to dynamic remove links. So,
although links are created/removed one by one via some
functions, they're stored as an array inside the entity struct.
As the array may grow, there's a logic inside the code that
checks if the amount of space is not enough to store
the needed links. If it isn't the core uses krealloc()
to change the size of the link, with is bad, as it
leaves the memory fragmented.
So, convert links into a list.
Also, currently, both source and sink entities need the link
at the graph traversal logic inside media_entity. So there's
a logic duplicating all links. That makes it to spend
twice the memory needed. This is not a big deal for today's
usage, where the number of links are not big.
Yet, if during the MC workshop discussions, it was said that
IIO graphs could have up to 4,000 entities. So, we may
want to remove the duplication on some future. The problem
is that it would require a separate linked list to store
the backlinks inside the entity, or to use a more complex
algorithm to do graph backlink traversal, with is something
that the current graph traversal inside the core can't cope
with. So, let's postpone a such change if/when it is actually
needed.
It should also be noticed that the media_link structure uses
44 bytes on 32-bit architectures and 84 bytes on 64-bit
architecture. It will thus be allocated out of the 64-bytes and
96-bytes pools respectively. That's a 12.5% memory waste on
64-bit architectures and 31.25% on 32-bit architecture.
A linked list is less efficient than an array in this case, but
this could later be optimized if we can get rid of the reverse
links (with would reduce memory allocation by 50%).
Signed-off-by: Mauro Carvalho Chehab <mchehab@osg.samsung.com>
2015-08-07 16:55:40 +07:00
|
|
|
struct list_head list;
|
2015-08-20 19:10:07 +07:00
|
|
|
union {
|
|
|
|
struct media_gobj *gobj0;
|
|
|
|
struct media_pad *source;
|
2015-08-07 20:36:25 +07:00
|
|
|
struct media_interface *intf;
|
2015-08-20 19:10:07 +07:00
|
|
|
};
|
|
|
|
union {
|
|
|
|
struct media_gobj *gobj1;
|
|
|
|
struct media_pad *sink;
|
2015-08-07 20:36:25 +07:00
|
|
|
struct media_entity *entity;
|
2015-08-20 19:10:07 +07:00
|
|
|
};
|
2015-08-30 09:43:03 +07:00
|
|
|
struct media_link *reverse;
|
|
|
|
unsigned long flags;
|
2015-08-30 19:53:57 +07:00
|
|
|
bool is_backlink;
|
2009-12-09 18:40:00 +07:00
|
|
|
};
|
|
|
|
|
2015-08-30 09:43:03 +07:00
|
|
|
/**
|
|
|
|
* struct media_pad - A media pad graph object.
|
|
|
|
*
|
|
|
|
* @graph_obj: Embedded structure containing the media object common data
|
|
|
|
* @entity: Entity this pad belongs to
|
|
|
|
* @index: Pad index in the entity pads array, numbered from 0 to n
|
|
|
|
* @flags: Pad flags, as defined in uapi/media.h (MEDIA_PAD_FL_*)
|
|
|
|
*/
|
2009-12-09 18:40:00 +07:00
|
|
|
struct media_pad {
|
2015-08-20 19:10:07 +07:00
|
|
|
struct media_gobj graph_obj; /* must be first field in struct */
|
2015-08-30 09:43:03 +07:00
|
|
|
struct media_entity *entity;
|
|
|
|
u16 index;
|
|
|
|
unsigned long flags;
|
2009-12-09 18:40:00 +07:00
|
|
|
};
|
|
|
|
|
2014-03-26 10:01:44 +07:00
|
|
|
/**
|
|
|
|
* struct media_entity_operations - Media entity operations
|
|
|
|
* @link_setup: Notify the entity of link changes. The operation can
|
|
|
|
* return an error, in which case link setup will be
|
|
|
|
* cancelled. Optional.
|
|
|
|
* @link_validate: Return whether a link is valid from the entity point of
|
|
|
|
* view. The media_entity_pipeline_start() function
|
|
|
|
* validates all links by calling this operation. Optional.
|
2016-04-06 20:55:25 +07:00
|
|
|
*
|
2016-07-20 19:22:38 +07:00
|
|
|
* .. note::
|
|
|
|
*
|
|
|
|
* Those these callbacks are called with struct media_device.@graph_mutex
|
|
|
|
* mutex held.
|
2014-03-26 10:01:44 +07:00
|
|
|
*/
|
2009-12-09 18:40:03 +07:00
|
|
|
struct media_entity_operations {
|
|
|
|
int (*link_setup)(struct media_entity *entity,
|
|
|
|
const struct media_pad *local,
|
|
|
|
const struct media_pad *remote, u32 flags);
|
2012-01-11 16:25:15 +07:00
|
|
|
int (*link_validate)(struct media_link *link);
|
2009-12-09 18:40:03 +07:00
|
|
|
};
|
|
|
|
|
2016-02-29 18:45:44 +07:00
|
|
|
/**
|
|
|
|
* enum media_entity_type - Media entity type
|
|
|
|
*
|
|
|
|
* @MEDIA_ENTITY_TYPE_BASE:
|
|
|
|
* The entity isn't embedded in another subsystem structure.
|
|
|
|
* @MEDIA_ENTITY_TYPE_VIDEO_DEVICE:
|
|
|
|
* The entity is embedded in a struct video_device instance.
|
|
|
|
* @MEDIA_ENTITY_TYPE_V4L2_SUBDEV:
|
|
|
|
* The entity is embedded in a struct v4l2_subdev instance.
|
|
|
|
*
|
|
|
|
* Media entity objects are often not instantiated directly, but the media
|
|
|
|
* entity structure is inherited by (through embedding) other subsystem-specific
|
|
|
|
* structures. The media entity type identifies the type of the subclass
|
|
|
|
* structure that implements a media entity instance.
|
|
|
|
*
|
|
|
|
* This allows runtime type identification of media entities and safe casting to
|
|
|
|
* the correct object type. For instance, a media entity structure instance
|
|
|
|
* embedded in a v4l2_subdev structure instance will have the type
|
|
|
|
* MEDIA_ENTITY_TYPE_V4L2_SUBDEV and can safely be cast to a v4l2_subdev
|
|
|
|
* structure using the container_of() macro.
|
|
|
|
*/
|
|
|
|
enum media_entity_type {
|
|
|
|
MEDIA_ENTITY_TYPE_BASE,
|
|
|
|
MEDIA_ENTITY_TYPE_VIDEO_DEVICE,
|
|
|
|
MEDIA_ENTITY_TYPE_V4L2_SUBDEV,
|
|
|
|
};
|
|
|
|
|
2015-08-30 09:43:03 +07:00
|
|
|
/**
|
|
|
|
* struct media_entity - A media entity graph object.
|
|
|
|
*
|
|
|
|
* @graph_obj: Embedded structure containing the media object common data.
|
|
|
|
* @name: Entity name.
|
2016-02-29 18:45:44 +07:00
|
|
|
* @obj_type: Type of the object that implements the media_entity.
|
2015-09-06 19:33:39 +07:00
|
|
|
* @function: Entity main function, as defined in uapi/media.h
|
|
|
|
* (MEDIA_ENT_F_*)
|
2015-08-30 09:43:03 +07:00
|
|
|
* @flags: Entity flags, as defined in uapi/media.h (MEDIA_ENT_FL_*)
|
|
|
|
* @num_pads: Number of sink and source pads.
|
|
|
|
* @num_links: Total number of links, forward and back, enabled and disabled.
|
|
|
|
* @num_backlinks: Number of backlinks
|
2015-12-16 20:32:17 +07:00
|
|
|
* @internal_idx: An unique internal entity specific number. The numbers are
|
|
|
|
* re-used if entities are unregistered or registered again.
|
2015-08-30 09:43:03 +07:00
|
|
|
* @pads: Pads array with the size defined by @num_pads.
|
|
|
|
* @links: List of data links.
|
|
|
|
* @ops: Entity operations.
|
|
|
|
* @stream_count: Stream count for the entity.
|
|
|
|
* @use_count: Use count for the entity.
|
|
|
|
* @pipe: Pipeline this entity belongs to.
|
|
|
|
* @info: Union with devnode information. Kept just for backward
|
|
|
|
* compatibility.
|
|
|
|
* @major: Devnode major number (zero if not applicable). Kept just
|
|
|
|
* for backward compatibility.
|
|
|
|
* @minor: Devnode minor number (zero if not applicable). Kept just
|
|
|
|
* for backward compatibility.
|
|
|
|
*
|
|
|
|
* NOTE: @stream_count and @use_count reference counts must never be
|
|
|
|
* negative, but are signed integers on purpose: a simple WARN_ON(<0) check
|
|
|
|
* can be used to detect reference count bugs that would make them negative.
|
|
|
|
*/
|
2009-12-09 18:40:00 +07:00
|
|
|
struct media_entity {
|
2015-08-20 19:10:07 +07:00
|
|
|
struct media_gobj graph_obj; /* must be first field in struct */
|
2015-08-30 09:43:03 +07:00
|
|
|
const char *name;
|
2016-02-29 18:45:44 +07:00
|
|
|
enum media_entity_type obj_type;
|
2015-09-06 19:33:39 +07:00
|
|
|
u32 function;
|
2015-08-30 09:43:03 +07:00
|
|
|
unsigned long flags;
|
2009-12-09 18:40:00 +07:00
|
|
|
|
2015-08-30 09:43:03 +07:00
|
|
|
u16 num_pads;
|
|
|
|
u16 num_links;
|
|
|
|
u16 num_backlinks;
|
2015-12-16 20:32:17 +07:00
|
|
|
int internal_idx;
|
2009-12-09 18:40:00 +07:00
|
|
|
|
2015-08-30 09:43:03 +07:00
|
|
|
struct media_pad *pads;
|
|
|
|
struct list_head links;
|
2009-12-09 18:40:00 +07:00
|
|
|
|
2015-08-30 09:43:03 +07:00
|
|
|
const struct media_entity_operations *ops;
|
2009-12-09 18:40:03 +07:00
|
|
|
|
2010-03-08 01:04:59 +07:00
|
|
|
/* Reference counts must never be negative, but are signed integers on
|
|
|
|
* purpose: a simple WARN_ON(<0) check can be used to detect reference
|
|
|
|
* count bugs that would make them negative.
|
|
|
|
*/
|
2015-08-30 09:43:03 +07:00
|
|
|
int stream_count;
|
|
|
|
int use_count;
|
2010-03-08 01:04:59 +07:00
|
|
|
|
2015-08-30 09:43:03 +07:00
|
|
|
struct media_pipeline *pipe;
|
2010-08-25 19:00:41 +07:00
|
|
|
|
2009-12-09 18:40:00 +07:00
|
|
|
union {
|
|
|
|
struct {
|
|
|
|
u32 major;
|
|
|
|
u32 minor;
|
[media] media: Fix DVB devnode representation at media controller
The previous provision for DVB media controller support were to
define an ID (likely meaning the adapter number) for the DVB
devnodes.
This is just plain wrong. Just like V4L, DVB devices (and any other
device node)) are uniquely identified via a (major, minor) tuple.
This is enough to uniquely identify a devnode, no matter what
API it implements.
So, before we go too far, let's mark the old v4l, fb, dvb and alsa
"devnode" info as deprecated, and just call it as "dev".
We can latter add fields specific to each API if needed.
As we don't want to break compilation on already existing apps,
let's just keep the old definitions as-is, adding a note that
those are deprecated at media-entity.h.
Signed-off-by: Mauro Carvalho Chehab <mchehab@osg.samsung.com>
2015-01-02 22:18:23 +07:00
|
|
|
} dev;
|
2011-11-06 04:42:01 +07:00
|
|
|
} info;
|
2009-12-09 18:40:00 +07:00
|
|
|
};
|
|
|
|
|
2015-08-20 19:07:34 +07:00
|
|
|
/**
|
2015-08-30 09:43:03 +07:00
|
|
|
* struct media_interface - A media interface graph object.
|
2015-08-20 19:07:34 +07:00
|
|
|
*
|
|
|
|
* @graph_obj: embedded graph object
|
2015-08-07 20:36:25 +07:00
|
|
|
* @links: List of links pointing to graph entities
|
2015-08-30 09:43:03 +07:00
|
|
|
* @type: Type of the interface as defined in the
|
2015-08-20 19:07:34 +07:00
|
|
|
* uapi/media/media.h header, e. g.
|
|
|
|
* MEDIA_INTF_T_*
|
2015-08-30 09:43:03 +07:00
|
|
|
* @flags: Interface flags as defined in uapi/media/media.h
|
2015-08-20 19:07:34 +07:00
|
|
|
*/
|
|
|
|
struct media_interface {
|
|
|
|
struct media_gobj graph_obj;
|
2015-08-07 20:36:25 +07:00
|
|
|
struct list_head links;
|
2015-08-20 19:07:34 +07:00
|
|
|
u32 type;
|
|
|
|
u32 flags;
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
2015-08-30 09:43:03 +07:00
|
|
|
* struct media_intf_devnode - A media interface via a device node.
|
2015-08-20 19:07:34 +07:00
|
|
|
*
|
|
|
|
* @intf: embedded interface object
|
|
|
|
* @major: Major number of a device node
|
|
|
|
* @minor: Minor number of a device node
|
|
|
|
*/
|
|
|
|
struct media_intf_devnode {
|
|
|
|
struct media_interface intf;
|
2015-08-23 18:28:21 +07:00
|
|
|
|
|
|
|
/* Should match the fields at media_v2_intf_devnode */
|
2015-08-20 19:07:34 +07:00
|
|
|
u32 major;
|
|
|
|
u32 minor;
|
|
|
|
};
|
|
|
|
|
2015-12-13 17:20:46 +07:00
|
|
|
/**
|
|
|
|
* media_entity_id() - return the media entity graph object id
|
|
|
|
*
|
|
|
|
* @entity: pointer to entity
|
|
|
|
*/
|
2015-08-14 20:42:05 +07:00
|
|
|
static inline u32 media_entity_id(struct media_entity *entity)
|
|
|
|
{
|
2015-08-14 22:47:48 +07:00
|
|
|
return entity->graph_obj.id;
|
2015-08-14 20:42:05 +07:00
|
|
|
}
|
|
|
|
|
2015-12-13 17:20:46 +07:00
|
|
|
/**
|
|
|
|
* media_type() - return the media object type
|
|
|
|
*
|
|
|
|
* @gobj: pointer to the media graph object
|
|
|
|
*/
|
2015-08-25 20:28:36 +07:00
|
|
|
static inline enum media_gobj_type media_type(struct media_gobj *gobj)
|
|
|
|
{
|
2015-12-16 23:28:01 +07:00
|
|
|
return gobj->id >> MEDIA_BITS_PER_ID;
|
2015-08-25 20:28:36 +07:00
|
|
|
}
|
|
|
|
|
2015-12-17 00:15:18 +07:00
|
|
|
/**
|
|
|
|
* media_id() - return the media object ID
|
|
|
|
*
|
|
|
|
* @gobj: pointer to the media graph object
|
|
|
|
*/
|
2015-12-16 23:28:01 +07:00
|
|
|
static inline u32 media_id(struct media_gobj *gobj)
|
2015-08-25 20:28:36 +07:00
|
|
|
{
|
2015-12-16 23:28:01 +07:00
|
|
|
return gobj->id & MEDIA_ID_MASK;
|
2015-08-25 20:28:36 +07:00
|
|
|
}
|
|
|
|
|
2015-12-17 00:15:18 +07:00
|
|
|
/**
|
|
|
|
* media_gobj_gen_id() - encapsulates type and ID on at the object ID
|
|
|
|
*
|
|
|
|
* @type: object type as define at enum &media_gobj_type.
|
|
|
|
* @local_id: next ID, from struct &media_device.@id.
|
|
|
|
*/
|
2015-12-16 23:28:01 +07:00
|
|
|
static inline u32 media_gobj_gen_id(enum media_gobj_type type, u64 local_id)
|
2015-08-25 20:28:36 +07:00
|
|
|
{
|
|
|
|
u32 id;
|
|
|
|
|
2015-12-16 23:28:01 +07:00
|
|
|
id = type << MEDIA_BITS_PER_ID;
|
|
|
|
id |= local_id & MEDIA_ID_MASK;
|
2015-08-25 20:28:36 +07:00
|
|
|
|
|
|
|
return id;
|
|
|
|
}
|
|
|
|
|
2015-12-13 17:20:46 +07:00
|
|
|
/**
|
2016-02-29 18:45:45 +07:00
|
|
|
* is_media_entity_v4l2_video_device() - Check if the entity is a video_device
|
2015-12-13 17:20:46 +07:00
|
|
|
* @entity: pointer to entity
|
|
|
|
*
|
2016-02-29 18:45:44 +07:00
|
|
|
* Return: true if the entity is an instance of a video_device object and can
|
|
|
|
* safely be cast to a struct video_device using the container_of() macro, or
|
|
|
|
* false otherwise.
|
2015-12-13 17:20:46 +07:00
|
|
|
*/
|
2016-02-29 18:45:45 +07:00
|
|
|
static inline bool is_media_entity_v4l2_video_device(struct media_entity *entity)
|
2015-08-21 22:17:40 +07:00
|
|
|
{
|
2016-02-29 18:45:44 +07:00
|
|
|
return entity && entity->obj_type == MEDIA_ENTITY_TYPE_VIDEO_DEVICE;
|
2015-08-21 22:17:40 +07:00
|
|
|
}
|
|
|
|
|
2015-12-13 17:20:46 +07:00
|
|
|
/**
|
2016-02-29 18:45:44 +07:00
|
|
|
* is_media_entity_v4l2_subdev() - Check if the entity is a v4l2_subdev
|
2015-12-13 17:20:46 +07:00
|
|
|
* @entity: pointer to entity
|
|
|
|
*
|
2016-02-29 18:45:44 +07:00
|
|
|
* Return: true if the entity is an instance of a v4l2_subdev object and can
|
|
|
|
* safely be cast to a struct v4l2_subdev using the container_of() macro, or
|
|
|
|
* false otherwise.
|
2015-12-13 17:20:46 +07:00
|
|
|
*/
|
2015-08-21 22:17:40 +07:00
|
|
|
static inline bool is_media_entity_v4l2_subdev(struct media_entity *entity)
|
|
|
|
{
|
2016-02-29 18:45:44 +07:00
|
|
|
return entity && entity->obj_type == MEDIA_ENTITY_TYPE_V4L2_SUBDEV;
|
2015-08-21 22:17:40 +07:00
|
|
|
}
|
|
|
|
|
2015-12-16 22:53:04 +07:00
|
|
|
/**
|
|
|
|
* __media_entity_enum_init - Initialise an entity enumeration
|
|
|
|
*
|
|
|
|
* @ent_enum: Entity enumeration to be initialised
|
|
|
|
* @idx_max: Maximum number of entities in the enumeration
|
|
|
|
*
|
|
|
|
* Return: Returns zero on success or a negative error code.
|
|
|
|
*/
|
2015-12-16 20:44:32 +07:00
|
|
|
__must_check int __media_entity_enum_init(struct media_entity_enum *ent_enum,
|
|
|
|
int idx_max);
|
2015-12-16 22:53:04 +07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* media_entity_enum_cleanup - Release resources of an entity enumeration
|
|
|
|
*
|
|
|
|
* @ent_enum: Entity enumeration to be released
|
|
|
|
*/
|
|
|
|
void media_entity_enum_cleanup(struct media_entity_enum *ent_enum);
|
2010-03-08 02:14:14 +07:00
|
|
|
|
2015-12-16 20:44:32 +07:00
|
|
|
/**
|
|
|
|
* media_entity_enum_zero - Clear the entire enum
|
|
|
|
*
|
2015-12-16 22:58:31 +07:00
|
|
|
* @ent_enum: Entity enumeration to be cleared
|
2015-10-02 04:07:53 +07:00
|
|
|
*/
|
2015-12-16 20:44:32 +07:00
|
|
|
static inline void media_entity_enum_zero(struct media_entity_enum *ent_enum)
|
|
|
|
{
|
|
|
|
bitmap_zero(ent_enum->bmap, ent_enum->idx_max);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* media_entity_enum_set - Mark a single entity in the enum
|
|
|
|
*
|
2015-12-16 22:58:31 +07:00
|
|
|
* @ent_enum: Entity enumeration
|
2015-12-16 20:44:32 +07:00
|
|
|
* @entity: Entity to be marked
|
|
|
|
*/
|
|
|
|
static inline void media_entity_enum_set(struct media_entity_enum *ent_enum,
|
|
|
|
struct media_entity *entity)
|
|
|
|
{
|
|
|
|
if (WARN_ON(entity->internal_idx >= ent_enum->idx_max))
|
|
|
|
return;
|
|
|
|
|
|
|
|
__set_bit(entity->internal_idx, ent_enum->bmap);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* media_entity_enum_clear - Unmark a single entity in the enum
|
|
|
|
*
|
2015-12-16 22:58:31 +07:00
|
|
|
* @ent_enum: Entity enumeration
|
2015-12-16 20:44:32 +07:00
|
|
|
* @entity: Entity to be unmarked
|
|
|
|
*/
|
|
|
|
static inline void media_entity_enum_clear(struct media_entity_enum *ent_enum,
|
|
|
|
struct media_entity *entity)
|
|
|
|
{
|
|
|
|
if (WARN_ON(entity->internal_idx >= ent_enum->idx_max))
|
|
|
|
return;
|
|
|
|
|
|
|
|
__clear_bit(entity->internal_idx, ent_enum->bmap);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* media_entity_enum_test - Test whether the entity is marked
|
|
|
|
*
|
2015-12-16 22:58:31 +07:00
|
|
|
* @ent_enum: Entity enumeration
|
2015-12-16 20:44:32 +07:00
|
|
|
* @entity: Entity to be tested
|
|
|
|
*
|
|
|
|
* Returns true if the entity was marked.
|
|
|
|
*/
|
|
|
|
static inline bool media_entity_enum_test(struct media_entity_enum *ent_enum,
|
|
|
|
struct media_entity *entity)
|
|
|
|
{
|
|
|
|
if (WARN_ON(entity->internal_idx >= ent_enum->idx_max))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return test_bit(entity->internal_idx, ent_enum->bmap);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* media_entity_enum_test - Test whether the entity is marked, and mark it
|
|
|
|
*
|
2015-12-16 22:58:31 +07:00
|
|
|
* @ent_enum: Entity enumeration
|
2015-12-16 20:44:32 +07:00
|
|
|
* @entity: Entity to be tested
|
|
|
|
*
|
|
|
|
* Returns true if the entity was marked, and mark it before doing so.
|
|
|
|
*/
|
2015-12-16 22:58:31 +07:00
|
|
|
static inline bool
|
|
|
|
media_entity_enum_test_and_set(struct media_entity_enum *ent_enum,
|
|
|
|
struct media_entity *entity)
|
2015-12-16 20:44:32 +07:00
|
|
|
{
|
|
|
|
if (WARN_ON(entity->internal_idx >= ent_enum->idx_max))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return __test_and_set_bit(entity->internal_idx, ent_enum->bmap);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2015-12-16 22:58:31 +07:00
|
|
|
* media_entity_enum_empty - Test whether the entire enum is empty
|
2015-12-16 20:44:32 +07:00
|
|
|
*
|
2015-12-16 22:58:31 +07:00
|
|
|
* @ent_enum: Entity enumeration
|
2015-12-16 20:44:32 +07:00
|
|
|
*
|
2016-08-11 12:10:09 +07:00
|
|
|
* Returns true if the entity was empty.
|
2015-12-16 20:44:32 +07:00
|
|
|
*/
|
|
|
|
static inline bool media_entity_enum_empty(struct media_entity_enum *ent_enum)
|
|
|
|
{
|
|
|
|
return bitmap_empty(ent_enum->bmap, ent_enum->idx_max);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* media_entity_enum_intersects - Test whether two enums intersect
|
|
|
|
*
|
2015-12-16 22:58:31 +07:00
|
|
|
* @ent_enum1: First entity enumeration
|
|
|
|
* @ent_enum2: Second entity enumeration
|
2015-12-16 20:44:32 +07:00
|
|
|
*
|
|
|
|
* Returns true if entity enumerations e and f intersect, otherwise false.
|
|
|
|
*/
|
|
|
|
static inline bool media_entity_enum_intersects(
|
|
|
|
struct media_entity_enum *ent_enum1,
|
|
|
|
struct media_entity_enum *ent_enum2)
|
|
|
|
{
|
|
|
|
WARN_ON(ent_enum1->idx_max != ent_enum2->idx_max);
|
|
|
|
|
|
|
|
return bitmap_intersects(ent_enum1->bmap, ent_enum2->bmap,
|
|
|
|
min(ent_enum1->idx_max, ent_enum2->idx_max));
|
|
|
|
}
|
2015-10-02 04:07:53 +07:00
|
|
|
|
2015-08-25 20:28:36 +07:00
|
|
|
#define gobj_to_entity(gobj) \
|
|
|
|
container_of(gobj, struct media_entity, graph_obj)
|
|
|
|
|
2015-08-14 00:42:42 +07:00
|
|
|
#define gobj_to_pad(gobj) \
|
|
|
|
container_of(gobj, struct media_pad, graph_obj)
|
|
|
|
|
|
|
|
#define gobj_to_link(gobj) \
|
|
|
|
container_of(gobj, struct media_link, graph_obj)
|
|
|
|
|
2015-08-20 19:07:34 +07:00
|
|
|
#define gobj_to_intf(gobj) \
|
|
|
|
container_of(gobj, struct media_interface, graph_obj)
|
|
|
|
|
|
|
|
#define intf_to_devnode(intf) \
|
|
|
|
container_of(intf, struct media_intf_devnode, intf)
|
|
|
|
|
2015-12-11 21:14:58 +07:00
|
|
|
/**
|
|
|
|
* media_gobj_create - Initialize a graph object
|
|
|
|
*
|
|
|
|
* @mdev: Pointer to the media_device that contains the object
|
|
|
|
* @type: Type of the object
|
|
|
|
* @gobj: Pointer to the graph object
|
|
|
|
*
|
|
|
|
* This routine initializes the embedded struct media_gobj inside a
|
2016-07-23 17:12:03 +07:00
|
|
|
* media graph object. It is called automatically if media_*_create\(\)
|
2015-12-11 21:14:58 +07:00
|
|
|
* calls are used. However, if the object (entity, link, pad, interface)
|
|
|
|
* is embedded on some other object, this function should be called before
|
|
|
|
* registering the object at the media controller.
|
|
|
|
*/
|
2015-12-11 20:55:40 +07:00
|
|
|
void media_gobj_create(struct media_device *mdev,
|
2015-08-25 20:28:36 +07:00
|
|
|
enum media_gobj_type type,
|
|
|
|
struct media_gobj *gobj);
|
2015-12-11 21:14:58 +07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* media_gobj_destroy - Stop using a graph object on a media device
|
|
|
|
*
|
|
|
|
* @gobj: Pointer to the graph object
|
|
|
|
*
|
|
|
|
* This should be called by all routines like media_device_unregister()
|
|
|
|
* that remove/destroy media graph objects.
|
|
|
|
*/
|
2015-12-11 20:55:40 +07:00
|
|
|
void media_gobj_destroy(struct media_gobj *gobj);
|
2015-08-25 20:28:36 +07:00
|
|
|
|
2015-12-11 20:06:08 +07:00
|
|
|
/**
|
|
|
|
* media_entity_pads_init() - Initialize the entity pads
|
|
|
|
*
|
|
|
|
* @entity: entity where the pads belong
|
2015-12-11 21:14:58 +07:00
|
|
|
* @num_pads: total number of sink and source pads
|
|
|
|
* @pads: Array of @num_pads pads.
|
|
|
|
*
|
|
|
|
* The pads array is managed by the entity driver and passed to
|
|
|
|
* media_entity_pads_init() where its pointer will be stored in the entity
|
|
|
|
* structure.
|
2015-12-11 20:06:08 +07:00
|
|
|
*
|
|
|
|
* If no pads are needed, drivers could either directly fill
|
|
|
|
* &media_entity->@num_pads with 0 and &media_entity->@pads with NULL or call
|
|
|
|
* this function that will do the same.
|
|
|
|
*
|
|
|
|
* 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_pads_init(). The function will initialize the other pads fields.
|
|
|
|
*/
|
2015-12-11 16:44:40 +07:00
|
|
|
int media_entity_pads_init(struct media_entity *entity, u16 num_pads,
|
[media] media: convert links from array to list
The entire logic that represent graph links were developed on a
time where there were no needs to dynamic remove links. So,
although links are created/removed one by one via some
functions, they're stored as an array inside the entity struct.
As the array may grow, there's a logic inside the code that
checks if the amount of space is not enough to store
the needed links. If it isn't the core uses krealloc()
to change the size of the link, with is bad, as it
leaves the memory fragmented.
So, convert links into a list.
Also, currently, both source and sink entities need the link
at the graph traversal logic inside media_entity. So there's
a logic duplicating all links. That makes it to spend
twice the memory needed. This is not a big deal for today's
usage, where the number of links are not big.
Yet, if during the MC workshop discussions, it was said that
IIO graphs could have up to 4,000 entities. So, we may
want to remove the duplication on some future. The problem
is that it would require a separate linked list to store
the backlinks inside the entity, or to use a more complex
algorithm to do graph backlink traversal, with is something
that the current graph traversal inside the core can't cope
with. So, let's postpone a such change if/when it is actually
needed.
It should also be noticed that the media_link structure uses
44 bytes on 32-bit architectures and 84 bytes on 64-bit
architecture. It will thus be allocated out of the 64-bytes and
96-bytes pools respectively. That's a 12.5% memory waste on
64-bit architectures and 31.25% on 32-bit architecture.
A linked list is less efficient than an array in this case, but
this could later be optimized if we can get rid of the reverse
links (with would reduce memory allocation by 50%).
Signed-off-by: Mauro Carvalho Chehab <mchehab@osg.samsung.com>
2015-08-07 16:55:40 +07:00
|
|
|
struct media_pad *pads);
|
2015-12-11 18:13:23 +07:00
|
|
|
|
2015-12-11 20:06:08 +07:00
|
|
|
/**
|
|
|
|
* media_entity_cleanup() - free resources associated with an entity
|
|
|
|
*
|
|
|
|
* @entity: entity where the pads belong
|
|
|
|
*
|
|
|
|
* This function must be called during the cleanup phase after unregistering
|
|
|
|
* the entity (currently, it does nothing).
|
|
|
|
*/
|
2015-12-11 18:13:23 +07:00
|
|
|
static inline void media_entity_cleanup(struct media_entity *entity) {};
|
2010-08-25 19:00:41 +07:00
|
|
|
|
2015-12-11 20:06:08 +07:00
|
|
|
/**
|
|
|
|
* media_create_pad_link() - creates a link between two entities.
|
|
|
|
*
|
|
|
|
* @source: pointer to &media_entity of the source pad.
|
|
|
|
* @source_pad: number of the source pad in the pads array
|
|
|
|
* @sink: pointer to &media_entity of the sink pad.
|
|
|
|
* @sink_pad: number of the sink pad in the pads array.
|
|
|
|
* @flags: Link flags, as defined in include/uapi/linux/media.h.
|
|
|
|
*
|
|
|
|
* Valid values for flags:
|
|
|
|
*
|
2016-07-17 19:18:03 +07:00
|
|
|
* - A %MEDIA_LNK_FL_ENABLED flag 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.
|
|
|
|
*
|
|
|
|
* - A %MEDIA_LNK_FL_IMMUTABLE flag 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.
|
2015-12-11 20:06:08 +07:00
|
|
|
*
|
2016-07-17 19:18:03 +07:00
|
|
|
* .. note::
|
2015-12-11 20:06:08 +07:00
|
|
|
*
|
2016-07-17 19:18:03 +07:00
|
|
|
* Before calling this function, media_entity_pads_init() and
|
|
|
|
* media_device_register_entity() should be called previously for both ends.
|
2015-12-11 20:06:08 +07:00
|
|
|
*/
|
2015-09-05 02:08:24 +07:00
|
|
|
__must_check int media_create_pad_link(struct media_entity *source,
|
|
|
|
u16 source_pad, struct media_entity *sink,
|
|
|
|
u16 sink_pad, u32 flags);
|
2015-12-30 18:45:48 +07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* media_create_pad_links() - creates a link between two entities.
|
|
|
|
*
|
|
|
|
* @mdev: Pointer to the media_device that contains the object
|
|
|
|
* @source_function: Function of the source entities. Used only if @source is
|
|
|
|
* NULL.
|
|
|
|
* @source: pointer to &media_entity of the source pad. If NULL, it will use
|
|
|
|
* all entities that matches the @sink_function.
|
|
|
|
* @source_pad: number of the source pad in the pads array
|
|
|
|
* @sink_function: Function of the sink entities. Used only if @sink is NULL.
|
|
|
|
* @sink: pointer to &media_entity of the sink pad. If NULL, it will use
|
|
|
|
* all entities that matches the @sink_function.
|
|
|
|
* @sink_pad: number of the sink pad in the pads array.
|
|
|
|
* @flags: Link flags, as defined in include/uapi/linux/media.h.
|
|
|
|
* @allow_both_undefined: if true, then both @source and @sink can be NULL.
|
|
|
|
* In such case, it will create a crossbar between all entities that
|
|
|
|
* matches @source_function to all entities that matches @sink_function.
|
|
|
|
* If false, it will return 0 and won't create any link if both @source
|
|
|
|
* and @sink are NULL.
|
|
|
|
*
|
|
|
|
* Valid values for flags:
|
2016-07-17 19:18:03 +07:00
|
|
|
*
|
2015-12-30 18:45:48 +07:00
|
|
|
* A %MEDIA_LNK_FL_ENABLED flag indicates that the link is enabled and can be
|
|
|
|
* used to transfer media data. If multiple links are created and this
|
|
|
|
* flag is passed as an argument, only the first created link will have
|
|
|
|
* this flag.
|
|
|
|
*
|
|
|
|
* A %MEDIA_LNK_FL_IMMUTABLE flag 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.
|
|
|
|
*
|
|
|
|
* It is common for some devices to have multiple source and/or sink entities
|
|
|
|
* of the same type that should be linked. While media_create_pad_link()
|
|
|
|
* creates link by link, this function is meant to allow 1:n, n:1 and even
|
|
|
|
* cross-bar (n:n) links.
|
|
|
|
*
|
|
|
|
* NOTE: Before calling this function, media_entity_pads_init() and
|
|
|
|
* media_device_register_entity() should be called previously for the entities
|
|
|
|
* to be linked.
|
|
|
|
*/
|
|
|
|
int media_create_pad_links(const struct media_device *mdev,
|
|
|
|
const u32 source_function,
|
|
|
|
struct media_entity *source,
|
|
|
|
const u16 source_pad,
|
|
|
|
const u32 sink_function,
|
|
|
|
struct media_entity *sink,
|
|
|
|
const u16 sink_pad,
|
|
|
|
u32 flags,
|
|
|
|
const bool allow_both_undefined);
|
|
|
|
|
2013-05-09 18:29:32 +07:00
|
|
|
void __media_entity_remove_links(struct media_entity *entity);
|
2015-12-11 20:06:08 +07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* media_entity_remove_links() - remove all links associated with an entity
|
|
|
|
*
|
|
|
|
* @entity: pointer to &media_entity
|
|
|
|
*
|
2016-07-17 19:18:03 +07:00
|
|
|
* .. note::
|
|
|
|
*
|
|
|
|
* This is called automatically when an entity is unregistered via
|
|
|
|
* media_device_register_entity().
|
2015-12-11 20:06:08 +07:00
|
|
|
*/
|
2013-05-09 18:29:32 +07:00
|
|
|
void media_entity_remove_links(struct media_entity *entity);
|
|
|
|
|
2015-12-11 21:14:58 +07:00
|
|
|
/**
|
|
|
|
* __media_entity_setup_link - Configure a media link without locking
|
|
|
|
* @link: The link being configured
|
|
|
|
* @flags: Link configuration flags
|
|
|
|
*
|
|
|
|
* The bulk of link setup is handled by the two entities connected through the
|
|
|
|
* link. This function notifies both entities of the link configuration change.
|
|
|
|
*
|
|
|
|
* If the link is immutable or if the current and new configuration are
|
|
|
|
* identical, return immediately.
|
|
|
|
*
|
|
|
|
* The user is expected to hold link->source->parent->mutex. If not,
|
|
|
|
* media_entity_setup_link() should be used instead.
|
|
|
|
*/
|
2009-12-09 18:40:03 +07:00
|
|
|
int __media_entity_setup_link(struct media_link *link, u32 flags);
|
2015-12-11 20:06:08 +07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* media_entity_setup_link() - changes the link flags properties in runtime
|
|
|
|
*
|
|
|
|
* @link: pointer to &media_link
|
|
|
|
* @flags: the requested new link flags
|
|
|
|
*
|
|
|
|
* The only configurable property is the %MEDIA_LNK_FL_ENABLED link flag
|
|
|
|
* flag to enable/disable a link. Links marked with the
|
|
|
|
* %MEDIA_LNK_FL_IMMUTABLE link flag can not be enabled or disabled.
|
|
|
|
*
|
|
|
|
* When a link is enabled or disabled, the media framework calls the
|
|
|
|
* link_setup operation for the two entities at the source and sink of the
|
|
|
|
* link, in that order. If the second link_setup call fails, another
|
|
|
|
* link_setup call is made on the first entity to restore the original link
|
|
|
|
* flags.
|
|
|
|
*
|
|
|
|
* Media device drivers can be notified of link setup operations by setting the
|
|
|
|
* media_device::link_notify pointer to a callback function. If provided, the
|
|
|
|
* notification callback will be called before enabling and after disabling
|
|
|
|
* links.
|
|
|
|
*
|
|
|
|
* Entity drivers must implement the link_setup operation if any of their links
|
|
|
|
* is non-immutable. The operation must either configure the hardware or store
|
|
|
|
* the configuration information to be applied later.
|
|
|
|
*
|
|
|
|
* Link configuration must not have any side effect on other links. If an
|
|
|
|
* enabled link at a sink pad prevents another link at the same pad from
|
|
|
|
* being enabled, the link_setup operation must return -EBUSY and can't
|
|
|
|
* implicitly disable the first enabled link.
|
|
|
|
*
|
2016-07-17 19:18:03 +07:00
|
|
|
* .. note::
|
|
|
|
*
|
|
|
|
* The valid values of the flags for the link is the same as described
|
|
|
|
* on media_create_pad_link(), for pad to pad links or the same as described
|
|
|
|
* on media_create_intf_link(), for interface to entity links.
|
2015-12-11 20:06:08 +07:00
|
|
|
*/
|
2009-12-09 18:40:03 +07:00
|
|
|
int media_entity_setup_link(struct media_link *link, u32 flags);
|
2015-12-11 21:14:58 +07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* media_entity_find_link - Find a link between two pads
|
|
|
|
* @source: Source pad
|
|
|
|
* @sink: Sink pad
|
|
|
|
*
|
|
|
|
* Return a pointer to the link between the two entities. If no such link
|
|
|
|
* exists, return NULL.
|
|
|
|
*/
|
2009-12-09 18:40:03 +07:00
|
|
|
struct media_link *media_entity_find_link(struct media_pad *source,
|
|
|
|
struct media_pad *sink);
|
2015-12-11 21:14:58 +07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* media_entity_remote_pad - Find the pad at the remote end of a link
|
|
|
|
* @pad: Pad at the local end of the link
|
|
|
|
*
|
|
|
|
* Search for a remote pad connected to the given pad by iterating over all
|
|
|
|
* links originating or terminating at that pad until an enabled link is found.
|
|
|
|
*
|
|
|
|
* Return a pointer to the pad at the remote end of the first found enabled
|
|
|
|
* link, or NULL if no enabled link has been found.
|
|
|
|
*/
|
2013-06-03 15:16:13 +07:00
|
|
|
struct media_pad *media_entity_remote_pad(struct media_pad *pad);
|
2009-12-09 18:40:00 +07:00
|
|
|
|
2015-12-11 21:14:58 +07:00
|
|
|
/**
|
|
|
|
* media_entity_get - Get a reference to the parent module
|
|
|
|
*
|
|
|
|
* @entity: The entity
|
|
|
|
*
|
|
|
|
* Get a reference to the parent media device module.
|
|
|
|
*
|
|
|
|
* The function will return immediately if @entity is NULL.
|
|
|
|
*
|
|
|
|
* Return a pointer to the entity on success or NULL on failure.
|
|
|
|
*/
|
2010-03-08 01:04:59 +07:00
|
|
|
struct media_entity *media_entity_get(struct media_entity *entity);
|
2015-12-11 21:14:58 +07:00
|
|
|
|
2015-12-16 20:32:22 +07:00
|
|
|
__must_check int media_entity_graph_walk_init(
|
|
|
|
struct media_entity_graph *graph, struct media_device *mdev);
|
2015-12-16 22:56:14 +07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* media_entity_graph_walk_cleanup - Release resources used by graph walk.
|
|
|
|
*
|
|
|
|
* @graph: Media graph structure that will be used to walk the graph
|
|
|
|
*/
|
2015-12-16 20:32:22 +07:00
|
|
|
void media_entity_graph_walk_cleanup(struct media_entity_graph *graph);
|
|
|
|
|
2015-12-11 21:14:58 +07:00
|
|
|
/**
|
|
|
|
* media_entity_put - Release the reference to the parent module
|
|
|
|
*
|
|
|
|
* @entity: The entity
|
|
|
|
*
|
|
|
|
* Release the reference count acquired by media_entity_get().
|
|
|
|
*
|
|
|
|
* The function will return immediately if @entity is NULL.
|
|
|
|
*/
|
2010-03-08 01:04:59 +07:00
|
|
|
void media_entity_put(struct media_entity *entity);
|
|
|
|
|
2015-12-11 21:14:58 +07:00
|
|
|
/**
|
|
|
|
* media_entity_graph_walk_start - Start walking the media graph at a given entity
|
|
|
|
* @graph: Media graph structure that will be used to walk the graph
|
|
|
|
* @entity: Starting entity
|
|
|
|
*
|
2015-12-16 20:32:22 +07:00
|
|
|
* Before using this function, media_entity_graph_walk_init() must be
|
|
|
|
* used to allocate resources used for walking the graph. This
|
|
|
|
* function initializes the graph traversal structure to walk the
|
|
|
|
* entities graph starting at the given entity. The traversal
|
|
|
|
* structure must not be modified by the caller during graph
|
|
|
|
* traversal. After the graph walk, the resources must be released
|
|
|
|
* using media_entity_graph_walk_cleanup().
|
2015-12-11 21:14:58 +07:00
|
|
|
*/
|
2010-03-08 02:14:14 +07:00
|
|
|
void media_entity_graph_walk_start(struct media_entity_graph *graph,
|
2015-12-16 20:32:22 +07:00
|
|
|
struct media_entity *entity);
|
2015-12-11 21:14:58 +07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* media_entity_graph_walk_next - Get the next entity in the graph
|
|
|
|
* @graph: Media graph structure
|
|
|
|
*
|
|
|
|
* Perform a depth-first traversal of the given media entities graph.
|
|
|
|
*
|
|
|
|
* The graph structure must have been previously initialized with a call to
|
|
|
|
* media_entity_graph_walk_start().
|
|
|
|
*
|
|
|
|
* Return the next entity in the graph or NULL if the whole graph have been
|
|
|
|
* traversed.
|
|
|
|
*/
|
2010-03-08 02:14:14 +07:00
|
|
|
struct media_entity *
|
|
|
|
media_entity_graph_walk_next(struct media_entity_graph *graph);
|
2015-12-11 21:14:58 +07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* media_entity_pipeline_start - Mark a pipeline as streaming
|
|
|
|
* @entity: Starting entity
|
|
|
|
* @pipe: Media pipeline to be assigned to all entities in the pipeline.
|
|
|
|
*
|
|
|
|
* Mark all entities connected to a given entity through enabled links, either
|
|
|
|
* directly or indirectly, as streaming. The given pipeline object is assigned to
|
|
|
|
* every entity in the pipeline and stored in the media_entity pipe field.
|
|
|
|
*
|
|
|
|
* Calls to this function can be nested, in which case the same number of
|
|
|
|
* media_entity_pipeline_stop() calls will be required to stop streaming. The
|
|
|
|
* pipeline pointer must be identical for all nested calls to
|
|
|
|
* media_entity_pipeline_start().
|
|
|
|
*/
|
2012-01-11 16:25:15 +07:00
|
|
|
__must_check int media_entity_pipeline_start(struct media_entity *entity,
|
|
|
|
struct media_pipeline *pipe);
|
2016-02-12 06:41:24 +07:00
|
|
|
/**
|
|
|
|
* __media_entity_pipeline_start - Mark a pipeline as streaming
|
|
|
|
*
|
|
|
|
* @entity: Starting entity
|
|
|
|
* @pipe: Media pipeline to be assigned to all entities in the pipeline.
|
|
|
|
*
|
2016-07-17 19:18:03 +07:00
|
|
|
* ..note:: This is the non-locking version of media_entity_pipeline_start()
|
2016-02-12 06:41:24 +07:00
|
|
|
*/
|
|
|
|
__must_check int __media_entity_pipeline_start(struct media_entity *entity,
|
|
|
|
struct media_pipeline *pipe);
|
2015-12-11 21:14:58 +07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* media_entity_pipeline_stop - Mark a pipeline as not streaming
|
|
|
|
* @entity: Starting entity
|
|
|
|
*
|
|
|
|
* Mark all entities connected to a given entity through enabled links, either
|
|
|
|
* directly or indirectly, as not streaming. The media_entity pipe field is
|
|
|
|
* reset to NULL.
|
|
|
|
*
|
|
|
|
* If multiple calls to media_entity_pipeline_start() have been made, the same
|
|
|
|
* number of calls to this function are required to mark the pipeline as not
|
|
|
|
* streaming.
|
|
|
|
*/
|
2010-08-25 19:00:41 +07:00
|
|
|
void media_entity_pipeline_stop(struct media_entity *entity);
|
2010-03-08 02:14:14 +07:00
|
|
|
|
2016-02-12 06:41:24 +07:00
|
|
|
/**
|
|
|
|
* __media_entity_pipeline_stop - Mark a pipeline as not streaming
|
|
|
|
*
|
|
|
|
* @entity: Starting entity
|
|
|
|
*
|
2016-07-17 19:18:03 +07:00
|
|
|
* .. note:: This is the non-locking version of media_entity_pipeline_stop()
|
2016-02-12 06:41:24 +07:00
|
|
|
*/
|
|
|
|
void __media_entity_pipeline_stop(struct media_entity *entity);
|
|
|
|
|
2015-12-11 20:06:08 +07:00
|
|
|
/**
|
|
|
|
* media_devnode_create() - creates and initializes a device node interface
|
|
|
|
*
|
|
|
|
* @mdev: pointer to struct &media_device
|
|
|
|
* @type: type of the interface, as given by MEDIA_INTF_T_* macros
|
|
|
|
* as defined in the uapi/media/media.h header.
|
|
|
|
* @flags: Interface flags as defined in uapi/media/media.h.
|
|
|
|
* @major: Device node major number.
|
|
|
|
* @minor: Device node minor number.
|
|
|
|
*
|
|
|
|
* Return: if succeeded, returns a pointer to the newly allocated
|
|
|
|
* &media_intf_devnode pointer.
|
|
|
|
*/
|
2015-09-05 01:34:19 +07:00
|
|
|
struct media_intf_devnode *
|
|
|
|
__must_check media_devnode_create(struct media_device *mdev,
|
|
|
|
u32 type, u32 flags,
|
2015-09-09 18:19:25 +07:00
|
|
|
u32 major, u32 minor);
|
2015-12-11 20:06:08 +07:00
|
|
|
/**
|
|
|
|
* media_devnode_remove() - removes a device node interface
|
|
|
|
*
|
|
|
|
* @devnode: pointer to &media_intf_devnode to be freed.
|
|
|
|
*
|
|
|
|
* When a device node interface is removed, all links to it are automatically
|
|
|
|
* removed.
|
|
|
|
*/
|
2015-08-20 19:07:34 +07:00
|
|
|
void media_devnode_remove(struct media_intf_devnode *devnode);
|
2015-09-05 01:34:19 +07:00
|
|
|
struct media_link *
|
2015-12-11 20:06:08 +07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* media_create_intf_link() - creates a link between an entity and an interface
|
|
|
|
*
|
|
|
|
* @entity: pointer to %media_entity
|
|
|
|
* @intf: pointer to %media_interface
|
|
|
|
* @flags: Link flags, as defined in include/uapi/linux/media.h.
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* Valid values for flags:
|
|
|
|
*
|
2016-07-17 19:18:03 +07:00
|
|
|
* - The %MEDIA_LNK_FL_ENABLED flag indicates that the interface is connected to
|
|
|
|
* the entity hardware. That's the default value for interfaces. An
|
|
|
|
* interface may be disabled if the hardware is busy due to the usage
|
|
|
|
* of some other interface that it is currently controlling the hardware.
|
|
|
|
* A typical example is an hybrid TV device that handle only one type of
|
|
|
|
* stream on a given time. So, when the digital TV is streaming,
|
|
|
|
* the V4L2 interfaces won't be enabled, as such device is not able to
|
|
|
|
* also stream analog TV or radio.
|
|
|
|
*
|
|
|
|
* .. note::
|
2015-12-11 20:06:08 +07:00
|
|
|
*
|
2016-07-17 19:18:03 +07:00
|
|
|
* Before calling this function, media_devnode_create() should be called for
|
|
|
|
* the interface and media_device_register_entity() should be called for the
|
|
|
|
* interface that will be part of the link.
|
2015-12-11 20:06:08 +07:00
|
|
|
*/
|
2015-09-05 01:34:19 +07:00
|
|
|
__must_check media_create_intf_link(struct media_entity *entity,
|
|
|
|
struct media_interface *intf,
|
|
|
|
u32 flags);
|
2015-12-13 17:20:46 +07:00
|
|
|
/**
|
|
|
|
* __media_remove_intf_link() - remove a single interface link
|
|
|
|
*
|
|
|
|
* @link: pointer to &media_link.
|
|
|
|
*
|
2016-07-17 19:18:03 +07:00
|
|
|
* .. note:: This is an unlocked version of media_remove_intf_link()
|
2015-12-13 17:20:46 +07:00
|
|
|
*/
|
2015-08-30 07:23:44 +07:00
|
|
|
void __media_remove_intf_link(struct media_link *link);
|
2015-12-13 17:20:46 +07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* media_remove_intf_link() - remove a single interface link
|
|
|
|
*
|
|
|
|
* @link: pointer to &media_link.
|
|
|
|
*
|
2016-07-17 19:18:03 +07:00
|
|
|
* .. note:: Prefer to use this one, instead of __media_remove_intf_link()
|
2015-12-13 17:20:46 +07:00
|
|
|
*/
|
2015-08-07 20:36:25 +07:00
|
|
|
void media_remove_intf_link(struct media_link *link);
|
2015-12-13 17:20:46 +07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* __media_remove_intf_links() - remove all links associated with an interface
|
|
|
|
*
|
|
|
|
* @intf: pointer to &media_interface
|
|
|
|
*
|
2016-07-17 19:18:03 +07:00
|
|
|
* .. note:: This is an unlocked version of media_remove_intf_links().
|
2015-12-13 17:20:46 +07:00
|
|
|
*/
|
2015-08-24 18:46:46 +07:00
|
|
|
void __media_remove_intf_links(struct media_interface *intf);
|
2015-12-16 22:53:04 +07:00
|
|
|
|
2015-12-11 20:06:08 +07:00
|
|
|
/**
|
|
|
|
* media_remove_intf_links() - remove all links associated with an interface
|
|
|
|
*
|
|
|
|
* @intf: pointer to &media_interface
|
|
|
|
*
|
2016-07-20 21:15:31 +07:00
|
|
|
* .. note::
|
2015-12-13 17:20:46 +07:00
|
|
|
*
|
2016-07-20 21:15:31 +07:00
|
|
|
* #) This is called automatically when an entity is unregistered via
|
|
|
|
* media_device_register_entity() and by media_devnode_remove().
|
2015-12-13 17:20:46 +07:00
|
|
|
*
|
2016-07-20 21:15:31 +07:00
|
|
|
* #) Prefer to use this one, instead of __media_remove_intf_links().
|
2015-12-11 20:06:08 +07:00
|
|
|
*/
|
2015-08-24 18:46:46 +07:00
|
|
|
void media_remove_intf_links(struct media_interface *intf);
|
|
|
|
|
2009-12-09 18:40:03 +07:00
|
|
|
#define media_entity_call(entity, operation, args...) \
|
|
|
|
(((entity)->ops && (entity)->ops->operation) ? \
|
|
|
|
(entity)->ops->operation((entity) , ##args) : -ENOIOCTLCMD)
|
|
|
|
|
2009-12-09 18:40:00 +07:00
|
|
|
#endif
|