Merge remote-tracking branch 'regulator/topic/linear-range' into regulator-helpers

+95

drivers/regulator/core.c

··· 2084 2084 EXPORT_SYMBOL_GPL(regulator_list_voltage_linear); 2085 2085 2086 2086 /** 2087 + * regulator_list_voltage_linear_range - List voltages for linear ranges 2088 + * 2089 + * @rdev: Regulator device 2090 + * @selector: Selector to convert into a voltage 2091 + * 2092 + * Regulators with a series of simple linear mappings between voltages 2093 + * and selectors can set linear_ranges in the regulator descriptor and 2094 + * then use this function as their list_voltage() operation, 2095 + */ 2096 + int regulator_list_voltage_linear_range(struct regulator_dev *rdev, 2097 + unsigned int selector) 2098 + { 2099 + const struct regulator_linear_range *range; 2100 + int i; 2101 + 2102 + if (!rdev->desc->n_linear_ranges) { 2103 + BUG_ON(!rdev->desc->n_linear_ranges); 2104 + return -EINVAL; 2105 + } 2106 + 2107 + for (i = 0; i < rdev->desc->n_linear_ranges; i++) { 2108 + range = &rdev->desc->linear_ranges[i]; 2109 + 2110 + if (!(selector >= range->min_sel && 2111 + selector <= range->max_sel)) 2112 + continue; 2113 + 2114 + selector -= range->min_sel; 2115 + 2116 + return range->min_uV + (range->uV_step * selector); 2117 + } 2118 + 2119 + return -EINVAL; 2120 + } 2121 + EXPORT_SYMBOL_GPL(regulator_list_voltage_linear_range); 2122 + 2123 + /** 2087 2124 * regulator_list_voltage_table - List voltages with table based mapping 2088 2125 * 2089 2126 * @rdev: Regulator device ··· 2409 2372 return ret; 2410 2373 } 2411 2374 EXPORT_SYMBOL_GPL(regulator_map_voltage_linear); 2375 + 2376 + /** 2377 + * regulator_map_voltage_linear - map_voltage() for multiple linear ranges 2378 + * 2379 + * @rdev: Regulator to operate on 2380 + * @min_uV: Lower bound for voltage 2381 + * @max_uV: Upper bound for voltage 2382 + * 2383 + * Drivers providing linear_ranges in their descriptor can use this as 2384 + * their map_voltage() callback. 2385 + */ 2386 + int regulator_map_voltage_linear_range(struct regulator_dev *rdev, 2387 + int min_uV, int max_uV) 2388 + { 2389 + const struct regulator_linear_range *range; 2390 + int ret = -EINVAL; 2391 + int voltage, i; 2392 + 2393 + if (!rdev->desc->n_linear_ranges) { 2394 + BUG_ON(!rdev->desc->n_linear_ranges); 2395 + return -EINVAL; 2396 + } 2397 + 2398 + for (i = 0; i < rdev->desc->n_linear_ranges; i++) { 2399 + range = &rdev->desc->linear_ranges[i]; 2400 + 2401 + if (!(min_uV <= range->max_uV && max_uV >= range->min_uV)) 2402 + continue; 2403 + 2404 + if (min_uV <= range->min_uV) 2405 + min_uV = range->min_uV; 2406 + 2407 + /* range->uV_step == 0 means fixed voltage range */ 2408 + if (range->uV_step == 0) { 2409 + ret = 0; 2410 + } else { 2411 + ret = DIV_ROUND_UP(min_uV - range->min_uV, 2412 + range->uV_step); 2413 + if (ret < 0) 2414 + return ret; 2415 + } 2416 + 2417 + ret += range->min_sel; 2418 + 2419 + break; 2420 + } 2421 + 2422 + if (i == rdev->desc->n_linear_ranges) 2423 + return -EINVAL; 2424 + 2425 + /* Map back into a voltage to verify we're still in bounds */ 2426 + voltage = rdev->desc->ops->list_voltage(rdev, ret); 2427 + if (voltage < min_uV || voltage > max_uV) 2428 + return -EINVAL; 2429 + 2430 + return ret; 2431 + } 2432 + EXPORT_SYMBOL_GPL(regulator_map_voltage_linear_range); 2412 2433 2413 2434 static int _regulator_do_set_voltage(struct regulator_dev *rdev, 2414 2435 int min_uV, int max_uV)

+10 -35

drivers/regulator/da903x.c

··· 252 252 return ret; 253 253 } 254 254 255 - static int da9034_map_ldo12_voltage(struct regulator_dev *rdev, 256 - int min_uV, int max_uV) 257 - { 258 - struct da903x_regulator_info *info = rdev_get_drvdata(rdev); 259 - int sel; 260 - 261 - if (check_range(info, min_uV, max_uV)) { 262 - pr_err("invalid voltage range (%d, %d) uV\n", min_uV, max_uV); 263 - return -EINVAL; 264 - } 265 - 266 - sel = DIV_ROUND_UP(min_uV - info->desc.min_uV, info->desc.uV_step); 267 - sel = (sel >= 20) ? sel - 12 : ((sel > 7) ? 8 : sel); 268 - 269 - return sel; 270 - } 271 - 272 - static int da9034_list_ldo12_voltage(struct regulator_dev *rdev, 273 - unsigned selector) 274 - { 275 - struct da903x_regulator_info *info = rdev_get_drvdata(rdev); 276 - int volt; 277 - 278 - if (selector >= 8) 279 - volt = 2700000 + rdev->desc->uV_step * (selector - 8); 280 - else 281 - volt = rdev->desc->min_uV + rdev->desc->uV_step * selector; 282 - 283 - if (volt > info->max_uV) 284 - return -EINVAL; 285 - 286 - return volt; 287 - } 255 + static const struct regulator_linear_range da9034_ldo12_ranges[] = { 256 + { .min_uV = 1700000, .max_uV = 2050000, .min_sel = 0, .max_sel = 7, 257 + .uV_step = 50000 }, 258 + { .min_uV = 2700000, .max_uV = 3050000, .min_sel = 8, .max_sel = 15, 259 + .uV_step = 50000 }, 260 + }; 288 261 289 262 static struct regulator_ops da903x_regulator_ldo_ops = { 290 263 .set_voltage_sel = da903x_set_voltage_sel, ··· 305 332 static struct regulator_ops da9034_regulator_ldo12_ops = { 306 333 .set_voltage_sel = da903x_set_voltage_sel, 307 334 .get_voltage_sel = da903x_get_voltage_sel, 308 - .list_voltage = da9034_list_ldo12_voltage, 309 - .map_voltage = da9034_map_ldo12_voltage, 335 + .list_voltage = regulator_list_voltage_linear_range, 336 + .map_voltage = regulator_map_voltage_linear_range, 310 337 .enable = da903x_enable, 311 338 .disable = da903x_disable, 312 339 .is_enabled = da903x_is_enabled, ··· 449 476 if (ri->desc.id == DA9034_ID_LDO12) { 450 477 ri->desc.ops = &da9034_regulator_ldo12_ops; 451 478 ri->desc.n_voltages = 16; 479 + ri->desc.linear_ranges = da9034_ldo12_ranges; 480 + ri->desc.n_linear_ranges = ARRAY_SIZE(da9034_ldo12_ranges); 452 481 } 453 482 454 483 if (ri->desc.id == DA9030_ID_LDO14)

+24 -80

drivers/regulator/wm831x-ldo.c

··· 62 62 * General purpose LDOs 63 63 */ 64 64 65 - #define WM831X_GP_LDO_SELECTOR_LOW 0xe 66 - #define WM831X_GP_LDO_MAX_SELECTOR 0x1f 67 - 68 - static int wm831x_gp_ldo_list_voltage(struct regulator_dev *rdev, 69 - unsigned int selector) 70 - { 71 - /* 0.9-1.6V in 50mV steps */ 72 - if (selector <= WM831X_GP_LDO_SELECTOR_LOW) 73 - return 900000 + (selector * 50000); 74 - /* 1.7-3.3V in 100mV steps */ 75 - if (selector <= WM831X_GP_LDO_MAX_SELECTOR) 76 - return 1600000 + ((selector - WM831X_GP_LDO_SELECTOR_LOW) 77 - * 100000); 78 - return -EINVAL; 79 - } 80 - 81 - static int wm831x_gp_ldo_map_voltage(struct regulator_dev *rdev, 82 - int min_uV, int max_uV) 83 - { 84 - int volt, vsel; 85 - 86 - if (min_uV < 900000) 87 - vsel = 0; 88 - else if (min_uV < 1700000) 89 - vsel = ((min_uV - 900000) / 50000); 90 - else 91 - vsel = ((min_uV - 1700000) / 100000) 92 - + WM831X_GP_LDO_SELECTOR_LOW + 1; 93 - 94 - volt = wm831x_gp_ldo_list_voltage(rdev, vsel); 95 - if (volt < min_uV || volt > max_uV) 96 - return -EINVAL; 97 - 98 - return vsel; 99 - } 65 + static const struct regulator_linear_range wm831x_gp_ldo_ranges[] = { 66 + { .min_uV = 900000, .max_uV = 1650000, .min_sel = 0, .max_sel = 14, 67 + .uV_step = 50000 }, 68 + { .min_uV = 1700000, .max_uV = 3300000, .min_sel = 15, .max_sel = 31, 69 + .uV_step = 100000 }, 70 + }; 100 71 101 72 static int wm831x_gp_ldo_set_suspend_voltage(struct regulator_dev *rdev, 102 73 int uV) ··· 76 105 struct wm831x *wm831x = ldo->wm831x; 77 106 int sel, reg = ldo->base + WM831X_LDO_SLEEP_CONTROL; 78 107 79 - sel = wm831x_gp_ldo_map_voltage(rdev, uV, uV); 108 + sel = regulator_map_voltage_linear_range(rdev, uV, uV); 80 109 if (sel < 0) 81 110 return sel; 82 111 ··· 201 230 202 231 203 232 static struct regulator_ops wm831x_gp_ldo_ops = { 204 - .list_voltage = wm831x_gp_ldo_list_voltage, 205 - .map_voltage = wm831x_gp_ldo_map_voltage, 233 + .list_voltage = regulator_list_voltage_linear_range, 234 + .map_voltage = regulator_map_voltage_linear_range, 206 235 .get_voltage_sel = regulator_get_voltage_sel_regmap, 207 236 .set_voltage_sel = regulator_set_voltage_sel_regmap, 208 237 .set_suspend_voltage = wm831x_gp_ldo_set_suspend_voltage, ··· 261 290 262 291 ldo->desc.id = id; 263 292 ldo->desc.type = REGULATOR_VOLTAGE; 264 - ldo->desc.n_voltages = WM831X_GP_LDO_MAX_SELECTOR + 1; 293 + ldo->desc.n_voltages = 32; 265 294 ldo->desc.ops = &wm831x_gp_ldo_ops; 266 295 ldo->desc.owner = THIS_MODULE; 267 296 ldo->desc.vsel_reg = ldo->base + WM831X_LDO_ON_CONTROL; ··· 270 299 ldo->desc.enable_mask = 1 << id; 271 300 ldo->desc.bypass_reg = ldo->base; 272 301 ldo->desc.bypass_mask = WM831X_LDO1_SWI; 302 + ldo->desc.linear_ranges = wm831x_gp_ldo_ranges; 303 + ldo->desc.n_linear_ranges = ARRAY_SIZE(wm831x_gp_ldo_ranges); 273 304 274 305 config.dev = pdev->dev.parent; 275 306 if (pdata) ··· 331 358 * Analogue LDOs 332 359 */ 333 360 334 - 335 - #define WM831X_ALDO_SELECTOR_LOW 0xc 336 - #define WM831X_ALDO_MAX_SELECTOR 0x1f 337 - 338 - static int wm831x_aldo_list_voltage(struct regulator_dev *rdev, 339 - unsigned int selector) 340 - { 341 - /* 1-1.6V in 50mV steps */ 342 - if (selector <= WM831X_ALDO_SELECTOR_LOW) 343 - return 1000000 + (selector * 50000); 344 - /* 1.7-3.5V in 100mV steps */ 345 - if (selector <= WM831X_ALDO_MAX_SELECTOR) 346 - return 1600000 + ((selector - WM831X_ALDO_SELECTOR_LOW) 347 - * 100000); 348 - return -EINVAL; 349 - } 350 - 351 - static int wm831x_aldo_map_voltage(struct regulator_dev *rdev, 352 - int min_uV, int max_uV) 353 - { 354 - int volt, vsel; 355 - 356 - if (min_uV < 1000000) 357 - vsel = 0; 358 - else if (min_uV < 1700000) 359 - vsel = ((min_uV - 1000000) / 50000); 360 - else 361 - vsel = ((min_uV - 1700000) / 100000) 362 - + WM831X_ALDO_SELECTOR_LOW + 1; 363 - 364 - volt = wm831x_aldo_list_voltage(rdev, vsel); 365 - if (volt < min_uV || volt > max_uV) 366 - return -EINVAL; 367 - 368 - return vsel; 369 - 370 - } 361 + static const struct regulator_linear_range wm831x_aldo_ranges[] = { 362 + { .min_uV = 1000000, .max_uV = 1650000, .min_sel = 0, .max_sel = 12, 363 + .uV_step = 50000 }, 364 + { .min_uV = 1700000, .max_uV = 3500000, .min_sel = 13, .max_sel = 31, 365 + .uV_step = 100000 }, 366 + }; 371 367 372 368 static int wm831x_aldo_set_suspend_voltage(struct regulator_dev *rdev, 373 369 int uV) ··· 345 403 struct wm831x *wm831x = ldo->wm831x; 346 404 int sel, reg = ldo->base + WM831X_LDO_SLEEP_CONTROL; 347 405 348 - sel = wm831x_aldo_map_voltage(rdev, uV, uV); 406 + sel = regulator_map_voltage_linear_range(rdev, uV, uV); 349 407 if (sel < 0) 350 408 return sel; 351 409 ··· 428 486 } 429 487 430 488 static struct regulator_ops wm831x_aldo_ops = { 431 - .list_voltage = wm831x_aldo_list_voltage, 432 - .map_voltage = wm831x_aldo_map_voltage, 489 + .list_voltage = regulator_list_voltage_linear_range, 490 + .map_voltage = regulator_map_voltage_linear_range, 433 491 .get_voltage_sel = regulator_get_voltage_sel_regmap, 434 492 .set_voltage_sel = regulator_set_voltage_sel_regmap, 435 493 .set_suspend_voltage = wm831x_aldo_set_suspend_voltage, ··· 487 545 488 546 ldo->desc.id = id; 489 547 ldo->desc.type = REGULATOR_VOLTAGE; 490 - ldo->desc.n_voltages = WM831X_ALDO_MAX_SELECTOR + 1; 548 + ldo->desc.n_voltages = 32; 549 + ldo->desc.linear_ranges = wm831x_aldo_ranges; 550 + ldo->desc.n_linear_ranges = ARRAY_SIZE(wm831x_aldo_ranges); 491 551 ldo->desc.ops = &wm831x_aldo_ops; 492 552 ldo->desc.owner = THIS_MODULE; 493 553 ldo->desc.vsel_reg = ldo->base + WM831X_LDO_ON_CONTROL;

+17 -38

drivers/regulator/wm8350-regulator.c

··· 542 542 return 0; 543 543 } 544 544 545 - static int wm8350_ldo_list_voltage(struct regulator_dev *rdev, 546 - unsigned selector) 547 - { 548 - if (selector > WM8350_LDO1_VSEL_MASK) 549 - return -EINVAL; 550 - 551 - if (selector < 16) 552 - return (selector * 50000) + 900000; 553 - else 554 - return ((selector - 16) * 100000) + 1800000; 555 - } 556 - 557 - static int wm8350_ldo_map_voltage(struct regulator_dev *rdev, int min_uV, 558 - int max_uV) 559 - { 560 - int volt, sel; 561 - int min_mV = min_uV / 1000; 562 - int max_mV = max_uV / 1000; 563 - 564 - if (min_mV < 900 || min_mV > 3300) 565 - return -EINVAL; 566 - if (max_mV < 900 || max_mV > 3300) 567 - return -EINVAL; 568 - 569 - if (min_mV < 1800) /* step size is 50mV < 1800mV */ 570 - sel = DIV_ROUND_UP(min_uV - 900, 50); 571 - else /* step size is 100mV > 1800mV */ 572 - sel = DIV_ROUND_UP(min_uV - 1800, 100) + 16; 573 - 574 - volt = wm8350_ldo_list_voltage(rdev, sel); 575 - if (volt < min_uV || volt > max_uV) 576 - return -EINVAL; 577 - 578 - return sel; 579 - } 545 + static const struct regulator_linear_range wm8350_ldo_ranges[] = { 546 + { .min_uV = 900000, .max_uV = 1750000, .min_sel = 0, .max_sel = 15, 547 + .uV_step = 50000 }, 548 + { .min_uV = 1800000, .max_uV = 3300000, .min_sel = 16, .max_sel = 31, 549 + .uV_step = 100000 }, 550 + }; 580 551 581 552 static int wm8350_ldo_set_suspend_voltage(struct regulator_dev *rdev, int uV) 582 553 { ··· 574 603 return -EINVAL; 575 604 } 576 605 577 - sel = wm8350_ldo_map_voltage(rdev, uV, uV); 606 + sel = regulator_map_voltage_linear_range(rdev, uV, uV); 578 607 if (sel < 0) 579 608 return -EINVAL; 580 609 ··· 969 998 }; 970 999 971 1000 static struct regulator_ops wm8350_ldo_ops = { 972 - .map_voltage = wm8350_ldo_map_voltage, 1001 + .map_voltage = regulator_map_voltage_linear_range, 973 1002 .set_voltage_sel = regulator_set_voltage_sel_regmap, 974 1003 .get_voltage_sel = regulator_get_voltage_sel_regmap, 975 - .list_voltage = wm8350_ldo_list_voltage, 1004 + .list_voltage = regulator_list_voltage_linear_range, 976 1005 .enable = regulator_enable_regmap, 977 1006 .disable = regulator_disable_regmap, 978 1007 .is_enabled = regulator_is_enabled_regmap, ··· 1079 1108 .irq = WM8350_IRQ_UV_LDO1, 1080 1109 .type = REGULATOR_VOLTAGE, 1081 1110 .n_voltages = WM8350_LDO1_VSEL_MASK + 1, 1111 + .linear_ranges = wm8350_ldo_ranges, 1112 + .n_linear_ranges = ARRAY_SIZE(wm8350_ldo_ranges), 1082 1113 .vsel_reg = WM8350_LDO1_CONTROL, 1083 1114 .vsel_mask = WM8350_LDO1_VSEL_MASK, 1084 1115 .enable_reg = WM8350_DCDC_LDO_REQUESTED, ··· 1094 1121 .irq = WM8350_IRQ_UV_LDO2, 1095 1122 .type = REGULATOR_VOLTAGE, 1096 1123 .n_voltages = WM8350_LDO2_VSEL_MASK + 1, 1124 + .linear_ranges = wm8350_ldo_ranges, 1125 + .n_linear_ranges = ARRAY_SIZE(wm8350_ldo_ranges), 1097 1126 .vsel_reg = WM8350_LDO2_CONTROL, 1098 1127 .vsel_mask = WM8350_LDO2_VSEL_MASK, 1099 1128 .enable_reg = WM8350_DCDC_LDO_REQUESTED, ··· 1109 1134 .irq = WM8350_IRQ_UV_LDO3, 1110 1135 .type = REGULATOR_VOLTAGE, 1111 1136 .n_voltages = WM8350_LDO3_VSEL_MASK + 1, 1137 + .linear_ranges = wm8350_ldo_ranges, 1138 + .n_linear_ranges = ARRAY_SIZE(wm8350_ldo_ranges), 1112 1139 .vsel_reg = WM8350_LDO3_CONTROL, 1113 1140 .vsel_mask = WM8350_LDO3_VSEL_MASK, 1114 1141 .enable_reg = WM8350_DCDC_LDO_REQUESTED, ··· 1124 1147 .irq = WM8350_IRQ_UV_LDO4, 1125 1148 .type = REGULATOR_VOLTAGE, 1126 1149 .n_voltages = WM8350_LDO4_VSEL_MASK + 1, 1150 + .linear_ranges = wm8350_ldo_ranges, 1151 + .n_linear_ranges = ARRAY_SIZE(wm8350_ldo_ranges), 1127 1152 .vsel_reg = WM8350_LDO4_CONTROL, 1128 1153 .vsel_mask = WM8350_LDO4_VSEL_MASK, 1129 1154 .enable_reg = WM8350_DCDC_LDO_REQUESTED,

+16 -34

drivers/regulator/wm8400-regulator.c

··· 19 19 #include <linux/regulator/driver.h> 20 20 #include <linux/mfd/wm8400-private.h> 21 21 22 - static int wm8400_ldo_list_voltage(struct regulator_dev *dev, 23 - unsigned selector) 24 - { 25 - if (selector > WM8400_LDO1_VSEL_MASK) 26 - return -EINVAL; 27 - 28 - if (selector < 15) 29 - return 900000 + (selector * 50000); 30 - else 31 - return 1700000 + ((selector - 15) * 100000); 32 - } 33 - 34 - static int wm8400_ldo_map_voltage(struct regulator_dev *dev, 35 - int min_uV, int max_uV) 36 - { 37 - u16 val; 38 - int volt; 39 - 40 - if (min_uV < 900000 || min_uV > 3300000) 41 - return -EINVAL; 42 - 43 - if (min_uV < 1700000) /* Steps of 50mV from 900mV; */ 44 - val = DIV_ROUND_UP(min_uV - 900000, 50000); 45 - else /* Steps of 100mV from 1700mV */ 46 - val = DIV_ROUND_UP(min_uV - 1700000, 100000) + 15; 47 - 48 - volt = wm8400_ldo_list_voltage(dev, val); 49 - if (volt < min_uV || volt > max_uV) 50 - return -EINVAL; 51 - 52 - return val; 53 - } 22 + static const struct regulator_linear_range wm8400_ldo_ranges[] = { 23 + { .min_uV = 900000, .max_uV = 1600000, .min_sel = 0, .max_sel = 14, 24 + .uV_step = 50000 }, 25 + { .min_uV = 1700000, .max_uV = 3300000, .min_sel = 15, .max_sel = 31, 26 + .uV_step = 100000 }, 27 + }; 54 28 55 29 static struct regulator_ops wm8400_ldo_ops = { 56 30 .is_enabled = regulator_is_enabled_regmap, 57 31 .enable = regulator_enable_regmap, 58 32 .disable = regulator_disable_regmap, 59 - .list_voltage = wm8400_ldo_list_voltage, 33 + .list_voltage = regulator_list_voltage_linear_range, 60 34 .get_voltage_sel = regulator_get_voltage_sel_regmap, 61 35 .set_voltage_sel = regulator_set_voltage_sel_regmap, 62 - .map_voltage = wm8400_ldo_map_voltage, 36 + .map_voltage = regulator_map_voltage_linear_range, 63 37 }; 64 38 65 39 static unsigned int wm8400_dcdc_get_mode(struct regulator_dev *dev) ··· 129 155 .enable_reg = WM8400_LDO1_CONTROL, 130 156 .enable_mask = WM8400_LDO1_ENA, 131 157 .n_voltages = WM8400_LDO1_VSEL_MASK + 1, 158 + .linear_ranges = wm8400_ldo_ranges, 159 + .n_linear_ranges = ARRAY_SIZE(wm8400_ldo_ranges), 132 160 .vsel_reg = WM8400_LDO1_CONTROL, 133 161 .vsel_mask = WM8400_LDO1_VSEL_MASK, 134 162 .type = REGULATOR_VOLTAGE, ··· 143 167 .enable_reg = WM8400_LDO2_CONTROL, 144 168 .enable_mask = WM8400_LDO2_ENA, 145 169 .n_voltages = WM8400_LDO2_VSEL_MASK + 1, 170 + .linear_ranges = wm8400_ldo_ranges, 171 + .n_linear_ranges = ARRAY_SIZE(wm8400_ldo_ranges), 146 172 .type = REGULATOR_VOLTAGE, 147 173 .vsel_reg = WM8400_LDO2_CONTROL, 148 174 .vsel_mask = WM8400_LDO2_VSEL_MASK, ··· 157 179 .enable_reg = WM8400_LDO3_CONTROL, 158 180 .enable_mask = WM8400_LDO3_ENA, 159 181 .n_voltages = WM8400_LDO3_VSEL_MASK + 1, 182 + .linear_ranges = wm8400_ldo_ranges, 183 + .n_linear_ranges = ARRAY_SIZE(wm8400_ldo_ranges), 160 184 .vsel_reg = WM8400_LDO3_CONTROL, 161 185 .vsel_mask = WM8400_LDO3_VSEL_MASK, 162 186 .type = REGULATOR_VOLTAGE, ··· 171 191 .enable_reg = WM8400_LDO4_CONTROL, 172 192 .enable_mask = WM8400_LDO4_ENA, 173 193 .n_voltages = WM8400_LDO4_VSEL_MASK + 1, 194 + .linear_ranges = wm8400_ldo_ranges, 195 + .n_linear_ranges = ARRAY_SIZE(wm8400_ldo_ranges), 174 196 .vsel_reg = WM8400_LDO4_CONTROL, 175 197 .vsel_mask = WM8400_LDO4_VSEL_MASK, 176 198 .type = REGULATOR_VOLTAGE,

+25

include/linux/regulator/driver.h

··· 40 40 }; 41 41 42 42 /** 43 + * Specify a range of voltages for regulator_map_linar_range() and 44 + * regulator_list_linear_range(). 45 + * 46 + * @min_uV: Lowest voltage in range 47 + * @max_uV: Highest voltage in range 48 + * @min_sel: Lowest selector for range 49 + * @max_sel: Highest selector for range 50 + * @uV_step: Step size 51 + */ 52 + struct regulator_linear_range { 53 + unsigned int min_uV; 54 + unsigned int max_uV; 55 + unsigned int min_sel; 56 + unsigned int max_sel; 57 + unsigned int uV_step; 58 + }; 59 + 60 + /** 43 61 * struct regulator_ops - regulator operations. 44 62 * 45 63 * @enable: Configure the regulator as enabled. ··· 241 223 unsigned int linear_min_sel; 242 224 unsigned int ramp_delay; 243 225 226 + const struct regulator_linear_range *linear_ranges; 227 + int n_linear_ranges; 228 + 244 229 const unsigned int *volt_table; 245 230 246 231 unsigned int vsel_reg; ··· 347 326 348 327 int regulator_list_voltage_linear(struct regulator_dev *rdev, 349 328 unsigned int selector); 329 + int regulator_list_voltage_linear_range(struct regulator_dev *rdev, 330 + unsigned int selector); 350 331 int regulator_list_voltage_table(struct regulator_dev *rdev, 351 332 unsigned int selector); 352 333 int regulator_map_voltage_linear(struct regulator_dev *rdev, 353 334 int min_uV, int max_uV); 335 + int regulator_map_voltage_linear_range(struct regulator_dev *rdev, 336 + int min_uV, int max_uV); 354 337 int regulator_map_voltage_iterate(struct regulator_dev *rdev, 355 338 int min_uV, int max_uV); 356 339 int regulator_map_voltage_ascend(struct regulator_dev *rdev,