[U-Boot] [PATCH v10 08/16] regmap: Add raw read/write functions

Mario Six mario.six at gdsys.cc
Thu Oct 4 07:00:47 UTC 2018


The regmap functions currently assume that all register map accesses
have a data width of 32 bits, but there are maps that have different
widths.

To rectify this, implement the regmap_raw_read and regmap_raw_write
functions from the Linux kernel API that specify the width of a desired
read or write operation on a regmap.

Implement the regmap_read and regmap_write functions using these raw
functions in a backwards-compatible manner.

Reviewed-by: Anatolij Gustschin <agust at denx.de>
Signed-off-by: Mario Six <mario.six at gdsys.cc>

---

v9 -> v10:
* Switched to the read{b,w,l,q} and write{b,w,l,q} functions for
  register map access

v8 -> v9:
* Removed forgotten "fpgamap" in documentation

v7 -> v8:
No changes

v6 -> v7:
* Fixed wrong variable type in 64-bit read (u32 -> u64)
* Added 64-bit case in write function

v5 -> v6:
* Corrected format specifier
* Added support for 64-bit reads/writes

v4 -> v5:
No changes

v3 -> v4:
* Switched 'ranges[0] + offset' to 'ranges[0].start + offset'
* Explained the difference between the raw and non-raw read/write
  functions better in the docs

v2 -> v3:
* Implement the "raw" functions from Linux instead of adding a size
  parameter to the regmap_{read,write} functions
* Fixed style violation
* Improved error handling

v1 -> v2:
New in v2

---
 drivers/core/regmap.c | 64 +++++++++++++++++++++++++++++++++++++++++++++------
 include/regmap.h      | 58 ++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 115 insertions(+), 7 deletions(-)

diff --git a/drivers/core/regmap.c b/drivers/core/regmap.c
index 154426269d..916d9272ea 100644
--- a/drivers/core/regmap.c
+++ b/drivers/core/regmap.c
@@ -188,22 +188,72 @@ 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) = readb((u8 *)ptr);
+		break;
+	case REGMAP_SIZE_16:
+		*((u16 *)valp) = readw((u16 *)ptr);
+		break;
+	case REGMAP_SIZE_32:
+		*((u32 *)valp) = readl((u32 *)ptr);
+		break;
+#if defined(readq)
+	case REGMAP_SIZE_64:
+		*((u64 *)valp) = readq((u64 *)ptr);
+		break;
+#endif
+	default:
+		debug("%s: regmap size %zu 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:
+		writeb(*((u8 *)val), (u8 *)ptr);
+		break;
+	case REGMAP_SIZE_16:
+		writew(*((u16 *)val), (u16 *)ptr);
+		break;
+	case REGMAP_SIZE_32:
+		writel(*((u32 *)val), (u32 *)ptr);
+		break;
+#if defined(writeq)
+	case REGMAP_SIZE_64:
+		writeq(*((u64 *)val), (u64 *)ptr);
+		break;
+#endif
+	default:
+		debug("%s: regmap size %zu 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)
diff --git a/include/regmap.h b/include/regmap.h
index 32f75e06f5..f23664e8ba 100644
--- a/include/regmap.h
+++ b/include/regmap.h
@@ -8,6 +8,21 @@
 #define __REGMAP_H

 /**
+ * enum regmap_size_t - Access sizes for regmap reads and writes
+ *
+ * @REGMAP_SIZE_8: 8-bit read/write access size
+ * @REGMAP_SIZE_16: 16-bit read/write access size
+ * @REGMAP_SIZE_32: 32-bit read/write access size
+ * @REGMAP_SIZE_64: 64-bit read/write access size
+ */
+enum regmap_size_t {
+	REGMAP_SIZE_8 = 1,
+	REGMAP_SIZE_16 = 2,
+	REGMAP_SIZE_32 = 4,
+	REGMAP_SIZE_64 = 8,
+};
+
+/**
  * struct regmap_range - a register map range
  *
  * @start:	Start address
@@ -41,6 +56,10 @@ struct regmap {
  * @offset:	Offset in the regmap to write to
  * @val:	Data to write to the regmap at the specified offset
  *
+ * Note that this function will only write values of 32 bit width to the
+ * regmap; if the size of data to be read is different, the regmap_raw_write
+ * function can be used.
+ *
  * Return: 0 if OK, -ve on error
  */
 int regmap_write(struct regmap *map, uint offset, uint val);
@@ -53,10 +72,49 @@ int regmap_write(struct regmap *map, uint offset, uint val);
  * @valp:	Pointer to the buffer to receive the data read from the regmap
  *		at the specified offset
  *
+ * Note that this function will only read values of 32 bit width from the
+ * regmap; if the size of data to be read is different, the regmap_raw_read
+ * function can be used.
+ *
  * Return: 0 if OK, -ve on error
  */
 int regmap_read(struct regmap *map, uint offset, uint *valp);

+/**
+ * regmap_raw_write() - Write a value of specified length to a regmap
+ *
+ * @map:	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
+ *
+ * Note that this function will, as opposed to regmap_write, write data of
+ * arbitrary length to the regmap, and not just 32-bit values, and is thus a
+ * generalized version of regmap_write.
+ *
+ * Return: 0 if OK, -ve on error
+ */
+int regmap_raw_write(struct regmap *map, uint offset, const void *val,
+		     size_t val_len);
+
+/**
+ * regmap_raw_read() - Read a value of specified length 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
+ * @val_len:	Length of the data to be read from the regmap
+ *
+ * Note that this function will, as opposed to regmap_read, read data of
+ * arbitrary length from the regmap, and not just 32-bit values, and is thus a
+ * generalized version of regmap_read.
+ *
+ * Return: 0 if OK, -ve on error
+ */
+int regmap_raw_read(struct regmap *map, 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)

--
2.11.0



More information about the U-Boot mailing list