/include/linux/regulator/consumer.h

https://bitbucket.org/thekraven/iscream_thunderc-2.6.35 · C++ Header · 300 lines · 149 code · 38 blank · 113 comment · 0 complexity · fb13e938ba829fce8efc437e9a2d7151 MD5 · raw file

  1. /*
  2. * consumer.h -- SoC Regulator consumer support.
  3. *
  4. * Copyright (C) 2007, 2008 Wolfson Microelectronics PLC.
  5. *
  6. * Author: Liam Girdwood <lrg@slimlogic.co.uk>
  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. * Regulator Consumer Interface.
  13. *
  14. * A Power Management Regulator framework for SoC based devices.
  15. * Features:-
  16. * o Voltage and current level control.
  17. * o Operating mode control.
  18. * o Regulator status.
  19. * o sysfs entries for showing client devices and status
  20. *
  21. * EXPERIMENTAL FEATURES:
  22. * Dynamic Regulator operating Mode Switching (DRMS) - allows regulators
  23. * to use most efficient operating mode depending upon voltage and load and
  24. * is transparent to client drivers.
  25. *
  26. * e.g. Devices x,y,z share regulator r. Device x and y draw 20mA each during
  27. * IO and 1mA at idle. Device z draws 100mA when under load and 5mA when
  28. * idling. Regulator r has > 90% efficiency in NORMAL mode at loads > 100mA
  29. * but this drops rapidly to 60% when below 100mA. Regulator r has > 90%
  30. * efficiency in IDLE mode at loads < 10mA. Thus regulator r will operate
  31. * in normal mode for loads > 10mA and in IDLE mode for load <= 10mA.
  32. *
  33. */
  34. #ifndef __LINUX_REGULATOR_CONSUMER_H_
  35. #define __LINUX_REGULATOR_CONSUMER_H_
  36. #include <linux/device.h>
  37. /*
  38. * Regulator operating modes.
  39. *
  40. * Regulators can run in a variety of different operating modes depending on
  41. * output load. This allows further system power savings by selecting the
  42. * best (and most efficient) regulator mode for a desired load.
  43. *
  44. * Most drivers will only care about NORMAL. The modes below are generic and
  45. * will probably not match the naming convention of your regulator data sheet
  46. * but should match the use cases in the datasheet.
  47. *
  48. * In order of power efficiency (least efficient at top).
  49. *
  50. * Mode Description
  51. * FAST Regulator can handle fast changes in it's load.
  52. * e.g. useful in CPU voltage & frequency scaling where
  53. * load can quickly increase with CPU frequency increases.
  54. *
  55. * NORMAL Normal regulator power supply mode. Most drivers will
  56. * use this mode.
  57. *
  58. * IDLE Regulator runs in a more efficient mode for light
  59. * loads. Can be used for devices that have a low power
  60. * requirement during periods of inactivity. This mode
  61. * may be more noisy than NORMAL and may not be able
  62. * to handle fast load switching.
  63. *
  64. * STANDBY Regulator runs in the most efficient mode for very
  65. * light loads. Can be used by devices when they are
  66. * in a sleep/standby state. This mode is likely to be
  67. * the most noisy and may not be able to handle fast load
  68. * switching.
  69. *
  70. * NOTE: Most regulators will only support a subset of these modes. Some
  71. * will only just support NORMAL.
  72. *
  73. * These modes can be OR'ed together to make up a mask of valid register modes.
  74. */
  75. #define REGULATOR_MODE_FAST 0x1
  76. #define REGULATOR_MODE_NORMAL 0x2
  77. #define REGULATOR_MODE_IDLE 0x4
  78. #define REGULATOR_MODE_STANDBY 0x8
  79. /*
  80. * Regulator notifier events.
  81. *
  82. * UNDER_VOLTAGE Regulator output is under voltage.
  83. * OVER_CURRENT Regulator output current is too high.
  84. * REGULATION_OUT Regulator output is out of regulation.
  85. * FAIL Regulator output has failed.
  86. * OVER_TEMP Regulator over temp.
  87. * FORCE_DISABLE Regulator forcibly shut down by software.
  88. * VOLTAGE_CHANGE Regulator voltage changed.
  89. * DISABLE Regulator was disabled.
  90. *
  91. * NOTE: These events can be OR'ed together when passed into handler.
  92. */
  93. #define REGULATOR_EVENT_UNDER_VOLTAGE 0x01
  94. #define REGULATOR_EVENT_OVER_CURRENT 0x02
  95. #define REGULATOR_EVENT_REGULATION_OUT 0x04
  96. #define REGULATOR_EVENT_FAIL 0x08
  97. #define REGULATOR_EVENT_OVER_TEMP 0x10
  98. #define REGULATOR_EVENT_FORCE_DISABLE 0x20
  99. #define REGULATOR_EVENT_VOLTAGE_CHANGE 0x40
  100. #define REGULATOR_EVENT_DISABLE 0x80
  101. struct regulator;
  102. /**
  103. * struct regulator_bulk_data - Data used for bulk regulator operations.
  104. *
  105. * @supply: The name of the supply. Initialised by the user before
  106. * using the bulk regulator APIs.
  107. * @consumer: The regulator consumer for the supply. This will be managed
  108. * by the bulk API.
  109. *
  110. * The regulator APIs provide a series of regulator_bulk_() API calls as
  111. * a convenience to consumers which require multiple supplies. This
  112. * structure is used to manage data for these calls.
  113. */
  114. struct regulator_bulk_data {
  115. const char *supply;
  116. struct regulator *consumer;
  117. };
  118. #if defined(CONFIG_REGULATOR)
  119. /* regulator get and put */
  120. struct regulator *__must_check regulator_get(struct device *dev,
  121. const char *id);
  122. struct regulator *__must_check regulator_get_exclusive(struct device *dev,
  123. const char *id);
  124. void regulator_put(struct regulator *regulator);
  125. /* regulator output control and status */
  126. int regulator_enable(struct regulator *regulator);
  127. int regulator_disable(struct regulator *regulator);
  128. int regulator_force_disable(struct regulator *regulator);
  129. int regulator_is_enabled(struct regulator *regulator);
  130. int regulator_bulk_get(struct device *dev, int num_consumers,
  131. struct regulator_bulk_data *consumers);
  132. int regulator_bulk_enable(int num_consumers,
  133. struct regulator_bulk_data *consumers);
  134. int regulator_bulk_disable(int num_consumers,
  135. struct regulator_bulk_data *consumers);
  136. void regulator_bulk_free(int num_consumers,
  137. struct regulator_bulk_data *consumers);
  138. int regulator_count_voltages(struct regulator *regulator);
  139. int regulator_list_voltage(struct regulator *regulator, unsigned selector);
  140. int regulator_is_supported_voltage(struct regulator *regulator,
  141. int min_uV, int max_uV);
  142. int regulator_set_voltage(struct regulator *regulator, int min_uV, int max_uV);
  143. int regulator_get_voltage(struct regulator *regulator);
  144. int regulator_set_current_limit(struct regulator *regulator,
  145. int min_uA, int max_uA);
  146. int regulator_get_current_limit(struct regulator *regulator);
  147. int regulator_set_mode(struct regulator *regulator, unsigned int mode);
  148. unsigned int regulator_get_mode(struct regulator *regulator);
  149. int regulator_set_optimum_mode(struct regulator *regulator, int load_uA);
  150. /* regulator notifier block */
  151. int regulator_register_notifier(struct regulator *regulator,
  152. struct notifier_block *nb);
  153. int regulator_unregister_notifier(struct regulator *regulator,
  154. struct notifier_block *nb);
  155. /* driver data - core doesn't touch */
  156. void *regulator_get_drvdata(struct regulator *regulator);
  157. void regulator_set_drvdata(struct regulator *regulator, void *data);
  158. #else
  159. /*
  160. * Make sure client drivers will still build on systems with no software
  161. * controllable voltage or current regulators.
  162. */
  163. static inline struct regulator *__must_check regulator_get(struct device *dev,
  164. const char *id)
  165. {
  166. /* Nothing except the stubbed out regulator API should be
  167. * looking at the value except to check if it is an error
  168. * value. Drivers are free to handle NULL specifically by
  169. * skipping all regulator API calls, but they don't have to.
  170. * Drivers which don't, should make sure they properly handle
  171. * corner cases of the API, such as regulator_get_voltage()
  172. * returning 0.
  173. */
  174. return NULL;
  175. }
  176. static inline void regulator_put(struct regulator *regulator)
  177. {
  178. }
  179. static inline int regulator_enable(struct regulator *regulator)
  180. {
  181. return 0;
  182. }
  183. static inline int regulator_disable(struct regulator *regulator)
  184. {
  185. return 0;
  186. }
  187. static inline int regulator_is_enabled(struct regulator *regulator)
  188. {
  189. return 1;
  190. }
  191. static inline int regulator_bulk_get(struct device *dev,
  192. int num_consumers,
  193. struct regulator_bulk_data *consumers)
  194. {
  195. return 0;
  196. }
  197. static inline int regulator_bulk_enable(int num_consumers,
  198. struct regulator_bulk_data *consumers)
  199. {
  200. return 0;
  201. }
  202. static inline int regulator_bulk_disable(int num_consumers,
  203. struct regulator_bulk_data *consumers)
  204. {
  205. return 0;
  206. }
  207. static inline void regulator_bulk_free(int num_consumers,
  208. struct regulator_bulk_data *consumers)
  209. {
  210. }
  211. static inline int regulator_set_voltage(struct regulator *regulator,
  212. int min_uV, int max_uV)
  213. {
  214. return 0;
  215. }
  216. static inline int regulator_get_voltage(struct regulator *regulator)
  217. {
  218. return 0;
  219. }
  220. static inline int regulator_set_current_limit(struct regulator *regulator,
  221. int min_uA, int max_uA)
  222. {
  223. return 0;
  224. }
  225. static inline int regulator_get_current_limit(struct regulator *regulator)
  226. {
  227. return 0;
  228. }
  229. static inline int regulator_set_mode(struct regulator *regulator,
  230. unsigned int mode)
  231. {
  232. return 0;
  233. }
  234. static inline unsigned int regulator_get_mode(struct regulator *regulator)
  235. {
  236. return REGULATOR_MODE_NORMAL;
  237. }
  238. static inline int regulator_set_optimum_mode(struct regulator *regulator,
  239. int load_uA)
  240. {
  241. return REGULATOR_MODE_NORMAL;
  242. }
  243. static inline int regulator_register_notifier(struct regulator *regulator,
  244. struct notifier_block *nb)
  245. {
  246. return 0;
  247. }
  248. static inline int regulator_unregister_notifier(struct regulator *regulator,
  249. struct notifier_block *nb)
  250. {
  251. return 0;
  252. }
  253. static inline void *regulator_get_drvdata(struct regulator *regulator)
  254. {
  255. return NULL;
  256. }
  257. static inline void regulator_set_drvdata(struct regulator *regulator,
  258. void *data)
  259. {
  260. }
  261. #endif
  262. #endif