of: reserved_mem: add support for using more than one region for given device (59ce4039) · Commits · 戴 / test

drivers/of/of_reserved_mem.c

+64 −21

Original line number	Diff line number	Diff line
		@@ -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];
		@@ -289,53 +290,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)
		return -ENODEV;
		if (!np \|\| !dev)
		return -EINVAL;

		rmem = __find_rmem(np);
		of_node_put(np);
		target = of_parse_phandle(np, "memory-region", idx);
		if (!target)
		return -EINVAL;

		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;

include/linux/of_reserved_mem.h

+22 −3

Original line number	Diff line number	Diff line
		#ifndef __OF_RESERVED_MEM_H
		#define __OF_RESERVED_MEM_H

		struct device;
		#include <linux/device.h>

		struct of_phandle_args;
		struct reserved_mem_ops;

		@@ -28,14 +29,17 @@ typedef int (reservedmem_of_init_fn)(struct reserved_mem rmem);
		_OF_DECLARE(reservedmem, name, compat, init, reservedmem_of_init_fn)

		#ifdef CONFIG_OF_RESERVED_MEM
		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);
		void of_reserved_mem_device_release(struct device *dev);

		void fdt_init_reserved_mem(void);
		void fdt_reserved_mem_save_node(unsigned long node, const char *uname,
		phys_addr_t base, phys_addr_t size);
		#else
		static inline int of_reserved_mem_device_init(struct device *dev)
		static inline int of_reserved_mem_device_init_by_idx(struct device *dev,
		struct device_node *np, int idx)
		{
		return -ENOSYS;
		}
		@@ -46,4 +50,19 @@ static inline void fdt_reserved_mem_save_node(unsigned long node,
		const char *uname, phys_addr_t base, phys_addr_t size) { }
		#endif

		/**
		* of_reserved_mem_device_init() - assign reserved memory region to given device
		* @dev: Pointer to the device to configure
		*
		* This function assigns respective DMA-mapping operations based on the first
		* reserved memory region specified by 'memory-region' property in device tree
		* node of the given device.
		*
		* Returns error code or zero on success.
		*/
		static inline int of_reserved_mem_device_init(struct device *dev)
		{
		return of_reserved_mem_device_init_by_idx(dev, dev->of_node, 0);
		}

		#endif /* __OF_RESERVED_MEM_H */

Admin message