1/* 2 * max8998.c - Voltage regulator driver for the Maxim 8998 3 * 4 * Copyright (C) 2009-2010 Samsung Electronics 5 * Kyungmin Park <kyungmin.park@samsung.com> 6 * Marek Szyprowski <m.szyprowski@samsung.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 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the Free Software 20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 21 */ 22 23#include <linux/module.h> 24#include <linux/init.h> 25#include <linux/i2c.h> 26#include <linux/err.h> 27#include <linux/gpio.h> 28#include <linux/slab.h> 29#include <linux/interrupt.h> 30#include <linux/mutex.h> 31#include <linux/of.h> 32#include <linux/of_gpio.h> 33#include <linux/platform_device.h> 34#include <linux/regulator/driver.h> 35#include <linux/regulator/of_regulator.h> 36#include <linux/mfd/max8998.h> 37#include <linux/mfd/max8998-private.h> 38 39struct max8998_data { 40 struct device *dev; 41 struct max8998_dev *iodev; 42 int num_regulators; 43 u8 buck1_vol[4]; /* voltages for selection */ 44 u8 buck2_vol[2]; 45 unsigned int buck1_idx; /* index to last changed voltage */ 46 /* value in a set */ 47 unsigned int buck2_idx; 48}; 49 50struct voltage_map_desc { 51 int min; 52 int max; 53 int step; 54}; 55 56/* Voltage maps in uV*/ 57static const struct voltage_map_desc ldo23_voltage_map_desc = { 58 .min = 800000, .step = 50000, .max = 1300000, 59}; 60static const struct voltage_map_desc ldo456711_voltage_map_desc = { 61 .min = 1600000, .step = 100000, .max = 3600000, 62}; 63static const struct voltage_map_desc ldo8_voltage_map_desc = { 64 .min = 3000000, .step = 100000, .max = 3600000, 65}; 66static const struct voltage_map_desc ldo9_voltage_map_desc = { 67 .min = 2800000, .step = 100000, .max = 3100000, 68}; 69static const struct voltage_map_desc ldo10_voltage_map_desc = { 70 .min = 950000, .step = 50000, .max = 1300000, 71}; 72static const struct voltage_map_desc ldo1213_voltage_map_desc = { 73 .min = 800000, .step = 100000, .max = 3300000, 74}; 75static const struct voltage_map_desc ldo1415_voltage_map_desc = { 76 .min = 1200000, .step = 100000, .max = 3300000, 77}; 78static const struct voltage_map_desc ldo1617_voltage_map_desc = { 79 .min = 1600000, .step = 100000, .max = 3600000, 80}; 81static const struct voltage_map_desc buck12_voltage_map_desc = { 82 .min = 750000, .step = 25000, .max = 1525000, 83}; 84static const struct voltage_map_desc buck3_voltage_map_desc = { 85 .min = 1600000, .step = 100000, .max = 3600000, 86}; 87static const struct voltage_map_desc buck4_voltage_map_desc = { 88 .min = 800000, .step = 100000, .max = 2300000, 89}; 90 91static const struct voltage_map_desc *ldo_voltage_map[] = { 92 NULL, 93 NULL, 94 &ldo23_voltage_map_desc, /* LDO2 */ 95 &ldo23_voltage_map_desc, /* LDO3 */ 96 &ldo456711_voltage_map_desc, /* LDO4 */ 97 &ldo456711_voltage_map_desc, /* LDO5 */ 98 &ldo456711_voltage_map_desc, /* LDO6 */ 99 &ldo456711_voltage_map_desc, /* LDO7 */ 100 &ldo8_voltage_map_desc, /* LDO8 */ 101 &ldo9_voltage_map_desc, /* LDO9 */ 102 &ldo10_voltage_map_desc, /* LDO10 */ 103 &ldo456711_voltage_map_desc, /* LDO11 */ 104 &ldo1213_voltage_map_desc, /* LDO12 */ 105 &ldo1213_voltage_map_desc, /* LDO13 */ 106 &ldo1415_voltage_map_desc, /* LDO14 */ 107 &ldo1415_voltage_map_desc, /* LDO15 */ 108 &ldo1617_voltage_map_desc, /* LDO16 */ 109 &ldo1617_voltage_map_desc, /* LDO17 */ 110 &buck12_voltage_map_desc, /* BUCK1 */ 111 &buck12_voltage_map_desc, /* BUCK2 */ 112 &buck3_voltage_map_desc, /* BUCK3 */ 113 &buck4_voltage_map_desc, /* BUCK4 */ 114}; 115 116static int max8998_get_enable_register(struct regulator_dev *rdev, 117 int *reg, int *shift) 118{ 119 int ldo = rdev_get_id(rdev); 120 121 switch (ldo) { 122 case MAX8998_LDO2 ... MAX8998_LDO5: 123 *reg = MAX8998_REG_ONOFF1; 124 *shift = 3 - (ldo - MAX8998_LDO2); 125 break; 126 case MAX8998_LDO6 ... MAX8998_LDO13: 127 *reg = MAX8998_REG_ONOFF2; 128 *shift = 7 - (ldo - MAX8998_LDO6); 129 break; 130 case MAX8998_LDO14 ... MAX8998_LDO17: 131 *reg = MAX8998_REG_ONOFF3; 132 *shift = 7 - (ldo - MAX8998_LDO14); 133 break; 134 case MAX8998_BUCK1 ... MAX8998_BUCK4: 135 *reg = MAX8998_REG_ONOFF1; 136 *shift = 7 - (ldo - MAX8998_BUCK1); 137 break; 138 case MAX8998_EN32KHZ_AP ... MAX8998_ENVICHG: 139 *reg = MAX8998_REG_ONOFF4; 140 *shift = 7 - (ldo - MAX8998_EN32KHZ_AP); 141 break; 142 case MAX8998_ESAFEOUT1 ... MAX8998_ESAFEOUT2: 143 *reg = MAX8998_REG_CHGR2; 144 *shift = 7 - (ldo - MAX8998_ESAFEOUT1); 145 break; 146 default: 147 return -EINVAL; 148 } 149 150 return 0; 151} 152 153static int max8998_ldo_is_enabled(struct regulator_dev *rdev) 154{ 155 struct max8998_data *max8998 = rdev_get_drvdata(rdev); 156 struct i2c_client *i2c = max8998->iodev->i2c; 157 int ret, reg, shift = 8; 158 u8 val; 159 160 ret = max8998_get_enable_register(rdev, ®, &shift); 161 if (ret) 162 return ret; 163 164 ret = max8998_read_reg(i2c, reg, &val); 165 if (ret) 166 return ret; 167 168 return val & (1 << shift); 169} 170 171static int max8998_ldo_enable(struct regulator_dev *rdev) 172{ 173 struct max8998_data *max8998 = rdev_get_drvdata(rdev); 174 struct i2c_client *i2c = max8998->iodev->i2c; 175 int reg, shift = 8, ret; 176 177 ret = max8998_get_enable_register(rdev, ®, &shift); 178 if (ret) 179 return ret; 180 181 return max8998_update_reg(i2c, reg, 1<<shift, 1<<shift); 182} 183 184static int max8998_ldo_disable(struct regulator_dev *rdev) 185{ 186 struct max8998_data *max8998 = rdev_get_drvdata(rdev); 187 struct i2c_client *i2c = max8998->iodev->i2c; 188 int reg, shift = 8, ret; 189 190 ret = max8998_get_enable_register(rdev, ®, &shift); 191 if (ret) 192 return ret; 193 194 return max8998_update_reg(i2c, reg, 0, 1<<shift); 195} 196 197static int max8998_get_voltage_register(struct regulator_dev *rdev, 198 int *_reg, int *_shift, int *_mask) 199{ 200 int ldo = rdev_get_id(rdev); 201 struct max8998_data *max8998 = rdev_get_drvdata(rdev); 202 int reg, shift = 0, mask = 0xff; 203 204 switch (ldo) { 205 case MAX8998_LDO2 ... MAX8998_LDO3: 206 reg = MAX8998_REG_LDO2_LDO3; 207 mask = 0xf; 208 if (ldo == MAX8998_LDO2) 209 shift = 4; 210 else 211 shift = 0; 212 break; 213 case MAX8998_LDO4 ... MAX8998_LDO7: 214 reg = MAX8998_REG_LDO4 + (ldo - MAX8998_LDO4); 215 break; 216 case MAX8998_LDO8 ... MAX8998_LDO9: 217 reg = MAX8998_REG_LDO8_LDO9; 218 mask = 0xf; 219 if (ldo == MAX8998_LDO8) 220 shift = 4; 221 else 222 shift = 0; 223 break; 224 case MAX8998_LDO10 ... MAX8998_LDO11: 225 reg = MAX8998_REG_LDO10_LDO11; 226 if (ldo == MAX8998_LDO10) { 227 shift = 5; 228 mask = 0x7; 229 } else { 230 shift = 0; 231 mask = 0x1f; 232 } 233 break; 234 case MAX8998_LDO12 ... MAX8998_LDO17: 235 reg = MAX8998_REG_LDO12 + (ldo - MAX8998_LDO12); 236 break; 237 case MAX8998_BUCK1: 238 reg = MAX8998_REG_BUCK1_VOLTAGE1 + max8998->buck1_idx; 239 break; 240 case MAX8998_BUCK2: 241 reg = MAX8998_REG_BUCK2_VOLTAGE1 + max8998->buck2_idx; 242 break; 243 case MAX8998_BUCK3: 244 reg = MAX8998_REG_BUCK3; 245 break; 246 case MAX8998_BUCK4: 247 reg = MAX8998_REG_BUCK4; 248 break; 249 default: 250 return -EINVAL; 251 } 252 253 *_reg = reg; 254 *_shift = shift; 255 *_mask = mask; 256 257 return 0; 258} 259 260static int max8998_get_voltage_sel(struct regulator_dev *rdev) 261{ 262 struct max8998_data *max8998 = rdev_get_drvdata(rdev); 263 struct i2c_client *i2c = max8998->iodev->i2c; 264 int reg, shift = 0, mask, ret; 265 u8 val; 266 267 ret = max8998_get_voltage_register(rdev, ®, &shift, &mask); 268 if (ret) 269 return ret; 270 271 ret = max8998_read_reg(i2c, reg, &val); 272 if (ret) 273 return ret; 274 275 val >>= shift; 276 val &= mask; 277 278 return val; 279} 280 281static int max8998_set_voltage_ldo_sel(struct regulator_dev *rdev, 282 unsigned selector) 283{ 284 struct max8998_data *max8998 = rdev_get_drvdata(rdev); 285 struct i2c_client *i2c = max8998->iodev->i2c; 286 int reg, shift = 0, mask, ret; 287 288 ret = max8998_get_voltage_register(rdev, ®, &shift, &mask); 289 if (ret) 290 return ret; 291 292 ret = max8998_update_reg(i2c, reg, selector<<shift, mask<<shift); 293 294 return ret; 295} 296 297static inline void buck1_gpio_set(int gpio1, int gpio2, int v) 298{ 299 gpio_set_value(gpio1, v & 0x1); 300 gpio_set_value(gpio2, (v >> 1) & 0x1); 301} 302 303static inline void buck2_gpio_set(int gpio, int v) 304{ 305 gpio_set_value(gpio, v & 0x1); 306} 307 308static int max8998_set_voltage_buck_sel(struct regulator_dev *rdev, 309 unsigned selector) 310{ 311 struct max8998_data *max8998 = rdev_get_drvdata(rdev); 312 struct max8998_platform_data *pdata = 313 dev_get_platdata(max8998->iodev->dev); 314 struct i2c_client *i2c = max8998->iodev->i2c; 315 int buck = rdev_get_id(rdev); 316 int reg, shift = 0, mask, ret, j; 317 static u8 buck1_last_val; 318 319 ret = max8998_get_voltage_register(rdev, ®, &shift, &mask); 320 if (ret) 321 return ret; 322 323 switch (buck) { 324 case MAX8998_BUCK1: 325 dev_dbg(max8998->dev, 326 "BUCK1, selector:%d, buck1_vol1:%d, buck1_vol2:%d\n" 327 "buck1_vol3:%d, buck1_vol4:%d\n", 328 selector, max8998->buck1_vol[0], max8998->buck1_vol[1], 329 max8998->buck1_vol[2], max8998->buck1_vol[3]); 330 331 if (gpio_is_valid(pdata->buck1_set1) && 332 gpio_is_valid(pdata->buck1_set2)) { 333 334 /* check if requested voltage */ 335 /* value is already defined */ 336 for (j = 0; j < ARRAY_SIZE(max8998->buck1_vol); j++) { 337 if (max8998->buck1_vol[j] == selector) { 338 max8998->buck1_idx = j; 339 buck1_gpio_set(pdata->buck1_set1, 340 pdata->buck1_set2, j); 341 goto buck1_exit; 342 } 343 } 344 345 if (pdata->buck_voltage_lock) 346 return -EINVAL; 347 348 /* no predefine regulator found */ 349 max8998->buck1_idx = (buck1_last_val % 2) + 2; 350 dev_dbg(max8998->dev, "max8998->buck1_idx:%d\n", 351 max8998->buck1_idx); 352 max8998->buck1_vol[max8998->buck1_idx] = selector; 353 ret = max8998_get_voltage_register(rdev, ®, 354 &shift, 355 &mask); 356 ret = max8998_write_reg(i2c, reg, selector); 357 buck1_gpio_set(pdata->buck1_set1, 358 pdata->buck1_set2, max8998->buck1_idx); 359 buck1_last_val++; 360buck1_exit: 361 dev_dbg(max8998->dev, "%s: SET1:%d, SET2:%d\n", 362 i2c->name, gpio_get_value(pdata->buck1_set1), 363 gpio_get_value(pdata->buck1_set2)); 364 break; 365 } else { 366 ret = max8998_write_reg(i2c, reg, selector); 367 } 368 break; 369 370 case MAX8998_BUCK2: 371 dev_dbg(max8998->dev, 372 "BUCK2, selector:%d buck2_vol1:%d, buck2_vol2:%d\n", 373 selector, max8998->buck2_vol[0], max8998->buck2_vol[1]); 374 if (gpio_is_valid(pdata->buck2_set3)) { 375 376 /* check if requested voltage */ 377 /* value is already defined */ 378 for (j = 0; j < ARRAY_SIZE(max8998->buck2_vol); j++) { 379 if (max8998->buck2_vol[j] == selector) { 380 max8998->buck2_idx = j; 381 buck2_gpio_set(pdata->buck2_set3, j); 382 goto buck2_exit; 383 } 384 } 385 386 if (pdata->buck_voltage_lock) 387 return -EINVAL; 388 389 max8998_get_voltage_register(rdev, 390 ®, &shift, &mask); 391 ret = max8998_write_reg(i2c, reg, selector); 392 max8998->buck2_vol[max8998->buck2_idx] = selector; 393 buck2_gpio_set(pdata->buck2_set3, max8998->buck2_idx); 394buck2_exit: 395 dev_dbg(max8998->dev, "%s: SET3:%d\n", i2c->name, 396 gpio_get_value(pdata->buck2_set3)); 397 } else { 398 ret = max8998_write_reg(i2c, reg, selector); 399 } 400 break; 401 402 case MAX8998_BUCK3: 403 case MAX8998_BUCK4: 404 ret = max8998_update_reg(i2c, reg, selector<<shift, 405 mask<<shift); 406 break; 407 } 408 409 return ret; 410} 411 412static int max8998_set_voltage_buck_time_sel(struct regulator_dev *rdev, 413 unsigned int old_selector, 414 unsigned int new_selector) 415{ 416 struct max8998_data *max8998 = rdev_get_drvdata(rdev); 417 struct i2c_client *i2c = max8998->iodev->i2c; 418 const struct voltage_map_desc *desc; 419 int buck = rdev_get_id(rdev); 420 u8 val = 0; 421 int difference, ret; 422 423 if (buck < MAX8998_BUCK1 || buck > MAX8998_BUCK4) 424 return -EINVAL; 425 426 desc = ldo_voltage_map[buck]; 427 428 /* Voltage stabilization */ 429 ret = max8998_read_reg(i2c, MAX8998_REG_ONOFF4, &val); 430 if (ret) 431 return ret; 432 433 /* lp3974 hasn't got ENRAMP bit - ramp is assumed as true */ 434 /* MAX8998 has ENRAMP bit implemented, so test it*/ 435 if (max8998->iodev->type == TYPE_MAX8998 && !(val & MAX8998_ENRAMP)) 436 return 0; 437 438 difference = (new_selector - old_selector) * desc->step / 1000; 439 if (difference > 0) 440 return DIV_ROUND_UP(difference, (val & 0x0f) + 1); 441 442 return 0; 443} 444 445static struct regulator_ops max8998_ldo_ops = { 446 .list_voltage = regulator_list_voltage_linear, 447 .map_voltage = regulator_map_voltage_linear, 448 .is_enabled = max8998_ldo_is_enabled, 449 .enable = max8998_ldo_enable, 450 .disable = max8998_ldo_disable, 451 .get_voltage_sel = max8998_get_voltage_sel, 452 .set_voltage_sel = max8998_set_voltage_ldo_sel, 453}; 454 455static struct regulator_ops max8998_buck_ops = { 456 .list_voltage = regulator_list_voltage_linear, 457 .map_voltage = regulator_map_voltage_linear, 458 .is_enabled = max8998_ldo_is_enabled, 459 .enable = max8998_ldo_enable, 460 .disable = max8998_ldo_disable, 461 .get_voltage_sel = max8998_get_voltage_sel, 462 .set_voltage_sel = max8998_set_voltage_buck_sel, 463 .set_voltage_time_sel = max8998_set_voltage_buck_time_sel, 464}; 465 466static struct regulator_ops max8998_others_ops = { 467 .is_enabled = max8998_ldo_is_enabled, 468 .enable = max8998_ldo_enable, 469 .disable = max8998_ldo_disable, 470}; 471 472static struct regulator_desc regulators[] = { 473 { 474 .name = "LDO2", 475 .id = MAX8998_LDO2, 476 .ops = &max8998_ldo_ops, 477 .type = REGULATOR_VOLTAGE, 478 .owner = THIS_MODULE, 479 }, { 480 .name = "LDO3", 481 .id = MAX8998_LDO3, 482 .ops = &max8998_ldo_ops, 483 .type = REGULATOR_VOLTAGE, 484 .owner = THIS_MODULE, 485 }, { 486 .name = "LDO4", 487 .id = MAX8998_LDO4, 488 .ops = &max8998_ldo_ops, 489 .type = REGULATOR_VOLTAGE, 490 .owner = THIS_MODULE, 491 }, { 492 .name = "LDO5", 493 .id = MAX8998_LDO5, 494 .ops = &max8998_ldo_ops, 495 .type = REGULATOR_VOLTAGE, 496 .owner = THIS_MODULE, 497 }, { 498 .name = "LDO6", 499 .id = MAX8998_LDO6, 500 .ops = &max8998_ldo_ops, 501 .type = REGULATOR_VOLTAGE, 502 .owner = THIS_MODULE, 503 }, { 504 .name = "LDO7", 505 .id = MAX8998_LDO7, 506 .ops = &max8998_ldo_ops, 507 .type = REGULATOR_VOLTAGE, 508 .owner = THIS_MODULE, 509 }, { 510 .name = "LDO8", 511 .id = MAX8998_LDO8, 512 .ops = &max8998_ldo_ops, 513 .type = REGULATOR_VOLTAGE, 514 .owner = THIS_MODULE, 515 }, { 516 .name = "LDO9", 517 .id = MAX8998_LDO9, 518 .ops = &max8998_ldo_ops, 519 .type = REGULATOR_VOLTAGE, 520 .owner = THIS_MODULE, 521 }, { 522 .name = "LDO10", 523 .id = MAX8998_LDO10, 524 .ops = &max8998_ldo_ops, 525 .type = REGULATOR_VOLTAGE, 526 .owner = THIS_MODULE, 527 }, { 528 .name = "LDO11", 529 .id = MAX8998_LDO11, 530 .ops = &max8998_ldo_ops, 531 .type = REGULATOR_VOLTAGE, 532 .owner = THIS_MODULE, 533 }, { 534 .name = "LDO12", 535 .id = MAX8998_LDO12, 536 .ops = &max8998_ldo_ops, 537 .type = REGULATOR_VOLTAGE, 538 .owner = THIS_MODULE, 539 }, { 540 .name = "LDO13", 541 .id = MAX8998_LDO13, 542 .ops = &max8998_ldo_ops, 543 .type = REGULATOR_VOLTAGE, 544 .owner = THIS_MODULE, 545 }, { 546 .name = "LDO14", 547 .id = MAX8998_LDO14, 548 .ops = &max8998_ldo_ops, 549 .type = REGULATOR_VOLTAGE, 550 .owner = THIS_MODULE, 551 }, { 552 .name = "LDO15", 553 .id = MAX8998_LDO15, 554 .ops = &max8998_ldo_ops, 555 .type = REGULATOR_VOLTAGE, 556 .owner = THIS_MODULE, 557 }, { 558 .name = "LDO16", 559 .id = MAX8998_LDO16, 560 .ops = &max8998_ldo_ops, 561 .type = REGULATOR_VOLTAGE, 562 .owner = THIS_MODULE, 563 }, { 564 .name = "LDO17", 565 .id = MAX8998_LDO17, 566 .ops = &max8998_ldo_ops, 567 .type = REGULATOR_VOLTAGE, 568 .owner = THIS_MODULE, 569 }, { 570 .name = "BUCK1", 571 .id = MAX8998_BUCK1, 572 .ops = &max8998_buck_ops, 573 .type = REGULATOR_VOLTAGE, 574 .owner = THIS_MODULE, 575 }, { 576 .name = "BUCK2", 577 .id = MAX8998_BUCK2, 578 .ops = &max8998_buck_ops, 579 .type = REGULATOR_VOLTAGE, 580 .owner = THIS_MODULE, 581 }, { 582 .name = "BUCK3", 583 .id = MAX8998_BUCK3, 584 .ops = &max8998_buck_ops, 585 .type = REGULATOR_VOLTAGE, 586 .owner = THIS_MODULE, 587 }, { 588 .name = "BUCK4", 589 .id = MAX8998_BUCK4, 590 .ops = &max8998_buck_ops, 591 .type = REGULATOR_VOLTAGE, 592 .owner = THIS_MODULE, 593 }, { 594 .name = "EN32KHz-AP", 595 .id = MAX8998_EN32KHZ_AP, 596 .ops = &max8998_others_ops, 597 .type = REGULATOR_VOLTAGE, 598 .owner = THIS_MODULE, 599 }, { 600 .name = "EN32KHz-CP", 601 .id = MAX8998_EN32KHZ_CP, 602 .ops = &max8998_others_ops, 603 .type = REGULATOR_VOLTAGE, 604 .owner = THIS_MODULE, 605 }, { 606 .name = "ENVICHG", 607 .id = MAX8998_ENVICHG, 608 .ops = &max8998_others_ops, 609 .type = REGULATOR_VOLTAGE, 610 .owner = THIS_MODULE, 611 }, { 612 .name = "ESAFEOUT1", 613 .id = MAX8998_ESAFEOUT1, 614 .ops = &max8998_others_ops, 615 .type = REGULATOR_VOLTAGE, 616 .owner = THIS_MODULE, 617 }, { 618 .name = "ESAFEOUT2", 619 .id = MAX8998_ESAFEOUT2, 620 .ops = &max8998_others_ops, 621 .type = REGULATOR_VOLTAGE, 622 .owner = THIS_MODULE, 623 } 624}; 625 626static int max8998_pmic_dt_parse_dvs_gpio(struct max8998_dev *iodev, 627 struct max8998_platform_data *pdata, 628 struct device_node *pmic_np) 629{ 630 int gpio; 631 632 gpio = of_get_named_gpio(pmic_np, "max8998,pmic-buck1-dvs-gpios", 0); 633 if (!gpio_is_valid(gpio)) { 634 dev_err(iodev->dev, "invalid buck1 gpio[0]: %d\n", gpio); 635 return -EINVAL; 636 } 637 pdata->buck1_set1 = gpio; 638 639 gpio = of_get_named_gpio(pmic_np, "max8998,pmic-buck1-dvs-gpios", 1); 640 if (!gpio_is_valid(gpio)) { 641 dev_err(iodev->dev, "invalid buck1 gpio[1]: %d\n", gpio); 642 return -EINVAL; 643 } 644 pdata->buck1_set2 = gpio; 645 646 gpio = of_get_named_gpio(pmic_np, "max8998,pmic-buck2-dvs-gpio", 0); 647 if (!gpio_is_valid(gpio)) { 648 dev_err(iodev->dev, "invalid buck 2 gpio: %d\n", gpio); 649 return -EINVAL; 650 } 651 pdata->buck2_set3 = gpio; 652 653 return 0; 654} 655 656static int max8998_pmic_dt_parse_pdata(struct max8998_dev *iodev, 657 struct max8998_platform_data *pdata) 658{ 659 struct device_node *pmic_np = iodev->dev->of_node; 660 struct device_node *regulators_np, *reg_np; 661 struct max8998_regulator_data *rdata; 662 unsigned int i; 663 int ret; 664 665 regulators_np = of_get_child_by_name(pmic_np, "regulators"); 666 if (!regulators_np) { 667 dev_err(iodev->dev, "could not find regulators sub-node\n"); 668 return -EINVAL; 669 } 670 671 /* count the number of regulators to be supported in pmic */ 672 pdata->num_regulators = of_get_child_count(regulators_np); 673 674 rdata = devm_kzalloc(iodev->dev, sizeof(*rdata) * 675 pdata->num_regulators, GFP_KERNEL); 676 if (!rdata) { 677 of_node_put(regulators_np); 678 return -ENOMEM; 679 } 680 681 pdata->regulators = rdata; 682 for (i = 0; i < ARRAY_SIZE(regulators); ++i) { 683 reg_np = of_get_child_by_name(regulators_np, 684 regulators[i].name); 685 if (!reg_np) 686 continue; 687 688 rdata->id = regulators[i].id; 689 rdata->initdata = of_get_regulator_init_data( 690 iodev->dev, reg_np); 691 rdata->reg_node = reg_np; 692 ++rdata; 693 } 694 pdata->num_regulators = rdata - pdata->regulators; 695 696 of_node_put(reg_np); 697 of_node_put(regulators_np); 698 699 ret = max8998_pmic_dt_parse_dvs_gpio(iodev, pdata, pmic_np); 700 if (ret) 701 return -EINVAL; 702 703 if (of_find_property(pmic_np, "max8998,pmic-buck-voltage-lock", NULL)) 704 pdata->buck_voltage_lock = true; 705 706 ret = of_property_read_u32(pmic_np, 707 "max8998,pmic-buck1-default-dvs-idx", 708 &pdata->buck1_default_idx); 709 if (!ret && pdata->buck1_default_idx >= 4) { 710 pdata->buck1_default_idx = 0; 711 dev_warn(iodev->dev, "invalid value for default dvs index, using 0 instead\n"); 712 } 713 714 ret = of_property_read_u32(pmic_np, 715 "max8998,pmic-buck2-default-dvs-idx", 716 &pdata->buck2_default_idx); 717 if (!ret && pdata->buck2_default_idx >= 2) { 718 pdata->buck2_default_idx = 0; 719 dev_warn(iodev->dev, "invalid value for default dvs index, using 0 instead\n"); 720 } 721 722 ret = of_property_read_u32_array(pmic_np, 723 "max8998,pmic-buck1-dvs-voltage", 724 pdata->buck1_voltage, 725 ARRAY_SIZE(pdata->buck1_voltage)); 726 if (ret) { 727 dev_err(iodev->dev, "buck1 voltages not specified\n"); 728 return -EINVAL; 729 } 730 731 ret = of_property_read_u32_array(pmic_np, 732 "max8998,pmic-buck2-dvs-voltage", 733 pdata->buck2_voltage, 734 ARRAY_SIZE(pdata->buck2_voltage)); 735 if (ret) { 736 dev_err(iodev->dev, "buck2 voltages not specified\n"); 737 return -EINVAL; 738 } 739 740 return 0; 741} 742 743static int max8998_pmic_probe(struct platform_device *pdev) 744{ 745 struct max8998_dev *iodev = dev_get_drvdata(pdev->dev.parent); 746 struct max8998_platform_data *pdata = iodev->pdata; 747 struct regulator_config config = { }; 748 struct regulator_dev *rdev; 749 struct max8998_data *max8998; 750 struct i2c_client *i2c; 751 int i, ret; 752 unsigned int v; 753 754 if (!pdata) { 755 dev_err(pdev->dev.parent, "No platform init data supplied\n"); 756 return -ENODEV; 757 } 758 759 if (IS_ENABLED(CONFIG_OF) && iodev->dev->of_node) { 760 ret = max8998_pmic_dt_parse_pdata(iodev, pdata); 761 if (ret) 762 return ret; 763 } 764 765 max8998 = devm_kzalloc(&pdev->dev, sizeof(struct max8998_data), 766 GFP_KERNEL); 767 if (!max8998) 768 return -ENOMEM; 769 770 max8998->dev = &pdev->dev; 771 max8998->iodev = iodev; 772 max8998->num_regulators = pdata->num_regulators; 773 platform_set_drvdata(pdev, max8998); 774 i2c = max8998->iodev->i2c; 775 776 max8998->buck1_idx = pdata->buck1_default_idx; 777 max8998->buck2_idx = pdata->buck2_default_idx; 778 779 /* NOTE: */ 780 /* For unused GPIO NOT marked as -1 (thereof equal to 0) WARN_ON */ 781 /* will be displayed */ 782 783 /* Check if MAX8998 voltage selection GPIOs are defined */ 784 if (gpio_is_valid(pdata->buck1_set1) && 785 gpio_is_valid(pdata->buck1_set2)) { 786 /* Check if SET1 is not equal to 0 */ 787 if (!pdata->buck1_set1) { 788 dev_err(&pdev->dev, 789 "MAX8998 SET1 GPIO defined as 0 !\n"); 790 WARN_ON(!pdata->buck1_set1); 791 return -EIO; 792 } 793 /* Check if SET2 is not equal to 0 */ 794 if (!pdata->buck1_set2) { 795 dev_err(&pdev->dev, 796 "MAX8998 SET2 GPIO defined as 0 !\n"); 797 WARN_ON(!pdata->buck1_set2); 798 return -EIO; 799 } 800 801 gpio_request(pdata->buck1_set1, "MAX8998 BUCK1_SET1"); 802 gpio_direction_output(pdata->buck1_set1, 803 max8998->buck1_idx & 0x1); 804 805 806 gpio_request(pdata->buck1_set2, "MAX8998 BUCK1_SET2"); 807 gpio_direction_output(pdata->buck1_set2, 808 (max8998->buck1_idx >> 1) & 0x1); 809 810 /* Set predefined values for BUCK1 registers */ 811 for (v = 0; v < ARRAY_SIZE(pdata->buck1_voltage); ++v) { 812 i = 0; 813 while (buck12_voltage_map_desc.min + 814 buck12_voltage_map_desc.step*i 815 < pdata->buck1_voltage[v]) 816 i++; 817 818 max8998->buck1_vol[v] = i; 819 ret = max8998_write_reg(i2c, 820 MAX8998_REG_BUCK1_VOLTAGE1 + v, i); 821 if (ret) 822 return ret; 823 } 824 } 825 826 if (gpio_is_valid(pdata->buck2_set3)) { 827 /* Check if SET3 is not equal to 0 */ 828 if (!pdata->buck2_set3) { 829 dev_err(&pdev->dev, 830 "MAX8998 SET3 GPIO defined as 0 !\n"); 831 WARN_ON(!pdata->buck2_set3); 832 return -EIO; 833 } 834 gpio_request(pdata->buck2_set3, "MAX8998 BUCK2_SET3"); 835 gpio_direction_output(pdata->buck2_set3, 836 max8998->buck2_idx & 0x1); 837 838 /* Set predefined values for BUCK2 registers */ 839 for (v = 0; v < ARRAY_SIZE(pdata->buck2_voltage); ++v) { 840 i = 0; 841 while (buck12_voltage_map_desc.min + 842 buck12_voltage_map_desc.step*i 843 < pdata->buck2_voltage[v]) 844 i++; 845 846 max8998->buck2_vol[v] = i; 847 ret = max8998_write_reg(i2c, 848 MAX8998_REG_BUCK2_VOLTAGE1 + v, i); 849 if (ret) 850 return ret; 851 } 852 } 853 854 for (i = 0; i < pdata->num_regulators; i++) { 855 const struct voltage_map_desc *desc; 856 int id = pdata->regulators[i].id; 857 int index = id - MAX8998_LDO2; 858 859 desc = ldo_voltage_map[id]; 860 if (desc && regulators[index].ops != &max8998_others_ops) { 861 int count = (desc->max - desc->min) / desc->step + 1; 862 863 regulators[index].n_voltages = count; 864 regulators[index].min_uV = desc->min; 865 regulators[index].uV_step = desc->step; 866 } 867 868 config.dev = max8998->dev; 869 config.of_node = pdata->regulators[i].reg_node; 870 config.init_data = pdata->regulators[i].initdata; 871 config.driver_data = max8998; 872 873 rdev = devm_regulator_register(&pdev->dev, ®ulators[index], 874 &config); 875 if (IS_ERR(rdev)) { 876 ret = PTR_ERR(rdev); 877 dev_err(max8998->dev, "regulator %s init failed (%d)\n", 878 regulators[index].name, ret); 879 return ret; 880 } 881 } 882 883 884 return 0; 885} 886 887static const struct platform_device_id max8998_pmic_id[] = { 888 { "max8998-pmic", TYPE_MAX8998 }, 889 { "lp3974-pmic", TYPE_LP3974 }, 890 { } 891}; 892MODULE_DEVICE_TABLE(platform, max8998_pmic_id); 893 894static struct platform_driver max8998_pmic_driver = { 895 .driver = { 896 .name = "max8998-pmic", 897 .owner = THIS_MODULE, 898 }, 899 .probe = max8998_pmic_probe, 900 .id_table = max8998_pmic_id, 901}; 902 903static int __init max8998_pmic_init(void) 904{ 905 return platform_driver_register(&max8998_pmic_driver); 906} 907subsys_initcall(max8998_pmic_init); 908 909static void __exit max8998_pmic_cleanup(void) 910{ 911 platform_driver_unregister(&max8998_pmic_driver); 912} 913module_exit(max8998_pmic_cleanup); 914 915MODULE_DESCRIPTION("MAXIM 8998 voltage regulator driver"); 916MODULE_AUTHOR("Kyungmin Park <kyungmin.park@samsung.com>"); 917MODULE_LICENSE("GPL"); 918