lib/devicetree.h - kvm-unit-tests - Git at Google

 #ifndef _DEVICETREE_H_
 #define _DEVICETREE_H_
 /*
  * devicetree builds on libfdt to implement abstractions and accessors
  * for Linux required device tree content. The accessors provided are
  * common across architectures. See section III of the kernel doc
  * Documentation/devicetree/booting-without-of.txt
  *
  * Copyright (C) 2014, Red Hat Inc, Andrew Jones <drjones@redhat.com>
  *
  * This work is licensed under the terms of the GNU LGPL, version 2.
  */
 #include "libcflat.h"
 #include "libfdt/libfdt.h"

 /**********************************************************************
  * devicetree init and libfdt helpers
  **********************************************************************/

 /* dt_init initializes devicetree with a pointer to an fdt, @fdt_ptr */
 extern int dt_init(const void *fdt_ptr);

 /* get the fdt pointer that devicetree is using */
 extern const void *dt_fdt(void);

 /* check for an initialized, valid devicetree */
 extern bool dt_available(void);

 /* traverse child nodes */
 #define dt_for_each_subnode(n, s)					\
 	for (s = fdt_first_subnode(dt_fdt(), n);			\
 	     s != -FDT_ERR_NOTFOUND;					\
 	     s = fdt_next_subnode(dt_fdt(), s))

 /**********************************************************************
  * Abstractions for required node types and properties
  **********************************************************************/

 struct dt_device {
 	int fdtnode;
 	const struct dt_bus *bus;

 	/*
 	 * info is a pointer to device specific data, which may be
 	 * used by the bus match() and translate() functions
 	 */
 	void *info;
 };

 struct dt_bus {
 	/*
 	 * match a device @dev to an fdt node @fdtnode
 	 * returns
 	 *  - a positive value on match
 	 *  - zero on no match
 	 *  - a negative FDT_ERR_* value on failure
 	 */
 	int (*match)(const struct dt_device *dev, int fdtnode);

 	/*
 	 * translate the @regidx'th "address size" tuple of
 	 * @dev's fdt node's "reg" property, and store the result
 	 * in @reg, a bus specific structure
 	 * returns
 	 *  - zero on success
 	 *  - a negative FDT_ERR_* value on failure
 	 */
 	int (*translate)(const struct dt_device *dev, int regidx, void *reg);
 };

 /* dt_bus_match_any matches any fdt node, i.e. it always returns true */
 extern int dt_bus_match_any(const struct dt_device *dev, int fdtnode);

 /* the processor bus (pbus) address type and register tuple */
 typedef u64 dt_pbus_addr_t;
 struct dt_pbus_reg {
 	dt_pbus_addr_t addr;
 	dt_pbus_addr_t size;
 };

 static inline dt_pbus_addr_t dt_pbus_read_cells(u32 nr_cells, u32 *cells)
 {
 	switch (nr_cells) {
 	case 1: return cells[0];
 	case 2: return ((u64)cells[0] << 32) | cells[1];
 	}
 	return (~0ULL);
 }

 /*
  * dt_pbus_translate translates device node regs for the
  * processor bus using the parent node's #address-cells
  * and #size-cells and dt_pbus_read_cells()
  * returns
  *  - zero on success
  *  - a negative FDT_ERR_* value on failure
  */
 extern int dt_pbus_translate(const struct dt_device *dev, int regidx,
 			     void *reg);

 /*
  * dt_pbus_translate_node is the same as dt_pbus_translate but
  * operates on an fdt node instead of a dt_device
  */
 extern int dt_pbus_translate_node(int fdtnode, int regidx,
 				  struct dt_pbus_reg *reg);

 /*
  * dt_pbus_get_base is an alias for
  *     dt_pbus_translate(dev, 0, base)
  * returns
  *  - zero on success
  *  - a negative FDT_ERR_* value on failure
  */
 static inline int dt_pbus_get_base(const struct dt_device *dev,
 				   struct dt_pbus_reg *base)
 {
 	return dt_pbus_translate(dev, 0, base);
 }

 /*
  * dt_bus_init_defaults initializes @bus with
  *  match		<- dt_bus_match_any
  *  translate		<- dt_pbus_translate
  */
 extern void dt_bus_init_defaults(struct dt_bus *bus);

 /*
  * dt_device_init initializes a dt_device with the given parameters
  */
 extern void dt_device_init(struct dt_device *dev, const struct dt_bus *bus,
 			   void *info);

 static inline void dt_device_bind_node(struct dt_device *dev, int fdtnode)
 {
 	dev->fdtnode = fdtnode;
 }

 /*
  * dt_device_find_compatible finds a @compatible node
  * returns
  *  - node (>= 0) on success
  *  - a negative FDT_ERR_* value on failure
  */
 extern int dt_device_find_compatible(const struct dt_device *dev,
 				     const char *compatible);

 /*
  * dt_pbus_get_base_compatible simply bundles many functions into one.
  * It finds the first @compatible fdt node, then translates the 0th reg
  * tuple (the base) using the processor bus translation, and finally it
  * stores that result in @base.
  * returns
  *  - zero on success
  *  - a negative FDT_ERR_* value on failure
  */
 extern int dt_pbus_get_base_compatible(const char *compatible,
 				       struct dt_pbus_reg *base);

 /**********************************************************************
  * Low-level accessors for required node types and properties
  **********************************************************************/

 /*
  * dt_get_nr_cells sets @nr_address_cells and @nr_size_cells to the
  * #address-cells and #size-cells properties of @fdtnode
  * returns
  *  - zero on success
  *  - a negative FDT_ERR_* value on failure
  */
 extern int dt_get_nr_cells(int fdtnode, u32 *nr_address_cells,
 					u32 *nr_size_cells);

 /* dt_reg is a structure for "raw" reg tuples */
 #define MAX_ADDRESS_CELLS	4
 #define MAX_SIZE_CELLS		4
 struct dt_reg {
 	u32 nr_address_cells, nr_size_cells;
 	u32 address_cells[MAX_ADDRESS_CELLS];
 	u32 size_cells[MAX_SIZE_CELLS];
 };

 /*
  * dt_reg_init initialize a dt_reg struct to zero and sets
  * nr_address_cells and nr_size_cells to @nr_address_cells and
  * @nr_size_cells respectively.
  */
 extern void dt_reg_init(struct dt_reg *reg, u32 nr_address_cells,
 					    u32 nr_size_cells);

 /*
  * dt_get_reg gets the @regidx'th reg tuple of @fdtnode's reg property
  * and stores it in @reg. @reg must be initialized.
  * returns
  *  - zero on success
  *  - a negative FDT_ERR_* value on failure
  */
 extern int dt_get_reg(int fdtnode, int regidx, struct dt_reg *reg);

 /**********************************************************************
  * High-level accessors for required node types and properties
  **********************************************************************/

 /*
  * dt_get_bootargs gets the string pointer from /chosen/bootargs
  * returns
  *  - zero on success
  *  - a negative FDT_ERR_* value on failure, and @bootargs
  *    will be set to NULL
  */
 extern int dt_get_bootargs(const char **bootargs);

 /*
  * dt_get_default_console_node gets the node of the path stored in
  * /chosen/stdout-path (or the deprecated /chosen/linux,stdout-path)
  * returns
  *  - the node (>= 0) on success
  *  - a negative FDT_ERR_* value on failure
  */
 extern int dt_get_default_console_node(void);

 /*
  * dt_get_initrd gets the physical address of the initrd and its
  * size from /chosen
  * returns
  *  - zero on success
  *  - a negative FDT_ERR_* value on failure, and @initrd will be
  *    set to NULL and @size set to zero
  */
 extern int dt_get_initrd(const char **initrd, u32 *size);

 /*
  * dt_get_memory_params gets the memory parameters from the /memory node(s)
  * storing each memory region ("address size" tuple) in consecutive entries
  * of @regs, up to @nr_regs
  * returns
  *  - number of memory regions found on success
  *  - a negative FDT_ERR_* value on failure
  */
 extern int dt_get_memory_params(struct dt_pbus_reg *regs, int nr_regs);

 /*
  * dt_for_each_cpu_node runs @func on each cpu node in the /cpus node
  * passing it its fdt node, its reg property value, and @info
  *  - zero on success
  *  - a negative FDT_ERR_* value on failure
  */
 extern int dt_for_each_cpu_node(void (*func)(int fdtnode, u64 regval,
 				void *info), void *info);

 #endif /* _DEVICETREE_H_ */
	#ifndef _DEVICETREE_H_
	#define _DEVICETREE_H_
	/*
	* devicetree builds on libfdt to implement abstractions and accessors
	* for Linux required device tree content. The accessors provided are
	* common across architectures. See section III of the kernel doc
	* Documentation/devicetree/booting-without-of.txt
	*
	* Copyright (C) 2014, Red Hat Inc, Andrew Jones <drjones@redhat.com>
	*
	* This work is licensed under the terms of the GNU LGPL, version 2.
	*/
	#include "libcflat.h"
	#include "libfdt/libfdt.h"

	/**********************************************************************
	* devicetree init and libfdt helpers
	**********************************************************************/

	/* dt_init initializes devicetree with a pointer to an fdt, @fdt_ptr */
	extern int dt_init(const void *fdt_ptr);

	/* get the fdt pointer that devicetree is using */
	extern const void *dt_fdt(void);

	/* check for an initialized, valid devicetree */
	extern bool dt_available(void);

	/* traverse child nodes */
	#define dt_for_each_subnode(n, s) \
	for (s = fdt_first_subnode(dt_fdt(), n); \
	s != -FDT_ERR_NOTFOUND; \
	s = fdt_next_subnode(dt_fdt(), s))

	/**********************************************************************
	* Abstractions for required node types and properties
	**********************************************************************/

	struct dt_device {
	int fdtnode;
	const struct dt_bus *bus;

	/*
	* info is a pointer to device specific data, which may be
	* used by the bus match() and translate() functions
	*/
	void *info;
	};

	struct dt_bus {
	/*
	* match a device @dev to an fdt node @fdtnode
	* returns
	* - a positive value on match
	* - zero on no match
	* - a negative FDT_ERR_* value on failure
	*/
	int (match)(const struct dt_device dev, int fdtnode);

	/*
	* translate the @regidx'th "address size" tuple of
	* @dev's fdt node's "reg" property, and store the result
	* in @reg, a bus specific structure
	* returns
	* - zero on success
	* - a negative FDT_ERR_* value on failure
	*/
	int (translate)(const struct dt_device dev, int regidx, void *reg);
	};

	/* dt_bus_match_any matches any fdt node, i.e. it always returns true */
	extern int dt_bus_match_any(const struct dt_device *dev, int fdtnode);

	/* the processor bus (pbus) address type and register tuple */
	typedef u64 dt_pbus_addr_t;
	struct dt_pbus_reg {
	dt_pbus_addr_t addr;
	dt_pbus_addr_t size;
	};

	static inline dt_pbus_addr_t dt_pbus_read_cells(u32 nr_cells, u32 *cells)
	{
	switch (nr_cells) {
	case 1: return cells[0];
	case 2: return ((u64)cells[0] << 32) \| cells[1];
	}
	return (~0ULL);
	}

	/*
	* dt_pbus_translate translates device node regs for the
	* processor bus using the parent node's #address-cells
	* and #size-cells and dt_pbus_read_cells()
	* returns
	* - zero on success
	* - a negative FDT_ERR_* value on failure
	*/
	extern int dt_pbus_translate(const struct dt_device *dev, int regidx,
	void *reg);

	/*
	* dt_pbus_translate_node is the same as dt_pbus_translate but
	* operates on an fdt node instead of a dt_device
	*/
	extern int dt_pbus_translate_node(int fdtnode, int regidx,
	struct dt_pbus_reg *reg);

	/*
	* dt_pbus_get_base is an alias for
	* dt_pbus_translate(dev, 0, base)
	* returns
	* - zero on success
	* - a negative FDT_ERR_* value on failure
	*/
	static inline int dt_pbus_get_base(const struct dt_device *dev,
	struct dt_pbus_reg *base)
	{
	return dt_pbus_translate(dev, 0, base);
	}

	/*
	* dt_bus_init_defaults initializes @bus with
	* match <- dt_bus_match_any
	* translate <- dt_pbus_translate
	*/
	extern void dt_bus_init_defaults(struct dt_bus *bus);

	/*
	* dt_device_init initializes a dt_device with the given parameters
	*/
	extern void dt_device_init(struct dt_device dev, const struct dt_bus bus,
	void *info);

	static inline void dt_device_bind_node(struct dt_device *dev, int fdtnode)
	{
	dev->fdtnode = fdtnode;
	}

	/*
	* dt_device_find_compatible finds a @compatible node
	* returns
	* - node (>= 0) on success
	* - a negative FDT_ERR_* value on failure
	*/
	extern int dt_device_find_compatible(const struct dt_device *dev,
	const char *compatible);

	/*
	* dt_pbus_get_base_compatible simply bundles many functions into one.
	* It finds the first @compatible fdt node, then translates the 0th reg
	* tuple (the base) using the processor bus translation, and finally it
	* stores that result in @base.
	* returns
	* - zero on success
	* - a negative FDT_ERR_* value on failure
	*/
	extern int dt_pbus_get_base_compatible(const char *compatible,
	struct dt_pbus_reg *base);

	/**********************************************************************
	* Low-level accessors for required node types and properties
	**********************************************************************/

	/*
	* dt_get_nr_cells sets @nr_address_cells and @nr_size_cells to the
	* #address-cells and #size-cells properties of @fdtnode
	* returns
	* - zero on success
	* - a negative FDT_ERR_* value on failure
	*/
	extern int dt_get_nr_cells(int fdtnode, u32 *nr_address_cells,
	u32 *nr_size_cells);

	/* dt_reg is a structure for "raw" reg tuples */
	#define MAX_ADDRESS_CELLS 4
	#define MAX_SIZE_CELLS 4
	struct dt_reg {
	u32 nr_address_cells, nr_size_cells;
	u32 address_cells[MAX_ADDRESS_CELLS];
	u32 size_cells[MAX_SIZE_CELLS];
	};

	/*
	* dt_reg_init initialize a dt_reg struct to zero and sets
	* nr_address_cells and nr_size_cells to @nr_address_cells and
	* @nr_size_cells respectively.
	*/
	extern void dt_reg_init(struct dt_reg *reg, u32 nr_address_cells,
	u32 nr_size_cells);

	/*
	* dt_get_reg gets the @regidx'th reg tuple of @fdtnode's reg property
	* and stores it in @reg. @reg must be initialized.
	* returns
	* - zero on success
	* - a negative FDT_ERR_* value on failure
	*/
	extern int dt_get_reg(int fdtnode, int regidx, struct dt_reg *reg);

	/**********************************************************************
	* High-level accessors for required node types and properties
	**********************************************************************/

	/*
	* dt_get_bootargs gets the string pointer from /chosen/bootargs
	* returns
	* - zero on success
	* - a negative FDT_ERR_* value on failure, and @bootargs
	* will be set to NULL
	*/
	extern int dt_get_bootargs(const char **bootargs);

	/*
	* dt_get_default_console_node gets the node of the path stored in
	* /chosen/stdout-path (or the deprecated /chosen/linux,stdout-path)
	* returns
	* - the node (>= 0) on success
	* - a negative FDT_ERR_* value on failure
	*/
	extern int dt_get_default_console_node(void);

	/*
	* dt_get_initrd gets the physical address of the initrd and its
	* size from /chosen
	* returns
	* - zero on success
	* - a negative FDT_ERR_* value on failure, and @initrd will be
	* set to NULL and @size set to zero
	*/
	extern int dt_get_initrd(const char *initrd, u32 size);

	/*
	* dt_get_memory_params gets the memory parameters from the /memory node(s)
	* storing each memory region ("address size" tuple) in consecutive entries
	* of @regs, up to @nr_regs
	* returns
	* - number of memory regions found on success
	* - a negative FDT_ERR_* value on failure
	*/
	extern int dt_get_memory_params(struct dt_pbus_reg *regs, int nr_regs);

	/*
	* dt_for_each_cpu_node runs @func on each cpu node in the /cpus node
	* passing it its fdt node, its reg property value, and @info
	* - zero on success
	* - a negative FDT_ERR_* value on failure
	*/
	extern int dt_for_each_cpu_node(void (*func)(int fdtnode, u64 regval,
	void info), void info);

	#endif /* _DEVICETREE_H_ */