include/regmap.h

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