1// SPDX-License-Identifier: GPL-2.0+ 2// 3// max8998.c - Voltage regulator driver for the Maxim 8998 4// 5// Copyright (C) 2009-2010 Samsung Electronics 6// Kyungmin Park <kyungmin.park@samsung.com> 7// Marek Szyprowski <m.szyprowski@samsung.com> 8 9#include <linux/module.h> 10#include <linux/init.h> 11#include <linux/i2c.h> 12#include <linux/err.h> 13#include <linux/bits.h> 14#include <linux/gpio/consumer.h> 15#include <linux/slab.h> 16#include <linux/interrupt.h> 17#include <linux/mutex.h> 18#include <linux/of.h> 19#include <linux/platform_device.h> 20#include <linux/regulator/driver.h> 21#include <linux/regulator/of_regulator.h> 22#include <linux/mfd/max8998.h> 23#include <linux/mfd/max8998-private.h> 24 25struct max8998_data { 26 struct device *dev; 27 struct max8998_dev *iodev; 28 int num_regulators; 29 u8 buck1_vol[4]; /* voltages for selection */ 30 u8 buck2_vol[2]; 31 unsigned int buck1_idx; /* index to last changed voltage */ 32 /* value in a set */ 33 unsigned int buck2_idx; 34 struct gpio_desc *buck1_gpio1; 35 struct gpio_desc *buck1_gpio2; 36 struct gpio_desc *buck2_gpio; 37}; 38 39static const unsigned int charger_current_table[] = { 40 90000, 380000, 475000, 550000, 570000, 600000, 700000, 800000, 41}; 42 43static int max8998_get_enable_register(struct regulator_dev *rdev, 44 int *reg, int *shift) 45{ 46 int ldo = rdev_get_id(rdev); 47 48 switch (ldo) { 49 case MAX8998_LDO2 ... MAX8998_LDO5: 50 *reg = MAX8998_REG_ONOFF1; 51 *shift = 3 - (ldo - MAX8998_LDO2); 52 break; 53 case MAX8998_LDO6 ... MAX8998_LDO13: 54 *reg = MAX8998_REG_ONOFF2; 55 *shift = 7 - (ldo - MAX8998_LDO6); 56 break; 57 case MAX8998_LDO14 ... MAX8998_LDO17: 58 *reg = MAX8998_REG_ONOFF3; 59 *shift = 7 - (ldo - MAX8998_LDO14); 60 break; 61 case MAX8998_BUCK1 ... MAX8998_BUCK4: 62 *reg = MAX8998_REG_ONOFF1; 63 *shift = 7 - (ldo - MAX8998_BUCK1); 64 break; 65 case MAX8998_EN32KHZ_AP ... MAX8998_ENVICHG: 66 *reg = MAX8998_REG_ONOFF4; 67 *shift = 7 - (ldo - MAX8998_EN32KHZ_AP); 68 break; 69 case MAX8998_ESAFEOUT1 ... MAX8998_ESAFEOUT2: 70 *reg = MAX8998_REG_CHGR2; 71 *shift = 7 - (ldo - MAX8998_ESAFEOUT1); 72 break; 73 case MAX8998_CHARGER: 74 *reg = MAX8998_REG_CHGR2; 75 *shift = 0; 76 break; 77 default: 78 return -EINVAL; 79 } 80 81 return 0; 82} 83 84static int max8998_ldo_is_enabled(struct regulator_dev *rdev) 85{ 86 struct max8998_data *max8998 = rdev_get_drvdata(rdev); 87 struct i2c_client *i2c = max8998->iodev->i2c; 88 int ret, reg, shift = 8; 89 u8 val; 90 91 ret = max8998_get_enable_register(rdev, ®, &shift); 92 if (ret) 93 return ret; 94 95 ret = max8998_read_reg(i2c, reg, &val); 96 if (ret) 97 return ret; 98 99 return val & (1 << shift); 100} 101 102static int max8998_ldo_is_enabled_inverted(struct regulator_dev *rdev) 103{ 104 return (!max8998_ldo_is_enabled(rdev)); 105} 106 107static int max8998_ldo_enable(struct regulator_dev *rdev) 108{ 109 struct max8998_data *max8998 = rdev_get_drvdata(rdev); 110 struct i2c_client *i2c = max8998->iodev->i2c; 111 int reg, shift = 8, ret; 112 113 ret = max8998_get_enable_register(rdev, ®, &shift); 114 if (ret) 115 return ret; 116 117 return max8998_update_reg(i2c, reg, 1<<shift, 1<<shift); 118} 119 120static int max8998_ldo_disable(struct regulator_dev *rdev) 121{ 122 struct max8998_data *max8998 = rdev_get_drvdata(rdev); 123 struct i2c_client *i2c = max8998->iodev->i2c; 124 int reg, shift = 8, ret; 125 126 ret = max8998_get_enable_register(rdev, ®, &shift); 127 if (ret) 128 return ret; 129 130 return max8998_update_reg(i2c, reg, 0, 1<<shift); 131} 132 133static int max8998_get_voltage_register(struct regulator_dev *rdev, 134 int *_reg, int *_shift, int *_mask) 135{ 136 int ldo = rdev_get_id(rdev); 137 struct max8998_data *max8998 = rdev_get_drvdata(rdev); 138 int reg, shift = 0, mask = 0xff; 139 140 switch (ldo) { 141 case MAX8998_LDO2 ... MAX8998_LDO3: 142 reg = MAX8998_REG_LDO2_LDO3; 143 mask = 0xf; 144 if (ldo == MAX8998_LDO2) 145 shift = 4; 146 else 147 shift = 0; 148 break; 149 case MAX8998_LDO4 ... MAX8998_LDO7: 150 reg = MAX8998_REG_LDO4 + (ldo - MAX8998_LDO4); 151 break; 152 case MAX8998_LDO8 ... MAX8998_LDO9: 153 reg = MAX8998_REG_LDO8_LDO9; 154 mask = 0xf; 155 if (ldo == MAX8998_LDO8) 156 shift = 4; 157 else 158 shift = 0; 159 break; 160 case MAX8998_LDO10 ... MAX8998_LDO11: 161 reg = MAX8998_REG_LDO10_LDO11; 162 if (ldo == MAX8998_LDO10) { 163 shift = 5; 164 mask = 0x7; 165 } else { 166 shift = 0; 167 mask = 0x1f; 168 } 169 break; 170 case MAX8998_LDO12 ... MAX8998_LDO17: 171 reg = MAX8998_REG_LDO12 + (ldo - MAX8998_LDO12); 172 break; 173 case MAX8998_BUCK1: 174 reg = MAX8998_REG_BUCK1_VOLTAGE1 + max8998->buck1_idx; 175 break; 176 case MAX8998_BUCK2: 177 reg = MAX8998_REG_BUCK2_VOLTAGE1 + max8998->buck2_idx; 178 break; 179 case MAX8998_BUCK3: 180 reg = MAX8998_REG_BUCK3; 181 break; 182 case MAX8998_BUCK4: 183 reg = MAX8998_REG_BUCK4; 184 break; 185 default: 186 return -EINVAL; 187 } 188 189 *_reg = reg; 190 *_shift = shift; 191 *_mask = mask; 192 193 return 0; 194} 195 196static int max8998_get_voltage_sel(struct regulator_dev *rdev) 197{ 198 struct max8998_data *max8998 = rdev_get_drvdata(rdev); 199 struct i2c_client *i2c = max8998->iodev->i2c; 200 int reg, shift = 0, mask, ret; 201 u8 val; 202 203 ret = max8998_get_voltage_register(rdev, ®, &shift, &mask); 204 if (ret) 205 return ret; 206 207 ret = max8998_read_reg(i2c, reg, &val); 208 if (ret) 209 return ret; 210 211 val >>= shift; 212 val &= mask; 213 214 return val; 215} 216 217static int max8998_set_voltage_ldo_sel(struct regulator_dev *rdev, 218 unsigned selector) 219{ 220 struct max8998_data *max8998 = rdev_get_drvdata(rdev); 221 struct i2c_client *i2c = max8998->iodev->i2c; 222 int reg, shift = 0, mask, ret; 223 224 ret = max8998_get_voltage_register(rdev, ®, &shift, &mask); 225 if (ret) 226 return ret; 227 228 ret = max8998_update_reg(i2c, reg, selector<<shift, mask<<shift); 229 230 return ret; 231} 232 233static inline void buck1_gpio_set(struct gpio_desc *gpio1, struct gpio_desc *gpio2, int v) 234{ 235 gpiod_set_value(gpio1, v & 0x1); 236 gpiod_set_value(gpio2, (v >> 1) & 0x1); 237} 238 239static inline void buck2_gpio_set(struct gpio_desc *gpio, int v) 240{ 241 gpiod_set_value(gpio, v & 0x1); 242} 243 244static int max8998_set_voltage_buck_sel(struct regulator_dev *rdev, 245 unsigned selector) 246{ 247 struct max8998_data *max8998 = rdev_get_drvdata(rdev); 248 struct max8998_platform_data *pdata = max8998->iodev->pdata; 249 struct i2c_client *i2c = max8998->iodev->i2c; 250 int buck = rdev_get_id(rdev); 251 int reg, shift = 0, mask, ret, j; 252 static u8 buck1_last_val; 253 254 ret = max8998_get_voltage_register(rdev, ®, &shift, &mask); 255 if (ret) 256 return ret; 257 258 switch (buck) { 259 case MAX8998_BUCK1: 260 dev_dbg(max8998->dev, 261 "BUCK1, selector:%d, buck1_vol1:%d, buck1_vol2:%d\n" 262 "buck1_vol3:%d, buck1_vol4:%d\n", 263 selector, max8998->buck1_vol[0], max8998->buck1_vol[1], 264 max8998->buck1_vol[2], max8998->buck1_vol[3]); 265 266 if (max8998->buck1_gpio1 && max8998->buck1_gpio2) { 267 268 /* check if requested voltage */ 269 /* value is already defined */ 270 for (j = 0; j < ARRAY_SIZE(max8998->buck1_vol); j++) { 271 if (max8998->buck1_vol[j] == selector) { 272 max8998->buck1_idx = j; 273 buck1_gpio_set(max8998->buck1_gpio1, 274 max8998->buck1_gpio2, j); 275 goto buck1_exit; 276 } 277 } 278 279 if (pdata->buck_voltage_lock) 280 return -EINVAL; 281 282 /* no predefine regulator found */ 283 max8998->buck1_idx = (buck1_last_val % 2) + 2; 284 dev_dbg(max8998->dev, "max8998->buck1_idx:%d\n", 285 max8998->buck1_idx); 286 max8998->buck1_vol[max8998->buck1_idx] = selector; 287 ret = max8998_get_voltage_register(rdev, ®, 288 &shift, 289 &mask); 290 ret = max8998_write_reg(i2c, reg, selector); 291 buck1_gpio_set(max8998->buck1_gpio1, 292 max8998->buck1_gpio2, max8998->buck1_idx); 293 buck1_last_val++; 294buck1_exit: 295 dev_dbg(max8998->dev, "%s: SET1:%d, SET2:%d\n", 296 i2c->name, gpiod_get_value(max8998->buck1_gpio1), 297 gpiod_get_value(max8998->buck1_gpio2)); 298 break; 299 } else { 300 ret = max8998_write_reg(i2c, reg, selector); 301 } 302 break; 303 304 case MAX8998_BUCK2: 305 dev_dbg(max8998->dev, 306 "BUCK2, selector:%d buck2_vol1:%d, buck2_vol2:%d\n", 307 selector, max8998->buck2_vol[0], max8998->buck2_vol[1]); 308 if (max8998->buck2_gpio) { 309 /* check if requested voltage */ 310 /* value is already defined */ 311 for (j = 0; j < ARRAY_SIZE(max8998->buck2_vol); j++) { 312 if (max8998->buck2_vol[j] == selector) { 313 max8998->buck2_idx = j; 314 buck2_gpio_set(max8998->buck2_gpio, j); 315 goto buck2_exit; 316 } 317 } 318 319 if (pdata->buck_voltage_lock) 320 return -EINVAL; 321 322 max8998_get_voltage_register(rdev, 323 ®, &shift, &mask); 324 ret = max8998_write_reg(i2c, reg, selector); 325 max8998->buck2_vol[max8998->buck2_idx] = selector; 326 buck2_gpio_set(max8998->buck2_gpio, max8998->buck2_idx); 327buck2_exit: 328 dev_dbg(max8998->dev, "%s: SET3:%d\n", i2c->name, 329 gpiod_get_value(max8998->buck2_gpio)); 330 } else { 331 ret = max8998_write_reg(i2c, reg, selector); 332 } 333 break; 334 335 case MAX8998_BUCK3: 336 case MAX8998_BUCK4: 337 ret = max8998_update_reg(i2c, reg, selector<<shift, 338 mask<<shift); 339 break; 340 } 341 342 return ret; 343} 344 345static int max8998_set_voltage_buck_time_sel(struct regulator_dev *rdev, 346 unsigned int old_selector, 347 unsigned int new_selector) 348{ 349 struct max8998_data *max8998 = rdev_get_drvdata(rdev); 350 struct i2c_client *i2c = max8998->iodev->i2c; 351 int buck = rdev_get_id(rdev); 352 u8 val = 0; 353 int difference, ret; 354 355 if (buck < MAX8998_BUCK1 || buck > MAX8998_BUCK4) 356 return -EINVAL; 357 358 /* Voltage stabilization */ 359 ret = max8998_read_reg(i2c, MAX8998_REG_ONOFF4, &val); 360 if (ret) 361 return ret; 362 363 /* lp3974 hasn't got ENRAMP bit - ramp is assumed as true */ 364 /* MAX8998 has ENRAMP bit implemented, so test it*/ 365 if (max8998->iodev->type == TYPE_MAX8998 && !(val & MAX8998_ENRAMP)) 366 return 0; 367 368 difference = (new_selector - old_selector) * rdev->desc->uV_step / 1000; 369 if (difference > 0) 370 return DIV_ROUND_UP(difference, (val & 0x0f) + 1); 371 372 return 0; 373} 374 375static int max8998_set_current_limit(struct regulator_dev *rdev, 376 int min_uA, int max_uA) 377{ 378 struct max8998_data *max8998 = rdev_get_drvdata(rdev); 379 struct i2c_client *i2c = max8998->iodev->i2c; 380 unsigned int n_currents = rdev->desc->n_current_limits; 381 int i, sel = -1; 382 383 if (n_currents == 0) 384 return -EINVAL; 385 386 if (rdev->desc->curr_table) { 387 const unsigned int *curr_table = rdev->desc->curr_table; 388 bool ascend = curr_table[n_currents - 1] > curr_table[0]; 389 390 /* search for closest to maximum */ 391 if (ascend) { 392 for (i = n_currents - 1; i >= 0; i--) { 393 if (min_uA <= curr_table[i] && 394 curr_table[i] <= max_uA) { 395 sel = i; 396 break; 397 } 398 } 399 } else { 400 for (i = 0; i < n_currents; i++) { 401 if (min_uA <= curr_table[i] && 402 curr_table[i] <= max_uA) { 403 sel = i; 404 break; 405 } 406 } 407 } 408 } 409 410 if (sel < 0) 411 return -EINVAL; 412 413 sel <<= ffs(rdev->desc->csel_mask) - 1; 414 415 return max8998_update_reg(i2c, rdev->desc->csel_reg, 416 sel, rdev->desc->csel_mask); 417} 418 419static int max8998_get_current_limit(struct regulator_dev *rdev) 420{ 421 struct max8998_data *max8998 = rdev_get_drvdata(rdev); 422 struct i2c_client *i2c = max8998->iodev->i2c; 423 u8 val; 424 int ret; 425 426 ret = max8998_read_reg(i2c, rdev->desc->csel_reg, &val); 427 if (ret != 0) 428 return ret; 429 430 val &= rdev->desc->csel_mask; 431 val >>= ffs(rdev->desc->csel_mask) - 1; 432 433 if (rdev->desc->curr_table) { 434 if (val >= rdev->desc->n_current_limits) 435 return -EINVAL; 436 437 return rdev->desc->curr_table[val]; 438 } 439 440 return -EINVAL; 441} 442 443static const struct regulator_ops max8998_ldo_ops = { 444 .list_voltage = regulator_list_voltage_linear, 445 .map_voltage = regulator_map_voltage_linear, 446 .is_enabled = max8998_ldo_is_enabled, 447 .enable = max8998_ldo_enable, 448 .disable = max8998_ldo_disable, 449 .get_voltage_sel = max8998_get_voltage_sel, 450 .set_voltage_sel = max8998_set_voltage_ldo_sel, 451}; 452 453static const struct regulator_ops max8998_buck_ops = { 454 .list_voltage = regulator_list_voltage_linear, 455 .map_voltage = regulator_map_voltage_linear, 456 .is_enabled = max8998_ldo_is_enabled, 457 .enable = max8998_ldo_enable, 458 .disable = max8998_ldo_disable, 459 .get_voltage_sel = max8998_get_voltage_sel, 460 .set_voltage_sel = max8998_set_voltage_buck_sel, 461 .set_voltage_time_sel = max8998_set_voltage_buck_time_sel, 462}; 463 464static const struct regulator_ops max8998_charger_ops = { 465 .set_current_limit = max8998_set_current_limit, 466 .get_current_limit = max8998_get_current_limit, 467 .is_enabled = max8998_ldo_is_enabled_inverted, 468 /* Swapped as register is inverted */ 469 .enable = max8998_ldo_disable, 470 .disable = max8998_ldo_enable, 471}; 472 473static const struct regulator_ops max8998_others_ops = { 474 .is_enabled = max8998_ldo_is_enabled, 475 .enable = max8998_ldo_enable, 476 .disable = max8998_ldo_disable, 477}; 478 479#define MAX8998_LINEAR_REG(_name, _ops, _min, _step, _max) \ 480 { \ 481 .name = #_name, \ 482 .id = MAX8998_##_name, \ 483 .ops = _ops, \ 484 .min_uV = (_min), \ 485 .uV_step = (_step), \ 486 .n_voltages = ((_max) - (_min)) / (_step) + 1, \ 487 .type = REGULATOR_VOLTAGE, \ 488 .owner = THIS_MODULE, \ 489 } 490 491#define MAX8998_CURRENT_REG(_name, _ops, _table, _reg, _mask) \ 492 { \ 493 .name = #_name, \ 494 .id = MAX8998_##_name, \ 495 .ops = _ops, \ 496 .curr_table = _table, \ 497 .n_current_limits = ARRAY_SIZE(_table), \ 498 .csel_reg = _reg, \ 499 .csel_mask = _mask, \ 500 .type = REGULATOR_CURRENT, \ 501 .owner = THIS_MODULE, \ 502 } 503 504#define MAX8998_OTHERS_REG(_name, _id) \ 505 { \ 506 .name = #_name, \ 507 .id = _id, \ 508 .ops = &max8998_others_ops, \ 509 .type = REGULATOR_VOLTAGE, \ 510 .owner = THIS_MODULE, \ 511 } 512 513static const struct regulator_desc regulators[] = { 514 MAX8998_LINEAR_REG(LDO2, &max8998_ldo_ops, 800000, 50000, 1300000), 515 MAX8998_LINEAR_REG(LDO3, &max8998_ldo_ops, 800000, 50000, 1300000), 516 MAX8998_LINEAR_REG(LDO4, &max8998_ldo_ops, 1600000, 100000, 3600000), 517 MAX8998_LINEAR_REG(LDO5, &max8998_ldo_ops, 1600000, 100000, 3600000), 518 MAX8998_LINEAR_REG(LDO6, &max8998_ldo_ops, 1600000, 100000, 3600000), 519 MAX8998_LINEAR_REG(LDO7, &max8998_ldo_ops, 1600000, 100000, 3600000), 520 MAX8998_LINEAR_REG(LDO8, &max8998_ldo_ops, 3000000, 100000, 3600000), 521 MAX8998_LINEAR_REG(LDO9, &max8998_ldo_ops, 2800000, 100000, 3100000), 522 MAX8998_LINEAR_REG(LDO10, &max8998_ldo_ops, 950000, 50000, 1300000), 523 MAX8998_LINEAR_REG(LDO11, &max8998_ldo_ops, 1600000, 100000, 3600000), 524 MAX8998_LINEAR_REG(LDO12, &max8998_ldo_ops, 800000, 100000, 3300000), 525 MAX8998_LINEAR_REG(LDO13, &max8998_ldo_ops, 800000, 100000, 3300000), 526 MAX8998_LINEAR_REG(LDO14, &max8998_ldo_ops, 1200000, 100000, 3300000), 527 MAX8998_LINEAR_REG(LDO15, &max8998_ldo_ops, 1200000, 100000, 3300000), 528 MAX8998_LINEAR_REG(LDO16, &max8998_ldo_ops, 1600000, 100000, 3600000), 529 MAX8998_LINEAR_REG(LDO17, &max8998_ldo_ops, 1600000, 100000, 3600000), 530 MAX8998_LINEAR_REG(BUCK1, &max8998_buck_ops, 750000, 25000, 1525000), 531 MAX8998_LINEAR_REG(BUCK2, &max8998_buck_ops, 750000, 25000, 1525000), 532 MAX8998_LINEAR_REG(BUCK3, &max8998_buck_ops, 1600000, 100000, 3600000), 533 MAX8998_LINEAR_REG(BUCK4, &max8998_buck_ops, 800000, 100000, 2300000), 534 MAX8998_OTHERS_REG(EN32KHz-AP, MAX8998_EN32KHZ_AP), 535 MAX8998_OTHERS_REG(EN32KHz-CP, MAX8998_EN32KHZ_CP), 536 MAX8998_OTHERS_REG(ENVICHG, MAX8998_ENVICHG), 537 MAX8998_OTHERS_REG(ESAFEOUT1, MAX8998_ESAFEOUT1), 538 MAX8998_OTHERS_REG(ESAFEOUT2, MAX8998_ESAFEOUT2), 539 MAX8998_CURRENT_REG(CHARGER, &max8998_charger_ops, 540 charger_current_table, MAX8998_REG_CHGR1, 0x7), 541}; 542 543static int max8998_pmic_dt_parse_pdata(struct max8998_dev *iodev, 544 struct max8998_platform_data *pdata) 545{ 546 struct device_node *pmic_np = iodev->dev->of_node; 547 struct device_node *regulators_np, *reg_np; 548 struct max8998_regulator_data *rdata; 549 unsigned int i; 550 int ret; 551 552 regulators_np = of_get_child_by_name(pmic_np, "regulators"); 553 if (!regulators_np) { 554 dev_err(iodev->dev, "could not find regulators sub-node\n"); 555 return -EINVAL; 556 } 557 558 /* count the number of regulators to be supported in pmic */ 559 pdata->num_regulators = of_get_child_count(regulators_np); 560 561 rdata = devm_kcalloc(iodev->dev, 562 pdata->num_regulators, sizeof(*rdata), 563 GFP_KERNEL); 564 if (!rdata) { 565 of_node_put(regulators_np); 566 return -ENOMEM; 567 } 568 569 pdata->regulators = rdata; 570 for (i = 0; i < ARRAY_SIZE(regulators); ++i) { 571 reg_np = of_get_child_by_name(regulators_np, 572 regulators[i].name); 573 if (!reg_np) 574 continue; 575 576 rdata->id = regulators[i].id; 577 rdata->initdata = of_get_regulator_init_data(iodev->dev, 578 reg_np, 579 ®ulators[i]); 580 rdata->reg_node = reg_np; 581 ++rdata; 582 } 583 pdata->num_regulators = rdata - pdata->regulators; 584 585 of_node_put(reg_np); 586 of_node_put(regulators_np); 587 588 pdata->buck_voltage_lock = of_property_read_bool(pmic_np, "max8998,pmic-buck-voltage-lock"); 589 590 ret = of_property_read_u32(pmic_np, 591 "max8998,pmic-buck1-default-dvs-idx", 592 &pdata->buck1_default_idx); 593 if (!ret && pdata->buck1_default_idx >= 4) { 594 pdata->buck1_default_idx = 0; 595 dev_warn(iodev->dev, "invalid value for default dvs index, using 0 instead\n"); 596 } 597 598 ret = of_property_read_u32(pmic_np, 599 "max8998,pmic-buck2-default-dvs-idx", 600 &pdata->buck2_default_idx); 601 if (!ret && pdata->buck2_default_idx >= 2) { 602 pdata->buck2_default_idx = 0; 603 dev_warn(iodev->dev, "invalid value for default dvs index, using 0 instead\n"); 604 } 605 606 ret = of_property_read_u32_array(pmic_np, 607 "max8998,pmic-buck1-dvs-voltage", 608 pdata->buck1_voltage, 609 ARRAY_SIZE(pdata->buck1_voltage)); 610 if (ret) { 611 dev_err(iodev->dev, "buck1 voltages not specified\n"); 612 return -EINVAL; 613 } 614 615 ret = of_property_read_u32_array(pmic_np, 616 "max8998,pmic-buck2-dvs-voltage", 617 pdata->buck2_voltage, 618 ARRAY_SIZE(pdata->buck2_voltage)); 619 if (ret) { 620 dev_err(iodev->dev, "buck2 voltages not specified\n"); 621 return -EINVAL; 622 } 623 624 return 0; 625} 626 627static int max8998_pmic_probe(struct platform_device *pdev) 628{ 629 struct max8998_dev *iodev = dev_get_drvdata(pdev->dev.parent); 630 struct max8998_platform_data *pdata = iodev->pdata; 631 struct regulator_config config = { }; 632 struct regulator_dev *rdev; 633 struct max8998_data *max8998; 634 struct i2c_client *i2c; 635 enum gpiod_flags flags; 636 int i, ret; 637 unsigned int v; 638 639 if (!pdata) { 640 dev_err(pdev->dev.parent, "No platform init data supplied\n"); 641 return -ENODEV; 642 } 643 644 if (IS_ENABLED(CONFIG_OF) && iodev->dev->of_node) { 645 ret = max8998_pmic_dt_parse_pdata(iodev, pdata); 646 if (ret) 647 return ret; 648 } 649 650 max8998 = devm_kzalloc(&pdev->dev, sizeof(struct max8998_data), 651 GFP_KERNEL); 652 if (!max8998) 653 return -ENOMEM; 654 655 max8998->dev = &pdev->dev; 656 max8998->iodev = iodev; 657 max8998->num_regulators = pdata->num_regulators; 658 platform_set_drvdata(pdev, max8998); 659 i2c = max8998->iodev->i2c; 660 661 max8998->buck1_idx = pdata->buck1_default_idx; 662 max8998->buck2_idx = pdata->buck2_default_idx; 663 664 /* Check if MAX8998 voltage selection GPIOs are defined */ 665 flags = (max8998->buck1_idx & BIT(0)) ? GPIOD_OUT_HIGH : GPIOD_OUT_LOW; 666 max8998->buck1_gpio1 = devm_gpiod_get_index_optional(iodev->dev, 667 "max8998,pmic-buck1-dvs", 668 0, 669 flags); 670 if (IS_ERR(max8998->buck1_gpio1)) 671 return dev_err_probe(&pdev->dev, PTR_ERR(max8998->buck1_gpio1), 672 "could not get BUCK1 GPIO1\n"); 673 gpiod_set_consumer_name(max8998->buck1_gpio1, "MAX8998 BUCK1_SET1"); 674 675 flags = (max8998->buck1_idx & BIT(1)) ? GPIOD_OUT_HIGH : GPIOD_OUT_LOW; 676 max8998->buck1_gpio2 = devm_gpiod_get_index_optional(iodev->dev, 677 "max8998,pmic-buck1-dvs", 678 1, 679 flags); 680 if (IS_ERR(max8998->buck1_gpio2)) 681 return dev_err_probe(&pdev->dev, PTR_ERR(max8998->buck1_gpio2), 682 "could not get BUCK1 GPIO2\n"); 683 gpiod_set_consumer_name(max8998->buck1_gpio1, "MAX8998 BUCK1_SET2"); 684 685 flags = (max8998->buck2_idx & BIT(0)) ? GPIOD_OUT_HIGH : GPIOD_OUT_LOW; 686 max8998->buck2_gpio = devm_gpiod_get_index_optional(iodev->dev, 687 "max8998,pmic-buck2-dvs", 688 0, 689 flags); 690 if (IS_ERR(max8998->buck2_gpio)) 691 return dev_err_probe(&pdev->dev, PTR_ERR(max8998->buck2_gpio), 692 "could not get BUCK2 GPIO\n"); 693 gpiod_set_consumer_name(max8998->buck1_gpio1, "MAX8998 BUCK2_SET3"); 694 695 if (max8998->buck1_gpio1 && max8998->buck1_gpio2) { 696 /* Set predefined values for BUCK1 registers */ 697 for (v = 0; v < ARRAY_SIZE(pdata->buck1_voltage); ++v) { 698 int index = MAX8998_BUCK1 - MAX8998_LDO2; 699 700 i = 0; 701 while (regulators[index].min_uV + 702 regulators[index].uV_step * i 703 < pdata->buck1_voltage[v]) 704 i++; 705 706 max8998->buck1_vol[v] = i; 707 ret = max8998_write_reg(i2c, 708 MAX8998_REG_BUCK1_VOLTAGE1 + v, i); 709 if (ret) 710 return ret; 711 } 712 } 713 714 if (max8998->buck2_gpio) { 715 /* Set predefined values for BUCK2 registers */ 716 for (v = 0; v < ARRAY_SIZE(pdata->buck2_voltage); ++v) { 717 int index = MAX8998_BUCK2 - MAX8998_LDO2; 718 719 i = 0; 720 while (regulators[index].min_uV + 721 regulators[index].uV_step * i 722 < pdata->buck2_voltage[v]) 723 i++; 724 725 max8998->buck2_vol[v] = i; 726 ret = max8998_write_reg(i2c, 727 MAX8998_REG_BUCK2_VOLTAGE1 + v, i); 728 if (ret) 729 return ret; 730 } 731 } 732 733 for (i = 0; i < pdata->num_regulators; i++) { 734 int index = pdata->regulators[i].id - MAX8998_LDO2; 735 736 config.dev = max8998->dev; 737 config.of_node = pdata->regulators[i].reg_node; 738 config.init_data = pdata->regulators[i].initdata; 739 config.driver_data = max8998; 740 741 rdev = devm_regulator_register(&pdev->dev, ®ulators[index], 742 &config); 743 if (IS_ERR(rdev)) { 744 ret = PTR_ERR(rdev); 745 dev_err(max8998->dev, "regulator %s init failed (%d)\n", 746 regulators[index].name, ret); 747 return ret; 748 } 749 } 750 751 return 0; 752} 753 754static const struct platform_device_id max8998_pmic_id[] = { 755 { "max8998-pmic", TYPE_MAX8998 }, 756 { "lp3974-pmic", TYPE_LP3974 }, 757 { } 758}; 759MODULE_DEVICE_TABLE(platform, max8998_pmic_id); 760 761static struct platform_driver max8998_pmic_driver = { 762 .driver = { 763 .name = "max8998-pmic", 764 .probe_type = PROBE_PREFER_ASYNCHRONOUS, 765 }, 766 .probe = max8998_pmic_probe, 767 .id_table = max8998_pmic_id, 768}; 769 770static int __init max8998_pmic_init(void) 771{ 772 return platform_driver_register(&max8998_pmic_driver); 773} 774subsys_initcall(max8998_pmic_init); 775 776static void __exit max8998_pmic_cleanup(void) 777{ 778 platform_driver_unregister(&max8998_pmic_driver); 779} 780module_exit(max8998_pmic_cleanup); 781 782MODULE_DESCRIPTION("MAXIM 8998 voltage regulator driver"); 783MODULE_AUTHOR("Kyungmin Park <kyungmin.park@samsung.com>"); 784MODULE_LICENSE("GPL"); 785