LCOV - code coverage report
Current view: top level - lkbce/include/linux/regulator - consumer.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 3 3 100.0 %
Date: 2017-01-25 Functions: 0 0 -

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

Generated by: LCOV version 1.10