1 /* 2 * Regulator driver for DA9055 PMIC 3 * 4 * Copyright(c) 2012 Dialog Semiconductor Ltd. 5 * 6 * Author: David Dajun Chen <dchen@diasemi.com> 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 * 13 */ 14 15 #include <linux/module.h> 16 #include <linux/init.h> 17 #include <linux/err.h> 18 #include <linux/gpio.h> 19 #include <linux/platform_device.h> 20 #include <linux/regulator/driver.h> 21 #include <linux/regulator/machine.h> 22 #include <linux/of.h> 23 #include <linux/regulator/of_regulator.h> 24 25 #include <linux/mfd/da9055/core.h> 26 #include <linux/mfd/da9055/reg.h> 27 #include <linux/mfd/da9055/pdata.h> 28 29 #define DA9055_MIN_UA 0 30 #define DA9055_MAX_UA 3 31 32 #define DA9055_LDO_MODE_SYNC 0 33 #define DA9055_LDO_MODE_SLEEP 1 34 35 #define DA9055_BUCK_MODE_SLEEP 1 36 #define DA9055_BUCK_MODE_SYNC 2 37 #define DA9055_BUCK_MODE_AUTO 3 38 39 /* DA9055 REGULATOR IDs */ 40 #define DA9055_ID_BUCK1 0 41 #define DA9055_ID_BUCK2 1 42 #define DA9055_ID_LDO1 2 43 #define DA9055_ID_LDO2 3 44 #define DA9055_ID_LDO3 4 45 #define DA9055_ID_LDO4 5 46 #define DA9055_ID_LDO5 6 47 #define DA9055_ID_LDO6 7 48 49 /* DA9055 BUCK current limit */ 50 static const int da9055_current_limits[] = { 500000, 600000, 700000, 800000 }; 51 52 struct da9055_conf_reg { 53 int reg; 54 int sel_mask; 55 int en_mask; 56 }; 57 58 struct da9055_volt_reg { 59 int reg_a; 60 int reg_b; 61 int sl_shift; 62 int v_mask; 63 }; 64 65 struct da9055_mode_reg { 66 int reg; 67 int mask; 68 int shift; 69 }; 70 71 struct da9055_regulator_info { 72 struct regulator_desc reg_desc; 73 struct da9055_conf_reg conf; 74 struct da9055_volt_reg volt; 75 struct da9055_mode_reg mode; 76 }; 77 78 struct da9055_regulator { 79 struct da9055 *da9055; 80 struct da9055_regulator_info *info; 81 struct regulator_dev *rdev; 82 enum gpio_select reg_rselect; 83 }; 84 85 static unsigned int da9055_buck_get_mode(struct regulator_dev *rdev) 86 { 87 struct da9055_regulator *regulator = rdev_get_drvdata(rdev); 88 struct da9055_regulator_info *info = regulator->info; 89 int ret, mode = 0; 90 91 ret = da9055_reg_read(regulator->da9055, info->mode.reg); 92 if (ret < 0) 93 return ret; 94 95 switch ((ret & info->mode.mask) >> info->mode.shift) { 96 case DA9055_BUCK_MODE_SYNC: 97 mode = REGULATOR_MODE_FAST; 98 break; 99 case DA9055_BUCK_MODE_AUTO: 100 mode = REGULATOR_MODE_NORMAL; 101 break; 102 case DA9055_BUCK_MODE_SLEEP: 103 mode = REGULATOR_MODE_STANDBY; 104 break; 105 } 106 107 return mode; 108 } 109 110 static int da9055_buck_set_mode(struct regulator_dev *rdev, 111 unsigned int mode) 112 { 113 struct da9055_regulator *regulator = rdev_get_drvdata(rdev); 114 struct da9055_regulator_info *info = regulator->info; 115 int val = 0; 116 117 switch (mode) { 118 case REGULATOR_MODE_FAST: 119 val = DA9055_BUCK_MODE_SYNC << info->mode.shift; 120 break; 121 case REGULATOR_MODE_NORMAL: 122 val = DA9055_BUCK_MODE_AUTO << info->mode.shift; 123 break; 124 case REGULATOR_MODE_STANDBY: 125 val = DA9055_BUCK_MODE_SLEEP << info->mode.shift; 126 break; 127 } 128 129 return da9055_reg_update(regulator->da9055, info->mode.reg, 130 info->mode.mask, val); 131 } 132 133 static unsigned int da9055_ldo_get_mode(struct regulator_dev *rdev) 134 { 135 struct da9055_regulator *regulator = rdev_get_drvdata(rdev); 136 struct da9055_regulator_info *info = regulator->info; 137 int ret; 138 139 ret = da9055_reg_read(regulator->da9055, info->volt.reg_b); 140 if (ret < 0) 141 return ret; 142 143 if (ret >> info->volt.sl_shift) 144 return REGULATOR_MODE_STANDBY; 145 else 146 return REGULATOR_MODE_NORMAL; 147 } 148 149 static int da9055_ldo_set_mode(struct regulator_dev *rdev, unsigned int mode) 150 { 151 struct da9055_regulator *regulator = rdev_get_drvdata(rdev); 152 struct da9055_regulator_info *info = regulator->info; 153 struct da9055_volt_reg volt = info->volt; 154 int val = 0; 155 156 switch (mode) { 157 case REGULATOR_MODE_NORMAL: 158 case REGULATOR_MODE_FAST: 159 val = DA9055_LDO_MODE_SYNC; 160 break; 161 case REGULATOR_MODE_STANDBY: 162 val = DA9055_LDO_MODE_SLEEP; 163 break; 164 } 165 166 return da9055_reg_update(regulator->da9055, volt.reg_b, 167 1 << volt.sl_shift, 168 val << volt.sl_shift); 169 } 170 171 static int da9055_buck_get_current_limit(struct regulator_dev *rdev) 172 { 173 struct da9055_regulator *regulator = rdev_get_drvdata(rdev); 174 struct da9055_regulator_info *info = regulator->info; 175 int ret; 176 177 ret = da9055_reg_read(regulator->da9055, DA9055_REG_BUCK_LIM); 178 if (ret < 0) 179 return ret; 180 181 ret &= info->mode.mask; 182 return da9055_current_limits[ret >> info->mode.shift]; 183 } 184 185 static int da9055_buck_set_current_limit(struct regulator_dev *rdev, int min_uA, 186 int max_uA) 187 { 188 struct da9055_regulator *regulator = rdev_get_drvdata(rdev); 189 struct da9055_regulator_info *info = regulator->info; 190 int i; 191 192 for (i = ARRAY_SIZE(da9055_current_limits) - 1; i >= 0; i--) { 193 if ((min_uA <= da9055_current_limits[i]) && 194 (da9055_current_limits[i] <= max_uA)) 195 return da9055_reg_update(regulator->da9055, 196 DA9055_REG_BUCK_LIM, 197 info->mode.mask, 198 i << info->mode.shift); 199 } 200 201 return -EINVAL; 202 } 203 204 static int da9055_regulator_get_voltage_sel(struct regulator_dev *rdev) 205 { 206 struct da9055_regulator *regulator = rdev_get_drvdata(rdev); 207 struct da9055_regulator_info *info = regulator->info; 208 struct da9055_volt_reg volt = info->volt; 209 int ret, sel; 210 211 /* 212 * There are two voltage register set A & B for voltage ramping but 213 * either one of then can be active therefore we first determine 214 * the active register set. 215 */ 216 ret = da9055_reg_read(regulator->da9055, info->conf.reg); 217 if (ret < 0) 218 return ret; 219 220 ret &= info->conf.sel_mask; 221 222 /* Get the voltage for the active register set A/B */ 223 if (ret == DA9055_REGUALTOR_SET_A) 224 ret = da9055_reg_read(regulator->da9055, volt.reg_a); 225 else 226 ret = da9055_reg_read(regulator->da9055, volt.reg_b); 227 228 if (ret < 0) 229 return ret; 230 231 sel = (ret & volt.v_mask); 232 return sel; 233 } 234 235 static int da9055_regulator_set_voltage_sel(struct regulator_dev *rdev, 236 unsigned int selector) 237 { 238 struct da9055_regulator *regulator = rdev_get_drvdata(rdev); 239 struct da9055_regulator_info *info = regulator->info; 240 int ret; 241 242 /* 243 * Regulator register set A/B is not selected through GPIO therefore 244 * we use default register set A for voltage ramping. 245 */ 246 if (regulator->reg_rselect == NO_GPIO) { 247 /* Select register set A */ 248 ret = da9055_reg_update(regulator->da9055, info->conf.reg, 249 info->conf.sel_mask, DA9055_SEL_REG_A); 250 if (ret < 0) 251 return ret; 252 253 /* Set the voltage */ 254 return da9055_reg_update(regulator->da9055, info->volt.reg_a, 255 info->volt.v_mask, selector); 256 } 257 258 /* 259 * Here regulator register set A/B is selected through GPIO. 260 * Therefore we first determine the selected register set A/B and 261 * then set the desired voltage for that register set A/B. 262 */ 263 ret = da9055_reg_read(regulator->da9055, info->conf.reg); 264 if (ret < 0) 265 return ret; 266 267 ret &= info->conf.sel_mask; 268 269 /* Set the voltage */ 270 if (ret == DA9055_REGUALTOR_SET_A) 271 return da9055_reg_update(regulator->da9055, info->volt.reg_a, 272 info->volt.v_mask, selector); 273 else 274 return da9055_reg_update(regulator->da9055, info->volt.reg_b, 275 info->volt.v_mask, selector); 276 } 277 278 static int da9055_regulator_set_suspend_voltage(struct regulator_dev *rdev, 279 int uV) 280 { 281 struct da9055_regulator *regulator = rdev_get_drvdata(rdev); 282 struct da9055_regulator_info *info = regulator->info; 283 int ret; 284 285 /* Select register set B for suspend voltage ramping. */ 286 if (regulator->reg_rselect == NO_GPIO) { 287 ret = da9055_reg_update(regulator->da9055, info->conf.reg, 288 info->conf.sel_mask, DA9055_SEL_REG_B); 289 if (ret < 0) 290 return ret; 291 } 292 293 ret = regulator_map_voltage_linear(rdev, uV, uV); 294 if (ret < 0) 295 return ret; 296 297 return da9055_reg_update(regulator->da9055, info->volt.reg_b, 298 info->volt.v_mask, ret); 299 } 300 301 static int da9055_suspend_enable(struct regulator_dev *rdev) 302 { 303 struct da9055_regulator *regulator = rdev_get_drvdata(rdev); 304 struct da9055_regulator_info *info = regulator->info; 305 306 /* Select register set B for voltage ramping. */ 307 if (regulator->reg_rselect == NO_GPIO) 308 return da9055_reg_update(regulator->da9055, info->conf.reg, 309 info->conf.sel_mask, DA9055_SEL_REG_B); 310 else 311 return 0; 312 } 313 314 static int da9055_suspend_disable(struct regulator_dev *rdev) 315 { 316 struct da9055_regulator *regulator = rdev_get_drvdata(rdev); 317 struct da9055_regulator_info *info = regulator->info; 318 319 /* Diselect register set B. */ 320 if (regulator->reg_rselect == NO_GPIO) 321 return da9055_reg_update(regulator->da9055, info->conf.reg, 322 info->conf.sel_mask, DA9055_SEL_REG_A); 323 else 324 return 0; 325 } 326 327 static const struct regulator_ops da9055_buck_ops = { 328 .get_mode = da9055_buck_get_mode, 329 .set_mode = da9055_buck_set_mode, 330 331 .get_current_limit = da9055_buck_get_current_limit, 332 .set_current_limit = da9055_buck_set_current_limit, 333 334 .get_voltage_sel = da9055_regulator_get_voltage_sel, 335 .set_voltage_sel = da9055_regulator_set_voltage_sel, 336 .list_voltage = regulator_list_voltage_linear, 337 .map_voltage = regulator_map_voltage_linear, 338 .is_enabled = regulator_is_enabled_regmap, 339 .enable = regulator_enable_regmap, 340 .disable = regulator_disable_regmap, 341 342 .set_suspend_voltage = da9055_regulator_set_suspend_voltage, 343 .set_suspend_enable = da9055_suspend_enable, 344 .set_suspend_disable = da9055_suspend_disable, 345 .set_suspend_mode = da9055_buck_set_mode, 346 }; 347 348 static const struct regulator_ops da9055_ldo_ops = { 349 .get_mode = da9055_ldo_get_mode, 350 .set_mode = da9055_ldo_set_mode, 351 352 .get_voltage_sel = da9055_regulator_get_voltage_sel, 353 .set_voltage_sel = da9055_regulator_set_voltage_sel, 354 .list_voltage = regulator_list_voltage_linear, 355 .map_voltage = regulator_map_voltage_linear, 356 .is_enabled = regulator_is_enabled_regmap, 357 .enable = regulator_enable_regmap, 358 .disable = regulator_disable_regmap, 359 360 .set_suspend_voltage = da9055_regulator_set_suspend_voltage, 361 .set_suspend_enable = da9055_suspend_enable, 362 .set_suspend_disable = da9055_suspend_disable, 363 .set_suspend_mode = da9055_ldo_set_mode, 364 365 }; 366 367 #define DA9055_LDO(_id, step, min, max, vbits, voffset) \ 368 {\ 369 .reg_desc = {\ 370 .name = #_id,\ 371 .ops = &da9055_ldo_ops,\ 372 .type = REGULATOR_VOLTAGE,\ 373 .id = DA9055_ID_##_id,\ 374 .n_voltages = (max - min) / step + 1 + (voffset), \ 375 .enable_reg = DA9055_REG_BCORE_CONT + DA9055_ID_##_id, \ 376 .enable_mask = 1, \ 377 .min_uV = (min) * 1000,\ 378 .uV_step = (step) * 1000,\ 379 .linear_min_sel = (voffset),\ 380 .owner = THIS_MODULE,\ 381 },\ 382 .conf = {\ 383 .reg = DA9055_REG_BCORE_CONT + DA9055_ID_##_id, \ 384 .sel_mask = (1 << 4),\ 385 .en_mask = 1,\ 386 },\ 387 .volt = {\ 388 .reg_a = DA9055_REG_VBCORE_A + DA9055_ID_##_id, \ 389 .reg_b = DA9055_REG_VBCORE_B + DA9055_ID_##_id, \ 390 .sl_shift = 7,\ 391 .v_mask = (1 << (vbits)) - 1,\ 392 },\ 393 } 394 395 #define DA9055_BUCK(_id, step, min, max, vbits, voffset, mbits, sbits) \ 396 {\ 397 .reg_desc = {\ 398 .name = #_id,\ 399 .ops = &da9055_buck_ops,\ 400 .type = REGULATOR_VOLTAGE,\ 401 .id = DA9055_ID_##_id,\ 402 .n_voltages = (max - min) / step + 1 + (voffset), \ 403 .enable_reg = DA9055_REG_BCORE_CONT + DA9055_ID_##_id, \ 404 .enable_mask = 1,\ 405 .min_uV = (min) * 1000,\ 406 .uV_step = (step) * 1000,\ 407 .linear_min_sel = (voffset),\ 408 .owner = THIS_MODULE,\ 409 },\ 410 .conf = {\ 411 .reg = DA9055_REG_BCORE_CONT + DA9055_ID_##_id, \ 412 .sel_mask = (1 << 4),\ 413 .en_mask = 1,\ 414 },\ 415 .volt = {\ 416 .reg_a = DA9055_REG_VBCORE_A + DA9055_ID_##_id, \ 417 .reg_b = DA9055_REG_VBCORE_B + DA9055_ID_##_id, \ 418 .sl_shift = 7,\ 419 .v_mask = (1 << (vbits)) - 1,\ 420 },\ 421 .mode = {\ 422 .reg = DA9055_REG_BCORE_MODE,\ 423 .mask = (mbits),\ 424 .shift = (sbits),\ 425 },\ 426 } 427 428 static struct da9055_regulator_info da9055_regulator_info[] = { 429 DA9055_BUCK(BUCK1, 25, 725, 2075, 6, 9, 0xc, 2), 430 DA9055_BUCK(BUCK2, 25, 925, 2500, 6, 0, 3, 0), 431 DA9055_LDO(LDO1, 50, 900, 3300, 6, 2), 432 DA9055_LDO(LDO2, 50, 900, 3300, 6, 3), 433 DA9055_LDO(LDO3, 50, 900, 3300, 6, 2), 434 DA9055_LDO(LDO4, 50, 900, 3300, 6, 2), 435 DA9055_LDO(LDO5, 50, 900, 2750, 6, 2), 436 DA9055_LDO(LDO6, 20, 900, 3300, 7, 0), 437 }; 438 439 /* 440 * Configures regulator to be controlled either through GPIO 1 or 2. 441 * GPIO can control regulator state and/or select the regulator register 442 * set A/B for voltage ramping. 443 */ 444 static int da9055_gpio_init(struct da9055_regulator *regulator, 445 struct regulator_config *config, 446 struct da9055_pdata *pdata, int id) 447 { 448 struct da9055_regulator_info *info = regulator->info; 449 int ret = 0; 450 451 if (!pdata) 452 return 0; 453 454 if (pdata->gpio_ren && pdata->gpio_ren[id]) { 455 char name[18]; 456 int gpio_mux = pdata->gpio_ren[id]; 457 458 config->ena_gpio = pdata->ena_gpio[id]; 459 config->ena_gpio_flags = GPIOF_OUT_INIT_HIGH; 460 config->ena_gpio_invert = 1; 461 462 /* 463 * GPI pin is muxed with regulator to control the 464 * regulator state. 465 */ 466 sprintf(name, "DA9055 GPI %d", gpio_mux); 467 ret = devm_gpio_request_one(config->dev, gpio_mux, GPIOF_DIR_IN, 468 name); 469 if (ret < 0) 470 goto err; 471 472 /* 473 * Let the regulator know that its state is controlled 474 * through GPI. 475 */ 476 ret = da9055_reg_update(regulator->da9055, info->conf.reg, 477 DA9055_E_GPI_MASK, 478 pdata->reg_ren[id] 479 << DA9055_E_GPI_SHIFT); 480 if (ret < 0) 481 goto err; 482 } 483 484 if (pdata->gpio_rsel && pdata->gpio_rsel[id]) { 485 char name[18]; 486 int gpio_mux = pdata->gpio_rsel[id]; 487 488 regulator->reg_rselect = pdata->reg_rsel[id]; 489 490 /* 491 * GPI pin is muxed with regulator to select the 492 * regulator register set A/B for voltage ramping. 493 */ 494 sprintf(name, "DA9055 GPI %d", gpio_mux); 495 ret = devm_gpio_request_one(config->dev, gpio_mux, GPIOF_DIR_IN, 496 name); 497 if (ret < 0) 498 goto err; 499 500 /* 501 * Let the regulator know that its register set A/B 502 * will be selected through GPI for voltage ramping. 503 */ 504 ret = da9055_reg_update(regulator->da9055, info->conf.reg, 505 DA9055_V_GPI_MASK, 506 pdata->reg_rsel[id] 507 << DA9055_V_GPI_SHIFT); 508 } 509 510 err: 511 return ret; 512 } 513 514 static irqreturn_t da9055_ldo5_6_oc_irq(int irq, void *data) 515 { 516 struct da9055_regulator *regulator = data; 517 518 regulator_notifier_call_chain(regulator->rdev, 519 REGULATOR_EVENT_OVER_CURRENT, NULL); 520 521 return IRQ_HANDLED; 522 } 523 524 static inline struct da9055_regulator_info *find_regulator_info(int id) 525 { 526 struct da9055_regulator_info *info; 527 int i; 528 529 for (i = 0; i < ARRAY_SIZE(da9055_regulator_info); i++) { 530 info = &da9055_regulator_info[i]; 531 if (info->reg_desc.id == id) 532 return info; 533 } 534 535 return NULL; 536 } 537 538 #ifdef CONFIG_OF 539 static struct of_regulator_match da9055_reg_matches[] = { 540 { .name = "BUCK1", }, 541 { .name = "BUCK2", }, 542 { .name = "LDO1", }, 543 { .name = "LDO2", }, 544 { .name = "LDO3", }, 545 { .name = "LDO4", }, 546 { .name = "LDO5", }, 547 { .name = "LDO6", }, 548 }; 549 550 static int da9055_regulator_dt_init(struct platform_device *pdev, 551 struct da9055_regulator *regulator, 552 struct regulator_config *config, 553 int regid) 554 { 555 struct device_node *nproot, *np; 556 int ret; 557 558 nproot = of_node_get(pdev->dev.parent->of_node); 559 if (!nproot) 560 return -ENODEV; 561 562 np = of_get_child_by_name(nproot, "regulators"); 563 if (!np) 564 return -ENODEV; 565 566 ret = of_regulator_match(&pdev->dev, np, &da9055_reg_matches[regid], 1); 567 of_node_put(nproot); 568 if (ret < 0) { 569 dev_err(&pdev->dev, "Error matching regulator: %d\n", ret); 570 return ret; 571 } 572 573 config->init_data = da9055_reg_matches[regid].init_data; 574 config->of_node = da9055_reg_matches[regid].of_node; 575 576 if (!config->of_node) 577 return -ENODEV; 578 579 return 0; 580 } 581 #else 582 static inline int da9055_regulator_dt_init(struct platform_device *pdev, 583 struct da9055_regulator *regulator, 584 struct regulator_config *config, 585 int regid) 586 { 587 return -ENODEV; 588 } 589 #endif /* CONFIG_OF */ 590 591 static int da9055_regulator_probe(struct platform_device *pdev) 592 { 593 struct regulator_config config = { }; 594 struct da9055_regulator *regulator; 595 struct da9055 *da9055 = dev_get_drvdata(pdev->dev.parent); 596 struct da9055_pdata *pdata = dev_get_platdata(da9055->dev); 597 int ret, irq; 598 599 regulator = devm_kzalloc(&pdev->dev, sizeof(struct da9055_regulator), 600 GFP_KERNEL); 601 if (!regulator) 602 return -ENOMEM; 603 604 regulator->info = find_regulator_info(pdev->id); 605 if (regulator->info == NULL) { 606 dev_err(&pdev->dev, "invalid regulator ID specified\n"); 607 return -EINVAL; 608 } 609 610 regulator->da9055 = da9055; 611 config.dev = &pdev->dev; 612 config.driver_data = regulator; 613 config.regmap = da9055->regmap; 614 615 if (pdata && pdata->regulators) { 616 config.init_data = pdata->regulators[pdev->id]; 617 } else { 618 ret = da9055_regulator_dt_init(pdev, regulator, &config, 619 pdev->id); 620 if (ret < 0) 621 return ret; 622 } 623 624 ret = da9055_gpio_init(regulator, &config, pdata, pdev->id); 625 if (ret < 0) 626 return ret; 627 628 regulator->rdev = devm_regulator_register(&pdev->dev, 629 ®ulator->info->reg_desc, 630 &config); 631 if (IS_ERR(regulator->rdev)) { 632 dev_err(&pdev->dev, "Failed to register regulator %s\n", 633 regulator->info->reg_desc.name); 634 return PTR_ERR(regulator->rdev); 635 } 636 637 /* Only LDO 5 and 6 has got the over current interrupt */ 638 if (pdev->id == DA9055_ID_LDO5 || pdev->id == DA9055_ID_LDO6) { 639 irq = platform_get_irq_byname(pdev, "REGULATOR"); 640 if (irq < 0) 641 return irq; 642 643 ret = devm_request_threaded_irq(&pdev->dev, irq, NULL, 644 da9055_ldo5_6_oc_irq, 645 IRQF_TRIGGER_HIGH | 646 IRQF_ONESHOT | 647 IRQF_PROBE_SHARED, 648 pdev->name, regulator); 649 if (ret != 0) { 650 if (ret != -EBUSY) { 651 dev_err(&pdev->dev, 652 "Failed to request Regulator IRQ %d: %d\n", 653 irq, ret); 654 return ret; 655 } 656 } 657 } 658 659 platform_set_drvdata(pdev, regulator); 660 661 return 0; 662 } 663 664 static struct platform_driver da9055_regulator_driver = { 665 .probe = da9055_regulator_probe, 666 .driver = { 667 .name = "da9055-regulator", 668 }, 669 }; 670 671 static int __init da9055_regulator_init(void) 672 { 673 return platform_driver_register(&da9055_regulator_driver); 674 } 675 subsys_initcall(da9055_regulator_init); 676 677 static void __exit da9055_regulator_exit(void) 678 { 679 platform_driver_unregister(&da9055_regulator_driver); 680 } 681 module_exit(da9055_regulator_exit); 682 683 MODULE_AUTHOR("David Dajun Chen <dchen@diasemi.com>"); 684 MODULE_DESCRIPTION("Power Regulator driver for Dialog DA9055 PMIC"); 685 MODULE_LICENSE("GPL"); 686 MODULE_ALIAS("platform:da9055-regulator"); 687