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 #define regmap_write32(map, ptr, member, val) \
 119         regmap_write(map, (uint32_t *)(ptr)->member - (uint32_t *)(ptr), val)
 120
 121 #define regmap_read32(map, ptr, member, valp) \
 122         regmap_read(map, (uint32_t *)(ptr)->member - (uint32_t *)(ptr), valp)
 123
 124 /**
 125  * regmap_update_bits() - Perform a read/modify/write using a mask
 126  *
 127  * @map:        The map returned by regmap_init_mem*()
 128  * @offset:     Offset of the memory
 129  * @mask:       Mask to apply to the read value
 130  * @val:        Value to apply to the value to write
 131  * Return: 0 if OK, -ve on error
 132  */
 133 int regmap_update_bits(struct regmap *map, uint offset, uint mask, uint val);
 134
 135 /**
 136  * regmap_init_mem() - Set up a new register map that uses memory access
 137  *
 138  * @node:       Device node that uses this map
 139  * @mapp:       Returns allocated map
 140  * Return: 0 if OK, -ve on error
 141  *
 142  * Use regmap_uninit() to free it.
 143  */
 144 int regmap_init_mem(ofnode node, struct regmap **mapp);
 145
 146 /**
 147  * regmap_init_mem_platdata() - Set up a new memory register map for
 148  *                              of-platdata
 149  *
 150  * @dev:        Device that uses this map
 151  * @reg:        List of address, size pairs
 152  * @count:      Number of pairs (e.g. 1 if the regmap has a single entry)
 153  * @mapp:       Returns allocated map
 154  * Return: 0 if OK, -ve on error
 155  *
 156  * This creates a new regmap with a list of regions passed in, rather than
 157  * using the device tree. It only supports 32-bit machines.
 158  *
 159  * Use regmap_uninit() to free it.
 160  *
 161  */
 162 int regmap_init_mem_platdata(struct udevice *dev, fdt_val_t *reg, int count,
 163                              struct regmap **mapp);
 164
 165 /**
 166  * regmap_get_range() - Obtain the base memory address of a regmap range
 167  *
 168  * @map:        Regmap to query
 169  * @range_num:  Range to look up
 170  * Return: Pointer to the range in question if OK, NULL on error
 171  */
 172 void *regmap_get_range(struct regmap *map, unsigned int range_num);
 173
 174 /**
 175  * regmap_uninit() - free a previously inited regmap
 176  *
 177  * @map:        Regmap to free
 178  * Return: 0 if OK, -ve on error
 179  */
 180 int regmap_uninit(struct regmap *map);
 181
 182 #endif