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 #include <common.h> 9 #include <errno.h> 10 #include <dm.h> 11 #include <dm/uclass-internal.h> 12 #include <power/pmic.h> 13 #include <power/regulator.h> 14 15 DECLARE_GLOBAL_DATA_PTR; 16 17 int regulator_mode(struct udevice *dev, struct dm_regulator_mode **modep) 18 { 19 struct dm_regulator_uclass_platdata *uc_pdata; 20 21 *modep = NULL; 22 23 uc_pdata = dev_get_uclass_platdata(dev); 24 if (!uc_pdata) 25 return -ENXIO; 26 27 *modep = uc_pdata->mode; 28 return uc_pdata->mode_count; 29 } 30 31 int regulator_get_value(struct udevice *dev) 32 { 33 const struct dm_regulator_ops *ops = dev_get_driver_ops(dev); 34 35 if (!ops || !ops->get_value) 36 return -ENOSYS; 37 38 return ops->get_value(dev); 39 } 40 41 int regulator_set_value(struct udevice *dev, int uV) 42 { 43 const struct dm_regulator_ops *ops = dev_get_driver_ops(dev); 44 struct dm_regulator_uclass_platdata *uc_pdata; 45 46 uc_pdata = dev_get_uclass_platdata(dev); 47 if (uc_pdata->min_uV != -ENODATA && uV < uc_pdata->min_uV) 48 return -EINVAL; 49 if (uc_pdata->max_uV != -ENODATA && uV > uc_pdata->max_uV) 50 return -EINVAL; 51 52 if (!ops || !ops->set_value) 53 return -ENOSYS; 54 55 return ops->set_value(dev, uV); 56 } 57 58 int regulator_set_suspend_value(struct udevice *dev, int uV) 59 { 60 const struct dm_regulator_ops *ops = dev_get_driver_ops(dev); 61 struct dm_regulator_uclass_platdata *uc_pdata; 62 63 uc_pdata = dev_get_uclass_platdata(dev); 64 if (uc_pdata->min_uV != -ENODATA && uV < uc_pdata->min_uV) 65 return -EINVAL; 66 if (uc_pdata->max_uV != -ENODATA && uV > uc_pdata->max_uV) 67 return -EINVAL; 68 69 if (!ops || !ops->set_suspend_value) 70 return -ENOSYS; 71 72 return ops->set_suspend_value(dev, uV); 73 } 74 75 /* 76 * To be called with at most caution as there is no check 77 * before setting the actual voltage value. 78 */ 79 int regulator_set_value_force(struct udevice *dev, int uV) 80 { 81 const struct dm_regulator_ops *ops = dev_get_driver_ops(dev); 82 83 if (!ops || !ops->set_value) 84 return -ENOSYS; 85 86 return ops->set_value(dev, uV); 87 } 88 89 int regulator_get_current(struct udevice *dev) 90 { 91 const struct dm_regulator_ops *ops = dev_get_driver_ops(dev); 92 93 if (!ops || !ops->get_current) 94 return -ENOSYS; 95 96 return ops->get_current(dev); 97 } 98 99 int regulator_set_current(struct udevice *dev, int uA) 100 { 101 const struct dm_regulator_ops *ops = dev_get_driver_ops(dev); 102 struct dm_regulator_uclass_platdata *uc_pdata; 103 104 uc_pdata = dev_get_uclass_platdata(dev); 105 if (uc_pdata->min_uA != -ENODATA && uA < uc_pdata->min_uA) 106 return -EINVAL; 107 if (uc_pdata->max_uA != -ENODATA && uA > uc_pdata->max_uA) 108 return -EINVAL; 109 110 if (!ops || !ops->set_current) 111 return -ENOSYS; 112 113 return ops->set_current(dev, uA); 114 } 115 116 int regulator_get_enable(struct udevice *dev) 117 { 118 const struct dm_regulator_ops *ops = dev_get_driver_ops(dev); 119 120 if (!ops || !ops->get_enable) 121 return -ENOSYS; 122 123 return ops->get_enable(dev); 124 } 125 126 int regulator_set_enable(struct udevice *dev, bool enable) 127 { 128 const struct dm_regulator_ops *ops = dev_get_driver_ops(dev); 129 130 if (!ops || !ops->set_enable) 131 return -ENOSYS; 132 133 return ops->set_enable(dev, enable); 134 } 135 136 int regulator_set_suspend_enable(struct udevice *dev, bool enable) 137 { 138 const struct dm_regulator_ops *ops = dev_get_driver_ops(dev); 139 140 if (!ops || !ops->set_suspend_enable) 141 return -ENOSYS; 142 143 return ops->set_suspend_enable(dev, enable); 144 } 145 146 int regulator_get_mode(struct udevice *dev) 147 { 148 const struct dm_regulator_ops *ops = dev_get_driver_ops(dev); 149 150 if (!ops || !ops->get_mode) 151 return -ENOSYS; 152 153 return ops->get_mode(dev); 154 } 155 156 int regulator_set_mode(struct udevice *dev, int mode) 157 { 158 const struct dm_regulator_ops *ops = dev_get_driver_ops(dev); 159 160 if (!ops || !ops->set_mode) 161 return -ENOSYS; 162 163 return ops->set_mode(dev, mode); 164 } 165 166 int regulator_get_by_platname(const char *plat_name, struct udevice **devp) 167 { 168 struct dm_regulator_uclass_platdata *uc_pdata; 169 struct udevice *dev; 170 int ret; 171 172 *devp = NULL; 173 174 for (ret = uclass_find_first_device(UCLASS_REGULATOR, &dev); dev; 175 ret = uclass_find_next_device(&dev)) { 176 if (ret) { 177 debug("regulator %s, ret=%d\n", dev->name, ret); 178 continue; 179 } 180 181 uc_pdata = dev_get_uclass_platdata(dev); 182 if (!uc_pdata || strcmp(plat_name, uc_pdata->name)) 183 continue; 184 185 return uclass_get_device_tail(dev, 0, devp); 186 } 187 188 debug("%s: can't find: %s, ret=%d\n", __func__, plat_name, ret); 189 190 return -ENODEV; 191 } 192 193 int regulator_get_by_devname(const char *devname, struct udevice **devp) 194 { 195 return uclass_get_device_by_name(UCLASS_REGULATOR, devname, devp); 196 } 197 198 int device_get_supply_regulator(struct udevice *dev, const char *supply_name, 199 struct udevice **devp) 200 { 201 return uclass_get_device_by_phandle(UCLASS_REGULATOR, dev, 202 supply_name, devp); 203 } 204 205 int regulator_autoset(struct udevice *dev) 206 { 207 struct dm_regulator_uclass_platdata *uc_pdata; 208 int ret = 0; 209 210 uc_pdata = dev_get_uclass_platdata(dev); 211 212 ret = regulator_set_suspend_enable(dev, uc_pdata->suspend_on); 213 if (!ret && uc_pdata->suspend_on) 214 ret = regulator_set_suspend_value(dev, uc_pdata->suspend_uV); 215 216 if (!uc_pdata->always_on && !uc_pdata->boot_on) 217 return -EMEDIUMTYPE; 218 219 if (uc_pdata->flags & REGULATOR_FLAG_AUTOSET_UV) 220 ret = regulator_set_value(dev, uc_pdata->min_uV); 221 if (!ret && (uc_pdata->flags & REGULATOR_FLAG_AUTOSET_UA)) 222 ret = regulator_set_current(dev, uc_pdata->min_uA); 223 224 if (!ret) 225 ret = regulator_set_enable(dev, true); 226 227 return ret; 228 } 229 230 static void regulator_show(struct udevice *dev, int ret) 231 { 232 struct dm_regulator_uclass_platdata *uc_pdata; 233 234 uc_pdata = dev_get_uclass_platdata(dev); 235 236 printf("%s@%s: ", dev->name, uc_pdata->name); 237 if (uc_pdata->flags & REGULATOR_FLAG_AUTOSET_UV) 238 printf("set %d uV", uc_pdata->min_uV); 239 if (uc_pdata->flags & REGULATOR_FLAG_AUTOSET_UA) 240 printf("; set %d uA", uc_pdata->min_uA); 241 printf("; enabling"); 242 if (ret) 243 printf(" (ret: %d)", ret); 244 printf("\n"); 245 } 246 247 int regulator_autoset_by_name(const char *platname, struct udevice **devp) 248 { 249 struct udevice *dev; 250 int ret; 251 252 ret = regulator_get_by_platname(platname, &dev); 253 if (devp) 254 *devp = dev; 255 if (ret) { 256 debug("Can get the regulator: %s (err=%d)\n", platname, ret); 257 return ret; 258 } 259 260 return regulator_autoset(dev); 261 } 262 263 int regulator_list_autoset(const char *list_platname[], 264 struct udevice *list_devp[], 265 bool verbose) 266 { 267 struct udevice *dev; 268 int error = 0, i = 0, ret; 269 270 while (list_platname[i]) { 271 ret = regulator_autoset_by_name(list_platname[i], &dev); 272 if (ret != -EMEDIUMTYPE && verbose) 273 regulator_show(dev, ret); 274 if (ret & !error) 275 error = ret; 276 277 if (list_devp) 278 list_devp[i] = dev; 279 280 i++; 281 } 282 283 return error; 284 } 285 286 static bool regulator_name_is_unique(struct udevice *check_dev, 287 const char *check_name) 288 { 289 struct dm_regulator_uclass_platdata *uc_pdata; 290 struct udevice *dev; 291 int check_len = strlen(check_name); 292 int ret; 293 int len; 294 295 for (ret = uclass_find_first_device(UCLASS_REGULATOR, &dev); dev; 296 ret = uclass_find_next_device(&dev)) { 297 if (ret || dev == check_dev) 298 continue; 299 300 uc_pdata = dev_get_uclass_platdata(dev); 301 len = strlen(uc_pdata->name); 302 if (len != check_len) 303 continue; 304 305 if (!strcmp(uc_pdata->name, check_name)) 306 return false; 307 } 308 309 return true; 310 } 311 312 static int regulator_post_bind(struct udevice *dev) 313 { 314 struct dm_regulator_uclass_platdata *uc_pdata; 315 const char *property = "regulator-name"; 316 317 uc_pdata = dev_get_uclass_platdata(dev); 318 319 /* Regulator's mandatory constraint */ 320 uc_pdata->name = dev_read_string(dev, property); 321 if (!uc_pdata->name) { 322 debug("%s: dev '%s' has no property '%s'\n", 323 __func__, dev->name, property); 324 uc_pdata->name = dev_read_name(dev); 325 if (!uc_pdata->name) 326 return -EINVAL; 327 } 328 329 if (regulator_name_is_unique(dev, uc_pdata->name)) 330 return 0; 331 332 debug("'%s' of dev: '%s', has nonunique value: '%s\n", 333 property, dev->name, uc_pdata->name); 334 335 return -EINVAL; 336 } 337 338 static int regulator_pre_probe(struct udevice *dev) 339 { 340 struct dm_regulator_uclass_platdata *uc_pdata; 341 ofnode node; 342 343 uc_pdata = dev_get_uclass_platdata(dev); 344 if (!uc_pdata) 345 return -ENXIO; 346 347 /* Regulator's optional constraints */ 348 uc_pdata->min_uV = dev_read_u32_default(dev, "regulator-min-microvolt", 349 -ENODATA); 350 uc_pdata->max_uV = dev_read_u32_default(dev, "regulator-max-microvolt", 351 -ENODATA); 352 uc_pdata->min_uA = dev_read_u32_default(dev, "regulator-min-microamp", 353 -ENODATA); 354 uc_pdata->max_uA = dev_read_u32_default(dev, "regulator-max-microamp", 355 -ENODATA); 356 uc_pdata->always_on = dev_read_bool(dev, "regulator-always-on"); 357 uc_pdata->boot_on = dev_read_bool(dev, "regulator-boot-on"); 358 359 node = dev_read_subnode(dev, "regulator-state-mem"); 360 if (ofnode_valid(node)) { 361 uc_pdata->suspend_on = !ofnode_read_bool(node, "regulator-off-in-suspend"); 362 if (ofnode_read_u32(node, "regulator-suspend-microvolt", &uc_pdata->suspend_uV)) 363 uc_pdata->suspend_uV = uc_pdata->max_uA; 364 } else { 365 uc_pdata->suspend_on = true; 366 uc_pdata->suspend_uV = uc_pdata->max_uA; 367 } 368 369 /* Those values are optional (-ENODATA if unset) */ 370 if ((uc_pdata->min_uV != -ENODATA) && 371 (uc_pdata->max_uV != -ENODATA) && 372 (uc_pdata->min_uV == uc_pdata->max_uV)) 373 uc_pdata->flags |= REGULATOR_FLAG_AUTOSET_UV; 374 375 /* Those values are optional (-ENODATA if unset) */ 376 if ((uc_pdata->min_uA != -ENODATA) && 377 (uc_pdata->max_uA != -ENODATA) && 378 (uc_pdata->min_uA == uc_pdata->max_uA)) 379 uc_pdata->flags |= REGULATOR_FLAG_AUTOSET_UA; 380 381 return 0; 382 } 383 384 int regulators_enable_boot_on(bool verbose) 385 { 386 struct udevice *dev; 387 struct uclass *uc; 388 int ret; 389 390 ret = uclass_get(UCLASS_REGULATOR, &uc); 391 if (ret) 392 return ret; 393 for (uclass_first_device(UCLASS_REGULATOR, &dev); 394 dev; 395 uclass_next_device(&dev)) { 396 ret = regulator_autoset(dev); 397 if (ret == -EMEDIUMTYPE) { 398 ret = 0; 399 continue; 400 } 401 if (verbose) 402 regulator_show(dev, ret); 403 if (ret == -ENOSYS) 404 ret = 0; 405 } 406 407 return ret; 408 } 409 410 UCLASS_DRIVER(regulator) = { 411 .id = UCLASS_REGULATOR, 412 .name = "regulator", 413 .post_bind = regulator_post_bind, 414 .pre_probe = regulator_pre_probe, 415 .per_device_platdata_auto_alloc_size = 416 sizeof(struct dm_regulator_uclass_platdata), 417 }; 418