regmap.h

Go to the documentation of this file.

#ifndef __LINUX_REGMAP_H
#define __LINUX_REGMAP_H

/*
 * Register map access API
 *
 * Copyright 2011 Wolfson Microelectronics plc
 *
 * Author: Mark Brown <[email protected]>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#include <linux/list.h>
#include <linux/rbtree.h>

struct module;
struct device;
struct i2c_client;
struct spi_device;
struct regmap;
struct regmap_range_cfg;

/* An enum of all the supported cache types */
enum regcache_type {
    REGCACHE_NONE,
    REGCACHE_RBTREE,
    REGCACHE_COMPRESSED
};

struct reg_default {
    unsigned int reg;
    unsigned int def;
};

#ifdef CONFIG_REGMAP

enum regmap_endian {
    /* Unspecified -> 0 -> Backwards compatible default */
    REGMAP_ENDIAN_DEFAULT = 0,
    REGMAP_ENDIAN_BIG,
    REGMAP_ENDIAN_LITTLE,
    REGMAP_ENDIAN_NATIVE,
};

struct regmap_config {
    const char *name;

    int reg_bits;
    int reg_stride;
    int pad_bits;
    int val_bits;

    bool (*writeable_reg)(struct device *dev, unsigned int reg);
    bool (*readable_reg)(struct device *dev, unsigned int reg);
    bool (*volatile_reg)(struct device *dev, unsigned int reg);
    bool (*precious_reg)(struct device *dev, unsigned int reg);

    unsigned int max_register;
    const struct reg_default *reg_defaults;
    unsigned int num_reg_defaults;
    enum regcache_type cache_type;
    const void *reg_defaults_raw;
    unsigned int num_reg_defaults_raw;

    u8 read_flag_mask;
    u8 write_flag_mask;

    bool use_single_rw;

    enum regmap_endian reg_format_endian;
    enum regmap_endian val_format_endian;

    const struct regmap_range_cfg *ranges;
    unsigned int n_ranges;
};

struct regmap_range_cfg {
    /* Registers of virtual address range */
    unsigned int range_min;
    unsigned int range_max;

    /* Page selector for indirect addressing */
    unsigned int selector_reg;
    unsigned int selector_mask;
    int selector_shift;

    /* Data window (per each page) */
    unsigned int window_start;
    unsigned int window_len;
};

typedef int (*regmap_hw_write)(void *context, const void *data,
                   size_t count);
typedef int (*regmap_hw_gather_write)(void *context,
                      const void *reg, size_t reg_len,
                      const void *val, size_t val_len);
typedef int (*regmap_hw_read)(void *context,
                  const void *reg_buf, size_t reg_size,
                  void *val_buf, size_t val_size);
typedef void (*regmap_hw_free_context)(void *context);

struct regmap_bus {
    bool fast_io;
    regmap_hw_write write;
    regmap_hw_gather_write gather_write;
    regmap_hw_read read;
    regmap_hw_free_context free_context;
    u8 read_flag_mask;
    enum regmap_endian reg_format_endian_default;
    enum regmap_endian val_format_endian_default;
};

struct regmap *regmap_init(struct device *dev,
               const struct regmap_bus *bus,
               void *bus_context,
               const struct regmap_config *config);
struct regmap *regmap_init_i2c(struct i2c_client *i2c,
                   const struct regmap_config *config);
struct regmap *regmap_init_spi(struct spi_device *dev,
                   const struct regmap_config *config);
struct regmap *regmap_init_mmio(struct device *dev,
                void __iomem *regs,
                const struct regmap_config *config);

struct regmap *devm_regmap_init(struct device *dev,
                const struct regmap_bus *bus,
                void *bus_context,
                const struct regmap_config *config);
struct regmap *devm_regmap_init_i2c(struct i2c_client *i2c,
                    const struct regmap_config *config);
struct regmap *devm_regmap_init_spi(struct spi_device *dev,
                    const struct regmap_config *config);
struct regmap *devm_regmap_init_mmio(struct device *dev,
                     void __iomem *regs,
                     const struct regmap_config *config);

void regmap_exit(struct regmap *map);
int regmap_reinit_cache(struct regmap *map,
            const struct regmap_config *config);
struct regmap *dev_get_regmap(struct device *dev, const char *name);
int regmap_write(struct regmap *map, unsigned int reg, unsigned int val);
int regmap_raw_write(struct regmap *map, unsigned int reg,
             const void *val, size_t val_len);
int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val,
            size_t val_count);
int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val);
int regmap_raw_read(struct regmap *map, unsigned int reg,
            void *val, size_t val_len);
int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val,
             size_t val_count);
int regmap_update_bits(struct regmap *map, unsigned int reg,
               unsigned int mask, unsigned int val);
int regmap_update_bits_check(struct regmap *map, unsigned int reg,
                 unsigned int mask, unsigned int val,
                 bool *change);
int regmap_get_val_bytes(struct regmap *map);

int regcache_sync(struct regmap *map);
int regcache_sync_region(struct regmap *map, unsigned int min,
             unsigned int max);
void regcache_cache_only(struct regmap *map, bool enable);
void regcache_cache_bypass(struct regmap *map, bool enable);
void regcache_mark_dirty(struct regmap *map);

int regmap_register_patch(struct regmap *map, const struct reg_default *regs,
              int num_regs);

struct regmap_irq {
    unsigned int reg_offset;
    unsigned int mask;
};

struct regmap_irq_chip {
    const char *name;

    unsigned int status_base;
    unsigned int mask_base;
    unsigned int ack_base;
    unsigned int wake_base;
    unsigned int irq_reg_stride;
    unsigned int mask_invert;
    bool runtime_pm;

    int num_regs;

    const struct regmap_irq *irqs;
    int num_irqs;
};

struct regmap_irq_chip_data;

int regmap_add_irq_chip(struct regmap *map, int irq, int irq_flags,
            int irq_base, const struct regmap_irq_chip *chip,
            struct regmap_irq_chip_data **data);
void regmap_del_irq_chip(int irq, struct regmap_irq_chip_data *data);
int regmap_irq_chip_get_base(struct regmap_irq_chip_data *data);
int regmap_irq_get_virq(struct regmap_irq_chip_data *data, int irq);

#else

/*
 * These stubs should only ever be called by generic code which has
 * regmap based facilities, if they ever get called at runtime
 * something is going wrong and something probably needs to select
 * REGMAP.
 */

static inline int regmap_write(struct regmap *map, unsigned int reg,
                   unsigned int val)
{
    WARN_ONCE(1, "regmap API is disabled");
    return -EINVAL;
}

static inline int regmap_raw_write(struct regmap *map, unsigned int reg,
                   const void *val, size_t val_len)
{
    WARN_ONCE(1, "regmap API is disabled");
    return -EINVAL;
}

static inline int regmap_bulk_write(struct regmap *map, unsigned int reg,
                    const void *val, size_t val_count)
{
    WARN_ONCE(1, "regmap API is disabled");
    return -EINVAL;
}

static inline int regmap_read(struct regmap *map, unsigned int reg,
                  unsigned int *val)
{
    WARN_ONCE(1, "regmap API is disabled");
    return -EINVAL;
}

static inline int regmap_raw_read(struct regmap *map, unsigned int reg,
                  void *val, size_t val_len)
{
    WARN_ONCE(1, "regmap API is disabled");
    return -EINVAL;
}

static inline int regmap_bulk_read(struct regmap *map, unsigned int reg,
                   void *val, size_t val_count)
{
    WARN_ONCE(1, "regmap API is disabled");
    return -EINVAL;
}

static inline int regmap_update_bits(struct regmap *map, unsigned int reg,
                     unsigned int mask, unsigned int val)
{
    WARN_ONCE(1, "regmap API is disabled");
    return -EINVAL;
}

static inline int regmap_update_bits_check(struct regmap *map,
                       unsigned int reg,
                       unsigned int mask, unsigned int val,
                       bool *change)
{
    WARN_ONCE(1, "regmap API is disabled");
    return -EINVAL;
}

static inline int regmap_get_val_bytes(struct regmap *map)
{
    WARN_ONCE(1, "regmap API is disabled");
    return -EINVAL;
}

static inline int regcache_sync(struct regmap *map)
{
    WARN_ONCE(1, "regmap API is disabled");
    return -EINVAL;
}

static inline int regcache_sync_region(struct regmap *map, unsigned int min,
                       unsigned int max)
{
    WARN_ONCE(1, "regmap API is disabled");
    return -EINVAL;
}

static inline void regcache_cache_only(struct regmap *map, bool enable)
{
    WARN_ONCE(1, "regmap API is disabled");
}

static inline void regcache_cache_bypass(struct regmap *map, bool enable)
{
    WARN_ONCE(1, "regmap API is disabled");
}

static inline void regcache_mark_dirty(struct regmap *map)
{
    WARN_ONCE(1, "regmap API is disabled");
}

static inline int regmap_register_patch(struct regmap *map,
                    const struct reg_default *regs,
                    int num_regs)
{
    WARN_ONCE(1, "regmap API is disabled");
    return -EINVAL;
}

static inline struct regmap *dev_get_regmap(struct device *dev,
                        const char *name)
{
    return NULL;
}

#endif

#endif