Liam Girdwood | 571a354 | 2008-04-30 15:42:28 +0100 | [diff] [blame] | 1 | /* |
| 2 | * driver.h -- SoC Regulator driver support. |
| 3 | * |
| 4 | * Copyright (C) 2007, 2008 Wolfson Microelectronics PLC. |
| 5 | * |
Liam Girdwood | 1dd68f0 | 2009-02-02 21:43:31 +0000 | [diff] [blame] | 6 | * Author: Liam Girdwood <lrg@slimlogic.co.uk> |
Liam Girdwood | 571a354 | 2008-04-30 15:42:28 +0100 | [diff] [blame] | 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 Driver Interface. |
| 13 | */ |
| 14 | |
| 15 | #ifndef __LINUX_REGULATOR_DRIVER_H_ |
| 16 | #define __LINUX_REGULATOR_DRIVER_H_ |
| 17 | |
| 18 | #include <linux/device.h> |
Paul Gortmaker | ced55d4 | 2011-07-17 16:24:35 -0400 | [diff] [blame] | 19 | #include <linux/notifier.h> |
Liam Girdwood | 571a354 | 2008-04-30 15:42:28 +0100 | [diff] [blame] | 20 | #include <linux/regulator/consumer.h> |
| 21 | |
Mark Brown | 65b19ce | 2012-04-15 11:16:05 +0100 | [diff] [blame] | 22 | struct regmap; |
Liam Girdwood | 571a354 | 2008-04-30 15:42:28 +0100 | [diff] [blame] | 23 | struct regulator_dev; |
Krzysztof Kozlowski | bfa21a0 | 2015-01-05 12:48:42 +0100 | [diff] [blame] | 24 | struct regulator_config; |
Liam Girdwood | a5766f1 | 2008-10-10 13:22:20 +0100 | [diff] [blame] | 25 | struct regulator_init_data; |
Kim, Milo | f19b00d | 2013-02-18 06:50:39 +0000 | [diff] [blame] | 26 | struct regulator_enable_gpio; |
Liam Girdwood | 571a354 | 2008-04-30 15:42:28 +0100 | [diff] [blame] | 27 | |
David Brownell | 853116a | 2009-01-14 23:03:17 -0800 | [diff] [blame] | 28 | enum regulator_status { |
| 29 | REGULATOR_STATUS_OFF, |
| 30 | REGULATOR_STATUS_ON, |
| 31 | REGULATOR_STATUS_ERROR, |
| 32 | /* fast/normal/idle/standby are flavors of "on" */ |
| 33 | REGULATOR_STATUS_FAST, |
| 34 | REGULATOR_STATUS_NORMAL, |
| 35 | REGULATOR_STATUS_IDLE, |
| 36 | REGULATOR_STATUS_STANDBY, |
Mark Brown | f59c8f9 | 2012-08-31 10:36:37 -0700 | [diff] [blame] | 37 | /* The regulator is enabled but not regulating */ |
| 38 | REGULATOR_STATUS_BYPASS, |
Krystian Garbaciak | 1beaf76 | 2012-07-12 13:53:35 +0100 | [diff] [blame] | 39 | /* in case that any other status doesn't apply */ |
| 40 | REGULATOR_STATUS_UNDEFINED, |
David Brownell | 853116a | 2009-01-14 23:03:17 -0800 | [diff] [blame] | 41 | }; |
| 42 | |
Liam Girdwood | 571a354 | 2008-04-30 15:42:28 +0100 | [diff] [blame] | 43 | /** |
Randy Dunlap | 7c2330f | 2013-09-16 18:08:02 -0700 | [diff] [blame] | 44 | * struct regulator_linear_range - specify linear voltage ranges |
| 45 | * |
Mark Brown | 94d33c0 | 2013-07-02 22:52:41 +0100 | [diff] [blame] | 46 | * Specify a range of voltages for regulator_map_linar_range() and |
| 47 | * regulator_list_linear_range(). |
| 48 | * |
| 49 | * @min_uV: Lowest voltage in range |
Mark Brown | 94d33c0 | 2013-07-02 22:52:41 +0100 | [diff] [blame] | 50 | * @min_sel: Lowest selector for range |
| 51 | * @max_sel: Highest selector for range |
| 52 | * @uV_step: Step size |
| 53 | */ |
| 54 | struct regulator_linear_range { |
| 55 | unsigned int min_uV; |
Mark Brown | 94d33c0 | 2013-07-02 22:52:41 +0100 | [diff] [blame] | 56 | unsigned int min_sel; |
| 57 | unsigned int max_sel; |
| 58 | unsigned int uV_step; |
| 59 | }; |
| 60 | |
Axel Lin | 8828bae | 2013-10-11 09:32:18 +0800 | [diff] [blame] | 61 | /* Initialize struct regulator_linear_range */ |
| 62 | #define REGULATOR_LINEAR_RANGE(_min_uV, _min_sel, _max_sel, _step_uV) \ |
| 63 | { \ |
| 64 | .min_uV = _min_uV, \ |
| 65 | .min_sel = _min_sel, \ |
| 66 | .max_sel = _max_sel, \ |
| 67 | .uV_step = _step_uV, \ |
| 68 | } |
| 69 | |
Mark Brown | 94d33c0 | 2013-07-02 22:52:41 +0100 | [diff] [blame] | 70 | /** |
Liam Girdwood | 571a354 | 2008-04-30 15:42:28 +0100 | [diff] [blame] | 71 | * struct regulator_ops - regulator operations. |
| 72 | * |
David Brownell | 3b2a606 | 2009-02-26 13:28:41 -0800 | [diff] [blame] | 73 | * @enable: Configure the regulator as enabled. |
| 74 | * @disable: Configure the regulator as disabled. |
Wolfram Sang | d87b969 | 2009-09-18 22:44:46 +0200 | [diff] [blame] | 75 | * @is_enabled: Return 1 if the regulator is enabled, 0 if not. |
| 76 | * May also return negative errno. |
Mark Brown | c8e7e46 | 2008-12-31 12:52:42 +0000 | [diff] [blame] | 77 | * |
| 78 | * @set_voltage: Set the voltage for the regulator within the range specified. |
| 79 | * The driver should select the voltage closest to min_uV. |
Mark Brown | e8eef82 | 2010-12-12 14:36:17 +0000 | [diff] [blame] | 80 | * @set_voltage_sel: Set the voltage for the regulator using the specified |
| 81 | * selector. |
Mark Brown | e843fc4 | 2012-05-09 21:16:06 +0100 | [diff] [blame] | 82 | * @map_voltage: Convert a voltage into a selector |
Mark Brown | c8e7e46 | 2008-12-31 12:52:42 +0000 | [diff] [blame] | 83 | * @get_voltage: Return the currently configured voltage for the regulator. |
Mark Brown | 476c2d8 | 2010-12-10 17:28:07 +0000 | [diff] [blame] | 84 | * @get_voltage_sel: Return the currently configured voltage selector for the |
| 85 | * regulator. |
David Brownell | 4367cfd | 2009-02-26 11:48:36 -0800 | [diff] [blame] | 86 | * @list_voltage: Return one of the supported voltages, in microvolts; zero |
| 87 | * if the selector indicates a voltage that is unusable on this system; |
| 88 | * or negative errno. Selectors range from zero to one less than |
| 89 | * regulator_desc.n_voltages. Voltages may be reported in any order. |
Mark Brown | c8e7e46 | 2008-12-31 12:52:42 +0000 | [diff] [blame] | 90 | * |
Mark Brown | c8e7e46 | 2008-12-31 12:52:42 +0000 | [diff] [blame] | 91 | * @set_current_limit: Configure a limit for a current-limited regulator. |
Axel Lin | 89009e1 | 2012-08-08 20:17:18 +0800 | [diff] [blame] | 92 | * The driver should select the current closest to max_uA. |
David Brownell | 3b2a606 | 2009-02-26 13:28:41 -0800 | [diff] [blame] | 93 | * @get_current_limit: Get the configured limit for a current-limited regulator. |
Stephen Boyd | 36e4f83 | 2015-06-11 17:37:06 -0700 | [diff] [blame] | 94 | * @set_input_current_limit: Configure an input limit. |
Mark Brown | c8e7e46 | 2008-12-31 12:52:42 +0000 | [diff] [blame] | 95 | * |
Luis de Bethencourt | abf2f82 | 2016-03-23 11:35:39 +0000 | [diff] [blame^] | 96 | * @set_over_current_protection: Support capability of automatically shutting |
| 97 | * down when detecting an over current event. |
| 98 | * |
Laxman Dewangan | 670666b | 2016-03-02 16:24:46 +0530 | [diff] [blame] | 99 | * @set_active_discharge: Set active discharge enable/disable of regulators. |
| 100 | * |
Randy Dunlap | 9f653251 | 2009-04-03 21:31:30 -0700 | [diff] [blame] | 101 | * @set_mode: Set the configured operating mode for the regulator. |
David Brownell | 3b2a606 | 2009-02-26 13:28:41 -0800 | [diff] [blame] | 102 | * @get_mode: Get the configured operating mode for the regulator. |
| 103 | * @get_status: Return actual (not as-configured) status of regulator, as a |
| 104 | * REGULATOR_STATUS value (or negative errno) |
Mark Brown | c8e7e46 | 2008-12-31 12:52:42 +0000 | [diff] [blame] | 105 | * @get_optimum_mode: Get the most efficient operating mode for the regulator |
| 106 | * when running with the specified parameters. |
Bjorn Andersson | 8f4490e | 2015-02-11 19:39:12 -0800 | [diff] [blame] | 107 | * @set_load: Set the load for the regulator. |
Mark Brown | c8e7e46 | 2008-12-31 12:52:42 +0000 | [diff] [blame] | 108 | * |
Mark Brown | f59c8f9 | 2012-08-31 10:36:37 -0700 | [diff] [blame] | 109 | * @set_bypass: Set the regulator in bypass mode. |
| 110 | * @get_bypass: Get the regulator bypass mode state. |
| 111 | * |
Mark Brown | 31aae2b | 2009-12-21 12:21:52 +0000 | [diff] [blame] | 112 | * @enable_time: Time taken for the regulator voltage output voltage to |
Linus Walleij | 77af1b264 | 2011-03-17 13:24:36 +0100 | [diff] [blame] | 113 | * stabilise after being enabled, in microseconds. |
Yadwinder Singh Brar | 6f0b2c6 | 2012-06-11 17:41:08 +0530 | [diff] [blame] | 114 | * @set_ramp_delay: Set the ramp delay for the regulator. The driver should |
| 115 | * select ramp delay equal to or less than(closest) ramp_delay. |
Linus Walleij | 77af1b264 | 2011-03-17 13:24:36 +0100 | [diff] [blame] | 116 | * @set_voltage_time_sel: Time taken for the regulator voltage output voltage |
| 117 | * to stabilise after being set to a new value, in microseconds. |
| 118 | * The function provides the from and to voltage selector, the |
| 119 | * function should return the worst case. |
Stephen Boyd | c751ad0 | 2015-06-12 15:48:06 -0700 | [diff] [blame] | 120 | * @set_soft_start: Enable soft start for the regulator. |
Mark Brown | 31aae2b | 2009-12-21 12:21:52 +0000 | [diff] [blame] | 121 | * |
Mark Brown | c8e7e46 | 2008-12-31 12:52:42 +0000 | [diff] [blame] | 122 | * @set_suspend_voltage: Set the voltage for the regulator when the system |
| 123 | * is suspended. |
| 124 | * @set_suspend_enable: Mark the regulator as enabled when the system is |
| 125 | * suspended. |
| 126 | * @set_suspend_disable: Mark the regulator as disabled when the system is |
| 127 | * suspended. |
| 128 | * @set_suspend_mode: Set the operating mode for the regulator when the |
| 129 | * system is suspended. |
David Brownell | 3b2a606 | 2009-02-26 13:28:41 -0800 | [diff] [blame] | 130 | * |
Stephen Boyd | 23c779b | 2015-06-11 17:37:04 -0700 | [diff] [blame] | 131 | * @set_pull_down: Configure the regulator to pull down when the regulator |
| 132 | * is disabled. |
| 133 | * |
David Brownell | 3b2a606 | 2009-02-26 13:28:41 -0800 | [diff] [blame] | 134 | * This struct describes regulator operations which can be implemented by |
| 135 | * regulator chip drivers. |
Liam Girdwood | 571a354 | 2008-04-30 15:42:28 +0100 | [diff] [blame] | 136 | */ |
| 137 | struct regulator_ops { |
| 138 | |
David Brownell | 4367cfd | 2009-02-26 11:48:36 -0800 | [diff] [blame] | 139 | /* enumerate supported voltages */ |
| 140 | int (*list_voltage) (struct regulator_dev *, unsigned selector); |
| 141 | |
Liam Girdwood | 571a354 | 2008-04-30 15:42:28 +0100 | [diff] [blame] | 142 | /* get/set regulator voltage */ |
Mark Brown | 3a93f2a | 2010-11-10 14:38:29 +0000 | [diff] [blame] | 143 | int (*set_voltage) (struct regulator_dev *, int min_uV, int max_uV, |
| 144 | unsigned *selector); |
Mark Brown | e843fc4 | 2012-05-09 21:16:06 +0100 | [diff] [blame] | 145 | int (*map_voltage)(struct regulator_dev *, int min_uV, int max_uV); |
Mark Brown | e8eef82 | 2010-12-12 14:36:17 +0000 | [diff] [blame] | 146 | int (*set_voltage_sel) (struct regulator_dev *, unsigned selector); |
Liam Girdwood | 571a354 | 2008-04-30 15:42:28 +0100 | [diff] [blame] | 147 | int (*get_voltage) (struct regulator_dev *); |
Mark Brown | 476c2d8 | 2010-12-10 17:28:07 +0000 | [diff] [blame] | 148 | int (*get_voltage_sel) (struct regulator_dev *); |
Liam Girdwood | 571a354 | 2008-04-30 15:42:28 +0100 | [diff] [blame] | 149 | |
| 150 | /* get/set regulator current */ |
| 151 | int (*set_current_limit) (struct regulator_dev *, |
| 152 | int min_uA, int max_uA); |
| 153 | int (*get_current_limit) (struct regulator_dev *); |
| 154 | |
Stephen Boyd | 36e4f83 | 2015-06-11 17:37:06 -0700 | [diff] [blame] | 155 | int (*set_input_current_limit) (struct regulator_dev *, int lim_uA); |
Stephen Boyd | 3a003ba | 2015-07-17 14:41:54 -0700 | [diff] [blame] | 156 | int (*set_over_current_protection) (struct regulator_dev *); |
Laxman Dewangan | 670666b | 2016-03-02 16:24:46 +0530 | [diff] [blame] | 157 | int (*set_active_discharge) (struct regulator_dev *, bool enable); |
Stephen Boyd | 36e4f83 | 2015-06-11 17:37:06 -0700 | [diff] [blame] | 158 | |
Liam Girdwood | 571a354 | 2008-04-30 15:42:28 +0100 | [diff] [blame] | 159 | /* enable/disable regulator */ |
| 160 | int (*enable) (struct regulator_dev *); |
| 161 | int (*disable) (struct regulator_dev *); |
| 162 | int (*is_enabled) (struct regulator_dev *); |
| 163 | |
Kim, Milo | fde297bb | 2012-02-16 22:41:32 -0800 | [diff] [blame] | 164 | /* get/set regulator operating mode (defined in consumer.h) */ |
Liam Girdwood | 571a354 | 2008-04-30 15:42:28 +0100 | [diff] [blame] | 165 | int (*set_mode) (struct regulator_dev *, unsigned int mode); |
| 166 | unsigned int (*get_mode) (struct regulator_dev *); |
| 167 | |
Linus Walleij | 77af1b264 | 2011-03-17 13:24:36 +0100 | [diff] [blame] | 168 | /* Time taken to enable or set voltage on the regulator */ |
Mark Brown | 31aae2b | 2009-12-21 12:21:52 +0000 | [diff] [blame] | 169 | int (*enable_time) (struct regulator_dev *); |
Yadwinder Singh Brar | 6f0b2c6 | 2012-06-11 17:41:08 +0530 | [diff] [blame] | 170 | int (*set_ramp_delay) (struct regulator_dev *, int ramp_delay); |
Linus Walleij | 77af1b264 | 2011-03-17 13:24:36 +0100 | [diff] [blame] | 171 | int (*set_voltage_time_sel) (struct regulator_dev *, |
| 172 | unsigned int old_selector, |
| 173 | unsigned int new_selector); |
Mark Brown | 31aae2b | 2009-12-21 12:21:52 +0000 | [diff] [blame] | 174 | |
Stephen Boyd | 57f66b7 | 2015-06-11 17:37:05 -0700 | [diff] [blame] | 175 | int (*set_soft_start) (struct regulator_dev *); |
| 176 | |
David Brownell | 853116a | 2009-01-14 23:03:17 -0800 | [diff] [blame] | 177 | /* report regulator status ... most other accessors report |
| 178 | * control inputs, this reports results of combining inputs |
| 179 | * from Linux (and other sources) with the actual load. |
David Brownell | 3b2a606 | 2009-02-26 13:28:41 -0800 | [diff] [blame] | 180 | * returns REGULATOR_STATUS_* or negative errno. |
David Brownell | 853116a | 2009-01-14 23:03:17 -0800 | [diff] [blame] | 181 | */ |
| 182 | int (*get_status)(struct regulator_dev *); |
| 183 | |
Liam Girdwood | 571a354 | 2008-04-30 15:42:28 +0100 | [diff] [blame] | 184 | /* get most efficient regulator operating mode for load */ |
| 185 | unsigned int (*get_optimum_mode) (struct regulator_dev *, int input_uV, |
| 186 | int output_uV, int load_uA); |
Bjorn Andersson | 8f4490e | 2015-02-11 19:39:12 -0800 | [diff] [blame] | 187 | /* set the load on the regulator */ |
| 188 | int (*set_load)(struct regulator_dev *, int load_uA); |
Liam Girdwood | 571a354 | 2008-04-30 15:42:28 +0100 | [diff] [blame] | 189 | |
Mark Brown | f59c8f9 | 2012-08-31 10:36:37 -0700 | [diff] [blame] | 190 | /* control and report on bypass mode */ |
| 191 | int (*set_bypass)(struct regulator_dev *dev, bool enable); |
| 192 | int (*get_bypass)(struct regulator_dev *dev, bool *enable); |
| 193 | |
Liam Girdwood | 571a354 | 2008-04-30 15:42:28 +0100 | [diff] [blame] | 194 | /* the operations below are for configuration of regulator state when |
Mark Brown | 3de8960 | 2008-09-09 16:21:17 +0100 | [diff] [blame] | 195 | * its parent PMIC enters a global STANDBY/HIBERNATE state */ |
Liam Girdwood | 571a354 | 2008-04-30 15:42:28 +0100 | [diff] [blame] | 196 | |
| 197 | /* set regulator suspend voltage */ |
| 198 | int (*set_suspend_voltage) (struct regulator_dev *, int uV); |
| 199 | |
| 200 | /* enable/disable regulator in suspend state */ |
| 201 | int (*set_suspend_enable) (struct regulator_dev *); |
| 202 | int (*set_suspend_disable) (struct regulator_dev *); |
| 203 | |
Kim, Milo | fde297bb | 2012-02-16 22:41:32 -0800 | [diff] [blame] | 204 | /* set regulator suspend operating mode (defined in consumer.h) */ |
Liam Girdwood | 571a354 | 2008-04-30 15:42:28 +0100 | [diff] [blame] | 205 | int (*set_suspend_mode) (struct regulator_dev *, unsigned int mode); |
Stephen Boyd | 23c779b | 2015-06-11 17:37:04 -0700 | [diff] [blame] | 206 | |
| 207 | int (*set_pull_down) (struct regulator_dev *); |
Liam Girdwood | 571a354 | 2008-04-30 15:42:28 +0100 | [diff] [blame] | 208 | }; |
| 209 | |
| 210 | /* |
| 211 | * Regulators can either control voltage or current. |
| 212 | */ |
| 213 | enum regulator_type { |
| 214 | REGULATOR_VOLTAGE, |
| 215 | REGULATOR_CURRENT, |
| 216 | }; |
| 217 | |
| 218 | /** |
Mark Brown | c172708 | 2012-04-04 00:50:22 +0100 | [diff] [blame] | 219 | * struct regulator_desc - Static regulator descriptor |
Liam Girdwood | 571a354 | 2008-04-30 15:42:28 +0100 | [diff] [blame] | 220 | * |
Mark Brown | c172708 | 2012-04-04 00:50:22 +0100 | [diff] [blame] | 221 | * Each regulator registered with the core is described with a |
| 222 | * structure of this type and a struct regulator_config. This |
| 223 | * structure contains the non-varying parts of the regulator |
| 224 | * description. |
Mark Brown | c8e7e46 | 2008-12-31 12:52:42 +0000 | [diff] [blame] | 225 | * |
| 226 | * @name: Identifying name for the regulator. |
Rajendra Nayak | 69511a4 | 2011-11-18 16:47:20 +0530 | [diff] [blame] | 227 | * @supply_name: Identifying the regulator supply |
Mark Brown | a0c7b16 | 2014-09-09 23:13:57 +0100 | [diff] [blame] | 228 | * @of_match: Name used to identify regulator in DT. |
| 229 | * @regulators_node: Name of node containing regulator definitions in DT. |
Krzysztof Kozlowski | bfa21a0 | 2015-01-05 12:48:42 +0100 | [diff] [blame] | 230 | * @of_parse_cb: Optional callback called only if of_match is present. |
| 231 | * Will be called for each regulator parsed from DT, during |
| 232 | * init_data parsing. |
| 233 | * The regulator_config passed as argument to the callback will |
| 234 | * be a copy of config passed to regulator_register, valid only |
| 235 | * for this particular call. Callback may freely change the |
| 236 | * config but it cannot store it for later usage. |
| 237 | * Callback should return 0 on success or negative ERRNO |
| 238 | * indicating failure. |
Mark Brown | c8e7e46 | 2008-12-31 12:52:42 +0000 | [diff] [blame] | 239 | * @id: Numerical identifier for the regulator. |
| 240 | * @ops: Regulator operations table. |
Randy Dunlap | 0ba4887 | 2009-01-08 11:50:23 -0800 | [diff] [blame] | 241 | * @irq: Interrupt number for the regulator. |
Mark Brown | c8e7e46 | 2008-12-31 12:52:42 +0000 | [diff] [blame] | 242 | * @type: Indicates if the regulator is a voltage or current regulator. |
| 243 | * @owner: Module providing the regulator, used for refcounting. |
Mark Brown | bca7bbf | 2012-05-09 21:38:33 +0100 | [diff] [blame] | 244 | * |
Pawel Moll | bd7a2b6 | 2012-09-24 18:56:53 +0100 | [diff] [blame] | 245 | * @continuous_voltage_range: Indicates if the regulator can set any |
| 246 | * voltage within constrains range. |
Mark Brown | bca7bbf | 2012-05-09 21:38:33 +0100 | [diff] [blame] | 247 | * @n_voltages: Number of selectors available for ops.list_voltage(). |
| 248 | * |
| 249 | * @min_uV: Voltage given by the lowest selector (if linear mapping) |
| 250 | * @uV_step: Voltage increase with each selector (if linear mapping) |
Axel Lin | 33234e7 | 2012-11-27 10:24:33 +0800 | [diff] [blame] | 251 | * @linear_min_sel: Minimal selector for starting linear mapping |
Laxman Dewangan | 5a52360 | 2013-09-10 15:45:05 +0530 | [diff] [blame] | 252 | * @fixed_uV: Fixed voltage of rails. |
Axel Lin | ea38d13 | 2012-06-18 14:03:16 +0800 | [diff] [blame] | 253 | * @ramp_delay: Time to settle down after voltage change (unit: uV/us) |
Sascha Hauer | 5abe4f2 | 2015-10-13 12:45:26 +0200 | [diff] [blame] | 254 | * @min_dropout_uV: The minimum dropout voltage this regulator can handle |
Randy Dunlap | a8dbfee | 2014-08-27 14:31:24 -0700 | [diff] [blame] | 255 | * @linear_ranges: A constant table of possible voltage ranges. |
| 256 | * @n_linear_ranges: Number of entries in the @linear_ranges table. |
Axel Lin | cffc959 | 2012-05-20 10:30:21 +0800 | [diff] [blame] | 257 | * @volt_table: Voltage mapping table (if table based mapping) |
Mark Brown | bca7bbf | 2012-05-09 21:38:33 +0100 | [diff] [blame] | 258 | * |
Mark Brown | 4ab5b3d | 2012-04-15 11:23:30 +0100 | [diff] [blame] | 259 | * @vsel_reg: Register for selector when using regulator_regmap_X_voltage_ |
| 260 | * @vsel_mask: Mask for register bitfield used for selector |
Luis de Bethencourt | d13d3a5 | 2016-03-23 11:24:47 +0000 | [diff] [blame] | 261 | * @csel_reg: Register for TPS65218 LS3 current regulator |
| 262 | * @csel_mask: Mask for TPS65218 LS3 current regulator |
Axel Lin | c8520b4 | 2012-12-18 09:30:10 +0800 | [diff] [blame] | 263 | * @apply_reg: Register for initiate voltage change on the output when |
| 264 | * using regulator_set_voltage_sel_regmap |
| 265 | * @apply_bit: Register bitfield used for initiate voltage change on the |
| 266 | * output when using regulator_set_voltage_sel_regmap |
Mark Brown | cd6dffb | 2012-04-15 12:37:47 +0100 | [diff] [blame] | 267 | * @enable_reg: Register for control when using regmap enable/disable ops |
| 268 | * @enable_mask: Mask for control when using regmap enable/disable ops |
Carlo Caione | ca5d1b3 | 2014-03-05 22:11:29 +0100 | [diff] [blame] | 269 | * @enable_val: Enabling value for control when using regmap enable/disable ops |
| 270 | * @disable_val: Disabling value for control when using regmap enable/disable ops |
Axel Lin | 51dcdaf | 2013-03-05 14:16:00 +0800 | [diff] [blame] | 271 | * @enable_is_inverted: A flag to indicate set enable_mask bits to disable |
| 272 | * when using regulator_enable_regmap and friends APIs. |
Nishanth Menon | 5838b03 | 2013-02-28 18:12:47 -0600 | [diff] [blame] | 273 | * @bypass_reg: Register for control when using regmap set_bypass |
| 274 | * @bypass_mask: Mask for control when using regmap set_bypass |
Carlo Caione | ca5d1b3 | 2014-03-05 22:11:29 +0100 | [diff] [blame] | 275 | * @bypass_val_on: Enabling value for control when using regmap set_bypass |
| 276 | * @bypass_val_off: Disabling value for control when using regmap set_bypass |
Laxman Dewangan | 354794d | 2016-03-02 16:24:47 +0530 | [diff] [blame] | 277 | * @active_discharge_off: Enabling value for control when using regmap |
| 278 | * set_active_discharge |
| 279 | * @active_discharge_on: Disabling value for control when using regmap |
| 280 | * set_active_discharge |
| 281 | * @active_discharge_mask: Mask for control when using regmap |
| 282 | * set_active_discharge |
| 283 | * @active_discharge_reg: Register for control when using regmap |
| 284 | * set_active_discharge |
Mark Brown | 79511ed | 2012-06-27 14:23:10 +0100 | [diff] [blame] | 285 | * |
| 286 | * @enable_time: Time taken for initial enable of regulator (in uS). |
Guodong Xu | 871f565 | 2014-08-13 19:33:40 +0800 | [diff] [blame] | 287 | * @off_on_delay: guard time (in uS), before re-enabling a regulator |
Javier Martinez Canillas | 87e1e0f | 2014-11-10 14:43:52 +0100 | [diff] [blame] | 288 | * |
| 289 | * @of_map_mode: Maps a hardware mode defined in a DeviceTree to a standard mode |
Liam Girdwood | 571a354 | 2008-04-30 15:42:28 +0100 | [diff] [blame] | 290 | */ |
| 291 | struct regulator_desc { |
| 292 | const char *name; |
Rajendra Nayak | 69511a4 | 2011-11-18 16:47:20 +0530 | [diff] [blame] | 293 | const char *supply_name; |
Mark Brown | a0c7b16 | 2014-09-09 23:13:57 +0100 | [diff] [blame] | 294 | const char *of_match; |
| 295 | const char *regulators_node; |
Krzysztof Kozlowski | bfa21a0 | 2015-01-05 12:48:42 +0100 | [diff] [blame] | 296 | int (*of_parse_cb)(struct device_node *, |
| 297 | const struct regulator_desc *, |
| 298 | struct regulator_config *); |
Liam Girdwood | 571a354 | 2008-04-30 15:42:28 +0100 | [diff] [blame] | 299 | int id; |
Pawel Moll | bd7a2b6 | 2012-09-24 18:56:53 +0100 | [diff] [blame] | 300 | bool continuous_voltage_range; |
David Brownell | 4367cfd | 2009-02-26 11:48:36 -0800 | [diff] [blame] | 301 | unsigned n_voltages; |
Axel Lin | df11e50 | 2014-08-21 10:11:34 +0800 | [diff] [blame] | 302 | const struct regulator_ops *ops; |
Liam Girdwood | 571a354 | 2008-04-30 15:42:28 +0100 | [diff] [blame] | 303 | int irq; |
| 304 | enum regulator_type type; |
| 305 | struct module *owner; |
Mark Brown | 4ab5b3d | 2012-04-15 11:23:30 +0100 | [diff] [blame] | 306 | |
Mark Brown | bca7bbf | 2012-05-09 21:38:33 +0100 | [diff] [blame] | 307 | unsigned int min_uV; |
| 308 | unsigned int uV_step; |
Axel Lin | 33234e7 | 2012-11-27 10:24:33 +0800 | [diff] [blame] | 309 | unsigned int linear_min_sel; |
Laxman Dewangan | 5a52360 | 2013-09-10 15:45:05 +0530 | [diff] [blame] | 310 | int fixed_uV; |
Yadwinder Singh Brar | 98a175b | 2012-06-09 16:40:38 +0530 | [diff] [blame] | 311 | unsigned int ramp_delay; |
Sascha Hauer | 5abe4f2 | 2015-10-13 12:45:26 +0200 | [diff] [blame] | 312 | int min_dropout_uV; |
Mark Brown | bca7bbf | 2012-05-09 21:38:33 +0100 | [diff] [blame] | 313 | |
Mark Brown | 94d33c0 | 2013-07-02 22:52:41 +0100 | [diff] [blame] | 314 | const struct regulator_linear_range *linear_ranges; |
| 315 | int n_linear_ranges; |
| 316 | |
Axel Lin | cffc959 | 2012-05-20 10:30:21 +0800 | [diff] [blame] | 317 | const unsigned int *volt_table; |
| 318 | |
Mark Brown | 4ab5b3d | 2012-04-15 11:23:30 +0100 | [diff] [blame] | 319 | unsigned int vsel_reg; |
| 320 | unsigned int vsel_mask; |
Nikita Kiryanov | c0ea88b | 2015-11-25 13:59:04 +0200 | [diff] [blame] | 321 | unsigned int csel_reg; |
| 322 | unsigned int csel_mask; |
Axel Lin | c8520b4 | 2012-12-18 09:30:10 +0800 | [diff] [blame] | 323 | unsigned int apply_reg; |
| 324 | unsigned int apply_bit; |
Mark Brown | cd6dffb | 2012-04-15 12:37:47 +0100 | [diff] [blame] | 325 | unsigned int enable_reg; |
| 326 | unsigned int enable_mask; |
Carlo Caione | ca5d1b3 | 2014-03-05 22:11:29 +0100 | [diff] [blame] | 327 | unsigned int enable_val; |
| 328 | unsigned int disable_val; |
Axel Lin | 51dcdaf | 2013-03-05 14:16:00 +0800 | [diff] [blame] | 329 | bool enable_is_inverted; |
Mark Brown | df36793 | 2012-08-27 16:04:23 -0700 | [diff] [blame] | 330 | unsigned int bypass_reg; |
| 331 | unsigned int bypass_mask; |
Carlo Caione | ca5d1b3 | 2014-03-05 22:11:29 +0100 | [diff] [blame] | 332 | unsigned int bypass_val_on; |
| 333 | unsigned int bypass_val_off; |
Laxman Dewangan | 354794d | 2016-03-02 16:24:47 +0530 | [diff] [blame] | 334 | unsigned int active_discharge_on; |
| 335 | unsigned int active_discharge_off; |
| 336 | unsigned int active_discharge_mask; |
| 337 | unsigned int active_discharge_reg; |
Mark Brown | 79511ed | 2012-06-27 14:23:10 +0100 | [diff] [blame] | 338 | |
| 339 | unsigned int enable_time; |
Guodong Xu | 871f565 | 2014-08-13 19:33:40 +0800 | [diff] [blame] | 340 | |
| 341 | unsigned int off_on_delay; |
Javier Martinez Canillas | 87e1e0f | 2014-11-10 14:43:52 +0100 | [diff] [blame] | 342 | |
| 343 | unsigned int (*of_map_mode)(unsigned int mode); |
Liam Girdwood | 571a354 | 2008-04-30 15:42:28 +0100 | [diff] [blame] | 344 | }; |
| 345 | |
Mark Brown | c172708 | 2012-04-04 00:50:22 +0100 | [diff] [blame] | 346 | /** |
| 347 | * struct regulator_config - Dynamic regulator descriptor |
| 348 | * |
| 349 | * Each regulator registered with the core is described with a |
| 350 | * structure of this type and a struct regulator_desc. This structure |
| 351 | * contains the runtime variable parts of the regulator description. |
| 352 | * |
| 353 | * @dev: struct device for the regulator |
| 354 | * @init_data: platform provided init data, passed through by driver |
| 355 | * @driver_data: private regulator data |
| 356 | * @of_node: OpenFirmware node to parse for device tree bindings (may be |
| 357 | * NULL). |
Axel Lin | cf39284 | 2015-03-18 08:57:41 +0800 | [diff] [blame] | 358 | * @regmap: regmap to use for core regmap helpers if dev_get_regmap() is |
Mark Brown | 380a0e6 | 2012-08-31 10:31:53 -0700 | [diff] [blame] | 359 | * insufficient. |
Markus Pargmann | 76f439d | 2014-10-08 15:47:05 +0200 | [diff] [blame] | 360 | * @ena_gpio_initialized: GPIO controlling regulator enable was properly |
| 361 | * initialized, meaning that >= 0 is a valid gpio |
| 362 | * identifier and < 0 is a non existent gpio. |
Mark Brown | 65f7350 | 2012-06-27 14:14:38 +0100 | [diff] [blame] | 363 | * @ena_gpio: GPIO controlling regulator enable. |
| 364 | * @ena_gpio_invert: Sense for GPIO enable control. |
| 365 | * @ena_gpio_flags: Flags to use when calling gpio_request_one() |
Mark Brown | c172708 | 2012-04-04 00:50:22 +0100 | [diff] [blame] | 366 | */ |
| 367 | struct regulator_config { |
| 368 | struct device *dev; |
| 369 | const struct regulator_init_data *init_data; |
| 370 | void *driver_data; |
| 371 | struct device_node *of_node; |
Mark Brown | 65b19ce | 2012-04-15 11:16:05 +0100 | [diff] [blame] | 372 | struct regmap *regmap; |
Mark Brown | 65f7350 | 2012-06-27 14:14:38 +0100 | [diff] [blame] | 373 | |
Markus Pargmann | 76f439d | 2014-10-08 15:47:05 +0200 | [diff] [blame] | 374 | bool ena_gpio_initialized; |
Mark Brown | 65f7350 | 2012-06-27 14:14:38 +0100 | [diff] [blame] | 375 | int ena_gpio; |
| 376 | unsigned int ena_gpio_invert:1; |
| 377 | unsigned int ena_gpio_flags; |
Mark Brown | c172708 | 2012-04-04 00:50:22 +0100 | [diff] [blame] | 378 | }; |
| 379 | |
Mark Brown | 1fa9ad5 | 2009-01-21 14:08:40 +0000 | [diff] [blame] | 380 | /* |
| 381 | * struct regulator_dev |
| 382 | * |
| 383 | * Voltage / Current regulator class device. One for each |
| 384 | * regulator. |
| 385 | * |
| 386 | * This should *not* be used directly by anything except the regulator |
| 387 | * core and notification injection (which should take the mutex and do |
| 388 | * no other direct access). |
| 389 | */ |
| 390 | struct regulator_dev { |
Mark Brown | 65f2684 | 2012-04-03 20:46:53 +0100 | [diff] [blame] | 391 | const struct regulator_desc *desc; |
Mark Brown | 5ffbd13 | 2009-07-21 16:00:23 +0100 | [diff] [blame] | 392 | int exclusive; |
Mark Brown | 1130e5b | 2010-12-21 23:49:31 +0000 | [diff] [blame] | 393 | u32 use_count; |
| 394 | u32 open_count; |
Mark Brown | f59c8f9 | 2012-08-31 10:36:37 -0700 | [diff] [blame] | 395 | u32 bypass_count; |
Mark Brown | 1fa9ad5 | 2009-01-21 14:08:40 +0000 | [diff] [blame] | 396 | |
| 397 | /* lists we belong to */ |
| 398 | struct list_head list; /* list of all regulators */ |
Mark Brown | 1fa9ad5 | 2009-01-21 14:08:40 +0000 | [diff] [blame] | 399 | |
| 400 | /* lists we own */ |
| 401 | struct list_head consumer_list; /* consumers we supply */ |
Mark Brown | 1fa9ad5 | 2009-01-21 14:08:40 +0000 | [diff] [blame] | 402 | |
| 403 | struct blocking_notifier_head notifier; |
| 404 | struct mutex mutex; /* consumer lock */ |
| 405 | struct module *owner; |
| 406 | struct device dev; |
| 407 | struct regulation_constraints *constraints; |
Mark Brown | 3801b86 | 2011-06-09 16:22:22 +0100 | [diff] [blame] | 408 | struct regulator *supply; /* for tree */ |
Bjorn Andersson | 6261b06 | 2015-03-24 18:56:05 -0700 | [diff] [blame] | 409 | const char *supply_name; |
Mark Brown | 65b19ce | 2012-04-15 11:16:05 +0100 | [diff] [blame] | 410 | struct regmap *regmap; |
Mark Brown | 1fa9ad5 | 2009-01-21 14:08:40 +0000 | [diff] [blame] | 411 | |
Mark Brown | da07ecd | 2011-09-11 09:53:50 +0100 | [diff] [blame] | 412 | struct delayed_work disable_work; |
| 413 | int deferred_disables; |
| 414 | |
Mark Brown | 1fa9ad5 | 2009-01-21 14:08:40 +0000 | [diff] [blame] | 415 | void *reg_data; /* regulator_dev data */ |
Mark Brown | 1130e5b | 2010-12-21 23:49:31 +0000 | [diff] [blame] | 416 | |
Mark Brown | 1130e5b | 2010-12-21 23:49:31 +0000 | [diff] [blame] | 417 | struct dentry *debugfs; |
Mark Brown | 65f7350 | 2012-06-27 14:14:38 +0100 | [diff] [blame] | 418 | |
Kim, Milo | f19b00d | 2013-02-18 06:50:39 +0000 | [diff] [blame] | 419 | struct regulator_enable_gpio *ena_pin; |
Mark Brown | 65f7350 | 2012-06-27 14:14:38 +0100 | [diff] [blame] | 420 | unsigned int ena_gpio_state:1; |
Guodong Xu | 871f565 | 2014-08-13 19:33:40 +0800 | [diff] [blame] | 421 | |
| 422 | /* time when this regulator was disabled last time */ |
| 423 | unsigned long last_off_jiffy; |
Mark Brown | 1fa9ad5 | 2009-01-21 14:08:40 +0000 | [diff] [blame] | 424 | }; |
| 425 | |
Mark Brown | 65f2684 | 2012-04-03 20:46:53 +0100 | [diff] [blame] | 426 | struct regulator_dev * |
| 427 | regulator_register(const struct regulator_desc *regulator_desc, |
Mark Brown | c172708 | 2012-04-04 00:50:22 +0100 | [diff] [blame] | 428 | const struct regulator_config *config); |
Mark Brown | b33e46b | 2013-08-31 11:58:26 +0100 | [diff] [blame] | 429 | struct regulator_dev * |
| 430 | devm_regulator_register(struct device *dev, |
| 431 | const struct regulator_desc *regulator_desc, |
| 432 | const struct regulator_config *config); |
Liam Girdwood | 571a354 | 2008-04-30 15:42:28 +0100 | [diff] [blame] | 433 | void regulator_unregister(struct regulator_dev *rdev); |
Mark Brown | b33e46b | 2013-08-31 11:58:26 +0100 | [diff] [blame] | 434 | void devm_regulator_unregister(struct device *dev, struct regulator_dev *rdev); |
Liam Girdwood | 571a354 | 2008-04-30 15:42:28 +0100 | [diff] [blame] | 435 | |
| 436 | int regulator_notifier_call_chain(struct regulator_dev *rdev, |
| 437 | unsigned long event, void *data); |
| 438 | |
| 439 | void *rdev_get_drvdata(struct regulator_dev *rdev); |
Liam Girdwood | a5766f1 | 2008-10-10 13:22:20 +0100 | [diff] [blame] | 440 | struct device *rdev_get_dev(struct regulator_dev *rdev); |
Liam Girdwood | 571a354 | 2008-04-30 15:42:28 +0100 | [diff] [blame] | 441 | int rdev_get_id(struct regulator_dev *rdev); |
| 442 | |
Mark Brown | be72197 | 2009-08-04 20:09:52 +0200 | [diff] [blame] | 443 | int regulator_mode_to_status(unsigned int); |
| 444 | |
Mark Brown | bca7bbf | 2012-05-09 21:38:33 +0100 | [diff] [blame] | 445 | int regulator_list_voltage_linear(struct regulator_dev *rdev, |
| 446 | unsigned int selector); |
Mark Brown | 94d33c0 | 2013-07-02 22:52:41 +0100 | [diff] [blame] | 447 | int regulator_list_voltage_linear_range(struct regulator_dev *rdev, |
| 448 | unsigned int selector); |
Axel Lin | cffc959 | 2012-05-20 10:30:21 +0800 | [diff] [blame] | 449 | int regulator_list_voltage_table(struct regulator_dev *rdev, |
| 450 | unsigned int selector); |
Mark Brown | bca7bbf | 2012-05-09 21:38:33 +0100 | [diff] [blame] | 451 | int regulator_map_voltage_linear(struct regulator_dev *rdev, |
| 452 | int min_uV, int max_uV); |
Mark Brown | 94d33c0 | 2013-07-02 22:52:41 +0100 | [diff] [blame] | 453 | int regulator_map_voltage_linear_range(struct regulator_dev *rdev, |
| 454 | int min_uV, int max_uV); |
Mark Brown | e843fc4 | 2012-05-09 21:16:06 +0100 | [diff] [blame] | 455 | int regulator_map_voltage_iterate(struct regulator_dev *rdev, |
| 456 | int min_uV, int max_uV); |
Axel Lin | fcf371e | 2013-04-18 10:34:49 +0800 | [diff] [blame] | 457 | int regulator_map_voltage_ascend(struct regulator_dev *rdev, |
| 458 | int min_uV, int max_uV); |
Mark Brown | 4ab5b3d | 2012-04-15 11:23:30 +0100 | [diff] [blame] | 459 | int regulator_get_voltage_sel_regmap(struct regulator_dev *rdev); |
| 460 | int regulator_set_voltage_sel_regmap(struct regulator_dev *rdev, unsigned sel); |
Mark Brown | cd6dffb | 2012-04-15 12:37:47 +0100 | [diff] [blame] | 461 | int regulator_is_enabled_regmap(struct regulator_dev *rdev); |
| 462 | int regulator_enable_regmap(struct regulator_dev *rdev); |
| 463 | int regulator_disable_regmap(struct regulator_dev *rdev); |
Yadwinder Singh Brar | 98a175b | 2012-06-09 16:40:38 +0530 | [diff] [blame] | 464 | int regulator_set_voltage_time_sel(struct regulator_dev *rdev, |
| 465 | unsigned int old_selector, |
| 466 | unsigned int new_selector); |
Mark Brown | df36793 | 2012-08-27 16:04:23 -0700 | [diff] [blame] | 467 | int regulator_set_bypass_regmap(struct regulator_dev *rdev, bool enable); |
| 468 | int regulator_get_bypass_regmap(struct regulator_dev *rdev, bool *enable); |
Mark Brown | 4ab5b3d | 2012-04-15 11:23:30 +0100 | [diff] [blame] | 469 | |
Laxman Dewangan | 354794d | 2016-03-02 16:24:47 +0530 | [diff] [blame] | 470 | int regulator_set_active_discharge_regmap(struct regulator_dev *rdev, |
| 471 | bool enable); |
Liam Girdwood | a5766f1 | 2008-10-10 13:22:20 +0100 | [diff] [blame] | 472 | void *regulator_get_init_drvdata(struct regulator_init_data *reg_init_data); |
| 473 | |
Liam Girdwood | 571a354 | 2008-04-30 15:42:28 +0100 | [diff] [blame] | 474 | #endif |