home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / linux / regulator / consumer.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  8.5 KB  |  285 lines
  1. /*
  2.  * consumer.h -- SoC Regulator consumer support.
  3.  *
  4.  * Copyright (C) 2007, 2008 Wolfson Microelectronics PLC.
  5.  *
  6.  * Author: Liam Girdwood <lg@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.  * 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.  
  35. #ifndef __LINUX_REGULATOR_CONSUMER_H_
  36. #define __LINUX_REGULATOR_CONSUMER_H_
  37.  
  38. /*
  39.  * Regulator operating modes.
  40.  *
  41.  * Regulators can run in a variety of different operating modes depending on
  42.  * output load. This allows further system power savings by selecting the
  43.  * best (and most efficient) regulator mode for a desired load.
  44.  *
  45.  * Most drivers will only care about NORMAL. The modes below are generic and
  46.  * will probably not match the naming convention of your regulator data sheet
  47.  * but should match the use cases in the datasheet.
  48.  *
  49.  * In order of power efficiency (least efficient at top).
  50.  *
  51.  *  Mode       Description
  52.  *  FAST       Regulator can handle fast changes in it's load.
  53.  *             e.g. useful in CPU voltage & frequency scaling where
  54.  *             load can quickly increase with CPU frequency increases.
  55.  *
  56.  *  NORMAL     Normal regulator power supply mode. Most drivers will
  57.  *             use this mode.
  58.  *
  59.  *  IDLE       Regulator runs in a more efficient mode for light
  60.  *             loads. Can be used for devices that have a low power
  61.  *             requirement during periods of inactivity. This mode
  62.  *             may be more noisy than NORMAL and may not be able
  63.  *             to handle fast load switching.
  64.  *
  65.  *  STANDBY    Regulator runs in the most efficient mode for very
  66.  *             light loads. Can be used by devices when they are
  67.  *             in a sleep/standby state. This mode is likely to be
  68.  *             the most noisy and may not be able to handle fast load
  69.  *             switching.
  70.  *
  71.  * NOTE: Most regulators will only support a subset of these modes. Some
  72.  * will only just support NORMAL.
  73.  *
  74.  * These modes can be OR'ed together to make up a mask of valid register modes.
  75.  */
  76.  
  77. #define REGULATOR_MODE_FAST            0x1
  78. #define REGULATOR_MODE_NORMAL            0x2
  79. #define REGULATOR_MODE_IDLE            0x4
  80. #define REGULATOR_MODE_STANDBY            0x8
  81.  
  82. /*
  83.  * Regulator notifier events.
  84.  *
  85.  * UNDER_VOLTAGE  Regulator output is under voltage.
  86.  * OVER_CURRENT   Regulator output current is too high.
  87.  * REGULATION_OUT Regulator output is out of regulation.
  88.  * FAIL           Regulator output has failed.
  89.  * OVER_TEMP      Regulator over temp.
  90.  * FORCE_DISABLE  Regulator shut down by software.
  91.  *
  92.  * NOTE: These events can be OR'ed together when passed into handler.
  93.  */
  94.  
  95. #define REGULATOR_EVENT_UNDER_VOLTAGE        0x01
  96. #define REGULATOR_EVENT_OVER_CURRENT        0x02
  97. #define REGULATOR_EVENT_REGULATION_OUT        0x04
  98. #define REGULATOR_EVENT_FAIL            0x08
  99. #define REGULATOR_EVENT_OVER_TEMP        0x10
  100. #define REGULATOR_EVENT_FORCE_DISABLE        0x20
  101.  
  102. struct regulator;
  103.  
  104. /**
  105.  * struct regulator_bulk_data - Data used for bulk regulator operations.
  106.  *
  107.  * @supply   The name of the supply.  Initialised by the user before
  108.  *           using the bulk regulator APIs.
  109.  * @consumer The regulator consumer for the supply.  This will be managed
  110.  *           by the bulk API.
  111.  *
  112.  * The regulator APIs provide a series of regulator_bulk_() API calls as
  113.  * a convenience to consumers which require multiple supplies.  This
  114.  * structure is used to manage data for these calls.
  115.  */
  116. struct regulator_bulk_data {
  117.     const char *supply;
  118.     struct regulator *consumer;
  119. };
  120.  
  121. #if defined(CONFIG_REGULATOR)
  122.  
  123. /* regulator get and put */
  124. struct regulator *__must_check regulator_get(struct device *dev,
  125.                          const char *id);
  126. void regulator_put(struct regulator *regulator);
  127.  
  128. /* regulator output control and status */
  129. int regulator_enable(struct regulator *regulator);
  130. int regulator_disable(struct regulator *regulator);
  131. int regulator_force_disable(struct regulator *regulator);
  132. int regulator_is_enabled(struct regulator *regulator);
  133.  
  134. int regulator_bulk_get(struct device *dev, int num_consumers,
  135.                struct regulator_bulk_data *consumers);
  136. int regulator_bulk_enable(int num_consumers,
  137.               struct regulator_bulk_data *consumers);
  138. int regulator_bulk_disable(int num_consumers,
  139.                struct regulator_bulk_data *consumers);
  140. void regulator_bulk_free(int num_consumers,
  141.              struct regulator_bulk_data *consumers);
  142.  
  143. int regulator_set_voltage(struct regulator *regulator, int min_uV, int max_uV);
  144. int regulator_get_voltage(struct regulator *regulator);
  145. int regulator_set_current_limit(struct regulator *regulator,
  146.                    int min_uA, int max_uA);
  147. int regulator_get_current_limit(struct regulator *regulator);
  148.  
  149. int regulator_set_mode(struct regulator *regulator, unsigned int mode);
  150. unsigned int regulator_get_mode(struct regulator *regulator);
  151. int regulator_set_optimum_mode(struct regulator *regulator, int load_uA);
  152.  
  153. /* regulator notifier block */
  154. int regulator_register_notifier(struct regulator *regulator,
  155.                   struct notifier_block *nb);
  156. int regulator_unregister_notifier(struct regulator *regulator,
  157.                 struct notifier_block *nb);
  158.  
  159. /* driver data - core doesn't touch */
  160. void *regulator_get_drvdata(struct regulator *regulator);
  161. void regulator_set_drvdata(struct regulator *regulator, void *data);
  162.  
  163. #else
  164.  
  165. /*
  166.  * Make sure client drivers will still build on systems with no software
  167.  * controllable voltage or current regulators.
  168.  */
  169. static inline struct regulator *__must_check regulator_get(struct device *dev,
  170.     const char *id)
  171. {
  172.     /* Nothing except the stubbed out regulator API should be
  173.      * looking at the value except to check if it is an error
  174.      * value so the actual return value doesn't matter.
  175.      */
  176.     return (struct regulator *)id;
  177. }
  178. static inline void regulator_put(struct regulator *regulator)
  179. {
  180. }
  181.  
  182. static inline int regulator_enable(struct regulator *regulator)
  183. {
  184.     return 0;
  185. }
  186.  
  187. static inline int regulator_disable(struct regulator *regulator)
  188. {
  189.     return 0;
  190. }
  191.  
  192. static inline int regulator_is_enabled(struct regulator *regulator)
  193. {
  194.     return 1;
  195. }
  196.  
  197. static inline int regulator_bulk_get(struct device *dev,
  198.                      int num_consumers,
  199.                      struct regulator_bulk_data *consumers)
  200. {
  201.     return 0;
  202. }
  203.  
  204. static inline int regulator_bulk_enable(int num_consumers,
  205.                     struct regulator_bulk_data *consumers)
  206. {
  207.     return 0;
  208. }
  209.  
  210. static inline int regulator_bulk_disable(int num_consumers,
  211.                      struct regulator_bulk_data *consumers)
  212. {
  213.     return 0;
  214. }
  215.  
  216. static inline void regulator_bulk_free(int num_consumers,
  217.                        struct regulator_bulk_data *consumers)
  218. {
  219. }
  220.  
  221. static inline int regulator_set_voltage(struct regulator *regulator,
  222.                     int min_uV, int max_uV)
  223. {
  224.     return 0;
  225. }
  226.  
  227. static inline int regulator_get_voltage(struct regulator *regulator)
  228. {
  229.     return 0;
  230. }
  231.  
  232. static inline int regulator_set_current_limit(struct regulator *regulator,
  233.                          int min_uA, int max_uA)
  234. {
  235.     return 0;
  236. }
  237.  
  238. static inline int regulator_get_current_limit(struct regulator *regulator)
  239. {
  240.     return 0;
  241. }
  242.  
  243. static inline int regulator_set_mode(struct regulator *regulator,
  244.     unsigned int mode)
  245. {
  246.     return 0;
  247. }
  248.  
  249. static inline unsigned int regulator_get_mode(struct regulator *regulator)
  250. {
  251.     return REGULATOR_MODE_NORMAL;
  252. }
  253.  
  254. static inline int regulator_set_optimum_mode(struct regulator *regulator,
  255.                     int load_uA)
  256. {
  257.     return REGULATOR_MODE_NORMAL;
  258. }
  259.  
  260. static inline int regulator_register_notifier(struct regulator *regulator,
  261.                   struct notifier_block *nb)
  262. {
  263.     return 0;
  264. }
  265.  
  266. static inline int regulator_unregister_notifier(struct regulator *regulator,
  267.                 struct notifier_block *nb)
  268. {
  269.     return 0;
  270. }
  271.  
  272. static inline void *regulator_get_drvdata(struct regulator *regulator)
  273. {
  274.     return NULL;
  275. }
  276.  
  277. static inline void regulator_set_drvdata(struct regulator *regulator,
  278.     void *data)
  279. {
  280. }
  281.  
  282. #endif
  283.  
  284. #endif
  285.