1 files changed, 517 insertions, 0 deletions

diff --git a/extras/recipes-kernel/linux/linux-omap/media/0015-media-Links-setup.patch b/extras/recipes-kernel/linux/linux-omap/media/0015-media-Links-setup.patch
new file mode 100644
index 00000000..4ea39740
--- /dev/null
+++ b/extras/recipes-kernel/linux/linux-omap/media/0015-media-Links-setup.patch
@@ -0,0 +1,517 @@
+From 9991c219079532183cc33f16064f86680b80237c Mon Sep 17 00:00:00 2001
+From: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
+Date: Wed, 9 Dec 2009 12:40:03 +0100
+Subject: [PATCH 15/43] media: Links setup
+
+Create the following ioctl and implement it at the media device level to
+setup links.
+
+- MEDIA_IOC_SETUP_LINK: Modify the properties of a given link
+
+The only property that can currently be modified is the ENABLED link
+flag to enable/disable a link. Links marked with the IMMUTABLE link flag
+can not be enabled or disabled.
+
+Enabling or disabling a link has effects on entities' use count. Those
+changes are automatically propagated through the graph.
+
+Signed-off-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
+Signed-off-by: Stanimir Varbanov <svarbanov@mm-sol.com>
+Signed-off-by: Sakari Ailus <sakari.ailus@maxwell.research.nokia.com>
+---
+ Documentation/DocBook/media-entities.tmpl          |    2 +
+ Documentation/DocBook/v4l/media-controller.xml     |    1 +
+ Documentation/DocBook/v4l/media-ioc-setup-link.xml |   90 +++++++++++
+ Documentation/media-framework.txt                  |   42 ++++++
+ drivers/media/media-device.c                       |   45 ++++++
+ drivers/media/media-entity.c                       |  155 ++++++++++++++++++++
+ include/linux/media.h                              |    1 +
+ include/media/media-device.h                       |    3 +
+ include/media/media-entity.h                       |   17 ++
+ 9 files changed, 356 insertions(+), 0 deletions(-)
+ create mode 100644 Documentation/DocBook/v4l/media-ioc-setup-link.xml
+
+diff --git a/Documentation/DocBook/media-entities.tmpl b/Documentation/DocBook/media-entities.tmpl
+index 6e7dae4..679c585 100644
+--- a/Documentation/DocBook/media-entities.tmpl
++++ b/Documentation/DocBook/media-entities.tmpl
+@@ -94,6 +94,7 @@
+ <!ENTITY MEDIA-IOC-DEVICE-INFO "<link linkend='media-ioc-device-info'><constant>MEDIA_IOC_DEVICE_INFO</constant></link>">
+ <!ENTITY MEDIA-IOC-ENUM-ENTITIES "<link linkend='media-ioc-enum-entities'><constant>MEDIA_IOC_ENUM_ENTITIES</constant></link>">
+ <!ENTITY MEDIA-IOC-ENUM-LINKS "<link linkend='media-ioc-enum-links'><constant>MEDIA_IOC_ENUM_LINKS</constant></link>">
++<!ENTITY MEDIA-IOC-SETUP-LINK "<link linkend='media-ioc-setup-link'><constant>MEDIA_IOC_SETUP_LINK</constant></link>">
+ 
+ <!-- Types -->
+ <!ENTITY v4l2-std-id "<link linkend='v4l2-std-id'>v4l2_std_id</link>">
+@@ -342,6 +343,7 @@
+ <!ENTITY sub-media-ioc-device-info SYSTEM "v4l/media-ioc-device-info.xml">
+ <!ENTITY sub-media-ioc-enum-entities SYSTEM "v4l/media-ioc-enum-entities.xml">
+ <!ENTITY sub-media-ioc-enum-links SYSTEM "v4l/media-ioc-enum-links.xml">
++<!ENTITY sub-media-ioc-setup-link SYSTEM "v4l/media-ioc-setup-link.xml">
+ 
+ <!-- Function Reference -->
+ <!ENTITY close SYSTEM "v4l/func-close.xml">
+diff --git a/Documentation/DocBook/v4l/media-controller.xml b/Documentation/DocBook/v4l/media-controller.xml
+index 2c4fd2b..2dc25e1 100644
+--- a/Documentation/DocBook/v4l/media-controller.xml
++++ b/Documentation/DocBook/v4l/media-controller.xml
+@@ -85,4 +85,5 @@
+   &sub-media-ioc-device-info;
+   &sub-media-ioc-enum-entities;
+   &sub-media-ioc-enum-links;
++  &sub-media-ioc-setup-link;
+ </appendix>
+diff --git a/Documentation/DocBook/v4l/media-ioc-setup-link.xml b/Documentation/DocBook/v4l/media-ioc-setup-link.xml
+new file mode 100644
+index 0000000..09ab3d2
+--- /dev/null
++++ b/Documentation/DocBook/v4l/media-ioc-setup-link.xml
+@@ -0,0 +1,90 @@
++<refentry id="media-ioc-setup-link">
++  <refmeta>
++    <refentrytitle>ioctl MEDIA_IOC_SETUP_LINK</refentrytitle>
++    &manvol;
++  </refmeta>
++
++  <refnamediv>
++    <refname>MEDIA_IOC_SETUP_LINK</refname>
++    <refpurpose>Modify the properties of a link</refpurpose>
++  </refnamediv>
++
++  <refsynopsisdiv>
++    <funcsynopsis>
++      <funcprototype>
++       <funcdef>int <function>ioctl</function></funcdef>
++       <paramdef>int <parameter>fd</parameter></paramdef>
++       <paramdef>int <parameter>request</parameter></paramdef>
++       <paramdef>struct media_link_desc *<parameter>argp</parameter></paramdef>
++      </funcprototype>
++    </funcsynopsis>
++  </refsynopsisdiv>
++
++  <refsect1>
++    <title>Arguments</title>
++
++    <variablelist>
++      <varlistentry>
++       <term><parameter>fd</parameter></term>
++       <listitem>
++         <para>File descriptor returned by
++         <link linkend='media-func-open'><function>open()</function></link>.</para>
++       </listitem>
++      </varlistentry>
++      <varlistentry>
++       <term><parameter>request</parameter></term>
++       <listitem>
++         <para>MEDIA_IOC_ENUM_LINKS</para>
++       </listitem>
++      </varlistentry>
++      <varlistentry>
++       <term><parameter>argp</parameter></term>
++       <listitem>
++         <para></para>
++       </listitem>
++      </varlistentry>
++    </variablelist>
++  </refsect1>
++
++  <refsect1>
++    <title>Description</title>
++
++    <para>To change link properties applications fill a &media-link-desc; with
++    link identification information (source and sink pad) and the new requested
++    link flags. They then call the MEDIA_IOC_SETUP_LINK ioctl with a pointer to
++    that structure.</para>
++    <para>The only configurable property is the <constant>ENABLED</constant>
++    link flag to enable/disable a link. Links marked with the
++    <constant>IMMUTABLE</constant> link flag can not be enabled or disabled.
++    </para>
++    <para>Link configuration has no side effect on other links. If an enabled
++    link at the sink pad prevents the link from being enabled, the driver
++    returns with an &EBUSY;.</para>
++    <para>If the specified link can't be found the driver returns with an
++    &EINVAL;.</para>
++  </refsect1>
++
++  <refsect1>
++    &return-value;
++
++    <variablelist>
++      <varlistentry>
++       <term><errorcode>EBUSY</errorcode></term>
++       <listitem>
++         <para>The link properties can't be changed because the link is
++         currently busy. This can be caused, for instance, by an active media
++         stream (audio or video) on the link. The ioctl shouldn't be retried if
++         no other action is performed before to fix the problem.</para>
++       </listitem>
++      </varlistentry>
++      <varlistentry>
++       <term><errorcode>EINVAL</errorcode></term>
++       <listitem>
++         <para>The &media-link-desc; references a non-existing link, or the
++         link is immutable and an attempt to modify its configuration was made.
++         </para>
++       </listitem>
++      </varlistentry>
++    </variablelist>
++  </refsect1>
++</refentry>
+diff --git a/Documentation/media-framework.txt b/Documentation/media-framework.txt
+index 9017a41..634845e 100644
+--- a/Documentation/media-framework.txt
++++ b/Documentation/media-framework.txt
+@@ -259,6 +259,16 @@ When the graph traversal is complete the function will return NULL.
+ Graph traversal can be interrupted at any moment. No cleanup function call is
+ required and the graph structure can be freed normally.
+ 
++Helper functions can be used to find a link between two given pads, or a pad
++connected to another pad through an enabled link
++
++       media_entity_find_link(struct media_pad *source,
++                              struct media_pad *sink);
++
++       media_entity_remote_source(struct media_pad *pad);
++
++Refer to the kerneldoc documentation for more information.
++
+ 
+ Use count and power handling
+ ----------------------------
+@@ -271,3 +281,35 @@ track the number of users of every entity for power management needs.
+ The use_count field is owned by media drivers and must not be touched by entity
+ drivers. Access to the field must be protected by the media device graph_mutex
+ lock.
++
++
++Links setup
++-----------
++
++Link properties can be modified at runtime by calling
++
++       media_entity_setup_link(struct media_link *link, u32 flags);
++
++The flags argument contains the requested new link flags.
++
++The only configurable property is the ENABLED link flag to enable/disable a
++link. Links marked with the 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 disabled,
++the link_setup operation must return -EBUSY and can't implicitly disable the
++first enabled link.
+diff --git a/drivers/media/media-device.c b/drivers/media/media-device.c
+index 1f46acb..719deba 100644
+--- a/drivers/media/media-device.c
++++ b/drivers/media/media-device.c
+@@ -172,6 +172,44 @@ static long media_device_enum_links(struct media_device *mdev,
+        return 0;
+ }
+ 
++static long media_device_setup_link(struct media_device *mdev,
++                                   struct media_link_desc __user *_ulink)
++{
++       struct media_link *link = NULL;
++       struct media_link_desc ulink;
++       struct media_entity *source;
++       struct media_entity *sink;
++       int ret;
++
++       if (copy_from_user(&ulink, _ulink, sizeof(ulink)))
++               return -EFAULT;
++
++       /* Find the source and sink entities and link.
++        */
++       source = find_entity(mdev, ulink.source.entity);
++       sink = find_entity(mdev, ulink.sink.entity);
++
++       if (source == NULL || sink == NULL)
++               return -EINVAL;
++
++       if (ulink.source.index >= source->num_pads ||
++           ulink.sink.index >= sink->num_pads)
++               return -EINVAL;
++
++       link = media_entity_find_link(&source->pads[ulink.source.index],
++                                     &sink->pads[ulink.sink.index]);
++       if (link == NULL)
++               return -EINVAL;
++
++       /* Setup the link on both entities. */
++       ret = __media_entity_setup_link(link, ulink.flags);
++
++       if (copy_to_user(_ulink, &ulink, sizeof(ulink)))
++               return -EFAULT;
++
++       return ret;
++}
++
+ static long media_device_ioctl(struct file *filp, unsigned int cmd,
+                               unsigned long arg)
+ {
+@@ -197,6 +235,13 @@ static long media_device_ioctl(struct file *filp, unsigned int cmd,
+                mutex_unlock(&dev->graph_mutex);
+                break;
+ 
++       case MEDIA_IOC_SETUP_LINK:
++               mutex_lock(&dev->graph_mutex);
++               ret = media_device_setup_link(dev,
++                               (struct media_link_desc __user *)arg);
++               mutex_unlock(&dev->graph_mutex);
++               break;
++
+        default:
+                ret = -ENOIOCTLCMD;
+        }
+diff --git a/drivers/media/media-entity.c b/drivers/media/media-entity.c
+index fe6bfd2..d703ce8 100644
+--- a/drivers/media/media-entity.c
++++ b/drivers/media/media-entity.c
+@@ -306,3 +306,158 @@ media_entity_create_link(struct media_entity *source, u16 source_pad,
+        return 0;
+ }
+ EXPORT_SYMBOL_GPL(media_entity_create_link);
++
++static int __media_entity_setup_link_notify(struct media_link *link, u32 flags)
++{
++       const u32 mask = MEDIA_LNK_FL_ENABLED;
++       int ret;
++
++       /* Notify both entities. */
++       ret = media_entity_call(link->source->entity, link_setup,
++                               link->source, link->sink, flags);
++       if (ret < 0 && ret != -ENOIOCTLCMD)
++               return ret;
++
++       ret = media_entity_call(link->sink->entity, link_setup,
++                               link->sink, link->source, flags);
++       if (ret < 0 && ret != -ENOIOCTLCMD) {
++               media_entity_call(link->source->entity, link_setup,
++                                 link->source, link->sink, link->flags);
++               return ret;
++       }
++
++       link->flags = (link->flags & ~mask) | (flags & mask);
++       link->reverse->flags = link->flags;
++
++       return 0;
++}
++
++/**
++ * __media_entity_setup_link - Configure a media link
++ * @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.
++ */
++int __media_entity_setup_link(struct media_link *link, u32 flags)
++{
++       struct media_device *mdev;
++       struct media_entity *source, *sink;
++       int ret = -EBUSY;
++
++       if (link == NULL)
++               return -EINVAL;
++
++       if (link->flags & MEDIA_LNK_FL_IMMUTABLE)
++               return link->flags == flags ? 0 : -EINVAL;
++
++       if (link->flags == flags)
++               return 0;
++
++       source = link->source->entity;
++       sink = link->sink->entity;
++
++       mdev = source->parent;
++
++       if ((flags & MEDIA_LNK_FL_ENABLED) && mdev->link_notify) {
++               ret = mdev->link_notify(link->source, link->sink,
++                                       MEDIA_LNK_FL_ENABLED);
++               if (ret < 0)
++                       return ret;
++       }
++
++       ret = __media_entity_setup_link_notify(link, flags);
++       if (ret < 0)
++               goto err;
++
++       if (!(flags & MEDIA_LNK_FL_ENABLED) && mdev->link_notify)
++               mdev->link_notify(link->source, link->sink, 0);
++
++       return 0;
++
++err:
++       if ((flags & MEDIA_LNK_FL_ENABLED) && mdev->link_notify)
++               mdev->link_notify(link->source, link->sink, 0);
++
++       return ret;
++}
++
++int media_entity_setup_link(struct media_link *link, u32 flags)
++{
++       int ret;
++
++       mutex_lock(&link->source->entity->parent->graph_mutex);
++       ret = __media_entity_setup_link(link, flags);
++       mutex_unlock(&link->source->entity->parent->graph_mutex);
++
++       return ret;
++}
++EXPORT_SYMBOL_GPL(media_entity_setup_link);
++
++/**
++ * 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.
++ */
++struct media_link *
++media_entity_find_link(struct media_pad *source, struct media_pad *sink)
++{
++       struct media_link *link;
++       unsigned int i;
++
++       for (i = 0; i < source->entity->num_links; ++i) {
++               link = &source->entity->links[i];
++
++               if (link->source->entity == source->entity &&
++                   link->source->index == source->index &&
++                   link->sink->entity == sink->entity &&
++                   link->sink->index == sink->index)
++                       return link;
++       }
++
++       return NULL;
++}
++EXPORT_SYMBOL_GPL(media_entity_find_link);
++
++/**
++ * media_entity_remote_source - Find the source pad at the remote end of a link
++ * @pad: Sink pad at the local end of the link
++ *
++ * Search for a remote source pad connected to the given sink 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.
++ */
++struct media_pad *media_entity_remote_source(struct media_pad *pad)
++{
++       unsigned int i;
++
++       for (i = 0; i < pad->entity->num_links; i++) {
++               struct media_link *link = &pad->entity->links[i];
++
++               if (!(link->flags & MEDIA_LNK_FL_ENABLED))
++                       continue;
++
++               if (link->source == pad)
++                       return link->sink;
++
++               if (link->sink == pad)
++                       return link->source;
++       }
++
++       return NULL;
++
++}
++EXPORT_SYMBOL_GPL(media_entity_remote_source);
+diff --git a/include/linux/media.h b/include/linux/media.h
+index 64c0313..2f67ed2 100644
+--- a/include/linux/media.h
++++ b/include/linux/media.h
+@@ -126,5 +126,6 @@ struct media_links_enum {
+ #define MEDIA_IOC_DEVICE_INFO          _IOWR('M', 1, struct media_device_info)
+ #define MEDIA_IOC_ENUM_ENTITIES                _IOWR('M', 2, struct media_entity_desc)
+ #define MEDIA_IOC_ENUM_LINKS           _IOWR('M', 3, struct media_links_enum)
++#define MEDIA_IOC_SETUP_LINK           _IOWR('M', 4, struct media_link_desc)
+ 
+ #endif /* __LINUX_MEDIA_H */
+diff --git a/include/media/media-device.h b/include/media/media-device.h
+index 260d59c..ad93e66 100644
+--- a/include/media/media-device.h
++++ b/include/media/media-device.h
+@@ -73,6 +73,9 @@ struct media_device {
+        spinlock_t lock;
+        /* Serializes graph operations. */
+        struct mutex graph_mutex;
++
++       int (*link_notify)(struct media_pad *source,
++                          struct media_pad *sink, u32 flags);
+ };
+ 
+ /* media_devnode to media_device */
+diff --git a/include/media/media-entity.h b/include/media/media-entity.h
+index 0954490..60fc7bd 100644
+--- a/include/media/media-entity.h
++++ b/include/media/media-entity.h
+@@ -39,6 +39,12 @@ struct media_pad {
+        unsigned long flags;            /* Pad flags (MEDIA_PAD_FL_*) */
+ };
+ 
++struct media_entity_operations {
++       int (*link_setup)(struct media_entity *entity,
++                         const struct media_pad *local,
++                         const struct media_pad *remote, u32 flags);
++};
++
+ struct media_entity {
+        struct list_head list;
+        struct media_device *parent;    /* Media device this entity belongs to*/
+@@ -59,6 +65,8 @@ struct media_entity {
+        struct media_pad *pads;         /* Pads array (num_pads elements) */
+        struct media_link *links;       /* Links array (max_links elements)*/
+ 
++       const struct media_entity_operations *ops;      /* Entity operations */
++
+        int use_count;                  /* Use count for the entity. */
+ 
+        union {
+@@ -108,6 +116,11 @@ int media_entity_init(struct media_entity *entity, u16 num_pads,
+ 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);
++int __media_entity_setup_link(struct media_link *link, u32 flags);
++int media_entity_setup_link(struct media_link *link, u32 flags);
++struct media_link *media_entity_find_link(struct media_pad *source,
++               struct media_pad *sink);
++struct media_pad *media_entity_remote_source(struct media_pad *pad);
+ 
+ struct media_entity *media_entity_get(struct media_entity *entity);
+ void media_entity_put(struct media_entity *entity);
+@@ -117,4 +130,8 @@ void media_entity_graph_walk_start(struct media_entity_graph *graph,
+ struct media_entity *
+ media_entity_graph_walk_next(struct media_entity_graph *graph);
+ 
++#define media_entity_call(entity, operation, args...)                  \
++       (((entity)->ops && (entity)->ops->operation) ?                  \
++        (entity)->ops->operation((entity) , ##args) : -ENOIOCTLCMD)
++
+ #endif
+-- 
+1.6.6.1
+