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