Merge tag 'media/v4.8-1' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-media

Pull media updates from Mauro Carvalho Chehab:

 - new framework support for HDMI CEC and remote control support

 - new encoding codec driver for Mediatek SoC

 - new frontend driver: helene tuner

 - added support for NetUp almost universal devices, with supports
   DVB-C/S/S2/T/T2 and ISDB-T

 - the mn88472 frontend driver got promoted from staging

 - a new driver for RCar video input

 - some soc_camera legacy drivers got removed: timb, omap1, mx2, mx3

 - lots of driver cleanups, improvements and fixups

* tag 'media/v4.8-1' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-media: (377 commits)
  [media] cec: always check all_device_types and features
  [media] cec: poll should check if there is room in the tx queue
  [media] vivid: support monitor all mode
  [media] cec: fix test for unconfigured adapter in main message loop
  [media] cec: limit the size of the transmit queue
  [media] cec: zero unused msg part after msg->len
  [media] cec: don't set fh to NULL in CEC_TRANSMIT
  [media] cec: clear all status fields before transmit and always fill in sequence
  [media] cec: CEC_RECEIVE overwrote the timeout field
  [media] cxd2841er: Reading SNR for DVB-C added
  [media] cxd2841er: Reading BER and UCB for DVB-C added
  [media] cxd2841er: fix switch-case for DVB-C
  [media] cxd2841er: fix signal strength scale for ISDB-T
  [media] cxd2841er: adjust the dB scale for DVB-C
  [media] cxd2841er: provide signal strength for DVB-C
  [media] cxd2841er: fix BER report via DVBv5 stats API
  [media] mb86a20s: apply mask to val after checking for read failure
  [media] airspy: fix error logic during device register
  [media] s5p-cec/TODO: add TODO item
  [media] cec/TODO: drop comment about sphinx documentation
  ...

1 files changed, 63 insertions, 20 deletions

diff --git a/drivers/of/of_reserved_mem.c b/drivers/of/of_reserved_mem.c
index 216648233874..06af99f64ad8 100644
--- a/drivers/of/of_reserved_mem.c
+++ b/drivers/of/of_reserved_mem.c
@@ -21,6 +21,7 @@
 #include <linux/sizes.h>
 #include <linux/of_reserved_mem.h>
 #include <linux/sort.h>
+#include <linux/slab.h>
 
 #define MAX_RESERVED_REGIONS    16
 static struct reserved_mem reserved_mem[MAX_RESERVED_REGIONS];
@@ -296,53 +297,95 @@ static inline struct reserved_mem *__find_rmem(struct device_node *node)
         return NULL;
 }
 
+struct rmem_assigned_device {
+        struct device *dev;
+        struct reserved_mem *rmem;
+        struct list_head list;
+};
+
+static LIST_HEAD(of_rmem_assigned_device_list);
+static DEFINE_MUTEX(of_rmem_assigned_device_mutex);
+
 /**
- * of_reserved_mem_device_init() - assign reserved memory region to given device
+ * of_reserved_mem_device_init_by_idx() - assign reserved memory region to
+ *                                        given device
+ * @dev:        Pointer to the device to configure
+ * @np:         Pointer to the device_node with 'reserved-memory' property
+ * @idx:        Index of selected region
  *
- * This function assign memory region pointed by "memory-region" device tree
- * property to the given device.
+ * This function assigns respective DMA-mapping operations based on reserved
+ * memory region specified by 'memory-region' property in @np node to the @dev
+ * device. When driver needs to use more than one reserved memory region, it
+ * should allocate child devices and initialize regions by name for each of
+ * child device.
+ *
+ * Returns error code or zero on success.
  */
-int of_reserved_mem_device_init(struct device *dev)
+int of_reserved_mem_device_init_by_idx(struct device *dev,
+                                       struct device_node *np, int idx)
 {
+        struct rmem_assigned_device *rd;
+        struct device_node *target;
         struct reserved_mem *rmem;
-        struct device_node *np;
         int ret;
 
-        np = of_parse_phandle(dev->of_node, "memory-region", 0);
-        if (!np)
+        if (!np || !dev)
+                return -EINVAL;
+
+        target = of_parse_phandle(np, "memory-region", idx);
+        if (!target)
                 return -ENODEV;
 
-        rmem = __find_rmem(np);
-        of_node_put(np);
+        rmem = __find_rmem(target);
+        of_node_put(target);
 
         if (!rmem || !rmem->ops || !rmem->ops->device_init)
                 return -EINVAL;
 
+        rd = kmalloc(sizeof(struct rmem_assigned_device), GFP_KERNEL);
+        if (!rd)
+                return -ENOMEM;
+
         ret = rmem->ops->device_init(rmem, dev);
-        if (ret == 0)
+        if (ret == 0) {
+                rd->dev = dev;
+                rd->rmem = rmem;
+
+                mutex_lock(&of_rmem_assigned_device_mutex);
+                list_add(&rd->list, &of_rmem_assigned_device_list);
+                mutex_unlock(&of_rmem_assigned_device_mutex);
+
                 dev_info(dev, "assigned reserved memory node %s\n", rmem->name);
+        } else {
+                kfree(rd);
+        }
 
         return ret;
 }
-EXPORT_SYMBOL_GPL(of_reserved_mem_device_init);
+EXPORT_SYMBOL_GPL(of_reserved_mem_device_init_by_idx);
 
 /**
  * of_reserved_mem_device_release() - release reserved memory device structures
+ * @dev:        Pointer to the device to deconfigure
  *
  * This function releases structures allocated for memory region handling for
  * the given device.
  */
 void of_reserved_mem_device_release(struct device *dev)
 {
-        struct reserved_mem *rmem;
-        struct device_node *np;
-
-        np = of_parse_phandle(dev->of_node, "memory-region", 0);
-        if (!np)
-                return;
-
-        rmem = __find_rmem(np);
-        of_node_put(np);
+        struct rmem_assigned_device *rd;
+        struct reserved_mem *rmem = NULL;
+
+        mutex_lock(&of_rmem_assigned_device_mutex);
+        list_for_each_entry(rd, &of_rmem_assigned_device_list, list) {
+                if (rd->dev == dev) {
+                        rmem = rd->rmem;
+                        list_del(&rd->list);
+                        kfree(rd);
+                        break;
+                }
+        }
+        mutex_unlock(&of_rmem_assigned_device_mutex);
 
         if (!rmem || !rmem->ops || !rmem->ops->device_release)
                 return;