test: regmap: Increase size of syscon0 memory

index 6a574eaa412..32f75e06f59 100644
@@ -21,8 +21,8 @@ struct regmap_range {
 /**
  * struct regmap - a way of accessing hardware/bus registers
  *
- * @range_count: Number of ranges available within the map
- * @ranges:	Array of ranges
+ * @range_count:	Number of ranges available within the map
+ * @ranges:		Array of ranges
  */
 struct regmap {
 	int range_count;

@@ -33,7 +33,28 @@ struct regmap {
  * Interface to provide access to registers either through a direct memory
  * bus or through a peripheral bus like I2C, SPI.
  */
+
+/**
+ * regmap_write() - Write a 32-bit value to a regmap
+ *
+ * @map:	Regmap to write to
+ * @offset:	Offset in the regmap to write to
+ * @val:	Data to write to the regmap at the specified offset
+ *
+ * Return: 0 if OK, -ve on error
+ */
 int regmap_write(struct regmap *map, uint offset, uint val);
+
+/**
+ * regmap_read() - Read a 32-bit value from a regmap
+ *
+ * @map:	Regmap to read from
+ * @offset:	Offset in the regmap to read from
+ * @valp:	Pointer to the buffer to receive the data read from the regmap
+ *		at the specified offset
+ *
+ * Return: 0 if OK, -ve on error
+ */
 int regmap_read(struct regmap *map, uint offset, uint *valp);
 
 #define regmap_write32(map, ptr, member, val) \

@@ -49,31 +70,36 @@ int regmap_read(struct regmap *map, uint offset, uint *valp);
  * @offset:	Offset of the memory
  * @mask:	Mask to apply to the read value
  * @val:	Value to apply to the value to write
+ * Return: 0 if OK, -ve on error
  */
 int regmap_update_bits(struct regmap *map, uint offset, uint mask, uint val);
 
 /**
  * regmap_init_mem() - Set up a new register map that uses memory access
  *
- * Use regmap_uninit() to free it.
- *
  * @node:	Device node that uses this map
  * @mapp:	Returns allocated map
+ * Return: 0 if OK, -ve on error
+ *
+ * Use regmap_uninit() to free it.
  */
 int regmap_init_mem(ofnode node, struct regmap **mapp);
 
 /**
- * regmap_init_mem_platdata() - Set up a new memory register map for of-platdata
+ * regmap_init_mem_platdata() - Set up a new memory register map for
+ *				of-platdata
+ *
+ * @dev:	Device that uses this map
+ * @reg:	List of address, size pairs
+ * @count:	Number of pairs (e.g. 1 if the regmap has a single entry)
+ * @mapp:	Returns allocated map
+ * Return: 0 if OK, -ve on error
  *
  * This creates a new regmap with a list of regions passed in, rather than
  * using the device tree. It only supports 32-bit machines.
  *
  * Use regmap_uninit() to free it.
  *
- * @dev:	Device that uses this map
- * @reg:	List of address, size pairs
- * @count:	Number of pairs (e.g. 1 if the regmap has a single entry)
- * @mapp:	Returns allocated map
  */
 int regmap_init_mem_platdata(struct udevice *dev, fdt_val_t *reg, int count,
 			     struct regmap **mapp);

@@ -83,11 +109,15 @@ int regmap_init_mem_platdata(struct udevice *dev, fdt_val_t *reg, int count,
  *
  * @map:	Regmap to query
  * @range_num:	Range to look up
+ * Return: Pointer to the range in question if OK, NULL on error
  */
 void *regmap_get_range(struct regmap *map, unsigned int range_num);
 
 /**
  * regmap_uninit() - free a previously inited regmap
+ *
+ * @map:	Regmap to free
+ * Return: 0 if OK, -ve on error
  */
 int regmap_uninit(struct regmap *map);
 

index 8e5c3bcf61b..77f6f520a06 100644
@@ -17,6 +17,12 @@
 
 DECLARE_GLOBAL_DATA_PTR;
 
+/**
+ * regmap_alloc() - Allocate a regmap with a given number of ranges.
+ *
+ * @count: Number of ranges to be allocated for the regmap.
+ * Return: A pointer to the newly allocated regmap, or NULL on error.
+ */
 static struct regmap *regmap_alloc(int count)
 {
 	struct regmap *map;

index 77f6f520a06..4ebab233490 100644
@@ -67,8 +67,25 @@ int regmap_init_mem(ofnode node, struct regmap **mapp)
 	struct resource r;
 
 	addr_len = ofnode_read_simple_addr_cells(ofnode_get_parent(node));
+	if (addr_len < 0) {
+		debug("%s: Error while reading the addr length (ret = %d)\n",
+		      ofnode_get_name(node), addr_len);
+		return addr_len;
+	}
+
 	size_len = ofnode_read_simple_size_cells(ofnode_get_parent(node));
+	if (size_len < 0) {
+		debug("%s: Error while reading the size length: (ret = %d)\n",
+		      ofnode_get_name(node), size_len);
+		return size_len;
+	}
+
 	both_len = addr_len + size_len;
+	if (!both_len) {
+		debug("%s: Both addr and size length are zero\n",
+		      ofnode_get_name(node));
+		return -EINVAL;
+	}
 
 	len = ofnode_read_size(node, "reg");
 	if (len < 0)

index 4ebab233490..25c1ae5d7df 100644
@@ -56,6 +56,58 @@ int regmap_init_mem_platdata(struct udevice *dev, fdt_val_t *reg, int count,
 	return 0;
 }
 #else
+/**
+ * init_range() - Initialize a single range of a regmap
+ * @node:     Device node that will use the map in question
+ * @range:    Pointer to a regmap_range structure that will be initialized
+ * @addr_len: The length of the addr parts of the reg property
+ * @size_len: The length of the size parts of the reg property
+ * @index:    The index of the range to initialize
+ *
+ * This function will read the necessary 'reg' information from the device tree
+ * (the 'addr' part, and the 'length' part), and initialize the range in
+ * quesion.
+ *
+ * Return: 0 if OK, -ve on error
+ */
+static int init_range(ofnode node, struct regmap_range *range, int addr_len,
+		      int size_len, int index)
+{
+	fdt_size_t sz;
+	struct resource r;
+
+	if (of_live_active()) {
+		int ret;
+
+		ret = of_address_to_resource(ofnode_to_np(node),
+					     index, &r);
+		if (ret) {
+			debug("%s: Could not read resource of range %d (ret = %d)\n",
+			      ofnode_get_name(node), index, ret);
+			return ret;
+		}
+
+		range->start = r.start;
+		range->size = r.end - r.start + 1;
+	} else {
+		int offset = ofnode_to_offset(node);
+
+		range->start = fdtdec_get_addr_size_fixed(gd->fdt_blob, offset,
+							  "reg", index,
+							  addr_len, size_len,
+							  &sz, true);
+		if (range->start == FDT_ADDR_T_NONE) {
+			debug("%s: Could not read start of range %d\n",
+			      ofnode_get_name(node), index);
+			return -EINVAL;
+		}
+
+		range->size = sz;
+	}
+
+	return 0;
+}
+
 int regmap_init_mem(ofnode node, struct regmap **mapp)
 {
 	struct regmap_range *range;

@@ -64,7 +116,6 @@ int regmap_init_mem(ofnode node, struct regmap **mapp)
 	int addr_len, size_len, both_len;
 	int len;
 	int index;
-	struct resource r;
 
 	addr_len = ofnode_read_simple_addr_cells(ofnode_get_parent(node));
 	if (addr_len < 0) {

@@ -101,17 +152,10 @@ int regmap_init_mem(ofnode node, struct regmap **mapp)
 
 	for (range = map->ranges, index = 0; count > 0;
 	     count--, range++, index++) {
-		fdt_size_t sz;
-		if (of_live_active()) {
-			of_address_to_resource(ofnode_to_np(node), index, &r);
-			range->start = r.start;
-			range->size = r.end - r.start + 1;
-		} else {
-			range->start = fdtdec_get_addr_size_fixed(gd->fdt_blob,
-					ofnode_to_offset(node), "reg", index,
-					addr_len, size_len, &sz, true);
-			range->size = sz;
-		}
+		int ret = init_range(node, range, addr_len, size_len, index);
+
+		if (ret)
+			return ret;
 	}
 
 	*mapp = map;

index 25c1ae5d7df..154426269d9 100644
@@ -139,12 +139,18 @@ int regmap_init_mem(ofnode node, struct regmap **mapp)
 	}
 
 	len = ofnode_read_size(node, "reg");
-	if (len < 0)
+	if (len < 0) {
+		debug("%s: Error while reading reg size (ret = %d)\n",
+		      ofnode_get_name(node), len);
 		return len;
+	}
 	len /= sizeof(fdt32_t);
 	count = len / both_len;
-	if (!count)
+	if (!count) {
+		debug("%s: Not enough data in reg property\n",
+		      ofnode_get_name(node));
 		return -EINVAL;
+	}
 
 	map = regmap_alloc(count);
 	if (!map)

index 154426269d9..87c4c950a63 100644
@@ -188,22 +188,62 @@ int regmap_uninit(struct regmap *map)
 	return 0;
 }
 
+int regmap_raw_read(struct regmap *map, uint offset, void *valp, size_t val_len)
+{
+	void *ptr;
+
+	ptr = map_physmem(map->ranges[0].start + offset, val_len, MAP_NOCACHE);
+
+	switch (val_len) {
+	case REGMAP_SIZE_8:
+		*((u8 *)valp) = in_8((u8 *)ptr);
+		break;
+	case REGMAP_SIZE_16:
+		*((u16 *)valp) = in_le16((u16 *)ptr);
+		break;
+	case REGMAP_SIZE_32:
+		*((u32 *)valp) = in_le32((u32 *)ptr);
+		break;
+	default:
+		debug("%s: regmap size %u unknown\n", __func__, val_len);
+		return -EINVAL;
+	}
+	return 0;
+}
+
 int regmap_read(struct regmap *map, uint offset, uint *valp)
 {
-	u32 *ptr = map_physmem(map->ranges[0].start + offset, 4, MAP_NOCACHE);
+	return regmap_raw_read(map, offset, valp, REGMAP_SIZE_32);
+}
 
-	*valp = le32_to_cpu(readl(ptr));
+int regmap_raw_write(struct regmap *map, uint offset, const void *val,
+		     size_t val_len)
+{
+	void *ptr;
+
+	ptr = map_physmem(map->ranges[0].start + offset, val_len, MAP_NOCACHE);
+
+	switch (val_len) {
+	case REGMAP_SIZE_8:
+		out_8((u8 *)ptr, *((u8 *)val));
+		break;
+	case REGMAP_SIZE_16:
+		out_le16((u16 *)ptr, *((u16 *)val));
+		break;
+	case REGMAP_SIZE_32:
+		out_le32((u32 *)ptr, *((u32 *)val));
+		break;
+	default:
+		debug("%s: regmap size %u unknown\n", __func__, val_len);
+		return -EINVAL;
+	}
 
 	return 0;
 }
 
 int regmap_write(struct regmap *map, uint offset, uint val)
 {
-	u32 *ptr = map_physmem(map->ranges[0].start + offset, 4, MAP_NOCACHE);
-
-	writel(cpu_to_le32(val), ptr);
-
-	return 0;
+	return regmap_raw_write(map, offset, &val, REGMAP_SIZE_32);
 }
 
 int regmap_update_bits(struct regmap *map, uint offset, uint mask, uint val)

78 lines not on this page · raw message

index 87c4c950a63..86b35edc050 100644
@@ -188,11 +188,25 @@ int regmap_uninit(struct regmap *map)
 	return 0;
 }
 
-int regmap_raw_read(struct regmap *map, uint offset, void *valp, size_t val_len)
+int regmap_raw_read_range(struct regmap *map, uint range_num, uint offset,
+			  void *valp, size_t val_len)
 {
+	struct regmap_range *range;
 	void *ptr;
 
-	ptr = map_physmem(map->ranges[0].start + offset, val_len, MAP_NOCACHE);
+	if (range_num >= map->range_count) {
+		debug("%s: range index %d larger than range count\n",
+		      __func__, range_num);
+		return -ERANGE;
+	}
+	range = &map->ranges[range_num];
+
+	ptr = map_physmem(range->start + offset, val_len, MAP_NOCACHE);
+
+	if (offset + val_len > range->size) {
+		debug("%s: offset/size combination invalid\n", __func__);
+		return -ERANGE;
+	}
 
 	switch (val_len) {
 	case REGMAP_SIZE_8:

@@ -208,20 +222,39 @@ int regmap_raw_read(struct regmap *map, uint offset, void *valp, size_t val_len)
 		debug("%s: regmap size %u unknown\n", __func__, val_len);
 		return -EINVAL;
 	}
+
 	return 0;
 }
 
+int regmap_raw_read(struct regmap *map, uint offset, void *valp, size_t val_len)
+{
+	return regmap_raw_read_range(map, 0, offset, valp, val_len);
+}
+
 int regmap_read(struct regmap *map, uint offset, uint *valp)
 {
 	return regmap_raw_read(map, offset, valp, REGMAP_SIZE_32);
 }
 
-int regmap_raw_write(struct regmap *map, uint offset, const void *val,
-		     size_t val_len)
+int regmap_raw_write_range(struct regmap *map, uint range_num, uint offset,
+			   const void *val, size_t val_len)
 {
+	struct regmap_range *range;
 	void *ptr;
 
-	ptr = map_physmem(map->ranges[0].start + offset, val_len, MAP_NOCACHE);
+	if (range_num >= map->range_count) {
+		debug("%s: range index %d larger than range count\n",
+		      __func__, range_num);
+		return -ERANGE;
+	}
+	range = &map->ranges[range_num];
+
+	ptr = map_physmem(range->start + offset, val_len, MAP_NOCACHE);
+
+	if (offset + val_len > range->size) {
+		debug("%s: offset/size combination invalid\n", __func__);
+		return -ERANGE;
+	}
 
 	switch (val_len) {
 	case REGMAP_SIZE_8:

@@ -241,6 +274,12 @@ int regmap_raw_write(struct regmap *map, uint offset, const void *val,
 	return 0;
 }
 
+int regmap_raw_write(struct regmap *map, uint offset, const void *val,
+		     size_t val_len)
+{
+	return regmap_raw_write_range(map, 0, offset, val, val_len);
+}
+
 int regmap_write(struct regmap *map, uint offset, uint val)
 {
 	return regmap_raw_write(map, offset, &val, REGMAP_SIZE_32);

index 46ae4ed0a03..df672df9fe1 100644
@@ -113,6 +113,37 @@ int regmap_raw_write(struct regmap *map, uint offset, const void *val,
 int regmap_raw_read(struct regmap *map, uint offset, void *valp,
 		    size_t val_len);
 
+/**
+ * regmap_raw_write_range() - Write a value of specified length to a range of a
+ *			      regmap
+ *
+ * @map:	Regmap to write to
+ * @range_num:	Number of the range in the regmap to write to
+ * @offset:	Offset in the regmap to write to
+ * @val:	Value to write to the regmap at the specified offset
+ * @val_len:	Length of the data to be written to the regmap
+ *
+ * Return: 0 if OK, -ve on error
+ */
+int regmap_raw_write_range(struct regmap *map, uint range_num, uint offset,
+			   const void *val, size_t val_len);
+
+/**
+ * regmap_raw_read_range() - Read a value of specified length from a range of a
+ *			     regmap
+ *
+ * @map:	Regmap to read from
+ * @range_num:	Number of the range in the regmap to write to
+ * @offset:	Offset in the regmap to read from
+ * @valp:	Pointer to the buffer to receive the data read from the regmap
+ *		at the specified offset
+ * @val_len:	Length of the data to be read from the regmap
+ *
+ * Return: 0 if OK, -ve on error
+ */
+int regmap_raw_read_range(struct regmap *map, uint range_num, uint offset,
+			  void *valp, size_t val_len);
+
 #define regmap_write32(map, ptr, member, val) \
 	regmap_write(map, (uint32_t *)(ptr)->member - (uint32_t *)(ptr), val)
 

index df672df9fe1..85c4a8e502f 100644
@@ -144,11 +144,57 @@ int regmap_raw_write_range(struct regmap *map, uint range_num, uint offset,
 int regmap_raw_read_range(struct regmap *map, uint range_num, uint offset,
 			  void *valp, size_t val_len);
 
-#define regmap_write32(map, ptr, member, val) \
-	regmap_write(map, (uint32_t *)(ptr)->member - (uint32_t *)(ptr), val)
+/**
+ * regmap_range_set() - Set a value in a regmap range described by a struct
+ * @map:    Regmap in which a value should be set
+ * @range:  Range of the regmap in which a value should be set
+ * @type:   Structure type that describes the memory layout of the regmap range
+ * @member: Member of the describing structure that should be set in the regmap
+ *          range
+ * @val:    Value which should be written to the regmap range
+ */
+#define regmap_range_set(map, range, type, member, val) \
+	do { \
+		typeof(((type *)0)->member) __tmp = val; \
+		regmap_raw_write_range(map, range, offsetof(type, member), \
+				       &__tmp, sizeof(((type *)0)->member)); \
+	} while (0)
+
+/**
+ * regmap_set() - Set a value in a regmap described by a struct
+ * @map:    Regmap in which a value should be set
+ * @type:   Structure type that describes the memory layout of the regmap
+ * @member: Member of the describing structure that should be set in the regmap
+ * @val:    Value which should be written to the regmap
+ */
+#define regmap_set(map, type, member, val) \
+	regmap_range_set(map, 0, type, member, val)
 
-#define regmap_read32(map, ptr, member, valp) \
-	regmap_read(map, (uint32_t *)(ptr)->member - (uint32_t *)(ptr), valp)
+/**
+ * regmap_range_get() - Get a value from a regmap range described by a struct
+ * @map:    Regmap from which a value should be read
+ * @range:  Range of the regmap from which a value should be read
+ * @type:   Structure type that describes the memory layout of the regmap
+ *          range
+ * @member: Member of the describing structure that should be read in the
+ *          regmap range
+ * @valp:   Variable that receives the value read from the regmap range
+ */
+#define regmap_range_get(map, range, type, member, valp) \
+	regmap_raw_read_range(map, range, offsetof(type, member), \
+			      (void *)valp, sizeof(((type *)0)->member))
+
+/**
+ * regmap_get() - Get a value from a regmap described by a struct
+ * @map:    Regmap from which a value should be read
+ * @type:   Structure type that describes the memory layout of the regmap
+ *          range
+ * @member: Member of the describing structure that should be read in the
+ *          regmap
+ * @valp:   Variable that receives the value read from the regmap
+ */
+#define regmap_get(map, type, member, valp) \
+	regmap_range_get(map, 0, type, member, valp)
 
 /**
  * regmap_update_bits() - Perform a read/modify/write using a mask

index d4b86b3b03c..152b3a4b800 100644
@@ -116,3 +116,31 @@ static int dm_test_regmap_rw(struct unit_test_state *uts)
 }
 
 DM_TEST(dm_test_regmap_rw, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+
+/* Get/Set test */
+static int dm_test_regmap_getset(struct unit_test_state *uts)
+{
+	struct udevice *dev;
+	struct regmap *map;
+	uint reg;
+	struct layout {
+		u32 val0;
+		u32 val1;
+		u32 val2;
+		u32 val3;
+	};
+
+	ut_assertok(uclass_get_device(UCLASS_SYSCON, 0, &dev));
+	map = syscon_get_regmap(dev);
+	ut_assertok_ptr(map);
+
+	regmap_set(map, struct layout, val0, 0xcacafafa);
+	regmap_set(map, struct layout, val3, 0x55aa2211);
+
+	ut_assertok(regmap_get(map, struct layout, val0, &reg));
+	ut_assertok(regmap_get(map, struct layout, val3, &reg));
+
+	return 0;
+}
+
+DM_TEST(dm_test_regmap_getset, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);

74 lines not on this page · raw message

new file mode 100644
index 00000000000..088d3b65234
@@ -0,0 +1,23 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
+/*
+ * (C) Copyright 2017
+ * Mario Six,  Guntermann & Drunck GmbH, mario.six at gdsys.cc
+ */
+
+#ifndef _GDSYS_SOC_H_
+#define _GDSYS_SOC_H_
+
+/**
+ * gdsys_soc_get_fpga() - Retrieve pointer to parent bus' FPGA device
+ * @child:	The child device on the FPGA bus needing access to the FPGA.
+ * @fpga:	Pointer to the retrieved FPGA device.
+ *
+ * To access their register maps, devices on gdsys soc buses usually have
+ * facilitate the accessor function of the IHS FPGA their parent bus is
+ * attached to. To access the FPGA device from within the bus' children, this
+ * function returns a pointer to it.
+ *
+ * Return: 0 on success, -ve on failure
+ */
+int gdsys_soc_get_fpga(struct udevice *child, struct udevice **fpga);
+#endif /* _GDSYS_SOC_H_ */

867 lines not on this page · raw message

49 lines not on this page · raw message