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 * If regulator-name property is not provided, node name will be chosen. 50 * 51 * Regulator bind: 52 * For each regulator device, the device_bind() should be called with passed 53 * device tree offset. This is required for this uclass's '.post_bind' method, 54 * which does the scan on the device node, for the 'regulator-name' constraint. 55 * If the parent is not a PMIC device, and the child is not bind by function: 56 * 'pmic_bind_childs()', then it's recommended to bind the device by call to 57 * dm_scan_fdt_dev() - this is usually done automatically for bus devices, 58 * as a post bind method. 59 * 60 * Regulator get: 61 * Having the device's name constraint, we can call regulator_by_platname(), 62 * to find the required regulator. Before return, the regulator is probed, 63 * and the rest of its constraints are put into the device's uclass platform 64 * data, by the uclass regulator '.pre_probe' method. 65 * 66 * For more info about PMIC bind, please refer to file: 'include/power/pmic.h' 67 * 68 * Note: 69 * Please do not use the device_bind_by_name() function, since it pass '-1' as 70 * device node offset - and the bind will fail on uclass .post_bind method, 71 * because of missing 'regulator-name' constraint. 72 * 73 * 74 * Fixed Voltage/Current Regulator 75 * =============================== 76 * 77 * When fixed voltage regulator is needed, then enable the config: 78 * - CONFIG_DM_REGULATOR_FIXED 79 * 80 * The driver file: 'drivers/power/regulator/fixed.c', provides basic support 81 * for control the GPIO, and return the device tree constraint values. 82 * 83 * To bind the fixed voltage regulator device, we usually use a 'simple-bus' 84 * node as a parent. And 'regulator-fixed' for the driver compatible. This is 85 * the same as in the kernel. The example node of fixed regulator: 86 * 87 * simple-bus { 88 * compatible = "simple-bus"; 89 * #address-cells = <1>; 90 * #size-cells = <0>; 91 * 92 * blue_led { 93 * compatible = "regulator-fixed"; 94 * regulator-name = "VDD_LED_3.3V"; 95 * regulator-min-microvolt = <3300000>; 96 * regulator-max-microvolt = <3300000>; 97 * gpio = <&gpc1 0 GPIO_ACTIVE_LOW>; 98 * }; 99 * }; 100 * 101 * The fixed regulator devices also provide regulator uclass platform data. And 102 * devices bound from such node, can use the regulator drivers API. 103 */ 104 105 /* enum regulator_type - used for regulator_*() variant calls */ 106 enum regulator_type { 107 REGULATOR_TYPE_LDO = 0, 108 REGULATOR_TYPE_BUCK, 109 REGULATOR_TYPE_DVS, 110 REGULATOR_TYPE_FIXED, 111 REGULATOR_TYPE_GPIO, 112 REGULATOR_TYPE_OTHER, 113 }; 114 115 /** 116 * struct dm_regulator_mode - this structure holds an information about 117 * each regulator operation mode. Probably in most cases - an array. 118 * This will be probably a driver-static data, since it is device-specific. 119 * 120 * @id - a driver-specific mode id 121 * @register_value - a driver-specific value for its mode id 122 * @name - the name of mode - used for regulator command 123 * Note: 124 * The field 'id', should be always a positive number, since the negative values 125 * are reserved for the errno numbers when returns the mode id. 126 */ 127 struct dm_regulator_mode { 128 int id; /* Set only as >= 0 (negative value is reserved for errno) */ 129 int register_value; 130 const char *name; 131 }; 132 133 enum regulator_flag { 134 REGULATOR_FLAG_AUTOSET_UV = 1 << 0, 135 REGULATOR_FLAG_AUTOSET_UA = 1 << 1, 136 }; 137 138 /** 139 * struct dm_regulator_uclass_platdata - pointed by dev->uclass_platdata, and 140 * allocated on each regulator bind. This structure holds an information 141 * about each regulator's constraints and supported operation modes. 142 * There is no "step" voltage value - so driver should take care of this. 143 * 144 * @type - one of 'enum regulator_type' 145 * @mode - pointer to the regulator mode (array if more than one) 146 * @mode_count - number of '.mode' entries 147 * @min_uV* - minimum voltage (micro Volts) 148 * @max_uV* - maximum voltage (micro Volts) 149 * @min_uA* - minimum amperage (micro Amps) 150 * @max_uA* - maximum amperage (micro Amps) 151 * @always_on* - bool type, true or false 152 * @boot_on* - bool type, true or false 153 * TODO(sjg@chromium.org): Consider putting the above two into @flags 154 * @flags: - flags value (see REGULATOR_FLAG_...) 155 * @name** - fdt regulator name - should be taken from the device tree 156 * ctrl_reg: - Control register offset used to enable/disable regulator 157 * volt_reg: - register offset for writing voltage vsel values 158 * 159 * Note: 160 * * - set automatically on device probe by the uclass's '.pre_probe' method. 161 * ** - set automatically on device bind by the uclass's '.post_bind' method. 162 * The constraints: type, mode, mode_count, can be set by device driver, e.g. 163 * by the driver '.probe' method. 164 */ 165 struct dm_regulator_uclass_platdata { 166 enum regulator_type type; 167 struct dm_regulator_mode *mode; 168 int mode_count; 169 int min_uV; 170 int max_uV; 171 int init_uV; 172 int min_uA; 173 int max_uA; 174 bool always_on; 175 bool boot_on; 176 const char *name; 177 int flags; 178 u8 ctrl_reg; 179 u8 volt_reg; 180 bool suspend_on; 181 bool ignore; 182 u32 suspend_uV; 183 u32 ramp_delay; 184 }; 185 186 /* Regulator device operations */ 187 struct dm_regulator_ops { 188 /** 189 * The regulator output value function calls operates on a micro Volts. 190 * 191 * get/set_value - get/set output value of the given output number 192 * @dev - regulator device 193 * Sets: 194 * @uV - set the output value [micro Volts] 195 * @return output value [uV] on success or negative errno if fail. 196 */ 197 int (*get_value)(struct udevice *dev); 198 int (*set_value)(struct udevice *dev, int uV); 199 int (*set_suspend_value)(struct udevice *dev, int uV); 200 int (*get_suspend_value)(struct udevice *dev); 201 202 /** 203 * The regulator output current function calls operates on a micro Amps. 204 * 205 * get/set_current - get/set output current of the given output number 206 * @dev - regulator device 207 * Sets: 208 * @uA - set the output current [micro Amps] 209 * @return output value [uA] on success or negative errno if fail. 210 */ 211 int (*get_current)(struct udevice *dev); 212 int (*set_current)(struct udevice *dev, int uA); 213 214 /** 215 * The most basic feature of the regulator output is its enable state. 216 * 217 * get/set_enable - get/set enable state of the given output number 218 * @dev - regulator device 219 * Sets: 220 * @enable - set true - enable or false - disable 221 * @return true/false for get or -errno if fail; 0 / -errno for set. 222 */ 223 int (*get_enable)(struct udevice *dev); 224 int (*set_enable)(struct udevice *dev, bool enable); 225 int (*set_suspend_enable)(struct udevice *dev, bool enable); 226 int (*get_suspend_enable)(struct udevice *dev); 227 228 /** 229 * The 'get/set_mode()' function calls should operate on a driver- 230 * specific mode id definitions, which should be found in: 231 * field 'id' of struct dm_regulator_mode. 232 * 233 * get/set_mode - get/set operation mode of the given output number 234 * @dev - regulator device 235 * Sets 236 * @mode_id - set output mode id (struct dm_regulator_mode->id) 237 * @return id/0 for get/set on success or negative errno if fail. 238 * Note: 239 * The field 'id' of struct type 'dm_regulator_mode', should be always 240 * a positive number, since the negative is reserved for the error. 241 */ 242 int (*get_mode)(struct udevice *dev); 243 int (*set_mode)(struct udevice *dev, int mode_id); 244 245 /** 246 * The regulator voltage set ramp delay 247 * 248 * @dev - regulator device 249 * @ramp_delay - ramp delay [uV/uS] 250 * @return zero on success and other failed. 251 */ 252 int (*set_ramp_delay)(struct udevice *dev, u32 ramp_delay); 253 }; 254 255 /** 256 * regulator_mode: returns a pointer to the array of regulator mode info 257 * 258 * @dev - pointer to the regulator device 259 * @modep - pointer to the returned mode info array 260 * @return - count of modep entries on success or negative errno if fail. 261 */ 262 int regulator_mode(struct udevice *dev, struct dm_regulator_mode **modep); 263 264 /** 265 * regulator_get_value: get microvoltage voltage value of a given regulator 266 * 267 * @dev - pointer to the regulator device 268 * @return - positive output value [uV] on success or negative errno if fail. 269 */ 270 int regulator_get_value(struct udevice *dev); 271 272 /** 273 * regulator_set_value: set the microvoltage value of a given regulator. 274 * 275 * @dev - pointer to the regulator device 276 * @uV - the output value to set [micro Volts] 277 * @return - 0 on success or -errno val if fails 278 */ 279 int regulator_set_value(struct udevice *dev, int uV); 280 281 /** 282 * regulator_set_suspend_value: set the suspend microvoltage value of a given regulator. 283 * 284 * @dev - pointer to the regulator device 285 * @uV - the output suspend value to set [micro Volts] 286 * @return - 0 on success or -errno val if fails 287 */ 288 int regulator_set_suspend_value(struct udevice *dev, int uV); 289 290 /** 291 * regulator_get_suspend_value: get the suspend microvoltage value of a given regulator. 292 * 293 * @dev - pointer to the regulator device 294 * @return - positive output value [uV] on success or negative errno if fail. 295 */ 296 int regulator_get_suspend_value(struct udevice *dev); 297 298 /** 299 * regulator_set_value_force: set the microvoltage value of a given regulator 300 * without any min-,max condition check 301 * 302 * @dev - pointer to the regulator device 303 * @uV - the output value to set [micro Volts] 304 * @return - 0 on success or -errno val if fails 305 */ 306 int regulator_set_value_force(struct udevice *dev, int uV); 307 308 /** 309 * regulator_get_current: get microampere value of a given regulator 310 * 311 * @dev - pointer to the regulator device 312 * @return - positive output current [uA] on success or negative errno if fail. 313 */ 314 int regulator_get_current(struct udevice *dev); 315 316 /** 317 * regulator_set_current: set the microampere value of a given regulator. 318 * 319 * @dev - pointer to the regulator device 320 * @uA - set the output current [micro Amps] 321 * @return - 0 on success or -errno val if fails 322 */ 323 int regulator_set_current(struct udevice *dev, int uA); 324 325 /** 326 * regulator_get_enable: get regulator device enable state. 327 * 328 * @dev - pointer to the regulator device 329 * @return - true/false of enable state or -errno val if fails 330 */ 331 int regulator_get_enable(struct udevice *dev); 332 333 /** 334 * regulator_set_enable: set regulator enable state 335 * 336 * @dev - pointer to the regulator device 337 * @enable - set true or false 338 * @return - 0 on success or -errno val if fails 339 */ 340 int regulator_set_enable(struct udevice *dev, bool enable); 341 342 /** 343 * regulator_set_suspend_enable: set regulator suspend enable state 344 * 345 * @dev - pointer to the regulator device 346 * @enable - set true or false 347 * @return - 0 on success or -errno val if fails 348 */ 349 int regulator_set_suspend_enable(struct udevice *dev, bool enable); 350 351 /** 352 * regulator_get_suspend_enable: get regulator suspend enable state 353 * 354 * @dev - pointer to the regulator device 355 * @return - 0 on success or -errno val if fails 356 */ 357 int regulator_get_suspend_enable(struct udevice *dev); 358 359 /** 360 * regulator_get_mode: get active operation mode id of a given regulator 361 * 362 * @dev - pointer to the regulator device 363 * @return - positive mode 'id' number on success or -errno val if fails 364 * Note: 365 * The device can provide an array of operating modes, which is type of struct 366 * dm_regulator_mode. Each mode has it's own 'id', which should be unique inside 367 * that array. By calling this function, the driver should return an active mode 368 * id of the given regulator device. 369 */ 370 int regulator_get_mode(struct udevice *dev); 371 372 /** 373 * regulator_set_mode: set the given regulator's, active mode id 374 * 375 * @dev - pointer to the regulator device 376 * @mode_id - mode id to set ('id' field of struct type dm_regulator_mode) 377 * @return - 0 on success or -errno value if fails 378 * Note: 379 * The device can provide an array of operating modes, which is type of struct 380 * dm_regulator_mode. Each mode has it's own 'id', which should be unique inside 381 * that array. By calling this function, the driver should set the active mode 382 * of a given regulator to given by "mode_id" argument. 383 */ 384 int regulator_set_mode(struct udevice *dev, int mode_id); 385 386 /** 387 * regulators_enable_boot_on() - enable regulators needed for boot 388 * 389 * This enables all regulators which are marked to be on at boot time. This 390 * only works for regulators which don't have a range for voltage/current, 391 * since in that case it is not possible to know which value to use. 392 * 393 * This effectively calls regulator_autoset() for every regulator. 394 */ 395 int regulators_enable_boot_on(bool verbose); 396 397 /** 398 * regulators_enable_state_mem() - enable regulators state mem configure 399 * 400 * This sets regulator-state-mem state for all regulators ; 401 */ 402 int regulators_enable_state_mem(bool verbose); 403 404 /** 405 * regulator_autoset_by_name: setup the regulator given by its uclass's 406 * platform data name field. The setup depends on constraints found in device's 407 * uclass's platform data (struct dm_regulator_uclass_platdata): 408 * - Enable - will set - if any of: 'always_on' or 'boot_on' is set to true, 409 * or if both are unset, then the function returns 410 * - Voltage value - will set - if '.min_uV' and '.max_uV' values are equal 411 * - Current limit - will set - if '.min_uA' and '.max_uA' values are equal 412 * 413 * The function returns on first encountered error. 414 * 415 * @platname - expected string for dm_regulator_uclass_platdata .name field 416 * @devp - returned pointer to the regulator device - if non-NULL passed 417 * @return: 0 on success or negative value of errno. 418 * 419 * The returned 'regulator' device can be used with: 420 * - regulator_get/set_* 421 */ 422 int regulator_autoset_by_name(const char *platname, struct udevice **devp); 423 424 /** 425 * regulator_list_autoset: setup the regulators given by list of their uclass's 426 * platform data name field. The setup depends on constraints found in device's 427 * uclass's platform data. The function loops with calls to: 428 * regulator_autoset_by_name() for each name from the list. 429 * 430 * @list_platname - an array of expected strings for .name field of each 431 * regulator's uclass platdata 432 * @list_devp - an array of returned pointers to the successfully setup 433 * regulator devices if non-NULL passed 434 * @verbose - (true/false) print each regulator setup info, or be quiet 435 * @return 0 on successfully setup of all list entries, otherwise first error. 436 * 437 * The returned 'regulator' devices can be used with: 438 * - regulator_get/set_* 439 * 440 * Note: The list must ends with NULL entry, like in the "platname" list below: 441 * char *my_regulators[] = { 442 * "VCC_3.3V", 443 * "VCC_1.8V", 444 * NULL, 445 * }; 446 */ 447 int regulator_list_autoset(const char *list_platname[], 448 struct udevice *list_devp[], 449 bool verbose); 450 451 /** 452 * regulator_get_by_devname: returns the pointer to the pmic regulator device. 453 * Search by name, found in regulator device's name. 454 * 455 * @devname - expected string for 'dev->name' of regulator device 456 * @devp - returned pointer to the regulator device 457 * @return 0 on success or negative value of errno. 458 * 459 * The returned 'regulator' device is probed and can be used with: 460 * - regulator_get/set_* 461 */ 462 int regulator_get_by_devname(const char *devname, struct udevice **devp); 463 464 /** 465 * regulator_get_by_platname: returns the pointer to the pmic regulator device. 466 * Search by name, found in regulator uclass platdata. 467 * 468 * @platname - expected string for uc_pdata->name of regulator uclass platdata 469 * @devp - returns pointer to the regulator device or NULL on error 470 * @return 0 on success or negative value of errno. 471 * 472 * The returned 'regulator' device is probed and can be used with: 473 * - regulator_get/set_* 474 */ 475 int regulator_get_by_platname(const char *platname, struct udevice **devp); 476 477 /** 478 * device_get_supply_regulator: returns the pointer to the supply regulator. 479 * Search by phandle, found in device's node. 480 * 481 * Note: Please pay attention to proper order of device bind sequence. 482 * The regulator device searched by the phandle, must be binded before 483 * this function call. 484 * 485 * @dev - device with supply phandle 486 * @supply_name - phandle name of regulator 487 * @devp - returned pointer to the supply device 488 * @return 0 on success or negative value of errno. 489 */ 490 int device_get_supply_regulator(struct udevice *dev, const char *supply_name, 491 struct udevice **devp); 492 493 #endif /* _INCLUDE_REGULATOR_H_ */ 494