blob: 0da5865df5b1b4f092fef5652814e7cc96b8993e [file] [log] [blame]
Mark Brown93de9122011-07-20 22:35:37 +01001/*
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 Brown31244e32011-07-20 22:56:53 +010017#include <linux/fs.h>
Mark Brown5166b7c2012-12-11 01:24:29 +090018#include <linux/list.h>
Mark Brown0d509f22013-01-27 22:07:38 +080019#include <linux/wait.h>
Mark Brown93de9122011-07-20 22:35:37 +010020
21struct regmap;
Dimitris Papastamos9fabe242011-09-19 14:34:00 +010022struct regcache_ops;
Mark Brown93de9122011-07-20 22:35:37 +010023
Mark Brown5166b7c2012-12-11 01:24:29 +090024struct regmap_debugfs_off_cache {
25 struct list_head list;
26 off_t min;
27 off_t max;
28 unsigned int base_reg;
Dimitris Papastamosc2c1ee62013-02-08 12:47:14 +000029 unsigned int max_reg;
Mark Brown5166b7c2012-12-11 01:24:29 +090030};
31
Mark Brown93de9122011-07-20 22:35:37 +010032struct regmap_format {
33 size_t buf_size;
34 size_t reg_bytes;
Mark Brown82159ba2012-01-18 10:52:25 +000035 size_t pad_bytes;
Mark Brown93de9122011-07-20 22:35:37 +010036 size_t val_bytes;
37 void (*format_write)(struct regmap *map,
38 unsigned int reg, unsigned int val);
Marc Reillyd939fb92012-03-16 12:11:43 +110039 void (*format_reg)(void *buf, unsigned int reg, unsigned int shift);
40 void (*format_val)(void *buf, unsigned int val, unsigned int shift);
Mark Brown8a819ff2013-03-04 09:04:51 +080041 unsigned int (*parse_val)(const void *buf);
42 void (*parse_inplace)(void *buf);
Mark Brown93de9122011-07-20 22:35:37 +010043};
44
Mark Brown0d509f22013-01-27 22:07:38 +080045struct regmap_async {
46 struct list_head list;
Mark Brown0d509f22013-01-27 22:07:38 +080047 struct regmap *map;
48 void *work_buf;
49};
50
Mark Brown93de9122011-07-20 22:35:37 +010051struct regmap {
Wang, Yalin336fb812014-09-11 16:19:49 +080052 union {
53 struct mutex mutex;
54 spinlock_t spinlock;
55 };
Lars-Peter Clausen92ab1aa2013-05-24 10:29:22 +020056 unsigned long spinlock_flags;
Stephen Warrenbacdbe02012-04-04 15:48:28 -060057 regmap_lock lock;
58 regmap_unlock unlock;
Davide Ciminaghi0d4529c2012-10-16 15:56:59 +020059 void *lock_arg; /* This is passed to lock/unlock functions */
Mark Brown93de9122011-07-20 22:35:37 +010060
61 struct device *dev; /* Device we do I/O on */
62 void *work_buf; /* Scratch buffer used to format I/O */
63 struct regmap_format format; /* Buffer format */
64 const struct regmap_bus *bus;
Stephen Warren0135bbc2012-04-04 15:48:30 -060065 void *bus_context;
Mark Brown72b39f62012-05-08 17:44:40 +010066 const char *name;
Mark Brown93de9122011-07-20 22:35:37 +010067
Mark Brown0a819802013-10-09 12:28:52 +010068 bool async;
Mark Brown0d509f22013-01-27 22:07:38 +080069 spinlock_t async_lock;
70 wait_queue_head_t async_waitq;
71 struct list_head async_list;
Mark Brown7e09a972013-10-07 23:00:24 +010072 struct list_head async_free;
Mark Brown0d509f22013-01-27 22:07:38 +080073 int async_ret;
74
Mark Brown31244e32011-07-20 22:56:53 +010075#ifdef CONFIG_DEBUG_FS
76 struct dentry *debugfs;
Stephen Warrend3c242e2012-04-04 15:48:29 -060077 const char *debugfs_name;
Mark Browncbc19382012-12-06 13:29:05 +090078
79 unsigned int debugfs_reg_len;
80 unsigned int debugfs_val_len;
81 unsigned int debugfs_tot_len;
Mark Brown5166b7c2012-12-11 01:24:29 +090082
83 struct list_head debugfs_off_cache;
Dimitris Papastamos065b4c52013-02-20 12:15:23 +000084 struct mutex cache_lock;
Mark Brown31244e32011-07-20 22:56:53 +010085#endif
86
Mark Brown93de9122011-07-20 22:35:37 +010087 unsigned int max_register;
88 bool (*writeable_reg)(struct device *dev, unsigned int reg);
89 bool (*readable_reg)(struct device *dev, unsigned int reg);
90 bool (*volatile_reg)(struct device *dev, unsigned int reg);
Mark Brown2efe1642011-08-08 15:41:46 +090091 bool (*precious_reg)(struct device *dev, unsigned int reg);
Davide Ciminaghi76aad392012-11-20 15:20:30 +010092 const struct regmap_access_table *wr_table;
93 const struct regmap_access_table *rd_table;
94 const struct regmap_access_table *volatile_table;
95 const struct regmap_access_table *precious_table;
Lars-Peter Clausen6f306442011-09-05 20:46:32 +020096
Andrey Smirnovad278402013-01-12 12:54:12 -080097 int (*reg_read)(void *context, unsigned int reg, unsigned int *val);
Andrey Smirnov07c320d2013-01-12 12:54:13 -080098 int (*reg_write)(void *context, unsigned int reg, unsigned int val);
Andrey Smirnovad278402013-01-12 12:54:12 -080099
Andrey Smirnovd2a58842013-01-27 10:49:05 -0800100 bool defer_caching;
101
Lars-Peter Clausen6f306442011-09-05 20:46:32 +0200102 u8 read_flag_mask;
103 u8 write_flag_mask;
Dimitris Papastamos9fabe242011-09-19 14:34:00 +0100104
Marc Reillyd939fb92012-03-16 12:11:43 +1100105 /* number of bits to (left) shift the reg value when formatting*/
106 int reg_shift;
Stephen Warrenf01ee602012-04-09 13:40:24 -0600107 int reg_stride;
Marc Reillyd939fb92012-03-16 12:11:43 +1100108
Dimitris Papastamos9fabe242011-09-19 14:34:00 +0100109 /* regcache specific members */
110 const struct regcache_ops *cache_ops;
111 enum regcache_type cache_type;
112
113 /* number of bytes in reg_defaults_raw */
114 unsigned int cache_size_raw;
115 /* number of bytes per word in reg_defaults_raw */
116 unsigned int cache_word_size;
117 /* number of entries in reg_defaults */
118 unsigned int num_reg_defaults;
119 /* number of entries in reg_defaults_raw */
120 unsigned int num_reg_defaults_raw;
121
122 /* if set, only the cache is modified not the HW */
Mark Brown847fb6f2012-02-06 18:01:35 +0000123 u32 cache_only;
Dimitris Papastamos9fabe242011-09-19 14:34:00 +0100124 /* if set, only the HW is modified not the cache */
Mark Brown847fb6f2012-02-06 18:01:35 +0000125 u32 cache_bypass;
Dimitris Papastamos9fabe242011-09-19 14:34:00 +0100126 /* if set, remember to free reg_defaults_raw */
Mark Brown847fb6f2012-02-06 18:01:35 +0000127 bool cache_free;
Dimitris Papastamos9fabe242011-09-19 14:34:00 +0100128
129 struct reg_default *reg_defaults;
130 const void *reg_defaults_raw;
131 void *cache;
Mark Brown847fb6f2012-02-06 18:01:35 +0000132 u32 cache_dirty;
Mark Brown22f0d902012-01-21 12:01:14 +0000133
134 struct reg_default *patch;
135 int patch_regs;
Ashish Jangam2e33caf2012-04-30 23:23:40 +0100136
137 /* if set, converts bulk rw to single rw */
138 bool use_single_rw;
Opensource [Anthony Olech]e894c3f2014-03-04 13:54:02 +0000139 /* if set, the device supports multi write mode */
140 bool can_multi_write;
Krystian Garbaciak6863ca62012-06-15 11:23:56 +0100141
142 struct rb_root range_tree;
143 void *selector_work_buf; /* Scratch buffer used for selector */
Dimitris Papastamos9fabe242011-09-19 14:34:00 +0100144};
145
146struct regcache_ops {
147 const char *name;
148 enum regcache_type type;
149 int (*init)(struct regmap *map);
150 int (*exit)(struct regmap *map);
Lars-Peter Clausen5e0cbe72014-08-24 15:32:27 +0200151#ifdef CONFIG_DEBUG_FS
152 void (*debugfs_init)(struct regmap *map);
153#endif
Dimitris Papastamos9fabe242011-09-19 14:34:00 +0100154 int (*read)(struct regmap *map, unsigned int reg, unsigned int *value);
155 int (*write)(struct regmap *map, unsigned int reg, unsigned int value);
Mark Brownac8d91c2012-02-23 19:31:04 +0000156 int (*sync)(struct regmap *map, unsigned int min, unsigned int max);
Mark Brown697e85b2013-05-08 13:55:22 +0100157 int (*drop)(struct regmap *map, unsigned int min, unsigned int max);
Mark Brown93de9122011-07-20 22:35:37 +0100158};
159
Mark Brown8de2f082011-08-10 17:14:41 +0900160bool regmap_writeable(struct regmap *map, unsigned int reg);
161bool regmap_readable(struct regmap *map, unsigned int reg);
162bool regmap_volatile(struct regmap *map, unsigned int reg);
163bool regmap_precious(struct regmap *map, unsigned int reg);
164
Dimitris Papastamos4d2dc092011-09-29 10:39:07 +0100165int _regmap_write(struct regmap *map, unsigned int reg,
166 unsigned int val);
167
Krystian Garbaciak6863ca62012-06-15 11:23:56 +0100168struct regmap_range_node {
169 struct rb_node node;
Mark Brownd058bb42012-10-03 12:40:47 +0100170 const char *name;
Mark Brown4b020b32012-10-03 13:13:16 +0100171 struct regmap *map;
Krystian Garbaciak6863ca62012-06-15 11:23:56 +0100172
173 unsigned int range_min;
174 unsigned int range_max;
175
176 unsigned int selector_reg;
177 unsigned int selector_mask;
178 int selector_shift;
179
180 unsigned int window_start;
181 unsigned int window_len;
182};
183
Srinivas Kandagatla67252282013-06-11 13:18:15 +0100184struct regmap_field {
185 struct regmap *regmap;
186 unsigned int mask;
187 /* lsb */
188 unsigned int shift;
189 unsigned int reg;
Kuninori Morimotoa0102372013-09-01 20:30:50 -0700190
191 unsigned int id_size;
192 unsigned int id_offset;
Srinivas Kandagatla67252282013-06-11 13:18:15 +0100193};
194
Mark Brown31244e32011-07-20 22:56:53 +0100195#ifdef CONFIG_DEBUG_FS
196extern void regmap_debugfs_initcall(void);
Stephen Warrend3c242e2012-04-04 15:48:29 -0600197extern void regmap_debugfs_init(struct regmap *map, const char *name);
Mark Brown31244e32011-07-20 22:56:53 +0100198extern void regmap_debugfs_exit(struct regmap *map);
199#else
Lars-Peter Clausenbbcf61c2011-09-05 22:06:13 +0200200static inline void regmap_debugfs_initcall(void) { }
Stephen Warrenabec95a2012-04-05 23:09:20 -0600201static inline void regmap_debugfs_init(struct regmap *map, const char *name) { }
Lars-Peter Clausenbbcf61c2011-09-05 22:06:13 +0200202static inline void regmap_debugfs_exit(struct regmap *map) { }
Mark Brown31244e32011-07-20 22:56:53 +0100203#endif
204
Dimitris Papastamos9fabe242011-09-19 14:34:00 +0100205/* regcache core declarations */
Lars-Peter Clausene5e3b8a2011-11-16 16:28:16 +0100206int regcache_init(struct regmap *map, const struct regmap_config *config);
Dimitris Papastamos9fabe242011-09-19 14:34:00 +0100207void regcache_exit(struct regmap *map);
208int regcache_read(struct regmap *map,
209 unsigned int reg, unsigned int *value);
210int regcache_write(struct regmap *map,
211 unsigned int reg, unsigned int value);
212int regcache_sync(struct regmap *map);
Mark Brownf8bd8222013-03-29 19:32:28 +0000213int regcache_sync_block(struct regmap *map, void *block,
Lars-Peter Clausen3f4ff562013-08-29 10:26:34 +0200214 unsigned long *cache_present,
Mark Brownf8bd8222013-03-29 19:32:28 +0000215 unsigned int block_base, unsigned int start,
216 unsigned int end);
Dimitris Papastamos9fabe242011-09-19 14:34:00 +0100217
Mark Brown88177962013-03-13 19:29:36 +0000218static inline const void *regcache_get_val_addr(struct regmap *map,
219 const void *base,
220 unsigned int idx)
221{
222 return base + (map->cache_word_size * idx);
223}
224
Mark Brown879082c2013-02-21 18:03:13 +0000225unsigned int regcache_get_val(struct regmap *map, const void *base,
226 unsigned int idx);
227bool regcache_set_val(struct regmap *map, void *base, unsigned int idx,
228 unsigned int val);
Dimitris Papastamos9fabe242011-09-19 14:34:00 +0100229int regcache_lookup_reg(struct regmap *map, unsigned int reg);
Dimitris Papastamos9fabe242011-09-19 14:34:00 +0100230
Mark Brown584de322013-03-13 19:19:34 +0000231int _regmap_raw_write(struct regmap *map, unsigned int reg,
Mark Brown0a819802013-10-09 12:28:52 +0100232 const void *val, size_t val_len);
Mark Brown584de322013-03-13 19:19:34 +0000233
Mark Brown0d509f22013-01-27 22:07:38 +0800234void regmap_async_complete_cb(struct regmap_async *async, int ret);
235
Dimitris Papastamos28644c802011-09-19 14:34:02 +0100236extern struct regcache_ops regcache_rbtree_ops;
Dimitris Papastamos2cbbb572011-09-19 14:34:03 +0100237extern struct regcache_ops regcache_lzo_ops;
Mark Brown2ac902c2012-12-19 14:51:55 +0000238extern struct regcache_ops regcache_flat_ops;
Dimitris Papastamos2cbbb572011-09-19 14:34:03 +0100239
Mark Brown93de9122011-07-20 22:35:37 +0100240#endif