Mark Brown | 93de912 | 2011-07-20 22:35:37 +0100 | [diff] [blame] | 1 | /* |
| 2 | * Register map access API internal header |
| 3 | * |
| 4 | * Copyright 2011 Wolfson Microelectronics plc |
| 5 | * |
| 6 | * Author: Mark Brown <broonie@opensource.wolfsonmicro.com> |
| 7 | * |
| 8 | * This program is free software; you can redistribute it and/or modify |
| 9 | * it under the terms of the GNU General Public License version 2 as |
| 10 | * published by the Free Software Foundation. |
| 11 | */ |
| 12 | |
| 13 | #ifndef _REGMAP_INTERNAL_H |
| 14 | #define _REGMAP_INTERNAL_H |
| 15 | |
| 16 | #include <linux/regmap.h> |
Mark Brown | 31244e3 | 2011-07-20 22:56:53 +0100 | [diff] [blame] | 17 | #include <linux/fs.h> |
Mark Brown | 93de912 | 2011-07-20 22:35:37 +0100 | [diff] [blame] | 18 | |
| 19 | struct regmap; |
Dimitris Papastamos | 9fabe24 | 2011-09-19 14:34:00 +0100 | [diff] [blame] | 20 | struct regcache_ops; |
Mark Brown | 93de912 | 2011-07-20 22:35:37 +0100 | [diff] [blame] | 21 | |
| 22 | struct regmap_format { |
| 23 | size_t buf_size; |
| 24 | size_t reg_bytes; |
Mark Brown | 82159ba | 2012-01-18 10:52:25 +0000 | [diff] [blame] | 25 | size_t pad_bytes; |
Mark Brown | 93de912 | 2011-07-20 22:35:37 +0100 | [diff] [blame] | 26 | size_t val_bytes; |
| 27 | void (*format_write)(struct regmap *map, |
| 28 | unsigned int reg, unsigned int val); |
Marc Reilly | d939fb9 | 2012-03-16 12:11:43 +1100 | [diff] [blame] | 29 | void (*format_reg)(void *buf, unsigned int reg, unsigned int shift); |
| 30 | void (*format_val)(void *buf, unsigned int val, unsigned int shift); |
Mark Brown | 93de912 | 2011-07-20 22:35:37 +0100 | [diff] [blame] | 31 | unsigned int (*parse_val)(void *buf); |
| 32 | }; |
| 33 | |
| 34 | struct regmap { |
Stephen Warren | bacdbe0 | 2012-04-04 15:48:28 -0600 | [diff] [blame] | 35 | struct mutex mutex; |
| 36 | spinlock_t spinlock; |
| 37 | regmap_lock lock; |
| 38 | regmap_unlock unlock; |
Davide Ciminaghi | 0d4529c | 2012-10-16 15:56:59 +0200 | [diff] [blame^] | 39 | void *lock_arg; /* This is passed to lock/unlock functions */ |
Mark Brown | 93de912 | 2011-07-20 22:35:37 +0100 | [diff] [blame] | 40 | |
| 41 | struct device *dev; /* Device we do I/O on */ |
| 42 | void *work_buf; /* Scratch buffer used to format I/O */ |
| 43 | struct regmap_format format; /* Buffer format */ |
| 44 | const struct regmap_bus *bus; |
Stephen Warren | 0135bbc | 2012-04-04 15:48:30 -0600 | [diff] [blame] | 45 | void *bus_context; |
Mark Brown | 72b39f6 | 2012-05-08 17:44:40 +0100 | [diff] [blame] | 46 | const char *name; |
Mark Brown | 93de912 | 2011-07-20 22:35:37 +0100 | [diff] [blame] | 47 | |
Mark Brown | 31244e3 | 2011-07-20 22:56:53 +0100 | [diff] [blame] | 48 | #ifdef CONFIG_DEBUG_FS |
| 49 | struct dentry *debugfs; |
Stephen Warren | d3c242e | 2012-04-04 15:48:29 -0600 | [diff] [blame] | 50 | const char *debugfs_name; |
Mark Brown | 31244e3 | 2011-07-20 22:56:53 +0100 | [diff] [blame] | 51 | #endif |
| 52 | |
Mark Brown | 93de912 | 2011-07-20 22:35:37 +0100 | [diff] [blame] | 53 | unsigned int max_register; |
| 54 | bool (*writeable_reg)(struct device *dev, unsigned int reg); |
| 55 | bool (*readable_reg)(struct device *dev, unsigned int reg); |
| 56 | bool (*volatile_reg)(struct device *dev, unsigned int reg); |
Mark Brown | 2efe164 | 2011-08-08 15:41:46 +0900 | [diff] [blame] | 57 | bool (*precious_reg)(struct device *dev, unsigned int reg); |
Lars-Peter Clausen | 6f30644 | 2011-09-05 20:46:32 +0200 | [diff] [blame] | 58 | |
| 59 | u8 read_flag_mask; |
| 60 | u8 write_flag_mask; |
Dimitris Papastamos | 9fabe24 | 2011-09-19 14:34:00 +0100 | [diff] [blame] | 61 | |
Marc Reilly | d939fb9 | 2012-03-16 12:11:43 +1100 | [diff] [blame] | 62 | /* number of bits to (left) shift the reg value when formatting*/ |
| 63 | int reg_shift; |
Stephen Warren | f01ee60 | 2012-04-09 13:40:24 -0600 | [diff] [blame] | 64 | int reg_stride; |
Marc Reilly | d939fb9 | 2012-03-16 12:11:43 +1100 | [diff] [blame] | 65 | |
Dimitris Papastamos | 9fabe24 | 2011-09-19 14:34:00 +0100 | [diff] [blame] | 66 | /* regcache specific members */ |
| 67 | const struct regcache_ops *cache_ops; |
| 68 | enum regcache_type cache_type; |
| 69 | |
| 70 | /* number of bytes in reg_defaults_raw */ |
| 71 | unsigned int cache_size_raw; |
| 72 | /* number of bytes per word in reg_defaults_raw */ |
| 73 | unsigned int cache_word_size; |
| 74 | /* number of entries in reg_defaults */ |
| 75 | unsigned int num_reg_defaults; |
| 76 | /* number of entries in reg_defaults_raw */ |
| 77 | unsigned int num_reg_defaults_raw; |
| 78 | |
| 79 | /* if set, only the cache is modified not the HW */ |
Mark Brown | 847fb6f | 2012-02-06 18:01:35 +0000 | [diff] [blame] | 80 | u32 cache_only; |
Dimitris Papastamos | 9fabe24 | 2011-09-19 14:34:00 +0100 | [diff] [blame] | 81 | /* if set, only the HW is modified not the cache */ |
Mark Brown | 847fb6f | 2012-02-06 18:01:35 +0000 | [diff] [blame] | 82 | u32 cache_bypass; |
Dimitris Papastamos | 9fabe24 | 2011-09-19 14:34:00 +0100 | [diff] [blame] | 83 | /* if set, remember to free reg_defaults_raw */ |
Mark Brown | 847fb6f | 2012-02-06 18:01:35 +0000 | [diff] [blame] | 84 | bool cache_free; |
Dimitris Papastamos | 9fabe24 | 2011-09-19 14:34:00 +0100 | [diff] [blame] | 85 | |
| 86 | struct reg_default *reg_defaults; |
| 87 | const void *reg_defaults_raw; |
| 88 | void *cache; |
Mark Brown | 847fb6f | 2012-02-06 18:01:35 +0000 | [diff] [blame] | 89 | u32 cache_dirty; |
Mark Brown | 22f0d90 | 2012-01-21 12:01:14 +0000 | [diff] [blame] | 90 | |
| 91 | struct reg_default *patch; |
| 92 | int patch_regs; |
Ashish Jangam | 2e33caf | 2012-04-30 23:23:40 +0100 | [diff] [blame] | 93 | |
| 94 | /* if set, converts bulk rw to single rw */ |
| 95 | bool use_single_rw; |
Krystian Garbaciak | 6863ca6 | 2012-06-15 11:23:56 +0100 | [diff] [blame] | 96 | |
| 97 | struct rb_root range_tree; |
| 98 | void *selector_work_buf; /* Scratch buffer used for selector */ |
Dimitris Papastamos | 9fabe24 | 2011-09-19 14:34:00 +0100 | [diff] [blame] | 99 | }; |
| 100 | |
| 101 | struct regcache_ops { |
| 102 | const char *name; |
| 103 | enum regcache_type type; |
| 104 | int (*init)(struct regmap *map); |
| 105 | int (*exit)(struct regmap *map); |
| 106 | int (*read)(struct regmap *map, unsigned int reg, unsigned int *value); |
| 107 | int (*write)(struct regmap *map, unsigned int reg, unsigned int value); |
Mark Brown | ac8d91c | 2012-02-23 19:31:04 +0000 | [diff] [blame] | 108 | int (*sync)(struct regmap *map, unsigned int min, unsigned int max); |
Mark Brown | 93de912 | 2011-07-20 22:35:37 +0100 | [diff] [blame] | 109 | }; |
| 110 | |
Mark Brown | 8de2f08 | 2011-08-10 17:14:41 +0900 | [diff] [blame] | 111 | bool regmap_writeable(struct regmap *map, unsigned int reg); |
| 112 | bool regmap_readable(struct regmap *map, unsigned int reg); |
| 113 | bool regmap_volatile(struct regmap *map, unsigned int reg); |
| 114 | bool regmap_precious(struct regmap *map, unsigned int reg); |
| 115 | |
Dimitris Papastamos | 4d2dc09 | 2011-09-29 10:39:07 +0100 | [diff] [blame] | 116 | int _regmap_write(struct regmap *map, unsigned int reg, |
| 117 | unsigned int val); |
| 118 | |
Krystian Garbaciak | 6863ca6 | 2012-06-15 11:23:56 +0100 | [diff] [blame] | 119 | struct regmap_range_node { |
| 120 | struct rb_node node; |
| 121 | |
| 122 | unsigned int range_min; |
| 123 | unsigned int range_max; |
| 124 | |
| 125 | unsigned int selector_reg; |
| 126 | unsigned int selector_mask; |
| 127 | int selector_shift; |
| 128 | |
| 129 | unsigned int window_start; |
| 130 | unsigned int window_len; |
| 131 | }; |
| 132 | |
Mark Brown | 31244e3 | 2011-07-20 22:56:53 +0100 | [diff] [blame] | 133 | #ifdef CONFIG_DEBUG_FS |
| 134 | extern void regmap_debugfs_initcall(void); |
Stephen Warren | d3c242e | 2012-04-04 15:48:29 -0600 | [diff] [blame] | 135 | extern void regmap_debugfs_init(struct regmap *map, const char *name); |
Mark Brown | 31244e3 | 2011-07-20 22:56:53 +0100 | [diff] [blame] | 136 | extern void regmap_debugfs_exit(struct regmap *map); |
| 137 | #else |
Lars-Peter Clausen | bbcf61c | 2011-09-05 22:06:13 +0200 | [diff] [blame] | 138 | static inline void regmap_debugfs_initcall(void) { } |
Stephen Warren | abec95a | 2012-04-05 23:09:20 -0600 | [diff] [blame] | 139 | static inline void regmap_debugfs_init(struct regmap *map, const char *name) { } |
Lars-Peter Clausen | bbcf61c | 2011-09-05 22:06:13 +0200 | [diff] [blame] | 140 | static inline void regmap_debugfs_exit(struct regmap *map) { } |
Mark Brown | 31244e3 | 2011-07-20 22:56:53 +0100 | [diff] [blame] | 141 | #endif |
| 142 | |
Dimitris Papastamos | 9fabe24 | 2011-09-19 14:34:00 +0100 | [diff] [blame] | 143 | /* regcache core declarations */ |
Lars-Peter Clausen | e5e3b8a | 2011-11-16 16:28:16 +0100 | [diff] [blame] | 144 | int regcache_init(struct regmap *map, const struct regmap_config *config); |
Dimitris Papastamos | 9fabe24 | 2011-09-19 14:34:00 +0100 | [diff] [blame] | 145 | void regcache_exit(struct regmap *map); |
| 146 | int regcache_read(struct regmap *map, |
| 147 | unsigned int reg, unsigned int *value); |
| 148 | int regcache_write(struct regmap *map, |
| 149 | unsigned int reg, unsigned int value); |
| 150 | int regcache_sync(struct regmap *map); |
| 151 | |
| 152 | unsigned int regcache_get_val(const void *base, unsigned int idx, |
| 153 | unsigned int word_size); |
| 154 | bool regcache_set_val(void *base, unsigned int idx, |
| 155 | unsigned int val, unsigned int word_size); |
| 156 | int regcache_lookup_reg(struct regmap *map, unsigned int reg); |
Dimitris Papastamos | 9fabe24 | 2011-09-19 14:34:00 +0100 | [diff] [blame] | 157 | |
Dimitris Papastamos | 28644c80 | 2011-09-19 14:34:02 +0100 | [diff] [blame] | 158 | extern struct regcache_ops regcache_rbtree_ops; |
Dimitris Papastamos | 2cbbb57 | 2011-09-19 14:34:03 +0100 | [diff] [blame] | 159 | extern struct regcache_ops regcache_lzo_ops; |
| 160 | |
Mark Brown | 93de912 | 2011-07-20 22:35:37 +0100 | [diff] [blame] | 161 | #endif |