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 #define regmap_write32(map, ptr, member, val) \
 150         regmap_write(map, (uint32_t *)(ptr)->member - (uint32_t *)(ptr), val)
 151
 152 #define regmap_read32(map, ptr, member, valp) \
 153         regmap_read(map, (uint32_t *)(ptr)->member - (uint32_t *)(ptr), valp)
 154
 155 /**
 156  * regmap_update_bits() - Perform a read/modify/write using a mask
 157  *
 158  * @map:        The map returned by regmap_init_mem*()
 159  * @offset:     Offset of the memory
 160  * @mask:       Mask to apply to the read value
 161  * @val:        Value to apply to the value to write
 162  * Return: 0 if OK, -ve on error
 163  */
 164 int regmap_update_bits(struct regmap *map, uint offset, uint mask, uint val);
 165
 166 /**
 167  * regmap_init_mem() - Set up a new register map that uses memory access
 168  *
 169  * @node:       Device node that uses this map
 170  * @mapp:       Returns allocated map
 171  * Return: 0 if OK, -ve on error
 172  *
 173  * Use regmap_uninit() to free it.
 174  */
 175 int regmap_init_mem(ofnode node, struct regmap **mapp);
 176
 177 /**
 178  * regmap_init_mem_platdata() - Set up a new memory register map for
 179  *                              of-platdata
 180  *
 181  * @dev:        Device that uses this map
 182  * @reg:        List of address, size pairs
 183  * @count:      Number of pairs (e.g. 1 if the regmap has a single entry)
 184  * @mapp:       Returns allocated map
 185  * Return: 0 if OK, -ve on error
 186  *
 187  * This creates a new regmap with a list of regions passed in, rather than
 188  * using the device tree. It only supports 32-bit machines.
 189  *
 190  * Use regmap_uninit() to free it.
 191  *
 192  */
 193 int regmap_init_mem_platdata(struct udevice *dev, fdt_val_t *reg, int count,
 194                              struct regmap **mapp);
 195
 196 /**
 197  * regmap_get_range() - Obtain the base memory address of a regmap range
 198  *
 199  * @map:        Regmap to query
 200  * @range_num:  Range to look up
 201  * Return: Pointer to the range in question if OK, NULL on error
 202  */
 203 void *regmap_get_range(struct regmap *map, unsigned int range_num);
 204
 205 /**
 206  * regmap_uninit() - free a previously inited regmap
 207  *
 208  * @map:        Regmap to free
 209  * Return: 0 if OK, -ve on error
 210  */
 211 int regmap_uninit(struct regmap *map);
 212
 213 #endif