130 files changed, 5237 insertions, 1849 deletions
diff --git a/Documentation/DocBook/device-drivers.tmpl b/Documentation/DocBook/device-drivers.tmpl
index 7b3fcc5effcd..cdd8b24db68d 100644
--- a/Documentation/DocBook/device-drivers.tmpl
+++ b/Documentation/DocBook/device-drivers.tmpl
@@ -263,6 +263,7 @@ X!Isound/sound_firmware.c
 !Iinclude/media/lirc_dev.h
    </sect1>
    <sect1><title>Media Controller devices</title>
+!Pinclude/media/media-device.h Media Controller
 !Iinclude/media/media-device.h
 !Iinclude/media/media-devnode.h
 !Iinclude/media/media-entity.h
diff --git a/Documentation/DocBook/media/v4l/media-controller.xml b/Documentation/DocBook/media/v4l/media-controller.xml
index 873ac3a621f0..5f2fc07a93d7 100644
--- a/Documentation/DocBook/media/v4l/media-controller.xml
+++ b/Documentation/DocBook/media/v4l/media-controller.xml
@@ -58,21 +58,36 @@
    <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
+    devices and Linux Kernel interfaces are modelled as graph objects on
-    connected through pads.</para>
+    an oriented graph. The object types that constitute the graph are:</para>
-    <para>An entity is a basic media hardware or software building block. It can
+    <itemizedlist>
-    correspond to a large variety of logical blocks such as physical hardware
+    <listitem><para>An <emphasis role="bold">entity</emphasis>
-    devices (CMOS sensor for instance), logical hardware devices (a building
+    is a basic media hardware or software building block. It can correspond to
-    block in a System-on-Chip image processing pipeline), DMA channels or
+    a large variety of logical blocks such as physical hardware devices
-    physical connectors.</para>
+    (CMOS sensor for instance), logical hardware devices (a building block in
-    <para>A pad is a connection endpoint through which an entity can interact
+    a System-on-Chip image processing pipeline), DMA channels or physical
-    with other entities. Data (not restricted to video) produced by an entity
+    connectors.</para></listitem>
-    flows from the entity's output to one or more entity inputs. Pads should not
+    <listitem><para>An <emphasis role="bold">interface</emphasis>
-    be confused with physical pins at chip boundaries.</para>
+    is a graph representation of a Linux Kernel userspace API interface,
-    <para>A link is a point-to-point oriented connection between two pads,
+    like a device node or a sysfs file that controls one or more entities
-    either on the same entity or on different entities. Data flows from a source
+    in the graph.</para></listitem>
-    pad to a sink pad.</para>
+    <listitem><para>A <emphasis role="bold">pad</emphasis>
+    is a data 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></listitem>
+    <listitem><para>A <emphasis role="bold">data link</emphasis>
+    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></listitem>
+    <listitem><para>An <emphasis role="bold">interface link</emphasis>
+    is a point-to-point bidirectional control connection between a Linux
+    Kernel interface and an entity.m</para></listitem>
+    </itemizedlist>
  </section>
+  <!-- All non-ioctl specific data types go here. -->
+  &sub-media-types;
 </chapter>
 <appendix id="media-user-func">
@@ -83,6 +98,7 @@
  &sub-media-func-ioctl;
  <!-- All ioctls go here. -->
  &sub-media-ioc-device-info;
+  &sub-media-ioc-g-topology;
  &sub-media-ioc-enum-entities;
  &sub-media-ioc-enum-links;
  &sub-media-ioc-setup-link;
diff --git a/Documentation/DocBook/media/v4l/media-ioc-enum-entities.xml b/Documentation/DocBook/media/v4l/media-ioc-enum-entities.xml
index 5872f8bbf774..0c4f96bfc2de 100644
--- a/Documentation/DocBook/media/v4l/media-ioc-enum-entities.xml
+++ b/Documentation/DocBook/media/v4l/media-ioc-enum-entities.xml
@@ -59,15 +59,6 @@
    <para>Entity IDs can be non-contiguous. Applications must
    <emphasis>not</emphasis> try to enumerate entities by calling
    MEDIA_IOC_ENUM_ENTITIES with increasing id's until they get an error.</para>
-    <para>Two or more entities that share a common non-zero
-    <structfield>group_id</structfield> value are considered as logically
-    grouped. Groups are used to report
-    <itemizedlist>
-      <listitem><para>ALSA, VBI and video nodes that carry the same media
-      stream</para></listitem>
-      <listitem><para>lens and flash controllers associated with a sensor</para></listitem>
-    </itemizedlist>
-    </para>
    <table pgwide="1" frame="none" id="media-entity-desc">
      <title>struct <structname>media_entity_desc</structname></title>
@@ -106,7 +97,7 @@
            <entry><structfield>revision</structfield></entry>
            <entry></entry>
            <entry></entry>
-            <entry>Entity revision in a driver/hardware specific format.</entry>
+            <entry>Entity revision. Always zero (obsolete)</entry>
          </row>
          <row>
            <entry>__u32</entry>
@@ -120,7 +111,7 @@
            <entry><structfield>group_id</structfield></entry>
            <entry></entry>
            <entry></entry>
-            <entry>Entity group ID</entry>
+            <entry>Entity group ID. Always zero (obsolete)</entry>
          </row>
          <row>
            <entry>__u16</entry>
@@ -171,97 +162,6 @@
        </tbody>
      </tgroup>
    </table>
-    <table frame="none" pgwide="1" id="media-entity-type">
-      <title>Media entity types</title>
-      <tgroup cols="2">
-        <colspec colname="c1"/>
-        <colspec colname="c2"/>
-        <tbody valign="top">
-          <row>
-            <entry><constant>MEDIA_ENT_T_DEVNODE</constant></entry>
-            <entry>Unknown device node</entry>
-          </row>
-          <row>
-            <entry><constant>MEDIA_ENT_T_DEVNODE_V4L</constant></entry>
-            <entry>V4L video, radio or vbi device node</entry>
-          </row>
-          <row>
-            <entry><constant>MEDIA_ENT_T_DEVNODE_FB</constant></entry>
-            <entry>Frame buffer device node</entry>
-          </row>
-          <row>
-            <entry><constant>MEDIA_ENT_T_DEVNODE_ALSA</constant></entry>
-            <entry>ALSA card</entry>
-          </row>
-          <row>
-            <entry><constant>MEDIA_ENT_T_DEVNODE_DVB_FE</constant></entry>
-            <entry>DVB frontend devnode</entry>
-          </row>
-          <row>
-            <entry><constant>MEDIA_ENT_T_DEVNODE_DVB_DEMUX</constant></entry>
-            <entry>DVB demux devnode</entry>
-          </row>
-          <row>
-            <entry><constant>MEDIA_ENT_T_DEVNODE_DVB_DVR</constant></entry>
-            <entry>DVB DVR devnode</entry>
-          </row>
-          <row>
-            <entry><constant>MEDIA_ENT_T_DEVNODE_DVB_CA</constant></entry>
-            <entry>DVB CAM devnode</entry>
-          </row>
-          <row>
-            <entry><constant>MEDIA_ENT_T_DEVNODE_DVB_NET</constant></entry>
-            <entry>DVB network devnode</entry>
-          </row>
-          <row>
-            <entry><constant>MEDIA_ENT_T_V4L2_SUBDEV</constant></entry>
-            <entry>Unknown V4L sub-device</entry>
-          </row>
-          <row>
-            <entry><constant>MEDIA_ENT_T_V4L2_SUBDEV_SENSOR</constant></entry>
-            <entry>Video sensor</entry>
-          </row>
-          <row>
-            <entry><constant>MEDIA_ENT_T_V4L2_SUBDEV_FLASH</constant></entry>
-            <entry>Flash controller</entry>
-          </row>
-          <row>
-            <entry><constant>MEDIA_ENT_T_V4L2_SUBDEV_LENS</constant></entry>
-            <entry>Lens controller</entry>
-          </row>
-          <row>
-            <entry><constant>MEDIA_ENT_T_V4L2_SUBDEV_DECODER</constant></entry>
-            <entry>Video decoder, the basic function of the video decoder is to
-            accept analogue video from a wide variety of sources such as
-            broadcast, DVD players, cameras and video cassette recorders, in
-            either NTSC, PAL or HD format and still occasionally SECAM, separate
-            it into its component parts, luminance and chrominance, and output
-            it in some digital video standard, with appropriate embedded timing
-            signals.</entry>
-          </row>
-          <row>
-            <entry><constant>MEDIA_ENT_T_V4L2_SUBDEV_TUNER</constant></entry>
-            <entry>TV and/or radio tuner</entry>
-          </row>
-        </tbody>
-      </tgroup>
-    </table>
-    <table frame="none" pgwide="1" id="media-entity-flag">
-      <title>Media entity flags</title>
-      <tgroup cols="2">
-        <colspec colname="c1"/>
-        <colspec colname="c2"/>
-        <tbody valign="top">
-          <row>
-            <entry><constant>MEDIA_ENT_FL_DEFAULT</constant></entry>
-            <entry>Default entity for its type. Used to discover the default
-            audio, VBI and video devices, the default camera sensor, ...</entry>
-          </row>
-        </tbody>
-      </tgroup>
-    </table>
  </refsect1>
  <refsect1>
diff --git a/Documentation/DocBook/media/v4l/media-ioc-enum-links.xml b/Documentation/DocBook/media/v4l/media-ioc-enum-links.xml
index 74fb394ec667..2bbeea9f3e18 100644
--- a/Documentation/DocBook/media/v4l/media-ioc-enum-links.xml
+++ b/Documentation/DocBook/media/v4l/media-ioc-enum-links.xml
@@ -118,35 +118,6 @@
      </tgroup>
    </table>
-    <table frame="none" pgwide="1" id="media-pad-flag">
-      <title>Media pad flags</title>
-      <tgroup cols="2">
-        <colspec colname="c1"/>
-        <colspec colname="c2"/>
-        <tbody valign="top">
-          <row>
-            <entry><constant>MEDIA_PAD_FL_SINK</constant></entry>
-            <entry>Input pad, relative to the entity. Input pads sink data and
-            are targets of links.</entry>
-          </row>
-          <row>
-            <entry><constant>MEDIA_PAD_FL_SOURCE</constant></entry>
-            <entry>Output pad, relative to the entity. Output pads source data
-            and are origins of links.</entry>
-          </row>
-          <row>
-            <entry><constant>MEDIA_PAD_FL_MUST_CONNECT</constant></entry>
-            <entry>If this flag is set and the pad is linked to any other
-            pad, then at least one of those links must be enabled for the
-            entity to be able to stream. There could be temporary reasons
-            (e.g. device configuration dependent) for the pad to need
-            enabled links even when this flag isn't set; the absence of the
-            flag doesn't imply there is none.</entry>
-          </row>
-        </tbody>
-      </tgroup>
-    </table>
    <table pgwide="1" frame="none" id="media-link-desc">
      <title>struct <structname>media_link_desc</structname></title>
      <tgroup cols="3">
@@ -171,33 +142,6 @@
      </tgroup>
    </table>
-    <table frame="none" pgwide="1" id="media-link-flag">
-      <title>Media link flags</title>
-      <tgroup cols="2">
-        <colspec colname="c1"/>
-        <colspec colname="c2"/>
-        <tbody valign="top">
-          <row>
-            <entry><constant>MEDIA_LNK_FL_ENABLED</constant></entry>
-            <entry>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.</entry>
-          </row>
-          <row>
-            <entry><constant>MEDIA_LNK_FL_IMMUTABLE</constant></entry>
-            <entry>The link enabled state can't be modified at runtime. An
-            immutable link is always enabled.</entry>
-          </row>
-          <row>
-            <entry><constant>MEDIA_LNK_FL_DYNAMIC</constant></entry>
-            <entry>The link enabled state can be modified during streaming. This
-            flag is set by drivers and is read-only for applications.</entry>
-          </row>
-        </tbody>
-      </tgroup>
-    </table>
-    <para>One and only one of <constant>MEDIA_PAD_FL_SINK</constant> and
-    <constant>MEDIA_PAD_FL_SOURCE</constant> must be set for every pad.</para>
  </refsect1>
  <refsect1>
diff --git a/Documentation/DocBook/media/v4l/media-ioc-g-topology.xml b/Documentation/DocBook/media/v4l/media-ioc-g-topology.xml
new file mode 100644
index 000000000000..63152ab9efba
--- /dev/null
+++ b/Documentation/DocBook/media/v4l/media-ioc-g-topology.xml
@@ -0,0 +1,394 @@
+<refentry id="media-g-topology">
+  <refmeta>
+    <refentrytitle>ioctl MEDIA_IOC_G_TOPOLOGY</refentrytitle>
+    &manvol;
+  </refmeta>
+  <refnamediv>
+    <refname>MEDIA_IOC_G_TOPOLOGY</refname>
+    <refpurpose>Enumerate the graph topology and graph element properties</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_v2_topology *<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_G_TOPOLOGY</para>
+        </listitem>
+      </varlistentry>
+      <varlistentry>
+        <term><parameter>argp</parameter></term>
+        <listitem>
+          <para></para>
+        </listitem>
+      </varlistentry>
+    </variablelist>
+  </refsect1>
+  <refsect1>
+    <title>Description</title>
+    <para><emphasis role="bold">NOTE:</emphasis> This new ioctl is programmed to be added on Kernel 4.6. Its definition/arguments may change until its final version.</para>
+    <para>The typical usage of this ioctl is to call it twice.
+    On the first call, the structure defined at &media-v2-topology; should
+    be zeroed. At return, if no errors happen, this ioctl will return the
+    <constant>topology_version</constant> and the total number of entities,
+    interfaces, pads and links.</para>
+    <para>Before the second call, the userspace should allocate arrays to
+    store the graph elements that are desired, putting the pointers to them
+    at the ptr_entities, ptr_interfaces, ptr_links and/or ptr_pads, keeping
+    the other values untouched.</para>
+    <para>If the <constant>topology_version</constant> remains the same, the
+    ioctl should fill the desired arrays with the media graph elements.</para>
+    <table pgwide="1" frame="none" id="media-v2-topology">
+      <title>struct <structname>media_v2_topology</structname></title>
+      <tgroup cols="5">
+        <colspec colname="c1" />
+        <colspec colname="c2" />
+        <colspec colname="c3" />
+        <colspec colname="c4" />
+        <colspec colname="c5" />
+        <tbody valign="top">
+          <row>
+            <entry>__u64</entry>
+            <entry><structfield>topology_version</structfield></entry>
+            <entry></entry>
+            <entry></entry>
+            <entry>Version of the media graph topology. When the graph is
+                    created, this field starts with zero. Every time a graph
+                    element is added or removed, this field is
+                    incremented.</entry>
+          </row>
+          <row>
+            <entry>__u64</entry>
+            <entry><structfield>num_entities</structfield></entry>
+            <entry></entry>
+            <entry></entry>
+            <entry>Number of entities in the graph</entry>
+          </row>
+          <row>
+            <entry>__u64</entry>
+            <entry><structfield>ptr_entities</structfield></entry>
+            <entry></entry>
+            <entry></entry>
+            <entry>A pointer to a memory area where the entities array
+                   will be stored, converted to a 64-bits integer.
+                   It can be zero. if zero, the ioctl won't store the
+                   entities. It will just update
+                   <constant>num_entities</constant></entry>
+          </row>
+          <row>
+            <entry>__u64</entry>
+            <entry><structfield>num_interfaces</structfield></entry>
+            <entry></entry>
+            <entry></entry>
+            <entry>Number of interfaces in the graph</entry>
+          </row>
+          <row>
+            <entry>__u64</entry>
+            <entry><structfield>ptr_interfaces</structfield></entry>
+            <entry></entry>
+            <entry></entry>
+            <entry>A pointer to a memory area where the interfaces array
+                   will be stored, converted to a 64-bits integer.
+                   It can be zero. if zero, the ioctl won't store the
+                   interfaces. It will just update
+                   <constant>num_interfaces</constant></entry>
+          </row>
+          <row>
+            <entry>__u64</entry>
+            <entry><structfield>num_pads</structfield></entry>
+            <entry></entry>
+            <entry></entry>
+            <entry>Total number of pads in the graph</entry>
+          </row>
+          <row>
+            <entry>__u64</entry>
+            <entry><structfield>ptr_pads</structfield></entry>
+            <entry></entry>
+            <entry></entry>
+            <entry>A pointer to a memory area where the pads array
+                   will be stored, converted to a 64-bits integer.
+                   It can be zero. if zero, the ioctl won't store the
+                   pads. It will just update
+                   <constant>num_pads</constant></entry>
+          </row>
+          <row>
+            <entry>__u64</entry>
+            <entry><structfield>num_links</structfield></entry>
+            <entry></entry>
+            <entry></entry>
+            <entry>Total number of data and interface links in the graph</entry>
+          </row>
+          <row>
+            <entry>__u64</entry>
+            <entry><structfield>ptr_links</structfield></entry>
+            <entry></entry>
+            <entry></entry>
+            <entry>A pointer to a memory area where the links array
+                   will be stored, converted to a 64-bits integer.
+                   It can be zero. if zero, the ioctl won't store the
+                   links. It will just update
+                   <constant>num_links</constant></entry>
+          </row>
+        </tbody>
+      </tgroup>
+    </table>
+    <table pgwide="1" frame="none" id="media-v2-entity">
+      <title>struct <structname>media_v2_entity</structname></title>
+      <tgroup cols="5">
+        <colspec colname="c1" />
+        <colspec colname="c2" />
+        <colspec colname="c3" />
+        <colspec colname="c4" />
+        <colspec colname="c5" />
+        <tbody valign="top">
+          <row>
+            <entry>__u32</entry>
+            <entry><structfield>id</structfield></entry>
+            <entry></entry>
+            <entry></entry>
+            <entry>Unique ID for the entity.</entry>
+          </row>
+          <row>
+            <entry>char</entry>
+            <entry><structfield>name</structfield>[64]</entry>
+            <entry></entry>
+            <entry></entry>
+            <entry>Entity name as an UTF-8 NULL-terminated string.</entry>
+          </row>
+          <row>
+            <entry>__u32</entry>
+            <entry><structfield>function</structfield></entry>
+            <entry></entry>
+            <entry></entry>
+            <entry>Entity main function, see <xref linkend="media-entity-type" /> for details.</entry>
+          </row>
+          <row>
+            <entry>__u32</entry>
+            <entry><structfield>reserved</structfield>[12]</entry>
+            <entry>Reserved for future extensions. Drivers and applications must
+            set this array to zero.</entry>
+          </row>
+        </tbody>
+      </tgroup>
+    </table>
+    <table pgwide="1" frame="none" id="media-v2-interface">
+      <title>struct <structname>media_v2_interface</structname></title>
+      <tgroup cols="5">
+        <colspec colname="c1" />
+        <colspec colname="c2" />
+        <colspec colname="c3" />
+        <colspec colname="c4" />
+        <colspec colname="c5" />
+        <tbody valign="top">
+          <row>
+            <entry>__u32</entry>
+            <entry><structfield>id</structfield></entry>
+            <entry></entry>
+            <entry></entry>
+            <entry>Unique ID for the interface.</entry>
+          </row>
+          <row>
+            <entry>__u32</entry>
+            <entry><structfield>intf_type</structfield></entry>
+            <entry></entry>
+            <entry></entry>
+            <entry>Interface type, see <xref linkend="media-intf-type" /> for details.</entry>
+          </row>
+          <row>
+            <entry>__u32</entry>
+            <entry><structfield>flags</structfield></entry>
+            <entry></entry>
+            <entry></entry>
+            <entry>Interface flags. Currently unused.</entry>
+          </row>
+          <row>
+            <entry>__u32</entry>
+            <entry><structfield>reserved</structfield>[9]</entry>
+            <entry></entry>
+            <entry></entry>
+            <entry>Reserved for future extensions. Drivers and applications must
+            set this array to zero.</entry>
+          </row>
+          <row>
+            <entry>struct media_v2_intf_devnode</entry>
+            <entry><structfield>devnode</structfield></entry>
+            <entry></entry>
+            <entry></entry>
+            <entry>Used only for device node interfaces. See <xref linkend="media-v2-intf-devnode" /> for details..</entry>
+          </row>
+        </tbody>
+      </tgroup>
+    </table>
+    <table pgwide="1" frame="none" id="media-v2-intf-devnode">
+      <title>struct <structname>media_v2_interface</structname></title>
+      <tgroup cols="5">
+        <colspec colname="c1" />
+        <colspec colname="c2" />
+        <colspec colname="c3" />
+        <colspec colname="c4" />
+        <colspec colname="c5" />
+        <tbody valign="top">
+          <row>
+            <entry>__u32</entry>
+            <entry><structfield>major</structfield></entry>
+            <entry></entry>
+            <entry></entry>
+            <entry>Device node major number.</entry>
+          </row>
+          <row>
+            <entry>__u32</entry>
+            <entry><structfield>minor</structfield></entry>
+            <entry></entry>
+            <entry></entry>
+            <entry>Device node minor number.</entry>
+          </row>
+        </tbody>
+      </tgroup>
+    </table>
+    <table pgwide="1" frame="none" id="media-v2-pad">
+      <title>struct <structname>media_v2_pad</structname></title>
+      <tgroup cols="5">
+        <colspec colname="c1" />
+        <colspec colname="c2" />
+        <colspec colname="c3" />
+        <colspec colname="c4" />
+        <colspec colname="c5" />
+        <tbody valign="top">
+          <row>
+            <entry>__u32</entry>
+            <entry><structfield>id</structfield></entry>
+            <entry></entry>
+            <entry></entry>
+            <entry>Unique ID for the pad.</entry>
+          </row>
+          <row>
+            <entry>__u32</entry>
+            <entry><structfield>entity_id</structfield></entry>
+            <entry></entry>
+            <entry></entry>
+            <entry>Unique ID for the entity where this pad belongs.</entry>
+          </row>
+          <row>
+            <entry>__u32</entry>
+            <entry><structfield>flags</structfield></entry>
+            <entry></entry>
+            <entry></entry>
+            <entry>Pad flags, see <xref linkend="media-pad-flag" /> for more details.</entry>
+          </row>
+          <row>
+            <entry>__u32</entry>
+            <entry><structfield>reserved</structfield>[9]</entry>
+            <entry></entry>
+            <entry></entry>
+            <entry>Reserved for future extensions. Drivers and applications must
+            set this array to zero.</entry>
+          </row>
+        </tbody>
+      </tgroup>
+    </table>
+    <table pgwide="1" frame="none" id="media-v2-link">
+      <title>struct <structname>media_v2_pad</structname></title>
+      <tgroup cols="5">
+        <colspec colname="c1" />
+        <colspec colname="c2" />
+        <colspec colname="c3" />
+        <colspec colname="c4" />
+        <colspec colname="c5" />
+        <tbody valign="top">
+          <row>
+            <entry>__u32</entry>
+            <entry><structfield>id</structfield></entry>
+            <entry></entry>
+            <entry></entry>
+            <entry>Unique ID for the pad.</entry>
+          </row>
+          <row>
+            <entry>__u32</entry>
+            <entry><structfield>source_id</structfield></entry>
+            <entry></entry>
+            <entry></entry>
+            <entry>
+               <para>On pad to pad links: unique ID for the source pad.</para>
+               <para>On interface to entity links: unique ID for the interface.</para>
+            </entry>
+          </row>
+          <row>
+            <entry>__u32</entry>
+            <entry><structfield>sink_id</structfield></entry>
+            <entry></entry>
+            <entry></entry>
+            <entry>
+               <para>On pad to pad links: unique ID for the sink pad.</para>
+               <para>On interface to entity links: unique ID for the entity.</para>
+            </entry>
+          </row>
+          <row>
+            <entry>__u32</entry>
+            <entry><structfield>flags</structfield></entry>
+            <entry></entry>
+            <entry></entry>
+            <entry>Link flags, see <xref linkend="media-link-flag" /> for more details.</entry>
+          </row>
+          <row>
+            <entry>__u32</entry>
+            <entry><structfield>reserved</structfield>[5]</entry>
+            <entry></entry>
+            <entry></entry>
+            <entry>Reserved for future extensions. Drivers and applications must
+            set this array to zero.</entry>
+          </row>
+        </tbody>
+      </tgroup>
+    </table>
+  </refsect1>
+  <refsect1>
+    &return-value;
+    <variablelist>
+      <varlistentry>
+        <term><errorcode>ENOSPC</errorcode></term>
+        <listitem>
+          <para>This is returned when either one or more of the num_entities,
+          num_interfaces, num_links or num_pads are non-zero and are smaller
+          than the actual number of elements inside the graph. This may happen
+          if the <constant>topology_version</constant> changed when compared
+          to the last time this ioctl was called. Userspace should usually
+          free the area for the pointers, zero the struct elements and call
+          this ioctl again.</para>
+        </listitem>
+      </varlistentry>
+    </variablelist>
+  </refsect1>
+</refentry>
diff --git a/Documentation/DocBook/media/v4l/media-types.xml b/Documentation/DocBook/media/v4l/media-types.xml
new file mode 100644
index 000000000000..1af384250910
--- /dev/null
+++ b/Documentation/DocBook/media/v4l/media-types.xml
@@ -0,0 +1,240 @@
+<section id="media-controller-types">
+<title>Types and flags used to represent the media graph elements</title>
+    <table frame="none" pgwide="1" id="media-entity-type">
+      <title>Media entity types</title>
+      <tgroup cols="2">
+        <colspec colname="c1"/>
+        <colspec colname="c2"/>
+        <tbody valign="top">
+          <row>
+            <entry><constant>MEDIA_ENT_F_UNKNOWN</constant> and <constant>MEDIA_ENT_F_V4L2_SUBDEV_UNKNOWN</constant></entry>
+            <entry>Unknown entity. That generally indicates that
+            a driver didn't initialize properly the entity, with is a Kernel bug</entry>
+          </row>
+          <row>
+            <entry><constant>MEDIA_ENT_F_IO_V4L</constant></entry>
+            <entry>Data streaming input and/or output entity.</entry>
+          </row>
+          <row>
+            <entry><constant>MEDIA_ENT_F_IO_VBI</constant></entry>
+            <entry>V4L VBI streaming input or output entity</entry>
+          </row>
+          <row>
+            <entry><constant>MEDIA_ENT_F_IO_SWRADIO</constant></entry>
+            <entry>V4L Software Digital Radio (SDR) streaming input or output entity</entry>
+          </row>
+          <row>
+            <entry><constant>MEDIA_ENT_F_IO_DTV</constant></entry>
+            <entry>DVB Digital TV streaming input or output entity</entry>
+          </row>
+          <row>
+            <entry><constant>MEDIA_ENT_F_DTV_DEMOD</constant></entry>
+            <entry>Digital TV demodulator entity.</entry>
+          </row>
+          <row>
+            <entry><constant>MEDIA_ENT_F_TS_DEMUX</constant></entry>
+            <entry>MPEG Transport stream demux entity. Could be implemented on hardware or in Kernelspace by the Linux DVB subsystem.</entry>
+          </row>
+          <row>
+            <entry><constant>MEDIA_ENT_F_DTV_CA</constant></entry>
+            <entry>Digital TV Conditional Access module (CAM) entity</entry>
+          </row>
+          <row>
+            <entry><constant>MEDIA_ENT_F_DTV_NET_DECAP</constant></entry>
+            <entry>Digital TV network ULE/MLE desencapsulation entity. Could be implemented on hardware or in Kernelspace</entry>
+          </row>
+          <row>
+            <entry><constant>MEDIA_ENT_F_CONN_RF</constant></entry>
+            <entry>Connector for a Radio Frequency (RF) signal.</entry>
+          </row>
+          <row>
+            <entry><constant>MEDIA_ENT_F_CONN_SVIDEO</constant></entry>
+            <entry>Connector for a S-Video signal.</entry>
+          </row>
+          <row>
+            <entry><constant>MEDIA_ENT_F_CONN_COMPOSITE</constant></entry>
+            <entry>Connector for a RGB composite signal.</entry>
+          </row>
+          <row>
+            <entry><constant>MEDIA_ENT_F_CONN_TEST</constant></entry>
+            <entry>Connector for a test generator.</entry>
+          </row>
+          <row>
+            <entry><constant>MEDIA_ENT_F_CAM_SENSOR</constant></entry>
+            <entry>Camera video sensor entity.</entry>
+          </row>
+          <row>
+            <entry><constant>MEDIA_ENT_F_FLASH</constant></entry>
+            <entry>Flash controller entity.</entry>
+          </row>
+          <row>
+            <entry><constant>MEDIA_ENT_F_LENS</constant></entry>
+            <entry>Lens controller entity.</entry>
+          </row>
+          <row>
+            <entry><constant>MEDIA_ENT_F_ATV_DECODER</constant></entry>
+            <entry>Analog video decoder, the basic function of the video decoder
+            is to accept analogue video from a wide variety of sources such as
+            broadcast, DVD players, cameras and video cassette recorders, in
+            either NTSC, PAL, SECAM or HD format, separating the stream
+            into its component parts, luminance and chrominance, and output
+            it in some digital video standard, with appropriate timing
+            signals.</entry>
+          </row>
+          <row>
+            <entry><constant>MEDIA_ENT_F_TUNER</constant></entry>
+            <entry>Digital TV, analog TV, radio and/or software radio tuner.</entry>
+          </row>
+        </tbody>
+      </tgroup>
+    </table>
+    <table frame="none" pgwide="1" id="media-entity-flag">
+      <title>Media entity flags</title>
+      <tgroup cols="2">
+        <colspec colname="c1"/>
+        <colspec colname="c2"/>
+        <tbody valign="top">
+          <row>
+            <entry><constant>MEDIA_ENT_FL_DEFAULT</constant></entry>
+            <entry>Default entity for its type. Used to discover the default
+            audio, VBI and video devices, the default camera sensor, ...</entry>
+          </row>
+          <row>
+            <entry><constant>MEDIA_ENT_FL_CONNECTOR</constant></entry>
+            <entry>The entity represents a data conector</entry>
+          </row>
+        </tbody>
+      </tgroup>
+    </table>
+    <table frame="none" pgwide="1" id="media-intf-type">
+      <title>Media interface types</title>
+      <tgroup cols="3">
+        <colspec colname="c1"/>
+        <colspec colname="c2"/>
+        <colspec colname="c3"/>
+        <tbody valign="top">
+          <row>
+            <entry><constant>MEDIA_INTF_T_DVB_FE</constant></entry>
+            <entry>Device node interface for the Digital TV frontend</entry>
+            <entry>typically, /dev/dvb/adapter?/frontend?</entry>
+          </row>
+          <row>
+            <entry><constant>MEDIA_INTF_T_DVB_DEMUX</constant></entry>
+            <entry>Device node interface for the Digital TV demux</entry>
+            <entry>typically, /dev/dvb/adapter?/demux?</entry>
+          </row>
+          <row>
+            <entry><constant>MEDIA_INTF_T_DVB_DVR</constant></entry>
+            <entry>Device node interface for the Digital TV DVR</entry>
+            <entry>typically, /dev/dvb/adapter?/dvr?</entry>
+          </row>
+          <row>
+            <entry><constant>MEDIA_INTF_T_DVB_CA</constant></entry>
+            <entry>Device node interface for the Digital TV Conditional Access</entry>
+            <entry>typically, /dev/dvb/adapter?/ca?</entry>
+          </row>
+          <row>
+            <entry><constant>MEDIA_INTF_T_DVB_FE</constant></entry>
+            <entry>Device node interface for the Digital TV network control</entry>
+            <entry>typically, /dev/dvb/adapter?/net?</entry>
+          </row>
+          <row>
+            <entry><constant>MEDIA_INTF_T_V4L_VIDEO</constant></entry>
+            <entry>Device node interface for video (V4L)</entry>
+            <entry>typically, /dev/video?</entry>
+          </row>
+          <row>
+            <entry><constant>MEDIA_INTF_T_V4L_VBI</constant></entry>
+            <entry>Device node interface for VBI (V4L)</entry>
+            <entry>typically, /dev/vbi?</entry>
+          </row>
+          <row>
+            <entry><constant>MEDIA_INTF_T_V4L_RADIO</constant></entry>
+            <entry>Device node interface for radio (V4L)</entry>
+            <entry>typically, /dev/vbi?</entry>
+          </row>
+          <row>
+            <entry><constant>MEDIA_INTF_T_V4L_SUBDEV</constant></entry>
+            <entry>Device node interface for a V4L subdevice</entry>
+            <entry>typically, /dev/v4l-subdev?</entry>
+          </row>
+          <row>
+            <entry><constant>MEDIA_INTF_T_V4L_SWRADIO</constant></entry>
+            <entry>Device node interface for Software Defined Radio (V4L)</entry>
+            <entry>typically, /dev/swradio?</entry>
+          </row>
+        </tbody>
+      </tgroup>
+    </table>
+    <table frame="none" pgwide="1" id="media-pad-flag">
+      <title>Media pad flags</title>
+      <tgroup cols="2">
+        <colspec colname="c1"/>
+        <colspec colname="c2"/>
+        <tbody valign="top">
+          <row>
+            <entry><constant>MEDIA_PAD_FL_SINK</constant></entry>
+            <entry>Input pad, relative to the entity. Input pads sink data and
+            are targets of links.</entry>
+          </row>
+          <row>
+            <entry><constant>MEDIA_PAD_FL_SOURCE</constant></entry>
+            <entry>Output pad, relative to the entity. Output pads source data
+            and are origins of links.</entry>
+          </row>
+          <row>
+            <entry><constant>MEDIA_PAD_FL_MUST_CONNECT</constant></entry>
+            <entry>If this flag is set and the pad is linked to any other
+            pad, then at least one of those links must be enabled for the
+            entity to be able to stream. There could be temporary reasons
+            (e.g. device configuration dependent) for the pad to need
+            enabled links even when this flag isn't set; the absence of the
+            flag doesn't imply there is none.</entry>
+          </row>
+        </tbody>
+      </tgroup>
+    </table>
+    <para>One and only one of <constant>MEDIA_PAD_FL_SINK</constant> and
+    <constant>MEDIA_PAD_FL_SOURCE</constant> must be set for every pad.</para>
+    <table frame="none" pgwide="1" id="media-link-flag">
+      <title>Media link flags</title>
+      <tgroup cols="2">
+        <colspec colname="c1"/>
+        <colspec colname="c2"/>
+        <tbody valign="top">
+          <row>
+            <entry><constant>MEDIA_LNK_FL_ENABLED</constant></entry>
+            <entry>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.</entry>
+          </row>
+          <row>
+            <entry><constant>MEDIA_LNK_FL_IMMUTABLE</constant></entry>
+            <entry>The link enabled state can't be modified at runtime. An
+            immutable link is always enabled.</entry>
+          </row>
+          <row>
+            <entry><constant>MEDIA_LNK_FL_DYNAMIC</constant></entry>
+            <entry>The link enabled state can be modified during streaming. This
+            flag is set by drivers and is read-only for applications.</entry>
+          </row>
+          <row>
+            <entry><constant>MEDIA_LNK_FL_LINK_TYPE</constant></entry>
+            <entry><para>This is a bitmask that defines the type of the link.
+                   Currently, two types of links are supported:</para>
+            <para><constant>MEDIA_LNK_FL_DATA_LINK</constant>
+            if the link is between two pads</para>
+            <para><constant>MEDIA_LNK_FL_INTERFACE_LINK</constant>
+            if the link is between an interface and an entity</para></entry>
+          </row>
+        </tbody>
+      </tgroup>
+    </table>
+</section>
diff --git a/Documentation/media-framework.txt b/Documentation/media-framework.txt
deleted file mode 100644
index f552a75c0e70..000000000000
--- a/Documentation/media-framework.txt
+++ /dev/null
@@ -1,372 +0,0 @@
-Linux kernel media framework
-============================
-This document describes the Linux kernel media framework, its data structures,
-functions and their usage.
-Introduction
------------
-The media controller API is documented in DocBook format in
-Documentation/DocBook/media/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
-modelled 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
------------
-A media device is represented by a struct media_device instance, defined in
-include/media/media-device.h. Allocation of the structure is handled by the
-media device driver, usually by embedding the media_device instance in a
-larger driver-specific structure.
-Drivers register media device instances by calling
-        media_device_register(struct media_device *mdev);
-The caller is responsible for initializing the media_device structure before
-registration. The following fields must be set:
- - dev must point to the parent device (usually a pci_dev, usb_interface or
-   platform_device instance).
- - model must be filled with the device model name as a NUL-terminated UTF-8
-   string. The device/model revision must not be stored in this field.
-The following fields are optional:
- - serial is a unique serial number stored as a NUL-terminated ASCII string.
-   The field is big enough to store a GUID in text form. If the hardware
-   doesn't provide a unique serial number this field must be left empty.
- - bus_info represents the location of the device in the system as a
-   NUL-terminated ASCII string. For PCI/PCIe devices bus_info must be set to
-   "PCI:" (or "PCIe:") followed by the value of pci_name(). For USB devices,
-   the usb_make_path() function must be used. This field is used by
-   applications to distinguish between otherwise identical devices that don't
-   provide a serial number.
- - hw_revision is the hardware device revision in a driver-specific format.
-   When possible the revision should be formatted with the KERNEL_VERSION
-   macro.
- - driver_version is formatted with the KERNEL_VERSION macro. The version
-   minor must be incremented when new features are added to the userspace API
-   without breaking binary compatibility. The version major must be
-   incremented when binary compatibility is broken.
-Upon successful registration a character device named media[0-9]+ is created.
-The device major and minor numbers are dynamic. The model name is exported as
-a sysfs attribute.
-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_SINK indicates that the pad supports sinking data.
-        MEDIA_PAD_FL_SOURCE indicates that the pad supports sourcing data.
-One and only one of MEDIA_PAD_FL_SINK and MEDIA_PAD_FL_SOURCE 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
-targeting 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.
-Graph traversal
---------------
-The media framework provides APIs to iterate over entities in a graph.
-To iterate over all entities belonging to a media device, drivers can use the
-media_device_for_each_entity macro, defined in include/media/media-device.h.
-        struct media_entity *entity;
-        media_device_for_each_entity(entity, mdev) {
-                /* entity will point to each entity in turn */
-                ...
-        }
-Drivers might also need to iterate over all entities in a graph that can be
-reached only through enabled links starting at a given entity. The media
-framework provides a depth-first graph traversal API for that purpose.
-Note that graphs with cycles (whether directed or undirected) are *NOT*
-supported by the graph traversal API. To prevent infinite loops, the graph
-traversal code limits the maximum depth to MEDIA_ENTITY_ENUM_MAX_DEPTH,
-currently defined as 16.
-Drivers initiate a graph traversal by calling
-        media_entity_graph_walk_start(struct media_entity_graph *graph,
-                                      struct media_entity *entity);
-The graph structure, provided by the caller, is initialized to start graph
-traversal at the given entity.
-Drivers can then retrieve the next entity by calling
-        media_entity_graph_walk_next(struct media_entity_graph *graph);
-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_pad(struct media_pad *pad);
-Refer to the kerneldoc documentation for more information.
-Use count and power handling
----------------------------
-Due to the wide differences between drivers regarding power management needs,
-the media controller does not implement power management. However, the
-media_entity structure includes a use_count field that media drivers can use to
-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 enabled,
-the link_setup operation must return -EBUSY and can't implicitly disable the
-first enabled link.
-Pipelines and media streams
---------------------------
-When starting streaming, drivers must notify all entities in the pipeline to
-prevent link states from being modified during streaming by calling
-        media_entity_pipeline_start(struct media_entity *entity,
-                                    struct media_pipeline *pipe);
-The function will mark all entities connected to the given entity through
-enabled links, either directly or indirectly, as streaming.
-The media_pipeline instance pointed to by the pipe argument will be stored in
-every entity in the pipeline. Drivers should embed the media_pipeline structure
-in higher-level pipeline structures and can then access the pipeline through
-the media_entity pipe field.
-Calls to media_entity_pipeline_start() can be nested. The pipeline pointer must
-be identical for all nested calls to the function.
-media_entity_pipeline_start() may return an error. In that case, it will
-clean up any of the changes it did by itself.
-When stopping the stream, drivers must notify the entities with
-        media_entity_pipeline_stop(struct media_entity *entity);
-If multiple calls to media_entity_pipeline_start() have been made the same
-number of media_entity_pipeline_stop() calls are required to stop streaming. The
-media_entity pipe field is reset to NULL on the last nested stop call.
-Link configuration will fail with -EBUSY by default if either end of the link is
-a streaming entity. Links that can be modified while streaming must be marked
-with the MEDIA_LNK_FL_DYNAMIC flag.
-If other operations need to be disallowed on streaming entities (such as
-changing entities configuration parameters) drivers can explicitly check the
-media_entity stream_count field to find out if an entity is streaming. This
-operation must be done with the media_device graph_mutex held.
-Link validation
---------------
-Link validation is performed by media_entity_pipeline_start() for any
-entity which has sink pads in the pipeline. The
-media_entity::link_validate() callback is used for that purpose. In
-link_validate() callback, entity driver should check that the properties of
-the source pad of the connected entity and its own sink pad match. It is up
-to the type of the entity (and in the end, the properties of the hardware)
-what matching actually means.
-Subsystems should facilitate link validation by providing subsystem specific
-helper functions to provide easy access for commonly needed information, and
-in the end provide a way to use driver-specific callbacks.
diff --git a/Documentation/video4linux/v4l2-framework.txt b/Documentation/video4linux/v4l2-framework.txt
index 75d5c18d689a..fa41608ab2b4 100644
--- a/Documentation/video4linux/v4l2-framework.txt
+++ b/Documentation/video4linux/v4l2-framework.txt
@@ -295,16 +295,16 @@ module owner. This is done for you if you use the i2c helper functions.
 If integration with the media framework is needed, you must initialize the
 media_entity struct embedded in the v4l2_subdev struct (entity field) by
-calling media_entity_init():
+calling media_entity_pads_init(), if the entity has pads:
        struct media_pad *pads = &my_sd->pads;
        int err;
-        err = media_entity_init(&sd->entity, npads, pads, 0);
+        err = media_entity_pads_init(&sd->entity, npads, pads);
 The pads array must have been previously initialized. There is no need to
-manually set the struct media_entity type and name fields, but the revision
+manually set the struct media_entity function and name fields, but the
-field must be initialized if needed.
+revision field must be initialized if needed.
 A reference to the entity will be automatically acquired/released when the
 subdev device node (if any) is opened/closed.
@@ -695,12 +695,12 @@ difference is that the inode argument is omitted since it is never used.
 If integration with the media framework is needed, you must initialize the
 media_entity struct embedded in the video_device struct (entity field) by
-calling media_entity_init():
+calling media_entity_pads_init():
        struct media_pad *pad = &my_vdev->pad;
        int err;
-        err = media_entity_init(&vdev->entity, 1, pad, 0);
+        err = media_entity_pads_init(&vdev->entity, 1, pad);
 The pads array must have been previously initialized. There is no need to
 manually set the struct media_entity type and name fields.
diff --git a/Documentation/zh_CN/video4linux/v4l2-framework.txt b/Documentation/zh_CN/video4linux/v4l2-framework.txt
index 2b828e631e31..698660b7f21f 100644
--- a/Documentation/zh_CN/video4linux/v4l2-framework.txt
+++ b/Documentation/zh_CN/video4linux/v4l2-framework.txt
@@ -289,13 +289,13 @@ struct v4l2_subdev_ops {
 然后，你必须用一个唯一的名字初始化 subdev->name，并初始化模块的
 owner 域。若使用 i2c 辅助函数，这些都会帮你处理好。
-若需同媒体框架整合，你必须调用 media_entity_init() 初始化 v4l2_subdev
+若需同媒体框架整合，你必须调用 media_entity_pads_init() 初始化 v4l2_subdev
 结构体中的 media_entity 结构体（entity 域）：
        struct media_pad *pads = &my_sd->pads;
        int err;
-        err = media_entity_init(&sd->entity, npads, pads, 0);
+        err = media_entity_pads_init(&sd->entity, npads, pads);
 pads 数组必须预先初始化。无须手动设置 media_entity 的 type 和
 name 域，但如有必要，revision 域必须初始化。
@@ -596,13 +596,13 @@ void v4l2_disable_ioctl(struct video_device *vdev, unsigned int cmd);
 v4l2_file_operations 结构体是 file_operations 的一个子集。其主要
 区别在于：因 inode 参数从未被使用，它将被忽略。
-如果需要与媒体框架整合，你必须通过调用 media_entity_init() 初始化
+如果需要与媒体框架整合，你必须通过调用 media_entity_pads_init() 初始化
 嵌入在 video_device 结构体中的 media_entity（entity 域）结构体：
        struct media_pad *pad = &my_vdev->pad;
        int err;
-        err = media_entity_init(&vdev->entity, 1, pad, 0);
+        err = media_entity_pads_init(&vdev->entity, 1, pad);
 pads 数组必须预先初始化。没有必要手动设置 media_entity 的 type 和
 name 域。
diff --git a/drivers/media/Kconfig b/drivers/media/Kconfig
index 9264ea73b3be..a8518fb3bca7 100644
--- a/drivers/media/Kconfig
+++ b/drivers/media/Kconfig
@@ -97,7 +97,6 @@ config MEDIA_CONTROLLER
 config MEDIA_CONTROLLER_DVB
        bool "Enable Media controller for DVB (EXPERIMENTAL)"
        depends on MEDIA_CONTROLLER
-        depends on BROKEN
        ---help---
          Enable the media controller API support for DVB.
diff --git a/drivers/media/common/siano/smsdvb-main.c b/drivers/media/common/siano/smsdvb-main.c
index f4305ae800f4..d31f468830cf 100644
--- a/drivers/media/common/siano/smsdvb-main.c
+++ b/drivers/media/common/siano/smsdvb-main.c
@@ -617,6 +617,7 @@ static void smsdvb_media_device_unregister(struct smsdvb_client_t *client)
        if (!coredev->media_dev)
                return;
        media_device_unregister(coredev->media_dev);
+        media_device_cleanup(coredev->media_dev);
        kfree(coredev->media_dev);
        coredev->media_dev = NULL;
 #endif
@@ -1183,7 +1184,11 @@ static int smsdvb_hotplug(struct smscore_device_t *coredev,
        if (smsdvb_debugfs_create(client) < 0)
                pr_info("failed to create debugfs node\n");
-        dvb_create_media_graph(&client->adapter);
+        rc = dvb_create_media_graph(&client->adapter, true);
+        if (rc < 0) {
+                pr_err("dvb_create_media_graph failed %d\n", rc);
+                goto client_error;
+        }
        pr_info("DVB interface registered.\n");
        return 0;
diff --git a/drivers/media/dvb-core/dmxdev.c b/drivers/media/dvb-core/dmxdev.c
index ea9abde902e9..a168cbe1c998 100644
--- a/drivers/media/dvb-core/dmxdev.c
+++ b/drivers/media/dvb-core/dmxdev.c
@@ -1244,9 +1244,9 @@ int dvb_dmxdev_init(struct dmxdev *dmxdev, struct dvb_adapter *dvb_adapter)
        }
        dvb_register_device(dvb_adapter, &dmxdev->dvbdev, &dvbdev_demux, dmxdev,
-                            DVB_DEVICE_DEMUX);
+                            DVB_DEVICE_DEMUX, dmxdev->filternum);
        dvb_register_device(dvb_adapter, &dmxdev->dvr_dvbdev, &dvbdev_dvr,
-                            dmxdev, DVB_DEVICE_DVR);
+                            dmxdev, DVB_DEVICE_DVR, dmxdev->filternum);
        dvb_ringbuffer_init(&dmxdev->dvr_buffer, NULL, 8192);
diff --git a/drivers/media/dvb-core/dvb_ca_en50221.c b/drivers/media/dvb-core/dvb_ca_en50221.c
index fb66184dc9b6..f82cd1ff4f3a 100644
--- a/drivers/media/dvb-core/dvb_ca_en50221.c
+++ b/drivers/media/dvb-core/dvb_ca_en50221.c
@@ -1695,7 +1695,7 @@ int dvb_ca_en50221_init(struct dvb_adapter *dvb_adapter,
        pubca->private = ca;
        /* register the DVB device */
-        ret = dvb_register_device(dvb_adapter, &ca->dvbdev, &dvbdev_ca, ca, DVB_DEVICE_CA);
+        ret = dvb_register_device(dvb_adapter, &ca->dvbdev, &dvbdev_ca, ca, DVB_DEVICE_CA, 0);
        if (ret)
                goto free_slot_info;
diff --git a/drivers/media/dvb-core/dvb_frontend.c b/drivers/media/dvb-core/dvb_frontend.c
index b64f33776b74..40080645341e 100644
--- a/drivers/media/dvb-core/dvb_frontend.c
+++ b/drivers/media/dvb-core/dvb_frontend.c
@@ -622,7 +622,7 @@ static int dvb_enable_media_tuner(struct dvb_frontend *fe)
        struct media_device *mdev = adapter->mdev;
        struct media_entity  *entity, *source;
        struct media_link *link, *found_link = NULL;
-        int i, ret, n_links = 0, active_links = 0;
+        int ret, n_links = 0, active_links = 0;
        fepriv->pipe_start_entity = NULL;
@@ -632,8 +632,7 @@ static int dvb_enable_media_tuner(struct dvb_frontend *fe)
        entity = fepriv->dvbdev->entity;
        fepriv->pipe_start_entity = entity;
-        for (i = 0; i < entity->num_links; i++) {
+        list_for_each_entry(link, &entity->links, list) {
-                link = &entity->links[i];
                if (link->sink->entity == entity) {
                        found_link = link;
                        n_links++;
@@ -659,13 +658,11 @@ static int dvb_enable_media_tuner(struct dvb_frontend *fe)
        source = found_link->source->entity;
        fepriv->pipe_start_entity = source;
-        for (i = 0; i < source->num_links; i++) {
+        list_for_each_entry(link, &source->links, list) {
                struct media_entity *sink;
                int flags = 0;
-                link = &source->links[i];
                sink = link->sink->entity;
                if (sink == entity)
                        flags = MEDIA_LNK_FL_ENABLED;
@@ -2762,7 +2759,7 @@ int dvb_register_frontend(struct dvb_adapter* dvb,
                        fe->dvb->num, fe->id, fe->ops.info.name);
        dvb_register_device (fe->dvb, &fepriv->dvbdev, &dvbdev_template,
-                             fe, DVB_DEVICE_FRONTEND);
+                             fe, DVB_DEVICE_FRONTEND, 0);
        /*
         * Initialize the cache to the proper values according with the
diff --git a/drivers/media/dvb-core/dvb_net.c b/drivers/media/dvb-core/dvb_net.c
index ce4332e80a91..ce6a711b42d4 100644
--- a/drivers/media/dvb-core/dvb_net.c
+++ b/drivers/media/dvb-core/dvb_net.c
@@ -1502,6 +1502,6 @@ int dvb_net_init (struct dvb_adapter *adap, struct dvb_net *dvbnet,
                dvbnet->state[i] = 0;
        return dvb_register_device(adap, &dvbnet->dvbdev, &dvbdev_net,
-                             dvbnet, DVB_DEVICE_NET);
+                             dvbnet, DVB_DEVICE_NET, 0);
 }
 EXPORT_SYMBOL(dvb_net_init);
diff --git a/drivers/media/dvb-core/dvbdev.c b/drivers/media/dvb-core/dvbdev.c
index 13bb57f0457f..560450a0b32a 100644
--- a/drivers/media/dvb-core/dvbdev.c
+++ b/drivers/media/dvb-core/dvbdev.c
@@ -34,6 +34,9 @@
 #include <linux/mutex.h>
 #include "dvbdev.h"
+/* Due to enum tuner_pad_index */
+#include <media/tuner.h>
 static DEFINE_MUTEX(dvbdev_mutex);
 static int dvbdev_debug;
@@ -180,102 +183,255 @@ skip:
        return -ENFILE;
 }
-static void dvb_register_media_device(struct dvb_device *dvbdev,
+static void dvb_media_device_free(struct dvb_device *dvbdev)
-                                      int type, int minor)
 {
 #if defined(CONFIG_MEDIA_CONTROLLER_DVB)
-        int ret = 0, npads;
+        if (dvbdev->entity) {
+                media_device_unregister_entity(dvbdev->entity);
+                kfree(dvbdev->entity);
+                kfree(dvbdev->pads);
+                dvbdev->entity = NULL;
+                dvbdev->pads = NULL;
+        }
-        if (!dvbdev->adapter->mdev)
+        if (dvbdev->tsout_entity) {
-                return;
+                int i;
-        dvbdev->entity = kzalloc(sizeof(*dvbdev->entity), GFP_KERNEL);
+                for (i = 0; i < dvbdev->tsout_num_entities; i++) {
-        if (!dvbdev->entity)
+                        media_device_unregister_entity(&dvbdev->tsout_entity[i]);
-                return;
+                        kfree(dvbdev->tsout_entity[i].name);
+                }
+                kfree(dvbdev->tsout_entity);
+                kfree(dvbdev->tsout_pads);
+                dvbdev->tsout_entity = NULL;
+                dvbdev->tsout_pads = NULL;
-        dvbdev->entity->info.dev.major = DVB_MAJOR;
+                dvbdev->tsout_num_entities = 0;
-        dvbdev->entity->info.dev.minor = minor;
+        }
-        dvbdev->entity->name = dvbdev->name;
+        if (dvbdev->intf_devnode) {
+                media_devnode_remove(dvbdev->intf_devnode);
+                dvbdev->intf_devnode = NULL;
+        }
+        if (dvbdev->adapter->conn) {
+                media_device_unregister_entity(dvbdev->adapter->conn);
+                dvbdev->adapter->conn = NULL;
+                kfree(dvbdev->adapter->conn_pads);
+                dvbdev->adapter->conn_pads = NULL;
+        }
+#endif
+}
+#if defined(CONFIG_MEDIA_CONTROLLER_DVB)
+static int dvb_create_tsout_entity(struct dvb_device *dvbdev,
+                                    const char *name, int npads)
+{
+        int i, ret = 0;
+        dvbdev->tsout_pads = kcalloc(npads, sizeof(*dvbdev->tsout_pads),
+                                     GFP_KERNEL);
+        if (!dvbdev->tsout_pads)
+                return -ENOMEM;
+        dvbdev->tsout_entity = kcalloc(npads, sizeof(*dvbdev->tsout_entity),
+                                       GFP_KERNEL);
+        if (!dvbdev->tsout_entity)
+                return -ENOMEM;
+        dvbdev->tsout_num_entities = npads;
+        for (i = 0; i < npads; i++) {
+                struct media_pad *pads = &dvbdev->tsout_pads[i];
+                struct media_entity *entity = &dvbdev->tsout_entity[i];
+                entity->name = kasprintf(GFP_KERNEL, "%s #%d", name, i);
+                if (!entity->name)
+                        return -ENOMEM;
+                entity->function = MEDIA_ENT_F_IO_DTV;
+                pads->flags = MEDIA_PAD_FL_SINK;
+                ret = media_entity_pads_init(entity, 1, pads);
+                if (ret < 0)
+                        return ret;
+                ret = media_device_register_entity(dvbdev->adapter->mdev,
+                                                   entity);
+                if (ret < 0)
+                        return ret;
+        }
+        return 0;
+}
+#define DEMUX_TSOUT     "demux-tsout"
+#define DVR_TSOUT       "dvr-tsout"
+static int dvb_create_media_entity(struct dvb_device *dvbdev,
+                                   int type, int demux_sink_pads)
+{
+        int i, ret, npads;
        switch (type) {
-        case DVB_DEVICE_CA:
-        case DVB_DEVICE_DEMUX:
        case DVB_DEVICE_FRONTEND:
                npads = 2;
                break;
-        case DVB_DEVICE_NET:
+        case DVB_DEVICE_DVR:
-                npads = 0;
+                ret = dvb_create_tsout_entity(dvbdev, DVR_TSOUT,
+                                              demux_sink_pads);
+                return ret;
+        case DVB_DEVICE_DEMUX:
+                npads = 1 + demux_sink_pads;
+                ret = dvb_create_tsout_entity(dvbdev, DEMUX_TSOUT,
+                                              demux_sink_pads);
+                if (ret < 0)
+                        return ret;
+                break;
+        case DVB_DEVICE_CA:
+                npads = 2;
                break;
+        case DVB_DEVICE_NET:
+                /*
+                 * We should be creating entities for the MPE/ULE
+                 * decapsulation hardware (or software implementation).
+                 *
+                 * However, the number of for the MPE/ULE decaps may not be
+                 * fixed. As we don't have yet dynamic support for PADs at
+                 * the Media Controller, let's not create the decap
+                 * entities yet.
+                 */
+                return 0;
        default:
-                npads = 1;
+                return 0;
        }
+        dvbdev->entity = kzalloc(sizeof(*dvbdev->entity), GFP_KERNEL);
+        if (!dvbdev->entity)
+                return -ENOMEM;
+        dvbdev->entity->name = dvbdev->name;
        if (npads) {
                dvbdev->pads = kcalloc(npads, sizeof(*dvbdev->pads),
                                       GFP_KERNEL);
-                if (!dvbdev->pads) {
+                if (!dvbdev->pads)
-                        kfree(dvbdev->entity);
+                        return -ENOMEM;
-                        return;
-                }
        }
        switch (type) {
        case DVB_DEVICE_FRONTEND:
-                dvbdev->entity->type = MEDIA_ENT_T_DEVNODE_DVB_FE;
+                dvbdev->entity->function = MEDIA_ENT_F_DTV_DEMOD;
                dvbdev->pads[0].flags = MEDIA_PAD_FL_SINK;
                dvbdev->pads[1].flags = MEDIA_PAD_FL_SOURCE;
                break;
        case DVB_DEVICE_DEMUX:
-                dvbdev->entity->type = MEDIA_ENT_T_DEVNODE_DVB_DEMUX;
+                dvbdev->entity->function = MEDIA_ENT_F_TS_DEMUX;
-                dvbdev->pads[0].flags = MEDIA_PAD_FL_SINK;
-                dvbdev->pads[1].flags = MEDIA_PAD_FL_SOURCE;
-                break;
-        case DVB_DEVICE_DVR:
-                dvbdev->entity->type = MEDIA_ENT_T_DEVNODE_DVB_DVR;
                dvbdev->pads[0].flags = MEDIA_PAD_FL_SINK;
+                for (i = 1; i < npads; i++)
+                        dvbdev->pads[i].flags = MEDIA_PAD_FL_SOURCE;
                break;
        case DVB_DEVICE_CA:
-                dvbdev->entity->type = MEDIA_ENT_T_DEVNODE_DVB_CA;
+                dvbdev->entity->function = MEDIA_ENT_F_DTV_CA;
                dvbdev->pads[0].flags = MEDIA_PAD_FL_SINK;
                dvbdev->pads[1].flags = MEDIA_PAD_FL_SOURCE;
                break;
-        case DVB_DEVICE_NET:
-                dvbdev->entity->type = MEDIA_ENT_T_DEVNODE_DVB_NET;
-                break;
        default:
+                /* Should never happen, as the first switch prevents it */
                kfree(dvbdev->entity);
+                kfree(dvbdev->pads);
                dvbdev->entity = NULL;
-                return;
+                dvbdev->pads = NULL;
+                return 0;
        }
-        if (npads)
+        if (npads) {
-                ret = media_entity_init(dvbdev->entity, npads, dvbdev->pads, 0);
+                ret = media_entity_pads_init(dvbdev->entity, npads, dvbdev->pads);
-        if (!ret)
+                if (ret)
-                ret = media_device_register_entity(dvbdev->adapter->mdev,
+                        return ret;
-                                                   dvbdev->entity);
-        if (ret < 0) {
-                printk(KERN_ERR
-                        "%s: media_device_register_entity failed for %s\n",
-                        __func__, dvbdev->entity->name);
-                kfree(dvbdev->pads);
-                kfree(dvbdev->entity);
-                dvbdev->entity = NULL;
-                return;
        }
+        ret = media_device_register_entity(dvbdev->adapter->mdev,
+                                           dvbdev->entity);
+        if (ret)
+                return (ret);
-        printk(KERN_DEBUG "%s: media device '%s' registered.\n",
+        printk(KERN_DEBUG "%s: media entity '%s' registered.\n",
                __func__, dvbdev->entity->name);
+        return 0;
+}
+#endif
+static int dvb_register_media_device(struct dvb_device *dvbdev,
+                                     int type, int minor,
+                                     unsigned demux_sink_pads)
+{
+#if defined(CONFIG_MEDIA_CONTROLLER_DVB)
+        struct media_link *link;
+        u32 intf_type;
+        int ret;
+        if (!dvbdev->adapter->mdev)
+                return 0;
+        ret = dvb_create_media_entity(dvbdev, type, demux_sink_pads);
+        if (ret)
+                return ret;
+        switch (type) {
+        case DVB_DEVICE_FRONTEND:
+                intf_type = MEDIA_INTF_T_DVB_FE;
+                break;
+        case DVB_DEVICE_DEMUX:
+                intf_type = MEDIA_INTF_T_DVB_DEMUX;
+                break;
+        case DVB_DEVICE_DVR:
+                intf_type = MEDIA_INTF_T_DVB_DVR;
+                break;
+        case DVB_DEVICE_CA:
+                intf_type = MEDIA_INTF_T_DVB_CA;
+                break;
+        case DVB_DEVICE_NET:
+                intf_type = MEDIA_INTF_T_DVB_NET;
+                break;
+        default:
+                return 0;
+        }
+        dvbdev->intf_devnode = media_devnode_create(dvbdev->adapter->mdev,
+                                                    intf_type, 0,
+                                                    DVB_MAJOR, minor);
+        if (!dvbdev->intf_devnode)
+                return -ENOMEM;
+        /*
+         * Create the "obvious" link, e. g. the ones that represent
+         * a direct association between an interface and an entity.
+         * Other links should be created elsewhere, like:
+         *              DVB FE intf    -> tuner
+         *              DVB demux intf -> dvr
+         */
+        if (!dvbdev->entity)
+                return 0;
+        link = media_create_intf_link(dvbdev->entity, &dvbdev->intf_devnode->intf,
+                                      MEDIA_LNK_FL_ENABLED);
+        if (!link)
+                return -ENOMEM;
 #endif
+        return 0;
 }
 int dvb_register_device(struct dvb_adapter *adap, struct dvb_device **pdvbdev,
-                        const struct dvb_device *template, void *priv, int type)
+                        const struct dvb_device *template, void *priv, int type,
+                        int demux_sink_pads)
 {
        struct dvb_device *dvbdev;
        struct file_operations *dvbdevfops;
        struct device *clsdev;
        int minor;
-        int id;
+        int id, ret;
        mutex_lock(&dvbdev_register_lock);
@@ -286,7 +442,7 @@ int dvb_register_device(struct dvb_adapter *adap, struct dvb_device **pdvbdev,
                return -ENFILE;
        }
-        *pdvbdev = dvbdev = kmalloc(sizeof(struct dvb_device), GFP_KERNEL);
+        *pdvbdev = dvbdev = kzalloc(sizeof(*dvbdev), GFP_KERNEL);
        if (!dvbdev){
                mutex_unlock(&dvbdev_register_lock);
@@ -335,6 +491,20 @@ int dvb_register_device(struct dvb_adapter *adap, struct dvb_device **pdvbdev,
        dvb_minors[minor] = dvbdev;
        up_write(&minor_rwsem);
+        ret = dvb_register_media_device(dvbdev, type, minor, demux_sink_pads);
+        if (ret) {
+                printk(KERN_ERR
+                      "%s: dvb_register_media_device failed to create the mediagraph\n",
+                      __func__);
+                dvb_media_device_free(dvbdev);
+                kfree(dvbdevfops);
+                kfree(dvbdev);
+                up_write(&minor_rwsem);
+                mutex_unlock(&dvbdev_register_lock);
+                return ret;
+        }
        mutex_unlock(&dvbdev_register_lock);
        clsdev = device_create(dvb_class, adap->device,
@@ -348,8 +518,6 @@ int dvb_register_device(struct dvb_adapter *adap, struct dvb_device **pdvbdev,
        dprintk(KERN_DEBUG "DVB: register adapter%d/%s%d @ minor: %i (0x%02x)\n",
                adap->num, dnames[type], id, minor, minor);
-        dvb_register_media_device(dvbdev, type, minor);
        return 0;
 }
 EXPORT_SYMBOL(dvb_register_device);
@@ -364,15 +532,9 @@ void dvb_unregister_device(struct dvb_device *dvbdev)
        dvb_minors[dvbdev->minor] = NULL;
        up_write(&minor_rwsem);
-        device_destroy(dvb_class, MKDEV(DVB_MAJOR, dvbdev->minor));
+        dvb_media_device_free(dvbdev);
-#if defined(CONFIG_MEDIA_CONTROLLER_DVB)
+        device_destroy(dvb_class, MKDEV(DVB_MAJOR, dvbdev->minor));
-        if (dvbdev->entity) {
-                media_device_unregister_entity(dvbdev->entity);
-                kfree(dvbdev->entity);
-                kfree(dvbdev->pads);
-        }
-#endif
        list_del (&dvbdev->list_head);
        kfree (dvbdev->fops);
@@ -382,46 +544,212 @@ EXPORT_SYMBOL(dvb_unregister_device);
 #ifdef CONFIG_MEDIA_CONTROLLER_DVB
-void dvb_create_media_graph(struct dvb_adapter *adap)
+static int dvb_create_io_intf_links(struct dvb_adapter *adap,
+                                    struct media_interface *intf,
+                                    char *name)
+{
+        struct media_device *mdev = adap->mdev;
+        struct media_entity *entity;
+        struct media_link *link;
+        media_device_for_each_entity(entity, mdev) {
+                if (entity->function == MEDIA_ENT_F_IO_DTV) {
+                        if (strncmp(entity->name, name, strlen(name)))
+                                continue;
+                        link = media_create_intf_link(entity, intf,
+                                                      MEDIA_LNK_FL_ENABLED);
+                        if (!link)
+                                return -ENOMEM;
+                }
+        }
+        return 0;
+}
+int dvb_create_media_graph(struct dvb_adapter *adap,
+                           bool create_rf_connector)
 {
        struct media_device *mdev = adap->mdev;
-        struct media_entity *entity, *tuner = NULL, *fe = NULL;
+        struct media_entity *entity, *tuner = NULL, *demod = NULL, *conn;
-        struct media_entity *demux = NULL, *dvr = NULL, *ca = NULL;
+        struct media_entity *demux = NULL, *ca = NULL;
+        struct media_link *link;
+        struct media_interface *intf;
+        unsigned demux_pad = 0;
+        unsigned dvr_pad = 0;
+        unsigned ntuner = 0, ndemod = 0;
+        int ret;
+        static const char *connector_name = "Television";
        if (!mdev)
-                return;
+                return 0;
        media_device_for_each_entity(entity, mdev) {
-                switch (entity->type) {
+                switch (entity->function) {
-                case MEDIA_ENT_T_V4L2_SUBDEV_TUNER:
+                case MEDIA_ENT_F_TUNER:
                        tuner = entity;
+                        ntuner++;
                        break;
-                case MEDIA_ENT_T_DEVNODE_DVB_FE:
+                case MEDIA_ENT_F_DTV_DEMOD:
-                        fe = entity;
+                        demod = entity;
+                        ndemod++;
                        break;
-                case MEDIA_ENT_T_DEVNODE_DVB_DEMUX:
+                case MEDIA_ENT_F_TS_DEMUX:
                        demux = entity;
                        break;
-                case MEDIA_ENT_T_DEVNODE_DVB_DVR:
+                case MEDIA_ENT_F_DTV_CA:
-                        dvr = entity;
-                        break;
-                case MEDIA_ENT_T_DEVNODE_DVB_CA:
                        ca = entity;
                        break;
                }
        }
-        if (tuner && fe)
+        /*
-                media_entity_create_link(tuner, 0, fe, 0, 0);
+         * Prepare to signalize to media_create_pad_links() that multiple
+         * entities of the same type exists and a 1:n or n:1 links need to be
+         * created.
+         * NOTE: if both tuner and demod have multiple instances, it is up
+         * to the caller driver to create such links.
+         */
+        if (ntuner > 1)
+                tuner = NULL;
+        if (ndemod > 1)
+                demod = NULL;
+        if (create_rf_connector) {
+                conn = kzalloc(sizeof(*conn), GFP_KERNEL);
+                if (!conn)
+                        return -ENOMEM;
+                adap->conn = conn;
+                adap->conn_pads = kcalloc(1, sizeof(*adap->conn_pads),
+                                            GFP_KERNEL);
+                if (!adap->conn_pads)
+                        return -ENOMEM;
+                conn->flags = MEDIA_ENT_FL_CONNECTOR;
+                conn->function = MEDIA_ENT_F_CONN_RF;
+                conn->name = connector_name;
+                adap->conn_pads->flags = MEDIA_PAD_FL_SOURCE;
+                ret = media_entity_pads_init(conn, 1, adap->conn_pads);
+                if (ret)
+                        return ret;
+                ret = media_device_register_entity(mdev, conn);
+                if (ret)
+                        return ret;
+                if (!ntuner)
+                        ret = media_create_pad_links(mdev,
+                                                     MEDIA_ENT_F_CONN_RF,
+                                                     conn, 0,
+                                                     MEDIA_ENT_F_DTV_DEMOD,
+                                                     demod, 0,
+                                                     MEDIA_LNK_FL_ENABLED,
+                                                     false);
+                else
+                        ret = media_create_pad_links(mdev,
+                                                     MEDIA_ENT_F_CONN_RF,
+                                                     conn, 0,
+                                                     MEDIA_ENT_F_TUNER,
+                                                     tuner, TUNER_PAD_RF_INPUT,
+                                                     MEDIA_LNK_FL_ENABLED,
+                                                     false);
+                if (ret)
+                        return ret;
+        }
+        if (ntuner && ndemod) {
+                ret = media_create_pad_links(mdev,
+                                             MEDIA_ENT_F_TUNER,
+                                             tuner, TUNER_PAD_IF_OUTPUT,
+                                             MEDIA_ENT_F_DTV_DEMOD,
+                                             demod, 0, MEDIA_LNK_FL_ENABLED,
+                                             false);
+                if (ret)
+                        return ret;
+        }
+        if (ndemod && demux) {
+                ret = media_create_pad_links(mdev,
+                                             MEDIA_ENT_F_DTV_DEMOD,
+                                             demod, 1,
+                                             MEDIA_ENT_F_TS_DEMUX,
+                                             demux, 0, MEDIA_LNK_FL_ENABLED,
+                                             false);
+                if (ret)
+                        return -ENOMEM;
+        }
+        if (demux && ca) {
+                ret = media_create_pad_link(demux, 1, ca,
+                                            0, MEDIA_LNK_FL_ENABLED);
+                if (!ret)
+                        return -ENOMEM;
+        }
-        if (fe && demux)
+        /* Create demux links for each ringbuffer/pad */
-                media_entity_create_link(fe, 1, demux, 0, MEDIA_LNK_FL_ENABLED);
+        if (demux) {
+                media_device_for_each_entity(entity, mdev) {
+                        if (entity->function == MEDIA_ENT_F_IO_DTV) {
+                                if (!strncmp(entity->name, DVR_TSOUT,
+                                    strlen(DVR_TSOUT))) {
+                                        ret = media_create_pad_link(demux,
+                                                                ++dvr_pad,
+                                                            entity, 0, 0);
+                                        if (ret)
+                                                return ret;
+                                }
+                                if (!strncmp(entity->name, DEMUX_TSOUT,
+                                    strlen(DEMUX_TSOUT))) {
+                                        ret = media_create_pad_link(demux,
+                                                              ++demux_pad,
+                                                            entity, 0, 0);
+                                        if (ret)
+                                                return ret;
+                                }
+                        }
+                }
+        }
-        if (demux && dvr)
+        /* Create interface links for FE->tuner, DVR->demux and CA->ca */
-                media_entity_create_link(demux, 1, dvr, 0, MEDIA_LNK_FL_ENABLED);
+        media_device_for_each_intf(intf, mdev) {
+                if (intf->type == MEDIA_INTF_T_DVB_CA && ca) {
+                        link = media_create_intf_link(ca, intf,
+                                                      MEDIA_LNK_FL_ENABLED);
+                        if (!link)
+                                return -ENOMEM;
+                }
-        if (demux && ca)
+                if (intf->type == MEDIA_INTF_T_DVB_FE && tuner) {
-                media_entity_create_link(demux, 1, ca, 0, MEDIA_LNK_FL_ENABLED);
+                        link = media_create_intf_link(tuner, intf,
+                                                      MEDIA_LNK_FL_ENABLED);
+                        if (!link)
+                                return -ENOMEM;
+                }
+#if 0
+                /*
+                 * Indirect link - let's not create yet, as we don't know how
+                 *                 to handle indirect links, nor if this will
+                 *                 actually be needed.
+                 */
+                if (intf->type == MEDIA_INTF_T_DVB_DVR && demux) {
+                        link = media_create_intf_link(demux, intf,
+                                                      MEDIA_LNK_FL_ENABLED);
+                        if (!link)
+                                return -ENOMEM;
+                }
+#endif
+                if (intf->type == MEDIA_INTF_T_DVB_DVR) {
+                        ret = dvb_create_io_intf_links(adap, intf, DVR_TSOUT);
+                        if (ret)
+                                return ret;
+                }
+                if (intf->type == MEDIA_INTF_T_DVB_DEMUX) {
+                        ret = dvb_create_io_intf_links(adap, intf, DEMUX_TSOUT);
+                        if (ret)
+                                return ret;
+                }
+        }
+        return 0;
 }
 EXPORT_SYMBOL_GPL(dvb_create_media_graph);
 #endif
diff --git a/drivers/media/dvb-core/dvbdev.h b/drivers/media/dvb-core/dvbdev.h
index 1069a776bbdb..4aff7bd3dea8 100644
--- a/drivers/media/dvb-core/dvbdev.h
+++ b/drivers/media/dvb-core/dvbdev.h
@@ -75,6 +75,9 @@ struct dvb_frontend;
 *                      used.
 * @mdev:               pointer to struct media_device, used when the media
 *                      controller is used.
+ * @conn:               RF connector. Used only if the device has no separate
+ *                      tuner.
+ * @conn_pads:          pointer to struct media_pad associated with @conn;
 */
 struct dvb_adapter {
        int num;
@@ -94,6 +97,8 @@ struct dvb_adapter {
 #if defined(CONFIG_MEDIA_CONTROLLER_DVB)
        struct media_device *mdev;
+        struct media_entity *conn;
+        struct media_pad *conn_pads;
 #endif
 };
@@ -120,6 +125,11 @@ struct dvb_adapter {
 * @entity:     pointer to struct media_entity associated with the device node
 * @pads:       pointer to struct media_pad associated with @entity;
 * @priv:       private data
+ * @intf_devnode: Pointer to media_intf_devnode. Used by the dvbdev core to
+ *              store the MC device node interface
+ * @tsout_num_entities: Number of Transport Stream output entities
+ * @tsout_entity: array with MC entities associated to each TS output node
+ * @tsout_pads: array with the source pads for each @tsout_entity
 *
 * This structure is used by the DVB core (frontend, CA, net, demux) in
 * order to create the device nodes. Usually, driver should not initialize
@@ -148,8 +158,11 @@ struct dvb_device {
        const char *name;
        /* Allocated and filled inside dvbdev.c */
-        struct media_entity *entity;
+        struct media_intf_devnode *intf_devnode;
-        struct media_pad *pads;
+        unsigned tsout_num_entities;
+        struct media_entity *entity, *tsout_entity;
+        struct media_pad *pads, *tsout_pads;
 #endif
        void *priv;
@@ -185,14 +198,18 @@ int dvb_unregister_adapter(struct dvb_adapter *adap);
 *              stored
 * @template:   Template used to create &pdvbdev;
 * @priv:       private data
- * @type:       type of the device: DVB_DEVICE_SEC, DVB_DEVICE_FRONTEND,
+ * @type:       type of the device: %DVB_DEVICE_SEC, %DVB_DEVICE_FRONTEND,
- *              DVB_DEVICE_DEMUX, DVB_DEVICE_DVR, DVB_DEVICE_CA, DVB_DEVICE_NET
+ *              %DVB_DEVICE_DEMUX, %DVB_DEVICE_DVR, %DVB_DEVICE_CA,
+ *              %DVB_DEVICE_NET
+ * @demux_sink_pads: Number of demux outputs, to be used to create the TS
+ *              outputs via the Media Controller.
 */
 int dvb_register_device(struct dvb_adapter *adap,
                        struct dvb_device **pdvbdev,
                        const struct dvb_device *template,
                        void *priv,
-                        int type);
+                        int type,
+                        int demux_sink_pads);
 /**
 * dvb_unregister_device - Unregisters a DVB device
@@ -202,16 +219,43 @@ int dvb_register_device(struct dvb_adapter *adap,
 void dvb_unregister_device(struct dvb_device *dvbdev);
 #ifdef CONFIG_MEDIA_CONTROLLER_DVB
-void dvb_create_media_graph(struct dvb_adapter *adap);
+/**
+ * dvb_create_media_graph - Creates media graph for the Digital TV part of the
+ *                              device.
+ *
+ * @adap:                       pointer to struct dvb_adapter
+ * @create_rf_connector:        if true, it creates the RF connector too
+ *
+ * This function checks all DVB-related functions at the media controller
+ * entities and creates the needed links for the media graph. It is
+ * capable of working with multiple tuners or multiple frontends, but it
+ * won't create links if the device has multiple tuners and multiple frontends
+ * or if the device has multiple muxes. In such case, the caller driver should
+ * manually create the remaining links.
+ */
+__must_check int dvb_create_media_graph(struct dvb_adapter *adap,
+                                        bool create_rf_connector);
 static inline void dvb_register_media_controller(struct dvb_adapter *adap,
                                                 struct media_device *mdev)
 {
        adap->mdev = mdev;
 }
+static inline struct media_device
+*dvb_get_media_controller(struct dvb_adapter *adap)
+{
+        return adap->mdev;
+}
 #else
-static inline void dvb_create_media_graph(struct dvb_adapter *adap) {}
+static inline
+int dvb_create_media_graph(struct dvb_adapter *adap,
+                           bool create_rf_connector)
+{
+        return 0;
+};
 #define dvb_register_media_controller(a, b) {}
+#define dvb_get_media_controller(a) NULL
 #endif
 int dvb_generic_open (struct inode *inode, struct file *file);
diff --git a/drivers/media/dvb-frontends/au8522_decoder.c b/drivers/media/dvb-frontends/au8522_decoder.c
index c8f13d8370e5..73612c5353d1 100644
--- a/drivers/media/dvb-frontends/au8522_decoder.c
+++ b/drivers/media/dvb-frontends/au8522_decoder.c
@@ -730,6 +730,9 @@ static int au8522_probe(struct i2c_client *client,
        struct v4l2_ctrl_handler *hdl;
        struct v4l2_subdev *sd;
        int instance;
+#ifdef CONFIG_MEDIA_CONTROLLER
+        int ret;
+#endif
        /* Check if the adapter supports the needed features */
        if (!i2c_check_functionality(client->adapter,
@@ -758,6 +761,20 @@ static int au8522_probe(struct i2c_client *client,
        sd = &state->sd;
        v4l2_i2c_subdev_init(sd, client, &au8522_ops);
+#if defined(CONFIG_MEDIA_CONTROLLER)
+        state->pads[AU8522_PAD_INPUT].flags = MEDIA_PAD_FL_SINK;
+        state->pads[AU8522_PAD_VID_OUT].flags = MEDIA_PAD_FL_SOURCE;
+        state->pads[AU8522_PAD_VBI_OUT].flags = MEDIA_PAD_FL_SOURCE;
+        sd->entity.function = MEDIA_ENT_F_ATV_DECODER;
+        ret = media_entity_pads_init(&sd->entity, ARRAY_SIZE(state->pads),
+                                state->pads);
+        if (ret < 0) {
+                v4l_info(client, "failed to initialize media entity!\n");
+                return ret;
+        }
+#endif
        hdl = &state->hdl;
        v4l2_ctrl_handler_init(hdl, 4);
diff --git a/drivers/media/dvb-frontends/au8522_priv.h b/drivers/media/dvb-frontends/au8522_priv.h
index ee330c61aa61..404a0cb0ed8d 100644
--- a/drivers/media/dvb-frontends/au8522_priv.h
+++ b/drivers/media/dvb-frontends/au8522_priv.h
@@ -39,6 +39,14 @@
 #define AU8522_DIGITAL_MODE 1
 #define AU8522_SUSPEND_MODE 2
+enum au8522_media_pads {
+        AU8522_PAD_INPUT,
+        AU8522_PAD_VID_OUT,
+        AU8522_PAD_VBI_OUT,
+        AU8522_NUM_PADS
+};
 struct au8522_state {
        struct i2c_client *c;
        struct i2c_adapter *i2c;
@@ -68,6 +76,10 @@ struct au8522_state {
        u32 id;
        u32 rev;
        struct v4l2_ctrl_handler hdl;
+#ifdef CONFIG_MEDIA_CONTROLLER
+        struct media_pad pads[AU8522_NUM_PADS];
+#endif
 };
 /* These are routines shared by both the VSB/QAM demodulator and the analog
diff --git a/drivers/media/firewire/firedtv-ci.c b/drivers/media/firewire/firedtv-ci.c
index e63f582378bf..edbb30fdd9d9 100644
--- a/drivers/media/firewire/firedtv-ci.c
+++ b/drivers/media/firewire/firedtv-ci.c
@@ -241,7 +241,7 @@ int fdtv_ca_register(struct firedtv *fdtv)
                return -EFAULT;
        err = dvb_register_device(&fdtv->adapter, &fdtv->cadev,
-                                  &fdtv_ca, fdtv, DVB_DEVICE_CA);
+                                  &fdtv_ca, fdtv, DVB_DEVICE_CA, 0);
        if (stat.ca_application_info == 0)
                dev_err(fdtv->device, "CaApplicationInfo is not set\n");
diff --git a/drivers/media/i2c/ad9389b.c b/drivers/media/i2c/ad9389b.c
index 0494a7896aa2..788967dadd29 100644
--- a/drivers/media/i2c/ad9389b.c
+++ b/drivers/media/i2c/ad9389b.c
@@ -1158,7 +1158,7 @@ static int ad9389b_probe(struct i2c_client *client, const struct i2c_device_id *
        state->rgb_quantization_range_ctrl->is_private = true;
        state->pad.flags = MEDIA_PAD_FL_SINK;
-        err = media_entity_init(&sd->entity, 1, &state->pad, 0);
+        err = media_entity_pads_init(&sd->entity, 1, &state->pad);
        if (err)
                goto err_hdl;
diff --git a/drivers/media/i2c/adp1653.c b/drivers/media/i2c/adp1653.c
index f00745bbe471..7e9cbf757e95 100644
--- a/drivers/media/i2c/adp1653.c
+++ b/drivers/media/i2c/adp1653.c
@@ -512,11 +512,11 @@ static int adp1653_probe(struct i2c_client *client,
        if (ret)
                goto free_and_quit;
-        ret = media_entity_init(&flash->subdev.entity, 0, NULL, 0);
+        ret = media_entity_pads_init(&flash->subdev.entity, 0, NULL);
        if (ret < 0)
                goto free_and_quit;
-        flash->subdev.entity.type = MEDIA_ENT_T_V4L2_SUBDEV_FLASH;
+        flash->subdev.entity.function = MEDIA_ENT_F_FLASH;
        return 0;
diff --git a/drivers/media/i2c/adv7180.c b/drivers/media/i2c/adv7180.c
index 3c3c4bfe3866..ff57c1dcb8af 100644
--- a/drivers/media/i2c/adv7180.c
+++ b/drivers/media/i2c/adv7180.c
@@ -1213,8 +1213,8 @@ static int adv7180_probe(struct i2c_client *client,
                goto err_unregister_vpp_client;
        state->pad.flags = MEDIA_PAD_FL_SOURCE;
-        sd->entity.flags |= MEDIA_ENT_T_V4L2_SUBDEV_DECODER;
+        sd->entity.flags |= MEDIA_ENT_F_ATV_DECODER;
-        ret = media_entity_init(&sd->entity, 1, &state->pad, 0);
+        ret = media_entity_pads_init(&sd->entity, 1, &state->pad);
        if (ret)
                goto err_free_ctrl;
diff --git a/drivers/media/i2c/adv7511.c b/drivers/media/i2c/adv7511.c
index eeb2cd823c4d..471fd23b5c5c 100644
--- a/drivers/media/i2c/adv7511.c
+++ b/drivers/media/i2c/adv7511.c
@@ -1482,7 +1482,7 @@ static int adv7511_probe(struct i2c_client *client, const struct i2c_device_id *
        state->rgb_quantization_range_ctrl->is_private = true;
        state->pad.flags = MEDIA_PAD_FL_SINK;
-        err = media_entity_init(&sd->entity, 1, &state->pad, 0);
+        err = media_entity_pads_init(&sd->entity, 1, &state->pad);
        if (err)
                goto err_hdl;
diff --git a/drivers/media/i2c/adv7604.c b/drivers/media/i2c/adv7604.c
index 745286225655..f8dd7505b529 100644
--- a/drivers/media/i2c/adv7604.c
+++ b/drivers/media/i2c/adv7604.c
@@ -3208,8 +3208,8 @@ static int adv76xx_probe(struct i2c_client *client,
                state->pads[i].flags = MEDIA_PAD_FL_SINK;
        state->pads[state->source_pad].flags = MEDIA_PAD_FL_SOURCE;
-        err = media_entity_init(&sd->entity, state->source_pad + 1,
+        err = media_entity_pads_init(&sd->entity, state->source_pad + 1,
-                                state->pads, 0);
+                                state->pads);
        if (err)
                goto err_work_queues;
diff --git a/drivers/media/i2c/adv7842.c b/drivers/media/i2c/adv7842.c
index 69378e4914b6..5fbb788e7b59 100644
--- a/drivers/media/i2c/adv7842.c
+++ b/drivers/media/i2c/adv7842.c
@@ -3309,7 +3309,7 @@ static int adv7842_probe(struct i2c_client *client,
                        adv7842_delayed_work_enable_hotplug);
        state->pad.flags = MEDIA_PAD_FL_SOURCE;
-        err = media_entity_init(&sd->entity, 1, &state->pad, 0);
+        err = media_entity_pads_init(&sd->entity, 1, &state->pad);
        if (err)
                goto err_work_queues;
diff --git a/drivers/media/i2c/as3645a.c b/drivers/media/i2c/as3645a.c
index 29a2e7034aa6..2e90e4094b79 100644
--- a/drivers/media/i2c/as3645a.c
+++ b/drivers/media/i2c/as3645a.c
@@ -827,11 +827,11 @@ static int as3645a_probe(struct i2c_client *client,
        if (ret < 0)
                goto done;
-        ret = media_entity_init(&flash->subdev.entity, 0, NULL, 0);
+        ret = media_entity_pads_init(&flash->subdev.entity, 0, NULL);
        if (ret < 0)
                goto done;
-        flash->subdev.entity.type = MEDIA_ENT_T_V4L2_SUBDEV_FLASH;
+        flash->subdev.entity.function = MEDIA_ENT_F_FLASH;
        mutex_init(&flash->power_lock);
diff --git a/drivers/media/i2c/cx25840/cx25840-core.c b/drivers/media/i2c/cx25840/cx25840-core.c
index f2e2c34ddbbd..07a3e7173144 100644
--- a/drivers/media/i2c/cx25840/cx25840-core.c
+++ b/drivers/media/i2c/cx25840/cx25840-core.c
@@ -5211,10 +5211,10 @@ static int cx25840_probe(struct i2c_client *client,
        state->pads[CX25840_PAD_INPUT].flags = MEDIA_PAD_FL_SINK;
        state->pads[CX25840_PAD_VID_OUT].flags = MEDIA_PAD_FL_SOURCE;
        state->pads[CX25840_PAD_VBI_OUT].flags = MEDIA_PAD_FL_SOURCE;
-        sd->entity.type = MEDIA_ENT_T_V4L2_SUBDEV_DECODER;
+        sd->entity.function = MEDIA_ENT_F_ATV_DECODER;
-        ret = media_entity_init(&sd->entity, ARRAY_SIZE(state->pads),
+        ret = media_entity_pads_init(&sd->entity, ARRAY_SIZE(state->pads),
-                                state->pads, 0);
+                                state->pads);
        if (ret < 0) {
                v4l_info(client, "failed to initialize media entity!\n");
                return ret;
diff --git a/drivers/media/i2c/lm3560.c b/drivers/media/i2c/lm3560.c
index 19ecb8801064..251a2aaf98c3 100644
--- a/drivers/media/i2c/lm3560.c
+++ b/drivers/media/i2c/lm3560.c
@@ -365,10 +365,10 @@ static int lm3560_subdev_init(struct lm3560_flash *flash,
        rval = lm3560_init_controls(flash, led_no);
        if (rval)
                goto err_out;
-        rval = media_entity_init(&flash->subdev_led[led_no].entity, 0, NULL, 0);
+        rval = media_entity_pads_init(&flash->subdev_led[led_no].entity, 0, NULL);
        if (rval < 0)
                goto err_out;
-        flash->subdev_led[led_no].entity.type = MEDIA_ENT_T_V4L2_SUBDEV_FLASH;
+        flash->subdev_led[led_no].entity.function = MEDIA_ENT_F_FLASH;
        return rval;
diff --git a/drivers/media/i2c/lm3646.c b/drivers/media/i2c/lm3646.c
index 7fbe6ff1c4f4..7e9967af36ec 100644
--- a/drivers/media/i2c/lm3646.c
+++ b/drivers/media/i2c/lm3646.c
@@ -282,10 +282,10 @@ static int lm3646_subdev_init(struct lm3646_flash *flash)
        rval = lm3646_init_controls(flash);
        if (rval)
                goto err_out;
-        rval = media_entity_init(&flash->subdev_led.entity, 0, NULL, 0);
+        rval = media_entity_pads_init(&flash->subdev_led.entity, 0, NULL);
        if (rval < 0)
                goto err_out;
-        flash->subdev_led.entity.type = MEDIA_ENT_T_V4L2_SUBDEV_FLASH;
+        flash->subdev_led.entity.function = MEDIA_ENT_F_FLASH;
        return rval;
 err_out:
diff --git a/drivers/media/i2c/m5mols/m5mols_core.c b/drivers/media/i2c/m5mols/m5mols_core.c
index f8993933416e..acb804bceccb 100644
--- a/drivers/media/i2c/m5mols/m5mols_core.c
+++ b/drivers/media/i2c/m5mols/m5mols_core.c
@@ -975,10 +975,10 @@ static int m5mols_probe(struct i2c_client *client,
        sd->internal_ops = &m5mols_subdev_internal_ops;
        info->pad.flags = MEDIA_PAD_FL_SOURCE;
-        ret = media_entity_init(&sd->entity, 1, &info->pad, 0);
+        ret = media_entity_pads_init(&sd->entity, 1, &info->pad);
        if (ret < 0)
                return ret;
-        sd->entity.type = MEDIA_ENT_T_V4L2_SUBDEV_SENSOR;
+        sd->entity.function = MEDIA_ENT_F_CAM_SENSOR;
        init_waitqueue_head(&info->irq_waitq);
        mutex_init(&info->lock);
diff --git a/drivers/media/i2c/mt9m032.c b/drivers/media/i2c/mt9m032.c
index 101cb26f9330..da076796999e 100644
--- a/drivers/media/i2c/mt9m032.c
+++ b/drivers/media/i2c/mt9m032.c
@@ -799,7 +799,7 @@ static int mt9m032_probe(struct i2c_client *client,
        sensor->subdev.ctrl_handler = &sensor->ctrls;
        sensor->pad.flags = MEDIA_PAD_FL_SOURCE;
-        ret = media_entity_init(&sensor->subdev.entity, 1, &sensor->pad, 0);
+        ret = media_entity_pads_init(&sensor->subdev.entity, 1, &sensor->pad);
        if (ret < 0)
                goto error_ctrl;
diff --git a/drivers/media/i2c/mt9p031.c b/drivers/media/i2c/mt9p031.c
index a3da0e977d0b..237737fec09c 100644
--- a/drivers/media/i2c/mt9p031.c
+++ b/drivers/media/i2c/mt9p031.c
@@ -1112,7 +1112,7 @@ static int mt9p031_probe(struct i2c_client *client,
        mt9p031->subdev.internal_ops = &mt9p031_subdev_internal_ops;
        mt9p031->pad.flags = MEDIA_PAD_FL_SOURCE;
-        ret = media_entity_init(&mt9p031->subdev.entity, 1, &mt9p031->pad, 0);
+        ret = media_entity_pads_init(&mt9p031->subdev.entity, 1, &mt9p031->pad);
        if (ret < 0)
                goto done;
diff --git a/drivers/media/i2c/mt9t001.c b/drivers/media/i2c/mt9t001.c
index b28fdff1d310..702d562f8e39 100644
--- a/drivers/media/i2c/mt9t001.c
+++ b/drivers/media/i2c/mt9t001.c
@@ -933,7 +933,7 @@ static int mt9t001_probe(struct i2c_client *client,
        mt9t001->subdev.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
        mt9t001->pad.flags = MEDIA_PAD_FL_SOURCE;
-        ret = media_entity_init(&mt9t001->subdev.entity, 1, &mt9t001->pad, 0);
+        ret = media_entity_pads_init(&mt9t001->subdev.entity, 1, &mt9t001->pad);
 done:
        if (ret < 0) {
diff --git a/drivers/media/i2c/mt9v032.c b/drivers/media/i2c/mt9v032.c
index 1dbbd23fdfb0..2e1d116a64e7 100644
--- a/drivers/media/i2c/mt9v032.c
+++ b/drivers/media/i2c/mt9v032.c
@@ -1046,7 +1046,7 @@ static int mt9v032_probe(struct i2c_client *client,
        mt9v032->subdev.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
        mt9v032->pad.flags = MEDIA_PAD_FL_SOURCE;
-        ret = media_entity_init(&mt9v032->subdev.entity, 1, &mt9v032->pad, 0);
+        ret = media_entity_pads_init(&mt9v032->subdev.entity, 1, &mt9v032->pad);
        if (ret < 0)
                goto err;
diff --git a/drivers/media/i2c/noon010pc30.c b/drivers/media/i2c/noon010pc30.c
index 69e4f3031d8b..30cb90b88d75 100644
--- a/drivers/media/i2c/noon010pc30.c
+++ b/drivers/media/i2c/noon010pc30.c
@@ -779,8 +779,8 @@ static int noon010_probe(struct i2c_client *client,
                goto np_err;
        info->pad.flags = MEDIA_PAD_FL_SOURCE;
-        sd->entity.type = MEDIA_ENT_T_V4L2_SUBDEV_SENSOR;
+        sd->entity.function = MEDIA_ENT_F_CAM_SENSOR;
-        ret = media_entity_init(&sd->entity, 1, &info->pad, 0);
+        ret = media_entity_pads_init(&sd->entity, 1, &info->pad);
        if (ret < 0)
                goto np_err;
diff --git a/drivers/media/i2c/ov2659.c b/drivers/media/i2c/ov2659.c
index 82c7ac1cc88e..02b9a3440557 100644
--- a/drivers/media/i2c/ov2659.c
+++ b/drivers/media/i2c/ov2659.c
@@ -1445,8 +1445,8 @@ static int ov2659_probe(struct i2c_client *client,
 #if defined(CONFIG_MEDIA_CONTROLLER)
        ov2659->pad.flags = MEDIA_PAD_FL_SOURCE;
-        sd->entity.type = MEDIA_ENT_T_V4L2_SUBDEV_SENSOR;
+        sd->entity.function = MEDIA_ENT_F_CAM_SENSOR;
-        ret = media_entity_init(&sd->entity, 1, &ov2659->pad, 0);
+        ret = media_entity_pads_init(&sd->entity, 1, &ov2659->pad);
        if (ret < 0) {
                v4l2_ctrl_handler_free(&ov2659->ctrls);
                return ret;
diff --git a/drivers/media/i2c/ov9650.c b/drivers/media/i2c/ov9650.c
index 9fe9006474b2..a0b3c9bde53d 100644
--- a/drivers/media/i2c/ov9650.c
+++ b/drivers/media/i2c/ov9650.c
@@ -1500,8 +1500,8 @@ static int ov965x_probe(struct i2c_client *client,
                return ret;
        ov965x->pad.flags = MEDIA_PAD_FL_SOURCE;
-        sd->entity.type = MEDIA_ENT_T_V4L2_SUBDEV_SENSOR;
+        sd->entity.function = MEDIA_ENT_F_CAM_SENSOR;
-        ret = media_entity_init(&sd->entity, 1, &ov965x->pad, 0);
+        ret = media_entity_pads_init(&sd->entity, 1, &ov965x->pad);
        if (ret < 0)
                return ret;
diff --git a/drivers/media/i2c/s5c73m3/s5c73m3-core.c b/drivers/media/i2c/s5c73m3/s5c73m3-core.c
index 25f5e79dc9bc..57b3d27993a4 100644
--- a/drivers/media/i2c/s5c73m3/s5c73m3-core.c
+++ b/drivers/media/i2c/s5c73m3/s5c73m3-core.c
@@ -1482,11 +1482,11 @@ static int s5c73m3_oif_registered(struct v4l2_subdev *sd)
                return ret;
        }
-        ret = media_entity_create_link(&state->sensor_sd.entity,
+        ret = media_create_pad_link(&state->sensor_sd.entity,
                        S5C73M3_ISP_PAD, &state->oif_sd.entity, OIF_ISP_PAD,
                        MEDIA_LNK_FL_IMMUTABLE | MEDIA_LNK_FL_ENABLED);
-        ret = media_entity_create_link(&state->sensor_sd.entity,
+        ret = media_create_pad_link(&state->sensor_sd.entity,
                        S5C73M3_JPEG_PAD, &state->oif_sd.entity, OIF_JPEG_PAD,
                        MEDIA_LNK_FL_IMMUTABLE | MEDIA_LNK_FL_ENABLED);
@@ -1688,10 +1688,10 @@ static int s5c73m3_probe(struct i2c_client *client,
        state->sensor_pads[S5C73M3_JPEG_PAD].flags = MEDIA_PAD_FL_SOURCE;
        state->sensor_pads[S5C73M3_ISP_PAD].flags = MEDIA_PAD_FL_SOURCE;
-        sd->entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
+        sd->entity.function = MEDIA_ENT_F_CAM_SENSOR;
-        ret = media_entity_init(&sd->entity, S5C73M3_NUM_PADS,
+        ret = media_entity_pads_init(&sd->entity, S5C73M3_NUM_PADS,
-                                                        state->sensor_pads, 0);
+                                                        state->sensor_pads);
        if (ret < 0)
                return ret;
@@ -1704,10 +1704,10 @@ static int s5c73m3_probe(struct i2c_client *client,
        state->oif_pads[OIF_ISP_PAD].flags = MEDIA_PAD_FL_SINK;
        state->oif_pads[OIF_JPEG_PAD].flags = MEDIA_PAD_FL_SINK;
        state->oif_pads[OIF_SOURCE_PAD].flags = MEDIA_PAD_FL_SOURCE;
-        oif_sd->entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
+        oif_sd->entity.function = MEDIA_ENT_F_V4L2_SUBDEV_UNKNOWN;
-        ret = media_entity_init(&oif_sd->entity, OIF_NUM_PADS,
+        ret = media_entity_pads_init(&oif_sd->entity, OIF_NUM_PADS,
-                                                        state->oif_pads, 0);
+                                                        state->oif_pads);
        if (ret < 0)
                return ret;
diff --git a/drivers/media/i2c/s5k4ecgx.c b/drivers/media/i2c/s5k4ecgx.c
index 6757aca2cdab..8a0f22da590f 100644
--- a/drivers/media/i2c/s5k4ecgx.c
+++ b/drivers/media/i2c/s5k4ecgx.c
@@ -961,8 +961,8 @@ static int s5k4ecgx_probe(struct i2c_client *client,
        sd->flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
        priv->pad.flags = MEDIA_PAD_FL_SOURCE;
-        sd->entity.type = MEDIA_ENT_T_V4L2_SUBDEV_SENSOR;
+        sd->entity.function = MEDIA_ENT_F_CAM_SENSOR;
-        ret = media_entity_init(&sd->entity, 1, &priv->pad, 0);
+        ret = media_entity_pads_init(&sd->entity, 1, &priv->pad);
        if (ret)
                return ret;
diff --git a/drivers/media/i2c/s5k5baf.c b/drivers/media/i2c/s5k5baf.c
index 774e0d0c94cb..fc3a5a8e6c9c 100644
--- a/drivers/media/i2c/s5k5baf.c
+++ b/drivers/media/i2c/s5k5baf.c
@@ -408,7 +408,7 @@ static inline struct v4l2_subdev *ctrl_to_sd(struct v4l2_ctrl *ctrl)
 static inline bool s5k5baf_is_cis_subdev(struct v4l2_subdev *sd)
 {
-        return sd->entity.type == MEDIA_ENT_T_V4L2_SUBDEV_SENSOR;
+        return sd->entity.function == MEDIA_ENT_F_CAM_SENSOR;
 }
 static inline struct s5k5baf *to_s5k5baf(struct v4l2_subdev *sd)
@@ -1756,7 +1756,7 @@ static int s5k5baf_registered(struct v4l2_subdev *sd)
                v4l2_err(sd, "failed to register subdev %s\n",
                         state->cis_sd.name);
        else
-                ret = media_entity_create_link(&state->cis_sd.entity, PAD_CIS,
+                ret = media_create_pad_link(&state->cis_sd.entity, PAD_CIS,
                                               &state->sd.entity, PAD_CIS,
                                               MEDIA_LNK_FL_IMMUTABLE |
                                               MEDIA_LNK_FL_ENABLED);
@@ -1904,8 +1904,8 @@ static int s5k5baf_configure_subdevs(struct s5k5baf *state,
        sd->flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
        state->cis_pad.flags = MEDIA_PAD_FL_SOURCE;
-        sd->entity.type = MEDIA_ENT_T_V4L2_SUBDEV_SENSOR;
+        sd->entity.function = MEDIA_ENT_F_CAM_SENSOR;
-        ret = media_entity_init(&sd->entity, NUM_CIS_PADS, &state->cis_pad, 0);
+        ret = media_entity_pads_init(&sd->entity, NUM_CIS_PADS, &state->cis_pad);
        if (ret < 0)
                goto err;
@@ -1919,8 +1919,8 @@ static int s5k5baf_configure_subdevs(struct s5k5baf *state,
        state->pads[PAD_CIS].flags = MEDIA_PAD_FL_SINK;
        state->pads[PAD_OUT].flags = MEDIA_PAD_FL_SOURCE;
-        sd->entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
+        sd->entity.function = MEDIA_ENT_F_V4L2_SUBDEV_UNKNOWN;
-        ret = media_entity_init(&sd->entity, NUM_ISP_PADS, state->pads, 0);
+        ret = media_entity_pads_init(&sd->entity, NUM_ISP_PADS, state->pads);
        if (!ret)
                return 0;
diff --git a/drivers/media/i2c/s5k6a3.c b/drivers/media/i2c/s5k6a3.c
index b1b1574dfb95..b9e43ffa5085 100644
--- a/drivers/media/i2c/s5k6a3.c
+++ b/drivers/media/i2c/s5k6a3.c
@@ -333,7 +333,7 @@ static int s5k6a3_probe(struct i2c_client *client,
        sensor->format.height = S5K6A3_DEFAULT_HEIGHT;
        sensor->pad.flags = MEDIA_PAD_FL_SOURCE;
-        ret = media_entity_init(&sd->entity, 1, &sensor->pad, 0);
+        ret = media_entity_pads_init(&sd->entity, 1, &sensor->pad);
        if (ret < 0)
                return ret;
diff --git a/drivers/media/i2c/s5k6aa.c b/drivers/media/i2c/s5k6aa.c
index 60aaff7190d2..faee11383cb7 100644
--- a/drivers/media/i2c/s5k6aa.c
+++ b/drivers/media/i2c/s5k6aa.c
@@ -1577,8 +1577,8 @@ static int s5k6aa_probe(struct i2c_client *client,
        sd->flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
        s5k6aa->pad.flags = MEDIA_PAD_FL_SOURCE;
-        sd->entity.type = MEDIA_ENT_T_V4L2_SUBDEV_SENSOR;
+        sd->entity.function = MEDIA_ENT_F_CAM_SENSOR;
-        ret = media_entity_init(&sd->entity, 1, &s5k6aa->pad, 0);
+        ret = media_entity_pads_init(&sd->entity, 1, &s5k6aa->pad);
        if (ret)
                return ret;
diff --git a/drivers/media/i2c/smiapp/smiapp-core.c b/drivers/media/i2c/smiapp/smiapp-core.c
index fb39dfd55e75..a215efe7a8ba 100644
--- a/drivers/media/i2c/smiapp/smiapp-core.c
+++ b/drivers/media/i2c/smiapp/smiapp-core.c
@@ -2487,31 +2487,31 @@ static int smiapp_register_subdevs(struct smiapp_sensor *sensor)
                if (!last)
                        continue;
-                rval = media_entity_init(&this->sd.entity,
+                rval = media_entity_pads_init(&this->sd.entity,
-                                         this->npads, this->pads, 0);
+                                         this->npads, this->pads);
                if (rval) {
                        dev_err(&client->dev,
-                                "media_entity_init failed\n");
+                                "media_entity_pads_init failed\n");
                        return rval;
                }
-                rval = media_entity_create_link(&this->sd.entity,
+                rval = v4l2_device_register_subdev(sensor->src->sd.v4l2_dev,
-                                                this->source_pad,
+                                                   &this->sd);
-                                                &last->sd.entity,
-                                                last->sink_pad,
-                                                MEDIA_LNK_FL_ENABLED |
-                                                MEDIA_LNK_FL_IMMUTABLE);
                if (rval) {
                        dev_err(&client->dev,
-                                "media_entity_create_link failed\n");
+                                "v4l2_device_register_subdev failed\n");
                        return rval;
                }
-                rval = v4l2_device_register_subdev(sensor->src->sd.v4l2_dev,
+                rval = media_create_pad_link(&this->sd.entity,
-                                                   &this->sd);
+                                             this->source_pad,
+                                             &last->sd.entity,
+                                             last->sink_pad,
+                                             MEDIA_LNK_FL_ENABLED |
+                                             MEDIA_LNK_FL_IMMUTABLE);
                if (rval) {
                        dev_err(&client->dev,
-                                "v4l2_device_register_subdev failed\n");
+                                "media_create_pad_link failed\n");
                        return rval;
                }
        }
@@ -2763,7 +2763,7 @@ static int smiapp_init(struct smiapp_sensor *sensor)
        dev_dbg(&client->dev, "profile %d\n", sensor->minfo.smiapp_profile);
-        sensor->pixel_array->sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV_SENSOR;
+        sensor->pixel_array->sd.entity.function = MEDIA_ENT_F_CAM_SENSOR;
        /* final steps */
        smiapp_read_frame_fmt(sensor);
@@ -3077,8 +3077,8 @@ static int smiapp_probe(struct i2c_client *client,
        sensor->src->sensor = sensor;
        sensor->src->pads[0].flags = MEDIA_PAD_FL_SOURCE;
-        rval = media_entity_init(&sensor->src->sd.entity, 2,
+        rval = media_entity_pads_init(&sensor->src->sd.entity, 2,
-                                 sensor->src->pads, 0);
+                                 sensor->src->pads);
        if (rval < 0)
                return rval;
diff --git a/drivers/media/i2c/tc358743.c b/drivers/media/i2c/tc358743.c
index 77b801152ea5..3397eb99c67b 100644
--- a/drivers/media/i2c/tc358743.c
+++ b/drivers/media/i2c/tc358743.c
@@ -1889,7 +1889,7 @@ static int tc358743_probe(struct i2c_client *client,
        }
        state->pad.flags = MEDIA_PAD_FL_SOURCE;
-        err = media_entity_init(&sd->entity, 1, &state->pad, 0);
+        err = media_entity_pads_init(&sd->entity, 1, &state->pad);
        if (err < 0)
                goto err_hdl;
diff --git a/drivers/media/i2c/tvp514x.c b/drivers/media/i2c/tvp514x.c
index b5dba5b7ce3a..7fa5f1e4fe37 100644
--- a/drivers/media/i2c/tvp514x.c
+++ b/drivers/media/i2c/tvp514x.c
@@ -1095,9 +1095,9 @@ tvp514x_probe(struct i2c_client *client, const struct i2c_device_id *id)
 #if defined(CONFIG_MEDIA_CONTROLLER)
        decoder->pad.flags = MEDIA_PAD_FL_SOURCE;
        decoder->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
-        decoder->sd.entity.flags |= MEDIA_ENT_T_V4L2_SUBDEV_DECODER;
+        decoder->sd.entity.flags |= MEDIA_ENT_F_ATV_DECODER;
-        ret = media_entity_init(&decoder->sd.entity, 1, &decoder->pad, 0);
+        ret = media_entity_pads_init(&decoder->sd.entity, 1, &decoder->pad);
        if (ret < 0) {
                v4l2_err(sd, "%s decoder driver failed to register !!\n",
                         sd->name);
diff --git a/drivers/media/i2c/tvp7002.c b/drivers/media/i2c/tvp7002.c
index 772a3043ae3b..83c79fa5f61d 100644
--- a/drivers/media/i2c/tvp7002.c
+++ b/drivers/media/i2c/tvp7002.c
@@ -1012,9 +1012,9 @@ static int tvp7002_probe(struct i2c_client *c, const struct i2c_device_id *id)
 #if defined(CONFIG_MEDIA_CONTROLLER)
        device->pad.flags = MEDIA_PAD_FL_SOURCE;
        device->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
-        device->sd.entity.flags |= MEDIA_ENT_T_V4L2_SUBDEV_DECODER;
+        device->sd.entity.flags |= MEDIA_ENT_F_ATV_DECODER;
-        error = media_entity_init(&device->sd.entity, 1, &device->pad, 0);
+        error = media_entity_pads_init(&device->sd.entity, 1, &device->pad);
        if (error < 0)
                return error;
 #endif
diff --git a/drivers/media/media-device.c b/drivers/media/media-device.c
index 7b39440192d6..7dae0ac0f3ae 100644
--- a/drivers/media/media-device.c
+++ b/drivers/media/media-device.c
@@ -22,14 +22,18 @@
 #include <linux/compat.h>
 #include <linux/export.h>
+#include <linux/idr.h>
 #include <linux/ioctl.h>
 #include <linux/media.h>
+#include <linux/slab.h>
 #include <linux/types.h>
 #include <media/media-device.h>
 #include <media/media-devnode.h>
 #include <media/media-entity.h>
+#ifdef CONFIG_MEDIA_CONTROLLER
 /* -----------------------------------------------------------------------------
 * Userspace API
 */
@@ -75,8 +79,8 @@ static struct media_entity *find_entity(struct media_device *mdev, u32 id)
        spin_lock(&mdev->lock);
        media_device_for_each_entity(entity, mdev) {
-                if ((entity->id == id && !next) ||
+                if (((media_entity_id(entity) == id) && !next) ||
-                    (entity->id > id && next)) {
+                    ((media_entity_id(entity) > id) && next)) {
                        spin_unlock(&mdev->lock);
                        return entity;
                }
@@ -102,13 +106,13 @@ static long media_device_enum_entities(struct media_device *mdev,
        if (ent == NULL)
                return -EINVAL;
-        u_ent.id = ent->id;
+        u_ent.id = media_entity_id(ent);
        if (ent->name)
                strlcpy(u_ent.name, ent->name, sizeof(u_ent.name));
-        u_ent.type = ent->type;
+        u_ent.type = ent->function;
-        u_ent.revision = ent->revision;
+        u_ent.revision = 0;             /* Unused */
        u_ent.flags = ent->flags;
-        u_ent.group_id = ent->group_id;
+        u_ent.group_id = 0;             /* Unused */
        u_ent.pads = ent->num_pads;
        u_ent.links = ent->num_links - ent->num_backlinks;
        memcpy(&u_ent.raw, &ent->info, sizeof(ent->info));
@@ -120,7 +124,7 @@ static long media_device_enum_entities(struct media_device *mdev,
 static void media_device_kpad_to_upad(const struct media_pad *kpad,
                                      struct media_pad_desc *upad)
 {
-        upad->entity = kpad->entity->id;
+        upad->entity = media_entity_id(kpad->entity);
        upad->index = kpad->index;
        upad->flags = kpad->flags;
 }
@@ -148,25 +152,25 @@ static long __media_device_enum_links(struct media_device *mdev,
        }
        if (links->links) {
-                struct media_link_desc __user *ulink;
+                struct media_link *link;
-                unsigned int l;
+                struct media_link_desc __user *ulink_desc = links->links;
-                for (l = 0, ulink = links->links; l < entity->num_links; l++) {
+                list_for_each_entry(link, &entity->links, list) {
-                        struct media_link_desc link;
+                        struct media_link_desc klink_desc;
                        /* Ignore backlinks. */
-                        if (entity->links[l].source->entity != entity)
+                        if (link->source->entity != entity)
                                continue;
+                        memset(&klink_desc, 0, sizeof(klink_desc));
-                        memset(&link, 0, sizeof(link));
+                        media_device_kpad_to_upad(link->source,
-                        media_device_kpad_to_upad(entity->links[l].source,
+                                                  &klink_desc.source);
-                                                  &link.source);
+                        media_device_kpad_to_upad(link->sink,
-                        media_device_kpad_to_upad(entity->links[l].sink,
+                                                  &klink_desc.sink);
-                                                  &link.sink);
+                        klink_desc.flags = link->flags;
-                        link.flags = entity->links[l].flags;
+                        if (copy_to_user(ulink_desc, &klink_desc,
-                        if (copy_to_user(ulink, &link, sizeof(*ulink)))
+                                         sizeof(*ulink_desc)))
                                return -EFAULT;
-                        ulink++;
+                        ulink_desc++;
                }
        }
@@ -230,6 +234,164 @@ static long media_device_setup_link(struct media_device *mdev,
        return ret;
 }
+#if 0 /* Let's postpone it to Kernel 4.6 */
+static long __media_device_get_topology(struct media_device *mdev,
+                                      struct media_v2_topology *topo)
+{
+        struct media_entity *entity;
+        struct media_interface *intf;
+        struct media_pad *pad;
+        struct media_link *link;
+        struct media_v2_entity kentity, *uentity;
+        struct media_v2_interface kintf, *uintf;
+        struct media_v2_pad kpad, *upad;
+        struct media_v2_link klink, *ulink;
+        unsigned int i;
+        int ret = 0;
+        topo->topology_version = mdev->topology_version;
+        /* Get entities and number of entities */
+        i = 0;
+        uentity = media_get_uptr(topo->ptr_entities);
+        media_device_for_each_entity(entity, mdev) {
+                i++;
+                if (ret || !uentity)
+                        continue;
+                if (i > topo->num_entities) {
+                        ret = -ENOSPC;
+                        continue;
+                }
+                /* Copy fields to userspace struct if not error */
+                memset(&kentity, 0, sizeof(kentity));
+                kentity.id = entity->graph_obj.id;
+                kentity.function = entity->function;
+                strncpy(kentity.name, entity->name,
+                        sizeof(kentity.name));
+                if (copy_to_user(uentity, &kentity, sizeof(kentity)))
+                        ret = -EFAULT;
+                uentity++;
+        }
+        topo->num_entities = i;
+        /* Get interfaces and number of interfaces */
+        i = 0;
+        uintf = media_get_uptr(topo->ptr_interfaces);
+        media_device_for_each_intf(intf, mdev) {
+                i++;
+                if (ret || !uintf)
+                        continue;
+                if (i > topo->num_interfaces) {
+                        ret = -ENOSPC;
+                        continue;
+                }
+                memset(&kintf, 0, sizeof(kintf));
+                /* Copy intf fields to userspace struct */
+                kintf.id = intf->graph_obj.id;
+                kintf.intf_type = intf->type;
+                kintf.flags = intf->flags;
+                if (media_type(&intf->graph_obj) == MEDIA_GRAPH_INTF_DEVNODE) {
+                        struct media_intf_devnode *devnode;
+                        devnode = intf_to_devnode(intf);
+                        kintf.devnode.major = devnode->major;
+                        kintf.devnode.minor = devnode->minor;
+                }
+                if (copy_to_user(uintf, &kintf, sizeof(kintf)))
+                        ret = -EFAULT;
+                uintf++;
+        }
+        topo->num_interfaces = i;
+        /* Get pads and number of pads */
+        i = 0;
+        upad = media_get_uptr(topo->ptr_pads);
+        media_device_for_each_pad(pad, mdev) {
+                i++;
+                if (ret || !upad)
+                        continue;
+                if (i > topo->num_pads) {
+                        ret = -ENOSPC;
+                        continue;
+                }
+                memset(&kpad, 0, sizeof(kpad));
+                /* Copy pad fields to userspace struct */
+                kpad.id = pad->graph_obj.id;
+                kpad.entity_id = pad->entity->graph_obj.id;
+                kpad.flags = pad->flags;
+                if (copy_to_user(upad, &kpad, sizeof(kpad)))
+                        ret = -EFAULT;
+                upad++;
+        }
+        topo->num_pads = i;
+        /* Get links and number of links */
+        i = 0;
+        ulink = media_get_uptr(topo->ptr_links);
+        media_device_for_each_link(link, mdev) {
+                if (link->is_backlink)
+                        continue;
+                i++;
+                if (ret || !ulink)
+                        continue;
+                if (i > topo->num_links) {
+                        ret = -ENOSPC;
+                        continue;
+                }
+                memset(&klink, 0, sizeof(klink));
+                /* Copy link fields to userspace struct */
+                klink.id = link->graph_obj.id;
+                klink.source_id = link->gobj0->id;
+                klink.sink_id = link->gobj1->id;
+                klink.flags = link->flags;
+                if (copy_to_user(ulink, &klink, sizeof(klink)))
+                        ret = -EFAULT;
+                ulink++;
+        }
+        topo->num_links = i;
+        return ret;
+}
+static long media_device_get_topology(struct media_device *mdev,
+                                      struct media_v2_topology __user *utopo)
+{
+        struct media_v2_topology ktopo;
+        int ret;
+        if (copy_from_user(&ktopo, utopo, sizeof(ktopo)))
+                return -EFAULT;
+        ret = __media_device_get_topology(mdev, &ktopo);
+        if (ret < 0)
+                return ret;
+        if (copy_to_user(utopo, &ktopo, sizeof(*utopo)))
+                return -EFAULT;
+        return 0;
+}
+#endif
 static long media_device_ioctl(struct file *filp, unsigned int cmd,
                               unsigned long arg)
 {
@@ -262,6 +424,14 @@ static long media_device_ioctl(struct file *filp, unsigned int cmd,
                mutex_unlock(&dev->graph_mutex);
                break;
+#if 0 /* Let's postpone it to Kernel 4.6 */
+        case MEDIA_IOC_G_TOPOLOGY:
+                mutex_lock(&dev->graph_mutex);
+                ret = media_device_get_topology(dev,
+                                (struct media_v2_topology __user *)arg);
+                mutex_unlock(&dev->graph_mutex);
+                break;
+#endif
        default:
                ret = -ENOIOCTLCMD;
        }
@@ -310,6 +480,9 @@ static long media_device_compat_ioctl(struct file *filp, unsigned int cmd,
        case MEDIA_IOC_DEVICE_INFO:
        case MEDIA_IOC_ENUM_ENTITIES:
        case MEDIA_IOC_SETUP_LINK:
+#if 0 /* Let's postpone it to Kernel 4.6 */
+        case MEDIA_IOC_G_TOPOLOGY:
+#endif
                return media_device_ioctl(filp, cmd, arg);
        case MEDIA_IOC_ENUM_LINKS32:
@@ -357,10 +530,107 @@ static DEVICE_ATTR(model, S_IRUGO, show_model, NULL);
 static void media_device_release(struct media_devnode *mdev)
 {
+        dev_dbg(mdev->parent, "Media device released\n");
+}
+/**
+ * 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)
+{
+        unsigned int i;
+        int ret;
+        if (entity->function == MEDIA_ENT_F_V4L2_SUBDEV_UNKNOWN ||
+            entity->function == MEDIA_ENT_F_UNKNOWN)
+                dev_warn(mdev->dev,
+                         "Entity type for entity %s was not initialized!\n",
+                         entity->name);
+        /* Warn if we apparently re-register an entity */
+        WARN_ON(entity->graph_obj.mdev != NULL);
+        entity->graph_obj.mdev = mdev;
+        INIT_LIST_HEAD(&entity->links);
+        entity->num_links = 0;
+        entity->num_backlinks = 0;
+        if (!ida_pre_get(&mdev->entity_internal_idx, GFP_KERNEL))
+                return -ENOMEM;
+        spin_lock(&mdev->lock);
+        ret = ida_get_new_above(&mdev->entity_internal_idx, 1,
+                                &entity->internal_idx);
+        if (ret < 0) {
+                spin_unlock(&mdev->lock);
+                return ret;
+        }
+        mdev->entity_internal_idx_max =
+                max(mdev->entity_internal_idx_max, entity->internal_idx);
+        /* Initialize media_gobj embedded at the entity */
+        media_gobj_create(mdev, MEDIA_GRAPH_ENTITY, &entity->graph_obj);
+        /* Initialize objects at the pads */
+        for (i = 0; i < entity->num_pads; i++)
+                media_gobj_create(mdev, MEDIA_GRAPH_PAD,
+                               &entity->pads[i].graph_obj);
+        spin_unlock(&mdev->lock);
+        return 0;
+}
+EXPORT_SYMBOL_GPL(media_device_register_entity);
+static void __media_device_unregister_entity(struct media_entity *entity)
+{
+        struct media_device *mdev = entity->graph_obj.mdev;
+        struct media_link *link, *tmp;
+        struct media_interface *intf;
+        unsigned int i;
+        ida_simple_remove(&mdev->entity_internal_idx, entity->internal_idx);
+        /* Remove all interface links pointing to this entity */
+        list_for_each_entry(intf, &mdev->interfaces, graph_obj.list) {
+                list_for_each_entry_safe(link, tmp, &intf->links, list) {
+                        if (link->entity == entity)
+                                __media_remove_intf_link(link);
+                }
+        }
+        /* Remove all data links that belong to this entity */
+        __media_entity_remove_links(entity);
+        /* Remove all pads that belong to this entity */
+        for (i = 0; i < entity->num_pads; i++)
+                media_gobj_destroy(&entity->pads[i].graph_obj);
+        /* Remove the entity */
+        media_gobj_destroy(&entity->graph_obj);
+        entity->graph_obj.mdev = NULL;
 }
+void media_device_unregister_entity(struct media_entity *entity)
+{
+        struct media_device *mdev = entity->graph_obj.mdev;
+        if (mdev == NULL)
+                return;
+        spin_lock(&mdev->lock);
+        __media_device_unregister_entity(entity);
+        spin_unlock(&mdev->lock);
+}
+EXPORT_SYMBOL_GPL(media_device_unregister_entity);
 /**
- * media_device_register - register a media device
+ * media_device_init() - initialize a media device
 * @mdev:       The media device
 *
 * The caller is responsible for initializing the media device before
@@ -369,23 +639,41 @@ static void media_device_release(struct media_devnode *mdev)
 * - dev must point to the parent device
 * - model must be filled with the device model name
 */
-int __must_check __media_device_register(struct media_device *mdev,
+void media_device_init(struct media_device *mdev)
-                                         struct module *owner)
 {
-        int ret;
-        if (WARN_ON(mdev->dev == NULL || mdev->model[0] == 0))
-                return -EINVAL;
-        mdev->entity_id = 1;
        INIT_LIST_HEAD(&mdev->entities);
+        INIT_LIST_HEAD(&mdev->interfaces);
+        INIT_LIST_HEAD(&mdev->pads);
+        INIT_LIST_HEAD(&mdev->links);
        spin_lock_init(&mdev->lock);
        mutex_init(&mdev->graph_mutex);
+        ida_init(&mdev->entity_internal_idx);
+        dev_dbg(mdev->dev, "Media device initialized\n");
+}
+EXPORT_SYMBOL_GPL(media_device_init);
+void media_device_cleanup(struct media_device *mdev)
+{
+        ida_destroy(&mdev->entity_internal_idx);
+        mdev->entity_internal_idx_max = 0;
+        mutex_destroy(&mdev->graph_mutex);
+}
+EXPORT_SYMBOL_GPL(media_device_cleanup);
+int __must_check __media_device_register(struct media_device *mdev,
+                                         struct module *owner)
+{
+        int ret;
        /* Register the device node. */
        mdev->devnode.fops = &media_device_fops;
        mdev->devnode.parent = mdev->dev;
        mdev->devnode.release = media_device_release;
+        /* Set version 0 to indicate user-space that the graph is static */
+        mdev->topology_version = 0;
        ret = media_devnode_register(&mdev->devnode, owner);
        if (ret < 0)
                return ret;
@@ -396,69 +684,74 @@ int __must_check __media_device_register(struct media_device *mdev,
                return ret;
        }
+        dev_dbg(mdev->dev, "Media device registered\n");
        return 0;
 }
 EXPORT_SYMBOL_GPL(__media_device_register);
-/**
- * media_device_unregister - unregister a media device
- * @mdev:       The media device
- *
- */
 void media_device_unregister(struct media_device *mdev)
 {
        struct media_entity *entity;
        struct media_entity *next;
+        struct media_interface *intf, *tmp_intf;
-        list_for_each_entry_safe(entity, next, &mdev->entities, list)
+        if (mdev == NULL)
-                media_device_unregister_entity(entity);
+                return;
+        spin_lock(&mdev->lock);
+        /* Check if mdev was ever registered at all */
+        if (!media_devnode_is_registered(&mdev->devnode)) {
+                spin_unlock(&mdev->lock);
+                return;
+        }
+        /* Remove all entities from the media device */
+        list_for_each_entry_safe(entity, next, &mdev->entities, graph_obj.list)
+                __media_device_unregister_entity(entity);
+        /* Remove all interfaces from the media device */
+        list_for_each_entry_safe(intf, tmp_intf, &mdev->interfaces,
+                                 graph_obj.list) {
+                __media_remove_intf_links(intf);
+                media_gobj_destroy(&intf->graph_obj);
+                kfree(intf);
+        }
+        spin_unlock(&mdev->lock);
        device_remove_file(&mdev->devnode.dev, &dev_attr_model);
        media_devnode_unregister(&mdev->devnode);
+        dev_dbg(mdev->dev, "Media device unregistered\n");
 }
 EXPORT_SYMBOL_GPL(media_device_unregister);
-/**
+static void media_device_release_devres(struct device *dev, void *res)
- * 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);
-/**
+struct media_device *media_device_get_devres(struct device *dev)
- * 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;
+        struct media_device *mdev;
-        if (mdev == NULL)
+        mdev = devres_find(dev, media_device_release_devres, NULL, NULL);
-                return;
+        if (mdev)
+                return mdev;
-        spin_lock(&mdev->lock);
+        mdev = devres_alloc(media_device_release_devres,
-        list_del(&entity->list);
+                                sizeof(struct media_device), GFP_KERNEL);
-        spin_unlock(&mdev->lock);
+        if (!mdev)
-        entity->parent = NULL;
+                return NULL;
+        return devres_get(dev, mdev, NULL, NULL);
 }
-EXPORT_SYMBOL_GPL(media_device_unregister_entity);
+EXPORT_SYMBOL_GPL(media_device_get_devres);
+struct media_device *media_device_find_devres(struct device *dev)
+{
+        return devres_find(dev, media_device_release_devres, NULL, NULL);
+}
+EXPORT_SYMBOL_GPL(media_device_find_devres);
+#endif /* CONFIG_MEDIA_CONTROLLER */
diff --git a/drivers/media/media-devnode.c b/drivers/media/media-devnode.c
index ebf9626e5ae5..cea35bf20011 100644
--- a/drivers/media/media-devnode.c
+++ b/drivers/media/media-devnode.c
@@ -217,20 +217,6 @@ static const struct file_operations media_devnode_fops = {
        .llseek = no_llseek,
 };
-/**
- * media_devnode_register - register a media device node
- * @mdev: media device node structure we want to register
- *
- * The registration code assigns minor numbers and registers the new device node
- * with the kernel. An error is returned if no free minor number can be found,
- * or if the registration of the device node fails.
- *
- * Zero is returned on success.
- *
- * Note that if the media_devnode_register call fails, the release() callback of
- * the media_devnode structure is *not* called, so the caller is responsible for
- * freeing any data.
- */
 int __must_check media_devnode_register(struct media_devnode *mdev,
                                        struct module *owner)
 {
@@ -285,16 +271,6 @@ error:
        return ret;
 }
-/**
- * media_devnode_unregister - unregister a media device node
- * @mdev: the device node to unregister
- *
- * This unregisters the passed device. Future open calls will be met with
- * errors.
- *
- * This function can safely be called if the device node has never been
- * registered or has already been unregistered.
- */
 void media_devnode_unregister(struct media_devnode *mdev)
 {
        /* Check if mdev was ever registered at all */
diff --git a/drivers/media/media-entity.c b/drivers/media/media-entity.c
index 767fe55ba08e..e89d85a7d31b 100644
--- a/drivers/media/media-entity.c
+++ b/drivers/media/media-entity.c
@@ -26,65 +26,198 @@
 #include <media/media-entity.h>
 #include <media/media-device.h>
+static inline const char *gobj_type(enum media_gobj_type type)
+{
+        switch (type) {
+        case MEDIA_GRAPH_ENTITY:
+                return "entity";
+        case MEDIA_GRAPH_PAD:
+                return "pad";
+        case MEDIA_GRAPH_LINK:
+                return "link";
+        case MEDIA_GRAPH_INTF_DEVNODE:
+                return "intf-devnode";
+        default:
+                return "unknown";
+        }
+}
+static inline const char *intf_type(struct media_interface *intf)
+{
+        switch (intf->type) {
+        case MEDIA_INTF_T_DVB_FE:
+                return "frontend";
+        case MEDIA_INTF_T_DVB_DEMUX:
+                return "demux";
+        case MEDIA_INTF_T_DVB_DVR:
+                return "DVR";
+        case MEDIA_INTF_T_DVB_CA:
+                return  "CA";
+        case MEDIA_INTF_T_DVB_NET:
+                return "dvbnet";
+        case MEDIA_INTF_T_V4L_VIDEO:
+                return "video";
+        case MEDIA_INTF_T_V4L_VBI:
+                return "vbi";
+        case MEDIA_INTF_T_V4L_RADIO:
+                return "radio";
+        case MEDIA_INTF_T_V4L_SUBDEV:
+                return "v4l2-subdev";
+        case MEDIA_INTF_T_V4L_SWRADIO:
+                return "swradio";
+        default:
+                return "unknown-intf";
+        }
+};
+__must_check int __media_entity_enum_init(struct media_entity_enum *ent_enum,
+                                          int idx_max)
+{
+        ent_enum->bmap = kcalloc(DIV_ROUND_UP(idx_max, BITS_PER_LONG),
+                                 sizeof(long), GFP_KERNEL);
+        if (!ent_enum->bmap)
+                return -ENOMEM;
+        bitmap_zero(ent_enum->bmap, idx_max);
+        ent_enum->idx_max = idx_max;
+        return 0;
+}
+EXPORT_SYMBOL_GPL(__media_entity_enum_init);
+void media_entity_enum_cleanup(struct media_entity_enum *ent_enum)
+{
+        kfree(ent_enum->bmap);
+}
+EXPORT_SYMBOL_GPL(media_entity_enum_cleanup);
 /**
- * media_entity_init - Initialize a media entity
+ *  dev_dbg_obj - Prints in debug mode a change on some object
- *
- * @num_pads: Total number of sink and source 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
+ * @event_name: Name of the event to report. Could be __func__
- * 'num_pads' + 'extra_links' elements. The media_entity::max_links field will
+ * @gobj:       Pointer to the object
- * be set to the number of allocated elements.
 *
- * The pads array is managed by the entity driver and passed to
+ * Enabled only if DEBUG or CONFIG_DYNAMIC_DEBUG. Otherwise, it
- * media_entity_init() where its pointer will be stored in the entity structure.
+ * won't produce any code.
 */
-int
+static void dev_dbg_obj(const char *event_name,  struct media_gobj *gobj)
-media_entity_init(struct media_entity *entity, u16 num_pads,
-                  struct media_pad *pads, u16 extra_links)
 {
-        struct media_link *links;
+#if defined(DEBUG) || defined (CONFIG_DYNAMIC_DEBUG)
-        unsigned int max_links = num_pads + extra_links;
+        switch (media_type(gobj)) {
-        unsigned int i;
+        case MEDIA_GRAPH_ENTITY:
+                dev_dbg(gobj->mdev->dev,
+                        "%s id %u: entity '%s'\n",
+                        event_name, media_id(gobj),
+                        gobj_to_entity(gobj)->name);
+                break;
+        case MEDIA_GRAPH_LINK:
+        {
+                struct media_link *link = gobj_to_link(gobj);
+                dev_dbg(gobj->mdev->dev,
+                        "%s id %u: %s link id %u ==> id %u\n",
+                        event_name, media_id(gobj),
+                        media_type(link->gobj0) == MEDIA_GRAPH_PAD ?
+                                "data" : "interface",
+                        media_id(link->gobj0),
+                        media_id(link->gobj1));
+                break;
+        }
+        case MEDIA_GRAPH_PAD:
+        {
+                struct media_pad *pad = gobj_to_pad(gobj);
+                dev_dbg(gobj->mdev->dev,
+                        "%s id %u: %s%spad '%s':%d\n",
+                        event_name, media_id(gobj),
+                        pad->flags & MEDIA_PAD_FL_SINK   ? "sink " : "",
+                        pad->flags & MEDIA_PAD_FL_SOURCE ? "source " : "",
+                        pad->entity->name, pad->index);
+                break;
+        }
+        case MEDIA_GRAPH_INTF_DEVNODE:
+        {
+                struct media_interface *intf = gobj_to_intf(gobj);
+                struct media_intf_devnode *devnode = intf_to_devnode(intf);
+                dev_dbg(gobj->mdev->dev,
+                        "%s id %u: intf_devnode %s - major: %d, minor: %d\n",
+                        event_name, media_id(gobj),
+                        intf_type(intf),
+                        devnode->major, devnode->minor);
+                break;
+        }
+        }
+#endif
+}
-        links = kzalloc(max_links * sizeof(links[0]), GFP_KERNEL);
+void media_gobj_create(struct media_device *mdev,
-        if (links == NULL)
+                           enum media_gobj_type type,
-                return -ENOMEM;
+                           struct media_gobj *gobj)
+{
+        BUG_ON(!mdev);
+        gobj->mdev = mdev;
+        /* Create a per-type unique object ID */
+        gobj->id = media_gobj_gen_id(type, ++mdev->id);
+        switch (type) {
+        case MEDIA_GRAPH_ENTITY:
+                list_add_tail(&gobj->list, &mdev->entities);
+                break;
+        case MEDIA_GRAPH_PAD:
+                list_add_tail(&gobj->list, &mdev->pads);
+                break;
+        case MEDIA_GRAPH_LINK:
+                list_add_tail(&gobj->list, &mdev->links);
+                break;
+        case MEDIA_GRAPH_INTF_DEVNODE:
+                list_add_tail(&gobj->list, &mdev->interfaces);
+                break;
+        }
+        mdev->topology_version++;
+        dev_dbg_obj(__func__, gobj);
+}
+void media_gobj_destroy(struct media_gobj *gobj)
+{
+        dev_dbg_obj(__func__, gobj);
+        gobj->mdev->topology_version++;
+        /* Remove the object from mdev list */
+        list_del(&gobj->list);
+}
+int media_entity_pads_init(struct media_entity *entity, u16 num_pads,
+                           struct media_pad *pads)
+{
+        struct media_device *mdev = entity->graph_obj.mdev;
+        unsigned int i;
-        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;
+        if (mdev)
+                spin_lock(&mdev->lock);
        for (i = 0; i < num_pads; i++) {
                pads[i].entity = entity;
                pads[i].index = i;
+                if (mdev)
+                        media_gobj_create(mdev, MEDIA_GRAPH_PAD,
+                                        &entity->pads[i].graph_obj);
        }
-        return 0;
+        if (mdev)
-}
+                spin_unlock(&mdev->lock);
-EXPORT_SYMBOL_GPL(media_entity_init);
-void
+        return 0;
-media_entity_cleanup(struct media_entity *entity)
-{
-        kfree(entity->links);
 }
-EXPORT_SYMBOL_GPL(media_entity_cleanup);
+EXPORT_SYMBOL_GPL(media_entity_pads_init);
 /* -----------------------------------------------------------------------------
 * Graph traversal
@@ -108,7 +241,7 @@ static void stack_push(struct media_entity_graph *graph,
                return;
        }
        graph->top++;
-        graph->stack[graph->top].link = 0;
+        graph->stack[graph->top].link = entity->links.next;
        graph->stack[graph->top].entity = entity;
 }
@@ -125,43 +258,51 @@ static struct media_entity *stack_pop(struct media_entity_graph *graph)
 #define link_top(en)    ((en)->stack[(en)->top].link)
 #define stack_top(en)   ((en)->stack[(en)->top].entity)
+/*
+ * TODO: Get rid of this.
+ */
+#define MEDIA_ENTITY_MAX_PADS           512
 /**
- * media_entity_graph_walk_start - Start walking the media graph at a given entity
+ * media_entity_graph_walk_init - Allocate resources for graph walk
 * @graph: Media graph structure that will be used to walk the graph
- * @entity: Starting entity
+ * @mdev: Media device
 *
- * This function initializes the graph traversal structure to walk the entities
+ * Reserve resources for graph walk in media device's current
- * graph starting at the given entity. The traversal structure must not be
+ * state. The memory must be released using
- * modified by the caller during graph traversal. When done the structure can
+ * media_entity_graph_walk_free().
- * safely be freed.
+ *
+ * Returns error on failure, zero on success.
 */
+__must_check int media_entity_graph_walk_init(
+        struct media_entity_graph *graph, struct media_device *mdev)
+{
+        return media_entity_enum_init(&graph->ent_enum, mdev);
+}
+EXPORT_SYMBOL_GPL(media_entity_graph_walk_init);
+/**
+ * media_entity_graph_walk_cleanup - Release resources related to graph walking
+ * @graph: Media graph structure that was used to walk the graph
+ */
+void media_entity_graph_walk_cleanup(struct media_entity_graph *graph)
+{
+        media_entity_enum_cleanup(&graph->ent_enum);
+}
+EXPORT_SYMBOL_GPL(media_entity_graph_walk_cleanup);
 void media_entity_graph_walk_start(struct media_entity_graph *graph,
                                   struct media_entity *entity)
 {
+        media_entity_enum_zero(&graph->ent_enum);
+        media_entity_enum_set(&graph->ent_enum, entity);
        graph->top = 0;
        graph->stack[graph->top].entity = NULL;
-        bitmap_zero(graph->entities, MEDIA_ENTITY_ENUM_MAX_ID);
-        if (WARN_ON(entity->id >= MEDIA_ENTITY_ENUM_MAX_ID))
-                return;
-        __set_bit(entity->id, graph->entities);
        stack_push(graph, entity);
 }
 EXPORT_SYMBOL_GPL(media_entity_graph_walk_start);
-/**
- * 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.
- */
 struct media_entity *
 media_entity_graph_walk_next(struct media_entity_graph *graph)
 {
@@ -173,30 +314,30 @@ media_entity_graph_walk_next(struct media_entity_graph *graph)
         * top of the stack until no more entities on the level can be
         * found.
         */
-        while (link_top(graph) < stack_top(graph)->num_links) {
+        while (link_top(graph) != &stack_top(graph)->links) {
                struct media_entity *entity = stack_top(graph);
-                struct media_link *link = &entity->links[link_top(graph)];
+                struct media_link *link;
                struct media_entity *next;
+                link = list_entry(link_top(graph), typeof(*link), list);
                /* The link is not enabled so we do not follow. */
                if (!(link->flags & MEDIA_LNK_FL_ENABLED)) {
-                        link_top(graph)++;
+                        link_top(graph) = link_top(graph)->next;
                        continue;
                }
                /* Get the entity in the other end of the link . */
                next = media_entity_other(entity, link);
-                if (WARN_ON(next->id >= MEDIA_ENTITY_ENUM_MAX_ID))
-                        return NULL;
                /* Has the entity already been visited? */
-                if (__test_and_set_bit(next->id, graph->entities)) {
+                if (media_entity_enum_test_and_set(&graph->ent_enum, next)) {
-                        link_top(graph)++;
+                        link_top(graph) = link_top(graph)->next;
                        continue;
                }
                /* Push the new entity to stack and start over. */
-                link_top(graph)++;
+                link_top(graph) = link_top(graph)->next;
                stack_push(graph, next);
        }
@@ -208,39 +349,36 @@ EXPORT_SYMBOL_GPL(media_entity_graph_walk_next);
 * Pipeline management
 */
-/**
- * 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().
- */
 __must_check int media_entity_pipeline_start(struct media_entity *entity,
                                             struct media_pipeline *pipe)
 {
-        struct media_device *mdev = entity->parent;
+        struct media_device *mdev = entity->graph_obj.mdev;
-        struct media_entity_graph graph;
+        struct media_entity_graph *graph = &pipe->graph;
        struct media_entity *entity_err = entity;
+        struct media_link *link;
        int ret;
        mutex_lock(&mdev->graph_mutex);
-        media_entity_graph_walk_start(&graph, entity);
+        if (!pipe->streaming_count++) {
+                ret = media_entity_graph_walk_init(&pipe->graph, mdev);
+                if (ret)
+                        goto error_graph_walk_start;
+        }
+        media_entity_graph_walk_start(&pipe->graph, entity);
-        while ((entity = media_entity_graph_walk_next(&graph))) {
+        while ((entity = media_entity_graph_walk_next(graph))) {
                DECLARE_BITMAP(active, MEDIA_ENTITY_MAX_PADS);
                DECLARE_BITMAP(has_no_links, MEDIA_ENTITY_MAX_PADS);
-                unsigned int i;
                entity->stream_count++;
-                WARN_ON(entity->pipe && entity->pipe != pipe);
+                if (WARN_ON(entity->pipe && entity->pipe != pipe)) {
+                        ret = -EBUSY;
+                        goto error;
+                }
                entity->pipe = pipe;
                /* Already streaming --- no need to check. */
@@ -253,8 +391,7 @@ __must_check int media_entity_pipeline_start(struct media_entity *entity,
                bitmap_zero(active, entity->num_pads);
                bitmap_fill(has_no_links, entity->num_pads);
-                for (i = 0; i < entity->num_links; i++) {
+                list_for_each_entry(link, &entity->links, list) {
-                        struct media_link *link = &entity->links[i];
                        struct media_pad *pad = link->sink->entity == entity
                                                ? link->sink : link->source;
@@ -280,7 +417,7 @@ __must_check int media_entity_pipeline_start(struct media_entity *entity,
                        ret = entity->ops->link_validate(link);
                        if (ret < 0 && ret != -ENOIOCTLCMD) {
-                                dev_dbg(entity->parent->dev,
+                                dev_dbg(entity->graph_obj.mdev->dev,
                                        "link validation failed for \"%s\":%u -> \"%s\":%u, error %d\n",
                                        link->source->entity->name,
                                        link->source->index,
@@ -294,7 +431,7 @@ __must_check int media_entity_pipeline_start(struct media_entity *entity,
                if (!bitmap_full(active, entity->num_pads)) {
                        ret = -EPIPE;
-                        dev_dbg(entity->parent->dev,
+                        dev_dbg(entity->graph_obj.mdev->dev,
                                "\"%s\":%u must be connected by an enabled link\n",
                                entity->name,
                                (unsigned)find_first_zero_bit(
@@ -312,9 +449,9 @@ error:
         * Link validation on graph failed. We revert what we did and
         * return the error.
         */
-        media_entity_graph_walk_start(&graph, entity_err);
+        media_entity_graph_walk_start(graph, entity_err);
-        while ((entity_err = media_entity_graph_walk_next(&graph))) {
+        while ((entity_err = media_entity_graph_walk_next(graph))) {
                entity_err->stream_count--;
                if (entity_err->stream_count == 0)
                        entity_err->pipe = NULL;
@@ -327,39 +464,36 @@ error:
                        break;
        }
+error_graph_walk_start:
+        if (!--pipe->streaming_count)
+                media_entity_graph_walk_cleanup(graph);
        mutex_unlock(&mdev->graph_mutex);
        return ret;
 }
 EXPORT_SYMBOL_GPL(media_entity_pipeline_start);
-/**
- * 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.
- */
 void media_entity_pipeline_stop(struct media_entity *entity)
 {
-        struct media_device *mdev = entity->parent;
+        struct media_device *mdev = entity->graph_obj.mdev;
-        struct media_entity_graph graph;
+        struct media_entity_graph *graph = &entity->pipe->graph;
+        struct media_pipeline *pipe = entity->pipe;
        mutex_lock(&mdev->graph_mutex);
-        media_entity_graph_walk_start(&graph, entity);
+        WARN_ON(!pipe->streaming_count);
+        media_entity_graph_walk_start(graph, entity);
-        while ((entity = media_entity_graph_walk_next(&graph))) {
+        while ((entity = media_entity_graph_walk_next(graph))) {
                entity->stream_count--;
                if (entity->stream_count == 0)
                        entity->pipe = NULL;
        }
+        if (!--pipe->streaming_count)
+                media_entity_graph_walk_cleanup(graph);
        mutex_unlock(&mdev->graph_mutex);
 }
 EXPORT_SYMBOL_GPL(media_entity_pipeline_stop);
@@ -368,44 +502,26 @@ EXPORT_SYMBOL_GPL(media_entity_pipeline_stop);
 * Module use count
 */
-/*
- * 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.
- */
 struct media_entity *media_entity_get(struct media_entity *entity)
 {
        if (entity == NULL)
                return NULL;
-        if (entity->parent->dev &&
+        if (entity->graph_obj.mdev->dev &&
-            !try_module_get(entity->parent->dev->driver->owner))
+            !try_module_get(entity->graph_obj.mdev->dev->driver->owner))
                return NULL;
        return entity;
 }
 EXPORT_SYMBOL_GPL(media_entity_get);
-/*
- * 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.
- */
 void media_entity_put(struct media_entity *entity)
 {
        if (entity == NULL)
                return;
-        if (entity->parent->dev)
+        if (entity->graph_obj.mdev->dev)
-                module_put(entity->parent->dev->driver->owner);
+                module_put(entity->graph_obj.mdev->dev->driver->owner);
 }
 EXPORT_SYMBOL_GPL(media_entity_put);
@@ -413,29 +529,52 @@ EXPORT_SYMBOL_GPL(media_entity_put);
 * Links management
 */
-static struct media_link *media_entity_add_link(struct media_entity *entity)
+static struct media_link *media_add_link(struct list_head *head)
 {
-        if (entity->num_links >= entity->max_links) {
+        struct media_link *link;
-                struct media_link *links = entity->links;
-                unsigned int max_links = entity->max_links + 2;
+        link = kzalloc(sizeof(*link), GFP_KERNEL);
-                unsigned int i;
+        if (link == NULL)
+                return NULL;
-                links = krealloc(links, max_links * sizeof(*links), GFP_KERNEL);
+        list_add_tail(&link->list, head);
-                if (links == NULL)
-                        return NULL;
-                for (i = 0; i < entity->num_links; i++)
+        return link;
-                        links[i].reverse->reverse = &links[i];
+}
-                entity->max_links = max_links;
+static void __media_entity_remove_link(struct media_entity *entity,
-                entity->links = links;
+                                       struct media_link *link)
-        }
+{
+        struct media_link *rlink, *tmp;
+        struct media_entity *remote;
+        if (link->source->entity == entity)
+                remote = link->sink->entity;
+        else
+                remote = link->source->entity;
-        return &entity->links[entity->num_links++];
+        list_for_each_entry_safe(rlink, tmp, &remote->links, list) {
+                if (rlink != link->reverse)
+                        continue;
+                if (link->source->entity == entity)
+                        remote->num_backlinks--;
+                /* Remove the remote link */
+                list_del(&rlink->list);
+                media_gobj_destroy(&rlink->graph_obj);
+                kfree(rlink);
+                if (--remote->num_links == 0)
+                        break;
+        }
+        list_del(&link->list);
+        media_gobj_destroy(&link->graph_obj);
+        kfree(link);
 }
 int
-media_entity_create_link(struct media_entity *source, u16 source_pad,
+media_create_pad_link(struct media_entity *source, u16 source_pad,
                         struct media_entity *sink, u16 sink_pad, u32 flags)
 {
        struct media_link *link;
@@ -445,68 +584,118 @@ media_entity_create_link(struct media_entity *source, u16 source_pad,
        BUG_ON(source_pad >= source->num_pads);
        BUG_ON(sink_pad >= sink->num_pads);
-        link = media_entity_add_link(source);
+        link = media_add_link(&source->links);
        if (link == NULL)
                return -ENOMEM;
        link->source = &source->pads[source_pad];
        link->sink = &sink->pads[sink_pad];
-        link->flags = flags;
+        link->flags = flags & ~MEDIA_LNK_FL_INTERFACE_LINK;
+        /* Initialize graph object embedded at the new link */
+        media_gobj_create(source->graph_obj.mdev, MEDIA_GRAPH_LINK,
+                        &link->graph_obj);
        /* Create the backlink. Backlinks are used to help graph traversal and
         * are not reported to userspace.
         */
-        backlink = media_entity_add_link(sink);
+        backlink = media_add_link(&sink->links);
        if (backlink == NULL) {
-                source->num_links--;
+                __media_entity_remove_link(source, link);
                return -ENOMEM;
        }
        backlink->source = &source->pads[source_pad];
        backlink->sink = &sink->pads[sink_pad];
        backlink->flags = flags;
+        backlink->is_backlink = true;
+        /* Initialize graph object embedded at the new link */
+        media_gobj_create(sink->graph_obj.mdev, MEDIA_GRAPH_LINK,
+                        &backlink->graph_obj);
        link->reverse = backlink;
        backlink->reverse = link;
        sink->num_backlinks++;
+        sink->num_links++;
+        source->num_links++;
        return 0;
 }
-EXPORT_SYMBOL_GPL(media_entity_create_link);
+EXPORT_SYMBOL_GPL(media_create_pad_link);
-void __media_entity_remove_links(struct media_entity *entity)
+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)
 {
-        unsigned int i;
+        struct media_entity *entity;
+        unsigned function;
-        for (i = 0; i < entity->num_links; i++) {
+        int ret;
-                struct media_link *link = &entity->links[i];
-                struct media_entity *remote;
-                unsigned int r = 0;
-                if (link->source->entity == entity)
-                        remote = link->sink->entity;
-                else
-                        remote = link->source->entity;
-                while (r < remote->num_links) {
-                        struct media_link *rlink = &remote->links[r];
-                        if (rlink != link->reverse) {
+        /* Trivial case: 1:1 relation */
-                                r++;
+        if (source && sink)
+                return media_create_pad_link(source, source_pad,
+                                             sink, sink_pad, flags);
+        /* Worse case scenario: n:n relation */
+        if (!source && !sink) {
+                if (!allow_both_undefined)
+                        return 0;
+                media_device_for_each_entity(source, mdev) {
+                        if (source->function != source_function)
                                continue;
+                        media_device_for_each_entity(sink, mdev) {
+                                if (sink->function != sink_function)
+                                        continue;
+                                ret = media_create_pad_link(source, source_pad,
+                                                            sink, sink_pad,
+                                                            flags);
+                                if (ret)
+                                        return ret;
+                                flags &= ~(MEDIA_LNK_FL_ENABLED |
+                                           MEDIA_LNK_FL_IMMUTABLE);
                        }
+                }
+                return 0;
+        }
-                        if (link->source->entity == entity)
+        /* Handle 1:n and n:1 cases */
-                                remote->num_backlinks--;
+        if (source)
+                function = sink_function;
+        else
+                function = source_function;
-                        if (--remote->num_links == 0)
+        media_device_for_each_entity(entity, mdev) {
-                                break;
+                if (entity->function != function)
+                        continue;
-                        /* Insert last entry in place of the dropped link. */
+                if (source)
-                        *rlink = remote->links[remote->num_links];
+                        ret = media_create_pad_link(source, source_pad,
-                }
+                                                    entity, sink_pad, flags);
+                else
+                        ret = media_create_pad_link(entity, source_pad,
+                                                    sink, sink_pad, flags);
+                if (ret)
+                        return ret;
+                flags &= ~(MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE);
        }
+        return 0;
+}
+EXPORT_SYMBOL_GPL(media_create_pad_links);
+void __media_entity_remove_links(struct media_entity *entity)
+{
+        struct media_link *link, *tmp;
+        list_for_each_entry_safe(link, tmp, &entity->links, list)
+                __media_entity_remove_link(entity, link);
        entity->num_links = 0;
        entity->num_backlinks = 0;
@@ -515,13 +704,15 @@ EXPORT_SYMBOL_GPL(__media_entity_remove_links);
 void media_entity_remove_links(struct media_entity *entity)
 {
+        struct media_device *mdev = entity->graph_obj.mdev;
        /* Do nothing if the entity is not registered. */
-        if (entity->parent == NULL)
+        if (mdev == NULL)
                return;
-        mutex_lock(&entity->parent->graph_mutex);
+        spin_lock(&mdev->lock);
        __media_entity_remove_links(entity);
-        mutex_unlock(&entity->parent->graph_mutex);
+        spin_unlock(&mdev->lock);
 }
 EXPORT_SYMBOL_GPL(media_entity_remove_links);
@@ -549,20 +740,6 @@ static int __media_entity_setup_link_notify(struct media_link *link, u32 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)
 {
        const u32 mask = MEDIA_LNK_FL_ENABLED;
@@ -590,7 +767,7 @@ int __media_entity_setup_link(struct media_link *link, u32 flags)
            (source->stream_count || sink->stream_count))
                return -EBUSY;
-        mdev = source->parent;
+        mdev = source->graph_obj.mdev;
        if (mdev->link_notify) {
                ret = mdev->link_notify(link, flags,
@@ -611,31 +788,20 @@ int media_entity_setup_link(struct media_link *link, u32 flags)
 {
        int ret;
-        mutex_lock(&link->source->entity->parent->graph_mutex);
+        mutex_lock(&link->graph_obj.mdev->graph_mutex);
        ret = __media_entity_setup_link(link, flags);
-        mutex_unlock(&link->source->entity->parent->graph_mutex);
+        mutex_unlock(&link->graph_obj.mdev->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];
+        list_for_each_entry(link, &source->entity->links, list) {
                if (link->source->entity == source->entity &&
                    link->source->index == source->index &&
                    link->sink->entity == sink->entity &&
@@ -647,23 +813,11 @@ media_entity_find_link(struct media_pad *source, struct media_pad *sink)
 }
 EXPORT_SYMBOL_GPL(media_entity_find_link);
-/**
- * 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.
- */
 struct media_pad *media_entity_remote_pad(struct media_pad *pad)
 {
-        unsigned int i;
+        struct media_link *link;
-        for (i = 0; i < pad->entity->num_links; i++) {
-                struct media_link *link = &pad->entity->links[i];
+        list_for_each_entry(link, &pad->entity->links, list) {
                if (!(link->flags & MEDIA_LNK_FL_ENABLED))
                        continue;
@@ -678,3 +832,113 @@ struct media_pad *media_entity_remote_pad(struct media_pad *pad)
 }
 EXPORT_SYMBOL_GPL(media_entity_remote_pad);
+static void media_interface_init(struct media_device *mdev,
+                                 struct media_interface *intf,
+                                 u32 gobj_type,
+                                 u32 intf_type, u32 flags)
+{
+        intf->type = intf_type;
+        intf->flags = flags;
+        INIT_LIST_HEAD(&intf->links);
+        media_gobj_create(mdev, gobj_type, &intf->graph_obj);
+}
+/* Functions related to the media interface via device nodes */
+struct media_intf_devnode *media_devnode_create(struct media_device *mdev,
+                                                u32 type, u32 flags,
+                                                u32 major, u32 minor)
+{
+        struct media_intf_devnode *devnode;
+        devnode = kzalloc(sizeof(*devnode), GFP_KERNEL);
+        if (!devnode)
+                return NULL;
+        devnode->major = major;
+        devnode->minor = minor;
+        media_interface_init(mdev, &devnode->intf, MEDIA_GRAPH_INTF_DEVNODE,
+                             type, flags);
+        return devnode;
+}
+EXPORT_SYMBOL_GPL(media_devnode_create);
+void media_devnode_remove(struct media_intf_devnode *devnode)
+{
+        media_remove_intf_links(&devnode->intf);
+        media_gobj_destroy(&devnode->intf.graph_obj);
+        kfree(devnode);
+}
+EXPORT_SYMBOL_GPL(media_devnode_remove);
+struct media_link *media_create_intf_link(struct media_entity *entity,
+                                            struct media_interface *intf,
+                                            u32 flags)
+{
+        struct media_link *link;
+        link = media_add_link(&intf->links);
+        if (link == NULL)
+                return NULL;
+        link->intf = intf;
+        link->entity = entity;
+        link->flags = flags | MEDIA_LNK_FL_INTERFACE_LINK;
+        /* Initialize graph object embedded at the new link */
+        media_gobj_create(intf->graph_obj.mdev, MEDIA_GRAPH_LINK,
+                        &link->graph_obj);
+        return link;
+}
+EXPORT_SYMBOL_GPL(media_create_intf_link);
+void __media_remove_intf_link(struct media_link *link)
+{
+        list_del(&link->list);
+        media_gobj_destroy(&link->graph_obj);
+        kfree(link);
+}
+EXPORT_SYMBOL_GPL(__media_remove_intf_link);
+void media_remove_intf_link(struct media_link *link)
+{
+        struct media_device *mdev = link->graph_obj.mdev;
+        /* Do nothing if the intf is not registered. */
+        if (mdev == NULL)
+                return;
+        spin_lock(&mdev->lock);
+        __media_remove_intf_link(link);
+        spin_unlock(&mdev->lock);
+}
+EXPORT_SYMBOL_GPL(media_remove_intf_link);
+void __media_remove_intf_links(struct media_interface *intf)
+{
+        struct media_link *link, *tmp;
+        list_for_each_entry_safe(link, tmp, &intf->links, list)
+                __media_remove_intf_link(link);
+}
+EXPORT_SYMBOL_GPL(__media_remove_intf_links);
+void media_remove_intf_links(struct media_interface *intf)
+{
+        struct media_device *mdev = intf->graph_obj.mdev;
+        /* Do nothing if the intf is not registered. */
+        if (mdev == NULL)
+                return;
+        spin_lock(&mdev->lock);
+        __media_remove_intf_links(intf);
+        spin_unlock(&mdev->lock);
+}
+EXPORT_SYMBOL_GPL(media_remove_intf_links);
diff --git a/drivers/media/pci/bt8xx/dst_ca.c b/drivers/media/pci/bt8xx/dst_ca.c
index c5cc14ef8347..da8b414fd824 100644
--- a/drivers/media/pci/bt8xx/dst_ca.c
+++ b/drivers/media/pci/bt8xx/dst_ca.c
@@ -705,7 +705,8 @@ struct dvb_device *dst_ca_attach(struct dst_state *dst, struct dvb_adapter *dvb_
        struct dvb_device *dvbdev;
        dprintk(verbose, DST_CA_ERROR, 1, "registering DST-CA device");
-        if (dvb_register_device(dvb_adapter, &dvbdev, &dvbdev_ca, dst, DVB_DEVICE_CA) == 0) {
+        if (dvb_register_device(dvb_adapter, &dvbdev, &dvbdev_ca, dst,
+                                DVB_DEVICE_CA, 0) == 0) {
                dst->dst_ca = dvbdev;
                return dst->dst_ca;
        }
diff --git a/drivers/media/pci/ddbridge/ddbridge-core.c b/drivers/media/pci/ddbridge/ddbridge-core.c
index fba5b40a869c..9d5b314142f1 100644
--- a/drivers/media/pci/ddbridge/ddbridge-core.c
+++ b/drivers/media/pci/ddbridge/ddbridge-core.c
@@ -1065,7 +1065,7 @@ static int ddb_ci_attach(struct ddb_port *port)
                            port->en, 0, 1);
        ret = dvb_register_device(&port->output->adap, &port->output->dev,
                                  &dvbdev_ci, (void *) port->output,
-                                  DVB_DEVICE_SEC);
+                                  DVB_DEVICE_SEC, 0);
        return ret;
 }
diff --git a/drivers/media/pci/ngene/ngene-core.c b/drivers/media/pci/ngene/ngene-core.c
index 1b92d836a564..4e924e2d1638 100644
--- a/drivers/media/pci/ngene/ngene-core.c
+++ b/drivers/media/pci/ngene/ngene-core.c
@@ -1513,7 +1513,7 @@ static int init_channel(struct ngene_channel *chan)
                set_transfer(&chan->dev->channel[2], 1);
                dvb_register_device(adapter, &chan->ci_dev,
                                    &ngene_dvbdev_ci, (void *) chan,
-                                    DVB_DEVICE_SEC);
+                                    DVB_DEVICE_SEC, 0);
                if (!chan->ci_dev)
                        goto err;
        }
diff --git a/drivers/media/pci/ttpci/av7110.c b/drivers/media/pci/ttpci/av7110.c
index 5e18b6796ed9..a69dc6a0752b 100644
--- a/drivers/media/pci/ttpci/av7110.c
+++ b/drivers/media/pci/ttpci/av7110.c
@@ -1358,7 +1358,7 @@ static int av7110_register(struct av7110 *av7110)
 #ifdef CONFIG_DVB_AV7110_OSD
        dvb_register_device(&av7110->dvb_adapter, &av7110->osd_dev,
-                            &dvbdev_osd, av7110, DVB_DEVICE_OSD);
+                            &dvbdev_osd, av7110, DVB_DEVICE_OSD, 0);
 #endif
        dvb_net_init(&av7110->dvb_adapter, &av7110->dvb_net, &dvbdemux->dmx);
diff --git a/drivers/media/pci/ttpci/av7110_av.c b/drivers/media/pci/ttpci/av7110_av.c
index 6fc748e22017..26c5696c193b 100644
--- a/drivers/media/pci/ttpci/av7110_av.c
+++ b/drivers/media/pci/ttpci/av7110_av.c
@@ -1594,10 +1594,10 @@ int av7110_av_register(struct av7110 *av7110)
        memset(&av7110->video_size, 0, sizeof (video_size_t));
        dvb_register_device(&av7110->dvb_adapter, &av7110->video_dev,
-                            &dvbdev_video, av7110, DVB_DEVICE_VIDEO);
+                            &dvbdev_video, av7110, DVB_DEVICE_VIDEO, 0);
        dvb_register_device(&av7110->dvb_adapter, &av7110->audio_dev,
-                            &dvbdev_audio, av7110, DVB_DEVICE_AUDIO);
+                            &dvbdev_audio, av7110, DVB_DEVICE_AUDIO, 0);
        return 0;
 }
diff --git a/drivers/media/pci/ttpci/av7110_ca.c b/drivers/media/pci/ttpci/av7110_ca.c
index bc4c65ffd4b9..96a130fb4595 100644
--- a/drivers/media/pci/ttpci/av7110_ca.c
+++ b/drivers/media/pci/ttpci/av7110_ca.c
@@ -378,7 +378,7 @@ static struct dvb_device dvbdev_ca = {
 int av7110_ca_register(struct av7110 *av7110)
 {
        return dvb_register_device(&av7110->dvb_adapter, &av7110->ca_dev,
-                                   &dvbdev_ca, av7110, DVB_DEVICE_CA);
+                                   &dvbdev_ca, av7110, DVB_DEVICE_CA, 0);
 }
 void av7110_ca_unregister(struct av7110 *av7110)
diff --git a/drivers/media/platform/exynos4-is/common.c b/drivers/media/platform/exynos4-is/common.c
index b6716c57b5db..b90f5bb15517 100644
--- a/drivers/media/platform/exynos4-is/common.c
+++ b/drivers/media/platform/exynos4-is/common.c
@@ -22,8 +22,7 @@ struct v4l2_subdev *fimc_find_remote_sensor(struct media_entity *entity)
        while (pad->flags & MEDIA_PAD_FL_SINK) {
                /* source pad */
                pad = media_entity_remote_pad(pad);
-                if (pad == NULL ||
+                if (!pad || !is_media_entity_v4l2_subdev(pad->entity))
-                    media_entity_type(pad->entity) != MEDIA_ENT_T_V4L2_SUBDEV)
                        break;
                sd = media_entity_to_v4l2_subdev(pad->entity);
diff --git a/drivers/media/platform/exynos4-is/fimc-capture.c b/drivers/media/platform/exynos4-is/fimc-capture.c
index 0d549a6c8a13..bf47d3b9cbe7 100644
--- a/drivers/media/platform/exynos4-is/fimc-capture.c
+++ b/drivers/media/platform/exynos4-is/fimc-capture.c
@@ -1136,8 +1136,7 @@ static int fimc_pipeline_validate(struct fimc_dev *fimc)
                        }
                }
-                if (src_pad == NULL ||
+                if (!src_pad || !is_media_entity_v4l2_subdev(src_pad->entity))
-                    media_entity_type(src_pad->entity) != MEDIA_ENT_T_V4L2_SUBDEV)
                        break;
                /* Don't call FIMC subdev operation to avoid nested locking */
@@ -1392,7 +1391,7 @@ static int fimc_link_setup(struct media_entity *entity,
        struct fimc_vid_cap *vc = &fimc->vid_cap;
        struct v4l2_subdev *sensor;
-        if (media_entity_type(remote->entity) != MEDIA_ENT_T_V4L2_SUBDEV)
+        if (!is_media_entity_v4l2_subdev(remote->entity))
                return -EINVAL;
        if (WARN_ON(fimc == NULL))
@@ -1800,7 +1799,7 @@ static int fimc_register_capture_device(struct fimc_dev *fimc,
        vid_cap->wb_fmt.code = fmt->mbus_code;
        vid_cap->vd_pad.flags = MEDIA_PAD_FL_SINK;
-        ret = media_entity_init(&vfd->entity, 1, &vid_cap->vd_pad, 0);
+        ret = media_entity_pads_init(&vfd->entity, 1, &vid_cap->vd_pad);
        if (ret)
                goto err_free_ctx;
@@ -1892,8 +1891,8 @@ int fimc_initialize_capture_subdev(struct fimc_dev *fimc)
        fimc->vid_cap.sd_pads[FIMC_SD_PAD_SINK_CAM].flags = MEDIA_PAD_FL_SINK;
        fimc->vid_cap.sd_pads[FIMC_SD_PAD_SINK_FIFO].flags = MEDIA_PAD_FL_SINK;
        fimc->vid_cap.sd_pads[FIMC_SD_PAD_SOURCE].flags = MEDIA_PAD_FL_SOURCE;
-        ret = media_entity_init(&sd->entity, FIMC_SD_PADS_NUM,
+        ret = media_entity_pads_init(&sd->entity, FIMC_SD_PADS_NUM,
-                                fimc->vid_cap.sd_pads, 0);
+                                fimc->vid_cap.sd_pads);
        if (ret)
                return ret;
diff --git a/drivers/media/platform/exynos4-is/fimc-isp-video.c b/drivers/media/platform/exynos4-is/fimc-isp-video.c
index 0dd22ec66694..bf9261eb57a1 100644
--- a/drivers/media/platform/exynos4-is/fimc-isp-video.c
+++ b/drivers/media/platform/exynos4-is/fimc-isp-video.c
@@ -287,7 +287,7 @@ static int isp_video_open(struct file *file)
                goto rel_fh;
        if (v4l2_fh_is_singular_file(file)) {
-                mutex_lock(&me->parent->graph_mutex);
+                mutex_lock(&me->graph_obj.mdev->graph_mutex);
                ret = fimc_pipeline_call(ve, open, me, true);
@@ -295,7 +295,7 @@ static int isp_video_open(struct file *file)
                if (ret == 0)
                        me->use_count++;
-                mutex_unlock(&me->parent->graph_mutex);
+                mutex_unlock(&me->graph_obj.mdev->graph_mutex);
        }
        if (!ret)
                goto unlock;
@@ -311,7 +311,7 @@ static int isp_video_release(struct file *file)
        struct fimc_isp *isp = video_drvdata(file);
        struct fimc_is_video *ivc = &isp->video_capture;
        struct media_entity *entity = &ivc->ve.vdev.entity;
-        struct media_device *mdev = entity->parent;
+        struct media_device *mdev = entity->graph_obj.mdev;
        mutex_lock(&isp->video_lock);
@@ -466,8 +466,7 @@ static int isp_video_pipeline_validate(struct fimc_isp *isp)
                /* Retrieve format at the source pad */
                pad = media_entity_remote_pad(pad);
-                if (pad == NULL ||
+                if (!pad || !is_media_entity_v4l2_subdev(pad->entity))
-                    media_entity_type(pad->entity) != MEDIA_ENT_T_V4L2_SUBDEV)
                        break;
                sd = media_entity_to_v4l2_subdev(pad->entity);
@@ -617,7 +616,7 @@ int fimc_isp_video_device_register(struct fimc_isp *isp,
        vdev->lock = &isp->video_lock;
        iv->pad.flags = MEDIA_PAD_FL_SINK;
-        ret = media_entity_init(&vdev->entity, 1, &iv->pad, 0);
+        ret = media_entity_pads_init(&vdev->entity, 1, &iv->pad);
        if (ret < 0)
                return ret;
diff --git a/drivers/media/platform/exynos4-is/fimc-isp.c b/drivers/media/platform/exynos4-is/fimc-isp.c
index 5d78f5716f3b..293b807020c4 100644
--- a/drivers/media/platform/exynos4-is/fimc-isp.c
+++ b/drivers/media/platform/exynos4-is/fimc-isp.c
@@ -708,8 +708,8 @@ int fimc_isp_subdev_create(struct fimc_isp *isp)
        isp->subdev_pads[FIMC_ISP_SD_PAD_SINK].flags = MEDIA_PAD_FL_SINK;
        isp->subdev_pads[FIMC_ISP_SD_PAD_SRC_FIFO].flags = MEDIA_PAD_FL_SOURCE;
        isp->subdev_pads[FIMC_ISP_SD_PAD_SRC_DMA].flags = MEDIA_PAD_FL_SOURCE;
-        ret = media_entity_init(&sd->entity, FIMC_ISP_SD_PADS_NUM,
+        ret = media_entity_pads_init(&sd->entity, FIMC_ISP_SD_PADS_NUM,
-                                isp->subdev_pads, 0);
+                                isp->subdev_pads);
        if (ret)
                return ret;
diff --git a/drivers/media/platform/exynos4-is/fimc-lite.c b/drivers/media/platform/exynos4-is/fimc-lite.c
index 639ee710499e..e85649147dc8 100644
--- a/drivers/media/platform/exynos4-is/fimc-lite.c
+++ b/drivers/media/platform/exynos4-is/fimc-lite.c
@@ -494,7 +494,7 @@ static int fimc_lite_open(struct file *file)
            atomic_read(&fimc->out_path) != FIMC_IO_DMA)
                goto unlock;
-        mutex_lock(&me->parent->graph_mutex);
+        mutex_lock(&me->graph_obj.mdev->graph_mutex);
        ret = fimc_pipeline_call(&fimc->ve, open, me, true);
@@ -502,7 +502,7 @@ static int fimc_lite_open(struct file *file)
        if (ret == 0)
                me->use_count++;
-        mutex_unlock(&me->parent->graph_mutex);
+        mutex_unlock(&me->graph_obj.mdev->graph_mutex);
        if (!ret) {
                fimc_lite_clear_event_counters(fimc);
@@ -535,9 +535,9 @@ static int fimc_lite_release(struct file *file)
                fimc_pipeline_call(&fimc->ve, close);
                clear_bit(ST_FLITE_IN_USE, &fimc->state);
-                mutex_lock(&entity->parent->graph_mutex);
+                mutex_lock(&entity->graph_obj.mdev->graph_mutex);
                entity->use_count--;
-                mutex_unlock(&entity->parent->graph_mutex);
+                mutex_unlock(&entity->graph_obj.mdev->graph_mutex);
        }
        _vb2_fop_release(file, NULL);
@@ -808,8 +808,7 @@ static int fimc_pipeline_validate(struct fimc_lite *fimc)
                }
                /* Retrieve format at the source pad */
                pad = media_entity_remote_pad(pad);
-                if (pad == NULL ||
+                if (!pad || !is_media_entity_v4l2_subdev(pad->entity))
-                    media_entity_type(pad->entity) != MEDIA_ENT_T_V4L2_SUBDEV)
                        break;
                sd = media_entity_to_v4l2_subdev(pad->entity);
@@ -982,7 +981,6 @@ static int fimc_lite_link_setup(struct media_entity *entity,
 {
        struct v4l2_subdev *sd = media_entity_to_v4l2_subdev(entity);
        struct fimc_lite *fimc = v4l2_get_subdevdata(sd);
-        unsigned int remote_ent_type = media_entity_type(remote->entity);
        int ret = 0;
        if (WARN_ON(fimc == NULL))
@@ -994,7 +992,7 @@ static int fimc_lite_link_setup(struct media_entity *entity,
        switch (local->index) {
        case FLITE_SD_PAD_SINK:
-                if (remote_ent_type != MEDIA_ENT_T_V4L2_SUBDEV) {
+                if (!is_media_entity_v4l2_subdev(remote->entity)) {
                        ret = -EINVAL;
                        break;
                }
@@ -1012,7 +1010,7 @@ static int fimc_lite_link_setup(struct media_entity *entity,
        case FLITE_SD_PAD_SOURCE_DMA:
                if (!(flags & MEDIA_LNK_FL_ENABLED))
                        atomic_set(&fimc->out_path, FIMC_IO_NONE);
-                else if (remote_ent_type == MEDIA_ENT_T_DEVNODE)
+                else if (is_media_entity_v4l2_io(remote->entity))
                        atomic_set(&fimc->out_path, FIMC_IO_DMA);
                else
                        ret = -EINVAL;
@@ -1021,7 +1019,7 @@ static int fimc_lite_link_setup(struct media_entity *entity,
        case FLITE_SD_PAD_SOURCE_ISP:
                if (!(flags & MEDIA_LNK_FL_ENABLED))
                        atomic_set(&fimc->out_path, FIMC_IO_NONE);
-                else if (remote_ent_type == MEDIA_ENT_T_V4L2_SUBDEV)
+                else if (is_media_entity_v4l2_subdev(remote->entity))
                        atomic_set(&fimc->out_path, FIMC_IO_ISP);
                else
                        ret = -EINVAL;
@@ -1316,7 +1314,7 @@ static int fimc_lite_subdev_registered(struct v4l2_subdev *sd)
                return ret;
        fimc->vd_pad.flags = MEDIA_PAD_FL_SINK;
-        ret = media_entity_init(&vfd->entity, 1, &fimc->vd_pad, 0);
+        ret = media_entity_pads_init(&vfd->entity, 1, &fimc->vd_pad);
        if (ret < 0)
                return ret;
@@ -1430,8 +1428,8 @@ static int fimc_lite_create_capture_subdev(struct fimc_lite *fimc)
        fimc->subdev_pads[FLITE_SD_PAD_SINK].flags = MEDIA_PAD_FL_SINK;
        fimc->subdev_pads[FLITE_SD_PAD_SOURCE_DMA].flags = MEDIA_PAD_FL_SOURCE;
        fimc->subdev_pads[FLITE_SD_PAD_SOURCE_ISP].flags = MEDIA_PAD_FL_SOURCE;
-        ret = media_entity_init(&sd->entity, FLITE_SD_PADS_NUM,
+        ret = media_entity_pads_init(&sd->entity, FLITE_SD_PADS_NUM,
-                                fimc->subdev_pads, 0);
+                                fimc->subdev_pads);
        if (ret)
                return ret;
diff --git a/drivers/media/platform/exynos4-is/fimc-m2m.c b/drivers/media/platform/exynos4-is/fimc-m2m.c
index 5aa857c7b631..55ec4c99d484 100644
--- a/drivers/media/platform/exynos4-is/fimc-m2m.c
+++ b/drivers/media/platform/exynos4-is/fimc-m2m.c
@@ -739,7 +739,7 @@ int fimc_register_m2m_device(struct fimc_dev *fimc,
                return PTR_ERR(fimc->m2m.m2m_dev);
        }
-        ret = media_entity_init(&vfd->entity, 0, NULL, 0);
+        ret = media_entity_pads_init(&vfd->entity, 0, NULL);
        if (ret)
                goto err_me;
diff --git a/drivers/media/platform/exynos4-is/media-dev.c b/drivers/media/platform/exynos4-is/media-dev.c
index 9481ce3201a2..f3b2dd30ec77 100644
--- a/drivers/media/platform/exynos4-is/media-dev.c
+++ b/drivers/media/platform/exynos4-is/media-dev.c
@@ -88,8 +88,7 @@ static void fimc_pipeline_prepare(struct fimc_pipeline *p,
                                break;
                }
-                if (pad == NULL ||
+                if (!pad || !is_media_entity_v4l2_subdev(pad->entity))
-                    media_entity_type(pad->entity) != MEDIA_ENT_T_V4L2_SUBDEV)
                        break;
                sd = media_entity_to_v4l2_subdev(pad->entity);
@@ -729,7 +728,7 @@ static int __fimc_md_create_fimc_sink_links(struct fimc_md *fmd,
                flags = ((1 << i) & link_mask) ? MEDIA_LNK_FL_ENABLED : 0;
                sink = &fmd->fimc[i]->vid_cap.subdev.entity;
-                ret = media_entity_create_link(source, pad, sink,
+                ret = media_create_pad_link(source, pad, sink,
                                              FIMC_SD_PAD_SINK_CAM, flags);
                if (ret)
                        return ret;
@@ -749,7 +748,7 @@ static int __fimc_md_create_fimc_sink_links(struct fimc_md *fmd,
                        continue;
                sink = &fmd->fimc_lite[i]->subdev.entity;
-                ret = media_entity_create_link(source, pad, sink,
+                ret = media_create_pad_link(source, pad, sink,
                                               FLITE_SD_PAD_SINK, 0);
                if (ret)
                        return ret;
@@ -781,13 +780,13 @@ static int __fimc_md_create_flite_source_links(struct fimc_md *fmd)
                source = &fimc->subdev.entity;
                sink = &fimc->ve.vdev.entity;
                /* FIMC-LITE's subdev and video node */
-                ret = media_entity_create_link(source, FLITE_SD_PAD_SOURCE_DMA,
+                ret = media_create_pad_link(source, FLITE_SD_PAD_SOURCE_DMA,
                                               sink, 0, 0);
                if (ret)
                        break;
                /* Link from FIMC-LITE to IS-ISP subdev */
                sink = &fmd->fimc_is->isp.subdev.entity;
-                ret = media_entity_create_link(source, FLITE_SD_PAD_SOURCE_ISP,
+                ret = media_create_pad_link(source, FLITE_SD_PAD_SOURCE_ISP,
                                               sink, 0, 0);
                if (ret)
                        break;
@@ -811,7 +810,7 @@ static int __fimc_md_create_fimc_is_links(struct fimc_md *fmd)
                /* Link from FIMC-IS-ISP subdev to FIMC */
                sink = &fmd->fimc[i]->vid_cap.subdev.entity;
-                ret = media_entity_create_link(source, FIMC_ISP_SD_PAD_SRC_FIFO,
+                ret = media_create_pad_link(source, FIMC_ISP_SD_PAD_SRC_FIFO,
                                               sink, FIMC_SD_PAD_SINK_FIFO, 0);
                if (ret)
                        return ret;
@@ -824,7 +823,7 @@ static int __fimc_md_create_fimc_is_links(struct fimc_md *fmd)
        if (sink->num_pads == 0)
                return 0;
-        return media_entity_create_link(source, FIMC_ISP_SD_PAD_SRC_DMA,
+        return media_create_pad_link(source, FIMC_ISP_SD_PAD_SRC_DMA,
                                        sink, 0, 0);
 }
@@ -873,7 +872,7 @@ static int fimc_md_create_links(struct fimc_md *fmd)
                                return -EINVAL;
                        pad = sensor->entity.num_pads - 1;
-                        ret = media_entity_create_link(&sensor->entity, pad,
+                        ret = media_create_pad_link(&sensor->entity, pad,
                                              &csis->entity, CSIS_PAD_SINK,
                                              MEDIA_LNK_FL_IMMUTABLE |
                                              MEDIA_LNK_FL_ENABLED);
@@ -927,7 +926,7 @@ static int fimc_md_create_links(struct fimc_md *fmd)
                source = &fmd->fimc[i]->vid_cap.subdev.entity;
                sink = &fmd->fimc[i]->vid_cap.ve.vdev.entity;
-                ret = media_entity_create_link(source, FIMC_SD_PAD_SOURCE,
+                ret = media_create_pad_link(source, FIMC_SD_PAD_SOURCE,
                                              sink, 0, flags);
                if (ret)
                        break;
@@ -1046,11 +1045,11 @@ static int __fimc_md_modify_pipeline(struct media_entity *entity, bool enable)
        return ret;
 }
-/* Locking: called with entity->parent->graph_mutex mutex held. */
+/* Locking: called with entity->graph_obj.mdev->graph_mutex mutex held. */
-static int __fimc_md_modify_pipelines(struct media_entity *entity, bool enable)
+static int __fimc_md_modify_pipelines(struct media_entity *entity, bool enable,
+                                      struct media_entity_graph *graph)
 {
        struct media_entity *entity_err = entity;
-        struct media_entity_graph graph;
        int ret;
        /*
@@ -1059,10 +1058,10 @@ static int __fimc_md_modify_pipelines(struct media_entity *entity, bool enable)
         * through active links. This is needed as we cannot power on/off the
         * subdevs in random order.
         */
-        media_entity_graph_walk_start(&graph, entity);
+        media_entity_graph_walk_start(graph, entity);
-        while ((entity = media_entity_graph_walk_next(&graph))) {
+        while ((entity = media_entity_graph_walk_next(graph))) {
-                if (media_entity_type(entity) != MEDIA_ENT_T_DEVNODE)
+                if (!is_media_entity_v4l2_io(entity))
                        continue;
                ret  = __fimc_md_modify_pipeline(entity, enable);
@@ -1072,11 +1071,12 @@ static int __fimc_md_modify_pipelines(struct media_entity *entity, bool enable)
        }
        return 0;
- err:
-        media_entity_graph_walk_start(&graph, entity_err);
-        while ((entity_err = media_entity_graph_walk_next(&graph))) {
+err:
-                if (media_entity_type(entity_err) != MEDIA_ENT_T_DEVNODE)
+        media_entity_graph_walk_start(graph, entity_err);
+        while ((entity_err = media_entity_graph_walk_next(graph))) {
+                if (!is_media_entity_v4l2_io(entity_err))
                        continue;
                __fimc_md_modify_pipeline(entity_err, !enable);
@@ -1091,21 +1091,29 @@ static int __fimc_md_modify_pipelines(struct media_entity *entity, bool enable)
 static int fimc_md_link_notify(struct media_link *link, unsigned int flags,
                                unsigned int notification)
 {
+        struct media_entity_graph *graph =
+                &container_of(link->graph_obj.mdev, struct fimc_md,
+                              media_dev)->link_setup_graph;
        struct media_entity *sink = link->sink->entity;
        int ret = 0;
        /* Before link disconnection */
        if (notification == MEDIA_DEV_NOTIFY_PRE_LINK_CH) {
+                ret = media_entity_graph_walk_init(graph,
+                                                   link->graph_obj.mdev);
+                if (ret)
+                        return ret;
                if (!(flags & MEDIA_LNK_FL_ENABLED))
-                        ret = __fimc_md_modify_pipelines(sink, false);
+                        ret = __fimc_md_modify_pipelines(sink, false, graph);
 #if 0
                else
                        /* TODO: Link state change validation */
 #endif
        /* After link activation */
-        } else if (notification == MEDIA_DEV_NOTIFY_POST_LINK_CH &&
+        } else if (notification == MEDIA_DEV_NOTIFY_POST_LINK_CH) {
-                   (link->flags & MEDIA_LNK_FL_ENABLED)) {
+                if (link->flags & MEDIA_LNK_FL_ENABLED)
-                ret = __fimc_md_modify_pipelines(sink, true);
+                        ret = __fimc_md_modify_pipelines(sink, true, graph);
+                media_entity_graph_walk_cleanup(graph);
        }
        return ret ? -EPIPE : 0;
@@ -1314,7 +1322,10 @@ static int subdev_notifier_complete(struct v4l2_async_notifier *notifier)
        ret = v4l2_device_register_subdev_nodes(&fmd->v4l2_dev);
 unlock:
        mutex_unlock(&fmd->media_dev.graph_mutex);
-        return ret;
+        if (ret < 0)
+                return ret;
+        return media_device_register(&fmd->media_dev);
 }
 static int fimc_md_probe(struct platform_device *pdev)
@@ -1345,18 +1356,14 @@ static int fimc_md_probe(struct platform_device *pdev)
        fmd->use_isp = fimc_md_is_isp_available(dev->of_node);
        fmd->user_subdev_api = true;
+        media_device_init(&fmd->media_dev);
        ret = v4l2_device_register(dev, &fmd->v4l2_dev);
        if (ret < 0) {
                v4l2_err(v4l2_dev, "Failed to register v4l2_device: %d\n", ret);
                return ret;
        }
-        ret = media_device_register(&fmd->media_dev);
-        if (ret < 0) {
-                v4l2_err(v4l2_dev, "Failed to register media device: %d\n", ret);
-                goto err_v4l2_dev;
-        }
        ret = fimc_md_get_clocks(fmd);
        if (ret)
                goto err_md;
@@ -1425,8 +1432,7 @@ err_clk:
 err_m_ent:
        fimc_md_unregister_entities(fmd);
 err_md:
-        media_device_unregister(&fmd->media_dev);
+        media_device_cleanup(&fmd->media_dev);
-err_v4l2_dev:
        v4l2_device_unregister(&fmd->v4l2_dev);
        return ret;
 }
@@ -1446,6 +1452,7 @@ static int fimc_md_remove(struct platform_device *pdev)
        fimc_md_unregister_entities(fmd);
        fimc_md_pipelines_free(fmd);
        media_device_unregister(&fmd->media_dev);
+        media_device_cleanup(&fmd->media_dev);
        fimc_md_put_clocks(fmd);
        return 0;
diff --git a/drivers/media/platform/exynos4-is/media-dev.h b/drivers/media/platform/exynos4-is/media-dev.h
index 93a96126929b..ed122cb2dd74 100644
--- a/drivers/media/platform/exynos4-is/media-dev.h
+++ b/drivers/media/platform/exynos4-is/media-dev.h
@@ -154,6 +154,7 @@ struct fimc_md {
        bool user_subdev_api;
        spinlock_t slock;
        struct list_head pipelines;
+        struct media_entity_graph link_setup_graph;
 };
 static inline
@@ -164,8 +165,8 @@ struct fimc_sensor_info *source_to_sensor_info(struct fimc_source_info *si)
 static inline struct fimc_md *entity_to_fimc_mdev(struct media_entity *me)
 {
-        return me->parent == NULL ? NULL :
+        return me->graph_obj.mdev == NULL ? NULL :
-                container_of(me->parent, struct fimc_md, media_dev);
+                container_of(me->graph_obj.mdev, struct fimc_md, media_dev);
 }
 static inline struct fimc_md *notifier_to_fimc_md(struct v4l2_async_notifier *n)
@@ -175,12 +176,12 @@ static inline struct fimc_md *notifier_to_fimc_md(struct v4l2_async_notifier *n)
 static inline void fimc_md_graph_lock(struct exynos_video_entity *ve)
 {
-        mutex_lock(&ve->vdev.entity.parent->graph_mutex);
+        mutex_lock(&ve->vdev.entity.graph_obj.mdev->graph_mutex);
 }
 static inline void fimc_md_graph_unlock(struct exynos_video_entity *ve)
 {
-        mutex_unlock(&ve->vdev.entity.parent->graph_mutex);
+        mutex_unlock(&ve->vdev.entity.graph_obj.mdev->graph_mutex);
 }
 int fimc_md_set_camclk(struct v4l2_subdev *sd, bool on);
diff --git a/drivers/media/platform/exynos4-is/mipi-csis.c b/drivers/media/platform/exynos4-is/mipi-csis.c
index ff5dabf24694..ac5e50e595be 100644
--- a/drivers/media/platform/exynos4-is/mipi-csis.c
+++ b/drivers/media/platform/exynos4-is/mipi-csis.c
@@ -866,8 +866,8 @@ static int s5pcsis_probe(struct platform_device *pdev)
        state->pads[CSIS_PAD_SINK].flags = MEDIA_PAD_FL_SINK;
        state->pads[CSIS_PAD_SOURCE].flags = MEDIA_PAD_FL_SOURCE;
-        ret = media_entity_init(&state->sd.entity,
+        ret = media_entity_pads_init(&state->sd.entity,
-                                CSIS_PADS_NUM, state->pads, 0);
+                                CSIS_PADS_NUM, state->pads);
        if (ret < 0)
                goto e_clkdis;
diff --git a/drivers/media/platform/omap3isp/isp.c b/drivers/media/platform/omap3isp/isp.c
index 56e683b19a73..0bcfa553c1aa 100644
--- a/drivers/media/platform/omap3isp/isp.c
+++ b/drivers/media/platform/omap3isp/isp.c
@@ -683,15 +683,15 @@ static irqreturn_t isp_isr(int irq, void *_isp)
 *
 * Return the total number of users of all video device nodes in the pipeline.
 */
-static int isp_pipeline_pm_use_count(struct media_entity *entity)
+static int isp_pipeline_pm_use_count(struct media_entity *entity,
+        struct media_entity_graph *graph)
 {
-        struct media_entity_graph graph;
        int use = 0;
-        media_entity_graph_walk_start(&graph, entity);
+        media_entity_graph_walk_start(graph, entity);
-        while ((entity = media_entity_graph_walk_next(&graph))) {
+        while ((entity = media_entity_graph_walk_next(graph))) {
-                if (media_entity_type(entity) == MEDIA_ENT_T_DEVNODE)
+                if (is_media_entity_v4l2_io(entity))
                        use += entity->use_count;
        }
@@ -714,7 +714,7 @@ static int isp_pipeline_pm_power_one(struct media_entity *entity, int change)
        struct v4l2_subdev *subdev;
        int ret;
-        subdev = media_entity_type(entity) == MEDIA_ENT_T_V4L2_SUBDEV
+        subdev = is_media_entity_v4l2_subdev(entity)
               ? media_entity_to_v4l2_subdev(entity) : NULL;
        if (entity->use_count == 0 && change > 0 && subdev != NULL) {
@@ -742,29 +742,29 @@ static int isp_pipeline_pm_power_one(struct media_entity *entity, int change)
 *
 * Return 0 on success or a negative error code on failure.
 */
-static int isp_pipeline_pm_power(struct media_entity *entity, int change)
+static int isp_pipeline_pm_power(struct media_entity *entity, int change,
+        struct media_entity_graph *graph)
 {
-        struct media_entity_graph graph;
        struct media_entity *first = entity;
        int ret = 0;
        if (!change)
                return 0;
-        media_entity_graph_walk_start(&graph, entity);
+        media_entity_graph_walk_start(graph, entity);
-        while (!ret && (entity = media_entity_graph_walk_next(&graph)))
+        while (!ret && (entity = media_entity_graph_walk_next(graph)))
-                if (media_entity_type(entity) != MEDIA_ENT_T_DEVNODE)
+                if (is_media_entity_v4l2_subdev(entity))
                        ret = isp_pipeline_pm_power_one(entity, change);
        if (!ret)
-                return 0;
+                return ret;
-        media_entity_graph_walk_start(&graph, first);
+        media_entity_graph_walk_start(graph, first);
-        while ((first = media_entity_graph_walk_next(&graph))
+        while ((first = media_entity_graph_walk_next(graph))
               && first != entity)
-                if (media_entity_type(first) != MEDIA_ENT_T_DEVNODE)
+                if (is_media_entity_v4l2_subdev(first))
                        isp_pipeline_pm_power_one(first, -change);
        return ret;
@@ -782,23 +782,24 @@ static int isp_pipeline_pm_power(struct media_entity *entity, int change)
 * off is assumed to never fail. No failure can occur when the use parameter is
 * set to 0.
 */
-int omap3isp_pipeline_pm_use(struct media_entity *entity, int use)
+int omap3isp_pipeline_pm_use(struct media_entity *entity, int use,
+                             struct media_entity_graph *graph)
 {
        int change = use ? 1 : -1;
        int ret;
-        mutex_lock(&entity->parent->graph_mutex);
+        mutex_lock(&entity->graph_obj.mdev->graph_mutex);
        /* Apply use count to node. */
        entity->use_count += change;
        WARN_ON(entity->use_count < 0);
        /* Apply power change to connected non-nodes. */
-        ret = isp_pipeline_pm_power(entity, change);
+        ret = isp_pipeline_pm_power(entity, change, graph);
        if (ret < 0)
                entity->use_count -= change;
-        mutex_unlock(&entity->parent->graph_mutex);
+        mutex_unlock(&entity->graph_obj.mdev->graph_mutex);
        return ret;
 }
@@ -820,35 +821,49 @@ int omap3isp_pipeline_pm_use(struct media_entity *entity, int use)
 static int isp_pipeline_link_notify(struct media_link *link, u32 flags,
                                    unsigned int notification)
 {
+        struct media_entity_graph *graph =
+                &container_of(link->graph_obj.mdev, struct isp_device,
+                              media_dev)->pm_count_graph;
        struct media_entity *source = link->source->entity;
        struct media_entity *sink = link->sink->entity;
-        int source_use = isp_pipeline_pm_use_count(source);
+        int source_use;
-        int sink_use = isp_pipeline_pm_use_count(sink);
+        int sink_use;
-        int ret;
+        int ret = 0;
+        if (notification == MEDIA_DEV_NOTIFY_PRE_LINK_CH) {
+                ret = media_entity_graph_walk_init(graph,
+                                                   link->graph_obj.mdev);
+                if (ret)
+                        return ret;
+        }
+        source_use = isp_pipeline_pm_use_count(source, graph);
+        sink_use = isp_pipeline_pm_use_count(sink, graph);
        if (notification == MEDIA_DEV_NOTIFY_POST_LINK_CH &&
            !(flags & MEDIA_LNK_FL_ENABLED)) {
                /* Powering off entities is assumed to never fail. */
-                isp_pipeline_pm_power(source, -sink_use);
+                isp_pipeline_pm_power(source, -sink_use, graph);
-                isp_pipeline_pm_power(sink, -source_use);
+                isp_pipeline_pm_power(sink, -source_use, graph);
                return 0;
        }
        if (notification == MEDIA_DEV_NOTIFY_PRE_LINK_CH &&
                (flags & MEDIA_LNK_FL_ENABLED)) {
-                ret = isp_pipeline_pm_power(source, sink_use);
+                ret = isp_pipeline_pm_power(source, sink_use, graph);
                if (ret < 0)
                        return ret;
-                ret = isp_pipeline_pm_power(sink, source_use);
+                ret = isp_pipeline_pm_power(sink, source_use, graph);
                if (ret < 0)
-                        isp_pipeline_pm_power(source, -sink_use);
+                        isp_pipeline_pm_power(source, -sink_use, graph);
-                return ret;
        }
-        return 0;
+        if (notification == MEDIA_DEV_NOTIFY_POST_LINK_CH)
+                media_entity_graph_walk_cleanup(graph);
+        return ret;
 }
 /* -----------------------------------------------------------------------------
@@ -881,7 +896,7 @@ static int isp_pipeline_enable(struct isp_pipeline *pipe,
         * starting entities if the pipeline won't start anyway (those entities
         * would then likely fail to stop, making the problem worse).
         */
-        if (pipe->entities & isp->crashed)
+        if (media_entity_enum_intersects(&pipe->ent_enum, &isp->crashed))
                return -EIO;
        spin_lock_irqsave(&pipe->lock, flags);
@@ -897,8 +912,7 @@ static int isp_pipeline_enable(struct isp_pipeline *pipe,
                        break;
                pad = media_entity_remote_pad(pad);
-                if (pad == NULL ||
+                if (!pad || !is_media_entity_v4l2_subdev(pad->entity))
-                    media_entity_type(pad->entity) != MEDIA_ENT_T_V4L2_SUBDEV)
                        break;
                entity = pad->entity;
@@ -987,8 +1001,7 @@ static int isp_pipeline_disable(struct isp_pipeline *pipe)
                        break;
                pad = media_entity_remote_pad(pad);
-                if (pad == NULL ||
+                if (!pad || !is_media_entity_v4l2_subdev(pad->entity))
-                    media_entity_type(pad->entity) != MEDIA_ENT_T_V4L2_SUBDEV)
                        break;
                entity = pad->entity;
@@ -1028,7 +1041,8 @@ static int isp_pipeline_disable(struct isp_pipeline *pipe)
                        dev_info(isp->dev, "Unable to stop %s\n", subdev->name);
                        isp->stop_failure = true;
                        if (subdev == &isp->isp_prev.subdev)
-                                isp->crashed |= 1U << subdev->entity.id;
+                                media_entity_enum_set(&isp->crashed,
+                                                      &subdev->entity);
                        failure = -ETIMEDOUT;
                }
        }
@@ -1234,7 +1248,7 @@ static int isp_reset(struct isp_device *isp)
        }
        isp->stop_failure = false;
-        isp->crashed = 0;
+        media_entity_enum_zero(&isp->crashed);
        return 0;
 }
@@ -1645,7 +1659,8 @@ static void __omap3isp_put(struct isp_device *isp, bool save_ctx)
                /* Reset the ISP if an entity has failed to stop. This is the
                 * only way to recover from such conditions.
                 */
-                if (isp->crashed || isp->stop_failure)
+                if (!media_entity_enum_empty(&isp->crashed) ||
+                    isp->stop_failure)
                        isp_reset(isp);
                isp_disable_clocks(isp);
        }
@@ -1792,6 +1807,7 @@ static void isp_unregister_entities(struct isp_device *isp)
        v4l2_device_unregister(&isp->v4l2_dev);
        media_device_unregister(&isp->media_dev);
+        media_device_cleanup(&isp->media_dev);
 }
 static int isp_link_entity(
@@ -1862,7 +1878,7 @@ static int isp_link_entity(
                return -EINVAL;
        }
-        return media_entity_create_link(entity, i, input, pad, flags);
+        return media_create_pad_link(entity, i, input, pad, flags);
 }
 static int isp_register_entities(struct isp_device *isp)
@@ -1874,12 +1890,7 @@ static int isp_register_entities(struct isp_device *isp)
                sizeof(isp->media_dev.model));
        isp->media_dev.hw_revision = isp->revision;
        isp->media_dev.link_notify = isp_pipeline_link_notify;
-        ret = media_device_register(&isp->media_dev);
+        media_device_init(&isp->media_dev);
-        if (ret < 0) {
-                dev_err(isp->dev, "%s: Media device registration failed (%d)\n",
-                        __func__, ret);
-                return ret;
-        }
        isp->v4l2_dev.mdev = &isp->media_dev;
        ret = v4l2_device_register(isp->dev, &isp->v4l2_dev);
@@ -1930,6 +1941,118 @@ done:
        return ret;
 }
+/*
+ * isp_create_links() - Create links for internal and external ISP entities
+ * @isp : Pointer to ISP device
+ *
+ * This function creates all links between ISP internal and external entities.
+ *
+ * Return: A negative error code on failure or zero on success. Possible error
+ * codes are those returned by media_create_pad_link().
+ */
+static int isp_create_links(struct isp_device *isp)
+{
+        int ret;
+        /* Create links between entities and video nodes. */
+        ret = media_create_pad_link(
+                        &isp->isp_csi2a.subdev.entity, CSI2_PAD_SOURCE,
+                        &isp->isp_csi2a.video_out.video.entity, 0, 0);
+        if (ret < 0)
+                return ret;
+        ret = media_create_pad_link(
+                        &isp->isp_ccp2.video_in.video.entity, 0,
+                        &isp->isp_ccp2.subdev.entity, CCP2_PAD_SINK, 0);
+        if (ret < 0)
+                return ret;
+        ret = media_create_pad_link(
+                        &isp->isp_ccdc.subdev.entity, CCDC_PAD_SOURCE_OF,
+                        &isp->isp_ccdc.video_out.video.entity, 0, 0);
+        if (ret < 0)
+                return ret;
+        ret = media_create_pad_link(
+                        &isp->isp_prev.video_in.video.entity, 0,
+                        &isp->isp_prev.subdev.entity, PREV_PAD_SINK, 0);
+        if (ret < 0)
+                return ret;
+        ret = media_create_pad_link(
+                        &isp->isp_prev.subdev.entity, PREV_PAD_SOURCE,
+                        &isp->isp_prev.video_out.video.entity, 0, 0);
+        if (ret < 0)
+                return ret;
+        ret = media_create_pad_link(
+                        &isp->isp_res.video_in.video.entity, 0,
+                        &isp->isp_res.subdev.entity, RESZ_PAD_SINK, 0);
+        if (ret < 0)
+                return ret;
+        ret = media_create_pad_link(
+                        &isp->isp_res.subdev.entity, RESZ_PAD_SOURCE,
+                        &isp->isp_res.video_out.video.entity, 0, 0);
+        if (ret < 0)
+                return ret;
+        /* Create links between entities. */
+        ret = media_create_pad_link(
+                        &isp->isp_csi2a.subdev.entity, CSI2_PAD_SOURCE,
+                        &isp->isp_ccdc.subdev.entity, CCDC_PAD_SINK, 0);
+        if (ret < 0)
+                return ret;
+        ret = media_create_pad_link(
+                        &isp->isp_ccp2.subdev.entity, CCP2_PAD_SOURCE,
+                        &isp->isp_ccdc.subdev.entity, CCDC_PAD_SINK, 0);
+        if (ret < 0)
+                return ret;
+        ret = media_create_pad_link(
+                        &isp->isp_ccdc.subdev.entity, CCDC_PAD_SOURCE_VP,
+                        &isp->isp_prev.subdev.entity, PREV_PAD_SINK, 0);
+        if (ret < 0)
+                return ret;
+        ret = media_create_pad_link(
+                        &isp->isp_ccdc.subdev.entity, CCDC_PAD_SOURCE_OF,
+                        &isp->isp_res.subdev.entity, RESZ_PAD_SINK, 0);
+        if (ret < 0)
+                return ret;
+        ret = media_create_pad_link(
+                        &isp->isp_prev.subdev.entity, PREV_PAD_SOURCE,
+                        &isp->isp_res.subdev.entity, RESZ_PAD_SINK, 0);
+        if (ret < 0)
+                return ret;
+        ret = media_create_pad_link(
+                        &isp->isp_ccdc.subdev.entity, CCDC_PAD_SOURCE_VP,
+                        &isp->isp_aewb.subdev.entity, 0,
+                        MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE);
+        if (ret < 0)
+                return ret;
+        ret = media_create_pad_link(
+                        &isp->isp_ccdc.subdev.entity, CCDC_PAD_SOURCE_VP,
+                        &isp->isp_af.subdev.entity, 0,
+                        MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE);
+        if (ret < 0)
+                return ret;
+        ret = media_create_pad_link(
+                        &isp->isp_ccdc.subdev.entity, CCDC_PAD_SOURCE_VP,
+                        &isp->isp_hist.subdev.entity, 0,
+                        MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE);
+        if (ret < 0)
+                return ret;
+        return 0;
+}
 static void isp_cleanup_modules(struct isp_device *isp)
 {
        omap3isp_h3a_aewb_cleanup(isp);
@@ -2000,62 +2123,8 @@ static int isp_initialize_modules(struct isp_device *isp)
                goto error_h3a_af;
        }
-        /* Connect the submodules. */
-        ret = media_entity_create_link(
-                        &isp->isp_csi2a.subdev.entity, CSI2_PAD_SOURCE,
-                        &isp->isp_ccdc.subdev.entity, CCDC_PAD_SINK, 0);
-        if (ret < 0)
-                goto error_link;
-        ret = media_entity_create_link(
-                        &isp->isp_ccp2.subdev.entity, CCP2_PAD_SOURCE,
-                        &isp->isp_ccdc.subdev.entity, CCDC_PAD_SINK, 0);
-        if (ret < 0)
-                goto error_link;
-        ret = media_entity_create_link(
-                        &isp->isp_ccdc.subdev.entity, CCDC_PAD_SOURCE_VP,
-                        &isp->isp_prev.subdev.entity, PREV_PAD_SINK, 0);
-        if (ret < 0)
-                goto error_link;
-        ret = media_entity_create_link(
-                        &isp->isp_ccdc.subdev.entity, CCDC_PAD_SOURCE_OF,
-                        &isp->isp_res.subdev.entity, RESZ_PAD_SINK, 0);
-        if (ret < 0)
-                goto error_link;
-        ret = media_entity_create_link(
-                        &isp->isp_prev.subdev.entity, PREV_PAD_SOURCE,
-                        &isp->isp_res.subdev.entity, RESZ_PAD_SINK, 0);
-        if (ret < 0)
-                goto error_link;
-        ret = media_entity_create_link(
-                        &isp->isp_ccdc.subdev.entity, CCDC_PAD_SOURCE_VP,
-                        &isp->isp_aewb.subdev.entity, 0,
-                        MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE);
-        if (ret < 0)
-                goto error_link;
-        ret = media_entity_create_link(
-                        &isp->isp_ccdc.subdev.entity, CCDC_PAD_SOURCE_VP,
-                        &isp->isp_af.subdev.entity, 0,
-                        MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE);
-        if (ret < 0)
-                goto error_link;
-        ret = media_entity_create_link(
-                        &isp->isp_ccdc.subdev.entity, CCDC_PAD_SOURCE_VP,
-                        &isp->isp_hist.subdev.entity, 0,
-                        MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE);
-        if (ret < 0)
-                goto error_link;
        return 0;
-error_link:
-        omap3isp_h3a_af_cleanup(isp);
 error_h3a_af:
        omap3isp_h3a_aewb_cleanup(isp);
 error_h3a_aewb:
@@ -2149,6 +2218,8 @@ static int isp_remove(struct platform_device *pdev)
        isp_detach_iommu(isp);
        __omap3isp_put(isp, false);
+        media_entity_enum_cleanup(&isp->crashed);
        return 0;
 }
@@ -2278,28 +2349,43 @@ static int isp_subdev_notifier_bound(struct v4l2_async_notifier *async,
                                     struct v4l2_subdev *subdev,
                                     struct v4l2_async_subdev *asd)
 {
-        struct isp_device *isp = container_of(async, struct isp_device,
-                                              notifier);
        struct isp_async_subdev *isd =
                container_of(asd, struct isp_async_subdev, asd);
-        int ret;
-        ret = isp_link_entity(isp, &subdev->entity, isd->bus.interface);
-        if (ret < 0)
-                return ret;
        isd->sd = subdev;
        isd->sd->host_priv = &isd->bus;
-        return ret;
+        return 0;
 }
 static int isp_subdev_notifier_complete(struct v4l2_async_notifier *async)
 {
        struct isp_device *isp = container_of(async, struct isp_device,
                                              notifier);
+        struct v4l2_device *v4l2_dev = &isp->v4l2_dev;
+        struct v4l2_subdev *sd;
+        struct isp_bus_cfg *bus;
+        int ret;
+        ret = media_entity_enum_init(&isp->crashed, &isp->media_dev);
+        if (ret)
+                return ret;
-        return v4l2_device_register_subdev_nodes(&isp->v4l2_dev);
+        list_for_each_entry(sd, &v4l2_dev->subdevs, list) {
+                /* Only try to link entities whose interface was set on bound */
+                if (sd->host_priv) {
+                        bus = (struct isp_bus_cfg *)sd->host_priv;
+                        ret = isp_link_entity(isp, &sd->entity, bus->interface);
+                        if (ret < 0)
+                                return ret;
+                }
+        }
+        ret = v4l2_device_register_subdev_nodes(&isp->v4l2_dev);
+        if (ret < 0)
+                return ret;
+        return media_device_register(&isp->media_dev);
 }
 /*
@@ -2465,6 +2551,10 @@ static int isp_probe(struct platform_device *pdev)
        if (ret < 0)
                goto error_modules;
+        ret = isp_create_links(isp);
+        if (ret < 0)
+                goto error_register_entities;
        isp->notifier.bound = isp_subdev_notifier_bound;
        isp->notifier.complete = isp_subdev_notifier_complete;
diff --git a/drivers/media/platform/omap3isp/isp.h b/drivers/media/platform/omap3isp/isp.h
index 5acc2e6511a5..49b7f71ac968 100644
--- a/drivers/media/platform/omap3isp/isp.h
+++ b/drivers/media/platform/omap3isp/isp.h
@@ -17,6 +17,7 @@
 #ifndef OMAP3_ISP_CORE_H
 #define OMAP3_ISP_CORE_H
+#include <media/media-entity.h>
 #include <media/v4l2-async.h>
 #include <media/v4l2-device.h>
 #include <linux/clk-provider.h>
@@ -152,7 +153,7 @@ struct isp_xclk {
 * @stat_lock: Spinlock for handling statistics
 * @isp_mutex: Mutex for serializing requests to ISP.
 * @stop_failure: Indicates that an entity failed to stop.
- * @crashed: Bitmask of crashed entities (indexed by entity ID)
+ * @crashed: Crashed ent_enum
 * @has_context: Context has been saved at least once and can be restored.
 * @ref_count: Reference count for handling multiple ISP requests.
 * @cam_ick: Pointer to camera interface clock structure.
@@ -176,6 +177,7 @@ struct isp_device {
        struct v4l2_device v4l2_dev;
        struct v4l2_async_notifier notifier;
        struct media_device media_dev;
+        struct media_entity_graph pm_count_graph;
        struct device *dev;
        u32 revision;
@@ -194,7 +196,7 @@ struct isp_device {
        spinlock_t stat_lock;   /* common lock for statistic drivers */
        struct mutex isp_mutex; /* For handling ref_count field */
        bool stop_failure;
-        u32 crashed;
+        struct media_entity_enum crashed;
        int has_context;
        int ref_count;
        unsigned int autoidle;
@@ -265,7 +267,8 @@ void omap3isp_subclk_enable(struct isp_device *isp,
 void omap3isp_subclk_disable(struct isp_device *isp,
                             enum isp_subclk_resource res);
-int omap3isp_pipeline_pm_use(struct media_entity *entity, int use);
+int omap3isp_pipeline_pm_use(struct media_entity *entity, int use,
+                             struct media_entity_graph *graph);
 int omap3isp_register_entities(struct platform_device *pdev,
                               struct v4l2_device *v4l2_dev);
diff --git a/drivers/media/platform/omap3isp/ispccdc.c b/drivers/media/platform/omap3isp/ispccdc.c
index a6a61cce43dd..bb3974c98e37 100644
--- a/drivers/media/platform/omap3isp/ispccdc.c
+++ b/drivers/media/platform/omap3isp/ispccdc.c
@@ -1608,7 +1608,7 @@ static int ccdc_isr_buffer(struct isp_ccdc_device *ccdc)
        /* Wait for the CCDC to become idle. */
        if (ccdc_sbl_wait_idle(ccdc, 1000)) {
                dev_info(isp->dev, "CCDC won't become idle!\n");
-                isp->crashed |= 1U << ccdc->subdev.entity.id;
+                media_entity_enum_set(&isp->crashed, &ccdc->subdev.entity);
                omap3isp_pipeline_cancel_stream(pipe);
                return 0;
        }
@@ -2513,9 +2513,14 @@ static int ccdc_link_setup(struct media_entity *entity,
        struct v4l2_subdev *sd = media_entity_to_v4l2_subdev(entity);
        struct isp_ccdc_device *ccdc = v4l2_get_subdevdata(sd);
        struct isp_device *isp = to_isp_device(ccdc);
+        unsigned int index = local->index;
-        switch (local->index | media_entity_type(remote->entity)) {
+        /* FIXME: this is actually a hack! */
-        case CCDC_PAD_SINK | MEDIA_ENT_T_V4L2_SUBDEV:
+        if (is_media_entity_v4l2_subdev(remote->entity))
+                index |= 2 << 16;
+        switch (index) {
+        case CCDC_PAD_SINK | 2 << 16:
                /* Read from the sensor (parallel interface), CCP2, CSI2a or
                 * CSI2c.
                 */
@@ -2543,7 +2548,7 @@ static int ccdc_link_setup(struct media_entity *entity,
         * Revisit this when it will be implemented, and return -EBUSY for now.
         */
-        case CCDC_PAD_SOURCE_VP | MEDIA_ENT_T_V4L2_SUBDEV:
+        case CCDC_PAD_SOURCE_VP | 2 << 16:
                /* Write to preview engine, histogram and H3A. When none of
                 * those links are active, the video port can be disabled.
                 */
@@ -2556,7 +2561,7 @@ static int ccdc_link_setup(struct media_entity *entity,
                }
                break;
-        case CCDC_PAD_SOURCE_OF | MEDIA_ENT_T_DEVNODE:
+        case CCDC_PAD_SOURCE_OF:
                /* Write to memory */
                if (flags & MEDIA_LNK_FL_ENABLED) {
                        if (ccdc->output & ~CCDC_OUTPUT_MEMORY)
@@ -2567,7 +2572,7 @@ static int ccdc_link_setup(struct media_entity *entity,
                }
                break;
-        case CCDC_PAD_SOURCE_OF | MEDIA_ENT_T_V4L2_SUBDEV:
+        case CCDC_PAD_SOURCE_OF | 2 << 16:
                /* Write to resizer */
                if (flags & MEDIA_LNK_FL_ENABLED) {
                        if (ccdc->output & ~CCDC_OUTPUT_RESIZER)
@@ -2650,7 +2655,7 @@ static int ccdc_init_entities(struct isp_ccdc_device *ccdc)
        pads[CCDC_PAD_SOURCE_OF].flags = MEDIA_PAD_FL_SOURCE;
        me->ops = &ccdc_media_ops;
-        ret = media_entity_init(me, CCDC_PADS_NUM, pads, 0);
+        ret = media_entity_pads_init(me, CCDC_PADS_NUM, pads);
        if (ret < 0)
                return ret;
@@ -2664,19 +2669,11 @@ static int ccdc_init_entities(struct isp_ccdc_device *ccdc)
        ret = omap3isp_video_init(&ccdc->video_out, "CCDC");
        if (ret < 0)
-                goto error_video;
+                goto error;
-        /* Connect the CCDC subdev to the video node. */
-        ret = media_entity_create_link(&ccdc->subdev.entity, CCDC_PAD_SOURCE_OF,
-                        &ccdc->video_out.video.entity, 0, 0);
-        if (ret < 0)
-                goto error_link;
        return 0;
-error_link:
+error:
-        omap3isp_video_cleanup(&ccdc->video_out);
-error_video:
        media_entity_cleanup(me);
        return ret;
 }
diff --git a/drivers/media/platform/omap3isp/ispccp2.c b/drivers/media/platform/omap3isp/ispccp2.c
index 38e6a974c5b1..ca095238510d 100644
--- a/drivers/media/platform/omap3isp/ispccp2.c
+++ b/drivers/media/platform/omap3isp/ispccp2.c
@@ -956,9 +956,14 @@ static int ccp2_link_setup(struct media_entity *entity,
 {
        struct v4l2_subdev *sd = media_entity_to_v4l2_subdev(entity);
        struct isp_ccp2_device *ccp2 = v4l2_get_subdevdata(sd);
+        unsigned int index = local->index;
-        switch (local->index | media_entity_type(remote->entity)) {
+        /* FIXME: this is actually a hack! */
-        case CCP2_PAD_SINK | MEDIA_ENT_T_DEVNODE:
+        if (is_media_entity_v4l2_subdev(remote->entity))
+                index |= 2 << 16;
+        switch (index) {
+        case CCP2_PAD_SINK:
                /* read from memory */
                if (flags & MEDIA_LNK_FL_ENABLED) {
                        if (ccp2->input == CCP2_INPUT_SENSOR)
@@ -970,7 +975,7 @@ static int ccp2_link_setup(struct media_entity *entity,
                }
                break;
-        case CCP2_PAD_SINK | MEDIA_ENT_T_V4L2_SUBDEV:
+        case CCP2_PAD_SINK | 2 << 16:
                /* read from sensor/phy */
                if (flags & MEDIA_LNK_FL_ENABLED) {
                        if (ccp2->input == CCP2_INPUT_MEMORY)
@@ -981,7 +986,7 @@ static int ccp2_link_setup(struct media_entity *entity,
                                ccp2->input = CCP2_INPUT_NONE;
                } break;
-        case CCP2_PAD_SOURCE | MEDIA_ENT_T_V4L2_SUBDEV:
+        case CCP2_PAD_SOURCE | 2 << 16:
                /* write to video port/ccdc */
                if (flags & MEDIA_LNK_FL_ENABLED)
                        ccp2->output = CCP2_OUTPUT_CCDC;
@@ -1071,7 +1076,7 @@ static int ccp2_init_entities(struct isp_ccp2_device *ccp2)
        pads[CCP2_PAD_SOURCE].flags = MEDIA_PAD_FL_SOURCE;
        me->ops = &ccp2_media_ops;
-        ret = media_entity_init(me, CCP2_PADS_NUM, pads, 0);
+        ret = media_entity_pads_init(me, CCP2_PADS_NUM, pads);
        if (ret < 0)
                return ret;
@@ -1097,19 +1102,11 @@ static int ccp2_init_entities(struct isp_ccp2_device *ccp2)
        ret = omap3isp_video_init(&ccp2->video_in, "CCP2");
        if (ret < 0)
-                goto error_video;
+                goto error;
-        /* Connect the video node to the ccp2 subdev. */
-        ret = media_entity_create_link(&ccp2->video_in.video.entity, 0,
-                                       &ccp2->subdev.entity, CCP2_PAD_SINK, 0);
-        if (ret < 0)
-                goto error_link;
        return 0;
-error_link:
+error:
-        omap3isp_video_cleanup(&ccp2->video_in);
-error_video:
        media_entity_cleanup(&ccp2->subdev.entity);
        return ret;
 }
diff --git a/drivers/media/platform/omap3isp/ispcsi2.c b/drivers/media/platform/omap3isp/ispcsi2.c
index a78338d012b4..f75a1be29d84 100644
--- a/drivers/media/platform/omap3isp/ispcsi2.c
+++ b/drivers/media/platform/omap3isp/ispcsi2.c
@@ -1144,14 +1144,19 @@ static int csi2_link_setup(struct media_entity *entity,
        struct v4l2_subdev *sd = media_entity_to_v4l2_subdev(entity);
        struct isp_csi2_device *csi2 = v4l2_get_subdevdata(sd);
        struct isp_csi2_ctrl_cfg *ctrl = &csi2->ctrl;
+        unsigned int index = local->index;
        /*
         * The ISP core doesn't support pipelines with multiple video outputs.
         * Revisit this when it will be implemented, and return -EBUSY for now.
         */
-        switch (local->index | media_entity_type(remote->entity)) {
+        /* FIXME: this is actually a hack! */
-        case CSI2_PAD_SOURCE | MEDIA_ENT_T_DEVNODE:
+        if (is_media_entity_v4l2_subdev(remote->entity))
+                index |= 2 << 16;
+        switch (index) {
+        case CSI2_PAD_SOURCE:
                if (flags & MEDIA_LNK_FL_ENABLED) {
                        if (csi2->output & ~CSI2_OUTPUT_MEMORY)
                                return -EBUSY;
@@ -1161,7 +1166,7 @@ static int csi2_link_setup(struct media_entity *entity,
                }
                break;
-        case CSI2_PAD_SOURCE | MEDIA_ENT_T_V4L2_SUBDEV:
+        case CSI2_PAD_SOURCE | 2 << 16:
                if (flags & MEDIA_LNK_FL_ENABLED) {
                        if (csi2->output & ~CSI2_OUTPUT_CCDC)
                                return -EBUSY;
@@ -1245,7 +1250,7 @@ static int csi2_init_entities(struct isp_csi2_device *csi2)
                                    | MEDIA_PAD_FL_MUST_CONNECT;
        me->ops = &csi2_media_ops;
-        ret = media_entity_init(me, CSI2_PADS_NUM, pads, 0);
+        ret = media_entity_pads_init(me, CSI2_PADS_NUM, pads);
        if (ret < 0)
                return ret;
@@ -1264,16 +1269,8 @@ static int csi2_init_entities(struct isp_csi2_device *csi2)
        if (ret < 0)
                goto error_video;
-        /* Connect the CSI2 subdev to the video node. */
-        ret = media_entity_create_link(&csi2->subdev.entity, CSI2_PAD_SOURCE,
-                                       &csi2->video_out.video.entity, 0, 0);
-        if (ret < 0)
-                goto error_link;
        return 0;
-error_link:
-        omap3isp_video_cleanup(&csi2->video_out);
 error_video:
        media_entity_cleanup(&csi2->subdev.entity);
        return ret;
diff --git a/drivers/media/platform/omap3isp/isppreview.c b/drivers/media/platform/omap3isp/isppreview.c
index 13803270d104..84a96670e2e7 100644
--- a/drivers/media/platform/omap3isp/isppreview.c
+++ b/drivers/media/platform/omap3isp/isppreview.c
@@ -2144,9 +2144,14 @@ static int preview_link_setup(struct media_entity *entity,
 {
        struct v4l2_subdev *sd = media_entity_to_v4l2_subdev(entity);
        struct isp_prev_device *prev = v4l2_get_subdevdata(sd);
+        unsigned int index = local->index;
-        switch (local->index | media_entity_type(remote->entity)) {
+        /* FIXME: this is actually a hack! */
-        case PREV_PAD_SINK | MEDIA_ENT_T_DEVNODE:
+        if (is_media_entity_v4l2_subdev(remote->entity))
+                index |= 2 << 16;
+        switch (index) {
+        case PREV_PAD_SINK:
                /* read from memory */
                if (flags & MEDIA_LNK_FL_ENABLED) {
                        if (prev->input == PREVIEW_INPUT_CCDC)
@@ -2158,7 +2163,7 @@ static int preview_link_setup(struct media_entity *entity,
                }
                break;
-        case PREV_PAD_SINK | MEDIA_ENT_T_V4L2_SUBDEV:
+        case PREV_PAD_SINK | 2 << 16:
                /* read from ccdc */
                if (flags & MEDIA_LNK_FL_ENABLED) {
                        if (prev->input == PREVIEW_INPUT_MEMORY)
@@ -2175,7 +2180,7 @@ static int preview_link_setup(struct media_entity *entity,
         * Revisit this when it will be implemented, and return -EBUSY for now.
         */
-        case PREV_PAD_SOURCE | MEDIA_ENT_T_DEVNODE:
+        case PREV_PAD_SOURCE:
                /* write to memory */
                if (flags & MEDIA_LNK_FL_ENABLED) {
                        if (prev->output & ~PREVIEW_OUTPUT_MEMORY)
@@ -2186,7 +2191,7 @@ static int preview_link_setup(struct media_entity *entity,
                }
                break;
-        case PREV_PAD_SOURCE | MEDIA_ENT_T_V4L2_SUBDEV:
+        case PREV_PAD_SOURCE | 2 << 16:
                /* write to resizer */
                if (flags & MEDIA_LNK_FL_ENABLED) {
                        if (prev->output & ~PREVIEW_OUTPUT_RESIZER)
@@ -2282,7 +2287,7 @@ static int preview_init_entities(struct isp_prev_device *prev)
        pads[PREV_PAD_SOURCE].flags = MEDIA_PAD_FL_SOURCE;
        me->ops = &preview_media_ops;
-        ret = media_entity_init(me, PREV_PADS_NUM, pads, 0);
+        ret = media_entity_pads_init(me, PREV_PADS_NUM, pads);
        if (ret < 0)
                return ret;
@@ -2311,21 +2316,8 @@ static int preview_init_entities(struct isp_prev_device *prev)
        if (ret < 0)
                goto error_video_out;
-        /* Connect the video nodes to the previewer subdev. */
-        ret = media_entity_create_link(&prev->video_in.video.entity, 0,
-                        &prev->subdev.entity, PREV_PAD_SINK, 0);
-        if (ret < 0)
-                goto error_link;
-        ret = media_entity_create_link(&prev->subdev.entity, PREV_PAD_SOURCE,
-                        &prev->video_out.video.entity, 0, 0);
-        if (ret < 0)
-                goto error_link;
        return 0;
-error_link:
-        omap3isp_video_cleanup(&prev->video_out);
 error_video_out:
        omap3isp_video_cleanup(&prev->video_in);
 error_video_in:
diff --git a/drivers/media/platform/omap3isp/ispresizer.c b/drivers/media/platform/omap3isp/ispresizer.c
index 7cfb43dc0ffd..0b6a87508584 100644
--- a/drivers/media/platform/omap3isp/ispresizer.c
+++ b/drivers/media/platform/omap3isp/ispresizer.c
@@ -1623,9 +1623,14 @@ static int resizer_link_setup(struct media_entity *entity,
 {
        struct v4l2_subdev *sd = media_entity_to_v4l2_subdev(entity);
        struct isp_res_device *res = v4l2_get_subdevdata(sd);
+        unsigned int index = local->index;
-        switch (local->index | media_entity_type(remote->entity)) {
+        /* FIXME: this is actually a hack! */
-        case RESZ_PAD_SINK | MEDIA_ENT_T_DEVNODE:
+        if (is_media_entity_v4l2_subdev(remote->entity))
+                index |= 2 << 16;
+        switch (index) {
+        case RESZ_PAD_SINK:
                /* read from memory */
                if (flags & MEDIA_LNK_FL_ENABLED) {
                        if (res->input == RESIZER_INPUT_VP)
@@ -1637,7 +1642,7 @@ static int resizer_link_setup(struct media_entity *entity,
                }
                break;
-        case RESZ_PAD_SINK | MEDIA_ENT_T_V4L2_SUBDEV:
+        case RESZ_PAD_SINK | 2 << 16:
                /* read from ccdc or previewer */
                if (flags & MEDIA_LNK_FL_ENABLED) {
                        if (res->input == RESIZER_INPUT_MEMORY)
@@ -1649,7 +1654,7 @@ static int resizer_link_setup(struct media_entity *entity,
                }
                break;
-        case RESZ_PAD_SOURCE | MEDIA_ENT_T_DEVNODE:
+        case RESZ_PAD_SOURCE:
                /* resizer always write to memory */
                break;
@@ -1728,7 +1733,7 @@ static int resizer_init_entities(struct isp_res_device *res)
        pads[RESZ_PAD_SOURCE].flags = MEDIA_PAD_FL_SOURCE;
        me->ops = &resizer_media_ops;
-        ret = media_entity_init(me, RESZ_PADS_NUM, pads, 0);
+        ret = media_entity_pads_init(me, RESZ_PADS_NUM, pads);
        if (ret < 0)
                return ret;
@@ -1755,21 +1760,8 @@ static int resizer_init_entities(struct isp_res_device *res)
        res->video_out.video.entity.flags |= MEDIA_ENT_FL_DEFAULT;
-        /* Connect the video nodes to the resizer subdev. */
-        ret = media_entity_create_link(&res->video_in.video.entity, 0,
-                        &res->subdev.entity, RESZ_PAD_SINK, 0);
-        if (ret < 0)
-                goto error_link;
-        ret = media_entity_create_link(&res->subdev.entity, RESZ_PAD_SOURCE,
-                        &res->video_out.video.entity, 0, 0);
-        if (ret < 0)
-                goto error_link;
        return 0;
-error_link:
-        omap3isp_video_cleanup(&res->video_out);
 error_video_out:
        omap3isp_video_cleanup(&res->video_in);
 error_video_in:
diff --git a/drivers/media/platform/omap3isp/ispstat.c b/drivers/media/platform/omap3isp/ispstat.c
index 94d4c295d3d0..1b9217d3b1b6 100644
--- a/drivers/media/platform/omap3isp/ispstat.c
+++ b/drivers/media/platform/omap3isp/ispstat.c
@@ -1028,7 +1028,7 @@ static int isp_stat_init_entities(struct ispstat *stat, const char *name,
        stat->pad.flags = MEDIA_PAD_FL_SINK | MEDIA_PAD_FL_MUST_CONNECT;
        me->ops = NULL;
-        return media_entity_init(me, 1, &stat->pad, 0);
+        return media_entity_pads_init(me, 1, &stat->pad);
 }
 int omap3isp_stat_init(struct ispstat *stat, const char *name,
diff --git a/drivers/media/platform/omap3isp/ispvideo.c b/drivers/media/platform/omap3isp/ispvideo.c
index ecadca3e945b..994dfc0813f6 100644
--- a/drivers/media/platform/omap3isp/ispvideo.c
+++ b/drivers/media/platform/omap3isp/ispvideo.c
@@ -210,8 +210,7 @@ isp_video_remote_subdev(struct isp_video *video, u32 *pad)
        remote = media_entity_remote_pad(&video->pad);
-        if (remote == NULL ||
+        if (!remote || !is_media_entity_v4l2_subdev(remote->entity))
-            media_entity_type(remote->entity) != MEDIA_ENT_T_V4L2_SUBDEV)
                return NULL;
        if (pad)
@@ -226,16 +225,23 @@ static int isp_video_get_graph_data(struct isp_video *video,
 {
        struct media_entity_graph graph;
        struct media_entity *entity = &video->video.entity;
-        struct media_device *mdev = entity->parent;
+        struct media_device *mdev = entity->graph_obj.mdev;
        struct isp_video *far_end = NULL;
+        int ret;
        mutex_lock(&mdev->graph_mutex);
+        ret = media_entity_graph_walk_init(&graph, entity->graph_obj.mdev);
+        if (ret) {
+                mutex_unlock(&mdev->graph_mutex);
+                return ret;
+        }
        media_entity_graph_walk_start(&graph, entity);
        while ((entity = media_entity_graph_walk_next(&graph))) {
                struct isp_video *__video;
-                pipe->entities |= 1 << entity->id;
+                media_entity_enum_set(&pipe->ent_enum, entity);
                if (far_end != NULL)
                        continue;
@@ -243,7 +249,7 @@ static int isp_video_get_graph_data(struct isp_video *video,
                if (entity == &video->video.entity)
                        continue;
-                if (media_entity_type(entity) != MEDIA_ENT_T_DEVNODE)
+                if (!is_media_entity_v4l2_io(entity))
                        continue;
                __video = to_isp_video(media_entity_to_video_device(entity));
@@ -253,6 +259,8 @@ static int isp_video_get_graph_data(struct isp_video *video,
        mutex_unlock(&mdev->graph_mutex);
+        media_entity_graph_walk_cleanup(&graph);
        if (video->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
                pipe->input = far_end;
                pipe->output = video;
@@ -900,7 +908,7 @@ static int isp_video_check_external_subdevs(struct isp_video *video,
        for (i = 0; i < ARRAY_SIZE(ents); i++) {
                /* Is the entity part of the pipeline? */
-                if (!(pipe->entities & (1 << ents[i]->id)))
+                if (!media_entity_enum_test(&pipe->ent_enum, ents[i]))
                        continue;
                /* ISP entities have always sink pad == 0. Find source. */
@@ -918,7 +926,7 @@ static int isp_video_check_external_subdevs(struct isp_video *video,
                return -EINVAL;
        }
-        if (media_entity_type(source) != MEDIA_ENT_T_V4L2_SUBDEV)
+        if (!is_media_entity_v4l2_subdev(source))
                return 0;
        pipe->external = media_entity_to_v4l2_subdev(source);
@@ -952,7 +960,8 @@ static int isp_video_check_external_subdevs(struct isp_video *video,
        pipe->external_rate = ctrl.value64;
-        if (pipe->entities & (1 << isp->isp_ccdc.subdev.entity.id)) {
+        if (media_entity_enum_test(&pipe->ent_enum,
+                                   &isp->isp_ccdc.subdev.entity)) {
                unsigned int rate = UINT_MAX;
                /*
                 * Check that maximum allowed CCDC pixel rate isn't
@@ -1018,7 +1027,9 @@ isp_video_streamon(struct file *file, void *fh, enum v4l2_buf_type type)
        pipe = video->video.entity.pipe
             ? to_isp_pipeline(&video->video.entity) : &video->pipe;
-        pipe->entities = 0;
+        ret = media_entity_enum_init(&pipe->ent_enum, &video->isp->media_dev);
+        if (ret)
+                goto err_enum_init;
        /* TODO: Implement PM QoS */
        pipe->l3_ick = clk_get_rate(video->isp->clock[ISP_CLK_L3_ICK]);
@@ -1092,6 +1103,7 @@ isp_video_streamon(struct file *file, void *fh, enum v4l2_buf_type type)
        }
        mutex_unlock(&video->stream_lock);
        return 0;
 err_set_stream:
@@ -1112,7 +1124,11 @@ err_pipeline_start:
        INIT_LIST_HEAD(&video->dmaqueue);
        video->queue = NULL;
+        media_entity_enum_cleanup(&pipe->ent_enum);
+err_enum_init:
        mutex_unlock(&video->stream_lock);
        return ret;
 }
@@ -1164,6 +1180,8 @@ isp_video_streamoff(struct file *file, void *fh, enum v4l2_buf_type type)
        /* TODO: Implement PM QoS */
        media_entity_pipeline_stop(&video->video.entity);
+        media_entity_enum_cleanup(&pipe->ent_enum);
 done:
        mutex_unlock(&video->stream_lock);
        return 0;
@@ -1243,7 +1261,12 @@ static int isp_video_open(struct file *file)
                goto done;
        }
-        ret = omap3isp_pipeline_pm_use(&video->video.entity, 1);
+        ret = media_entity_graph_walk_init(&handle->graph,
+                                           &video->isp->media_dev);
+        if (ret)
+                goto done;
+        ret = omap3isp_pipeline_pm_use(&video->video.entity, 1, &handle->graph);
        if (ret < 0) {
                omap3isp_put(video->isp);
                goto done;
@@ -1274,6 +1297,7 @@ static int isp_video_open(struct file *file)
 done:
        if (ret < 0) {
                v4l2_fh_del(&handle->vfh);
+                media_entity_graph_walk_cleanup(&handle->graph);
                kfree(handle);
        }
@@ -1293,7 +1317,8 @@ static int isp_video_release(struct file *file)
        vb2_queue_release(&handle->queue);
        mutex_unlock(&video->queue_lock);
-        omap3isp_pipeline_pm_use(&video->video.entity, 0);
+        omap3isp_pipeline_pm_use(&video->video.entity, 0, &handle->graph);
+        media_entity_graph_walk_cleanup(&handle->graph);
        /* Release the file handle. */
        v4l2_fh_del(vfh);
@@ -1367,7 +1392,7 @@ int omap3isp_video_init(struct isp_video *video, const char *name)
        if (IS_ERR(video->alloc_ctx))
                return PTR_ERR(video->alloc_ctx);
-        ret = media_entity_init(&video->video.entity, 1, &video->pad, 0);
+        ret = media_entity_pads_init(&video->video.entity, 1, &video->pad);
        if (ret < 0) {
                vb2_dma_contig_cleanup_ctx(video->alloc_ctx);
                return ret;
diff --git a/drivers/media/platform/omap3isp/ispvideo.h b/drivers/media/platform/omap3isp/ispvideo.h
index bcf0e0acc8f3..156429878d64 100644
--- a/drivers/media/platform/omap3isp/ispvideo.h
+++ b/drivers/media/platform/omap3isp/ispvideo.h
@@ -80,7 +80,7 @@ enum isp_pipeline_state {
 * struct isp_pipeline - An ISP hardware pipeline
 * @field: The field being processed by the pipeline
 * @error: A hardware error occurred during capture
- * @entities: Bitmask of entities in the pipeline (indexed by entity ID)
+ * @ent_enum: Entities in the pipeline
 */
 struct isp_pipeline {
        struct media_pipeline pipe;
@@ -89,7 +89,7 @@ struct isp_pipeline {
        enum isp_pipeline_stream_state stream_state;
        struct isp_video *input;
        struct isp_video *output;
-        u32 entities;
+        struct media_entity_enum ent_enum;
        unsigned long l3_ick;
        unsigned int max_rate;
        enum v4l2_field field;
@@ -189,6 +189,7 @@ struct isp_video_fh {
        struct vb2_queue queue;
        struct v4l2_format format;
        struct v4l2_fract timeperframe;
+        struct media_entity_graph graph;
 };
 #define to_isp_video_fh(fh)     container_of(fh, struct isp_video_fh, vfh)
diff --git a/drivers/media/platform/s3c-camif/camif-capture.c b/drivers/media/platform/s3c-camif/camif-capture.c
index ec3abbed87d9..bd060ef5d1e1 100644
--- a/drivers/media/platform/s3c-camif/camif-capture.c
+++ b/drivers/media/platform/s3c-camif/camif-capture.c
@@ -822,7 +822,7 @@ static int camif_pipeline_validate(struct camif_dev *camif)
        /* Retrieve format at the sensor subdev source pad */
        pad = media_entity_remote_pad(&camif->pads[0]);
-        if (!pad || media_entity_type(pad->entity) != MEDIA_ENT_T_V4L2_SUBDEV)
+        if (!pad || !is_media_entity_v4l2_subdev(pad->entity))
                return -EPIPE;
        src_fmt.pad = pad->index;
@@ -1144,7 +1144,7 @@ int s3c_camif_register_video_node(struct camif_dev *camif, int idx)
                goto err_vd_rel;
        vp->pad.flags = MEDIA_PAD_FL_SINK;
-        ret = media_entity_init(&vfd->entity, 1, &vp->pad, 0);
+        ret = media_entity_pads_init(&vfd->entity, 1, &vp->pad);
        if (ret)
                goto err_vd_rel;
@@ -1559,8 +1559,8 @@ int s3c_camif_create_subdev(struct camif_dev *camif)
        camif->pads[CAMIF_SD_PAD_SOURCE_C].flags = MEDIA_PAD_FL_SOURCE;
        camif->pads[CAMIF_SD_PAD_SOURCE_P].flags = MEDIA_PAD_FL_SOURCE;
-        ret = media_entity_init(&sd->entity, CAMIF_SD_PADS_NUM,
+        ret = media_entity_pads_init(&sd->entity, CAMIF_SD_PADS_NUM,
-                                camif->pads, 0);
+                                camif->pads);
        if (ret)
                return ret;
diff --git a/drivers/media/platform/s3c-camif/camif-core.c b/drivers/media/platform/s3c-camif/camif-core.c
index 1ba9bb08f5da..0b44b9accf50 100644
--- a/drivers/media/platform/s3c-camif/camif-core.c
+++ b/drivers/media/platform/s3c-camif/camif-core.c
@@ -263,7 +263,7 @@ static int camif_create_media_links(struct camif_dev *camif)
 {
        int i, ret;
-        ret = media_entity_create_link(&camif->sensor.sd->entity, 0,
+        ret = media_create_pad_link(&camif->sensor.sd->entity, 0,
                                &camif->subdev.entity, CAMIF_SD_PAD_SINK,
                                MEDIA_LNK_FL_IMMUTABLE |
                                MEDIA_LNK_FL_ENABLED);
@@ -271,7 +271,7 @@ static int camif_create_media_links(struct camif_dev *camif)
                return ret;
        for (i = 1; i < CAMIF_SD_PADS_NUM && !ret; i++) {
-                ret = media_entity_create_link(&camif->subdev.entity, i,
+                ret = media_create_pad_link(&camif->subdev.entity, i,
                                &camif->vp[i - 1].vdev.entity, 0,
                                MEDIA_LNK_FL_IMMUTABLE |
                                MEDIA_LNK_FL_ENABLED);
@@ -305,7 +305,7 @@ static void camif_unregister_media_entities(struct camif_dev *camif)
 /*
 * Media device
 */
-static int camif_media_dev_register(struct camif_dev *camif)
+static int camif_media_dev_init(struct camif_dev *camif)
 {
        struct media_device *md = &camif->media_dev;
        struct v4l2_device *v4l2_dev = &camif->v4l2_dev;
@@ -324,14 +324,12 @@ static int camif_media_dev_register(struct camif_dev *camif)
        strlcpy(v4l2_dev->name, "s3c-camif", sizeof(v4l2_dev->name));
        v4l2_dev->mdev = md;
+        media_device_init(md);
        ret = v4l2_device_register(camif->dev, v4l2_dev);
        if (ret < 0)
                return ret;
-        ret = media_device_register(md);
-        if (ret < 0)
-                v4l2_device_unregister(v4l2_dev);
        return ret;
 }
@@ -483,7 +481,7 @@ static int s3c_camif_probe(struct platform_device *pdev)
                goto err_alloc;
        }
-        ret = camif_media_dev_register(camif);
+        ret = camif_media_dev_init(camif);
        if (ret < 0)
                goto err_mdev;
@@ -510,6 +508,11 @@ static int s3c_camif_probe(struct platform_device *pdev)
                goto err_unlock;
        mutex_unlock(&camif->media_dev.graph_mutex);
+        ret = media_device_register(&camif->media_dev);
+        if (ret < 0)
+                goto err_sens;
        pm_runtime_put(dev);
        return 0;
@@ -518,6 +521,7 @@ err_unlock:
 err_sens:
        v4l2_device_unregister(&camif->v4l2_dev);
        media_device_unregister(&camif->media_dev);
+        media_device_cleanup(&camif->media_dev);
        camif_unregister_media_entities(camif);
 err_mdev:
        vb2_dma_contig_cleanup_ctx(camif->alloc_ctx);
@@ -539,6 +543,7 @@ static int s3c_camif_remove(struct platform_device *pdev)
        struct s3c_camif_plat_data *pdata = &camif->pdata;
        media_device_unregister(&camif->media_dev);
+        media_device_cleanup(&camif->media_dev);
        camif_unregister_media_entities(camif);
        v4l2_device_unregister(&camif->v4l2_dev);
diff --git a/drivers/media/platform/vsp1/vsp1_drv.c b/drivers/media/platform/vsp1/vsp1_drv.c
index 4e61886384e3..42dff9d020af 100644
--- a/drivers/media/platform/vsp1/vsp1_drv.c
+++ b/drivers/media/platform/vsp1/vsp1_drv.c
@@ -101,7 +101,7 @@ static int vsp1_create_links(struct vsp1_device *vsp1, struct vsp1_entity *sink)
                        if (!(entity->pads[pad].flags & MEDIA_PAD_FL_SINK))
                                continue;
-                        ret = media_entity_create_link(&source->subdev.entity,
+                        ret = media_create_pad_link(&source->subdev.entity,
                                                       source->source_pad,
                                                       entity, pad, flags);
                        if (ret < 0)
@@ -127,6 +127,7 @@ static void vsp1_destroy_entities(struct vsp1_device *vsp1)
        v4l2_device_unregister(&vsp1->v4l2_dev);
        media_device_unregister(&vsp1->media_dev);
+        media_device_cleanup(&vsp1->media_dev);
 }
 static int vsp1_create_entities(struct vsp1_device *vsp1)
@@ -141,12 +142,7 @@ static int vsp1_create_entities(struct vsp1_device *vsp1)
        strlcpy(mdev->model, "VSP1", sizeof(mdev->model));
        snprintf(mdev->bus_info, sizeof(mdev->bus_info), "platform:%s",
                 dev_name(mdev->dev));
-        ret = media_device_register(mdev);
+        media_device_init(mdev);
-        if (ret < 0) {
-                dev_err(vsp1->dev, "media device registration failed (%d)\n",
-                        ret);
-                return ret;
-        }
        vdev->mdev = mdev;
        ret = v4l2_device_register(vsp1->dev, vdev);
@@ -250,34 +246,44 @@ static int vsp1_create_entities(struct vsp1_device *vsp1)
                list_add_tail(&wpf->entity.list_dev, &vsp1->entities);
        }
-        /* Create links. */
+        /* Register all subdevs. */
        list_for_each_entry(entity, &vsp1->entities, list_dev) {
-                if (entity->type == VSP1_ENTITY_LIF ||
+                ret = v4l2_device_register_subdev(&vsp1->v4l2_dev,
-                    entity->type == VSP1_ENTITY_RPF)
+                                                  &entity->subdev);
-                        continue;
-                ret = vsp1_create_links(vsp1, entity);
                if (ret < 0)
                        goto done;
        }
+        /* Create links. */
+        list_for_each_entry(entity, &vsp1->entities, list_dev) {
+                if (entity->type == VSP1_ENTITY_LIF) {
+                        ret = vsp1_wpf_create_links(vsp1, entity);
+                        if (ret < 0)
+                                goto done;
+                } else if (entity->type == VSP1_ENTITY_RPF) {
+                        ret = vsp1_rpf_create_links(vsp1, entity);
+                        if (ret < 0)
+                                goto done;
+                } else {
+                        ret = vsp1_create_links(vsp1, entity);
+                        if (ret < 0)
+                                goto done;
+                }
+        }
        if (vsp1->pdata.features & VSP1_HAS_LIF) {
-                ret = media_entity_create_link(
+                ret = media_create_pad_link(
                        &vsp1->wpf[0]->entity.subdev.entity, RWPF_PAD_SOURCE,
                        &vsp1->lif->entity.subdev.entity, LIF_PAD_SINK, 0);
                if (ret < 0)
                        return ret;
        }
-        /* Register all subdevs. */
-        list_for_each_entry(entity, &vsp1->entities, list_dev) {
-                ret = v4l2_device_register_subdev(&vsp1->v4l2_dev,
-                                                  &entity->subdev);
-                if (ret < 0)
-                        goto done;
-        }
        ret = v4l2_device_register_subdev_nodes(&vsp1->v4l2_dev);
+        if (ret < 0)
+                goto done;
+        ret = media_device_register(mdev);
 done:
        if (ret < 0)
diff --git a/drivers/media/platform/vsp1/vsp1_entity.c b/drivers/media/platform/vsp1/vsp1_entity.c
index fd95a75b04f4..d7308530952f 100644
--- a/drivers/media/platform/vsp1/vsp1_entity.c
+++ b/drivers/media/platform/vsp1/vsp1_entity.c
@@ -219,8 +219,8 @@ int vsp1_entity_init(struct vsp1_device *vsp1, struct vsp1_entity *entity,
        entity->pads[num_pads - 1].flags = MEDIA_PAD_FL_SOURCE;
        /* Initialize the media entity. */
-        return media_entity_init(&entity->subdev.entity, num_pads,
+        return media_entity_pads_init(&entity->subdev.entity, num_pads,
-                                 entity->pads, 0);
+                                 entity->pads);
 }
 void vsp1_entity_destroy(struct vsp1_entity *entity)
diff --git a/drivers/media/platform/vsp1/vsp1_rpf.c b/drivers/media/platform/vsp1/vsp1_rpf.c
index cd5248a9a271..924538223d3e 100644
--- a/drivers/media/platform/vsp1/vsp1_rpf.c
+++ b/drivers/media/platform/vsp1/vsp1_rpf.c
@@ -277,18 +277,29 @@ struct vsp1_rwpf *vsp1_rpf_create(struct vsp1_device *vsp1, unsigned int index)
        rpf->entity.video = video;
-        /* Connect the video device to the RPF. */
-        ret = media_entity_create_link(&rpf->video.video.entity, 0,
-                                       &rpf->entity.subdev.entity,
-                                       RWPF_PAD_SINK,
-                                       MEDIA_LNK_FL_ENABLED |
-                                       MEDIA_LNK_FL_IMMUTABLE);
-        if (ret < 0)
-                goto error;
        return rpf;
 error:
        vsp1_entity_destroy(&rpf->entity);
        return ERR_PTR(ret);
 }
+/*
+ * vsp1_rpf_create_links() - RPF pads links creation
+ * @vsp1: Pointer to VSP1 device
+ * @entity: Pointer to VSP1 entity
+ *
+ * return negative error code or zero on success
+ */
+int vsp1_rpf_create_links(struct vsp1_device *vsp1,
+                               struct vsp1_entity *entity)
+{
+        struct vsp1_rwpf *rpf = to_rwpf(&entity->subdev);
+        /* Connect the video device to the RPF. */
+        return media_create_pad_link(&rpf->video.video.entity, 0,
+                                     &rpf->entity.subdev.entity,
+                                     RWPF_PAD_SINK,
+                                     MEDIA_LNK_FL_ENABLED |
+                                     MEDIA_LNK_FL_IMMUTABLE);
+}
diff --git a/drivers/media/platform/vsp1/vsp1_rwpf.h b/drivers/media/platform/vsp1/vsp1_rwpf.h
index f452dce1a931..731d36e5258d 100644
--- a/drivers/media/platform/vsp1/vsp1_rwpf.h
+++ b/drivers/media/platform/vsp1/vsp1_rwpf.h
@@ -50,6 +50,11 @@ static inline struct vsp1_rwpf *to_rwpf(struct v4l2_subdev *subdev)
 struct vsp1_rwpf *vsp1_rpf_create(struct vsp1_device *vsp1, unsigned int index);
 struct vsp1_rwpf *vsp1_wpf_create(struct vsp1_device *vsp1, unsigned int index);
+int vsp1_rpf_create_links(struct vsp1_device *vsp1,
+                               struct vsp1_entity *entity);
+int vsp1_wpf_create_links(struct vsp1_device *vsp1,
+                               struct vsp1_entity *entity);
 int vsp1_rwpf_enum_mbus_code(struct v4l2_subdev *subdev,
                             struct v4l2_subdev_pad_config *cfg,
                             struct v4l2_subdev_mbus_code_enum *code);
diff --git a/drivers/media/platform/vsp1/vsp1_video.c b/drivers/media/platform/vsp1/vsp1_video.c
index 45eb65fa23db..637d0d6f79fb 100644
--- a/drivers/media/platform/vsp1/vsp1_video.c
+++ b/drivers/media/platform/vsp1/vsp1_video.c
@@ -160,8 +160,7 @@ vsp1_video_remote_subdev(struct media_pad *local, u32 *pad)
        struct media_pad *remote;
        remote = media_entity_remote_pad(local);
-        if (remote == NULL ||
+        if (!remote || !is_media_entity_v4l2_subdev(remote->entity))
-            media_entity_type(remote->entity) != MEDIA_ENT_T_V4L2_SUBDEV)
                return NULL;
        if (pad)
@@ -283,24 +282,35 @@ static int vsp1_pipeline_validate_branch(struct vsp1_pipeline *pipe,
                                         struct vsp1_rwpf *output)
 {
        struct vsp1_entity *entity;
-        unsigned int entities = 0;
+        struct media_entity_enum ent_enum;
        struct media_pad *pad;
+        int rval;
        bool bru_found = false;
        input->location.left = 0;
        input->location.top = 0;
+        rval = media_entity_enum_init(
+                &ent_enum, input->entity.pads[RWPF_PAD_SOURCE].graph_obj.mdev);
+        if (rval)
+                return rval;
        pad = media_entity_remote_pad(&input->entity.pads[RWPF_PAD_SOURCE]);
        while (1) {
-                if (pad == NULL)
+                if (pad == NULL) {
-                        return -EPIPE;
+                        rval = -EPIPE;
+                        goto out;
+                }
                /* We've reached a video node, that shouldn't have happened. */
-                if (media_entity_type(pad->entity) != MEDIA_ENT_T_V4L2_SUBDEV)
+                if (!is_media_entity_v4l2_subdev(pad->entity)) {
-                        return -EPIPE;
+                        rval = -EPIPE;
+                        goto out;
+                }
-                entity = to_vsp1_entity(media_entity_to_v4l2_subdev(pad->entity));
+                entity = to_vsp1_entity(
+                        media_entity_to_v4l2_subdev(pad->entity));
                /* A BRU is present in the pipeline, store the compose rectangle
                 * location in the input RPF for use when configuring the RPF.
@@ -323,15 +333,18 @@ static int vsp1_pipeline_validate_branch(struct vsp1_pipeline *pipe,
                        break;
                /* Ensure the branch has no loop. */
-                if (entities & (1 << entity->subdev.entity.id))
+                if (media_entity_enum_test_and_set(&ent_enum,
-                        return -EPIPE;
+                                                   &entity->subdev.entity)) {
+                        rval = -EPIPE;
-                entities |= 1 << entity->subdev.entity.id;
+                        goto out;
+                }
                /* UDS can't be chained. */
                if (entity->type == VSP1_ENTITY_UDS) {
-                        if (pipe->uds)
+                        if (pipe->uds) {
-                                return -EPIPE;
+                                rval = -EPIPE;
+                                goto out;
+                        }
                        pipe->uds = entity;
                        pipe->uds_input = bru_found ? pipe->bru
@@ -349,9 +362,12 @@ static int vsp1_pipeline_validate_branch(struct vsp1_pipeline *pipe,
        /* The last entity must be the output WPF. */
        if (entity != &output->entity)
-                return -EPIPE;
+                rval = -EPIPE;
-        return 0;
+out:
+        media_entity_enum_cleanup(&ent_enum);
+        return rval;
 }
 static void __vsp1_pipeline_cleanup(struct vsp1_pipeline *pipe)
@@ -380,13 +396,19 @@ static int vsp1_pipeline_validate(struct vsp1_pipeline *pipe,
 {
        struct media_entity_graph graph;
        struct media_entity *entity = &video->video.entity;
-        struct media_device *mdev = entity->parent;
+        struct media_device *mdev = entity->graph_obj.mdev;
        unsigned int i;
        int ret;
        mutex_lock(&mdev->graph_mutex);
        /* Walk the graph to locate the entities and video nodes. */
+        ret = media_entity_graph_walk_init(&graph, mdev);
+        if (ret) {
+                mutex_unlock(&mdev->graph_mutex);
+                return ret;
+        }
        media_entity_graph_walk_start(&graph, entity);
        while ((entity = media_entity_graph_walk_next(&graph))) {
@@ -394,7 +416,7 @@ static int vsp1_pipeline_validate(struct vsp1_pipeline *pipe,
                struct vsp1_rwpf *rwpf;
                struct vsp1_entity *e;
-                if (media_entity_type(entity) != MEDIA_ENT_T_V4L2_SUBDEV) {
+                if (is_media_entity_v4l2_io(entity)) {
                        pipe->num_video++;
                        continue;
                }
@@ -420,6 +442,8 @@ static int vsp1_pipeline_validate(struct vsp1_pipeline *pipe,
        mutex_unlock(&mdev->graph_mutex);
+        media_entity_graph_walk_cleanup(&graph);
        /* We need one output and at least one input. */
        if (pipe->num_inputs == 0 || !pipe->output) {
                ret = -EPIPE;
@@ -663,7 +687,7 @@ void vsp1_pipeline_propagate_alpha(struct vsp1_pipeline *pipe,
        pad = media_entity_remote_pad(&input->pads[RWPF_PAD_SOURCE]);
        while (pad) {
-                if (media_entity_type(pad->entity) != MEDIA_ENT_T_V4L2_SUBDEV)
+                if (!is_media_entity_v4l2_subdev(pad->entity))
                        break;
                entity = to_vsp1_entity(media_entity_to_v4l2_subdev(pad->entity));
@@ -1193,7 +1217,7 @@ int vsp1_video_init(struct vsp1_video *video, struct vsp1_entity *rwpf)
        video->pipe.state = VSP1_PIPELINE_STOPPED;
        /* Initialize the media entity... */
-        ret = media_entity_init(&video->video.entity, 1, &video->pad, 0);
+        ret = media_entity_pads_init(&video->video.entity, 1, &video->pad);
        if (ret < 0)
                return ret;
diff --git a/drivers/media/platform/vsp1/vsp1_wpf.c b/drivers/media/platform/vsp1/vsp1_wpf.c
index 95b62f4f77e7..cbf514a6582d 100644
--- a/drivers/media/platform/vsp1/vsp1_wpf.c
+++ b/drivers/media/platform/vsp1/vsp1_wpf.c
@@ -220,7 +220,6 @@ struct vsp1_rwpf *vsp1_wpf_create(struct vsp1_device *vsp1, unsigned int index)
        struct v4l2_subdev *subdev;
        struct vsp1_video *video;
        struct vsp1_rwpf *wpf;
-        unsigned int flags;
        int ret;
        wpf = devm_kzalloc(vsp1->dev, sizeof(*wpf), GFP_KERNEL);
@@ -276,20 +275,6 @@ struct vsp1_rwpf *vsp1_wpf_create(struct vsp1_device *vsp1, unsigned int index)
                goto error;
        wpf->entity.video = video;
-        /* Connect the video device to the WPF. All connections are immutable
-         * except for the WPF0 source link if a LIF is present.
-         */
-        flags = MEDIA_LNK_FL_ENABLED;
-        if (!(vsp1->pdata.features & VSP1_HAS_LIF) || index != 0)
-                flags |= MEDIA_LNK_FL_IMMUTABLE;
-        ret = media_entity_create_link(&wpf->entity.subdev.entity,
-                                       RWPF_PAD_SOURCE,
-                                       &wpf->video.video.entity, 0, flags);
-        if (ret < 0)
-                goto error;
        wpf->entity.sink = &wpf->video.video.entity;
        return wpf;
@@ -298,3 +283,28 @@ error:
        vsp1_entity_destroy(&wpf->entity);
        return ERR_PTR(ret);
 }
+/*
+ * vsp1_wpf_create_links() - RPF pads links creation
+ * @vsp1: Pointer to VSP1 device
+ * @entity: Pointer to VSP1 entity
+ *
+ * return negative error code or zero on success
+ */
+int vsp1_wpf_create_links(struct vsp1_device *vsp1,
+                               struct vsp1_entity *entity)
+{
+        struct vsp1_rwpf *wpf = to_rwpf(&entity->subdev);
+        unsigned int flags;
+        /* Connect the video device to the WPF. All connections are immutable
+         * except for the WPF0 source link if a LIF is present.
+         */
+        flags = MEDIA_LNK_FL_ENABLED;
+        if (!(vsp1->pdata.features & VSP1_HAS_LIF) || entity->index != 0)
+                flags |= MEDIA_LNK_FL_IMMUTABLE;
+        return media_create_pad_link(&wpf->entity.subdev.entity,
+                                     RWPF_PAD_SOURCE,
+                                     &wpf->video.video.entity, 0, flags);
+}
diff --git a/drivers/media/platform/xilinx/xilinx-dma.c b/drivers/media/platform/xilinx/xilinx-dma.c
index 722758f33924..7f6898b13cac 100644
--- a/drivers/media/platform/xilinx/xilinx-dma.c
+++ b/drivers/media/platform/xilinx/xilinx-dma.c
@@ -49,8 +49,7 @@ xvip_dma_remote_subdev(struct media_pad *local, u32 *pad)
        struct media_pad *remote;
        remote = media_entity_remote_pad(local);
-        if (remote == NULL ||
+        if (!remote || !is_media_entity_v4l2_subdev(remote->entity))
-            media_entity_type(remote->entity) != MEDIA_ENT_T_V4L2_SUBDEV)
                return NULL;
        if (pad)
@@ -113,8 +112,7 @@ static int xvip_pipeline_start_stop(struct xvip_pipeline *pipe, bool start)
                        break;
                pad = media_entity_remote_pad(pad);
-                if (pad == NULL ||
+                if (!pad || !is_media_entity_v4l2_subdev(pad->entity))
-                    media_entity_type(pad->entity) != MEDIA_ENT_T_V4L2_SUBDEV)
                        break;
                entity = pad->entity;
@@ -181,19 +179,26 @@ static int xvip_pipeline_validate(struct xvip_pipeline *pipe,
 {
        struct media_entity_graph graph;
        struct media_entity *entity = &start->video.entity;
-        struct media_device *mdev = entity->parent;
+        struct media_device *mdev = entity->graph_obj.mdev;
        unsigned int num_inputs = 0;
        unsigned int num_outputs = 0;
+        int ret;
        mutex_lock(&mdev->graph_mutex);
        /* Walk the graph to locate the video nodes. */
+        ret = media_entity_graph_walk_init(&graph, entity->graph_obj.mdev);
+        if (ret) {
+                mutex_unlock(&mdev->graph_mutex);
+                return ret;
+        }
        media_entity_graph_walk_start(&graph, entity);
        while ((entity = media_entity_graph_walk_next(&graph))) {
                struct xvip_dma *dma;
-                if (entity->type != MEDIA_ENT_T_DEVNODE_V4L)
+                if (entity->function != MEDIA_ENT_F_IO_V4L)
                        continue;
                dma = to_xvip_dma(media_entity_to_video_device(entity));
@@ -208,6 +213,8 @@ static int xvip_pipeline_validate(struct xvip_pipeline *pipe,
        mutex_unlock(&mdev->graph_mutex);
+        media_entity_graph_walk_cleanup(&graph);
        /* We need exactly one output and zero or one input. */
        if (num_outputs != 1 || num_inputs > 1)
                return -EPIPE;
@@ -677,7 +684,7 @@ int xvip_dma_init(struct xvip_composite_device *xdev, struct xvip_dma *dma,
        dma->pad.flags = type == V4L2_BUF_TYPE_VIDEO_CAPTURE
                       ? MEDIA_PAD_FL_SINK : MEDIA_PAD_FL_SOURCE;
-        ret = media_entity_init(&dma->video.entity, 1, &dma->pad, 0);
+        ret = media_entity_pads_init(&dma->video.entity, 1, &dma->pad);
        if (ret < 0)
                goto error;
diff --git a/drivers/media/platform/xilinx/xilinx-tpg.c b/drivers/media/platform/xilinx/xilinx-tpg.c
index 8bd7e3736019..2ec1f6c4b274 100644
--- a/drivers/media/platform/xilinx/xilinx-tpg.c
+++ b/drivers/media/platform/xilinx/xilinx-tpg.c
@@ -838,7 +838,7 @@ static int xtpg_probe(struct platform_device *pdev)
        subdev->flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
        subdev->entity.ops = &xtpg_media_ops;
-        ret = media_entity_init(&subdev->entity, xtpg->npads, xtpg->pads, 0);
+        ret = media_entity_pads_init(&subdev->entity, xtpg->npads, xtpg->pads);
        if (ret < 0)
                goto error;
diff --git a/drivers/media/platform/xilinx/xilinx-vipp.c b/drivers/media/platform/xilinx/xilinx-vipp.c
index b9bf24fefa5a..e795a4501e8b 100644
--- a/drivers/media/platform/xilinx/xilinx-vipp.c
+++ b/drivers/media/platform/xilinx/xilinx-vipp.c
@@ -156,7 +156,7 @@ static int xvip_graph_build_one(struct xvip_composite_device *xdev,
                        local->name, local_pad->index,
                        remote->name, remote_pad->index);
-                ret = media_entity_create_link(local, local_pad->index,
+                ret = media_create_pad_link(local, local_pad->index,
                                               remote, remote_pad->index,
                                               link_flags);
                if (ret < 0) {
@@ -270,7 +270,7 @@ static int xvip_graph_build_dma(struct xvip_composite_device *xdev)
                        source->name, source_pad->index,
                        sink->name, sink_pad->index);
-                ret = media_entity_create_link(source, source_pad->index,
+                ret = media_create_pad_link(source, source_pad->index,
                                               sink, sink_pad->index,
                                               link_flags);
                if (ret < 0) {
@@ -311,7 +311,7 @@ static int xvip_graph_notify_complete(struct v4l2_async_notifier *notifier)
        if (ret < 0)
                dev_err(xdev->dev, "failed to register subdev nodes\n");
-        return ret;
+        return media_device_register(&xdev->media_dev);
 }
 static int xvip_graph_notify_bound(struct v4l2_async_notifier *notifier,
@@ -573,6 +573,7 @@ static void xvip_composite_v4l2_cleanup(struct xvip_composite_device *xdev)
 {
        v4l2_device_unregister(&xdev->v4l2_dev);
        media_device_unregister(&xdev->media_dev);
+        media_device_cleanup(&xdev->media_dev);
 }
 static int xvip_composite_v4l2_init(struct xvip_composite_device *xdev)
@@ -584,19 +585,14 @@ static int xvip_composite_v4l2_init(struct xvip_composite_device *xdev)
                sizeof(xdev->media_dev.model));
        xdev->media_dev.hw_revision = 0;
-        ret = media_device_register(&xdev->media_dev);
+        media_device_init(&xdev->media_dev);
-        if (ret < 0) {
-                dev_err(xdev->dev, "media device registration failed (%d)\n",
-                        ret);
-                return ret;
-        }
        xdev->v4l2_dev.mdev = &xdev->media_dev;
        ret = v4l2_device_register(xdev->dev, &xdev->v4l2_dev);
        if (ret < 0) {
                dev_err(xdev->dev, "V4L2 device registration failed (%d)\n",
                        ret);
-                media_device_unregister(&xdev->media_dev);
+                media_device_cleanup(&xdev->media_dev);
                return ret;
        }
diff --git a/drivers/media/usb/au0828/au0828-cards.c b/drivers/media/usb/au0828/au0828-cards.c
index 6b469e8c4c6e..ca861aea68a5 100644
--- a/drivers/media/usb/au0828/au0828-cards.c
+++ b/drivers/media/usb/au0828/au0828-cards.c
@@ -228,6 +228,10 @@ void au0828_card_analog_fe_setup(struct au0828_dev *dev)
                                "au8522", 0x8e >> 1, NULL);
                if (sd == NULL)
                        pr_err("analog subdev registration failed\n");
+#ifdef CONFIG_MEDIA_CONTROLLER
+                if (sd)
+                        dev->decoder = &sd->entity;
+#endif
        }
        /* Setup tuners */
diff --git a/drivers/media/usb/au0828/au0828-core.c b/drivers/media/usb/au0828/au0828-core.c
index 0934024fb89d..9e29e70a78d7 100644
--- a/drivers/media/usb/au0828/au0828-core.c
+++ b/drivers/media/usb/au0828/au0828-core.c
@@ -27,6 +27,9 @@
 #include <media/v4l2-common.h>
 #include <linux/mutex.h>
+/* Due to enum tuner_pad_index */
+#include <media/tuner.h>
 /*
 * 1 = General debug messages
 * 2 = USB handling
@@ -127,8 +130,23 @@ static int recv_control_msg(struct au0828_dev *dev, u16 request, u32 value,
        return status;
 }
+static void au0828_unregister_media_device(struct au0828_dev *dev)
+{
+#ifdef CONFIG_MEDIA_CONTROLLER
+        if (dev->media_dev) {
+                media_device_unregister(dev->media_dev);
+                media_device_cleanup(dev->media_dev);
+                kfree(dev->media_dev);
+                dev->media_dev = NULL;
+        }
+#endif
+}
 static void au0828_usb_release(struct au0828_dev *dev)
 {
+        au0828_unregister_media_device(dev);
        /* I2C */
        au0828_i2c_unregister(dev);
@@ -136,6 +154,20 @@ static void au0828_usb_release(struct au0828_dev *dev)
 }
 #ifdef CONFIG_VIDEO_AU0828_V4L2
+static void au0828_usb_v4l2_media_release(struct au0828_dev *dev)
+{
+#ifdef CONFIG_MEDIA_CONTROLLER
+        int i;
+        for (i = 0; i < AU0828_MAX_INPUT; i++) {
+                if (AUVI_INPUT(i).type == AU0828_VMUX_UNDEFINED)
+                        return;
+                media_device_unregister_entity(&dev->input_ent[i]);
+        }
+#endif
+}
 static void au0828_usb_v4l2_release(struct v4l2_device *v4l2_dev)
 {
        struct au0828_dev *dev =
@@ -143,6 +175,7 @@ static void au0828_usb_v4l2_release(struct v4l2_device *v4l2_dev)
        v4l2_ctrl_handler_free(&dev->v4l2_ctrl_hdl);
        v4l2_device_unregister(&dev->v4l2_dev);
+        au0828_usb_v4l2_media_release(dev);
        au0828_usb_release(dev);
 }
 #endif
@@ -174,12 +207,123 @@ static void au0828_usb_disconnect(struct usb_interface *interface)
                au0828_analog_unregister(dev);
                v4l2_device_disconnect(&dev->v4l2_dev);
                v4l2_device_put(&dev->v4l2_dev);
+                /*
+                 * No need to call au0828_usb_release() if V4L2 is enabled,
+                 * as this is already called via au0828_usb_v4l2_release()
+                 */
                return;
        }
 #endif
        au0828_usb_release(dev);
 }
+static int au0828_media_device_init(struct au0828_dev *dev,
+                                    struct usb_device *udev)
+{
+#ifdef CONFIG_MEDIA_CONTROLLER
+        struct media_device *mdev;
+        mdev = kzalloc(sizeof(*mdev), GFP_KERNEL);
+        if (!mdev)
+                return -ENOMEM;
+        mdev->dev = &udev->dev;
+        if (!dev->board.name)
+                strlcpy(mdev->model, "unknown au0828", sizeof(mdev->model));
+        else
+                strlcpy(mdev->model, dev->board.name, sizeof(mdev->model));
+        if (udev->serial)
+                strlcpy(mdev->serial, udev->serial, sizeof(mdev->serial));
+        strcpy(mdev->bus_info, udev->devpath);
+        mdev->hw_revision = le16_to_cpu(udev->descriptor.bcdDevice);
+        mdev->driver_version = LINUX_VERSION_CODE;
+        media_device_init(mdev);
+        dev->media_dev = mdev;
+#endif
+        return 0;
+}
+static int au0828_create_media_graph(struct au0828_dev *dev)
+{
+#ifdef CONFIG_MEDIA_CONTROLLER
+        struct media_device *mdev = dev->media_dev;
+        struct media_entity *entity;
+        struct media_entity *tuner = NULL, *decoder = NULL;
+        int i, ret;
+        if (!mdev)
+                return 0;
+        media_device_for_each_entity(entity, mdev) {
+                switch (entity->function) {
+                case MEDIA_ENT_F_TUNER:
+                        tuner = entity;
+                        break;
+                case MEDIA_ENT_F_ATV_DECODER:
+                        decoder = entity;
+                        break;
+                }
+        }
+        /* Analog setup, using tuner as a link */
+        /* Something bad happened! */
+        if (!decoder)
+                return -EINVAL;
+        if (tuner) {
+                ret = media_create_pad_link(tuner, TUNER_PAD_IF_OUTPUT,
+                                            decoder, 0,
+                                            MEDIA_LNK_FL_ENABLED);
+                if (ret)
+                        return ret;
+        }
+        ret = media_create_pad_link(decoder, 1, &dev->vdev.entity, 0,
+                                    MEDIA_LNK_FL_ENABLED);
+        if (ret)
+                return ret;
+        ret = media_create_pad_link(decoder, 2, &dev->vbi_dev.entity, 0,
+                                    MEDIA_LNK_FL_ENABLED);
+        if (ret)
+                return ret;
+        for (i = 0; i < AU0828_MAX_INPUT; i++) {
+                struct media_entity *ent = &dev->input_ent[i];
+                if (AUVI_INPUT(i).type == AU0828_VMUX_UNDEFINED)
+                        break;
+                switch (AUVI_INPUT(i).type) {
+                case AU0828_VMUX_CABLE:
+                case AU0828_VMUX_TELEVISION:
+                case AU0828_VMUX_DVB:
+                        if (!tuner)
+                                break;
+                        ret = media_create_pad_link(ent, 0, tuner,
+                                                    TUNER_PAD_RF_INPUT,
+                                                    MEDIA_LNK_FL_ENABLED);
+                        if (ret)
+                                return ret;
+                        break;
+                case AU0828_VMUX_COMPOSITE:
+                case AU0828_VMUX_SVIDEO:
+                default: /* AU0828_VMUX_DEBUG */
+                        /* FIXME: fix the decoder PAD */
+                        ret = media_create_pad_link(ent, 0, decoder, 0, 0);
+                        if (ret)
+                                return ret;
+                        break;
+                }
+        }
+#endif
+        return 0;
+}
 static int au0828_usb_probe(struct usb_interface *interface,
        const struct usb_device_id *id)
 {
@@ -224,11 +368,23 @@ static int au0828_usb_probe(struct usb_interface *interface,
        dev->boardnr = id->driver_info;
        dev->board = au0828_boards[dev->boardnr];
+        /* Initialize the media controller */
+        retval = au0828_media_device_init(dev, usbdev);
+        if (retval) {
+                pr_err("%s() au0828_media_device_init failed\n",
+                       __func__);
+                mutex_unlock(&dev->lock);
+                kfree(dev);
+                return retval;
+        }
 #ifdef CONFIG_VIDEO_AU0828_V4L2
        dev->v4l2_dev.release = au0828_usb_v4l2_release;
        /* Create the v4l2_device */
+#ifdef CONFIG_MEDIA_CONTROLLER
+        dev->v4l2_dev.mdev = dev->media_dev;
+#endif
        retval = v4l2_device_register(&interface->dev, &dev->v4l2_dev);
        if (retval) {
                pr_err("%s() v4l2_device_register failed\n",
@@ -287,6 +443,21 @@ static int au0828_usb_probe(struct usb_interface *interface,
        mutex_unlock(&dev->lock);
+        retval = au0828_create_media_graph(dev);
+        if (retval) {
+                pr_err("%s() au0282_dev_register failed to create graph\n",
+                       __func__);
+                goto done;
+        }
+#ifdef CONFIG_MEDIA_CONTROLLER
+        retval = media_device_register(dev->media_dev);
+#endif
+done:
+        if (retval < 0)
+                au0828_usb_disconnect(interface);
        return retval;
 }
diff --git a/drivers/media/usb/au0828/au0828-dvb.c b/drivers/media/usb/au0828/au0828-dvb.c
index c267d76f5b3c..94363a3ba400 100644
--- a/drivers/media/usb/au0828/au0828-dvb.c
+++ b/drivers/media/usb/au0828/au0828-dvb.c
@@ -415,6 +415,11 @@ static int dvb_register(struct au0828_dev *dev)
                       result);
                goto fail_adapter;
        }
+#ifdef CONFIG_MEDIA_CONTROLLER_DVB
+        dvb->adapter.mdev = dev->media_dev;
+#endif
        dvb->adapter.priv = dev;
        /* register frontend */
@@ -480,8 +485,15 @@ static int dvb_register(struct au0828_dev *dev)
        dvb->start_count = 0;
        dvb->stop_count = 0;
+        result = dvb_create_media_graph(&dvb->adapter, false);
+        if (result < 0)
+                goto fail_create_graph;
        return 0;
+fail_create_graph:
+        dvb_net_release(&dvb->net);
 fail_fe_conn:
        dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem);
 fail_fe_mem:
diff --git a/drivers/media/usb/au0828/au0828-video.c b/drivers/media/usb/au0828/au0828-video.c
index 0a725a161dd6..8c54fd21022e 100644
--- a/drivers/media/usb/au0828/au0828-video.c
+++ b/drivers/media/usb/au0828/au0828-video.c
@@ -638,6 +638,64 @@ static inline int au0828_isoc_copy(struct au0828_dev *dev, struct urb *urb)
        return rc;
 }
+static int au0828_enable_analog_tuner(struct au0828_dev *dev)
+{
+#ifdef CONFIG_MEDIA_CONTROLLER
+        struct media_device *mdev = dev->media_dev;
+        struct media_entity *source;
+        struct media_link *link, *found_link = NULL;
+        int ret, active_links = 0;
+        if (!mdev || !dev->decoder)
+                return 0;
+        /*
+         * This will find the tuner that is connected into the decoder.
+         * Technically, this is not 100% correct, as the device may be
+         * using an analog input instead of the tuner. However, as we can't
+         * do DVB streaming while the DMA engine is being used for V4L2,
+         * this should be enough for the actual needs.
+         */
+        list_for_each_entry(link, &dev->decoder->links, list) {
+                if (link->sink->entity == dev->decoder) {
+                        found_link = link;
+                        if (link->flags & MEDIA_LNK_FL_ENABLED)
+                                active_links++;
+                        break;
+                }
+        }
+        if (active_links == 1 || !found_link)
+                return 0;
+        source = found_link->source->entity;
+        list_for_each_entry(link, &source->links, list) {
+                struct media_entity *sink;
+                int flags = 0;
+                sink = link->sink->entity;
+                if (sink == dev->decoder)
+                        flags = MEDIA_LNK_FL_ENABLED;
+                ret = media_entity_setup_link(link, flags);
+                if (ret) {
+                        pr_err(
+                                "Couldn't change link %s->%s to %s. Error %d\n",
+                                source->name, sink->name,
+                                flags ? "enabled" : "disabled",
+                                ret);
+                        return ret;
+                } else
+                        au0828_isocdbg(
+                                "link %s->%s was %s\n",
+                                source->name, sink->name,
+                                flags ? "ENABLED" : "disabled");
+        }
+#endif
+        return 0;
+}
 static int queue_setup(struct vb2_queue *vq,
                       unsigned int *nbuffers, unsigned int *nplanes,
                       unsigned int sizes[], void *alloc_ctxs[])
@@ -650,6 +708,8 @@ static int queue_setup(struct vb2_queue *vq,
        *nplanes = 1;
        sizes[0] = size;
+        au0828_enable_analog_tuner(dev);
        return 0;
 }
@@ -1735,6 +1795,69 @@ static int au0828_vb2_setup(struct au0828_dev *dev)
        return 0;
 }
+static void au0828_analog_create_entities(struct au0828_dev *dev)
+{
+#if defined(CONFIG_MEDIA_CONTROLLER)
+        static const char * const inames[] = {
+                [AU0828_VMUX_COMPOSITE] = "Composite",
+                [AU0828_VMUX_SVIDEO] = "S-Video",
+                [AU0828_VMUX_CABLE] = "Cable TV",
+                [AU0828_VMUX_TELEVISION] = "Television",
+                [AU0828_VMUX_DVB] = "DVB",
+                [AU0828_VMUX_DEBUG] = "tv debug"
+        };
+        int ret, i;
+        /* Initialize Video and VBI pads */
+        dev->video_pad.flags = MEDIA_PAD_FL_SINK;
+        ret = media_entity_pads_init(&dev->vdev.entity, 1, &dev->video_pad);
+        if (ret < 0)
+                pr_err("failed to initialize video media entity!\n");
+        dev->vbi_pad.flags = MEDIA_PAD_FL_SINK;
+        ret = media_entity_pads_init(&dev->vbi_dev.entity, 1, &dev->vbi_pad);
+        if (ret < 0)
+                pr_err("failed to initialize vbi media entity!\n");
+        /* Create entities for each input connector */
+        for (i = 0; i < AU0828_MAX_INPUT; i++) {
+                struct media_entity *ent = &dev->input_ent[i];
+                if (AUVI_INPUT(i).type == AU0828_VMUX_UNDEFINED)
+                        break;
+                ent->name = inames[AUVI_INPUT(i).type];
+                ent->flags = MEDIA_ENT_FL_CONNECTOR;
+                dev->input_pad[i].flags = MEDIA_PAD_FL_SOURCE;
+                switch (AUVI_INPUT(i).type) {
+                case AU0828_VMUX_COMPOSITE:
+                        ent->function = MEDIA_ENT_F_CONN_COMPOSITE;
+                        break;
+                case AU0828_VMUX_SVIDEO:
+                        ent->function = MEDIA_ENT_F_CONN_SVIDEO;
+                        break;
+                case AU0828_VMUX_CABLE:
+                case AU0828_VMUX_TELEVISION:
+                case AU0828_VMUX_DVB:
+                        ent->function = MEDIA_ENT_F_CONN_RF;
+                        break;
+                default: /* AU0828_VMUX_DEBUG */
+                        ent->function = MEDIA_ENT_F_CONN_TEST;
+                        break;
+                }
+                ret = media_entity_pads_init(ent, 1, &dev->input_pad[i]);
+                if (ret < 0)
+                        pr_err("failed to initialize input pad[%d]!\n", i);
+                ret = media_device_register_entity(dev->media_dev, ent);
+                if (ret < 0)
+                        pr_err("failed to register input entity %d!\n", i);
+        }
+#endif
+}
 /**************************************************************************/
 int au0828_analog_register(struct au0828_dev *dev,
@@ -1823,6 +1946,9 @@ int au0828_analog_register(struct au0828_dev *dev,
        dev->vbi_dev.queue->lock = &dev->vb_vbi_queue_lock;
        strcpy(dev->vbi_dev.name, "au0828a vbi");
+        /* Init entities at the Media Controller */
+        au0828_analog_create_entities(dev);
        /* initialize videobuf2 stuff */
        retval = au0828_vb2_setup(dev);
        if (retval != 0) {
diff --git a/drivers/media/usb/au0828/au0828.h b/drivers/media/usb/au0828/au0828.h
index 60b59391ea2a..8276072bc55a 100644
--- a/drivers/media/usb/au0828/au0828.h
+++ b/drivers/media/usb/au0828/au0828.h
@@ -33,6 +33,7 @@
 #include <media/v4l2-device.h>
 #include <media/v4l2-ctrls.h>
 #include <media/v4l2-fh.h>
+#include <media/media-device.h>
 /* DVB */
 #include "demux.h"
@@ -93,7 +94,6 @@ struct au0828_board {
        unsigned char has_ir_i2c:1;
        unsigned char has_analog:1;
        struct au0828_input input[AU0828_MAX_INPUT];
 };
 struct au0828_dvb {
@@ -276,6 +276,14 @@ struct au0828_dev {
        /* Preallocated transfer digital transfer buffers */
        char *dig_transfer_buffer[URB_COUNT];
+#ifdef CONFIG_MEDIA_CONTROLLER
+        struct media_device *media_dev;
+        struct media_pad video_pad, vbi_pad;
+        struct media_entity *decoder;
+        struct media_entity input_ent[AU0828_MAX_INPUT];
+        struct media_pad input_pad[AU0828_MAX_INPUT];
+#endif
 };
diff --git a/drivers/media/usb/cx231xx/cx231xx-cards.c b/drivers/media/usb/cx231xx/cx231xx-cards.c
index 89dc695c696e..620b83d03f75 100644
--- a/drivers/media/usb/cx231xx/cx231xx-cards.c
+++ b/drivers/media/usb/cx231xx/cx231xx-cards.c
@@ -1172,6 +1172,7 @@ static void cx231xx_unregister_media_device(struct cx231xx *dev)
 #ifdef CONFIG_MEDIA_CONTROLLER
        if (dev->media_dev) {
                media_device_unregister(dev->media_dev);
+                media_device_cleanup(dev->media_dev);
                kfree(dev->media_dev);
                dev->media_dev = NULL;
        }
@@ -1185,8 +1186,6 @@ static void cx231xx_unregister_media_device(struct cx231xx *dev)
 */
 void cx231xx_release_resources(struct cx231xx *dev)
 {
-        cx231xx_unregister_media_device(dev);
        cx231xx_release_analog_resources(dev);
        cx231xx_remove_from_devlist(dev);
@@ -1199,22 +1198,23 @@ void cx231xx_release_resources(struct cx231xx *dev)
        /* delete v4l2 device */
        v4l2_device_unregister(&dev->v4l2_dev);
+        cx231xx_unregister_media_device(dev);
        usb_put_dev(dev->udev);
        /* Mark device as unused */
        clear_bit(dev->devno, &cx231xx_devused);
 }
-static void cx231xx_media_device_register(struct cx231xx *dev,
+static int cx231xx_media_device_init(struct cx231xx *dev,
-                                          struct usb_device *udev)
+                                      struct usb_device *udev)
 {
 #ifdef CONFIG_MEDIA_CONTROLLER
        struct media_device *mdev;
-        int ret;
        mdev = kzalloc(sizeof(*mdev), GFP_KERNEL);
        if (!mdev)
-                return;
+                return -ENOMEM;
        mdev->dev = dev->dev;
        strlcpy(mdev->model, dev->board.name, sizeof(mdev->model));
@@ -1224,35 +1224,30 @@ static void cx231xx_media_device_register(struct cx231xx *dev,
        mdev->hw_revision = le16_to_cpu(udev->descriptor.bcdDevice);
        mdev->driver_version = LINUX_VERSION_CODE;
-        ret = media_device_register(mdev);
+        media_device_init(mdev);
-        if (ret) {
-                dev_err(dev->dev,
-                        "Couldn't create a media device. Error: %d\n",
-                        ret);
-                kfree(mdev);
-                return;
-        }
        dev->media_dev = mdev;
 #endif
+        return 0;
 }
-static void cx231xx_create_media_graph(struct cx231xx *dev)
+static int cx231xx_create_media_graph(struct cx231xx *dev)
 {
 #ifdef CONFIG_MEDIA_CONTROLLER
        struct media_device *mdev = dev->media_dev;
        struct media_entity *entity;
        struct media_entity *tuner = NULL, *decoder = NULL;
+        int ret;
        if (!mdev)
-                return;
+                return 0;
        media_device_for_each_entity(entity, mdev) {
-                switch (entity->type) {
+                switch (entity->function) {
-                case MEDIA_ENT_T_V4L2_SUBDEV_TUNER:
+                case MEDIA_ENT_F_TUNER:
                        tuner = entity;
                        break;
-                case MEDIA_ENT_T_V4L2_SUBDEV_DECODER:
+                case MEDIA_ENT_F_ATV_DECODER:
                        decoder = entity;
                        break;
                }
@@ -1261,16 +1256,24 @@ static void cx231xx_create_media_graph(struct cx231xx *dev)
        /* Analog setup, using tuner as a link */
        if (!decoder)
-                return;
+                return 0;
-        if (tuner)
+        if (tuner) {
-                media_entity_create_link(tuner, 0, decoder, 0,
+                ret = media_create_pad_link(tuner, TUNER_PAD_IF_OUTPUT, decoder, 0,
-                                         MEDIA_LNK_FL_ENABLED);
+                                            MEDIA_LNK_FL_ENABLED);
-        media_entity_create_link(decoder, 1, &dev->vdev.entity, 0,
+                if (ret < 0)
-                                 MEDIA_LNK_FL_ENABLED);
+                        return ret;
-        media_entity_create_link(decoder, 2, &dev->vbi_dev.entity, 0,
+        }
-                                 MEDIA_LNK_FL_ENABLED);
+        ret = media_create_pad_link(decoder, 1, &dev->vdev.entity, 0,
+                                    MEDIA_LNK_FL_ENABLED);
+        if (ret < 0)
+                return ret;
+        ret = media_create_pad_link(decoder, 2, &dev->vbi_dev.entity, 0,
+                                    MEDIA_LNK_FL_ENABLED);
+        if (ret < 0)
+                return ret;
 #endif
+        return 0;
 }
 /*
@@ -1660,8 +1663,12 @@ static int cx231xx_usb_probe(struct usb_interface *interface,
        /* save our data pointer in this interface device */
        usb_set_intfdata(interface, dev);
-        /* Register the media controller */
+        /* Initialize the media controller */
-        cx231xx_media_device_register(dev, udev);
+        retval = cx231xx_media_device_init(dev, udev);
+        if (retval) {
+                dev_err(d, "cx231xx_media_device_init failed\n");
+                goto err_media_init;
+        }
        /* Create v4l2 device */
 #ifdef CONFIG_MEDIA_CONTROLLER
@@ -1732,9 +1739,19 @@ static int cx231xx_usb_probe(struct usb_interface *interface,
        /* load other modules required */
        request_modules(dev);
-        cx231xx_create_media_graph(dev);
+        retval = cx231xx_create_media_graph(dev);
+        if (retval < 0)
+                goto done;
+#ifdef CONFIG_MEDIA_CONTROLLER
+        retval = media_device_register(dev->media_dev);
+#endif
+done:
+        if (retval < 0)
+                cx231xx_release_resources(dev);
+        return retval;
-        return 0;
 err_video_alt:
        /* cx231xx_uninit_dev: */
        cx231xx_close_extension(dev);
@@ -1746,6 +1763,8 @@ err_video_alt:
 err_init:
        v4l2_device_unregister(&dev->v4l2_dev);
 err_v4l2:
+        cx231xx_unregister_media_device(dev);
+err_media_init:
        usb_set_intfdata(interface, NULL);
 err_if:
        usb_put_dev(udev);
diff --git a/drivers/media/usb/cx231xx/cx231xx-dvb.c b/drivers/media/usb/cx231xx/cx231xx-dvb.c
index e3594b9fab4a..b8d5b2be9293 100644
--- a/drivers/media/usb/cx231xx/cx231xx-dvb.c
+++ b/drivers/media/usb/cx231xx/cx231xx-dvb.c
@@ -551,10 +551,14 @@ static int register_dvb(struct cx231xx_dvb *dvb,
        /* register network adapter */
        dvb_net_init(&dvb->adapter, &dvb->net, &dvb->demux.dmx);
-        dvb_create_media_graph(&dvb->adapter);
+        result = dvb_create_media_graph(&dvb->adapter, false);
+        if (result < 0)
+                goto fail_create_graph;
        return 0;
+fail_create_graph:
+        dvb_net_release(&dvb->net);
 fail_fe_conn:
        dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem);
 fail_fe_mem:
diff --git a/drivers/media/usb/cx231xx/cx231xx-video.c b/drivers/media/usb/cx231xx/cx231xx-video.c
index a70850fe6235..9b88cd8127ac 100644
--- a/drivers/media/usb/cx231xx/cx231xx-video.c
+++ b/drivers/media/usb/cx231xx/cx231xx-video.c
@@ -106,7 +106,7 @@ static int cx231xx_enable_analog_tuner(struct cx231xx *dev)
        struct media_device *mdev = dev->media_dev;
        struct media_entity  *entity, *decoder = NULL, *source;
        struct media_link *link, *found_link = NULL;
-        int i, ret, active_links = 0;
+        int ret, active_links = 0;
        if (!mdev)
                return 0;
@@ -119,7 +119,7 @@ static int cx231xx_enable_analog_tuner(struct cx231xx *dev)
         * this should be enough for the actual needs.
         */
        media_device_for_each_entity(entity, mdev) {
-                if (entity->type == MEDIA_ENT_T_V4L2_SUBDEV_DECODER) {
+                if (entity->function == MEDIA_ENT_F_ATV_DECODER) {
                        decoder = entity;
                        break;
                }
@@ -127,8 +127,7 @@ static int cx231xx_enable_analog_tuner(struct cx231xx *dev)
        if (!decoder)
                return 0;
-        for (i = 0; i < decoder->num_links; i++) {
+        list_for_each_entry(link, &decoder->links, list) {
-                link = &decoder->links[i];
                if (link->sink->entity == decoder) {
                        found_link = link;
                        if (link->flags & MEDIA_LNK_FL_ENABLED)
@@ -141,11 +140,10 @@ static int cx231xx_enable_analog_tuner(struct cx231xx *dev)
                return 0;
        source = found_link->source->entity;
-        for (i = 0; i < source->num_links; i++) {
+        list_for_each_entry(link, &source->links, list) {
                struct media_entity *sink;
                int flags = 0;
-                link = &source->links[i];
                sink = link->sink->entity;
                if (sink == entity)
@@ -2177,7 +2175,7 @@ int cx231xx_register_analog_devices(struct cx231xx *dev)
        cx231xx_vdev_init(dev, &dev->vdev, &cx231xx_video_template, "video");
 #if defined(CONFIG_MEDIA_CONTROLLER)
        dev->video_pad.flags = MEDIA_PAD_FL_SINK;
-        ret = media_entity_init(&dev->vdev.entity, 1, &dev->video_pad, 0);
+        ret = media_entity_pads_init(&dev->vdev.entity, 1, &dev->video_pad);
        if (ret < 0)
                dev_err(dev->dev, "failed to initialize video media entity!\n");
 #endif
@@ -2204,7 +2202,7 @@ int cx231xx_register_analog_devices(struct cx231xx *dev)
 #if defined(CONFIG_MEDIA_CONTROLLER)
        dev->vbi_pad.flags = MEDIA_PAD_FL_SINK;
-        ret = media_entity_init(&dev->vbi_dev.entity, 1, &dev->vbi_pad, 0);
+        ret = media_entity_pads_init(&dev->vbi_dev.entity, 1, &dev->vbi_pad);
        if (ret < 0)
                dev_err(dev->dev, "failed to initialize vbi media entity!\n");
 #endif
diff --git a/drivers/media/usb/dvb-usb-v2/dvb_usb_core.c b/drivers/media/usb/dvb-usb-v2/dvb_usb_core.c
index f5df9eaba04f..f0565bf3673e 100644
--- a/drivers/media/usb/dvb-usb-v2/dvb_usb_core.c
+++ b/drivers/media/usb/dvb-usb-v2/dvb_usb_core.c
@@ -400,17 +400,16 @@ skip_feed_stop:
        return ret;
 }
-static void dvb_usbv2_media_device_register(struct dvb_usb_adapter *adap)
+static int dvb_usbv2_media_device_init(struct dvb_usb_adapter *adap)
 {
 #ifdef CONFIG_MEDIA_CONTROLLER_DVB
        struct media_device *mdev;
        struct dvb_usb_device *d = adap_to_d(adap);
        struct usb_device *udev = d->udev;
-        int ret;
        mdev = kzalloc(sizeof(*mdev), GFP_KERNEL);
        if (!mdev)
-                return;
+                return -ENOMEM;
        mdev->dev = &udev->dev;
        strlcpy(mdev->model, d->name, sizeof(mdev->model));
@@ -420,19 +419,21 @@ static void dvb_usbv2_media_device_register(struct dvb_usb_adapter *adap)
        mdev->hw_revision = le16_to_cpu(udev->descriptor.bcdDevice);
        mdev->driver_version = LINUX_VERSION_CODE;
-        ret = media_device_register(mdev);
+        media_device_init(mdev);
-        if (ret) {
-                dev_err(&d->udev->dev,
-                        "Couldn't create a media device. Error: %d\n",
-                        ret);
-                kfree(mdev);
-                return;
-        }
        dvb_register_media_controller(&adap->dvb_adap, mdev);
        dev_info(&d->udev->dev, "media controller created\n");
+#endif
+        return 0;
+}
+static int dvb_usbv2_media_device_register(struct dvb_usb_adapter *adap)
+{
+#ifdef CONFIG_MEDIA_CONTROLLER_DVB
+        return media_device_register(adap->dvb_adap.mdev);
+#else
+        return 0;
 #endif
 }
@@ -444,6 +445,7 @@ static void dvb_usbv2_media_device_unregister(struct dvb_usb_adapter *adap)
                return;
        media_device_unregister(adap->dvb_adap.mdev);
+        media_device_cleanup(adap->dvb_adap.mdev);
        kfree(adap->dvb_adap.mdev);
        adap->dvb_adap.mdev = NULL;
@@ -467,7 +469,12 @@ static int dvb_usbv2_adapter_dvb_init(struct dvb_usb_adapter *adap)
        adap->dvb_adap.priv = adap;
-        dvb_usbv2_media_device_register(adap);
+        ret = dvb_usbv2_media_device_init(adap);
+        if (ret < 0) {
+                dev_dbg(&d->udev->dev, "%s: dvb_usbv2_media_device_init() failed=%d\n",
+                                __func__, ret);
+                goto err_dvb_register_mc;
+        }
        if (d->props->read_mac_address) {
                ret = d->props->read_mac_address(adap,
@@ -518,6 +525,7 @@ err_dvb_dmxdev_init:
        dvb_dmx_release(&adap->demux);
 err_dvb_dmx_init:
        dvb_usbv2_media_device_unregister(adap);
+err_dvb_register_mc:
        dvb_unregister_adapter(&adap->dvb_adap);
 err_dvb_register_adapter:
        adap->dvb_adap.priv = NULL;
@@ -534,7 +542,6 @@ static int dvb_usbv2_adapter_dvb_exit(struct dvb_usb_adapter *adap)
                adap->demux.dmx.close(&adap->demux.dmx);
                dvb_dmxdev_release(&adap->dmxdev);
                dvb_dmx_release(&adap->demux);
-                dvb_usbv2_media_device_unregister(adap);
                dvb_unregister_adapter(&adap->dvb_adap);
        }
@@ -698,9 +705,13 @@ static int dvb_usbv2_adapter_frontend_init(struct dvb_usb_adapter *adap)
                }
        }
-        dvb_create_media_graph(&adap->dvb_adap);
+        ret = dvb_create_media_graph(&adap->dvb_adap, true);
+        if (ret < 0)
+                goto err_dvb_unregister_frontend;
-        return 0;
+        ret = dvb_usbv2_media_device_register(adap);
+        return ret;
 err_dvb_unregister_frontend:
        for (i = count_registered - 1; i >= 0; i--)
@@ -840,6 +851,7 @@ static int dvb_usbv2_adapter_exit(struct dvb_usb_device *d)
                        dvb_usbv2_adapter_dvb_exit(&d->adapter[i]);
                        dvb_usbv2_adapter_stream_exit(&d->adapter[i]);
                        dvb_usbv2_adapter_frontend_exit(&d->adapter[i]);
+                        dvb_usbv2_media_device_unregister(&d->adapter[i]);
                }
        }
diff --git a/drivers/media/usb/dvb-usb-v2/mxl111sf.c b/drivers/media/usb/dvb-usb-v2/mxl111sf.c
index 1710f9038d75..b669deccc34c 100644
--- a/drivers/media/usb/dvb-usb-v2/mxl111sf.c
+++ b/drivers/media/usb/dvb-usb-v2/mxl111sf.c
@@ -10,6 +10,7 @@
 #include <linux/vmalloc.h>
 #include <linux/i2c.h>
+#include <media/tuner.h>
 #include "mxl111sf.h"
 #include "mxl111sf-reg.h"
@@ -868,6 +869,10 @@ static struct mxl111sf_tuner_config mxl_tuner_config = {
 static int mxl111sf_attach_tuner(struct dvb_usb_adapter *adap)
 {
        struct mxl111sf_state *state = adap_to_priv(adap);
+#ifdef CONFIG_MEDIA_CONTROLLER_DVB
+        struct media_device *mdev = dvb_get_media_controller(&adap->dvb_adap);
+        int ret;
+#endif
        int i;
        pr_debug("%s()\n", __func__);
@@ -879,6 +884,21 @@ static int mxl111sf_attach_tuner(struct dvb_usb_adapter *adap)
                adap->fe[i]->ops.read_signal_strength = adap->fe[i]->ops.tuner_ops.get_rf_strength;
        }
+#ifdef CONFIG_MEDIA_CONTROLLER_DVB
+        state->tuner.function = MEDIA_ENT_F_TUNER;
+        state->tuner.name = "mxl111sf tuner";
+        state->tuner_pads[TUNER_PAD_RF_INPUT].flags = MEDIA_PAD_FL_SINK;
+        state->tuner_pads[TUNER_PAD_IF_OUTPUT].flags = MEDIA_PAD_FL_SOURCE;
+        ret = media_entity_pads_init(&state->tuner,
+                                     TUNER_NUM_PADS, state->tuner_pads);
+        if (ret)
+                return ret;
+        ret = media_device_register_entity(mdev, &state->tuner);
+        if (ret)
+                return ret;
+#endif
        return 0;
 }
diff --git a/drivers/media/usb/dvb-usb-v2/mxl111sf.h b/drivers/media/usb/dvb-usb-v2/mxl111sf.h
index ee70df1f1e94..846260e0eec0 100644
--- a/drivers/media/usb/dvb-usb-v2/mxl111sf.h
+++ b/drivers/media/usb/dvb-usb-v2/mxl111sf.h
@@ -17,6 +17,7 @@
 #define DVB_USB_LOG_PREFIX "mxl111sf"
 #include "dvb_usb.h"
 #include <media/tveeprom.h>
+#include <media/media-entity.h>
 #define MXL_EP1_REG_READ     1
 #define MXL_EP2_REG_WRITE    2
@@ -85,6 +86,10 @@ struct mxl111sf_state {
        struct mutex fe_lock;
        u8 num_frontends;
        struct mxl111sf_adap_state adap_state[3];
+#ifdef CONFIG_MEDIA_CONTROLLER_DVB
+        struct media_entity tuner;
+        struct media_pad tuner_pads[2];
+#endif
 };
 int mxl111sf_read_reg(struct mxl111sf_state *state, u8 addr, u8 *data);
diff --git a/drivers/media/usb/dvb-usb/dvb-usb-dvb.c b/drivers/media/usb/dvb-usb/dvb-usb-dvb.c
index 8a260c854653..9ddfcab268be 100644
--- a/drivers/media/usb/dvb-usb/dvb-usb-dvb.c
+++ b/drivers/media/usb/dvb-usb/dvb-usb-dvb.c
@@ -95,17 +95,16 @@ static int dvb_usb_stop_feed(struct dvb_demux_feed *dvbdmxfeed)
        return dvb_usb_ctrl_feed(dvbdmxfeed, 0);
 }
-static void dvb_usb_media_device_register(struct dvb_usb_adapter *adap)
+static int dvb_usb_media_device_init(struct dvb_usb_adapter *adap)
 {
 #ifdef CONFIG_MEDIA_CONTROLLER_DVB
        struct media_device *mdev;
        struct dvb_usb_device *d = adap->dev;
        struct usb_device *udev = d->udev;
-        int ret;
        mdev = kzalloc(sizeof(*mdev), GFP_KERNEL);
        if (!mdev)
-                return;
+                return -ENOMEM;
        mdev->dev = &udev->dev;
        strlcpy(mdev->model, d->desc->name, sizeof(mdev->model));
@@ -115,18 +114,22 @@ static void dvb_usb_media_device_register(struct dvb_usb_adapter *adap)
        mdev->hw_revision = le16_to_cpu(udev->descriptor.bcdDevice);
        mdev->driver_version = LINUX_VERSION_CODE;
-        ret = media_device_register(mdev);
+        media_device_init(mdev);
-        if (ret) {
-                dev_err(&d->udev->dev,
-                        "Couldn't create a media device. Error: %d\n",
-                        ret);
-                kfree(mdev);
-                return;
-        }
        dvb_register_media_controller(&adap->dvb_adap, mdev);
        dev_info(&d->udev->dev, "media controller created\n");
 #endif
+        return 0;
+}
+static int  dvb_usb_media_device_register(struct dvb_usb_adapter *adap)
+{
+#ifdef CONFIG_MEDIA_CONTROLLER_DVB
+        return media_device_register(adap->dvb_adap.mdev);
+#else
+        return 0;
+#endif
 }
 static void dvb_usb_media_device_unregister(struct dvb_usb_adapter *adap)
@@ -136,6 +139,7 @@ static void dvb_usb_media_device_unregister(struct dvb_usb_adapter *adap)
                return;
        media_device_unregister(adap->dvb_adap.mdev);
+        media_device_cleanup(adap->dvb_adap.mdev);
        kfree(adap->dvb_adap.mdev);
        adap->dvb_adap.mdev = NULL;
 #endif
@@ -154,7 +158,11 @@ int dvb_usb_adapter_dvb_init(struct dvb_usb_adapter *adap, short *adapter_nums)
        }
        adap->dvb_adap.priv = adap;
-        dvb_usb_media_device_register(adap);
+        ret = dvb_usb_media_device_init(adap);
+        if (ret < 0) {
+                deb_info("dvb_usb_media_device_init failed: error %d", ret);
+                goto err_mc;
+        }
        if (adap->dev->props.read_mac_address) {
                if (adap->dev->props.read_mac_address(adap->dev, adap->dvb_adap.proposed_mac) == 0)
@@ -204,6 +212,7 @@ err_dmx_dev:
        dvb_dmx_release(&adap->demux);
 err_dmx:
        dvb_usb_media_device_unregister(adap);
+err_mc:
        dvb_unregister_adapter(&adap->dvb_adap);
 err:
        return ret;
@@ -318,10 +327,16 @@ int dvb_usb_adapter_frontend_init(struct dvb_usb_adapter *adap)
                adap->num_frontends_initialized++;
        }
+        if (ret)
+                return ret;
-        dvb_create_media_graph(&adap->dvb_adap);
+        ret = dvb_create_media_graph(&adap->dvb_adap, true);
+        if (ret)
+                return ret;
-        return 0;
+        ret = dvb_usb_media_device_register(adap);
+        return ret;
 }
 int dvb_usb_adapter_frontend_exit(struct dvb_usb_adapter *adap)
diff --git a/drivers/media/usb/siano/smsusb.c b/drivers/media/usb/siano/smsusb.c
index c945e4c2fbd4..8abbd3cc8eba 100644
--- a/drivers/media/usb/siano/smsusb.c
+++ b/drivers/media/usb/siano/smsusb.c
@@ -361,10 +361,11 @@ static void *siano_media_device_register(struct smsusb_device_t *dev,
        mdev->hw_revision = le16_to_cpu(udev->descriptor.bcdDevice);
        mdev->driver_version = LINUX_VERSION_CODE;
+        media_device_init(mdev);
        ret = media_device_register(mdev);
        if (ret) {
-                pr_err("Couldn't create a media device. Error: %d\n",
+                media_device_cleanup(mdev);
-                        ret);
                kfree(mdev);
                return NULL;
        }
diff --git a/drivers/media/usb/uvc/uvc_driver.c b/drivers/media/usb/uvc/uvc_driver.c
index 39abbafad796..4e7148815a78 100644
--- a/drivers/media/usb/uvc/uvc_driver.c
+++ b/drivers/media/usb/uvc/uvc_driver.c
@@ -1656,6 +1656,7 @@ static void uvc_delete(struct uvc_device *dev)
 #ifdef CONFIG_MEDIA_CONTROLLER
        if (media_devnode_is_registered(&dev->mdev.devnode))
                media_device_unregister(&dev->mdev);
+        media_device_cleanup(&dev->mdev);
 #endif
        list_for_each_safe(p, n, &dev->chains) {
@@ -1906,7 +1907,7 @@ static int uvc_probe(struct usb_interface *intf,
                        "linux-uvc-devel mailing list.\n");
        }
-        /* Register the media and V4L2 devices. */
+        /* Initialize the media device and register the V4L2 device. */
 #ifdef CONFIG_MEDIA_CONTROLLER
        dev->mdev.dev = &intf->dev;
        strlcpy(dev->mdev.model, dev->name, sizeof(dev->mdev.model));
@@ -1916,8 +1917,7 @@ static int uvc_probe(struct usb_interface *intf,
        strcpy(dev->mdev.bus_info, udev->devpath);
        dev->mdev.hw_revision = le16_to_cpu(udev->descriptor.bcdDevice);
        dev->mdev.driver_version = LINUX_VERSION_CODE;
-        if (media_device_register(&dev->mdev) < 0)
+        media_device_init(&dev->mdev);
-                goto error;
        dev->vdev.mdev = &dev->mdev;
 #endif
@@ -1936,6 +1936,11 @@ static int uvc_probe(struct usb_interface *intf,
        if (uvc_register_chains(dev) < 0)
                goto error;
+#ifdef CONFIG_MEDIA_CONTROLLER
+        /* Register the media device node */
+        if (media_device_register(&dev->mdev) < 0)
+                goto error;
+#endif
        /* Save our data pointer in the interface data. */
        usb_set_intfdata(intf, dev);
diff --git a/drivers/media/usb/uvc/uvc_entity.c b/drivers/media/usb/uvc/uvc_entity.c
index dc56a59ecadc..ac386bb547e6 100644
--- a/drivers/media/usb/uvc/uvc_entity.c
+++ b/drivers/media/usb/uvc/uvc_entity.c
@@ -19,12 +19,8 @@
 #include "uvcvideo.h"
-/* ------------------------------------------------------------------------
+static int uvc_mc_create_links(struct uvc_video_chain *chain,
- * Video subdevices registration and unregistration
+                                    struct uvc_entity *entity)
- */
-static int uvc_mc_register_entity(struct uvc_video_chain *chain,
-        struct uvc_entity *entity)
 {
        const u32 flags = MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE;
        struct media_entity *sink;
@@ -56,16 +52,13 @@ static int uvc_mc_register_entity(struct uvc_video_chain *chain,
                        continue;
                remote_pad = remote->num_pads - 1;
-                ret = media_entity_create_link(source, remote_pad,
+                ret = media_create_pad_link(source, remote_pad,
                                               sink, i, flags);
                if (ret < 0)
                        return ret;
        }
-        if (UVC_ENTITY_TYPE(entity) == UVC_TT_STREAMING)
+        return 0;
-                return 0;
-        return v4l2_device_register_subdev(&chain->dev->vdev, &entity->subdev);
 }
 static struct v4l2_subdev_ops uvc_subdev_ops = {
@@ -79,7 +72,8 @@ void uvc_mc_cleanup_entity(struct uvc_entity *entity)
                media_entity_cleanup(&entity->vdev->entity);
 }
-static int uvc_mc_init_entity(struct uvc_entity *entity)
+static int uvc_mc_init_entity(struct uvc_video_chain *chain,
+                              struct uvc_entity *entity)
 {
        int ret;
@@ -88,11 +82,17 @@ static int uvc_mc_init_entity(struct uvc_entity *entity)
                strlcpy(entity->subdev.name, entity->name,
                        sizeof(entity->subdev.name));
-                ret = media_entity_init(&entity->subdev.entity,
+                ret = media_entity_pads_init(&entity->subdev.entity,
-                                        entity->num_pads, entity->pads, 0);
+                                        entity->num_pads, entity->pads);
+                if (ret < 0)
+                        return ret;
+                ret = v4l2_device_register_subdev(&chain->dev->vdev,
+                                                  &entity->subdev);
        } else if (entity->vdev != NULL) {
-                ret = media_entity_init(&entity->vdev->entity,
+                ret = media_entity_pads_init(&entity->vdev->entity,
-                                        entity->num_pads, entity->pads, 0);
+                                        entity->num_pads, entity->pads);
                if (entity->flags & UVC_ENTITY_FLAG_DEFAULT)
                        entity->vdev->entity.flags |= MEDIA_ENT_FL_DEFAULT;
        } else
@@ -107,7 +107,7 @@ int uvc_mc_register_entities(struct uvc_video_chain *chain)
        int ret;
        list_for_each_entry(entity, &chain->entities, chain) {
-                ret = uvc_mc_init_entity(entity);
+                ret = uvc_mc_init_entity(chain, entity);
                if (ret < 0) {
                        uvc_printk(KERN_INFO, "Failed to initialize entity for "
                                   "entity %u\n", entity->id);
@@ -116,9 +116,9 @@ int uvc_mc_register_entities(struct uvc_video_chain *chain)
        }
        list_for_each_entry(entity, &chain->entities, chain) {
-                ret = uvc_mc_register_entity(chain, entity);
+                ret = uvc_mc_create_links(chain, entity);
                if (ret < 0) {
-                        uvc_printk(KERN_INFO, "Failed to register entity for "
+                        uvc_printk(KERN_INFO, "Failed to create links for "
                                   "entity %u\n", entity->id);
                        return ret;
                }
diff --git a/drivers/media/v4l2-core/tuner-core.c b/drivers/media/v4l2-core/tuner-core.c
index 581e21ad6801..76496fd282aa 100644
--- a/drivers/media/v4l2-core/tuner-core.c
+++ b/drivers/media/v4l2-core/tuner-core.c
@@ -134,8 +134,9 @@ struct tuner {
        unsigned int        type; /* chip type id */
        void                *config;
        const char          *name;
 #if defined(CONFIG_MEDIA_CONTROLLER)
-        struct media_pad        pad;
+        struct media_pad        pad[TUNER_NUM_PADS];
 #endif
 };
@@ -695,11 +696,12 @@ static int tuner_probe(struct i2c_client *client,
        /* Should be just before return */
 register_client:
 #if defined(CONFIG_MEDIA_CONTROLLER)
-        t->pad.flags = MEDIA_PAD_FL_SOURCE;
+        t->pad[TUNER_PAD_RF_INPUT].flags = MEDIA_PAD_FL_SINK;
-        t->sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV_TUNER;
+        t->pad[TUNER_PAD_IF_OUTPUT].flags = MEDIA_PAD_FL_SOURCE;
+        t->sd.entity.function = MEDIA_ENT_F_TUNER;
        t->sd.entity.name = t->name;
-        ret = media_entity_init(&t->sd.entity, 1, &t->pad, 0);
+        ret = media_entity_pads_init(&t->sd.entity, TUNER_NUM_PADS, &t->pad[0]);
        if (ret < 0) {
                tuner_err("failed to initialize media entity!\n");
                kfree(t);
diff --git a/drivers/media/v4l2-core/v4l2-dev.c b/drivers/media/v4l2-core/v4l2-dev.c
index 6b1eaeddbdb3..d8e5994cccf1 100644
--- a/drivers/media/v4l2-core/v4l2-dev.c
+++ b/drivers/media/v4l2-core/v4l2-dev.c
@@ -194,9 +194,12 @@ static void v4l2_device_release(struct device *cd)
        mutex_unlock(&videodev_lock);
 #if defined(CONFIG_MEDIA_CONTROLLER)
-        if (v4l2_dev->mdev &&
+        if (v4l2_dev->mdev) {
-            vdev->vfl_type != VFL_TYPE_SUBDEV)
+                /* Remove interfaces and interface links */
-                media_device_unregister_entity(&vdev->entity);
+                media_devnode_remove(vdev->intf_devnode);
+                if (vdev->entity.function != MEDIA_ENT_F_UNKNOWN)
+                        media_device_unregister_entity(&vdev->entity);
+        }
 #endif
        /* Do not call v4l2_device_put if there is no release callback set.
@@ -723,6 +726,91 @@ static void determine_valid_ioctls(struct video_device *vdev)
                        BASE_VIDIOC_PRIVATE);
 }
+static int video_register_media_controller(struct video_device *vdev, int type)
+{
+#if defined(CONFIG_MEDIA_CONTROLLER)
+        u32 intf_type;
+        int ret;
+        if (!vdev->v4l2_dev->mdev)
+                return 0;
+        vdev->entity.function = MEDIA_ENT_F_UNKNOWN;
+        switch (type) {
+        case VFL_TYPE_GRABBER:
+                intf_type = MEDIA_INTF_T_V4L_VIDEO;
+                vdev->entity.function = MEDIA_ENT_F_IO_V4L;
+                break;
+        case VFL_TYPE_VBI:
+                intf_type = MEDIA_INTF_T_V4L_VBI;
+                vdev->entity.function = MEDIA_ENT_F_IO_VBI;
+                break;
+        case VFL_TYPE_SDR:
+                intf_type = MEDIA_INTF_T_V4L_SWRADIO;
+                vdev->entity.function = MEDIA_ENT_F_IO_SWRADIO;
+                break;
+        case VFL_TYPE_RADIO:
+                intf_type = MEDIA_INTF_T_V4L_RADIO;
+                /*
+                 * Radio doesn't have an entity at the V4L2 side to represent
+                 * radio input or output. Instead, the audio input/output goes
+                 * via either physical wires or ALSA.
+                 */
+                break;
+        case VFL_TYPE_SUBDEV:
+                intf_type = MEDIA_INTF_T_V4L_SUBDEV;
+                /* Entity will be created via v4l2_device_register_subdev() */
+                break;
+        default:
+                return 0;
+        }
+        if (vdev->entity.function != MEDIA_ENT_F_UNKNOWN) {
+                vdev->entity.name = vdev->name;
+                /* Needed just for backward compatibility with legacy MC API */
+                vdev->entity.info.dev.major = VIDEO_MAJOR;
+                vdev->entity.info.dev.minor = vdev->minor;
+                ret = media_device_register_entity(vdev->v4l2_dev->mdev,
+                                                   &vdev->entity);
+                if (ret < 0) {
+                        printk(KERN_WARNING
+                                "%s: media_device_register_entity failed\n",
+                                __func__);
+                        return ret;
+                }
+        }
+        vdev->intf_devnode = media_devnode_create(vdev->v4l2_dev->mdev,
+                                                  intf_type,
+                                                  0, VIDEO_MAJOR,
+                                                  vdev->minor);
+        if (!vdev->intf_devnode) {
+                media_device_unregister_entity(&vdev->entity);
+                return -ENOMEM;
+        }
+        if (vdev->entity.function != MEDIA_ENT_F_UNKNOWN) {
+                struct media_link *link;
+                link = media_create_intf_link(&vdev->entity,
+                                              &vdev->intf_devnode->intf,
+                                              MEDIA_LNK_FL_ENABLED);
+                if (!link) {
+                        media_devnode_remove(vdev->intf_devnode);
+                        media_device_unregister_entity(&vdev->entity);
+                        return -ENOMEM;
+                }
+        }
+        /* FIXME: how to create the other interface links? */
+#endif
+        return 0;
+}
 /**
 *      __video_register_device - register video4linux devices
 *      @vdev: video device structure we want to register
@@ -918,22 +1006,9 @@ int __video_register_device(struct video_device *vdev, int type, int nr,
        /* Increase v4l2_device refcount */
        v4l2_device_get(vdev->v4l2_dev);
-#if defined(CONFIG_MEDIA_CONTROLLER)
        /* Part 5: Register the entity. */
-        if (vdev->v4l2_dev->mdev &&
+        ret = video_register_media_controller(vdev, type);
-            vdev->vfl_type != VFL_TYPE_SUBDEV) {
-                vdev->entity.type = MEDIA_ENT_T_DEVNODE_V4L;
-                vdev->entity.name = vdev->name;
-                vdev->entity.info.dev.major = VIDEO_MAJOR;
-                vdev->entity.info.dev.minor = vdev->minor;
-                ret = media_device_register_entity(vdev->v4l2_dev->mdev,
-                        &vdev->entity);
-                if (ret < 0)
-                        printk(KERN_WARNING
-                               "%s: media_device_register_entity failed\n",
-                               __func__);
-        }
-#endif
        /* Part 6: Activate this minor. The char device can now be used. */
        set_bit(V4L2_FL_REGISTERED, &vdev->flags);
diff --git a/drivers/media/v4l2-core/v4l2-device.c b/drivers/media/v4l2-core/v4l2-device.c
index 7129e438f29e..06fa5f1b2cff 100644
--- a/drivers/media/v4l2-core/v4l2-device.c
+++ b/drivers/media/v4l2-core/v4l2-device.c
@@ -180,26 +180,26 @@ int v4l2_device_register_subdev(struct v4l2_device *v4l2_dev,
                return -ENODEV;
        sd->v4l2_dev = v4l2_dev;
-        if (sd->internal_ops && sd->internal_ops->registered) {
-                err = sd->internal_ops->registered(sd);
-                if (err)
-                        goto error_module;
-        }
        /* This just returns 0 if either of the two args is NULL */
        err = v4l2_ctrl_add_handler(v4l2_dev->ctrl_handler, sd->ctrl_handler, NULL);
        if (err)
-                goto error_unregister;
+                goto error_module;
 #if defined(CONFIG_MEDIA_CONTROLLER)
        /* Register the entity. */
        if (v4l2_dev->mdev) {
                err = media_device_register_entity(v4l2_dev->mdev, entity);
                if (err < 0)
-                        goto error_unregister;
+                        goto error_module;
        }
 #endif
+        if (sd->internal_ops && sd->internal_ops->registered) {
+                err = sd->internal_ops->registered(sd);
+                if (err)
+                        goto error_unregister;
+        }
        spin_lock(&v4l2_dev->lock);
        list_add_tail(&sd->list, &v4l2_dev->subdevs);
        spin_unlock(&v4l2_dev->lock);
@@ -207,8 +207,9 @@ int v4l2_device_register_subdev(struct v4l2_device *v4l2_dev,
        return 0;
 error_unregister:
-        if (sd->internal_ops && sd->internal_ops->unregistered)
+#if defined(CONFIG_MEDIA_CONTROLLER)
-                sd->internal_ops->unregistered(sd);
+        media_device_unregister_entity(entity);
+#endif
 error_module:
        if (!sd->owner_v4l2_dev)
                module_put(sd->owner);
@@ -258,6 +259,19 @@ int v4l2_device_register_subdev_nodes(struct v4l2_device *v4l2_dev)
 #if defined(CONFIG_MEDIA_CONTROLLER)
                sd->entity.info.dev.major = VIDEO_MAJOR;
                sd->entity.info.dev.minor = vdev->minor;
+                /* Interface is created by __video_register_device() */
+                if (vdev->v4l2_dev->mdev) {
+                        struct media_link *link;
+                        link = media_create_intf_link(&sd->entity,
+                                                      &vdev->intf_devnode->intf,
+                                                      MEDIA_LNK_FL_ENABLED);
+                        if (!link) {
+                                err = -ENOMEM;
+                                goto clean_up;
+                        }
+                }
 #endif
                sd->devnode = vdev;
        }
@@ -294,7 +308,10 @@ void v4l2_device_unregister_subdev(struct v4l2_subdev *sd)
 #if defined(CONFIG_MEDIA_CONTROLLER)
        if (v4l2_dev->mdev) {
-                media_entity_remove_links(&sd->entity);
+                /*
+                 * No need to explicitly remove links, as both pads and
+                 * links are removed by the function below, in the right order
+                 */
                media_device_unregister_entity(&sd->entity);
        }
 #endif
diff --git a/drivers/media/v4l2-core/v4l2-flash-led-class.c b/drivers/media/v4l2-core/v4l2-flash-led-class.c
index 5d673357f75f..fc5ff8b215f9 100644
--- a/drivers/media/v4l2-core/v4l2-flash-led-class.c
+++ b/drivers/media/v4l2-core/v4l2-flash-led-class.c
@@ -651,11 +651,11 @@ struct v4l2_flash *v4l2_flash_init(
        sd->flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
        strlcpy(sd->name, config->dev_name, sizeof(sd->name));
-        ret = media_entity_init(&sd->entity, 0, NULL, 0);
+        ret = media_entity_pads_init(&sd->entity, 0, NULL);
        if (ret < 0)
                return ERR_PTR(ret);
-        sd->entity.type = MEDIA_ENT_T_V4L2_SUBDEV_FLASH;
+        sd->entity.function = MEDIA_ENT_F_FLASH;
        ret = v4l2_flash_init_controls(v4l2_flash, config);
        if (ret < 0)
diff --git a/drivers/media/v4l2-core/v4l2-subdev.c b/drivers/media/v4l2-core/v4l2-subdev.c
index 83615b8fb46a..d63083803144 100644
--- a/drivers/media/v4l2-core/v4l2-subdev.c
+++ b/drivers/media/v4l2-core/v4l2-subdev.c
@@ -526,7 +526,7 @@ static int
 v4l2_subdev_link_validate_get_format(struct media_pad *pad,
                                     struct v4l2_subdev_format *fmt)
 {
-        if (media_entity_type(pad->entity) == MEDIA_ENT_T_V4L2_SUBDEV) {
+        if (is_media_entity_v4l2_subdev(pad->entity)) {
                struct v4l2_subdev *sd =
                        media_entity_to_v4l2_subdev(pad->entity);
@@ -535,9 +535,9 @@ v4l2_subdev_link_validate_get_format(struct media_pad *pad,
                return v4l2_subdev_call(sd, pad, get_fmt, NULL, fmt);
        }
-        WARN(pad->entity->type != MEDIA_ENT_T_DEVNODE_V4L,
+        WARN(pad->entity->function != MEDIA_ENT_F_IO_V4L,
             "Driver bug! Wrong media entity type 0x%08x, entity %s\n",
-             pad->entity->type, pad->entity->name);
+             pad->entity->function, pad->entity->name);
        return -EINVAL;
 }
@@ -584,7 +584,7 @@ void v4l2_subdev_init(struct v4l2_subdev *sd, const struct v4l2_subdev_ops *ops)
        sd->host_priv = NULL;
 #if defined(CONFIG_MEDIA_CONTROLLER)
        sd->entity.name = sd->name;
-        sd->entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
+        sd->entity.function = MEDIA_ENT_F_V4L2_SUBDEV_UNKNOWN;
 #endif
 }
 EXPORT_SYMBOL(v4l2_subdev_init);
diff --git a/drivers/staging/media/davinci_vpfe/dm365_ipipe.c b/drivers/staging/media/davinci_vpfe/dm365_ipipe.c
index c492914768ea..ac78ed2f8bcc 100644
--- a/drivers/staging/media/davinci_vpfe/dm365_ipipe.c
+++ b/drivers/staging/media/davinci_vpfe/dm365_ipipe.c
@@ -1712,8 +1712,11 @@ ipipe_link_setup(struct media_entity *entity, const struct media_pad *local,
        struct vpfe_device *vpfe_dev = to_vpfe_device(ipipe);
        u16 ipipeif_sink = vpfe_dev->vpfe_ipipeif.input;
-        switch (local->index | media_entity_type(remote->entity)) {
+        if (!is_media_entity_v4l2_subdev(remote->entity))
-        case IPIPE_PAD_SINK | MEDIA_ENT_T_V4L2_SUBDEV:
+                return -EINVAL;
+        switch (local->index) {
+        case IPIPE_PAD_SINK:
                if (!(flags & MEDIA_LNK_FL_ENABLED)) {
                        ipipe->input = IPIPE_INPUT_NONE;
                        break;
@@ -1726,7 +1729,7 @@ ipipe_link_setup(struct media_entity *entity, const struct media_pad *local,
                        ipipe->input = IPIPE_INPUT_CCDC;
                break;
-        case IPIPE_PAD_SOURCE | MEDIA_ENT_T_V4L2_SUBDEV:
+        case IPIPE_PAD_SOURCE:
                /* out to RESIZER */
                if (flags & MEDIA_LNK_FL_ENABLED)
                        ipipe->output = IPIPE_OUTPUT_RESIZER;
@@ -1840,7 +1843,7 @@ vpfe_ipipe_init(struct vpfe_ipipe_device *ipipe, struct platform_device *pdev)
        v4l2_ctrl_handler_setup(&ipipe->ctrls);
        sd->ctrl_handler = &ipipe->ctrls;
-        return media_entity_init(me, IPIPE_PADS_NUM, pads, 0);
+        return media_entity_pads_init(me, IPIPE_PADS_NUM, pads);
 }
 /*
diff --git a/drivers/staging/media/davinci_vpfe/dm365_ipipeif.c b/drivers/staging/media/davinci_vpfe/dm365_ipipeif.c
index 8b230541b1d1..633d6456fdce 100644
--- a/drivers/staging/media/davinci_vpfe/dm365_ipipeif.c
+++ b/drivers/staging/media/davinci_vpfe/dm365_ipipeif.c
@@ -885,9 +885,14 @@ ipipeif_link_setup(struct media_entity *entity, const struct media_pad *local,
        struct v4l2_subdev *sd = media_entity_to_v4l2_subdev(entity);
        struct vpfe_ipipeif_device *ipipeif = v4l2_get_subdevdata(sd);
        struct vpfe_device *vpfe = to_vpfe_device(ipipeif);
+        unsigned int index = local->index;
-        switch (local->index | media_entity_type(remote->entity)) {
+        /* FIXME: this is actually a hack! */
-        case IPIPEIF_PAD_SINK | MEDIA_ENT_T_DEVNODE:
+        if (is_media_entity_v4l2_subdev(remote->entity))
+                index |= 2 << 16;
+        switch (index) {
+        case IPIPEIF_PAD_SINK:
                /* Single shot mode */
                if (!(flags & MEDIA_LNK_FL_ENABLED)) {
                        ipipeif->input = IPIPEIF_INPUT_NONE;
@@ -896,7 +901,7 @@ ipipeif_link_setup(struct media_entity *entity, const struct media_pad *local,
                ipipeif->input = IPIPEIF_INPUT_MEMORY;
                break;
-        case IPIPEIF_PAD_SINK | MEDIA_ENT_T_V4L2_SUBDEV:
+        case IPIPEIF_PAD_SINK | 2 << 16:
                /* read from isif */
                if (!(flags & MEDIA_LNK_FL_ENABLED)) {
                        ipipeif->input = IPIPEIF_INPUT_NONE;
@@ -908,7 +913,7 @@ ipipeif_link_setup(struct media_entity *entity, const struct media_pad *local,
                ipipeif->input = IPIPEIF_INPUT_ISIF;
                break;
-        case IPIPEIF_PAD_SOURCE | MEDIA_ENT_T_V4L2_SUBDEV:
+        case IPIPEIF_PAD_SOURCE | 2 << 16:
                if (!(flags & MEDIA_LNK_FL_ENABLED)) {
                        ipipeif->output = IPIPEIF_OUTPUT_NONE;
                        break;
@@ -971,7 +976,7 @@ vpfe_ipipeif_register_entities(struct vpfe_ipipeif_device *ipipeif,
        ipipeif->video_in.vpfe_dev = vpfe_dev;
        flags = 0;
-        ret = media_entity_create_link(&ipipeif->video_in.video_dev.entity, 0,
+        ret = media_create_pad_link(&ipipeif->video_in.video_dev.entity, 0,
                                        &ipipeif->subdev.entity, 0, flags);
        if (ret < 0)
                goto fail;
@@ -1026,7 +1031,7 @@ int vpfe_ipipeif_init(struct vpfe_ipipeif_device *ipipeif,
        ipipeif->output = IPIPEIF_OUTPUT_NONE;
        me->ops = &ipipeif_media_ops;
-        ret = media_entity_init(me, IPIPEIF_NUM_PADS, pads, 0);
+        ret = media_entity_pads_init(me, IPIPEIF_NUM_PADS, pads);
        if (ret)
                goto fail;
diff --git a/drivers/staging/media/davinci_vpfe/dm365_isif.c b/drivers/staging/media/davinci_vpfe/dm365_isif.c
index 80907b464412..99057892d88d 100644
--- a/drivers/staging/media/davinci_vpfe/dm365_isif.c
+++ b/drivers/staging/media/davinci_vpfe/dm365_isif.c
@@ -1707,9 +1707,14 @@ isif_link_setup(struct media_entity *entity, const struct media_pad *local,
 {
        struct v4l2_subdev *sd = media_entity_to_v4l2_subdev(entity);
        struct vpfe_isif_device *isif = v4l2_get_subdevdata(sd);
+        unsigned int index = local->index;
-        switch (local->index | media_entity_type(remote->entity)) {
+        /* FIXME: this is actually a hack! */
-        case ISIF_PAD_SINK | MEDIA_ENT_T_V4L2_SUBDEV:
+        if (is_media_entity_v4l2_subdev(remote->entity))
+                index |= 2 << 16;
+        switch (index) {
+        case ISIF_PAD_SINK | 2 << 16:
                /* read from decoder/sensor */
                if (!(flags & MEDIA_LNK_FL_ENABLED)) {
                        isif->input = ISIF_INPUT_NONE;
@@ -1720,7 +1725,7 @@ isif_link_setup(struct media_entity *entity, const struct media_pad *local,
                isif->input = ISIF_INPUT_PARALLEL;
                break;
-        case ISIF_PAD_SOURCE | MEDIA_ENT_T_DEVNODE:
+        case ISIF_PAD_SOURCE:
                /* write to memory */
                if (flags & MEDIA_LNK_FL_ENABLED)
                        isif->output = ISIF_OUTPUT_MEMORY;
@@ -1728,7 +1733,7 @@ isif_link_setup(struct media_entity *entity, const struct media_pad *local,
                        isif->output = ISIF_OUTPUT_NONE;
                break;
-        case ISIF_PAD_SOURCE | MEDIA_ENT_T_V4L2_SUBDEV:
+        case ISIF_PAD_SOURCE | 2 << 16:
                if (flags & MEDIA_LNK_FL_ENABLED)
                        isif->output = ISIF_OUTPUT_IPIPEIF;
                else
@@ -1817,7 +1822,7 @@ int vpfe_isif_register_entities(struct vpfe_isif_device *isif,
        isif->video_out.vpfe_dev = vpfe_dev;
        flags = 0;
        /* connect isif to video node */
-        ret = media_entity_create_link(&isif->subdev.entity, 1,
+        ret = media_create_pad_link(&isif->subdev.entity, 1,
                                       &isif->video_out.video_dev.entity,
                                       0, flags);
        if (ret < 0)
@@ -2052,7 +2057,7 @@ int vpfe_isif_init(struct vpfe_isif_device *isif, struct platform_device *pdev)
        isif->input = ISIF_INPUT_NONE;
        isif->output = ISIF_OUTPUT_NONE;
        me->ops = &isif_media_ops;
-        status = media_entity_init(me, ISIF_PADS_NUM, pads, 0);
+        status = media_entity_pads_init(me, ISIF_PADS_NUM, pads);
        if (status)
                goto isif_fail;
        isif->video_out.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
diff --git a/drivers/staging/media/davinci_vpfe/dm365_resizer.c b/drivers/staging/media/davinci_vpfe/dm365_resizer.c
index d892fee3f52f..a91395ce91e1 100644
--- a/drivers/staging/media/davinci_vpfe/dm365_resizer.c
+++ b/drivers/staging/media/davinci_vpfe/dm365_resizer.c
@@ -1648,10 +1648,15 @@ static int resizer_link_setup(struct media_entity *entity,
        struct vpfe_device *vpfe_dev = to_vpfe_device(resizer);
        u16 ipipeif_source = vpfe_dev->vpfe_ipipeif.output;
        u16 ipipe_source = vpfe_dev->vpfe_ipipe.output;
+        unsigned int index = local->index;
+        /* FIXME: this is actually a hack! */
+        if (is_media_entity_v4l2_subdev(remote->entity))
+                index |= 2 << 16;
        if (&resizer->crop_resizer.subdev == sd) {
-                switch (local->index | media_entity_type(remote->entity)) {
+                switch (index) {
-                case RESIZER_CROP_PAD_SINK | MEDIA_ENT_T_V4L2_SUBDEV:
+                case RESIZER_CROP_PAD_SINK | 2 << 16:
                        if (!(flags & MEDIA_LNK_FL_ENABLED)) {
                                resizer->crop_resizer.input =
                                        RESIZER_CROP_INPUT_NONE;
@@ -1671,7 +1676,7 @@ static int resizer_link_setup(struct media_entity *entity,
                                return -EINVAL;
                        break;
-                case RESIZER_CROP_PAD_SOURCE | MEDIA_ENT_T_V4L2_SUBDEV:
+                case RESIZER_CROP_PAD_SOURCE | 2 << 16:
                        if (!(flags & MEDIA_LNK_FL_ENABLED)) {
                                resizer->crop_resizer.output =
                                RESIZER_CROP_OUTPUT_NONE;
@@ -1683,7 +1688,7 @@ static int resizer_link_setup(struct media_entity *entity,
                        resizer->crop_resizer.output = RESIZER_A;
                        break;
-                case RESIZER_CROP_PAD_SOURCE2 | MEDIA_ENT_T_V4L2_SUBDEV:
+                case RESIZER_CROP_PAD_SOURCE2 | 2 << 16:
                        if (!(flags & MEDIA_LNK_FL_ENABLED)) {
                                resizer->crop_resizer.output2 =
                                        RESIZER_CROP_OUTPUT_NONE;
@@ -1699,8 +1704,8 @@ static int resizer_link_setup(struct media_entity *entity,
                        return -EINVAL;
                }
        } else if (&resizer->resizer_a.subdev == sd) {
-                switch (local->index | media_entity_type(remote->entity)) {
+                switch (index) {
-                case RESIZER_PAD_SINK | MEDIA_ENT_T_V4L2_SUBDEV:
+                case RESIZER_PAD_SINK | 2 << 16:
                        if (!(flags & MEDIA_LNK_FL_ENABLED)) {
                                resizer->resizer_a.input = RESIZER_INPUT_NONE;
                                break;
@@ -1710,7 +1715,7 @@ static int resizer_link_setup(struct media_entity *entity,
                        resizer->resizer_a.input = RESIZER_INPUT_CROP_RESIZER;
                        break;
-                case RESIZER_PAD_SOURCE | MEDIA_ENT_T_DEVNODE:
+                case RESIZER_PAD_SOURCE:
                        if (!(flags & MEDIA_LNK_FL_ENABLED)) {
                                resizer->resizer_a.output = RESIZER_OUTPUT_NONE;
                                break;
@@ -1724,8 +1729,8 @@ static int resizer_link_setup(struct media_entity *entity,
                        return -EINVAL;
                }
        } else if (&resizer->resizer_b.subdev == sd) {
-                switch (local->index | media_entity_type(remote->entity)) {
+                switch (index) {
-                case RESIZER_PAD_SINK | MEDIA_ENT_T_V4L2_SUBDEV:
+                case RESIZER_PAD_SINK | 2 << 16:
                        if (!(flags & MEDIA_LNK_FL_ENABLED)) {
                                resizer->resizer_b.input = RESIZER_INPUT_NONE;
                                break;
@@ -1735,7 +1740,7 @@ static int resizer_link_setup(struct media_entity *entity,
                        resizer->resizer_b.input = RESIZER_INPUT_CROP_RESIZER;
                        break;
-                case RESIZER_PAD_SOURCE | MEDIA_ENT_T_DEVNODE:
+                case RESIZER_PAD_SOURCE:
                        if (!(flags & MEDIA_LNK_FL_ENABLED)) {
                                resizer->resizer_b.output = RESIZER_OUTPUT_NONE;
                                break;
@@ -1826,27 +1831,27 @@ int vpfe_resizer_register_entities(struct vpfe_resizer_device *resizer,
        resizer->resizer_b.video_out.vpfe_dev = vpfe_dev;
        /* create link between Resizer Crop----> Resizer A*/
-        ret = media_entity_create_link(&resizer->crop_resizer.subdev.entity, 1,
+        ret = media_create_pad_link(&resizer->crop_resizer.subdev.entity, 1,
                                &resizer->resizer_a.subdev.entity,
                                0, flags);
        if (ret < 0)
                goto out_create_link;
        /* create link between Resizer Crop----> Resizer B*/
-        ret = media_entity_create_link(&resizer->crop_resizer.subdev.entity, 2,
+        ret = media_create_pad_link(&resizer->crop_resizer.subdev.entity, 2,
                                &resizer->resizer_b.subdev.entity,
                                0, flags);
        if (ret < 0)
                goto out_create_link;
        /* create link between Resizer A ----> video out */
-        ret = media_entity_create_link(&resizer->resizer_a.subdev.entity, 1,
+        ret = media_create_pad_link(&resizer->resizer_a.subdev.entity, 1,
                &resizer->resizer_a.video_out.video_dev.entity, 0, flags);
        if (ret < 0)
                goto out_create_link;
        /* create link between Resizer B ----> video out */
-        ret = media_entity_create_link(&resizer->resizer_b.subdev.entity, 1,
+        ret = media_create_pad_link(&resizer->resizer_b.subdev.entity, 1,
                &resizer->resizer_b.video_out.video_dev.entity, 0, flags);
        if (ret < 0)
                goto out_create_link;
@@ -1910,7 +1915,7 @@ int vpfe_resizer_init(struct vpfe_resizer_device *vpfe_rsz,
        vpfe_rsz->crop_resizer.output2 = RESIZER_CROP_OUTPUT_NONE;
        vpfe_rsz->crop_resizer.rsz_device = vpfe_rsz;
        me->ops = &resizer_media_ops;
-        ret = media_entity_init(me, RESIZER_CROP_PADS_NUM, pads, 0);
+        ret = media_entity_pads_init(me, RESIZER_CROP_PADS_NUM, pads);
        if (ret)
                return ret;
@@ -1932,7 +1937,7 @@ int vpfe_resizer_init(struct vpfe_resizer_device *vpfe_rsz,
        vpfe_rsz->resizer_a.output = RESIZER_OUTPUT_NONE;
        vpfe_rsz->resizer_a.rsz_device = vpfe_rsz;
        me->ops = &resizer_media_ops;
-        ret = media_entity_init(me, RESIZER_PADS_NUM, pads, 0);
+        ret = media_entity_pads_init(me, RESIZER_PADS_NUM, pads);
        if (ret)
                return ret;
@@ -1954,7 +1959,7 @@ int vpfe_resizer_init(struct vpfe_resizer_device *vpfe_rsz,
        vpfe_rsz->resizer_b.output = RESIZER_OUTPUT_NONE;
        vpfe_rsz->resizer_b.rsz_device = vpfe_rsz;
        me->ops = &resizer_media_ops;
-        ret = media_entity_init(me, RESIZER_PADS_NUM, pads, 0);
+        ret = media_entity_pads_init(me, RESIZER_PADS_NUM, pads);
        if (ret)
                return ret;
diff --git a/drivers/staging/media/davinci_vpfe/vpfe_mc_capture.c b/drivers/staging/media/davinci_vpfe/vpfe_mc_capture.c
index 69b678ca40c0..ec46f366dd17 100644
--- a/drivers/staging/media/davinci_vpfe/vpfe_mc_capture.c
+++ b/drivers/staging/media/davinci_vpfe/vpfe_mc_capture.c
@@ -445,32 +445,32 @@ static int vpfe_register_entities(struct vpfe_device *vpfe_dev)
                /* if entity has no pads (ex: amplifier),
                   cant establish link */
                if (vpfe_dev->sd[i]->entity.num_pads) {
-                        ret = media_entity_create_link(&vpfe_dev->sd[i]->entity,
+                        ret = media_create_pad_link(&vpfe_dev->sd[i]->entity,
                                0, &vpfe_dev->vpfe_isif.subdev.entity,
                                0, flags);
                        if (ret < 0)
                                goto out_resizer_register;
                }
-        ret = media_entity_create_link(&vpfe_dev->vpfe_isif.subdev.entity, 1,
+        ret = media_create_pad_link(&vpfe_dev->vpfe_isif.subdev.entity, 1,
                                       &vpfe_dev->vpfe_ipipeif.subdev.entity,
                                       0, flags);
        if (ret < 0)
                goto out_resizer_register;
-        ret = media_entity_create_link(&vpfe_dev->vpfe_ipipeif.subdev.entity, 1,
+        ret = media_create_pad_link(&vpfe_dev->vpfe_ipipeif.subdev.entity, 1,
                                       &vpfe_dev->vpfe_ipipe.subdev.entity,
                                       0, flags);
        if (ret < 0)
                goto out_resizer_register;
-        ret = media_entity_create_link(&vpfe_dev->vpfe_ipipe.subdev.entity,
+        ret = media_create_pad_link(&vpfe_dev->vpfe_ipipe.subdev.entity,
                        1, &vpfe_dev->vpfe_resizer.crop_resizer.subdev.entity,
                        0, flags);
        if (ret < 0)
                goto out_resizer_register;
-        ret = media_entity_create_link(&vpfe_dev->vpfe_ipipeif.subdev.entity, 1,
+        ret = media_create_pad_link(&vpfe_dev->vpfe_ipipeif.subdev.entity, 1,
                        &vpfe_dev->vpfe_resizer.crop_resizer.subdev.entity,
                        0, flags);
        if (ret < 0)
diff --git a/drivers/staging/media/davinci_vpfe/vpfe_video.c b/drivers/staging/media/davinci_vpfe/vpfe_video.c
index adb2bc8811ab..3ec7e65a3ffa 100644
--- a/drivers/staging/media/davinci_vpfe/vpfe_video.c
+++ b/drivers/staging/media/davinci_vpfe/vpfe_video.c
@@ -88,7 +88,7 @@ vpfe_video_remote_subdev(struct vpfe_video_device *video, u32 *pad)
 {
        struct media_pad *remote = media_entity_remote_pad(&video->pad);
-        if (remote == NULL || remote->entity->type != MEDIA_ENT_T_V4L2_SUBDEV)
+        if (!remote || !is_media_entity_v4l2_subdev(remote->entity))
                return NULL;
        if (pad)
                *pad = remote->index;
@@ -127,13 +127,14 @@ __vpfe_video_get_format(struct vpfe_video_device *video,
 }
 /* make a note of pipeline details */
-static void vpfe_prepare_pipeline(struct vpfe_video_device *video)
+static int vpfe_prepare_pipeline(struct vpfe_video_device *video)
 {
+        struct media_entity_graph graph;
        struct media_entity *entity = &video->video_dev.entity;
-        struct media_device *mdev = entity->parent;
+        struct media_device *mdev = entity->graph_obj.mdev;
        struct vpfe_pipeline *pipe = &video->pipe;
        struct vpfe_video_device *far_end = NULL;
-        struct media_entity_graph graph;
+        int ret;
        pipe->input_num = 0;
        pipe->output_num = 0;
@@ -144,11 +145,16 @@ static void vpfe_prepare_pipeline(struct vpfe_video_device *video)
                pipe->outputs[pipe->output_num++] = video;
        mutex_lock(&mdev->graph_mutex);
+        ret = media_entity_graph_walk_init(&graph, entity->graph_obj.mdev);
+        if (ret) {
+                mutex_unlock(&video->lock);
+                return -ENOMEM;
+        }
        media_entity_graph_walk_start(&graph, entity);
        while ((entity = media_entity_graph_walk_next(&graph))) {
                if (entity == &video->video_dev.entity)
                        continue;
-                if (media_entity_type(entity) != MEDIA_ENT_T_DEVNODE)
+                if (!is_media_entity_v4l2_io(entity))
                        continue;
                far_end = to_vpfe_video(media_entity_to_video_device(entity));
                if (far_end->type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
@@ -156,7 +162,10 @@ static void vpfe_prepare_pipeline(struct vpfe_video_device *video)
                else
                        pipe->outputs[pipe->output_num++] = far_end;
        }
+        media_entity_graph_walk_cleanup(&graph);
        mutex_unlock(&mdev->graph_mutex);
+        return 0;
 }
 /* update pipe state selected by user */
@@ -165,7 +174,9 @@ static int vpfe_update_pipe_state(struct vpfe_video_device *video)
        struct vpfe_pipeline *pipe = &video->pipe;
        int ret;
-        vpfe_prepare_pipeline(video);
+        ret = vpfe_prepare_pipeline(video);
+        if (ret)
+                return ret;
        /* Find out if there is any input video
          if yes, it is single shot.
@@ -243,8 +254,7 @@ static int vpfe_video_validate_pipeline(struct vpfe_pipeline *pipe)
                /* Retrieve the source format */
                pad = media_entity_remote_pad(pad);
-                if (pad == NULL ||
+                if (!pad || !is_media_entity_v4l2_subdev(pad->entity))
-                        pad->entity->type != MEDIA_ENT_T_V4L2_SUBDEV)
                        break;
                subdev = media_entity_to_v4l2_subdev(pad->entity);
@@ -277,29 +287,35 @@ static int vpfe_video_validate_pipeline(struct vpfe_pipeline *pipe)
 */
 static int vpfe_pipeline_enable(struct vpfe_pipeline *pipe)
 {
-        struct media_entity_graph graph;
        struct media_entity *entity;
        struct v4l2_subdev *subdev;
        struct media_device *mdev;
-        int ret = 0;
+        int ret;
        if (pipe->state == VPFE_PIPELINE_STREAM_CONTINUOUS)
                entity = vpfe_get_input_entity(pipe->outputs[0]);
        else
                entity = &pipe->inputs[0]->video_dev.entity;
-        mdev = entity->parent;
+        mdev = entity->graph_obj.mdev;
        mutex_lock(&mdev->graph_mutex);
-        media_entity_graph_walk_start(&graph, entity);
+        ret = media_entity_graph_walk_init(&pipe->graph,
-        while ((entity = media_entity_graph_walk_next(&graph))) {
+                                           entity->graph_obj.mdev);
+        if (ret)
+                goto out;
+        media_entity_graph_walk_start(&pipe->graph, entity);
+        while ((entity = media_entity_graph_walk_next(&pipe->graph))) {
-                if (media_entity_type(entity) == MEDIA_ENT_T_DEVNODE)
+                if (!is_media_entity_v4l2_subdev(entity))
                        continue;
                subdev = media_entity_to_v4l2_subdev(entity);
                ret = v4l2_subdev_call(subdev, video, s_stream, 1);
                if (ret < 0 && ret != -ENOIOCTLCMD)
                        break;
        }
+out:
+        if (ret)
+                media_entity_graph_walk_cleanup(&pipe->graph);
        mutex_unlock(&mdev->graph_mutex);
        return ret;
 }
@@ -317,7 +333,6 @@ static int vpfe_pipeline_enable(struct vpfe_pipeline *pipe)
 */
 static int vpfe_pipeline_disable(struct vpfe_pipeline *pipe)
 {
-        struct media_entity_graph graph;
        struct media_entity *entity;
        struct v4l2_subdev *subdev;
        struct media_device *mdev;
@@ -328,13 +343,13 @@ static int vpfe_pipeline_disable(struct vpfe_pipeline *pipe)
        else
                entity = &pipe->inputs[0]->video_dev.entity;
-        mdev = entity->parent;
+        mdev = entity->graph_obj.mdev;
        mutex_lock(&mdev->graph_mutex);
-        media_entity_graph_walk_start(&graph, entity);
+        media_entity_graph_walk_start(&pipe->graph, entity);
-        while ((entity = media_entity_graph_walk_next(&graph))) {
+        while ((entity = media_entity_graph_walk_next(&pipe->graph))) {
-                if (media_entity_type(entity) == MEDIA_ENT_T_DEVNODE)
+                if (!is_media_entity_v4l2_subdev(entity))
                        continue;
                subdev = media_entity_to_v4l2_subdev(entity);
                ret = v4l2_subdev_call(subdev, video, s_stream, 0);
@@ -343,6 +358,7 @@ static int vpfe_pipeline_disable(struct vpfe_pipeline *pipe)
        }
        mutex_unlock(&mdev->graph_mutex);
+        media_entity_graph_walk_cleanup(&pipe->graph);
        return ret ? -ETIMEDOUT : 0;
 }
@@ -1600,8 +1616,8 @@ int vpfe_video_init(struct vpfe_video_device *video, const char *name)
        spin_lock_init(&video->irqlock);
        spin_lock_init(&video->dma_queue_lock);
        mutex_init(&video->lock);
-        ret = media_entity_init(&video->video_dev.entity,
+        ret = media_entity_pads_init(&video->video_dev.entity,
-                                1, &video->pad, 0);
+                                1, &video->pad);
        if (ret < 0)
                return ret;
diff --git a/drivers/staging/media/davinci_vpfe/vpfe_video.h b/drivers/staging/media/davinci_vpfe/vpfe_video.h
index 673cefe3ef61..653334d537d3 100644
--- a/drivers/staging/media/davinci_vpfe/vpfe_video.h
+++ b/drivers/staging/media/davinci_vpfe/vpfe_video.h
@@ -52,6 +52,7 @@ enum vpfe_video_state {
 struct vpfe_pipeline {
        /* media pipeline */
        struct media_pipeline           *pipe;
+        struct media_entity_graph       graph;
        /* state of the pipeline, continuous,
         * single-shot or stopped
         */
diff --git a/drivers/staging/media/omap4iss/iss.c b/drivers/staging/media/omap4iss/iss.c
index e27a988540a6..30b473cfb020 100644
--- a/drivers/staging/media/omap4iss/iss.c
+++ b/drivers/staging/media/omap4iss/iss.c
@@ -389,15 +389,15 @@ static irqreturn_t iss_isr(int irq, void *_iss)
 *
 * Return the total number of users of all video device nodes in the pipeline.
 */
-static int iss_pipeline_pm_use_count(struct media_entity *entity)
+static int iss_pipeline_pm_use_count(struct media_entity *entity,
+                                     struct media_entity_graph *graph)
 {
-        struct media_entity_graph graph;
        int use = 0;
-        media_entity_graph_walk_start(&graph, entity);
+        media_entity_graph_walk_start(graph, entity);
-        while ((entity = media_entity_graph_walk_next(&graph))) {
+        while ((entity = media_entity_graph_walk_next(graph))) {
-                if (media_entity_type(entity) == MEDIA_ENT_T_DEVNODE)
+                if (is_media_entity_v4l2_io(entity))
                        use += entity->use_count;
        }
@@ -419,7 +419,7 @@ static int iss_pipeline_pm_power_one(struct media_entity *entity, int change)
 {
        struct v4l2_subdev *subdev;
-        subdev = media_entity_type(entity) == MEDIA_ENT_T_V4L2_SUBDEV
+        subdev = is_media_entity_v4l2_subdev(entity)
               ? media_entity_to_v4l2_subdev(entity) : NULL;
        if (entity->use_count == 0 && change > 0 && subdev) {
@@ -449,29 +449,29 @@ static int iss_pipeline_pm_power_one(struct media_entity *entity, int change)
 *
 * Return 0 on success or a negative error code on failure.
 */
-static int iss_pipeline_pm_power(struct media_entity *entity, int change)
+static int iss_pipeline_pm_power(struct media_entity *entity, int change,
+                                 struct media_entity_graph *graph)
 {
-        struct media_entity_graph graph;
        struct media_entity *first = entity;
        int ret = 0;
        if (!change)
                return 0;
-        media_entity_graph_walk_start(&graph, entity);
+        media_entity_graph_walk_start(graph, entity);
-        while (!ret && (entity = media_entity_graph_walk_next(&graph)))
+        while (!ret && (entity = media_entity_graph_walk_next(graph)))
-                if (media_entity_type(entity) != MEDIA_ENT_T_DEVNODE)
+                if (is_media_entity_v4l2_subdev(entity))
                        ret = iss_pipeline_pm_power_one(entity, change);
        if (!ret)
                return 0;
-        media_entity_graph_walk_start(&graph, first);
+        media_entity_graph_walk_start(graph, first);
-        while ((first = media_entity_graph_walk_next(&graph)) &&
+        while ((first = media_entity_graph_walk_next(graph)) &&
               first != entity)
-                if (media_entity_type(first) != MEDIA_ENT_T_DEVNODE)
+                if (is_media_entity_v4l2_subdev(first))
                        iss_pipeline_pm_power_one(first, -change);
        return ret;
@@ -489,23 +489,24 @@ static int iss_pipeline_pm_power(struct media_entity *entity, int change)
 * off is assumed to never fail. No failure can occur when the use parameter is
 * set to 0.
 */
-int omap4iss_pipeline_pm_use(struct media_entity *entity, int use)
+int omap4iss_pipeline_pm_use(struct media_entity *entity, int use,
+                             struct media_entity_graph *graph)
 {
        int change = use ? 1 : -1;
        int ret;
-        mutex_lock(&entity->parent->graph_mutex);
+        mutex_lock(&entity->graph_obj.mdev->graph_mutex);
        /* Apply use count to node. */
        entity->use_count += change;
        WARN_ON(entity->use_count < 0);
        /* Apply power change to connected non-nodes. */
-        ret = iss_pipeline_pm_power(entity, change);
+        ret = iss_pipeline_pm_power(entity, change, graph);
        if (ret < 0)
                entity->use_count -= change;
-        mutex_unlock(&entity->parent->graph_mutex);
+        mutex_unlock(&entity->graph_obj.mdev->graph_mutex);
        return ret;
 }
@@ -526,34 +527,48 @@ int omap4iss_pipeline_pm_use(struct media_entity *entity, int use)
 static int iss_pipeline_link_notify(struct media_link *link, u32 flags,
                                    unsigned int notification)
 {
+        struct media_entity_graph *graph =
+                &container_of(link->graph_obj.mdev, struct iss_device,
+                              media_dev)->pm_count_graph;
        struct media_entity *source = link->source->entity;
        struct media_entity *sink = link->sink->entity;
-        int source_use = iss_pipeline_pm_use_count(source);
+        int source_use;
-        int sink_use = iss_pipeline_pm_use_count(sink);
+        int sink_use;
        int ret;
+        if (notification == MEDIA_DEV_NOTIFY_PRE_LINK_CH) {
+                ret = media_entity_graph_walk_init(graph,
+                                                   link->graph_obj.mdev);
+                if (ret)
+                        return ret;
+        }
+        source_use = iss_pipeline_pm_use_count(source, graph);
+        sink_use = iss_pipeline_pm_use_count(sink, graph);
        if (notification == MEDIA_DEV_NOTIFY_POST_LINK_CH &&
-            !(link->flags & MEDIA_LNK_FL_ENABLED)) {
+            !(flags & MEDIA_LNK_FL_ENABLED)) {
                /* Powering off entities is assumed to never fail. */
-                iss_pipeline_pm_power(source, -sink_use);
+                iss_pipeline_pm_power(source, -sink_use, graph);
-                iss_pipeline_pm_power(sink, -source_use);
+                iss_pipeline_pm_power(sink, -source_use, graph);
                return 0;
        }
-        if (notification == MEDIA_DEV_NOTIFY_POST_LINK_CH &&
+        if (notification == MEDIA_DEV_NOTIFY_PRE_LINK_CH &&
            (flags & MEDIA_LNK_FL_ENABLED)) {
-                ret = iss_pipeline_pm_power(source, sink_use);
+                ret = iss_pipeline_pm_power(source, sink_use, graph);
                if (ret < 0)
                        return ret;
-                ret = iss_pipeline_pm_power(sink, source_use);
+                ret = iss_pipeline_pm_power(sink, source_use, graph);
                if (ret < 0)
-                        iss_pipeline_pm_power(source, -sink_use);
+                        iss_pipeline_pm_power(source, -sink_use, graph);
-                return ret;
        }
-        return 0;
+        if (notification == MEDIA_DEV_NOTIFY_POST_LINK_CH)
+                media_entity_graph_walk_cleanup(graph);
+        return ret;
 }
 /* -----------------------------------------------------------------------------
@@ -590,8 +605,7 @@ static int iss_pipeline_disable(struct iss_pipeline *pipe,
                        break;
                pad = media_entity_remote_pad(pad);
-                if (!pad ||
+                if (!pad || !is_media_entity_v4l2_subdev(pad->entity))
-                    media_entity_type(pad->entity) != MEDIA_ENT_T_V4L2_SUBDEV)
                        break;
                entity = pad->entity;
@@ -607,7 +621,7 @@ static int iss_pipeline_disable(struct iss_pipeline *pipe,
                         * crashed. Mark it as such, the ISS will be reset when
                         * applications will release it.
                         */
-                        iss->crashed |= 1U << subdev->entity.id;
+                        media_entity_enum_set(&iss->crashed, &subdev->entity);
                        failure = -ETIMEDOUT;
                }
        }
@@ -642,7 +656,7 @@ static int iss_pipeline_enable(struct iss_pipeline *pipe,
         * pipeline won't start anyway (those entities would then likely fail to
         * stop, making the problem worse).
         */
-        if (pipe->entities & iss->crashed)
+        if (media_entity_enum_intersects(&pipe->ent_enum, &iss->crashed))
                return -EIO;
        spin_lock_irqsave(&pipe->lock, flags);
@@ -658,8 +672,7 @@ static int iss_pipeline_enable(struct iss_pipeline *pipe,
                        break;
                pad = media_entity_remote_pad(pad);
-                if (!pad ||
+                if (!pad || !is_media_entity_v4l2_subdev(pad->entity))
-                    media_entity_type(pad->entity) != MEDIA_ENT_T_V4L2_SUBDEV)
                        break;
                entity = pad->entity;
@@ -763,7 +776,8 @@ static int iss_reset(struct iss_device *iss)
                return -ETIMEDOUT;
        }
-        iss->crashed = 0;
+        media_entity_enum_zero(&iss->crashed);
        return 0;
 }
@@ -1092,7 +1106,7 @@ void omap4iss_put(struct iss_device *iss)
                 * be worth investigating whether resetting the ISP only can't
                 * fix the problem in some cases.
                 */
-                if (iss->crashed)
+                if (!media_entity_enum_empty(&iss->crashed))
                        iss_reset(iss);
                iss_disable_clocks(iss);
        }
@@ -1259,7 +1273,7 @@ static int iss_register_entities(struct iss_device *iss)
                        goto done;
                }
-                ret = media_entity_create_link(&sensor->entity, 0, input, pad,
+                ret = media_create_pad_link(&sensor->entity, 0, input, pad,
                                               flags);
                if (ret < 0)
                        goto done;
@@ -1274,6 +1288,68 @@ done:
        return ret;
 }
+/*
+ * iss_create_links() - Pads links creation for the subdevices
+ * @iss : Pointer to ISS device
+ *
+ * return negative error code or zero on success
+ */
+static int iss_create_links(struct iss_device *iss)
+{
+        int ret;
+        ret = omap4iss_csi2_create_links(iss);
+        if (ret < 0) {
+                dev_err(iss->dev, "CSI2 pads links creation failed\n");
+                return ret;
+        }
+        ret = omap4iss_ipipeif_create_links(iss);
+        if (ret < 0) {
+                dev_err(iss->dev, "ISP IPIPEIF pads links creation failed\n");
+                return ret;
+        }
+        ret = omap4iss_resizer_create_links(iss);
+        if (ret < 0) {
+                dev_err(iss->dev, "ISP RESIZER pads links creation failed\n");
+                return ret;
+        }
+        /* Connect the submodules. */
+        ret = media_create_pad_link(
+                        &iss->csi2a.subdev.entity, CSI2_PAD_SOURCE,
+                        &iss->ipipeif.subdev.entity, IPIPEIF_PAD_SINK, 0);
+        if (ret < 0)
+                return ret;
+        ret = media_create_pad_link(
+                        &iss->csi2b.subdev.entity, CSI2_PAD_SOURCE,
+                        &iss->ipipeif.subdev.entity, IPIPEIF_PAD_SINK, 0);
+        if (ret < 0)
+                return ret;
+        ret = media_create_pad_link(
+                        &iss->ipipeif.subdev.entity, IPIPEIF_PAD_SOURCE_VP,
+                        &iss->resizer.subdev.entity, RESIZER_PAD_SINK, 0);
+        if (ret < 0)
+                return ret;
+        ret = media_create_pad_link(
+                        &iss->ipipeif.subdev.entity, IPIPEIF_PAD_SOURCE_VP,
+                        &iss->ipipe.subdev.entity, IPIPE_PAD_SINK, 0);
+        if (ret < 0)
+                return ret;
+        ret = media_create_pad_link(
+                        &iss->ipipe.subdev.entity, IPIPE_PAD_SOURCE_VP,
+                        &iss->resizer.subdev.entity, RESIZER_PAD_SINK, 0);
+        if (ret < 0)
+                return ret;
+        return 0;
+};
 static void iss_cleanup_modules(struct iss_device *iss)
 {
        omap4iss_csi2_cleanup(iss);
@@ -1316,41 +1392,8 @@ static int iss_initialize_modules(struct iss_device *iss)
                goto error_resizer;
        }
-        /* Connect the submodules. */
-        ret = media_entity_create_link(
-                        &iss->csi2a.subdev.entity, CSI2_PAD_SOURCE,
-                        &iss->ipipeif.subdev.entity, IPIPEIF_PAD_SINK, 0);
-        if (ret < 0)
-                goto error_link;
-        ret = media_entity_create_link(
-                        &iss->csi2b.subdev.entity, CSI2_PAD_SOURCE,
-                        &iss->ipipeif.subdev.entity, IPIPEIF_PAD_SINK, 0);
-        if (ret < 0)
-                goto error_link;
-        ret = media_entity_create_link(
-                        &iss->ipipeif.subdev.entity, IPIPEIF_PAD_SOURCE_VP,
-                        &iss->resizer.subdev.entity, RESIZER_PAD_SINK, 0);
-        if (ret < 0)
-                goto error_link;
-        ret = media_entity_create_link(
-                        &iss->ipipeif.subdev.entity, IPIPEIF_PAD_SOURCE_VP,
-                        &iss->ipipe.subdev.entity, IPIPE_PAD_SINK, 0);
-        if (ret < 0)
-                goto error_link;
-        ret = media_entity_create_link(
-                        &iss->ipipe.subdev.entity, IPIPE_PAD_SOURCE_VP,
-                        &iss->resizer.subdev.entity, RESIZER_PAD_SINK, 0);
-        if (ret < 0)
-                goto error_link;
        return 0;
-error_link:
-        omap4iss_resizer_cleanup(iss);
 error_resizer:
        omap4iss_ipipe_cleanup(iss);
 error_ipipe:
@@ -1464,10 +1507,21 @@ static int iss_probe(struct platform_device *pdev)
        if (ret < 0)
                goto error_modules;
+        ret = media_entity_enum_init(&iss->crashed, &iss->media_dev);
+        if (ret)
+                goto error_entities;
+        ret = iss_create_links(iss);
+        if (ret < 0)
+                goto error_entities;
        omap4iss_put(iss);
        return 0;
+error_entities:
+        iss_unregister_entities(iss);
+        media_entity_enum_cleanup(&iss->crashed);
 error_modules:
        iss_cleanup_modules(iss);
 error_iss:
@@ -1485,6 +1539,7 @@ static int iss_remove(struct platform_device *pdev)
        struct iss_device *iss = platform_get_drvdata(pdev);
        iss_unregister_entities(iss);
+        media_entity_enum_cleanup(&iss->crashed);
        iss_cleanup_modules(iss);
        return 0;
diff --git a/drivers/staging/media/omap4iss/iss.h b/drivers/staging/media/omap4iss/iss.h
index 5929357fe687..05f08a3caa19 100644
--- a/drivers/staging/media/omap4iss/iss.h
+++ b/drivers/staging/media/omap4iss/iss.h
@@ -82,11 +82,12 @@ struct iss_reg {
 /*
 * struct iss_device - ISS device structure.
 * @syscon: Regmap for the syscon register space
- * @crashed: Bitmask of crashed entities (indexed by entity ID)
+ * @crashed: Crashed entities
 */
 struct iss_device {
        struct v4l2_device v4l2_dev;
        struct media_device media_dev;
+        struct media_entity_graph pm_count_graph;
        struct device *dev;
        u32 revision;
@@ -101,7 +102,7 @@ struct iss_device {
        u64 raw_dmamask;
        struct mutex iss_mutex; /* For handling ref_count field */
-        unsigned int crashed;
+        struct media_entity_enum crashed;
        int has_context;
        int ref_count;
@@ -151,7 +152,8 @@ void omap4iss_isp_subclk_enable(struct iss_device *iss,
 void omap4iss_isp_subclk_disable(struct iss_device *iss,
                                 enum iss_isp_subclk_resource res);
-int omap4iss_pipeline_pm_use(struct media_entity *entity, int use);
+int omap4iss_pipeline_pm_use(struct media_entity *entity, int use,
+                             struct media_entity_graph *graph);
 int omap4iss_register_entities(struct platform_device *pdev,
                               struct v4l2_device *v4l2_dev);
diff --git a/drivers/staging/media/omap4iss/iss_csi2.c b/drivers/staging/media/omap4iss/iss_csi2.c
index b941035139ae..aaca39d751a5 100644
--- a/drivers/staging/media/omap4iss/iss_csi2.c
+++ b/drivers/staging/media/omap4iss/iss_csi2.c
@@ -1170,14 +1170,19 @@ static int csi2_link_setup(struct media_entity *entity,
        struct v4l2_subdev *sd = media_entity_to_v4l2_subdev(entity);
        struct iss_csi2_device *csi2 = v4l2_get_subdevdata(sd);
        struct iss_csi2_ctrl_cfg *ctrl = &csi2->ctrl;
+        unsigned int index = local->index;
+        /* FIXME: this is actually a hack! */
+        if (is_media_entity_v4l2_subdev(remote->entity))
+                index |= 2 << 16;
        /*
         * The ISS core doesn't support pipelines with multiple video outputs.
         * Revisit this when it will be implemented, and return -EBUSY for now.
         */
-        switch (local->index | media_entity_type(remote->entity)) {
+        switch (index) {
-        case CSI2_PAD_SOURCE | MEDIA_ENT_T_DEVNODE:
+        case CSI2_PAD_SOURCE:
                if (flags & MEDIA_LNK_FL_ENABLED) {
                        if (csi2->output & ~CSI2_OUTPUT_MEMORY)
                                return -EBUSY;
@@ -1187,7 +1192,7 @@ static int csi2_link_setup(struct media_entity *entity,
                }
                break;
-        case CSI2_PAD_SOURCE | MEDIA_ENT_T_V4L2_SUBDEV:
+        case CSI2_PAD_SOURCE | 2 << 16:
                if (flags & MEDIA_LNK_FL_ENABLED) {
                        if (csi2->output & ~CSI2_OUTPUT_IPIPEIF)
                                return -EBUSY;
@@ -1271,7 +1276,7 @@ static int csi2_init_entities(struct iss_csi2_device *csi2, const char *subname)
        pads[CSI2_PAD_SINK].flags = MEDIA_PAD_FL_SINK;
        me->ops = &csi2_media_ops;
-        ret = media_entity_init(me, CSI2_PADS_NUM, pads, 0);
+        ret = media_entity_pads_init(me, CSI2_PADS_NUM, pads);
        if (ret < 0)
                return ret;
@@ -1290,16 +1295,8 @@ static int csi2_init_entities(struct iss_csi2_device *csi2, const char *subname)
        if (ret < 0)
                goto error_video;
-        /* Connect the CSI2 subdev to the video node. */
-        ret = media_entity_create_link(&csi2->subdev.entity, CSI2_PAD_SOURCE,
-                                       &csi2->video_out.video.entity, 0, 0);
-        if (ret < 0)
-                goto error_link;
        return 0;
-error_link:
-        omap4iss_video_cleanup(&csi2->video_out);
 error_video:
        media_entity_cleanup(&csi2->subdev.entity);
        return ret;
@@ -1342,6 +1339,33 @@ int omap4iss_csi2_init(struct iss_device *iss)
 }
 /*
+ * omap4iss_csi2_create_links() - CSI2 pads links creation
+ * @iss: Pointer to ISS device
+ *
+ * return negative error code or zero on success
+ */
+int omap4iss_csi2_create_links(struct iss_device *iss)
+{
+        struct iss_csi2_device *csi2a = &iss->csi2a;
+        struct iss_csi2_device *csi2b = &iss->csi2b;
+        int ret;
+        /* Connect the CSI2a subdev to the video node. */
+        ret = media_create_pad_link(&csi2a->subdev.entity, CSI2_PAD_SOURCE,
+                                    &csi2a->video_out.video.entity, 0, 0);
+        if (ret < 0)
+                return ret;
+        /* Connect the CSI2b subdev to the video node. */
+        ret = media_create_pad_link(&csi2b->subdev.entity, CSI2_PAD_SOURCE,
+                                    &csi2b->video_out.video.entity, 0, 0);
+        if (ret < 0)
+                return ret;
+        return 0;
+}
+/*
 * omap4iss_csi2_cleanup - Routine for module driver cleanup
 */
 void omap4iss_csi2_cleanup(struct iss_device *iss)
diff --git a/drivers/staging/media/omap4iss/iss_csi2.h b/drivers/staging/media/omap4iss/iss_csi2.h
index f2f5343b4a80..24ab378d469f 100644
--- a/drivers/staging/media/omap4iss/iss_csi2.h
+++ b/drivers/staging/media/omap4iss/iss_csi2.h
@@ -151,6 +151,7 @@ struct iss_csi2_device {
 void omap4iss_csi2_isr(struct iss_csi2_device *csi2);
 int omap4iss_csi2_reset(struct iss_csi2_device *csi2);
 int omap4iss_csi2_init(struct iss_device *iss);
+int omap4iss_csi2_create_links(struct iss_device *iss);
 void omap4iss_csi2_cleanup(struct iss_device *iss);
 void omap4iss_csi2_unregister_entities(struct iss_csi2_device *csi2);
 int omap4iss_csi2_register_entities(struct iss_csi2_device *csi2,
diff --git a/drivers/staging/media/omap4iss/iss_ipipe.c b/drivers/staging/media/omap4iss/iss_ipipe.c
index dd0abeffd893..d38782e8e84c 100644
--- a/drivers/staging/media/omap4iss/iss_ipipe.c
+++ b/drivers/staging/media/omap4iss/iss_ipipe.c
@@ -447,8 +447,11 @@ static int ipipe_link_setup(struct media_entity *entity,
        struct iss_ipipe_device *ipipe = v4l2_get_subdevdata(sd);
        struct iss_device *iss = to_iss_device(ipipe);
-        switch (local->index | media_entity_type(remote->entity)) {
+        if (!is_media_entity_v4l2_subdev(remote->entity))
-        case IPIPE_PAD_SINK | MEDIA_ENT_T_V4L2_SUBDEV:
+                return -EINVAL;
+        switch (local->index) {
+        case IPIPE_PAD_SINK:
                /* Read from IPIPEIF. */
                if (!(flags & MEDIA_LNK_FL_ENABLED)) {
                        ipipe->input = IPIPE_INPUT_NONE;
@@ -463,7 +466,7 @@ static int ipipe_link_setup(struct media_entity *entity,
                break;
-        case IPIPE_PAD_SOURCE_VP | MEDIA_ENT_T_V4L2_SUBDEV:
+        case IPIPE_PAD_SOURCE_VP:
                /* Send to RESIZER */
                if (flags & MEDIA_LNK_FL_ENABLED) {
                        if (ipipe->output & ~IPIPE_OUTPUT_VP)
@@ -513,7 +516,7 @@ static int ipipe_init_entities(struct iss_ipipe_device *ipipe)
        pads[IPIPE_PAD_SOURCE_VP].flags = MEDIA_PAD_FL_SOURCE;
        me->ops = &ipipe_media_ops;
-        ret = media_entity_init(me, IPIPE_PADS_NUM, pads, 0);
+        ret = media_entity_pads_init(me, IPIPE_PADS_NUM, pads);
        if (ret < 0)
                return ret;
diff --git a/drivers/staging/media/omap4iss/iss_ipipeif.c b/drivers/staging/media/omap4iss/iss_ipipeif.c
index 5f9e449e7007..23de8330731d 100644
--- a/drivers/staging/media/omap4iss/iss_ipipeif.c
+++ b/drivers/staging/media/omap4iss/iss_ipipeif.c
@@ -662,9 +662,14 @@ static int ipipeif_link_setup(struct media_entity *entity,
        struct v4l2_subdev *sd = media_entity_to_v4l2_subdev(entity);
        struct iss_ipipeif_device *ipipeif = v4l2_get_subdevdata(sd);
        struct iss_device *iss = to_iss_device(ipipeif);
+        unsigned int index = local->index;
-        switch (local->index | media_entity_type(remote->entity)) {
+        /* FIXME: this is actually a hack! */
-        case IPIPEIF_PAD_SINK | MEDIA_ENT_T_V4L2_SUBDEV:
+        if (is_media_entity_v4l2_subdev(remote->entity))
+                index |= 2 << 16;
+        switch (index) {
+        case IPIPEIF_PAD_SINK | 2 << 16:
                /* Read from the sensor CSI2a or CSI2b. */
                if (!(flags & MEDIA_LNK_FL_ENABLED)) {
                        ipipeif->input = IPIPEIF_INPUT_NONE;
@@ -681,7 +686,7 @@ static int ipipeif_link_setup(struct media_entity *entity,
                break;
-        case IPIPEIF_PAD_SOURCE_ISIF_SF | MEDIA_ENT_T_DEVNODE:
+        case IPIPEIF_PAD_SOURCE_ISIF_SF:
                /* Write to memory */
                if (flags & MEDIA_LNK_FL_ENABLED) {
                        if (ipipeif->output & ~IPIPEIF_OUTPUT_MEMORY)
@@ -692,7 +697,7 @@ static int ipipeif_link_setup(struct media_entity *entity,
                }
                break;
-        case IPIPEIF_PAD_SOURCE_VP | MEDIA_ENT_T_V4L2_SUBDEV:
+        case IPIPEIF_PAD_SOURCE_VP | 2 << 16:
                /* Send to IPIPE/RESIZER */
                if (flags & MEDIA_LNK_FL_ENABLED) {
                        if (ipipeif->output & ~IPIPEIF_OUTPUT_VP)
@@ -743,7 +748,7 @@ static int ipipeif_init_entities(struct iss_ipipeif_device *ipipeif)
        pads[IPIPEIF_PAD_SOURCE_VP].flags = MEDIA_PAD_FL_SOURCE;
        me->ops = &ipipeif_media_ops;
-        ret = media_entity_init(me, IPIPEIF_PADS_NUM, pads, 0);
+        ret = media_entity_pads_init(me, IPIPEIF_PADS_NUM, pads);
        if (ret < 0)
                return ret;
@@ -757,18 +762,7 @@ static int ipipeif_init_entities(struct iss_ipipeif_device *ipipeif)
        ipipeif->video_out.bpl_zero_padding = 1;
        ipipeif->video_out.bpl_max = 0x1ffe0;
-        ret = omap4iss_video_init(&ipipeif->video_out, "ISP IPIPEIF");
+        return omap4iss_video_init(&ipipeif->video_out, "ISP IPIPEIF");
-        if (ret < 0)
-                return ret;
-        /* Connect the IPIPEIF subdev to the video node. */
-        ret = media_entity_create_link(&ipipeif->subdev.entity,
-                                       IPIPEIF_PAD_SOURCE_ISIF_SF,
-                                       &ipipeif->video_out.video.entity, 0, 0);
-        if (ret < 0)
-                return ret;
-        return 0;
 }
 void omap4iss_ipipeif_unregister_entities(struct iss_ipipeif_device *ipipeif)
@@ -821,6 +815,22 @@ int omap4iss_ipipeif_init(struct iss_device *iss)
 }
 /*
+ * omap4iss_ipipeif_create_links() - IPIPEIF pads links creation
+ * @iss: Pointer to ISS device
+ *
+ * return negative error code or zero on success
+ */
+int omap4iss_ipipeif_create_links(struct iss_device *iss)
+{
+        struct iss_ipipeif_device *ipipeif = &iss->ipipeif;
+        /* Connect the IPIPEIF subdev to the video node. */
+        return media_create_pad_link(&ipipeif->subdev.entity,
+                                     IPIPEIF_PAD_SOURCE_ISIF_SF,
+                                     &ipipeif->video_out.video.entity, 0, 0);
+}
+/*
 * omap4iss_ipipeif_cleanup - IPIPEIF module cleanup.
 * @iss: Device pointer specific to the OMAP4 ISS.
 */
diff --git a/drivers/staging/media/omap4iss/iss_ipipeif.h b/drivers/staging/media/omap4iss/iss_ipipeif.h
index c6bd96d9656c..bad32b1d6ad8 100644
--- a/drivers/staging/media/omap4iss/iss_ipipeif.h
+++ b/drivers/staging/media/omap4iss/iss_ipipeif.h
@@ -78,6 +78,7 @@ struct iss_ipipeif_device {
 struct iss_device;
 int omap4iss_ipipeif_init(struct iss_device *iss);
+int omap4iss_ipipeif_create_links(struct iss_device *iss);
 void omap4iss_ipipeif_cleanup(struct iss_device *iss);
 int omap4iss_ipipeif_register_entities(struct iss_ipipeif_device *ipipeif,
                                       struct v4l2_device *vdev);
diff --git a/drivers/staging/media/omap4iss/iss_resizer.c b/drivers/staging/media/omap4iss/iss_resizer.c
index 108961e05f53..f1d352c711d5 100644
--- a/drivers/staging/media/omap4iss/iss_resizer.c
+++ b/drivers/staging/media/omap4iss/iss_resizer.c
@@ -716,9 +716,14 @@ static int resizer_link_setup(struct media_entity *entity,
        struct v4l2_subdev *sd = media_entity_to_v4l2_subdev(entity);
        struct iss_resizer_device *resizer = v4l2_get_subdevdata(sd);
        struct iss_device *iss = to_iss_device(resizer);
+        unsigned int index = local->index;
-        switch (local->index | media_entity_type(remote->entity)) {
+        /* FIXME: this is actually a hack! */
-        case RESIZER_PAD_SINK | MEDIA_ENT_T_V4L2_SUBDEV:
+        if (is_media_entity_v4l2_subdev(remote->entity))
+                index |= 2 << 16;
+        switch (index) {
+        case RESIZER_PAD_SINK | 2 << 16:
                /* Read from IPIPE or IPIPEIF. */
                if (!(flags & MEDIA_LNK_FL_ENABLED)) {
                        resizer->input = RESIZER_INPUT_NONE;
@@ -735,7 +740,7 @@ static int resizer_link_setup(struct media_entity *entity,
                break;
-        case RESIZER_PAD_SOURCE_MEM | MEDIA_ENT_T_DEVNODE:
+        case RESIZER_PAD_SOURCE_MEM:
                /* Write to memory */
                if (flags & MEDIA_LNK_FL_ENABLED) {
                        if (resizer->output & ~RESIZER_OUTPUT_MEMORY)
@@ -785,7 +790,7 @@ static int resizer_init_entities(struct iss_resizer_device *resizer)
        pads[RESIZER_PAD_SOURCE_MEM].flags = MEDIA_PAD_FL_SOURCE;
        me->ops = &resizer_media_ops;
-        ret = media_entity_init(me, RESIZER_PADS_NUM, pads, 0);
+        ret = media_entity_pads_init(me, RESIZER_PADS_NUM, pads);
        if (ret < 0)
                return ret;
@@ -799,18 +804,7 @@ static int resizer_init_entities(struct iss_resizer_device *resizer)
        resizer->video_out.bpl_zero_padding = 1;
        resizer->video_out.bpl_max = 0x1ffe0;
-        ret = omap4iss_video_init(&resizer->video_out, "ISP resizer a");
+        return omap4iss_video_init(&resizer->video_out, "ISP resizer a");
-        if (ret < 0)
-                return ret;
-        /* Connect the RESIZER subdev to the video node. */
-        ret = media_entity_create_link(&resizer->subdev.entity,
-                                       RESIZER_PAD_SOURCE_MEM,
-                                       &resizer->video_out.video.entity, 0, 0);
-        if (ret < 0)
-                return ret;
-        return 0;
 }
 void omap4iss_resizer_unregister_entities(struct iss_resizer_device *resizer)
@@ -863,6 +857,22 @@ int omap4iss_resizer_init(struct iss_device *iss)
 }
 /*
+ * omap4iss_resizer_create_links() - RESIZER pads links creation
+ * @iss: Pointer to ISS device
+ *
+ * return negative error code or zero on success
+ */
+int omap4iss_resizer_create_links(struct iss_device *iss)
+{
+        struct iss_resizer_device *resizer = &iss->resizer;
+        /* Connect the RESIZER subdev to the video node. */
+        return media_create_pad_link(&resizer->subdev.entity,
+                                     RESIZER_PAD_SOURCE_MEM,
+                                     &resizer->video_out.video.entity, 0, 0);
+}
+/*
 * omap4iss_resizer_cleanup - RESIZER module cleanup.
 * @iss: Device pointer specific to the OMAP4 ISS.
 */
diff --git a/drivers/staging/media/omap4iss/iss_resizer.h b/drivers/staging/media/omap4iss/iss_resizer.h
index 1e145abafc65..8b7c5fe9ffed 100644
--- a/drivers/staging/media/omap4iss/iss_resizer.h
+++ b/drivers/staging/media/omap4iss/iss_resizer.h
@@ -61,6 +61,7 @@ struct iss_resizer_device {
 struct iss_device;
 int omap4iss_resizer_init(struct iss_device *iss);
+int omap4iss_resizer_create_links(struct iss_device *iss);
 void omap4iss_resizer_cleanup(struct iss_device *iss);
 int omap4iss_resizer_register_entities(struct iss_resizer_device *resizer,
                                       struct v4l2_device *vdev);
diff --git a/drivers/staging/media/omap4iss/iss_video.c b/drivers/staging/media/omap4iss/iss_video.c
index e9aeca08986f..058233a9de67 100644
--- a/drivers/staging/media/omap4iss/iss_video.c
+++ b/drivers/staging/media/omap4iss/iss_video.c
@@ -190,8 +190,7 @@ iss_video_remote_subdev(struct iss_video *video, u32 *pad)
        remote = media_entity_remote_pad(&video->pad);
-        if (!remote ||
+        if (!remote || !is_media_entity_v4l2_subdev(remote->entity))
-            media_entity_type(remote->entity) != MEDIA_ENT_T_V4L2_SUBDEV)
                return NULL;
        if (pad)
@@ -206,17 +205,23 @@ iss_video_far_end(struct iss_video *video)
 {
        struct media_entity_graph graph;
        struct media_entity *entity = &video->video.entity;
-        struct media_device *mdev = entity->parent;
+        struct media_device *mdev = entity->graph_obj.mdev;
        struct iss_video *far_end = NULL;
        mutex_lock(&mdev->graph_mutex);
+        if (media_entity_graph_walk_init(&graph, mdev)) {
+                mutex_unlock(&mdev->graph_mutex);
+                return NULL;
+        }
        media_entity_graph_walk_start(&graph, entity);
        while ((entity = media_entity_graph_walk_next(&graph))) {
                if (entity == &video->video.entity)
                        continue;
-                if (media_entity_type(entity) != MEDIA_ENT_T_DEVNODE)
+                if (!is_media_entity_v4l2_io(entity))
                        continue;
                far_end = to_iss_video(media_entity_to_video_device(entity));
@@ -227,6 +232,9 @@ iss_video_far_end(struct iss_video *video)
        }
        mutex_unlock(&mdev->graph_mutex);
+        media_entity_graph_walk_cleanup(&graph);
        return far_end;
 }
@@ -750,7 +758,7 @@ iss_video_streamon(struct file *file, void *fh, enum v4l2_buf_type type)
        struct iss_video_fh *vfh = to_iss_video_fh(fh);
        struct iss_video *video = video_drvdata(file);
        struct media_entity_graph graph;
-        struct media_entity *entity;
+        struct media_entity *entity = &video->video.entity;
        enum iss_pipeline_state state;
        struct iss_pipeline *pipe;
        struct iss_video *far_end;
@@ -765,24 +773,30 @@ iss_video_streamon(struct file *file, void *fh, enum v4l2_buf_type type)
        /* Start streaming on the pipeline. No link touching an entity in the
         * pipeline can be activated or deactivated once streaming is started.
         */
-        pipe = video->video.entity.pipe
+        pipe = entity->pipe
-             ? to_iss_pipeline(&video->video.entity) : &video->pipe;
+             ? to_iss_pipeline(entity) : &video->pipe;
        pipe->external = NULL;
        pipe->external_rate = 0;
        pipe->external_bpp = 0;
-        pipe->entities = 0;
+        ret = media_entity_enum_init(&pipe->ent_enum, entity->graph_obj.mdev);
+        if (ret)
+                goto err_graph_walk_init;
+        ret = media_entity_graph_walk_init(&graph, entity->graph_obj.mdev);
+        if (ret)
+                goto err_graph_walk_init;
        if (video->iss->pdata->set_constraints)
                video->iss->pdata->set_constraints(video->iss, true);
-        ret = media_entity_pipeline_start(&video->video.entity, &pipe->pipe);
+        ret = media_entity_pipeline_start(entity, &pipe->pipe);
        if (ret < 0)
                goto err_media_entity_pipeline_start;
-        entity = &video->video.entity;
        media_entity_graph_walk_start(&graph, entity);
        while ((entity = media_entity_graph_walk_next(&graph)))
-                pipe->entities |= 1 << entity->id;
+                media_entity_enum_set(&pipe->ent_enum, entity);
        /* Verify that the currently configured format matches the output of
         * the connected subdev.
@@ -852,7 +866,10 @@ iss_video_streamon(struct file *file, void *fh, enum v4l2_buf_type type)
                spin_unlock_irqrestore(&video->qlock, flags);
        }
+        media_entity_graph_walk_cleanup(&graph);
        mutex_unlock(&video->stream_lock);
        return 0;
 err_omap4iss_set_stream:
@@ -864,7 +881,13 @@ err_media_entity_pipeline_start:
                video->iss->pdata->set_constraints(video->iss, false);
        video->queue = NULL;
+        media_entity_graph_walk_cleanup(&graph);
+err_graph_walk_init:
+        media_entity_enum_cleanup(&pipe->ent_enum);
        mutex_unlock(&video->stream_lock);
        return ret;
 }
@@ -902,6 +925,8 @@ iss_video_streamoff(struct file *file, void *fh, enum v4l2_buf_type type)
        vb2_streamoff(&vfh->queue, type);
        video->queue = NULL;
+        media_entity_enum_cleanup(&pipe->ent_enum);
        if (video->iss->pdata->set_constraints)
                video->iss->pdata->set_constraints(video->iss, false);
        media_entity_pipeline_stop(&video->video.entity);
@@ -984,7 +1009,13 @@ static int iss_video_open(struct file *file)
                goto done;
        }
-        ret = omap4iss_pipeline_pm_use(&video->video.entity, 1);
+        ret = media_entity_graph_walk_init(&handle->graph,
+                                           &video->iss->media_dev);
+        if (ret)
+                goto done;
+        ret = omap4iss_pipeline_pm_use(&video->video.entity, 1,
+                                       &handle->graph);
        if (ret < 0) {
                omap4iss_put(video->iss);
                goto done;
@@ -1023,6 +1054,7 @@ static int iss_video_open(struct file *file)
 done:
        if (ret < 0) {
                v4l2_fh_del(&handle->vfh);
+                media_entity_graph_walk_cleanup(&handle->graph);
                kfree(handle);
        }
@@ -1038,12 +1070,13 @@ static int iss_video_release(struct file *file)
        /* Disable streaming and free the buffers queue resources. */
        iss_video_streamoff(file, vfh, video->type);
-        omap4iss_pipeline_pm_use(&video->video.entity, 0);
+        omap4iss_pipeline_pm_use(&video->video.entity, 0, &handle->graph);
        /* Release the videobuf2 queue */
        vb2_queue_release(&handle->queue);
        /* Release the file handle. */
+        media_entity_graph_walk_cleanup(&handle->graph);
        v4l2_fh_del(vfh);
        kfree(handle);
        file->private_data = NULL;
@@ -1102,7 +1135,7 @@ int omap4iss_video_init(struct iss_video *video, const char *name)
                return -EINVAL;
        }
-        ret = media_entity_init(&video->video.entity, 1, &video->pad, 0);
+        ret = media_entity_pads_init(&video->video.entity, 1, &video->pad);
        if (ret < 0)
                return ret;
diff --git a/drivers/staging/media/omap4iss/iss_video.h b/drivers/staging/media/omap4iss/iss_video.h
index 41532eda1277..34588b7176ca 100644
--- a/drivers/staging/media/omap4iss/iss_video.h
+++ b/drivers/staging/media/omap4iss/iss_video.h
@@ -77,7 +77,7 @@ enum iss_pipeline_state {
 /*
 * struct iss_pipeline - An OMAP4 ISS hardware pipeline
- * @entities: Bitmask of entities in the pipeline (indexed by entity ID)
+ * @ent_enum: Entities in the pipeline
 * @error: A hardware error occurred during capture
 */
 struct iss_pipeline {
@@ -87,7 +87,7 @@ struct iss_pipeline {
        enum iss_pipeline_stream_state stream_state;
        struct iss_video *input;
        struct iss_video *output;
-        unsigned int entities;
+        struct media_entity_enum ent_enum;
        atomic_t frame_number;
        bool do_propagation; /* of frame number */
        bool error;
@@ -183,6 +183,7 @@ struct iss_video_fh {
        struct vb2_queue queue;
        struct v4l2_format format;
        struct v4l2_fract timeperframe;
+        struct media_entity_graph graph;
 };
 #define to_iss_video_fh(fh)     container_of(fh, struct iss_video_fh, vfh)
diff --git a/include/media/media-device.h b/include/media/media-device.h
index 6e6db78f1ee2..d3855898c3fc 100644
--- a/include/media/media-device.h
+++ b/include/media/media-device.h
@@ -30,6 +30,238 @@
 #include <media/media-devnode.h>
 #include <media/media-entity.h>
+/**
+ * DOC: Media Controller
+ *
+ * The media controller userspace API is documented in DocBook format in
+ * Documentation/DocBook/media/v4l/media-controller.xml. This document 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
+ * modelled 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:
+ *
+ * A media device is represented by a struct &media_device instance, defined in
+ * include/media/media-device.h. Allocation of the structure is handled by the
+ * media device driver, usually by embedding the &media_device instance in a
+ * larger driver-specific structure.
+ *
+ * Drivers register media device instances by calling
+ *      __media_device_register() via the macro media_device_register()
+ * and unregistered by calling
+ *      media_device_unregister().
+ *
+ * * 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 entity pads by calling
+ *      media_entity_pads_init().
+ *
+ * Drivers register entities with a media device by calling
+ *      media_device_register_entity()
+ * and unregistred by calling
+ *      media_device_unregister_entity().
+ *
+ * - Interfaces
+ *
+ * Interfaces are represented by a struct &media_interface instance, defined in
+ * include/media/media-entity.h. Currently, only one type of interface is
+ * defined: a device node. Such interfaces are represented by a struct
+ * &media_intf_devnode.
+ *
+ * Drivers initialize and create device node interfaces by calling
+ *      media_devnode_create()
+ * and remove them by calling:
+ *      media_devnode_remove().
+ *
+ * - 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_SINK indicates that the pad supports sinking data.
+ *      %MEDIA_PAD_FL_SOURCE indicates that the pad supports sourcing data.
+ *
+ * NOTE: One and only one of %MEDIA_PAD_FL_SINK and %MEDIA_PAD_FL_SOURCE must
+ * be set for each pad.
+ *
+ * - Links
+ *
+ * Links are represented by a struct &media_link instance, defined in
+ * include/media/media-entity.h. There are two types of links:
+ *
+ * 1. pad to pad links:
+ *
+ * Associate two entities via their PADs. Each entity has a list that points
+ * to all links originating at or targeting any of its pads.
+ * A given link is thus stored twice, once in the source entity and once in
+ * the target entity.
+ *
+ * Drivers create pad to pad links by calling:
+ *      media_create_pad_link() and remove with media_entity_remove_links().
+ *
+ * 2. interface to entity links:
+ *
+ * Associate one interface to a Link.
+ *
+ * Drivers create interface to entity links by calling:
+ *      media_create_intf_link() and remove with media_remove_intf_links().
+ *
+ * NOTE:
+ *
+ * Links can only be created after having both ends already created.
+ *
+ * Links have flags that describe the link capabilities and state. The
+ * valid values are described at media_create_pad_link() and
+ * media_create_intf_link().
+ *
+ * Graph traversal:
+ *
+ * The media framework provides APIs to iterate over entities in a graph.
+ *
+ * To iterate over all entities belonging to a media device, drivers can use
+ * the media_device_for_each_entity macro, defined in
+ * include/media/media-device.h.
+ *
+ *      struct media_entity *entity;
+ *
+ *      media_device_for_each_entity(entity, mdev) {
+ *              // entity will point to each entity in turn
+ *              ...
+ *      }
+ *
+ * Drivers might also need to iterate over all entities in a graph that can be
+ * reached only through enabled links starting at a given entity. The media
+ * framework provides a depth-first graph traversal API for that purpose.
+ *
+ * Note that graphs with cycles (whether directed or undirected) are *NOT*
+ * supported by the graph traversal API. To prevent infinite loops, the graph
+ * traversal code limits the maximum depth to MEDIA_ENTITY_ENUM_MAX_DEPTH,
+ * currently defined as 16.
+ *
+ * Drivers initiate a graph traversal by calling
+ *      media_entity_graph_walk_start()
+ *
+ * The graph structure, provided by the caller, is initialized to start graph
+ * traversal at the given entity.
+ *
+ * Drivers can then retrieve the next entity by calling
+ *      media_entity_graph_walk_next()
+ *
+ * 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() and media_entity_remote_pad()
+ *
+ * Use count and power handling:
+ *
+ * Due to the wide differences between drivers regarding power management
+ * needs, the media controller does not implement power management. However,
+ * the &media_entity structure includes a use_count field that media drivers
+ * can use to track the number of users of every entity for power management
+ * needs.
+ *
+ * The &media_entity.@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()
+ *
+ * Pipelines and media streams:
+ *
+ * When starting streaming, drivers must notify all entities in the pipeline to
+ * prevent link states from being modified during streaming by calling
+ *      media_entity_pipeline_start().
+ *
+ * The function will mark all entities connected to the given entity through
+ * enabled links, either directly or indirectly, as streaming.
+ *
+ * The &media_pipeline instance pointed to by the pipe argument will be stored
+ * in every entity in the pipeline. Drivers should embed the &media_pipeline
+ * structure in higher-level pipeline structures and can then access the
+ * pipeline through the &media_entity pipe field.
+ *
+ * Calls to media_entity_pipeline_start() can be nested. The pipeline pointer
+ * must be identical for all nested calls to the function.
+ *
+ * media_entity_pipeline_start() may return an error. In that case, it will
+ * clean up any of the changes it did by itself.
+ *
+ * When stopping the stream, drivers must notify the entities with
+ *      media_entity_pipeline_stop().
+ *
+ * If multiple calls to media_entity_pipeline_start() have been made the same
+ * number of media_entity_pipeline_stop() calls are required to stop streaming.
+ * The &media_entity pipe field is reset to NULL on the last nested stop call.
+ *
+ * Link configuration will fail with -%EBUSY by default if either end of the
+ * link is a streaming entity. Links that can be modified while streaming must
+ * be marked with the %MEDIA_LNK_FL_DYNAMIC flag.
+ *
+ * If other operations need to be disallowed on streaming entities (such as
+ * changing entities configuration parameters) drivers can explicitly check the
+ * media_entity stream_count field to find out if an entity is streaming. This
+ * operation must be done with the media_device graph_mutex held.
+ *
+ * Link validation:
+ *
+ * Link validation is performed by media_entity_pipeline_start() for any
+ * entity which has sink pads in the pipeline. The
+ * &media_entity.@link_validate() callback is used for that purpose. In
+ * @link_validate() callback, entity driver should check that the properties of
+ * the source pad of the connected entity and its own sink pad match. It is up
+ * to the type of the entity (and in the end, the properties of the hardware)
+ * what matching actually means.
+ *
+ * Subsystems should facilitate link validation by providing subsystem specific
+ * helper functions to provide easy access for commonly needed information, and
+ * in the end provide a way to use driver-specific callbacks.
+ */
+struct ida;
 struct device;
 /**
@@ -41,8 +273,16 @@ struct device;
 * @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
+ * @topology_version: Monotonic counter for storing the version of the graph
+ *              topology. Should be incremented each time the topology changes.
+ * @id:         Unique ID used on the last registered graph object
+ * @entity_internal_idx: Unique internal entity ID used by the graph traversal
+ *              algorithms
+ * @entity_internal_idx_max: Allocated internal entity indices
 * @entities:   List of registered entities
+ * @interfaces: List of registered interfaces
+ * @pads:       List of registered pads
+ * @links:      List of registered links
 * @lock:       Entities list lock
 * @graph_mutex: Entities graph operation lock
 * @link_notify: Link state change notification callback
@@ -68,10 +308,18 @@ struct media_device {
        u32 hw_revision;
        u32 driver_version;
-        u32 entity_id;
+        u32 topology_version;
+        u32 id;
+        struct ida entity_internal_idx;
+        int entity_internal_idx_max;
        struct list_head entities;
+        struct list_head interfaces;
+        struct list_head pads;
+        struct list_head links;
-        /* Protects the entities list */
+        /* Protects the graph objects creation/removal */
        spinlock_t lock;
        /* Serializes graph operations. */
        struct mutex graph_mutex;
@@ -80,6 +328,8 @@ struct media_device {
                           unsigned int notification);
 };
+#ifdef CONFIG_MEDIA_CONTROLLER
 /* Supported link_notify @notification values. */
 #define MEDIA_DEV_NOTIFY_PRE_LINK_CH    0
 #define MEDIA_DEV_NOTIFY_POST_LINK_CH   1
@@ -87,17 +337,228 @@ struct media_device {
 /* media_devnode to media_device */
 #define to_media_device(node) container_of(node, struct media_device, devnode)
+/**
+ * media_entity_enum_init - Initialise an entity enumeration
+ *
+ * @ent_enum: Entity enumeration to be initialised
+ * @mdev: The related media device
+ *
+ * Returns zero on success or a negative error code.
+ */
+static inline __must_check int media_entity_enum_init(
+        struct media_entity_enum *ent_enum, struct media_device *mdev)
+{
+        return __media_entity_enum_init(ent_enum,
+                                        mdev->entity_internal_idx_max + 1);
+}
+/**
+ * media_device_init() - Initializes a media device element
+ *
+ * @mdev:       pointer to struct &media_device
+ *
+ * This function initializes the media device prior to its registration.
+ * The media device initialization and registration is split in two functions
+ * to avoid race conditions and make the media device available to user-space
+ * before the media graph has been completed.
+ *
+ * So drivers need to first initialize the media device, register any entity
+ * within the media device, create pad to pad links and then finally register
+ * the media device by calling media_device_register() as a final step.
+ */
+void media_device_init(struct media_device *mdev);
+/**
+ * media_device_cleanup() - Cleanups a media device element
+ *
+ * @mdev:       pointer to struct &media_device
+ *
+ * This function that will destroy the graph_mutex that is
+ * initialized in media_device_init().
+ */
+void media_device_cleanup(struct media_device *mdev);
+/**
+ * __media_device_register() - Registers a media device element
+ *
+ * @mdev:       pointer to struct &media_device
+ * @owner:      should be filled with %THIS_MODULE
+ *
+ * Users, should, instead, call the media_device_register() macro.
+ *
+ * The caller is responsible for initializing the media_device structure before
+ * registration. The following fields must be set:
+ *
+ *  - dev must point to the parent device (usually a &pci_dev, &usb_interface or
+ *    &platform_device instance).
+ *
+ *  - model must be filled with the device model name as a NUL-terminated UTF-8
+ *    string. The device/model revision must not be stored in this field.
+ *
+ * The following fields are optional:
+ *
+ *  - serial is a unique serial number stored as a NUL-terminated ASCII string.
+ *    The field is big enough to store a GUID in text form. If the hardware
+ *    doesn't provide a unique serial number this field must be left empty.
+ *
+ *  - bus_info represents the location of the device in the system as a
+ *    NUL-terminated ASCII string. For PCI/PCIe devices bus_info must be set to
+ *    "PCI:" (or "PCIe:") followed by the value of pci_name(). For USB devices,
+ *    the usb_make_path() function must be used. This field is used by
+ *    applications to distinguish between otherwise identical devices that don't
+ *    provide a serial number.
+ *
+ *  - hw_revision is the hardware device revision in a driver-specific format.
+ *    When possible the revision should be formatted with the KERNEL_VERSION
+ *    macro.
+ *
+ *  - driver_version is formatted with the KERNEL_VERSION macro. The version
+ *    minor must be incremented when new features are added to the userspace API
+ *    without breaking binary compatibility. The version major must be
+ *    incremented when binary compatibility is broken.
+ *
+ * Notes:
+ *
+ * Upon successful registration a character device named media[0-9]+ is created.
+ * The device major and minor numbers are dynamic. The model name is exported as
+ * a sysfs attribute.
+ *
+ * Unregistering a media device that hasn't been registered is *NOT* safe.
+ *
+ * Return: returns zero on success or a negative error code.
+ */
 int __must_check __media_device_register(struct media_device *mdev,
                                         struct module *owner);
 #define media_device_register(mdev) __media_device_register(mdev, THIS_MODULE)
+/**
+ * __media_device_unregister() - Unegisters a media device element
+ *
+ * @mdev:       pointer to struct &media_device
+ *
+ *
+ * It is safe to call this function on an unregistered (but initialised)
+ * media device.
+ */
 void media_device_unregister(struct media_device *mdev);
+/**
+ * media_device_register_entity() - registers a media entity inside a
+ *      previously registered media device.
+ *
+ * @mdev:       pointer to struct &media_device
+ * @entity:     pointer to struct &media_entity to be registered
+ *
+ * Entities are identified by a unique positive integer ID. The media
+ * controller framework will such ID automatically. IDs are not guaranteed
+ * to be contiguous, and the ID number can change on newer Kernel versions.
+ * So, neither the driver nor userspace should hardcode ID numbers to refer
+ * to the entities, but, instead, use the framework to find the ID, when
+ * needed.
+ *
+ * The media_entity name, type and flags fields should be initialized before
+ * calling media_device_register_entity(). Entities embedded in higher-level
+ * standard structures can have some of those fields set by the higher-level
+ * framework.
+ *
+ * If the device has pads, media_entity_pads_init() should be called before
+ * this function. Otherwise, the &media_entity.@pad and &media_entity.@num_pads
+ * should be zeroed before calling this function.
+ *
+ * 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.
+ *
+ * NOTE: Drivers should set the entity function before calling this function.
+ * Please notice that the values %MEDIA_ENT_F_V4L2_SUBDEV_UNKNOWN and
+ * %MEDIA_ENT_F_UNKNOWN should not be used by the drivers.
+ */
 int __must_check media_device_register_entity(struct media_device *mdev,
                                              struct media_entity *entity);
+/*
+ * media_device_unregister_entity() - unregisters a media entity.
+ *
+ * @entity:     pointer to struct &media_entity to be unregistered
+ *
+ * All links associated with the entity and all PADs are automatically
+ * unregistered from the media_device when this function is called.
+ *
+ * Unregistering an entity will not change the IDs of the other entities and
+ * the previoully used ID will never be reused for a newly registered entities.
+ *
+ * When a media device is unregistered, all its entities are unregistered
+ * automatically. No manual entities unregistration is then required.
+ *
+ * Note: the media_entity instance itself must be freed explicitly by
+ * the driver if required.
+ */
 void media_device_unregister_entity(struct media_entity *entity);
+/**
+ * media_device_get_devres() -  get media device as device resource
+ *                              creates if one doesn't exist
+ *
+ * @dev: pointer to struct &device.
+ *
+ * Sometimes, the media controller &media_device needs to be shared by more
+ * than one driver. This function adds support for that, by dynamically
+ * allocating the &media_device and allowing it to be obtained from the
+ * struct &device associated with the common device where all sub-device
+ * components belong. So, for example, on an USB device with multiple
+ * interfaces, each interface may be handled by a separate per-interface
+ * drivers. While each interface have its own &device, they all share a
+ * common &device associated with the hole USB device.
+ */
+struct media_device *media_device_get_devres(struct device *dev);
+/**
+ * media_device_find_devres() - find media device as device resource
+ *
+ * @dev: pointer to struct &device.
+ */
+struct media_device *media_device_find_devres(struct device *dev);
 /* Iterate over all entities. */
 #define media_device_for_each_entity(entity, mdev)                      \
-        list_for_each_entry(entity, &(mdev)->entities, list)
+        list_for_each_entry(entity, &(mdev)->entities, graph_obj.list)
+/* Iterate over all interfaces. */
+#define media_device_for_each_intf(intf, mdev)                  \
+        list_for_each_entry(intf, &(mdev)->interfaces, graph_obj.list)
+/* Iterate over all pads. */
+#define media_device_for_each_pad(pad, mdev)                    \
+        list_for_each_entry(pad, &(mdev)->pads, graph_obj.list)
+/* Iterate over all links. */
+#define media_device_for_each_link(link, mdev)                  \
+        list_for_each_entry(link, &(mdev)->links, graph_obj.list)
+#else
+static inline int media_device_register(struct media_device *mdev)
+{
+        return 0;
+}
+static inline void media_device_unregister(struct media_device *mdev)
+{
+}
+static inline int media_device_register_entity(struct media_device *mdev,
+                                                struct media_entity *entity)
+{
+        return 0;
+}
+static inline void media_device_unregister_entity(struct media_entity *entity)
+{
+}
+static inline struct media_device *media_device_get_devres(struct device *dev)
+{
+        return NULL;
+}
+static inline struct media_device *media_device_find_devres(struct device *dev)
+{
+        return NULL;
+}
+#endif /* CONFIG_MEDIA_CONTROLLER */
 #endif
diff --git a/include/media/media-devnode.h b/include/media/media-devnode.h
index 17ddae32060d..fe42f08e72bd 100644
--- a/include/media/media-devnode.h
+++ b/include/media/media-devnode.h
@@ -40,6 +40,20 @@
 */
 #define MEDIA_FLAG_REGISTERED   0
+/**
+ * struct media_file_operations - Media device file operations
+ *
+ * @owner: should be filled with %THIS_MODULE
+ * @read: pointer to the function that implements read() syscall
+ * @write: pointer to the function that implements write() syscall
+ * @poll: pointer to the function that implements poll() syscall
+ * @ioctl: pointer to the function that implements ioctl() syscall
+ * @compat_ioctl: pointer to the function that will handle 32 bits userspace
+ *      calls to the the ioctl() syscall on a Kernel compiled with 64 bits.
+ * @open: pointer to the function that implements open() syscall
+ * @release: pointer to the function that will release the resources allocated
+ *      by the @open function.
+ */
 struct media_file_operations {
        struct module *owner;
        ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
@@ -53,7 +67,7 @@ struct media_file_operations {
 /**
 * struct media_devnode - Media device node
- * @fops:       pointer to struct media_file_operations with media device ops
+ * @fops:       pointer to struct &media_file_operations with media device ops
 * @dev:        struct device pointer for the media controller device
 * @cdev:       struct cdev pointer character device
 * @parent:     parent device
@@ -86,15 +100,53 @@ struct media_devnode {
 /* dev to media_devnode */
 #define to_media_devnode(cd) container_of(cd, struct media_devnode, dev)
+/**
+ * media_devnode_register - register a media device node
+ *
+ * @mdev: media device node structure we want to register
+ * @owner: should be filled with %THIS_MODULE
+ *
+ * The registration code assigns minor numbers and registers the new device node
+ * with the kernel. An error is returned if no free minor number can be found,
+ * or if the registration of the device node fails.
+ *
+ * Zero is returned on success.
+ *
+ * Note that if the media_devnode_register call fails, the release() callback of
+ * the media_devnode structure is *not* called, so the caller is responsible for
+ * freeing any data.
+ */
 int __must_check media_devnode_register(struct media_devnode *mdev,
                                        struct module *owner);
+/**
+ * media_devnode_unregister - unregister a media device node
+ * @mdev: the device node to unregister
+ *
+ * This unregisters the passed device. Future open calls will be met with
+ * errors.
+ *
+ * This function can safely be called if the device node has never been
+ * registered or has already been unregistered.
+ */
 void media_devnode_unregister(struct media_devnode *mdev);
+/**
+ * media_devnode_data - returns a pointer to the &media_devnode
+ *
+ * @filp: pointer to struct &file
+ */
 static inline struct media_devnode *media_devnode_data(struct file *filp)
 {
        return filp->private_data;
 }
+/**
+ * media_devnode_is_registered - returns true if &media_devnode is registered;
+ *      false otherwise.
+ *
+ * @mdev: pointer to struct &media_devnode.
+ */
 static inline int media_devnode_is_registered(struct media_devnode *mdev)
 {
        return test_bit(MEDIA_FLAG_REGISTERED, &mdev->flags);
diff --git a/include/media/media-entity.h b/include/media/media-entity.h
index 197f93799753..fe485d367985 100644
--- a/include/media/media-entity.h
+++ b/include/media/media-entity.h
@@ -23,25 +23,151 @@
 #ifndef _MEDIA_ENTITY_H
 #define _MEDIA_ENTITY_H
-#include <linux/bitops.h>
+#include <linux/bitmap.h>
 #include <linux/kernel.h>
 #include <linux/list.h>
 #include <linux/media.h>
+/* Enums used internally at the media controller to represent graphs */
+/**
+ * enum media_gobj_type - type of a graph object
+ *
+ * @MEDIA_GRAPH_ENTITY:         Identify a media entity
+ * @MEDIA_GRAPH_PAD:            Identify a media pad
+ * @MEDIA_GRAPH_LINK:           Identify a media link
+ * @MEDIA_GRAPH_INTF_DEVNODE:   Identify a media Kernel API interface via
+ *                              a device node
+ */
+enum media_gobj_type {
+        MEDIA_GRAPH_ENTITY,
+        MEDIA_GRAPH_PAD,
+        MEDIA_GRAPH_LINK,
+        MEDIA_GRAPH_INTF_DEVNODE,
+};
+#define MEDIA_BITS_PER_TYPE             8
+#define MEDIA_BITS_PER_ID               (32 - MEDIA_BITS_PER_TYPE)
+#define MEDIA_ID_MASK                    GENMASK_ULL(MEDIA_BITS_PER_ID - 1, 0)
+/* Structs to represent the objects that belong to a media graph */
+/**
+ * struct media_gobj - Define a graph object.
+ *
+ * @mdev:       Pointer to the struct media_device that owns the object
+ * @id:         Non-zero object ID identifier. The ID should be unique
+ *              inside a media_device, as it is composed by
+ *              %MEDIA_BITS_PER_TYPE to store the type plus
+ *              %MEDIA_BITS_PER_ID to store the ID
+ * @list:       List entry stored in one of the per-type mdev object lists
+ *
+ * All objects on the media graph should have this struct embedded
+ */
+struct media_gobj {
+        struct media_device     *mdev;
+        u32                     id;
+        struct list_head        list;
+};
+#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;
+};
+/**
+ * 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.
+ * @ent_enum:           Visited entities
+ * @top:                The top of the stack
+ */
+struct media_entity_graph {
+        struct {
+                struct media_entity *entity;
+                struct list_head *link;
+        } stack[MEDIA_ENTITY_ENUM_MAX_DEPTH];
+        struct media_entity_enum ent_enum;
+        int top;
+};
+/*
+ * struct media_pipeline - Media pipeline related information
+ *
+ * @streaming_count:    Streaming start count - streaming stop count
+ * @graph:              Media graph walk during pipeline start / stop
+ */
 struct media_pipeline {
+        int streaming_count;
+        struct media_entity_graph graph;
 };
+/**
+ * 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_*)
+ * @is_backlink: Indicate if the link is a backlink.
+ */
 struct media_link {
-        struct media_pad *source;       /* Source pad */
+        struct media_gobj graph_obj;
-        struct media_pad *sink;         /* Sink pad  */
+        struct list_head list;
-        struct media_link *reverse;     /* Link in the reverse direction */
+        union {
-        unsigned long flags;            /* Link flags (MEDIA_LNK_FL_*) */
+                struct media_gobj *gobj0;
+                struct media_pad *source;
+                struct media_interface *intf;
+        };
+        union {
+                struct media_gobj *gobj1;
+                struct media_pad *sink;
+                struct media_entity *entity;
+        };
+        struct media_link *reverse;
+        unsigned long flags;
+        bool is_backlink;
 };
+/**
+ * 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_*)
+ */
 struct media_pad {
-        struct media_entity *entity;    /* Entity this pad belongs to */
+        struct media_gobj graph_obj;    /* must be first field in struct */
-        u16 index;                      /* Pad index in the entity pads array */
+        struct media_entity *entity;
-        unsigned long flags;            /* Pad flags (MEDIA_PAD_FL_*) */
+        u16 index;
+        unsigned long flags;
 };
 /**
@@ -60,105 +186,763 @@ struct media_entity_operations {
        int (*link_validate)(struct media_link *link);
 };
+/**
+ * struct media_entity - A media entity graph object.
+ *
+ * @graph_obj:  Embedded structure containing the media object common data.
+ * @name:       Entity name.
+ * @function:   Entity main function, as defined in uapi/media.h
+ *              (MEDIA_ENT_F_*)
+ * @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
+ * @internal_idx: An unique internal entity specific number. The numbers are
+ *              re-used if entities are unregistered or registered again.
+ * @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.
+ */
 struct media_entity {
-        struct list_head list;
+        struct media_gobj graph_obj;    /* must be first field in struct */
-        struct media_device *parent;    /* Media device this entity belongs to*/
+        const char *name;
-        u32 id;                         /* Entity ID, unique in the parent media
+        u32 function;
-                                         * device context */
+        unsigned long flags;
-        const char *name;               /* Entity name */
-        u32 type;                       /* Entity type (MEDIA_ENT_T_*) */
+        u16 num_pads;
-        u32 revision;                   /* Entity revision, driver specific */
+        u16 num_links;
-        unsigned long flags;            /* Entity flags (MEDIA_ENT_FL_*) */
+        u16 num_backlinks;
-        u32 group_id;                   /* Entity group ID */
+        int internal_idx;
-        u16 num_pads;                   /* Number of sink and source pads */
+        struct media_pad *pads;
-        u16 num_links;                  /* Number of existing links, both
+        struct list_head links;
-                                         * enabled and disabled */
-        u16 num_backlinks;              /* Number of backlinks */
+        const struct media_entity_operations *ops;
-        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)*/
-        const struct media_entity_operations *ops;      /* Entity operations */
        /* 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.
         */
-        int stream_count;               /* Stream count for the entity. */
+        int stream_count;
-        int use_count;                  /* Use count for the entity. */
+        int use_count;
-        struct media_pipeline *pipe;    /* Pipeline this entity belongs to. */
+        struct media_pipeline *pipe;
        union {
-                /* Node specifications */
                struct {
                        u32 major;
                        u32 minor;
                } dev;
-                /* Sub-device specifications */
-                /* Nothing needed yet */
        } info;
 };
-static inline u32 media_entity_type(struct media_entity *entity)
+/**
+ * struct media_interface - A media interface graph object.
+ *
+ * @graph_obj:          embedded graph object
+ * @links:              List of links pointing to graph entities
+ * @type:               Type of the interface as defined in the
+ *                      uapi/media/media.h header, e. g.
+ *                      MEDIA_INTF_T_*
+ * @flags:              Interface flags as defined in uapi/media/media.h
+ */
+struct media_interface {
+        struct media_gobj               graph_obj;
+        struct list_head                links;
+        u32                             type;
+        u32                             flags;
+};
+/**
+ * struct media_intf_devnode - A media interface via a device node.
+ *
+ * @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;
+        /* Should match the fields at media_v2_intf_devnode */
+        u32                             major;
+        u32                             minor;
+};
+/**
+ * media_entity_id() - return the media entity graph object id
+ *
+ * @entity:     pointer to entity
+ */
+static inline u32 media_entity_id(struct media_entity *entity)
 {
-        return entity->type & MEDIA_ENT_TYPE_MASK;
+        return entity->graph_obj.id;
 }
-static inline u32 media_entity_subtype(struct media_entity *entity)
+/**
+ * media_type() - return the media object type
+ *
+ * @gobj:       pointer to the media graph object
+ */
+static inline enum media_gobj_type media_type(struct media_gobj *gobj)
 {
-        return entity->type & MEDIA_ENT_SUBTYPE_MASK;
+        return gobj->id >> MEDIA_BITS_PER_ID;
 }
-#define MEDIA_ENTITY_ENUM_MAX_DEPTH     16
+/**
-#define MEDIA_ENTITY_ENUM_MAX_ID        64
+ * media_id() - return the media object ID
+ *
+ * @gobj:       pointer to the media graph object
+ */
+static inline u32 media_id(struct media_gobj *gobj)
+{
+        return gobj->id & MEDIA_ID_MASK;
+}
-/*
+/**
- * The number of pads can't be bigger than the number of entities,
+ * media_gobj_gen_id() - encapsulates type and ID on at the object ID
- * as the worse-case scenario is to have one entity linked up to
+ *
- * MEDIA_ENTITY_ENUM_MAX_ID - 1 entities.
+ * @type:       object type as define at enum &media_gobj_type.
+ * @local_id:   next ID, from struct &media_device.@id.
 */
-#define MEDIA_ENTITY_MAX_PADS           (MEDIA_ENTITY_ENUM_MAX_ID - 1)
+static inline u32 media_gobj_gen_id(enum media_gobj_type type, u64 local_id)
+{
+        u32 id;
-struct media_entity_graph {
+        id = type << MEDIA_BITS_PER_ID;
-        struct {
+        id |= local_id & MEDIA_ID_MASK;
-                struct media_entity *entity;
-                int link;
-        } stack[MEDIA_ENTITY_ENUM_MAX_DEPTH];
-        DECLARE_BITMAP(entities, MEDIA_ENTITY_ENUM_MAX_ID);
+        return id;
-        int top;
+}
-};
+/**
+ * is_media_entity_v4l2_io() - identify if the entity main function
+ *                             is a V4L2 I/O
+ *
+ * @entity:     pointer to entity
+ *
+ * Return: true if the entity main function is one of the V4L2 I/O types
+ *      (video, VBI or SDR radio); false otherwise.
+ */
+static inline bool is_media_entity_v4l2_io(struct media_entity *entity)
+{
+        if (!entity)
+                return false;
+        switch (entity->function) {
+        case MEDIA_ENT_F_IO_V4L:
+        case MEDIA_ENT_F_IO_VBI:
+        case MEDIA_ENT_F_IO_SWRADIO:
+                return true;
+        default:
+                return false;
+        }
+}
+/**
+ * is_media_entity_v4l2_subdev - return true if the entity main function is
+ *                               associated with the V4L2 API subdev usage
+ *
+ * @entity:     pointer to entity
+ *
+ * This is an ancillary function used by subdev-based V4L2 drivers.
+ * It checks if the entity function is one of functions used by a V4L2 subdev,
+ * e. g. camera-relatef functions, analog TV decoder, TV tuner, V4L2 DSPs.
+ */
+static inline bool is_media_entity_v4l2_subdev(struct media_entity *entity)
+{
+        if (!entity)
+                return false;
+        switch (entity->function) {
+        case MEDIA_ENT_F_V4L2_SUBDEV_UNKNOWN:
+        case MEDIA_ENT_F_CAM_SENSOR:
+        case MEDIA_ENT_F_FLASH:
+        case MEDIA_ENT_F_LENS:
+        case MEDIA_ENT_F_ATV_DECODER:
+        case MEDIA_ENT_F_TUNER:
+                return true;
+        default:
+                return false;
+        }
+}
+/**
+ * __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.
+ */
+__must_check int __media_entity_enum_init(struct media_entity_enum *ent_enum,
+                                          int idx_max);
+/**
+ * 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);
+/**
+ * media_entity_enum_zero - Clear the entire enum
+ *
+ * @ent_enum: Entity enumeration to be cleared
+ */
+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
+ *
+ * @ent_enum: Entity enumeration
+ * @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
+ *
+ * @ent_enum: Entity enumeration
+ * @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;
-int media_entity_init(struct media_entity *entity, u16 num_pads,
+        __clear_bit(entity->internal_idx, ent_enum->bmap);
-                struct media_pad *pads, u16 extra_links);
+}
-void media_entity_cleanup(struct media_entity *entity);
+/**
+ * media_entity_enum_test - Test whether the entity is marked
+ *
+ * @ent_enum: Entity enumeration
+ * @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
+ *
+ * @ent_enum: Entity enumeration
+ * @entity: Entity to be tested
+ *
+ * Returns true if the entity was marked, and mark it before doing so.
+ */
+static inline bool
+media_entity_enum_test_and_set(struct media_entity_enum *ent_enum,
+                               struct media_entity *entity)
+{
+        if (WARN_ON(entity->internal_idx >= ent_enum->idx_max))
+                return true;
+        return __test_and_set_bit(entity->internal_idx, ent_enum->bmap);
+}
+/**
+ * media_entity_enum_empty - Test whether the entire enum is empty
+ *
+ * @ent_enum: Entity enumeration
+ *
+ * Returns true if the entity was marked.
+ */
+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
+ *
+ * @ent_enum1: First entity enumeration
+ * @ent_enum2: Second entity enumeration
+ *
+ * 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));
+}
+#define gobj_to_entity(gobj) \
+                container_of(gobj, struct media_entity, graph_obj)
+#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)
+#define gobj_to_link(gobj) \
+                container_of(gobj, struct media_link, graph_obj)
+#define gobj_to_pad(gobj) \
+                container_of(gobj, struct media_pad, graph_obj)
+#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)
+/**
+ *  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
+ * media graph object. It is called automatically if media_*_create()
+ * 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.
+ */
+void media_gobj_create(struct media_device *mdev,
+                    enum media_gobj_type type,
+                    struct media_gobj *gobj);
+/**
+ *  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.
+ */
+void media_gobj_destroy(struct media_gobj *gobj);
+/**
+ * media_entity_pads_init() - Initialize the entity pads
+ *
+ * @entity:     entity where the pads belong
+ * @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.
+ *
+ * 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.
+ */
+int media_entity_pads_init(struct media_entity *entity, u16 num_pads,
+                      struct media_pad *pads);
+/**
+ * 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).
+ */
+static inline void media_entity_cleanup(struct media_entity *entity) {};
+/**
+ * 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:
+ * 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.
+ *
+ * NOTE:
+ *
+ * Before calling this function, media_entity_pads_init() and
+ * media_device_register_entity() should be called previously for both ends.
+ */
+__must_check int media_create_pad_link(struct media_entity *source,
+                        u16 source_pad, struct media_entity *sink,
+                        u16 sink_pad, u32 flags);
+/**
+ * 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:
+ * 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);
-int media_entity_create_link(struct media_entity *source, u16 source_pad,
-                struct media_entity *sink, u16 sink_pad, u32 flags);
 void __media_entity_remove_links(struct media_entity *entity);
+/**
+ * media_entity_remove_links() - remove all links associated with an entity
+ *
+ * @entity:     pointer to &media_entity
+ *
+ * Note: this is called automatically when an entity is unregistered via
+ * media_device_register_entity().
+ */
 void media_entity_remove_links(struct media_entity *entity);
+/**
+ * __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.
+ */
 int __media_entity_setup_link(struct media_link *link, u32 flags);
+/**
+ * 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.
+ *
+ * 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.
+ */
 int media_entity_setup_link(struct media_link *link, u32 flags);
+/**
+ * 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);
+/**
+ * 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.
+ */
 struct media_pad *media_entity_remote_pad(struct media_pad *pad);
+/**
+ * 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.
+ */
 struct media_entity *media_entity_get(struct media_entity *entity);
+__must_check int media_entity_graph_walk_init(
+        struct media_entity_graph *graph, struct media_device *mdev);
+/**
+ * media_entity_graph_walk_cleanup - Release resources used by graph walk.
+ *
+ * @graph: Media graph structure that will be used to walk the graph
+ */
+void media_entity_graph_walk_cleanup(struct media_entity_graph *graph);
+/**
+ * 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.
+ */
 void media_entity_put(struct media_entity *entity);
+/**
+ * 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
+ *
+ * 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().
+ */
 void media_entity_graph_walk_start(struct media_entity_graph *graph,
-                struct media_entity *entity);
+                                   struct media_entity *entity);
+/**
+ * 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.
+ */
 struct media_entity *
 media_entity_graph_walk_next(struct media_entity_graph *graph);
+/**
+ * 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().
+ */
 __must_check int media_entity_pipeline_start(struct media_entity *entity,
                                             struct media_pipeline *pipe);
+/**
+ * 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.
+ */
 void media_entity_pipeline_stop(struct media_entity *entity);
+/**
+ * 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.
+ */
+struct media_intf_devnode *
+__must_check media_devnode_create(struct media_device *mdev,
+                                  u32 type, u32 flags,
+                                  u32 major, u32 minor);
+/**
+ * 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.
+ */
+void media_devnode_remove(struct media_intf_devnode *devnode);
+struct media_link *
+/**
+ * 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:
+ * 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:
+ *
+ * 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.
+ */
+__must_check media_create_intf_link(struct media_entity *entity,
+                                    struct media_interface *intf,
+                                    u32 flags);
+/**
+ * __media_remove_intf_link() - remove a single interface link
+ *
+ * @link:       pointer to &media_link.
+ *
+ * Note: this is an unlocked version of media_remove_intf_link()
+ */
+void __media_remove_intf_link(struct media_link *link);
+/**
+ * media_remove_intf_link() - remove a single interface link
+ *
+ * @link:       pointer to &media_link.
+ *
+ * Note: prefer to use this one, instead of __media_remove_intf_link()
+ */
+void media_remove_intf_link(struct media_link *link);
+/**
+ * __media_remove_intf_links() - remove all links associated with an interface
+ *
+ * @intf:       pointer to &media_interface
+ *
+ * Note: this is an unlocked version of media_remove_intf_links().
+ */
+void __media_remove_intf_links(struct media_interface *intf);
+/**
+ * media_remove_intf_links() - remove all links associated with an interface
+ *
+ * @intf:       pointer to &media_interface
+ *
+ * Notes:
+ *
+ * this is called automatically when an entity is unregistered via
+ * media_device_register_entity() and by media_devnode_remove().
+ *
+ * Prefer to use this one, instead of __media_remove_intf_links().
+ */
+void media_remove_intf_links(struct media_interface *intf);
 #define media_entity_call(entity, operation, args...)                   \
        (((entity)->ops && (entity)->ops->operation) ?                  \
         (entity)->ops->operation((entity) , ##args) : -ENOIOCTLCMD)
diff --git a/include/media/tuner.h b/include/media/tuner.h
index 486b6a54363b..e5321fda5489 100644
--- a/include/media/tuner.h
+++ b/include/media/tuner.h
@@ -21,6 +21,14 @@
 #include <linux/videodev2.h>
+/* Tuner PADs */
+/* FIXME: is this the right place for it? */
+enum tuner_pad_index {
+        TUNER_PAD_RF_INPUT,
+        TUNER_PAD_IF_OUTPUT,
+        TUNER_NUM_PADS
+};
 #define ADDR_UNSET (255)
 #define TUNER_TEMIC_PAL                 0        /* 4002 FH5 (3X 7756, 9483) */
diff --git a/include/media/v4l2-dev.h b/include/media/v4l2-dev.h
index acbcd2f5fe7f..eeabf20e87a6 100644
--- a/include/media/v4l2-dev.h
+++ b/include/media/v4l2-dev.h
@@ -86,6 +86,7 @@ struct video_device
 {
 #if defined(CONFIG_MEDIA_CONTROLLER)
        struct media_entity entity;
+        struct media_intf_devnode *intf_devnode;
 #endif
        /* device ops */
        const struct v4l2_file_operations *fops;
diff --git a/include/uapi/linux/media.h b/include/uapi/linux/media.h
index 4e816be3de39..1e3c8cb43bd7 100644
--- a/include/uapi/linux/media.h
+++ b/include/uapi/linux/media.h
@@ -23,6 +23,9 @@
 #ifndef __LINUX_MEDIA_H
 #define __LINUX_MEDIA_H
+#ifndef __KERNEL__
+#include <stdint.h>
+#endif
 #include <linux/ioctl.h>
 #include <linux/types.h>
 #include <linux/version.h>
@@ -42,33 +45,107 @@ struct media_device_info {
 #define MEDIA_ENT_ID_FLAG_NEXT          (1 << 31)
+/*
+ * Initial value to be used when a new entity is created
+ * Drivers should change it to something useful
+ */
+#define MEDIA_ENT_F_UNKNOWN     0x00000000
+/*
+ * Base number ranges for entity functions
+ *
+ * NOTE: those ranges and entity function number are phased just to
+ * make it easier to maintain this file. Userspace should not rely on
+ * the ranges to identify a group of function types, as newer
+ * functions can be added with any name within the full u32 range.
+ */
+#define MEDIA_ENT_F_BASE                0x00000000
+#define MEDIA_ENT_F_OLD_BASE            0x00010000
+#define MEDIA_ENT_F_OLD_SUBDEV_BASE     0x00020000
+/*
+ * DVB entities
+ */
+#define MEDIA_ENT_F_DTV_DEMOD           (MEDIA_ENT_F_BASE + 1)
+#define MEDIA_ENT_F_TS_DEMUX            (MEDIA_ENT_F_BASE + 2)
+#define MEDIA_ENT_F_DTV_CA              (MEDIA_ENT_F_BASE + 3)
+#define MEDIA_ENT_F_DTV_NET_DECAP       (MEDIA_ENT_F_BASE + 4)
+/*
+ * Connectors
+ */
+/* It is a responsibility of the entity drivers to add connectors and links */
+#define MEDIA_ENT_F_CONN_RF             (MEDIA_ENT_F_BASE + 21)
+#define MEDIA_ENT_F_CONN_SVIDEO         (MEDIA_ENT_F_BASE + 22)
+#define MEDIA_ENT_F_CONN_COMPOSITE      (MEDIA_ENT_F_BASE + 23)
+/* For internal test signal generators and other debug connectors */
+#define MEDIA_ENT_F_CONN_TEST           (MEDIA_ENT_F_BASE + 24)
+/*
+ * I/O entities
+ */
+#define MEDIA_ENT_F_IO_DTV              (MEDIA_ENT_F_BASE + 31)
+#define MEDIA_ENT_F_IO_VBI              (MEDIA_ENT_F_BASE + 32)
+#define MEDIA_ENT_F_IO_SWRADIO          (MEDIA_ENT_F_BASE + 33)
+/*
+ * Don't touch on those. The ranges MEDIA_ENT_F_OLD_BASE and
+ * MEDIA_ENT_F_OLD_SUBDEV_BASE are kept to keep backward compatibility
+ * with the legacy v1 API.The number range is out of range by purpose:
+ * several previously reserved numbers got excluded from this range.
+ *
+ * Subdevs are initialized with MEDIA_ENT_T_V4L2_SUBDEV_UNKNOWN,
+ * in order to preserve backward compatibility.
+ * Drivers must change to the proper subdev type before
+ * registering the entity.
+ */
+#define MEDIA_ENT_F_IO_V4L              (MEDIA_ENT_F_OLD_BASE + 1)
+#define MEDIA_ENT_F_CAM_SENSOR          (MEDIA_ENT_F_OLD_SUBDEV_BASE + 1)
+#define MEDIA_ENT_F_FLASH               (MEDIA_ENT_F_OLD_SUBDEV_BASE + 2)
+#define MEDIA_ENT_F_LENS                (MEDIA_ENT_F_OLD_SUBDEV_BASE + 3)
+#define MEDIA_ENT_F_ATV_DECODER         (MEDIA_ENT_F_OLD_SUBDEV_BASE + 4)
+/*
+ * It is a responsibility of the entity drivers to add connectors and links
+ *      for the tuner entities.
+ */
+#define MEDIA_ENT_F_TUNER               (MEDIA_ENT_F_OLD_SUBDEV_BASE + 5)
+#define MEDIA_ENT_F_V4L2_SUBDEV_UNKNOWN MEDIA_ENT_F_OLD_SUBDEV_BASE
+#ifndef __KERNEL__
+/*
+ * Legacy symbols used to avoid userspace compilation breakages
+ *
+ * Those symbols map the entity function into types and should be
+ * used only on legacy programs for legacy hardware. Don't rely
+ * on those for MEDIA_IOC_G_TOPOLOGY.
+ */
 #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_ENT_TYPE_SHIFT)
+#define MEDIA_ENT_T_DEVNODE             MEDIA_ENT_F_OLD_BASE
-#define MEDIA_ENT_T_DEVNODE_V4L         (MEDIA_ENT_T_DEVNODE + 1)
+#define MEDIA_ENT_T_DEVNODE_V4L         MEDIA_ENT_F_IO_V4L
 #define MEDIA_ENT_T_DEVNODE_FB          (MEDIA_ENT_T_DEVNODE + 2)
 #define MEDIA_ENT_T_DEVNODE_ALSA        (MEDIA_ENT_T_DEVNODE + 3)
-#define MEDIA_ENT_T_DEVNODE_DVB_FE      (MEDIA_ENT_T_DEVNODE + 4)
+#define MEDIA_ENT_T_DEVNODE_DVB         (MEDIA_ENT_T_DEVNODE + 4)
-#define MEDIA_ENT_T_DEVNODE_DVB_DEMUX   (MEDIA_ENT_T_DEVNODE + 5)
-#define MEDIA_ENT_T_DEVNODE_DVB_DVR     (MEDIA_ENT_T_DEVNODE + 6)
-#define MEDIA_ENT_T_DEVNODE_DVB_CA      (MEDIA_ENT_T_DEVNODE + 7)
-#define MEDIA_ENT_T_DEVNODE_DVB_NET     (MEDIA_ENT_T_DEVNODE + 8)
-/* Legacy symbol. Use it to avoid userspace compilation breakages */
-#define MEDIA_ENT_T_DEVNODE_DVB         MEDIA_ENT_T_DEVNODE_DVB_FE
-#define MEDIA_ENT_T_V4L2_SUBDEV         (2 << MEDIA_ENT_TYPE_SHIFT)
-#define MEDIA_ENT_T_V4L2_SUBDEV_SENSOR  (MEDIA_ENT_T_V4L2_SUBDEV + 1)
-#define MEDIA_ENT_T_V4L2_SUBDEV_FLASH   (MEDIA_ENT_T_V4L2_SUBDEV + 2)
-#define MEDIA_ENT_T_V4L2_SUBDEV_LENS    (MEDIA_ENT_T_V4L2_SUBDEV + 3)
-/* A converter of analogue video to its digital representation. */
-#define MEDIA_ENT_T_V4L2_SUBDEV_DECODER (MEDIA_ENT_T_V4L2_SUBDEV + 4)
-#define MEDIA_ENT_T_V4L2_SUBDEV_TUNER   (MEDIA_ENT_T_V4L2_SUBDEV + 5)
+#define MEDIA_ENT_T_UNKNOWN             MEDIA_ENT_F_UNKNOWN
+#define MEDIA_ENT_T_V4L2_VIDEO          MEDIA_ENT_F_IO_V4L
+#define MEDIA_ENT_T_V4L2_SUBDEV         MEDIA_ENT_F_V4L2_SUBDEV_UNKNOWN
+#define MEDIA_ENT_T_V4L2_SUBDEV_SENSOR  MEDIA_ENT_F_CAM_SENSOR
+#define MEDIA_ENT_T_V4L2_SUBDEV_FLASH   MEDIA_ENT_F_FLASH
+#define MEDIA_ENT_T_V4L2_SUBDEV_LENS    MEDIA_ENT_F_LENS
+#define MEDIA_ENT_T_V4L2_SUBDEV_DECODER MEDIA_ENT_F_ATV_DECODER
+#define MEDIA_ENT_T_V4L2_SUBDEV_TUNER   MEDIA_ENT_F_TUNER
+#endif
+/* Entity flags */
 #define MEDIA_ENT_FL_DEFAULT            (1 << 0)
+#define MEDIA_ENT_FL_CONNECTOR          (1 << 1)
 struct media_entity_desc {
        __u32 id;
@@ -151,6 +228,10 @@ struct media_pad_desc {
 #define MEDIA_LNK_FL_IMMUTABLE          (1 << 1)
 #define MEDIA_LNK_FL_DYNAMIC            (1 << 2)
+#define MEDIA_LNK_FL_LINK_TYPE          (0xf << 28)
+#  define MEDIA_LNK_FL_DATA_LINK        (0 << 28)
+#  define MEDIA_LNK_FL_INTERFACE_LINK   (1 << 28)
 struct media_link_desc {
        struct media_pad_desc source;
        struct media_pad_desc sink;
@@ -167,9 +248,120 @@ struct media_links_enum {
        __u32 reserved[4];
 };
+/* Interface type ranges */
+#define MEDIA_INTF_T_DVB_BASE   0x00000100
+#define MEDIA_INTF_T_V4L_BASE   0x00000200
+/* Interface types */
+#define MEDIA_INTF_T_DVB_FE     (MEDIA_INTF_T_DVB_BASE)
+#define MEDIA_INTF_T_DVB_DEMUX  (MEDIA_INTF_T_DVB_BASE + 1)
+#define MEDIA_INTF_T_DVB_DVR    (MEDIA_INTF_T_DVB_BASE + 2)
+#define MEDIA_INTF_T_DVB_CA     (MEDIA_INTF_T_DVB_BASE + 3)
+#define MEDIA_INTF_T_DVB_NET    (MEDIA_INTF_T_DVB_BASE + 4)
+#define MEDIA_INTF_T_V4L_VIDEO  (MEDIA_INTF_T_V4L_BASE)
+#define MEDIA_INTF_T_V4L_VBI    (MEDIA_INTF_T_V4L_BASE + 1)
+#define MEDIA_INTF_T_V4L_RADIO  (MEDIA_INTF_T_V4L_BASE + 2)
+#define MEDIA_INTF_T_V4L_SUBDEV (MEDIA_INTF_T_V4L_BASE + 3)
+#define MEDIA_INTF_T_V4L_SWRADIO (MEDIA_INTF_T_V4L_BASE + 4)
+/*
+ * MC next gen API definitions
+ *
+ * NOTE: The declarations below are close to the MC RFC for the Media
+ *       Controller, the next generation. Yet, there are a few adjustments
+ *       to do, as we want to be able to have a functional API before
+ *       the MC properties change. Those will be properly marked below.
+ *       Please also notice that I removed "num_pads", "num_links",
+ *       from the proposal, as a proper userspace application will likely
+ *       use lists for pads/links, just as we intend to do in Kernelspace.
+ *       The API definition should be freed from fields that are bound to
+ *       some specific data structure.
+ *
+ * FIXME: Currently, I opted to name the new types as "media_v2", as this
+ *        won't cause any conflict with the Kernelspace namespace, nor with
+ *        the previous kAPI media_*_desc namespace. This can be changed
+ *        later, before the adding this API upstream.
+ */
+#if 0 /* Let's postpone it to Kernel 4.6 */
+struct media_v2_entity {
+        __u32 id;
+        char name[64];          /* FIXME: move to a property? (RFC says so) */
+        __u32 function;         /* Main function of the entity */
+        __u16 reserved[12];
+};
+/* Should match the specific fields at media_intf_devnode */
+struct media_v2_intf_devnode {
+        __u32 major;
+        __u32 minor;
+};
+struct media_v2_interface {
+        __u32 id;
+        __u32 intf_type;
+        __u32 flags;
+        __u32 reserved[9];
+        union {
+                struct media_v2_intf_devnode devnode;
+                __u32 raw[16];
+        };
+};
+struct media_v2_pad {
+        __u32 id;
+        __u32 entity_id;
+        __u32 flags;
+        __u16 reserved[9];
+};
+struct media_v2_link {
+        __u32 id;
+        __u32 source_id;
+        __u32 sink_id;
+        __u32 flags;
+        __u32 reserved[5];
+};
+struct media_v2_topology {
+        __u64 topology_version;
+        __u32 num_entities;
+        __u32 reserved1;
+        __u64 ptr_entities;
+        __u32 num_interfaces;
+        __u32 reserved2;
+        __u64 ptr_interfaces;
+        __u32 num_pads;
+        __u32 reserved3;
+        __u64 ptr_pads;
+        __u32 num_links;
+        __u32 reserved4;
+        __u64 ptr_links;
+};
+static inline void __user *media_get_uptr(__u64 arg)
+{
+        return (void __user *)(uintptr_t)arg;
+}
+#endif
+/* ioctls */
 #define MEDIA_IOC_DEVICE_INFO           _IOWR('|', 0x00, struct media_device_info)
 #define MEDIA_IOC_ENUM_ENTITIES         _IOWR('|', 0x01, struct media_entity_desc)
 #define MEDIA_IOC_ENUM_LINKS            _IOWR('|', 0x02, struct media_links_enum)
 #define MEDIA_IOC_SETUP_LINK            _IOWR('|', 0x03, struct media_link_desc)
+#if 0 /* Let's postpone it to Kernel 4.6 */
+#define MEDIA_IOC_G_TOPOLOGY            _IOWR('|', 0x04, struct media_v2_topology)
+#endif
 #endif /* __LINUX_MEDIA_H */