1 /* 2 * Copyright (C) 2014-2015 Samsung Electronics 3 * Przemyslaw Marczak <p.marczak@samsung.com> 4 * 5 * SPDX-License-Identifier: GPL-2.0+ 6 */ 7 8 #ifndef _INCLUDE_REGULATOR_H_ 9 #define _INCLUDE_REGULATOR_H_ 10 11 /** 12 * U-Boot Voltage/Current Regulator 13 * ================================ 14 * 15 * The regulator API is based on a driver model, with the device tree support. 16 * And this header describes the functions and data types for the uclass id: 17 * 'UCLASS_REGULATOR' and the regulator driver API. 18 * 19 * The regulator uclass - is based on uclass platform data which is allocated, 20 * automatically for each regulator device on bind and 'dev->uclass_platdata' 21 * points to it. The data type is: 'struct dm_regulator_uclass_platdata'. 22 * The uclass file: 'drivers/power/regulator/regulator-uclass.c' 23 * 24 * The regulator device - is based on driver's model 'struct udevice'. 25 * The API can use regulator name in two meanings: 26 * - devname - the regulator device's name: 'dev->name' 27 * - platname - the device's platdata's name. So in the code it looks like: 28 * 'uc_pdata = dev->uclass_platdata'; 'name = uc_pdata->name'. 29 * 30 * The regulator device driver - provide an implementation of uclass operations 31 * pointed by 'dev->driver->ops' as a struct of type 'struct dm_regulator_ops'. 32 * 33 * To proper bind the regulator device, the device tree node should provide 34 * regulator constraints, like in the example below: 35 * 36 * ldo1 { 37 * regulator-name = "VDD_MMC_1.8V"; (must be unique for proper bind) 38 * regulator-min-microvolt = <1000000>; (optional) 39 * regulator-max-microvolt = <1000000>; (optional) 40 * regulator-min-microamp = <1000>; (optional) 41 * regulator-max-microamp = <1000>; (optional) 42 * regulator-always-on; (optional) 43 * regulator-boot-on; (optional) 44 * }; 45 * 46 * Note: For the proper operation, at least name constraint is needed, since 47 * it can be used when calling regulator_get_by_platname(). And the mandatory 48 * rule for this name is, that it must be globally unique for the single dts. 49 * 50 * Regulator bind: 51 * For each regulator device, the device_bind() should be called with passed 52 * device tree offset. This is required for this uclass's '.post_bind' method, 53 * which does the scan on the device node, for the 'regulator-name' constraint. 54 * If the parent is not a PMIC device, and the child is not bind by function: 55 * 'pmic_bind_childs()', then it's recommended to bind the device by call to 56 * dm_scan_fdt_node() - this is usually done automatically for bus devices, 57 * as a post bind method. 58 * 59 * Regulator get: 60 * Having the device's name constraint, we can call regulator_by_platname(), 61 * to find the required regulator. Before return, the regulator is probed, 62 * and the rest of its constraints are put into the device's uclass platform 63 * data, by the uclass regulator '.pre_probe' method. 64 * 65 * For more info about PMIC bind, please refer to file: 'include/power/pmic.h' 66 * 67 * Note: 68 * Please do not use the device_bind_by_name() function, since it pass '-1' as 69 * device node offset - and the bind will fail on uclass .post_bind method, 70 * because of missing 'regulator-name' constraint. 71 * 72 * 73 * Fixed Voltage/Current Regulator 74 * =============================== 75 * 76 * When fixed voltage regulator is needed, then enable the config: 77 * - CONFIG_DM_REGULATOR_FIXED 78 * 79 * The driver file: 'drivers/power/regulator/fixed.c', provides basic support 80 * for control the GPIO, and return the device tree constraint values. 81 * 82 * To bind the fixed voltage regulator device, we usually use a 'simple-bus' 83 * node as a parent. And 'regulator-fixed' for the driver compatible. This is 84 * the same as in the kernel. The example node of fixed regulator: 85 * 86 * simple-bus { 87 * compatible = "simple-bus"; 88 * #address-cells = <1>; 89 * #size-cells = <0>; 90 * 91 * blue_led { 92 * compatible = "regulator-fixed"; 93 * regulator-name = "VDD_LED_3.3V"; 94 * regulator-min-microvolt = <3300000>; 95 * regulator-max-microvolt = <3300000>; 96 * gpio = <&gpc1 0 GPIO_ACTIVE_LOW>; 97 * }; 98 * }; 99 * 100 * The fixed regulator devices also provide regulator uclass platform data. And 101 * devices bound from such node, can use the regulator drivers API. 102 */ 103 104 /* enum regulator_type - used for regulator_*() variant calls */ 105 enum regulator_type { 106 REGULATOR_TYPE_LDO = 0, 107 REGULATOR_TYPE_BUCK, 108 REGULATOR_TYPE_DVS, 109 REGULATOR_TYPE_FIXED, 110 REGULATOR_TYPE_OTHER, 111 }; 112 113 /** 114 * struct dm_regulator_mode - this structure holds an information about 115 * each regulator operation mode. Probably in most cases - an array. 116 * This will be probably a driver-static data, since it is device-specific. 117 * 118 * @id - a driver-specific mode id 119 * @register_value - a driver-specific value for its mode id 120 * @name - the name of mode - used for regulator command 121 * Note: 122 * The field 'id', should be always a positive number, since the negative values 123 * are reserved for the errno numbers when returns the mode id. 124 */ 125 struct dm_regulator_mode { 126 int id; /* Set only as >= 0 (negative value is reserved for errno) */ 127 int register_value; 128 const char *name; 129 }; 130 131 /** 132 * struct dm_regulator_uclass_platdata - pointed by dev->uclass_platdata, and 133 * allocated on each regulator bind. This structure holds an information 134 * about each regulator's constraints and supported operation modes. 135 * There is no "step" voltage value - so driver should take care of this. 136 * 137 * @type - one of 'enum regulator_type' 138 * @mode - pointer to the regulator mode (array if more than one) 139 * @mode_count - number of '.mode' entries 140 * @min_uV* - minimum voltage (micro Volts) 141 * @max_uV* - maximum voltage (micro Volts) 142 * @min_uA* - minimum amperage (micro Amps) 143 * @max_uA* - maximum amperage (micro Amps) 144 * @always_on* - bool type, true or false 145 * @boot_on* - bool type, true or false 146 * @name** - fdt regulator name - should be taken from the device tree 147 * 148 * Note: 149 * * - set automatically on device probe by the uclass's '.pre_probe' method. 150 * ** - set automatically on device bind by the uclass's '.post_bind' method. 151 * The constraints: type, mode, mode_count, can be set by device driver, e.g. 152 * by the driver '.probe' method. 153 */ 154 struct dm_regulator_uclass_platdata { 155 enum regulator_type type; 156 struct dm_regulator_mode *mode; 157 int mode_count; 158 int min_uV; 159 int max_uV; 160 int min_uA; 161 int max_uA; 162 bool always_on; 163 bool boot_on; 164 const char *name; 165 }; 166 167 /* Regulator device operations */ 168 struct dm_regulator_ops { 169 /** 170 * The regulator output value function calls operates on a micro Volts. 171 * 172 * get/set_value - get/set output value of the given output number 173 * @dev - regulator device 174 * Sets: 175 * @uV - set the output value [micro Volts] 176 * @return output value [uV] on success or negative errno if fail. 177 */ 178 int (*get_value)(struct udevice *dev); 179 int (*set_value)(struct udevice *dev, int uV); 180 181 /** 182 * The regulator output current function calls operates on a micro Amps. 183 * 184 * get/set_current - get/set output current of the given output number 185 * @dev - regulator device 186 * Sets: 187 * @uA - set the output current [micro Amps] 188 * @return output value [uA] on success or negative errno if fail. 189 */ 190 int (*get_current)(struct udevice *dev); 191 int (*set_current)(struct udevice *dev, int uA); 192 193 /** 194 * The most basic feature of the regulator output is its enable state. 195 * 196 * get/set_enable - get/set enable state of the given output number 197 * @dev - regulator device 198 * Sets: 199 * @enable - set true - enable or false - disable 200 * @return true/false for get; or 0 / -errno for set. 201 */ 202 bool (*get_enable)(struct udevice *dev); 203 int (*set_enable)(struct udevice *dev, bool enable); 204 205 /** 206 * The 'get/set_mode()' function calls should operate on a driver- 207 * specific mode id definitions, which should be found in: 208 * field 'id' of struct dm_regulator_mode. 209 * 210 * get/set_mode - get/set operation mode of the given output number 211 * @dev - regulator device 212 * Sets 213 * @mode_id - set output mode id (struct dm_regulator_mode->id) 214 * @return id/0 for get/set on success or negative errno if fail. 215 * Note: 216 * The field 'id' of struct type 'dm_regulator_mode', should be always 217 * a positive number, since the negative is reserved for the error. 218 */ 219 int (*get_mode)(struct udevice *dev); 220 int (*set_mode)(struct udevice *dev, int mode_id); 221 }; 222 223 /** 224 * regulator_mode: returns a pointer to the array of regulator mode info 225 * 226 * @dev - pointer to the regulator device 227 * @modep - pointer to the returned mode info array 228 * @return - count of modep entries on success or negative errno if fail. 229 */ 230 int regulator_mode(struct udevice *dev, struct dm_regulator_mode **modep); 231 232 /** 233 * regulator_get_value: get microvoltage voltage value of a given regulator 234 * 235 * @dev - pointer to the regulator device 236 * @return - positive output value [uV] on success or negative errno if fail. 237 */ 238 int regulator_get_value(struct udevice *dev); 239 240 /** 241 * regulator_set_value: set the microvoltage value of a given regulator. 242 * 243 * @dev - pointer to the regulator device 244 * @uV - the output value to set [micro Volts] 245 * @return - 0 on success or -errno val if fails 246 */ 247 int regulator_set_value(struct udevice *dev, int uV); 248 249 /** 250 * regulator_get_current: get microampere value of a given regulator 251 * 252 * @dev - pointer to the regulator device 253 * @return - positive output current [uA] on success or negative errno if fail. 254 */ 255 int regulator_get_current(struct udevice *dev); 256 257 /** 258 * regulator_set_current: set the microampere value of a given regulator. 259 * 260 * @dev - pointer to the regulator device 261 * @uA - set the output current [micro Amps] 262 * @return - 0 on success or -errno val if fails 263 */ 264 int regulator_set_current(struct udevice *dev, int uA); 265 266 /** 267 * regulator_get_enable: get regulator device enable state. 268 * 269 * @dev - pointer to the regulator device 270 * @return - true/false of enable state 271 */ 272 bool regulator_get_enable(struct udevice *dev); 273 274 /** 275 * regulator_set_enable: set regulator enable state 276 * 277 * @dev - pointer to the regulator device 278 * @enable - set true or false 279 * @return - 0 on success or -errno val if fails 280 */ 281 int regulator_set_enable(struct udevice *dev, bool enable); 282 283 /** 284 * regulator_get_mode: get active operation mode id of a given regulator 285 * 286 * @dev - pointer to the regulator device 287 * @return - positive mode 'id' number on success or -errno val if fails 288 * Note: 289 * The device can provide an array of operating modes, which is type of struct 290 * dm_regulator_mode. Each mode has it's own 'id', which should be unique inside 291 * that array. By calling this function, the driver should return an active mode 292 * id of the given regulator device. 293 */ 294 int regulator_get_mode(struct udevice *dev); 295 296 /** 297 * regulator_set_mode: set the given regulator's, active mode id 298 * 299 * @dev - pointer to the regulator device 300 * @mode_id - mode id to set ('id' field of struct type dm_regulator_mode) 301 * @return - 0 on success or -errno value if fails 302 * Note: 303 * The device can provide an array of operating modes, which is type of struct 304 * dm_regulator_mode. Each mode has it's own 'id', which should be unique inside 305 * that array. By calling this function, the driver should set the active mode 306 * of a given regulator to given by "mode_id" argument. 307 */ 308 int regulator_set_mode(struct udevice *dev, int mode_id); 309 310 /** 311 * regulator_autoset: setup the regulator given by its uclass's platform data 312 * name field. The setup depends on constraints found in device's uclass's 313 * platform data (struct dm_regulator_uclass_platdata): 314 * - Enable - will set - if any of: 'always_on' or 'boot_on' is set to true, 315 * or if both are unset, then the function returns 316 * - Voltage value - will set - if '.min_uV' and '.max_uV' values are equal 317 * - Current limit - will set - if '.min_uA' and '.max_uA' values are equal 318 * 319 * The function returns on first encountered error. 320 * 321 * @platname - expected string for dm_regulator_uclass_platdata .name field 322 * @devp - returned pointer to the regulator device - if non-NULL passed 323 * @verbose - (true/false) print regulator setup info, or be quiet 324 * @return: 0 on success or negative value of errno. 325 * 326 * The returned 'regulator' device can be used with: 327 * - regulator_get/set_* 328 */ 329 int regulator_autoset(const char *platname, 330 struct udevice **devp, 331 bool verbose); 332 333 /** 334 * regulator_list_autoset: setup the regulators given by list of their uclass's 335 * platform data name field. The setup depends on constraints found in device's 336 * uclass's platform data. The function loops with calls to: 337 * regulator_autoset() for each name from the list. 338 * 339 * @list_platname - an array of expected strings for .name field of each 340 * regulator's uclass platdata 341 * @list_devp - an array of returned pointers to the successfully setup 342 * regulator devices if non-NULL passed 343 * @verbose - (true/false) print each regulator setup info, or be quiet 344 * @return 0 on successfully setup of all list entries, otherwise first error. 345 * 346 * The returned 'regulator' devices can be used with: 347 * - regulator_get/set_* 348 * 349 * Note: The list must ends with NULL entry, like in the "platname" list below: 350 * char *my_regulators[] = { 351 * "VCC_3.3V", 352 * "VCC_1.8V", 353 * NULL, 354 * }; 355 */ 356 int regulator_list_autoset(const char *list_platname[], 357 struct udevice *list_devp[], 358 bool verbose); 359 360 /** 361 * regulator_get_by_devname: returns the pointer to the pmic regulator device. 362 * Search by name, found in regulator device's name. 363 * 364 * @devname - expected string for 'dev->name' of regulator device 365 * @devp - returned pointer to the regulator device 366 * @return 0 on success or negative value of errno. 367 * 368 * The returned 'regulator' device is probed and can be used with: 369 * - regulator_get/set_* 370 */ 371 int regulator_get_by_devname(const char *devname, struct udevice **devp); 372 373 /** 374 * regulator_get_by_platname: returns the pointer to the pmic regulator device. 375 * Search by name, found in regulator uclass platdata. 376 * 377 * @platname - expected string for uc_pdata->name of regulator uclass platdata 378 * @devp - returned pointer to the regulator device 379 * @return 0 on success or negative value of errno. 380 * 381 * The returned 'regulator' device is probed and can be used with: 382 * - regulator_get/set_* 383 */ 384 int regulator_get_by_platname(const char *platname, struct udevice **devp); 385 386 #endif /* _INCLUDE_REGULATOR_H_ */ 387