[u-boot.git] / include / regmap.h

/* SPDX-License-Identifier: GPL-2.0+ */
/*
 * Copyright (c) 2015 Google, Inc
 * Written by Simon Glass <[email protected]>
 */

#ifndef __REGMAP_H
#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,
};

/**
 * enum regmap_endianness_t - Endianness for regmap reads and writes
 *
 * @REGMAP_NATIVE_ENDIAN: Native endian read/write accesses
 * @REGMAP_LITTLE_ENDIAN: Little endian read/write accesses
 * @REGMAP_BIG_ENDIAN: Big endian read/write accesses
 */
enum regmap_endianness_t {
	REGMAP_NATIVE_ENDIAN,
	REGMAP_LITTLE_ENDIAN,
	REGMAP_BIG_ENDIAN,
};

/**
 * struct regmap_range - a register map range
 *
 * @start:	Start address
 * @size:	Size in bytes
 */
struct regmap_range {
	ulong start;
	ulong size;
};

/**
 * struct regmap - a way of accessing hardware/bus registers
 *
 * @range_count:	Number of ranges available within the map
 * @ranges:		Array of ranges
 */
struct regmap {
	enum regmap_endianness_t endianness;
	int range_count;
	struct regmap_range ranges[0];
};

/*
 * 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
 *
 * 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);

/**
 * 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
 *
 * 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);

/**
 * 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);

/**
 * 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)

/**
 * 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
 *
 * @map:	The map returned by regmap_init_mem*()
 * @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
 *
 * @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
 *
 * @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.
 *
 */
int regmap_init_mem_platdata(struct udevice *dev, fdt_val_t *reg, int count,
			     struct regmap **mapp);

/**
 * regmap_get_range() - Obtain the base memory address of a regmap range
 *
 * @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);

#endif
Commit	Line	Data
83d290c5	1	/* SPDX-License-Identifier: GPL-2.0+ */
6f98b750 SG	2	/*
	3	* Copyright (c) 2015 Google, Inc
	4	* Written by Simon Glass <[email protected]>
6f98b750 SG	5	*/
	6
	7	#ifndef __REGMAP_H
	8	#define __REGMAP_H
	9
84ff8f62 MS	10	/**
	11	* enum regmap_size_t - Access sizes for regmap reads and writes
	12	*
	13	* @REGMAP_SIZE_8: 8-bit read/write access size
	14	* @REGMAP_SIZE_16: 16-bit read/write access size
	15	* @REGMAP_SIZE_32: 32-bit read/write access size
	16	* @REGMAP_SIZE_64: 64-bit read/write access size
	17	*/
	18	enum regmap_size_t {
	19	REGMAP_SIZE_8 = 1,
	20	REGMAP_SIZE_16 = 2,
	21	REGMAP_SIZE_32 = 4,
	22	REGMAP_SIZE_64 = 8,
	23	};
	24
9b77fe3b MS	25	/**
	26	* enum regmap_endianness_t - Endianness for regmap reads and writes
	27	*
	28	* @REGMAP_NATIVE_ENDIAN: Native endian read/write accesses
	29	* @REGMAP_LITTLE_ENDIAN: Little endian read/write accesses
	30	* @REGMAP_BIG_ENDIAN: Big endian read/write accesses
	31	*/
	32	enum regmap_endianness_t {
	33	REGMAP_NATIVE_ENDIAN,
	34	REGMAP_LITTLE_ENDIAN,
	35	REGMAP_BIG_ENDIAN,
	36	};
	37
6f98b750 SG	38	/**
	39	* struct regmap_range - a register map range
	40	*
	41	* @start: Start address
	42	* @size: Size in bytes
	43	*/
	44	struct regmap_range {
	45	ulong start;
	46	ulong size;
	47	};
	48
	49	/**
	50	* struct regmap - a way of accessing hardware/bus registers
	51	*
604b6696 MS	52	* @range_count: Number of ranges available within the map
604b6696 MS	53	* @ranges: Array of ranges
6f98b750 SG	54	*/
6f98b750 SG	55	struct regmap {
9b77fe3b	56	enum regmap_endianness_t endianness;
6f98b750	57	int range_count;
8c1de5e0	58	struct regmap_range ranges[0];
6f98b750 SG	59	};
	60
	61	/*
	62	* Interface to provide access to registers either through a direct memory
	63	* bus or through a peripheral bus like I2C, SPI.
	64	*/
604b6696 MS	65
	66	/**
	67	* regmap_write() - Write a 32-bit value to a regmap
	68	*
	69	* @map: Regmap to write to
	70	* @offset: Offset in the regmap to write to
	71	* @val: Data to write to the regmap at the specified offset
	72	*
84ff8f62 MS	73	* Note that this function will only write values of 32 bit width to the
	74	* regmap; if the size of data to be read is different, the regmap_raw_write
	75	* function can be used.
	76	*
604b6696 MS	77	* Return: 0 if OK, -ve on error
604b6696 MS	78	*/
6f98b750	79	int regmap_write(struct regmap *map, uint offset, uint val);
604b6696 MS	80
	81	/**
	82	* regmap_read() - Read a 32-bit value from a regmap
	83	*
	84	* @map: Regmap to read from
	85	* @offset: Offset in the regmap to read from
	86	* @valp: Pointer to the buffer to receive the data read from the regmap
	87	* at the specified offset
	88	*
84ff8f62 MS	89	* Note that this function will only read values of 32 bit width from the
	90	* regmap; if the size of data to be read is different, the regmap_raw_read
	91	* function can be used.
	92	*
604b6696 MS	93	* Return: 0 if OK, -ve on error
604b6696 MS	94	*/
6f98b750 SG	95	int regmap_read(struct regmap map, uint offset, uint valp);
6f98b750 SG	96
84ff8f62 MS	97	/**
	98	* regmap_raw_write() - Write a value of specified length to a regmap
	99	*
	100	* @map: Regmap to write to
	101	* @offset: Offset in the regmap to write to
	102	* @val: Value to write to the regmap at the specified offset
	103	* @val_len: Length of the data to be written to the regmap
	104	*
	105	* Note that this function will, as opposed to regmap_write, write data of
	106	* arbitrary length to the regmap, and not just 32-bit values, and is thus a
	107	* generalized version of regmap_write.
	108	*
	109	* Return: 0 if OK, -ve on error
	110	*/
	111	int regmap_raw_write(struct regmap map, uint offset, const void val,
	112	size_t val_len);
	113
	114	/**
	115	* regmap_raw_read() - Read a value of specified length from a regmap
	116	*
	117	* @map: Regmap to read from
	118	* @offset: Offset in the regmap to read from
	119	* @valp: Pointer to the buffer to receive the data read from the regmap
	120	* at the specified offset
	121	* @val_len: Length of the data to be read from the regmap
	122	*
	123	* Note that this function will, as opposed to regmap_read, read data of
	124	* arbitrary length from the regmap, and not just 32-bit values, and is thus a
	125	* generalized version of regmap_read.
	126	*
	127	* Return: 0 if OK, -ve on error
	128	*/
	129	int regmap_raw_read(struct regmap map, uint offset, void valp,
	130	size_t val_len);
	131
d5c7bd98 MS	132	/**
	133	* regmap_raw_write_range() - Write a value of specified length to a range of a
	134	* regmap
	135	*
	136	* @map: Regmap to write to
	137	* @range_num: Number of the range in the regmap to write to
	138	* @offset: Offset in the regmap to write to
	139	* @val: Value to write to the regmap at the specified offset
	140	* @val_len: Length of the data to be written to the regmap
	141	*
	142	* Return: 0 if OK, -ve on error
	143	*/
	144	int regmap_raw_write_range(struct regmap *map, uint range_num, uint offset,
	145	const void *val, size_t val_len);
	146
	147	/**
	148	* regmap_raw_read_range() - Read a value of specified length from a range of a
	149	* regmap
	150	*
	151	* @map: Regmap to read from
	152	* @range_num: Number of the range in the regmap to write to
	153	* @offset: Offset in the regmap to read from
	154	* @valp: Pointer to the buffer to receive the data read from the regmap
	155	* at the specified offset
	156	* @val_len: Length of the data to be read from the regmap
	157	*
	158	* Return: 0 if OK, -ve on error
	159	*/
	160	int regmap_raw_read_range(struct regmap *map, uint range_num, uint offset,
	161	void *valp, size_t val_len);
	162
e936397a MS	163	/**
	164	* regmap_range_set() - Set a value in a regmap range described by a struct
	165	* @map: Regmap in which a value should be set
	166	* @range: Range of the regmap in which a value should be set
	167	* @type: Structure type that describes the memory layout of the regmap range
	168	* @member: Member of the describing structure that should be set in the regmap
	169	* range
	170	* @val: Value which should be written to the regmap range
	171	*/
	172	#define regmap_range_set(map, range, type, member, val) \
	173	do { \
	174	typeof(((type *)0)->member) __tmp = val; \
	175	regmap_raw_write_range(map, range, offsetof(type, member), \
	176	&__tmp, sizeof(((type *)0)->member)); \
	177	} while (0)
	178
	179	/**
	180	* regmap_set() - Set a value in a regmap described by a struct
	181	* @map: Regmap in which a value should be set
	182	* @type: Structure type that describes the memory layout of the regmap
	183	* @member: Member of the describing structure that should be set in the regmap
	184	* @val: Value which should be written to the regmap
	185	*/
	186	#define regmap_set(map, type, member, val) \
	187	regmap_range_set(map, 0, type, member, val)
6f98b750	188
e936397a MS	189	/**
	190	* regmap_range_get() - Get a value from a regmap range described by a struct
	191	* @map: Regmap from which a value should be read
	192	* @range: Range of the regmap from which a value should be read
	193	* @type: Structure type that describes the memory layout of the regmap
	194	* range
	195	* @member: Member of the describing structure that should be read in the
	196	* regmap range
	197	* @valp: Variable that receives the value read from the regmap range
	198	*/
	199	#define regmap_range_get(map, range, type, member, valp) \
	200	regmap_raw_read_range(map, range, offsetof(type, member), \
	201	(void )valp, sizeof(((type )0)->member))
	202
	203	/**
	204	* regmap_get() - Get a value from a regmap described by a struct
	205	* @map: Regmap from which a value should be read
	206	* @type: Structure type that describes the memory layout of the regmap
	207	* range
	208	* @member: Member of the describing structure that should be read in the
	209	* regmap
	210	* @valp: Variable that receives the value read from the regmap
	211	*/
	212	#define regmap_get(map, type, member, valp) \
	213	regmap_range_get(map, 0, type, member, valp)
6f98b750	214
285cbcf9 NA	215	/**
	216	* regmap_update_bits() - Perform a read/modify/write using a mask
	217	*
	218	* @map: The map returned by regmap_init_mem*()
	219	* @offset: Offset of the memory
	220	* @mask: Mask to apply to the read value
	221	* @val: Value to apply to the value to write
604b6696	222	* Return: 0 if OK, -ve on error
285cbcf9 NA	223	*/
	224	int regmap_update_bits(struct regmap *map, uint offset, uint mask, uint val);
	225
6f98b750 SG	226	/**
	227	* regmap_init_mem() - Set up a new register map that uses memory access
	228	*
d3581236	229	* @node: Device node that uses this map
6f98b750	230	* @mapp: Returns allocated map
604b6696 MS	231	* Return: 0 if OK, -ve on error
	232	*
	233	* Use regmap_uninit() to free it.
6f98b750	234	*/
d3581236	235	int regmap_init_mem(ofnode node, struct regmap **mapp);
6f98b750	236
1e6ca1a6	237	/**
604b6696 MS	238	* regmap_init_mem_platdata() - Set up a new memory register map for
	239	* of-platdata
	240	*
	241	* @dev: Device that uses this map
	242	* @reg: List of address, size pairs
	243	* @count: Number of pairs (e.g. 1 if the regmap has a single entry)
	244	* @mapp: Returns allocated map
	245	* Return: 0 if OK, -ve on error
1e6ca1a6 SG	246	*
	247	* This creates a new regmap with a list of regions passed in, rather than
	248	* using the device tree. It only supports 32-bit machines.
	249	*
	250	* Use regmap_uninit() to free it.
	251	*
1e6ca1a6	252	*/
c20ee0ed	253	int regmap_init_mem_platdata(struct udevice dev, fdt_val_t reg, int count,
3b2a29e0 SG	254	struct regmap **mapp);
3b2a29e0 SG	255
6f98b750 SG	256	/**
	257	* regmap_get_range() - Obtain the base memory address of a regmap range
	258	*
	259	* @map: Regmap to query
	260	* @range_num: Range to look up
604b6696	261	* Return: Pointer to the range in question if OK, NULL on error
6f98b750 SG	262	*/
	263	void regmap_get_range(struct regmap map, unsigned int range_num);
	264
	265	/**
	266	* regmap_uninit() - free a previously inited regmap
604b6696 MS	267	*
	268	* @map: Regmap to free
	269	* Return: 0 if OK, -ve on error
6f98b750 SG	270	*/
	271	int regmap_uninit(struct regmap *map);
	272
	273	#endif