internal.h 7.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258
  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. #ifndef _REGMAP_INTERNAL_H
  13. #define _REGMAP_INTERNAL_H
  14. #include <linux/regmap.h>
  15. #include <linux/fs.h>
  16. #include <linux/list.h>
  17. #include <linux/wait.h>
  18. struct regmap;
  19. struct regcache_ops;
  20. struct regmap_debugfs_off_cache {
  21. struct list_head list;
  22. off_t min;
  23. off_t max;
  24. unsigned int base_reg;
  25. unsigned int max_reg;
  26. };
  27. struct regmap_format {
  28. size_t buf_size;
  29. size_t reg_bytes;
  30. size_t pad_bytes;
  31. size_t val_bytes;
  32. void (*format_write)(struct regmap *map,
  33. unsigned int reg, unsigned int val);
  34. void (*format_reg)(void *buf, unsigned int reg, unsigned int shift);
  35. void (*format_val)(void *buf, unsigned int val, unsigned int shift);
  36. unsigned int (*parse_val)(const void *buf);
  37. void (*parse_inplace)(void *buf);
  38. };
  39. struct regmap_async {
  40. struct list_head list;
  41. struct regmap *map;
  42. void *work_buf;
  43. };
  44. struct regmap {
  45. union {
  46. struct mutex mutex;
  47. struct {
  48. spinlock_t spinlock;
  49. unsigned long spinlock_flags;
  50. };
  51. };
  52. regmap_lock lock;
  53. regmap_unlock unlock;
  54. void *lock_arg; /* This is passed to lock/unlock functions */
  55. struct device *dev; /* Device we do I/O on */
  56. void *work_buf; /* Scratch buffer used to format I/O */
  57. struct regmap_format format; /* Buffer format */
  58. const struct regmap_bus *bus;
  59. void *bus_context;
  60. const char *name;
  61. bool async;
  62. spinlock_t async_lock;
  63. wait_queue_head_t async_waitq;
  64. struct list_head async_list;
  65. struct list_head async_free;
  66. int async_ret;
  67. #ifdef CONFIG_DEBUG_FS
  68. struct dentry *debugfs;
  69. const char *debugfs_name;
  70. unsigned int debugfs_reg_len;
  71. unsigned int debugfs_val_len;
  72. unsigned int debugfs_tot_len;
  73. struct list_head debugfs_off_cache;
  74. struct mutex cache_lock;
  75. #endif
  76. unsigned int max_register;
  77. bool (*writeable_reg)(struct device *dev, unsigned int reg);
  78. bool (*readable_reg)(struct device *dev, unsigned int reg);
  79. bool (*volatile_reg)(struct device *dev, unsigned int reg);
  80. bool (*precious_reg)(struct device *dev, unsigned int reg);
  81. const struct regmap_access_table *wr_table;
  82. const struct regmap_access_table *rd_table;
  83. const struct regmap_access_table *volatile_table;
  84. const struct regmap_access_table *precious_table;
  85. int (*reg_read)(void *context, unsigned int reg, unsigned int *val);
  86. int (*reg_write)(void *context, unsigned int reg, unsigned int val);
  87. bool defer_caching;
  88. u8 read_flag_mask;
  89. u8 write_flag_mask;
  90. /* number of bits to (left) shift the reg value when formatting*/
  91. int reg_shift;
  92. int reg_stride;
  93. /* regcache specific members */
  94. const struct regcache_ops *cache_ops;
  95. enum regcache_type cache_type;
  96. /* number of bytes in reg_defaults_raw */
  97. unsigned int cache_size_raw;
  98. /* number of bytes per word in reg_defaults_raw */
  99. unsigned int cache_word_size;
  100. /* number of entries in reg_defaults */
  101. unsigned int num_reg_defaults;
  102. /* number of entries in reg_defaults_raw */
  103. unsigned int num_reg_defaults_raw;
  104. /* if set, only the cache is modified not the HW */
  105. u32 cache_only;
  106. /* if set, only the HW is modified not the cache */
  107. u32 cache_bypass;
  108. /* if set, remember to free reg_defaults_raw */
  109. bool cache_free;
  110. struct reg_default *reg_defaults;
  111. const void *reg_defaults_raw;
  112. void *cache;
  113. /* if set, the cache contains newer data than the HW */
  114. u32 cache_dirty;
  115. /* if set, the HW registers are known to match map->reg_defaults */
  116. bool no_sync_defaults;
  117. struct reg_default *patch;
  118. int patch_regs;
  119. /* if set, converts bulk rw to single rw */
  120. bool use_single_rw;
  121. /* if set, the device supports multi write mode */
  122. bool can_multi_write;
  123. struct rb_root range_tree;
  124. void *selector_work_buf; /* Scratch buffer used for selector */
  125. };
  126. struct regcache_ops {
  127. const char *name;
  128. enum regcache_type type;
  129. int (*init)(struct regmap *map);
  130. int (*exit)(struct regmap *map);
  131. #ifdef CONFIG_DEBUG_FS
  132. void (*debugfs_init)(struct regmap *map);
  133. #endif
  134. int (*read)(struct regmap *map, unsigned int reg, unsigned int *value);
  135. int (*write)(struct regmap *map, unsigned int reg, unsigned int value);
  136. int (*sync)(struct regmap *map, unsigned int min, unsigned int max);
  137. int (*drop)(struct regmap *map, unsigned int min, unsigned int max);
  138. };
  139. bool regmap_writeable(struct regmap *map, unsigned int reg);
  140. bool regmap_readable(struct regmap *map, unsigned int reg);
  141. bool regmap_volatile(struct regmap *map, unsigned int reg);
  142. bool regmap_precious(struct regmap *map, unsigned int reg);
  143. int _regmap_write(struct regmap *map, unsigned int reg,
  144. unsigned int val);
  145. struct regmap_range_node {
  146. struct rb_node node;
  147. const char *name;
  148. struct regmap *map;
  149. unsigned int range_min;
  150. unsigned int range_max;
  151. unsigned int selector_reg;
  152. unsigned int selector_mask;
  153. int selector_shift;
  154. unsigned int window_start;
  155. unsigned int window_len;
  156. };
  157. struct regmap_field {
  158. struct regmap *regmap;
  159. unsigned int mask;
  160. /* lsb */
  161. unsigned int shift;
  162. unsigned int reg;
  163. unsigned int id_size;
  164. unsigned int id_offset;
  165. };
  166. #ifdef CONFIG_DEBUG_FS
  167. extern void regmap_debugfs_initcall(void);
  168. extern void regmap_debugfs_init(struct regmap *map, const char *name);
  169. extern void regmap_debugfs_exit(struct regmap *map);
  170. #else
  171. static inline void regmap_debugfs_initcall(void) { }
  172. static inline void regmap_debugfs_init(struct regmap *map, const char *name) { }
  173. static inline void regmap_debugfs_exit(struct regmap *map) { }
  174. #endif
  175. /* regcache core declarations */
  176. int regcache_init(struct regmap *map, const struct regmap_config *config);
  177. void regcache_exit(struct regmap *map);
  178. int regcache_read(struct regmap *map,
  179. unsigned int reg, unsigned int *value);
  180. int regcache_write(struct regmap *map,
  181. unsigned int reg, unsigned int value);
  182. int regcache_sync(struct regmap *map);
  183. int regcache_sync_block(struct regmap *map, void *block,
  184. unsigned long *cache_present,
  185. unsigned int block_base, unsigned int start,
  186. unsigned int end);
  187. static inline const void *regcache_get_val_addr(struct regmap *map,
  188. const void *base,
  189. unsigned int idx)
  190. {
  191. return base + (map->cache_word_size * idx);
  192. }
  193. unsigned int regcache_get_val(struct regmap *map, const void *base,
  194. unsigned int idx);
  195. bool regcache_set_val(struct regmap *map, void *base, unsigned int idx,
  196. unsigned int val);
  197. int regcache_lookup_reg(struct regmap *map, unsigned int reg);
  198. int _regmap_raw_write(struct regmap *map, unsigned int reg,
  199. const void *val, size_t val_len);
  200. void regmap_async_complete_cb(struct regmap_async *async, int ret);
  201. enum regmap_endian regmap_get_val_endian(struct device *dev,
  202. const struct regmap_bus *bus,
  203. const struct regmap_config *config);
  204. extern struct regcache_ops regcache_rbtree_ops;
  205. extern struct regcache_ops regcache_lzo_ops;
  206. extern struct regcache_ops regcache_flat_ops;
  207. static inline const char *regmap_name(const struct regmap *map)
  208. {
  209. if (map->dev)
  210. return dev_name(map->dev);
  211. return map->name;
  212. }
  213. #endif