LXR linux/include/linux/regmap.h

   1#ifndef __LINUX_REGMAP_H
   2#define __LINUX_REGMAP_H
   3
   4/*
   5 * Register map access API
   6 *
   7 * Copyright 2011 Wolfson Microelectronics plc
   8 *
   9 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
  10 *
  11 * This program is free software; you can redistribute it and/or modify
  12 * it under the terms of the GNU General Public License version 2 as
  13 * published by the Free Software Foundation.
  14 */
  15
  16#include <linux/device.h>
  17#include <linux/list.h>
  18
  19struct module;
  20struct i2c_client;
  21struct spi_device;
  22
  23/* An enum of all the supported cache types */
  24enum regcache_type {
  25        REGCACHE_NONE,
  26        REGCACHE_INDEXED,
  27        REGCACHE_RBTREE,
  28        REGCACHE_LZO
  29};
  30
  31/**
  32 * Default value for a register.  We use an array of structs rather
  33 * than a simple array as many modern devices have very sparse
  34 * register maps.
  35 *
  36 * @reg: Register address.
  37 * @def: Register default value.
  38 */
  39struct reg_default {
  40        unsigned int reg;
  41        unsigned int def;
  42};
  43
  44/**
  45 * Configuration for the register map of a device.
  46 *
  47 * @reg_bits: Number of bits in a register address, mandatory.
  48 * @val_bits: Number of bits in a register value, mandatory.
  49 *
  50 * @writeable_reg: Optional callback returning true if the register
  51 *                 can be written to.
  52 * @readable_reg: Optional callback returning true if the register
  53 *                can be read from.
  54 * @volatile_reg: Optional callback returning true if the register
  55 *                value can't be cached.
  56 * @precious_reg: Optional callback returning true if the rgister
  57 *                should not be read outside of a call from the driver
  58 *                (eg, a clear on read interrupt status register).
  59 *
  60 * @max_register: Optional, specifies the maximum valid register index.
  61 * @reg_defaults: Power on reset values for registers (for use with
  62 *                register cache support).
  63 * @num_reg_defaults: Number of elements in reg_defaults.
  64 *
  65 * @read_flag_mask: Mask to be set in the top byte of the register when doing
  66 *                  a read.
  67 * @write_flag_mask: Mask to be set in the top byte of the register when doing
  68 *                   a write. If both read_flag_mask and write_flag_mask are
  69 *                   empty the regmap_bus default masks are used.
  70 *
  71 * @cache_type: The actual cache type.
  72 * @reg_defaults_raw: Power on reset values for registers (for use with
  73 *                    register cache support).
  74 * @num_reg_defaults_raw: Number of elements in reg_defaults_raw.
  75 */
  76struct regmap_config {
  77        int reg_bits;
  78        int val_bits;
  79
  80        bool (*writeable_reg)(struct device *dev, unsigned int reg);
  81        bool (*readable_reg)(struct device *dev, unsigned int reg);
  82        bool (*volatile_reg)(struct device *dev, unsigned int reg);
  83        bool (*precious_reg)(struct device *dev, unsigned int reg);
  84
  85        unsigned int max_register;
  86        struct reg_default *reg_defaults;
  87        unsigned int num_reg_defaults;
  88        enum regcache_type cache_type;
  89        const void *reg_defaults_raw;
  90        unsigned int num_reg_defaults_raw;
  91
  92        u8 read_flag_mask;
  93        u8 write_flag_mask;
  94};
  95
  96typedef int (*regmap_hw_write)(struct device *dev, const void *data,
  97                               size_t count);
  98typedef int (*regmap_hw_gather_write)(struct device *dev,
  99                                      const void *reg, size_t reg_len,
 100                                      const void *val, size_t val_len);
 101typedef int (*regmap_hw_read)(struct device *dev,
 102                              const void *reg_buf, size_t reg_size,
 103                              void *val_buf, size_t val_size);
 104
 105/**
 106 * Description of a hardware bus for the register map infrastructure.
 107 *
 108 * @write: Write operation.
 109 * @gather_write: Write operation with split register/value, return -ENOTSUPP
 110 *                if not implemented  on a given device.
 111 * @read: Read operation.  Data is returned in the buffer used to transmit
 112 *         data.
 113 * @read_flag_mask: Mask to be set in the top byte of the register when doing
 114 *                  a read.
 115 */
 116struct regmap_bus {
 117        regmap_hw_write write;
 118        regmap_hw_gather_write gather_write;
 119        regmap_hw_read read;
 120        u8 read_flag_mask;
 121};
 122
 123struct regmap *regmap_init(struct device *dev,
 124                           const struct regmap_bus *bus,
 125                           const struct regmap_config *config);
 126struct regmap *regmap_init_i2c(struct i2c_client *i2c,
 127                               const struct regmap_config *config);
 128struct regmap *regmap_init_spi(struct spi_device *dev,
 129                               const struct regmap_config *config);
 130
 131void regmap_exit(struct regmap *map);
 132int regmap_write(struct regmap *map, unsigned int reg, unsigned int val);
 133int regmap_raw_write(struct regmap *map, unsigned int reg,
 134                     const void *val, size_t val_len);
 135int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val);
 136int regmap_raw_read(struct regmap *map, unsigned int reg,
 137                    void *val, size_t val_len);
 138int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val,
 139                     size_t val_count);
 140int regmap_update_bits(struct regmap *map, unsigned int reg,
 141                       unsigned int mask, unsigned int val);
 142
 143int regcache_sync(struct regmap *map);
 144void regcache_cache_only(struct regmap *map, bool enable);
 145void regcache_cache_bypass(struct regmap *map, bool enable);
 146
 147#endif
 148