1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * OF helpers for regulator framework 4 * 5 * Copyright (C) 2011 Texas Instruments, Inc. 6 * Rajendra Nayak <rnayak@ti.com> 7 */ 8 9 #include <linux/module.h> 10 #include <linux/slab.h> 11 #include <linux/of.h> 12 #include <linux/regulator/machine.h> 13 #include <linux/regulator/driver.h> 14 #include <linux/regulator/of_regulator.h> 15 16 #include "internal.h" 17 18 static const char *const regulator_states[PM_SUSPEND_MAX + 1] = { 19 [PM_SUSPEND_STANDBY] = "regulator-state-standby", 20 [PM_SUSPEND_MEM] = "regulator-state-mem", 21 [PM_SUSPEND_MAX] = "regulator-state-disk", 22 }; 23 24 static void fill_limit(int *limit, int val) 25 { 26 if (val) 27 if (val == 1) 28 *limit = REGULATOR_NOTIF_LIMIT_ENABLE; 29 else 30 *limit = val; 31 else 32 *limit = REGULATOR_NOTIF_LIMIT_DISABLE; 33 } 34 35 static void of_get_regulator_prot_limits(struct device_node *np, 36 struct regulation_constraints *constraints) 37 { 38 u32 pval; 39 int i; 40 static const char *const props[] = { 41 "regulator-oc-%s-microamp", 42 "regulator-ov-%s-microvolt", 43 "regulator-temp-%s-kelvin", 44 "regulator-uv-%s-microvolt", 45 }; 46 struct notification_limit *limits[] = { 47 &constraints->over_curr_limits, 48 &constraints->over_voltage_limits, 49 &constraints->temp_limits, 50 &constraints->under_voltage_limits, 51 }; 52 bool set[4] = {0}; 53 54 /* Protection limits: */ 55 for (i = 0; i < ARRAY_SIZE(props); i++) { 56 char prop[255]; 57 bool found; 58 int j; 59 static const char *const lvl[] = { 60 "protection", "error", "warn" 61 }; 62 int *l[] = { 63 &limits[i]->prot, &limits[i]->err, &limits[i]->warn, 64 }; 65 66 for (j = 0; j < ARRAY_SIZE(lvl); j++) { 67 snprintf(prop, 255, props[i], lvl[j]); 68 found = !of_property_read_u32(np, prop, &pval); 69 if (found) 70 fill_limit(l[j], pval); 71 set[i] |= found; 72 } 73 } 74 constraints->over_current_detection = set[0]; 75 constraints->over_voltage_detection = set[1]; 76 constraints->over_temp_detection = set[2]; 77 constraints->under_voltage_detection = set[3]; 78 } 79 80 static int of_get_regulation_constraints(struct device *dev, 81 struct device_node *np, 82 struct regulator_init_data **init_data, 83 const struct regulator_desc *desc) 84 { 85 struct regulation_constraints *constraints = &(*init_data)->constraints; 86 struct regulator_state *suspend_state; 87 struct device_node *suspend_np; 88 unsigned int mode; 89 int ret, i, len; 90 int n_phandles; 91 u32 pval; 92 93 n_phandles = of_count_phandle_with_args(np, "regulator-coupled-with", 94 NULL); 95 n_phandles = max(n_phandles, 0); 96 97 constraints->name = of_get_property(np, "regulator-name", NULL); 98 99 if (!of_property_read_u32(np, "regulator-min-microvolt", &pval)) 100 constraints->min_uV = pval; 101 102 if (!of_property_read_u32(np, "regulator-max-microvolt", &pval)) 103 constraints->max_uV = pval; 104 105 /* Voltage change possible? */ 106 if (constraints->min_uV != constraints->max_uV) 107 constraints->valid_ops_mask |= REGULATOR_CHANGE_VOLTAGE; 108 109 /* Do we have a voltage range, if so try to apply it? */ 110 if (constraints->min_uV && constraints->max_uV) 111 constraints->apply_uV = true; 112 113 if (!of_property_read_u32(np, "regulator-microvolt-offset", &pval)) 114 constraints->uV_offset = pval; 115 if (!of_property_read_u32(np, "regulator-min-microamp", &pval)) 116 constraints->min_uA = pval; 117 if (!of_property_read_u32(np, "regulator-max-microamp", &pval)) 118 constraints->max_uA = pval; 119 120 if (!of_property_read_u32(np, "regulator-input-current-limit-microamp", 121 &pval)) 122 constraints->ilim_uA = pval; 123 124 /* Current change possible? */ 125 if (constraints->min_uA != constraints->max_uA) 126 constraints->valid_ops_mask |= REGULATOR_CHANGE_CURRENT; 127 128 constraints->boot_on = of_property_read_bool(np, "regulator-boot-on"); 129 constraints->always_on = of_property_read_bool(np, "regulator-always-on"); 130 if (!constraints->always_on) /* status change should be possible. */ 131 constraints->valid_ops_mask |= REGULATOR_CHANGE_STATUS; 132 133 constraints->pull_down = of_property_read_bool(np, "regulator-pull-down"); 134 135 if (of_property_read_bool(np, "regulator-allow-bypass")) 136 constraints->valid_ops_mask |= REGULATOR_CHANGE_BYPASS; 137 138 if (of_property_read_bool(np, "regulator-allow-set-load")) 139 constraints->valid_ops_mask |= REGULATOR_CHANGE_DRMS; 140 141 ret = of_property_read_u32(np, "regulator-ramp-delay", &pval); 142 if (!ret) { 143 if (pval) 144 constraints->ramp_delay = pval; 145 else 146 constraints->ramp_disable = true; 147 } 148 149 ret = of_property_read_u32(np, "regulator-settling-time-us", &pval); 150 if (!ret) 151 constraints->settling_time = pval; 152 153 ret = of_property_read_u32(np, "regulator-settling-time-up-us", &pval); 154 if (!ret) 155 constraints->settling_time_up = pval; 156 if (constraints->settling_time_up && constraints->settling_time) { 157 pr_warn("%pOFn: ambiguous configuration for settling time, ignoring 'regulator-settling-time-up-us'\n", 158 np); 159 constraints->settling_time_up = 0; 160 } 161 162 ret = of_property_read_u32(np, "regulator-settling-time-down-us", 163 &pval); 164 if (!ret) 165 constraints->settling_time_down = pval; 166 if (constraints->settling_time_down && constraints->settling_time) { 167 pr_warn("%pOFn: ambiguous configuration for settling time, ignoring 'regulator-settling-time-down-us'\n", 168 np); 169 constraints->settling_time_down = 0; 170 } 171 172 ret = of_property_read_u32(np, "regulator-enable-ramp-delay", &pval); 173 if (!ret) 174 constraints->enable_time = pval; 175 176 constraints->soft_start = of_property_read_bool(np, 177 "regulator-soft-start"); 178 ret = of_property_read_u32(np, "regulator-active-discharge", &pval); 179 if (!ret) { 180 constraints->active_discharge = 181 (pval) ? REGULATOR_ACTIVE_DISCHARGE_ENABLE : 182 REGULATOR_ACTIVE_DISCHARGE_DISABLE; 183 } 184 185 if (!of_property_read_u32(np, "regulator-initial-mode", &pval)) { 186 if (desc && desc->of_map_mode) { 187 mode = desc->of_map_mode(pval); 188 if (mode == REGULATOR_MODE_INVALID) 189 pr_err("%pOFn: invalid mode %u\n", np, pval); 190 else 191 constraints->initial_mode = mode; 192 } else { 193 pr_warn("%pOFn: mapping for mode %d not defined\n", 194 np, pval); 195 } 196 } 197 198 len = of_property_count_elems_of_size(np, "regulator-allowed-modes", 199 sizeof(u32)); 200 if (len > 0) { 201 if (desc && desc->of_map_mode) { 202 for (i = 0; i < len; i++) { 203 ret = of_property_read_u32_index(np, 204 "regulator-allowed-modes", i, &pval); 205 if (ret) { 206 pr_err("%pOFn: couldn't read allowed modes index %d, ret=%d\n", 207 np, i, ret); 208 break; 209 } 210 mode = desc->of_map_mode(pval); 211 if (mode == REGULATOR_MODE_INVALID) 212 pr_err("%pOFn: invalid regulator-allowed-modes element %u\n", 213 np, pval); 214 else 215 constraints->valid_modes_mask |= mode; 216 } 217 if (constraints->valid_modes_mask) 218 constraints->valid_ops_mask 219 |= REGULATOR_CHANGE_MODE; 220 } else { 221 pr_warn("%pOFn: mode mapping not defined\n", np); 222 } 223 } 224 225 if (!of_property_read_u32(np, "regulator-system-load", &pval)) 226 constraints->system_load = pval; 227 228 if (n_phandles) { 229 constraints->max_spread = devm_kzalloc(dev, 230 sizeof(*constraints->max_spread) * n_phandles, 231 GFP_KERNEL); 232 233 if (!constraints->max_spread) 234 return -ENOMEM; 235 236 of_property_read_u32_array(np, "regulator-coupled-max-spread", 237 constraints->max_spread, n_phandles); 238 } 239 240 if (!of_property_read_u32(np, "regulator-max-step-microvolt", 241 &pval)) 242 constraints->max_uV_step = pval; 243 244 constraints->over_current_protection = of_property_read_bool(np, 245 "regulator-over-current-protection"); 246 247 of_get_regulator_prot_limits(np, constraints); 248 249 for (i = 0; i < ARRAY_SIZE(regulator_states); i++) { 250 switch (i) { 251 case PM_SUSPEND_MEM: 252 suspend_state = &constraints->state_mem; 253 break; 254 case PM_SUSPEND_MAX: 255 suspend_state = &constraints->state_disk; 256 break; 257 case PM_SUSPEND_STANDBY: 258 suspend_state = &constraints->state_standby; 259 break; 260 case PM_SUSPEND_ON: 261 case PM_SUSPEND_TO_IDLE: 262 default: 263 continue; 264 } 265 266 suspend_np = of_get_child_by_name(np, regulator_states[i]); 267 if (!suspend_np) 268 continue; 269 if (!suspend_state) { 270 of_node_put(suspend_np); 271 continue; 272 } 273 274 if (!of_property_read_u32(suspend_np, "regulator-mode", 275 &pval)) { 276 if (desc && desc->of_map_mode) { 277 mode = desc->of_map_mode(pval); 278 if (mode == REGULATOR_MODE_INVALID) 279 pr_err("%pOFn: invalid mode %u\n", 280 np, pval); 281 else 282 suspend_state->mode = mode; 283 } else { 284 pr_warn("%pOFn: mapping for mode %d not defined\n", 285 np, pval); 286 } 287 } 288 289 if (of_property_read_bool(suspend_np, 290 "regulator-on-in-suspend")) 291 suspend_state->enabled = ENABLE_IN_SUSPEND; 292 else if (of_property_read_bool(suspend_np, 293 "regulator-off-in-suspend")) 294 suspend_state->enabled = DISABLE_IN_SUSPEND; 295 296 if (!of_property_read_u32(suspend_np, 297 "regulator-suspend-min-microvolt", &pval)) 298 suspend_state->min_uV = pval; 299 300 if (!of_property_read_u32(suspend_np, 301 "regulator-suspend-max-microvolt", &pval)) 302 suspend_state->max_uV = pval; 303 304 if (!of_property_read_u32(suspend_np, 305 "regulator-suspend-microvolt", &pval)) 306 suspend_state->uV = pval; 307 else /* otherwise use min_uV as default suspend voltage */ 308 suspend_state->uV = suspend_state->min_uV; 309 310 if (of_property_read_bool(suspend_np, 311 "regulator-changeable-in-suspend")) 312 suspend_state->changeable = true; 313 314 if (i == PM_SUSPEND_MEM) 315 constraints->initial_state = PM_SUSPEND_MEM; 316 317 of_node_put(suspend_np); 318 suspend_state = NULL; 319 suspend_np = NULL; 320 } 321 322 return 0; 323 } 324 325 /** 326 * of_get_regulator_init_data - extract regulator_init_data structure info 327 * @dev: device requesting for regulator_init_data 328 * @node: regulator device node 329 * @desc: regulator description 330 * 331 * Populates regulator_init_data structure by extracting data from device 332 * tree node, returns a pointer to the populated structure or NULL if memory 333 * alloc fails. 334 */ 335 struct regulator_init_data *of_get_regulator_init_data(struct device *dev, 336 struct device_node *node, 337 const struct regulator_desc *desc) 338 { 339 struct regulator_init_data *init_data; 340 341 if (!node) 342 return NULL; 343 344 init_data = devm_kzalloc(dev, sizeof(*init_data), GFP_KERNEL); 345 if (!init_data) 346 return NULL; /* Out of memory? */ 347 348 if (of_get_regulation_constraints(dev, node, &init_data, desc)) 349 return NULL; 350 351 return init_data; 352 } 353 EXPORT_SYMBOL_GPL(of_get_regulator_init_data); 354 355 struct devm_of_regulator_matches { 356 struct of_regulator_match *matches; 357 unsigned int num_matches; 358 }; 359 360 static void devm_of_regulator_put_matches(struct device *dev, void *res) 361 { 362 struct devm_of_regulator_matches *devm_matches = res; 363 int i; 364 365 for (i = 0; i < devm_matches->num_matches; i++) 366 of_node_put(devm_matches->matches[i].of_node); 367 } 368 369 /** 370 * of_regulator_match - extract multiple regulator init data from device tree. 371 * @dev: device requesting the data 372 * @node: parent device node of the regulators 373 * @matches: match table for the regulators 374 * @num_matches: number of entries in match table 375 * 376 * This function uses a match table specified by the regulator driver to 377 * parse regulator init data from the device tree. @node is expected to 378 * contain a set of child nodes, each providing the init data for one 379 * regulator. The data parsed from a child node will be matched to a regulator 380 * based on either the deprecated property regulator-compatible if present, 381 * or otherwise the child node's name. Note that the match table is modified 382 * in place and an additional of_node reference is taken for each matched 383 * regulator. 384 * 385 * Returns the number of matches found or a negative error code on failure. 386 */ 387 int of_regulator_match(struct device *dev, struct device_node *node, 388 struct of_regulator_match *matches, 389 unsigned int num_matches) 390 { 391 unsigned int count = 0; 392 unsigned int i; 393 const char *name; 394 struct device_node *child; 395 struct devm_of_regulator_matches *devm_matches; 396 397 if (!dev || !node) 398 return -EINVAL; 399 400 devm_matches = devres_alloc(devm_of_regulator_put_matches, 401 sizeof(struct devm_of_regulator_matches), 402 GFP_KERNEL); 403 if (!devm_matches) 404 return -ENOMEM; 405 406 devm_matches->matches = matches; 407 devm_matches->num_matches = num_matches; 408 409 devres_add(dev, devm_matches); 410 411 for (i = 0; i < num_matches; i++) { 412 struct of_regulator_match *match = &matches[i]; 413 match->init_data = NULL; 414 match->of_node = NULL; 415 } 416 417 for_each_child_of_node(node, child) { 418 name = of_get_property(child, 419 "regulator-compatible", NULL); 420 if (!name) 421 name = child->name; 422 for (i = 0; i < num_matches; i++) { 423 struct of_regulator_match *match = &matches[i]; 424 if (match->of_node) 425 continue; 426 427 if (strcmp(match->name, name)) 428 continue; 429 430 match->init_data = 431 of_get_regulator_init_data(dev, child, 432 match->desc); 433 if (!match->init_data) { 434 dev_err(dev, 435 "failed to parse DT for regulator %pOFn\n", 436 child); 437 of_node_put(child); 438 return -EINVAL; 439 } 440 match->of_node = of_node_get(child); 441 count++; 442 break; 443 } 444 } 445 446 return count; 447 } 448 EXPORT_SYMBOL_GPL(of_regulator_match); 449 450 static struct 451 device_node *regulator_of_get_init_node(struct device *dev, 452 const struct regulator_desc *desc) 453 { 454 struct device_node *search, *child; 455 const char *name; 456 457 if (!dev->of_node || !desc->of_match) 458 return NULL; 459 460 if (desc->regulators_node) { 461 search = of_get_child_by_name(dev->of_node, 462 desc->regulators_node); 463 } else { 464 search = of_node_get(dev->of_node); 465 466 if (!strcmp(desc->of_match, search->name)) 467 return search; 468 } 469 470 if (!search) { 471 dev_dbg(dev, "Failed to find regulator container node '%s'\n", 472 desc->regulators_node); 473 return NULL; 474 } 475 476 for_each_available_child_of_node(search, child) { 477 name = of_get_property(child, "regulator-compatible", NULL); 478 if (!name) { 479 if (!desc->of_match_full_name) 480 name = child->name; 481 else 482 name = child->full_name; 483 } 484 485 if (!strcmp(desc->of_match, name)) { 486 of_node_put(search); 487 /* 488 * 'of_node_get(child)' is already performed by the 489 * for_each loop. 490 */ 491 return child; 492 } 493 } 494 495 of_node_put(search); 496 497 return NULL; 498 } 499 500 struct regulator_init_data *regulator_of_get_init_data(struct device *dev, 501 const struct regulator_desc *desc, 502 struct regulator_config *config, 503 struct device_node **node) 504 { 505 struct device_node *child; 506 struct regulator_init_data *init_data = NULL; 507 508 child = regulator_of_get_init_node(config->dev, desc); 509 if (!child) 510 return NULL; 511 512 init_data = of_get_regulator_init_data(dev, child, desc); 513 if (!init_data) { 514 dev_err(dev, "failed to parse DT for regulator %pOFn\n", child); 515 goto error; 516 } 517 518 if (desc->of_parse_cb) { 519 int ret; 520 521 ret = desc->of_parse_cb(child, desc, config); 522 if (ret) { 523 if (ret == -EPROBE_DEFER) { 524 of_node_put(child); 525 return ERR_PTR(-EPROBE_DEFER); 526 } 527 dev_err(dev, 528 "driver callback failed to parse DT for regulator %pOFn\n", 529 child); 530 goto error; 531 } 532 } 533 534 *node = child; 535 536 return init_data; 537 538 error: 539 of_node_put(child); 540 541 return NULL; 542 } 543 544 struct regulator_dev *of_find_regulator_by_node(struct device_node *np) 545 { 546 struct device *dev; 547 548 dev = class_find_device_by_of_node(®ulator_class, np); 549 550 return dev ? dev_to_rdev(dev) : NULL; 551 } 552 553 /* 554 * Returns number of regulators coupled with rdev. 555 */ 556 int of_get_n_coupled(struct regulator_dev *rdev) 557 { 558 struct device_node *node = rdev->dev.of_node; 559 int n_phandles; 560 561 n_phandles = of_count_phandle_with_args(node, 562 "regulator-coupled-with", 563 NULL); 564 565 return (n_phandles > 0) ? n_phandles : 0; 566 } 567 568 /* Looks for "to_find" device_node in src's "regulator-coupled-with" property */ 569 static bool of_coupling_find_node(struct device_node *src, 570 struct device_node *to_find, 571 int *index) 572 { 573 int n_phandles, i; 574 bool found = false; 575 576 n_phandles = of_count_phandle_with_args(src, 577 "regulator-coupled-with", 578 NULL); 579 580 for (i = 0; i < n_phandles; i++) { 581 struct device_node *tmp = of_parse_phandle(src, 582 "regulator-coupled-with", i); 583 584 if (!tmp) 585 break; 586 587 /* found */ 588 if (tmp == to_find) 589 found = true; 590 591 of_node_put(tmp); 592 593 if (found) { 594 *index = i; 595 break; 596 } 597 } 598 599 return found; 600 } 601 602 /** 603 * of_check_coupling_data - Parse rdev's coupling properties and check data 604 * consistency 605 * @rdev: pointer to regulator_dev whose data is checked 606 * 607 * Function checks if all the following conditions are met: 608 * - rdev's max_spread is greater than 0 609 * - all coupled regulators have the same max_spread 610 * - all coupled regulators have the same number of regulator_dev phandles 611 * - all regulators are linked to each other 612 * 613 * Returns true if all conditions are met. 614 */ 615 bool of_check_coupling_data(struct regulator_dev *rdev) 616 { 617 struct device_node *node = rdev->dev.of_node; 618 int n_phandles = of_get_n_coupled(rdev); 619 struct device_node *c_node; 620 int index; 621 int i; 622 bool ret = true; 623 624 /* iterate over rdev's phandles */ 625 for (i = 0; i < n_phandles; i++) { 626 int max_spread = rdev->constraints->max_spread[i]; 627 int c_max_spread, c_n_phandles; 628 629 if (max_spread <= 0) { 630 dev_err(&rdev->dev, "max_spread value invalid\n"); 631 return false; 632 } 633 634 c_node = of_parse_phandle(node, 635 "regulator-coupled-with", i); 636 637 if (!c_node) 638 ret = false; 639 640 c_n_phandles = of_count_phandle_with_args(c_node, 641 "regulator-coupled-with", 642 NULL); 643 644 if (c_n_phandles != n_phandles) { 645 dev_err(&rdev->dev, "number of coupled reg phandles mismatch\n"); 646 ret = false; 647 goto clean; 648 } 649 650 if (!of_coupling_find_node(c_node, node, &index)) { 651 dev_err(&rdev->dev, "missing 2-way linking for coupled regulators\n"); 652 ret = false; 653 goto clean; 654 } 655 656 if (of_property_read_u32_index(c_node, "regulator-coupled-max-spread", 657 index, &c_max_spread)) { 658 ret = false; 659 goto clean; 660 } 661 662 if (c_max_spread != max_spread) { 663 dev_err(&rdev->dev, 664 "coupled regulators max_spread mismatch\n"); 665 ret = false; 666 goto clean; 667 } 668 669 clean: 670 of_node_put(c_node); 671 if (!ret) 672 break; 673 } 674 675 return ret; 676 } 677 678 /** 679 * of_parse_coupled_regulator() - Get regulator_dev pointer from rdev's property 680 * @rdev: Pointer to regulator_dev, whose DTS is used as a source to parse 681 * "regulator-coupled-with" property 682 * @index: Index in phandles array 683 * 684 * Returns the regulator_dev pointer parsed from DTS. If it has not been yet 685 * registered, returns NULL 686 */ 687 struct regulator_dev *of_parse_coupled_regulator(struct regulator_dev *rdev, 688 int index) 689 { 690 struct device_node *node = rdev->dev.of_node; 691 struct device_node *c_node; 692 struct regulator_dev *c_rdev; 693 694 c_node = of_parse_phandle(node, "regulator-coupled-with", index); 695 if (!c_node) 696 return NULL; 697 698 c_rdev = of_find_regulator_by_node(c_node); 699 700 of_node_put(c_node); 701 702 return c_rdev; 703 } 704 705 /* 706 * Check if name is a supply name according to the '*-supply' pattern 707 * return 0 if false 708 * return length of supply name without the -supply 709 */ 710 static int is_supply_name(const char *name) 711 { 712 int strs, i; 713 714 strs = strlen(name); 715 /* string need to be at minimum len(x-supply) */ 716 if (strs < 8) 717 return 0; 718 for (i = strs - 6; i > 0; i--) { 719 /* find first '-' and check if right part is supply */ 720 if (name[i] != '-') 721 continue; 722 if (strcmp(name + i + 1, "supply") != 0) 723 return 0; 724 return i; 725 } 726 return 0; 727 } 728 729 /* 730 * of_regulator_bulk_get_all - get multiple regulator consumers 731 * 732 * @dev: Device to supply 733 * @np: device node to search for consumers 734 * @consumers: Configuration of consumers; clients are stored here. 735 * 736 * @return number of regulators on success, an errno on failure. 737 * 738 * This helper function allows drivers to get several regulator 739 * consumers in one operation. If any of the regulators cannot be 740 * acquired then any regulators that were allocated will be freed 741 * before returning to the caller. 742 */ 743 int of_regulator_bulk_get_all(struct device *dev, struct device_node *np, 744 struct regulator_bulk_data **consumers) 745 { 746 int num_consumers = 0; 747 struct regulator *tmp; 748 struct property *prop; 749 int i, n = 0, ret; 750 char name[64]; 751 752 *consumers = NULL; 753 754 /* 755 * first pass: get numbers of xxx-supply 756 * second pass: fill consumers 757 */ 758 restart: 759 for_each_property_of_node(np, prop) { 760 i = is_supply_name(prop->name); 761 if (i == 0) 762 continue; 763 if (!*consumers) { 764 num_consumers++; 765 continue; 766 } else { 767 memcpy(name, prop->name, i); 768 name[i] = '\0'; 769 tmp = regulator_get(dev, name); 770 if (IS_ERR(tmp)) { 771 ret = -EINVAL; 772 goto error; 773 } 774 (*consumers)[n].consumer = tmp; 775 n++; 776 continue; 777 } 778 } 779 if (*consumers) 780 return num_consumers; 781 if (num_consumers == 0) 782 return 0; 783 *consumers = kmalloc_array(num_consumers, 784 sizeof(struct regulator_bulk_data), 785 GFP_KERNEL); 786 if (!*consumers) 787 return -ENOMEM; 788 goto restart; 789 790 error: 791 while (--n >= 0) 792 regulator_put(consumers[n]->consumer); 793 return ret; 794 } 795 EXPORT_SYMBOL_GPL(of_regulator_bulk_get_all); 796