1 /* 2 * Device driver for regulators in Hi6421 IC 3 * 4 * Copyright (c) <2011-2014> HiSilicon Technologies Co., Ltd. 5 * http://www.hisilicon.com 6 * Copyright (c) <2013-2014> Linaro Ltd. 7 * http://www.linaro.org 8 * 9 * Author: Guodong Xu <guodong.xu@linaro.org> 10 * 11 * This program is free software; you can redistribute it and/or modify 12 * it under the terms of the GNU General Public License version 2 as 13 * published by the Free Software Foundation. 14 */ 15 16 #include <linux/slab.h> 17 #include <linux/device.h> 18 #include <linux/module.h> 19 #include <linux/err.h> 20 #include <linux/platform_device.h> 21 #include <linux/of.h> 22 #include <linux/regmap.h> 23 #include <linux/regulator/driver.h> 24 #include <linux/regulator/machine.h> 25 #include <linux/regulator/of_regulator.h> 26 #include <linux/mfd/hi6421-pmic.h> 27 28 /* 29 * struct hi6421_regulator_pdata - Hi6421 regulator data of platform device 30 * @lock: mutex to serialize regulator enable 31 */ 32 struct hi6421_regulator_pdata { 33 struct mutex lock; 34 }; 35 36 /* 37 * struct hi6421_regulator_info - hi6421 regulator information 38 * @desc: regulator description 39 * @mode_mask: ECO mode bitmask of LDOs; for BUCKs, this masks sleep 40 * @eco_microamp: eco mode load upper limit (in uA), valid for LDOs only 41 */ 42 struct hi6421_regulator_info { 43 struct regulator_desc desc; 44 u8 mode_mask; 45 u32 eco_microamp; 46 }; 47 48 /* HI6421 regulators */ 49 enum hi6421_regulator_id { 50 HI6421_LDO0, 51 HI6421_LDO1, 52 HI6421_LDO2, 53 HI6421_LDO3, 54 HI6421_LDO4, 55 HI6421_LDO5, 56 HI6421_LDO6, 57 HI6421_LDO7, 58 HI6421_LDO8, 59 HI6421_LDO9, 60 HI6421_LDO10, 61 HI6421_LDO11, 62 HI6421_LDO12, 63 HI6421_LDO13, 64 HI6421_LDO14, 65 HI6421_LDO15, 66 HI6421_LDO16, 67 HI6421_LDO17, 68 HI6421_LDO18, 69 HI6421_LDO19, 70 HI6421_LDO20, 71 HI6421_LDOAUDIO, 72 HI6421_BUCK0, 73 HI6421_BUCK1, 74 HI6421_BUCK2, 75 HI6421_BUCK3, 76 HI6421_BUCK4, 77 HI6421_BUCK5, 78 HI6421_NUM_REGULATORS, 79 }; 80 81 #define HI6421_REGULATOR_OF_MATCH(_name, id) \ 82 { \ 83 .name = #_name, \ 84 .driver_data = (void *) HI6421_##id, \ 85 } 86 87 static struct of_regulator_match hi6421_regulator_match[] = { 88 HI6421_REGULATOR_OF_MATCH(hi6421_vout0, LDO0), 89 HI6421_REGULATOR_OF_MATCH(hi6421_vout1, LDO1), 90 HI6421_REGULATOR_OF_MATCH(hi6421_vout2, LDO2), 91 HI6421_REGULATOR_OF_MATCH(hi6421_vout3, LDO3), 92 HI6421_REGULATOR_OF_MATCH(hi6421_vout4, LDO4), 93 HI6421_REGULATOR_OF_MATCH(hi6421_vout5, LDO5), 94 HI6421_REGULATOR_OF_MATCH(hi6421_vout6, LDO6), 95 HI6421_REGULATOR_OF_MATCH(hi6421_vout7, LDO7), 96 HI6421_REGULATOR_OF_MATCH(hi6421_vout8, LDO8), 97 HI6421_REGULATOR_OF_MATCH(hi6421_vout9, LDO9), 98 HI6421_REGULATOR_OF_MATCH(hi6421_vout10, LDO10), 99 HI6421_REGULATOR_OF_MATCH(hi6421_vout11, LDO11), 100 HI6421_REGULATOR_OF_MATCH(hi6421_vout12, LDO12), 101 HI6421_REGULATOR_OF_MATCH(hi6421_vout13, LDO13), 102 HI6421_REGULATOR_OF_MATCH(hi6421_vout14, LDO14), 103 HI6421_REGULATOR_OF_MATCH(hi6421_vout15, LDO15), 104 HI6421_REGULATOR_OF_MATCH(hi6421_vout16, LDO16), 105 HI6421_REGULATOR_OF_MATCH(hi6421_vout17, LDO17), 106 HI6421_REGULATOR_OF_MATCH(hi6421_vout18, LDO18), 107 HI6421_REGULATOR_OF_MATCH(hi6421_vout19, LDO19), 108 HI6421_REGULATOR_OF_MATCH(hi6421_vout20, LDO20), 109 HI6421_REGULATOR_OF_MATCH(hi6421_vout_audio, LDOAUDIO), 110 HI6421_REGULATOR_OF_MATCH(hi6421_buck0, BUCK0), 111 HI6421_REGULATOR_OF_MATCH(hi6421_buck1, BUCK1), 112 HI6421_REGULATOR_OF_MATCH(hi6421_buck2, BUCK2), 113 HI6421_REGULATOR_OF_MATCH(hi6421_buck3, BUCK3), 114 HI6421_REGULATOR_OF_MATCH(hi6421_buck4, BUCK4), 115 HI6421_REGULATOR_OF_MATCH(hi6421_buck5, BUCK5), 116 }; 117 118 /* LDO 0, 4~7, 9~14, 16~20 have same voltage table. */ 119 static const unsigned int ldo_0_voltages[] = { 120 1500000, 1800000, 2400000, 2500000, 121 2600000, 2700000, 2850000, 3000000, 122 }; 123 124 /* LDO 8, 15 have same voltage table. */ 125 static const unsigned int ldo_8_voltages[] = { 126 1500000, 1800000, 2400000, 2600000, 127 2700000, 2850000, 3000000, 3300000, 128 }; 129 130 /* Ranges are sorted in ascending order. */ 131 static const struct regulator_linear_range ldo_audio_volt_range[] = { 132 REGULATOR_LINEAR_RANGE(2800000, 0, 3, 50000), 133 REGULATOR_LINEAR_RANGE(3000000, 4, 7, 100000), 134 }; 135 136 static const unsigned int buck_3_voltages[] = { 137 950000, 1050000, 1100000, 1117000, 138 1134000, 1150000, 1167000, 1200000, 139 }; 140 141 static const unsigned int buck_4_voltages[] = { 142 1150000, 1200000, 1250000, 1350000, 143 1700000, 1800000, 1900000, 2000000, 144 }; 145 146 static const unsigned int buck_5_voltages[] = { 147 1150000, 1200000, 1250000, 1350000, 148 1600000, 1700000, 1800000, 1900000, 149 }; 150 151 static const struct regulator_ops hi6421_ldo_ops; 152 static const struct regulator_ops hi6421_ldo_linear_ops; 153 static const struct regulator_ops hi6421_ldo_linear_range_ops; 154 static const struct regulator_ops hi6421_buck012_ops; 155 static const struct regulator_ops hi6421_buck345_ops; 156 157 #define HI6421_LDO_ENABLE_TIME (350) 158 /* 159 * _id - LDO id name string 160 * v_table - voltage table 161 * vreg - voltage select register 162 * vmask - voltage select mask 163 * ereg - enable register 164 * emask - enable mask 165 * odelay - off/on delay time in uS 166 * ecomask - eco mode mask 167 * ecoamp - eco mode load uppler limit in uA 168 */ 169 #define HI6421_LDO(_id, v_table, vreg, vmask, ereg, emask, \ 170 odelay, ecomask, ecoamp) \ 171 [HI6421_##_id] = { \ 172 .desc = { \ 173 .name = #_id, \ 174 .ops = &hi6421_ldo_ops, \ 175 .type = REGULATOR_VOLTAGE, \ 176 .id = HI6421_##_id, \ 177 .owner = THIS_MODULE, \ 178 .n_voltages = ARRAY_SIZE(v_table), \ 179 .volt_table = v_table, \ 180 .vsel_reg = HI6421_REG_TO_BUS_ADDR(vreg), \ 181 .vsel_mask = vmask, \ 182 .enable_reg = HI6421_REG_TO_BUS_ADDR(ereg), \ 183 .enable_mask = emask, \ 184 .enable_time = HI6421_LDO_ENABLE_TIME, \ 185 .off_on_delay = odelay, \ 186 }, \ 187 .mode_mask = ecomask, \ 188 .eco_microamp = ecoamp, \ 189 } 190 191 /* HI6421 LDO1~3 are linear voltage regulators at fixed uV_step 192 * 193 * _id - LDO id name string 194 * _min_uV - minimum voltage supported in uV 195 * n_volt - number of votages available 196 * vstep - voltage increase in each linear step in uV 197 * vreg - voltage select register 198 * vmask - voltage select mask 199 * ereg - enable register 200 * emask - enable mask 201 * odelay - off/on delay time in uS 202 * ecomask - eco mode mask 203 * ecoamp - eco mode load uppler limit in uA 204 */ 205 #define HI6421_LDO_LINEAR(_id, _min_uV, n_volt, vstep, vreg, vmask, \ 206 ereg, emask, odelay, ecomask, ecoamp) \ 207 [HI6421_##_id] = { \ 208 .desc = { \ 209 .name = #_id, \ 210 .ops = &hi6421_ldo_linear_ops, \ 211 .type = REGULATOR_VOLTAGE, \ 212 .id = HI6421_##_id, \ 213 .owner = THIS_MODULE, \ 214 .min_uV = _min_uV, \ 215 .n_voltages = n_volt, \ 216 .uV_step = vstep, \ 217 .vsel_reg = HI6421_REG_TO_BUS_ADDR(vreg), \ 218 .vsel_mask = vmask, \ 219 .enable_reg = HI6421_REG_TO_BUS_ADDR(ereg), \ 220 .enable_mask = emask, \ 221 .enable_time = HI6421_LDO_ENABLE_TIME, \ 222 .off_on_delay = odelay, \ 223 }, \ 224 .mode_mask = ecomask, \ 225 .eco_microamp = ecoamp, \ 226 } 227 228 /* HI6421 LDOAUDIO is a linear voltage regulator with two 4-step ranges 229 * 230 * _id - LDO id name string 231 * n_volt - number of votages available 232 * volt_ranges - array of regulator_linear_range 233 * vstep - voltage increase in each linear step in uV 234 * vreg - voltage select register 235 * vmask - voltage select mask 236 * ereg - enable register 237 * emask - enable mask 238 * odelay - off/on delay time in uS 239 * ecomask - eco mode mask 240 * ecoamp - eco mode load uppler limit in uA 241 */ 242 #define HI6421_LDO_LINEAR_RANGE(_id, n_volt, volt_ranges, vreg, vmask, \ 243 ereg, emask, odelay, ecomask, ecoamp) \ 244 [HI6421_##_id] = { \ 245 .desc = { \ 246 .name = #_id, \ 247 .ops = &hi6421_ldo_linear_range_ops, \ 248 .type = REGULATOR_VOLTAGE, \ 249 .id = HI6421_##_id, \ 250 .owner = THIS_MODULE, \ 251 .n_voltages = n_volt, \ 252 .linear_ranges = volt_ranges, \ 253 .n_linear_ranges = ARRAY_SIZE(volt_ranges), \ 254 .vsel_reg = HI6421_REG_TO_BUS_ADDR(vreg), \ 255 .vsel_mask = vmask, \ 256 .enable_reg = HI6421_REG_TO_BUS_ADDR(ereg), \ 257 .enable_mask = emask, \ 258 .enable_time = HI6421_LDO_ENABLE_TIME, \ 259 .off_on_delay = odelay, \ 260 }, \ 261 .mode_mask = ecomask, \ 262 .eco_microamp = ecoamp, \ 263 } 264 265 /* HI6421 BUCK0/1/2 are linear voltage regulators at fixed uV_step 266 * 267 * _id - BUCK0/1/2 id name string 268 * vreg - voltage select register 269 * vmask - voltage select mask 270 * ereg - enable register 271 * emask - enable mask 272 * sleepmask - mask of sleep mode 273 * etime - enable time 274 * odelay - off/on delay time in uS 275 */ 276 #define HI6421_BUCK012(_id, vreg, vmask, ereg, emask, sleepmask, \ 277 etime, odelay) \ 278 [HI6421_##_id] = { \ 279 .desc = { \ 280 .name = #_id, \ 281 .ops = &hi6421_buck012_ops, \ 282 .type = REGULATOR_VOLTAGE, \ 283 .id = HI6421_##_id, \ 284 .owner = THIS_MODULE, \ 285 .min_uV = 700000, \ 286 .n_voltages = 128, \ 287 .uV_step = 7086, \ 288 .vsel_reg = HI6421_REG_TO_BUS_ADDR(vreg), \ 289 .vsel_mask = vmask, \ 290 .enable_reg = HI6421_REG_TO_BUS_ADDR(ereg), \ 291 .enable_mask = emask, \ 292 .enable_time = etime, \ 293 .off_on_delay = odelay, \ 294 }, \ 295 .mode_mask = sleepmask, \ 296 } 297 298 /* HI6421 BUCK3/4/5 share similar configurations as LDOs, with exception 299 * that it supports SLEEP mode, so has different .ops. 300 * 301 * _id - LDO id name string 302 * v_table - voltage table 303 * vreg - voltage select register 304 * vmask - voltage select mask 305 * ereg - enable register 306 * emask - enable mask 307 * odelay - off/on delay time in uS 308 * sleepmask - mask of sleep mode 309 */ 310 #define HI6421_BUCK345(_id, v_table, vreg, vmask, ereg, emask, \ 311 odelay, sleepmask) \ 312 [HI6421_##_id] = { \ 313 .desc = { \ 314 .name = #_id, \ 315 .ops = &hi6421_buck345_ops, \ 316 .type = REGULATOR_VOLTAGE, \ 317 .id = HI6421_##_id, \ 318 .owner = THIS_MODULE, \ 319 .n_voltages = ARRAY_SIZE(v_table), \ 320 .volt_table = v_table, \ 321 .vsel_reg = HI6421_REG_TO_BUS_ADDR(vreg), \ 322 .vsel_mask = vmask, \ 323 .enable_reg = HI6421_REG_TO_BUS_ADDR(ereg), \ 324 .enable_mask = emask, \ 325 .enable_time = HI6421_LDO_ENABLE_TIME, \ 326 .off_on_delay = odelay, \ 327 }, \ 328 .mode_mask = sleepmask, \ 329 } 330 331 /* HI6421 regulator information */ 332 static struct hi6421_regulator_info 333 hi6421_regulator_info[HI6421_NUM_REGULATORS] = { 334 HI6421_LDO(LDO0, ldo_0_voltages, 0x20, 0x07, 0x20, 0x10, 335 10000, 0x20, 8000), 336 HI6421_LDO_LINEAR(LDO1, 1700000, 4, 100000, 0x21, 0x03, 0x21, 0x10, 337 10000, 0x20, 5000), 338 HI6421_LDO_LINEAR(LDO2, 1050000, 8, 50000, 0x22, 0x07, 0x22, 0x10, 339 20000, 0x20, 8000), 340 HI6421_LDO_LINEAR(LDO3, 1050000, 8, 50000, 0x23, 0x07, 0x23, 0x10, 341 20000, 0x20, 8000), 342 HI6421_LDO(LDO4, ldo_0_voltages, 0x24, 0x07, 0x24, 0x10, 343 20000, 0x20, 8000), 344 HI6421_LDO(LDO5, ldo_0_voltages, 0x25, 0x07, 0x25, 0x10, 345 20000, 0x20, 8000), 346 HI6421_LDO(LDO6, ldo_0_voltages, 0x26, 0x07, 0x26, 0x10, 347 20000, 0x20, 8000), 348 HI6421_LDO(LDO7, ldo_0_voltages, 0x27, 0x07, 0x27, 0x10, 349 20000, 0x20, 5000), 350 HI6421_LDO(LDO8, ldo_8_voltages, 0x28, 0x07, 0x28, 0x10, 351 20000, 0x20, 8000), 352 HI6421_LDO(LDO9, ldo_0_voltages, 0x29, 0x07, 0x29, 0x10, 353 40000, 0x20, 8000), 354 HI6421_LDO(LDO10, ldo_0_voltages, 0x2a, 0x07, 0x2a, 0x10, 355 40000, 0x20, 8000), 356 HI6421_LDO(LDO11, ldo_0_voltages, 0x2b, 0x07, 0x2b, 0x10, 357 40000, 0x20, 8000), 358 HI6421_LDO(LDO12, ldo_0_voltages, 0x2c, 0x07, 0x2c, 0x10, 359 40000, 0x20, 8000), 360 HI6421_LDO(LDO13, ldo_0_voltages, 0x2d, 0x07, 0x2d, 0x10, 361 40000, 0x20, 8000), 362 HI6421_LDO(LDO14, ldo_0_voltages, 0x2e, 0x07, 0x2e, 0x10, 363 40000, 0x20, 8000), 364 HI6421_LDO(LDO15, ldo_8_voltages, 0x2f, 0x07, 0x2f, 0x10, 365 40000, 0x20, 8000), 366 HI6421_LDO(LDO16, ldo_0_voltages, 0x30, 0x07, 0x30, 0x10, 367 40000, 0x20, 8000), 368 HI6421_LDO(LDO17, ldo_0_voltages, 0x31, 0x07, 0x31, 0x10, 369 40000, 0x20, 8000), 370 HI6421_LDO(LDO18, ldo_0_voltages, 0x32, 0x07, 0x32, 0x10, 371 40000, 0x20, 8000), 372 HI6421_LDO(LDO19, ldo_0_voltages, 0x33, 0x07, 0x33, 0x10, 373 40000, 0x20, 8000), 374 HI6421_LDO(LDO20, ldo_0_voltages, 0x34, 0x07, 0x34, 0x10, 375 40000, 0x20, 8000), 376 HI6421_LDO_LINEAR_RANGE(LDOAUDIO, 8, ldo_audio_volt_range, 0x36, 377 0x70, 0x36, 0x01, 40000, 0x02, 5000), 378 HI6421_BUCK012(BUCK0, 0x0d, 0x7f, 0x0c, 0x01, 0x10, 400, 20000), 379 HI6421_BUCK012(BUCK1, 0x0f, 0x7f, 0x0e, 0x01, 0x10, 400, 20000), 380 HI6421_BUCK012(BUCK2, 0x11, 0x7f, 0x10, 0x01, 0x10, 350, 100), 381 HI6421_BUCK345(BUCK3, buck_3_voltages, 0x13, 0x07, 0x12, 0x01, 382 20000, 0x10), 383 HI6421_BUCK345(BUCK4, buck_4_voltages, 0x15, 0x07, 0x14, 0x01, 384 20000, 0x10), 385 HI6421_BUCK345(BUCK5, buck_5_voltages, 0x17, 0x07, 0x16, 0x01, 386 20000, 0x10), 387 }; 388 389 static int hi6421_regulator_enable(struct regulator_dev *rdev) 390 { 391 struct hi6421_regulator_pdata *pdata; 392 393 pdata = dev_get_drvdata(rdev->dev.parent); 394 /* hi6421 spec requires regulator enablement must be serialized: 395 * - Because when BUCK, LDO switching from off to on, it will have 396 * a huge instantaneous current; so you can not turn on two or 397 * more LDO or BUCKs simultaneously, or it may burn the chip. 398 */ 399 mutex_lock(&pdata->lock); 400 401 /* call regulator regmap helper */ 402 regulator_enable_regmap(rdev); 403 404 mutex_unlock(&pdata->lock); 405 return 0; 406 } 407 408 static unsigned int hi6421_regulator_ldo_get_mode(struct regulator_dev *rdev) 409 { 410 struct hi6421_regulator_info *info = rdev_get_drvdata(rdev); 411 u32 reg_val; 412 413 regmap_read(rdev->regmap, rdev->desc->enable_reg, ®_val); 414 if (reg_val & info->mode_mask) 415 return REGULATOR_MODE_IDLE; 416 417 return REGULATOR_MODE_NORMAL; 418 } 419 420 static unsigned int hi6421_regulator_buck_get_mode(struct regulator_dev *rdev) 421 { 422 struct hi6421_regulator_info *info = rdev_get_drvdata(rdev); 423 u32 reg_val; 424 425 regmap_read(rdev->regmap, rdev->desc->enable_reg, ®_val); 426 if (reg_val & info->mode_mask) 427 return REGULATOR_MODE_STANDBY; 428 429 return REGULATOR_MODE_NORMAL; 430 } 431 432 static int hi6421_regulator_ldo_set_mode(struct regulator_dev *rdev, 433 unsigned int mode) 434 { 435 struct hi6421_regulator_info *info = rdev_get_drvdata(rdev); 436 u32 new_mode; 437 438 switch (mode) { 439 case REGULATOR_MODE_NORMAL: 440 new_mode = 0; 441 break; 442 case REGULATOR_MODE_IDLE: 443 new_mode = info->mode_mask; 444 break; 445 default: 446 return -EINVAL; 447 } 448 449 /* set mode */ 450 regmap_update_bits(rdev->regmap, rdev->desc->enable_reg, 451 info->mode_mask, new_mode); 452 453 return 0; 454 } 455 456 static int hi6421_regulator_buck_set_mode(struct regulator_dev *rdev, 457 unsigned int mode) 458 { 459 struct hi6421_regulator_info *info = rdev_get_drvdata(rdev); 460 u32 new_mode; 461 462 switch (mode) { 463 case REGULATOR_MODE_NORMAL: 464 new_mode = 0; 465 break; 466 case REGULATOR_MODE_STANDBY: 467 new_mode = info->mode_mask; 468 break; 469 default: 470 return -EINVAL; 471 } 472 473 /* set mode */ 474 regmap_update_bits(rdev->regmap, rdev->desc->enable_reg, 475 info->mode_mask, new_mode); 476 477 return 0; 478 } 479 480 unsigned int hi6421_regulator_ldo_get_optimum_mode(struct regulator_dev *rdev, 481 int input_uV, int output_uV, int load_uA) 482 { 483 struct hi6421_regulator_info *info = rdev_get_drvdata(rdev); 484 485 if (load_uA > info->eco_microamp) 486 return REGULATOR_MODE_NORMAL; 487 488 return REGULATOR_MODE_IDLE; 489 } 490 491 static const struct regulator_ops hi6421_ldo_ops = { 492 .is_enabled = regulator_is_enabled_regmap, 493 .enable = hi6421_regulator_enable, 494 .disable = regulator_disable_regmap, 495 .list_voltage = regulator_list_voltage_table, 496 .map_voltage = regulator_map_voltage_ascend, 497 .get_voltage_sel = regulator_get_voltage_sel_regmap, 498 .set_voltage_sel = regulator_set_voltage_sel_regmap, 499 .get_mode = hi6421_regulator_ldo_get_mode, 500 .set_mode = hi6421_regulator_ldo_set_mode, 501 .get_optimum_mode = hi6421_regulator_ldo_get_optimum_mode, 502 }; 503 504 static const struct regulator_ops hi6421_ldo_linear_ops = { 505 .is_enabled = regulator_is_enabled_regmap, 506 .enable = hi6421_regulator_enable, 507 .disable = regulator_disable_regmap, 508 .list_voltage = regulator_list_voltage_linear, 509 .map_voltage = regulator_map_voltage_linear, 510 .get_voltage_sel = regulator_get_voltage_sel_regmap, 511 .set_voltage_sel = regulator_set_voltage_sel_regmap, 512 .get_mode = hi6421_regulator_ldo_get_mode, 513 .set_mode = hi6421_regulator_ldo_set_mode, 514 .get_optimum_mode = hi6421_regulator_ldo_get_optimum_mode, 515 }; 516 517 static const struct regulator_ops hi6421_ldo_linear_range_ops = { 518 .is_enabled = regulator_is_enabled_regmap, 519 .enable = hi6421_regulator_enable, 520 .disable = regulator_disable_regmap, 521 .list_voltage = regulator_list_voltage_linear_range, 522 .map_voltage = regulator_map_voltage_linear_range, 523 .get_voltage_sel = regulator_get_voltage_sel_regmap, 524 .set_voltage_sel = regulator_set_voltage_sel_regmap, 525 .get_mode = hi6421_regulator_ldo_get_mode, 526 .set_mode = hi6421_regulator_ldo_set_mode, 527 .get_optimum_mode = hi6421_regulator_ldo_get_optimum_mode, 528 }; 529 530 static const struct regulator_ops hi6421_buck012_ops = { 531 .is_enabled = regulator_is_enabled_regmap, 532 .enable = hi6421_regulator_enable, 533 .disable = regulator_disable_regmap, 534 .list_voltage = regulator_list_voltage_linear, 535 .map_voltage = regulator_map_voltage_linear, 536 .get_voltage_sel = regulator_get_voltage_sel_regmap, 537 .set_voltage_sel = regulator_set_voltage_sel_regmap, 538 .get_mode = hi6421_regulator_buck_get_mode, 539 .set_mode = hi6421_regulator_buck_set_mode, 540 }; 541 542 static const struct regulator_ops hi6421_buck345_ops = { 543 .is_enabled = regulator_is_enabled_regmap, 544 .enable = hi6421_regulator_enable, 545 .disable = regulator_disable_regmap, 546 .list_voltage = regulator_list_voltage_table, 547 .map_voltage = regulator_map_voltage_ascend, 548 .get_voltage_sel = regulator_get_voltage_sel_regmap, 549 .set_voltage_sel = regulator_set_voltage_sel_regmap, 550 .get_mode = hi6421_regulator_buck_get_mode, 551 .set_mode = hi6421_regulator_buck_set_mode, 552 }; 553 554 static int hi6421_regulator_register(struct platform_device *pdev, 555 struct regmap *rmap, 556 struct regulator_init_data *init_data, 557 int id, struct device_node *np) 558 { 559 struct hi6421_regulator_info *info = NULL; 560 struct regulator_config config = { }; 561 struct regulator_dev *rdev; 562 563 /* assign per-regulator data */ 564 info = &hi6421_regulator_info[id]; 565 566 config.dev = &pdev->dev; 567 config.init_data = init_data; 568 config.driver_data = info; 569 config.regmap = rmap; 570 config.of_node = np; 571 572 /* register regulator with framework */ 573 rdev = devm_regulator_register(&pdev->dev, &info->desc, &config); 574 if (IS_ERR(rdev)) { 575 dev_err(&pdev->dev, "failed to register regulator %s\n", 576 info->desc.name); 577 return PTR_ERR(rdev); 578 } 579 580 return 0; 581 } 582 583 static int hi6421_regulator_probe(struct platform_device *pdev) 584 { 585 struct device *dev = &pdev->dev; 586 struct device_node *np; 587 struct hi6421_pmic *pmic; 588 struct hi6421_regulator_pdata *pdata; 589 int i, ret = 0; 590 591 pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL); 592 if (!pdata) 593 return -ENOMEM; 594 mutex_init(&pdata->lock); 595 platform_set_drvdata(pdev, pdata); 596 597 np = of_get_child_by_name(dev->parent->of_node, "regulators"); 598 if (!np) 599 return -ENODEV; 600 601 ret = of_regulator_match(dev, np, 602 hi6421_regulator_match, 603 ARRAY_SIZE(hi6421_regulator_match)); 604 of_node_put(np); 605 if (ret < 0) { 606 dev_err(dev, "Error parsing regulator init data: %d\n", ret); 607 return ret; 608 } 609 610 pmic = dev_get_drvdata(dev->parent); 611 612 for (i = 0; i < ARRAY_SIZE(hi6421_regulator_info); i++) { 613 ret = hi6421_regulator_register(pdev, pmic->regmap, 614 hi6421_regulator_match[i].init_data, i, 615 hi6421_regulator_match[i].of_node); 616 if (ret) 617 return ret; 618 } 619 620 return 0; 621 } 622 623 static struct platform_driver hi6421_regulator_driver = { 624 .driver = { 625 .name = "hi6421-regulator", 626 }, 627 .probe = hi6421_regulator_probe, 628 }; 629 module_platform_driver(hi6421_regulator_driver); 630 631 MODULE_AUTHOR("Guodong Xu <guodong.xu@linaro.org>"); 632 MODULE_DESCRIPTION("Hi6421 regulator driver"); 633 MODULE_LICENSE("GPL v2"); 634