diff options
-rw-r--r-- | drivers/mfd/pcf50633-core.c | 2 | ||||
-rw-r--r-- | drivers/regulator/Kconfig | 9 | ||||
-rw-r--r-- | drivers/regulator/Makefile | 1 | ||||
-rw-r--r-- | drivers/regulator/db8500-prcmu.c | 20 | ||||
-rw-r--r-- | drivers/regulator/gpio-regulator.c | 17 | ||||
-rw-r--r-- | drivers/regulator/lp3971.c | 43 | ||||
-rw-r--r-- | drivers/regulator/lp3972.c | 41 | ||||
-rw-r--r-- | drivers/regulator/max14577.c | 273 | ||||
-rw-r--r-- | drivers/regulator/max77693.c | 1 | ||||
-rw-r--r-- | drivers/regulator/mc13892-regulator.c | 24 | ||||
-rw-r--r-- | drivers/regulator/pcf50633-regulator.c | 2 | ||||
-rw-r--r-- | drivers/regulator/pfuze100-regulator.c | 39 |
12 files changed, 333 insertions, 139 deletions
diff --git a/drivers/mfd/pcf50633-core.c b/drivers/mfd/pcf50633-core.c index 6841d6805fd6..41ab5e34d2ac 100644 --- a/drivers/mfd/pcf50633-core.c +++ b/drivers/mfd/pcf50633-core.c | |||
@@ -245,7 +245,7 @@ static int pcf50633_probe(struct i2c_client *client, | |||
245 | for (i = 0; i < PCF50633_NUM_REGULATORS; i++) { | 245 | for (i = 0; i < PCF50633_NUM_REGULATORS; i++) { |
246 | struct platform_device *pdev; | 246 | struct platform_device *pdev; |
247 | 247 | ||
248 | pdev = platform_device_alloc("pcf50633-regltr", i); | 248 | pdev = platform_device_alloc("pcf50633-regulator", i); |
249 | if (!pdev) { | 249 | if (!pdev) { |
250 | dev_err(pcf->dev, "Cannot create regulator %d\n", i); | 250 | dev_err(pcf->dev, "Cannot create regulator %d\n", i); |
251 | continue; | 251 | continue; |
diff --git a/drivers/regulator/Kconfig b/drivers/regulator/Kconfig index 63bc1bab37e3..77711d4bd377 100644 --- a/drivers/regulator/Kconfig +++ b/drivers/regulator/Kconfig | |||
@@ -257,6 +257,13 @@ config REGULATOR_LP8788 | |||
257 | help | 257 | help |
258 | This driver supports LP8788 voltage regulator chip. | 258 | This driver supports LP8788 voltage regulator chip. |
259 | 259 | ||
260 | config REGULATOR_MAX14577 | ||
261 | tristate "Maxim 14577 regulator" | ||
262 | depends on MFD_MAX14577 | ||
263 | help | ||
264 | This driver controls a Maxim 14577 regulator via I2C bus. | ||
265 | The regulators include safeout LDO and current regulator 'CHARGER'. | ||
266 | |||
260 | config REGULATOR_MAX1586 | 267 | config REGULATOR_MAX1586 |
261 | tristate "Maxim 1586/1587 voltage regulator" | 268 | tristate "Maxim 1586/1587 voltage regulator" |
262 | depends on I2C | 269 | depends on I2C |
@@ -392,7 +399,7 @@ config REGULATOR_PCF50633 | |||
392 | on PCF50633 | 399 | on PCF50633 |
393 | 400 | ||
394 | config REGULATOR_PFUZE100 | 401 | config REGULATOR_PFUZE100 |
395 | tristate "Support regulators on Freescale PFUZE100 PMIC" | 402 | tristate "Freescale PFUZE100 regulator driver" |
396 | depends on I2C | 403 | depends on I2C |
397 | select REGMAP_I2C | 404 | select REGMAP_I2C |
398 | help | 405 | help |
diff --git a/drivers/regulator/Makefile b/drivers/regulator/Makefile index 3bb3a5591b95..979f9ddcf259 100644 --- a/drivers/regulator/Makefile +++ b/drivers/regulator/Makefile | |||
@@ -36,6 +36,7 @@ obj-$(CONFIG_REGULATOR_LP872X) += lp872x.o | |||
36 | obj-$(CONFIG_REGULATOR_LP8788) += lp8788-buck.o | 36 | obj-$(CONFIG_REGULATOR_LP8788) += lp8788-buck.o |
37 | obj-$(CONFIG_REGULATOR_LP8788) += lp8788-ldo.o | 37 | obj-$(CONFIG_REGULATOR_LP8788) += lp8788-ldo.o |
38 | obj-$(CONFIG_REGULATOR_LP8755) += lp8755.o | 38 | obj-$(CONFIG_REGULATOR_LP8755) += lp8755.o |
39 | obj-$(CONFIG_REGULATOR_MAX14577) += max14577.o | ||
39 | obj-$(CONFIG_REGULATOR_MAX1586) += max1586.o | 40 | obj-$(CONFIG_REGULATOR_MAX1586) += max1586.o |
40 | obj-$(CONFIG_REGULATOR_MAX8649) += max8649.o | 41 | obj-$(CONFIG_REGULATOR_MAX8649) += max8649.o |
41 | obj-$(CONFIG_REGULATOR_MAX8660) += max8660.o | 42 | obj-$(CONFIG_REGULATOR_MAX8660) += max8660.o |
diff --git a/drivers/regulator/db8500-prcmu.c b/drivers/regulator/db8500-prcmu.c index a53c11a529d5..846acf240e48 100644 --- a/drivers/regulator/db8500-prcmu.c +++ b/drivers/regulator/db8500-prcmu.c | |||
@@ -431,17 +431,11 @@ static int db8500_regulator_register(struct platform_device *pdev, | |||
431 | config.of_node = np; | 431 | config.of_node = np; |
432 | 432 | ||
433 | /* register with the regulator framework */ | 433 | /* register with the regulator framework */ |
434 | info->rdev = regulator_register(&info->desc, &config); | 434 | info->rdev = devm_regulator_register(&pdev->dev, &info->desc, &config); |
435 | if (IS_ERR(info->rdev)) { | 435 | if (IS_ERR(info->rdev)) { |
436 | err = PTR_ERR(info->rdev); | 436 | err = PTR_ERR(info->rdev); |
437 | dev_err(&pdev->dev, "failed to register %s: err %i\n", | 437 | dev_err(&pdev->dev, "failed to register %s: err %i\n", |
438 | info->desc.name, err); | 438 | info->desc.name, err); |
439 | |||
440 | /* if failing, unregister all earlier regulators */ | ||
441 | while (--id >= 0) { | ||
442 | info = &dbx500_regulator_info[id]; | ||
443 | regulator_unregister(info->rdev); | ||
444 | } | ||
445 | return err; | 439 | return err; |
446 | } | 440 | } |
447 | 441 | ||
@@ -530,20 +524,8 @@ static int db8500_regulator_probe(struct platform_device *pdev) | |||
530 | 524 | ||
531 | static int db8500_regulator_remove(struct platform_device *pdev) | 525 | static int db8500_regulator_remove(struct platform_device *pdev) |
532 | { | 526 | { |
533 | int i; | ||
534 | |||
535 | ux500_regulator_debug_exit(); | 527 | ux500_regulator_debug_exit(); |
536 | 528 | ||
537 | for (i = 0; i < ARRAY_SIZE(dbx500_regulator_info); i++) { | ||
538 | struct dbx500_regulator_info *info; | ||
539 | info = &dbx500_regulator_info[i]; | ||
540 | |||
541 | dev_vdbg(rdev_get_dev(info->rdev), | ||
542 | "regulator-%s-remove\n", info->desc.name); | ||
543 | |||
544 | regulator_unregister(info->rdev); | ||
545 | } | ||
546 | |||
547 | return 0; | 529 | return 0; |
548 | } | 530 | } |
549 | 531 | ||
diff --git a/drivers/regulator/gpio-regulator.c b/drivers/regulator/gpio-regulator.c index 234960dc9607..c0a1d00b78c9 100644 --- a/drivers/regulator/gpio-regulator.c +++ b/drivers/regulator/gpio-regulator.c | |||
@@ -203,17 +203,18 @@ of_get_gpio_regulator_config(struct device *dev, struct device_node *np) | |||
203 | } | 203 | } |
204 | config->nr_states = i; | 204 | config->nr_states = i; |
205 | 205 | ||
206 | config->type = REGULATOR_VOLTAGE; | ||
206 | ret = of_property_read_string(np, "regulator-type", ®type); | 207 | ret = of_property_read_string(np, "regulator-type", ®type); |
207 | if (ret < 0) { | 208 | if (ret >= 0) { |
208 | dev_err(dev, "Missing 'regulator-type' property\n"); | 209 | if (!strncmp("voltage", regtype, 7)) |
209 | return ERR_PTR(-EINVAL); | 210 | config->type = REGULATOR_VOLTAGE; |
211 | else if (!strncmp("current", regtype, 7)) | ||
212 | config->type = REGULATOR_CURRENT; | ||
213 | else | ||
214 | dev_warn(dev, "Unknown regulator-type '%s'\n", | ||
215 | regtype); | ||
210 | } | 216 | } |
211 | 217 | ||
212 | if (!strncmp("voltage", regtype, 7)) | ||
213 | config->type = REGULATOR_VOLTAGE; | ||
214 | else if (!strncmp("current", regtype, 7)) | ||
215 | config->type = REGULATOR_CURRENT; | ||
216 | |||
217 | return config; | 218 | return config; |
218 | } | 219 | } |
219 | 220 | ||
diff --git a/drivers/regulator/lp3971.c b/drivers/regulator/lp3971.c index 947c05ffe0ab..3b1102b75071 100644 --- a/drivers/regulator/lp3971.c +++ b/drivers/regulator/lp3971.c | |||
@@ -25,8 +25,6 @@ struct lp3971 { | |||
25 | struct device *dev; | 25 | struct device *dev; |
26 | struct mutex io_lock; | 26 | struct mutex io_lock; |
27 | struct i2c_client *i2c; | 27 | struct i2c_client *i2c; |
28 | int num_regulators; | ||
29 | struct regulator_dev **rdev; | ||
30 | }; | 28 | }; |
31 | 29 | ||
32 | static u8 lp3971_reg_read(struct lp3971 *lp3971, u8 reg); | 30 | static u8 lp3971_reg_read(struct lp3971 *lp3971, u8 reg); |
@@ -383,42 +381,27 @@ static int setup_regulators(struct lp3971 *lp3971, | |||
383 | { | 381 | { |
384 | int i, err; | 382 | int i, err; |
385 | 383 | ||
386 | lp3971->num_regulators = pdata->num_regulators; | ||
387 | lp3971->rdev = kcalloc(pdata->num_regulators, | ||
388 | sizeof(struct regulator_dev *), GFP_KERNEL); | ||
389 | if (!lp3971->rdev) { | ||
390 | err = -ENOMEM; | ||
391 | goto err_nomem; | ||
392 | } | ||
393 | |||
394 | /* Instantiate the regulators */ | 384 | /* Instantiate the regulators */ |
395 | for (i = 0; i < pdata->num_regulators; i++) { | 385 | for (i = 0; i < pdata->num_regulators; i++) { |
396 | struct regulator_config config = { }; | 386 | struct regulator_config config = { }; |
397 | struct lp3971_regulator_subdev *reg = &pdata->regulators[i]; | 387 | struct lp3971_regulator_subdev *reg = &pdata->regulators[i]; |
388 | struct regulator_dev *rdev; | ||
398 | 389 | ||
399 | config.dev = lp3971->dev; | 390 | config.dev = lp3971->dev; |
400 | config.init_data = reg->initdata; | 391 | config.init_data = reg->initdata; |
401 | config.driver_data = lp3971; | 392 | config.driver_data = lp3971; |
402 | 393 | ||
403 | lp3971->rdev[i] = regulator_register(®ulators[reg->id], | 394 | rdev = devm_regulator_register(lp3971->dev, |
404 | &config); | 395 | ®ulators[reg->id], &config); |
405 | if (IS_ERR(lp3971->rdev[i])) { | 396 | if (IS_ERR(rdev)) { |
406 | err = PTR_ERR(lp3971->rdev[i]); | 397 | err = PTR_ERR(rdev); |
407 | dev_err(lp3971->dev, "regulator init failed: %d\n", | 398 | dev_err(lp3971->dev, "regulator init failed: %d\n", |
408 | err); | 399 | err); |
409 | goto error; | 400 | return err; |
410 | } | 401 | } |
411 | } | 402 | } |
412 | 403 | ||
413 | return 0; | 404 | return 0; |
414 | |||
415 | error: | ||
416 | while (--i >= 0) | ||
417 | regulator_unregister(lp3971->rdev[i]); | ||
418 | kfree(lp3971->rdev); | ||
419 | lp3971->rdev = NULL; | ||
420 | err_nomem: | ||
421 | return err; | ||
422 | } | 405 | } |
423 | 406 | ||
424 | static int lp3971_i2c_probe(struct i2c_client *i2c, | 407 | static int lp3971_i2c_probe(struct i2c_client *i2c, |
@@ -460,19 +443,6 @@ static int lp3971_i2c_probe(struct i2c_client *i2c, | |||
460 | return 0; | 443 | return 0; |
461 | } | 444 | } |
462 | 445 | ||
463 | static int lp3971_i2c_remove(struct i2c_client *i2c) | ||
464 | { | ||
465 | struct lp3971 *lp3971 = i2c_get_clientdata(i2c); | ||
466 | int i; | ||
467 | |||
468 | for (i = 0; i < lp3971->num_regulators; i++) | ||
469 | regulator_unregister(lp3971->rdev[i]); | ||
470 | |||
471 | kfree(lp3971->rdev); | ||
472 | |||
473 | return 0; | ||
474 | } | ||
475 | |||
476 | static const struct i2c_device_id lp3971_i2c_id[] = { | 446 | static const struct i2c_device_id lp3971_i2c_id[] = { |
477 | { "lp3971", 0 }, | 447 | { "lp3971", 0 }, |
478 | { } | 448 | { } |
@@ -485,7 +455,6 @@ static struct i2c_driver lp3971_i2c_driver = { | |||
485 | .owner = THIS_MODULE, | 455 | .owner = THIS_MODULE, |
486 | }, | 456 | }, |
487 | .probe = lp3971_i2c_probe, | 457 | .probe = lp3971_i2c_probe, |
488 | .remove = lp3971_i2c_remove, | ||
489 | .id_table = lp3971_i2c_id, | 458 | .id_table = lp3971_i2c_id, |
490 | }; | 459 | }; |
491 | 460 | ||
diff --git a/drivers/regulator/lp3972.c b/drivers/regulator/lp3972.c index 093e6f44ff8a..aea485afcc1a 100644 --- a/drivers/regulator/lp3972.c +++ b/drivers/regulator/lp3972.c | |||
@@ -22,8 +22,6 @@ struct lp3972 { | |||
22 | struct device *dev; | 22 | struct device *dev; |
23 | struct mutex io_lock; | 23 | struct mutex io_lock; |
24 | struct i2c_client *i2c; | 24 | struct i2c_client *i2c; |
25 | int num_regulators; | ||
26 | struct regulator_dev **rdev; | ||
27 | }; | 25 | }; |
28 | 26 | ||
29 | /* LP3972 Control Registers */ | 27 | /* LP3972 Control Registers */ |
@@ -478,41 +476,27 @@ static int setup_regulators(struct lp3972 *lp3972, | |||
478 | { | 476 | { |
479 | int i, err; | 477 | int i, err; |
480 | 478 | ||
481 | lp3972->num_regulators = pdata->num_regulators; | ||
482 | lp3972->rdev = kcalloc(pdata->num_regulators, | ||
483 | sizeof(struct regulator_dev *), GFP_KERNEL); | ||
484 | if (!lp3972->rdev) { | ||
485 | err = -ENOMEM; | ||
486 | goto err_nomem; | ||
487 | } | ||
488 | |||
489 | /* Instantiate the regulators */ | 479 | /* Instantiate the regulators */ |
490 | for (i = 0; i < pdata->num_regulators; i++) { | 480 | for (i = 0; i < pdata->num_regulators; i++) { |
491 | struct lp3972_regulator_subdev *reg = &pdata->regulators[i]; | 481 | struct lp3972_regulator_subdev *reg = &pdata->regulators[i]; |
492 | struct regulator_config config = { }; | 482 | struct regulator_config config = { }; |
483 | struct regulator_dev *rdev; | ||
493 | 484 | ||
494 | config.dev = lp3972->dev; | 485 | config.dev = lp3972->dev; |
495 | config.init_data = reg->initdata; | 486 | config.init_data = reg->initdata; |
496 | config.driver_data = lp3972; | 487 | config.driver_data = lp3972; |
497 | 488 | ||
498 | lp3972->rdev[i] = regulator_register(®ulators[reg->id], | 489 | rdev = devm_regulator_register(lp3972->dev, |
499 | &config); | 490 | ®ulators[reg->id], &config); |
500 | if (IS_ERR(lp3972->rdev[i])) { | 491 | if (IS_ERR(rdev)) { |
501 | err = PTR_ERR(lp3972->rdev[i]); | 492 | err = PTR_ERR(rdev); |
502 | dev_err(lp3972->dev, "regulator init failed: %d\n", | 493 | dev_err(lp3972->dev, "regulator init failed: %d\n", |
503 | err); | 494 | err); |
504 | goto error; | 495 | return err; |
505 | } | 496 | } |
506 | } | 497 | } |
507 | 498 | ||
508 | return 0; | 499 | return 0; |
509 | error: | ||
510 | while (--i >= 0) | ||
511 | regulator_unregister(lp3972->rdev[i]); | ||
512 | kfree(lp3972->rdev); | ||
513 | lp3972->rdev = NULL; | ||
514 | err_nomem: | ||
515 | return err; | ||
516 | } | 500 | } |
517 | 501 | ||
518 | static int lp3972_i2c_probe(struct i2c_client *i2c, | 502 | static int lp3972_i2c_probe(struct i2c_client *i2c, |
@@ -557,18 +541,6 @@ static int lp3972_i2c_probe(struct i2c_client *i2c, | |||
557 | return 0; | 541 | return 0; |
558 | } | 542 | } |
559 | 543 | ||
560 | static int lp3972_i2c_remove(struct i2c_client *i2c) | ||
561 | { | ||
562 | struct lp3972 *lp3972 = i2c_get_clientdata(i2c); | ||
563 | int i; | ||
564 | |||
565 | for (i = 0; i < lp3972->num_regulators; i++) | ||
566 | regulator_unregister(lp3972->rdev[i]); | ||
567 | kfree(lp3972->rdev); | ||
568 | |||
569 | return 0; | ||
570 | } | ||
571 | |||
572 | static const struct i2c_device_id lp3972_i2c_id[] = { | 544 | static const struct i2c_device_id lp3972_i2c_id[] = { |
573 | { "lp3972", 0 }, | 545 | { "lp3972", 0 }, |
574 | { } | 546 | { } |
@@ -581,7 +553,6 @@ static struct i2c_driver lp3972_i2c_driver = { | |||
581 | .owner = THIS_MODULE, | 553 | .owner = THIS_MODULE, |
582 | }, | 554 | }, |
583 | .probe = lp3972_i2c_probe, | 555 | .probe = lp3972_i2c_probe, |
584 | .remove = lp3972_i2c_remove, | ||
585 | .id_table = lp3972_i2c_id, | 556 | .id_table = lp3972_i2c_id, |
586 | }; | 557 | }; |
587 | 558 | ||
diff --git a/drivers/regulator/max14577.c b/drivers/regulator/max14577.c new file mode 100644 index 000000000000..b1078ba3f393 --- /dev/null +++ b/drivers/regulator/max14577.c | |||
@@ -0,0 +1,273 @@ | |||
1 | /* | ||
2 | * max14577.c - Regulator driver for the Maxim 14577 | ||
3 | * | ||
4 | * Copyright (C) 2013 Samsung Electronics | ||
5 | * Krzysztof Kozlowski <k.kozlowski@samsung.com> | ||
6 | * | ||
7 | * This program is free software; you can redistribute it and/or modify | ||
8 | * it under the terms of the GNU General Public License as published by | ||
9 | * the Free Software Foundation; either version 2 of the License, or | ||
10 | * (at your option) any later version. | ||
11 | * | ||
12 | * This program is distributed in the hope that it will be useful, | ||
13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
15 | * GNU General Public License for more details. | ||
16 | */ | ||
17 | |||
18 | #include <linux/module.h> | ||
19 | #include <linux/platform_device.h> | ||
20 | #include <linux/regulator/driver.h> | ||
21 | #include <linux/mfd/max14577.h> | ||
22 | #include <linux/mfd/max14577-private.h> | ||
23 | #include <linux/regulator/of_regulator.h> | ||
24 | |||
25 | struct max14577_regulator { | ||
26 | struct device *dev; | ||
27 | struct max14577 *max14577; | ||
28 | struct regulator_dev **regulators; | ||
29 | }; | ||
30 | |||
31 | static int max14577_reg_is_enabled(struct regulator_dev *rdev) | ||
32 | { | ||
33 | int rid = rdev_get_id(rdev); | ||
34 | struct regmap *rmap = rdev->regmap; | ||
35 | u8 reg_data; | ||
36 | |||
37 | switch (rid) { | ||
38 | case MAX14577_CHARGER: | ||
39 | max14577_read_reg(rmap, MAX14577_CHG_REG_CHG_CTRL2, ®_data); | ||
40 | if ((reg_data & CHGCTRL2_MBCHOSTEN_MASK) == 0) | ||
41 | return 0; | ||
42 | max14577_read_reg(rmap, MAX14577_CHG_REG_STATUS3, ®_data); | ||
43 | if ((reg_data & STATUS3_CGMBC_MASK) == 0) | ||
44 | return 0; | ||
45 | /* MBCHOSTEN and CGMBC are on */ | ||
46 | return 1; | ||
47 | default: | ||
48 | return -EINVAL; | ||
49 | } | ||
50 | } | ||
51 | |||
52 | static int max14577_reg_get_current_limit(struct regulator_dev *rdev) | ||
53 | { | ||
54 | u8 reg_data; | ||
55 | struct regmap *rmap = rdev->regmap; | ||
56 | |||
57 | if (rdev_get_id(rdev) != MAX14577_CHARGER) | ||
58 | return -EINVAL; | ||
59 | |||
60 | max14577_read_reg(rmap, MAX14577_CHG_REG_CHG_CTRL4, ®_data); | ||
61 | |||
62 | if ((reg_data & CHGCTRL4_MBCICHWRCL_MASK) == 0) | ||
63 | return MAX14577_REGULATOR_CURRENT_LIMIT_MIN; | ||
64 | |||
65 | reg_data = ((reg_data & CHGCTRL4_MBCICHWRCH_MASK) >> | ||
66 | CHGCTRL4_MBCICHWRCH_SHIFT); | ||
67 | return MAX14577_REGULATOR_CURRENT_LIMIT_HIGH_START + | ||
68 | reg_data * MAX14577_REGULATOR_CURRENT_LIMIT_HIGH_STEP; | ||
69 | } | ||
70 | |||
71 | static int max14577_reg_set_current_limit(struct regulator_dev *rdev, | ||
72 | int min_uA, int max_uA) | ||
73 | { | ||
74 | int i, current_bits = 0xf; | ||
75 | u8 reg_data; | ||
76 | |||
77 | if (rdev_get_id(rdev) != MAX14577_CHARGER) | ||
78 | return -EINVAL; | ||
79 | |||
80 | if (min_uA > MAX14577_REGULATOR_CURRENT_LIMIT_MAX || | ||
81 | max_uA < MAX14577_REGULATOR_CURRENT_LIMIT_MIN) | ||
82 | return -EINVAL; | ||
83 | |||
84 | if (max_uA < MAX14577_REGULATOR_CURRENT_LIMIT_HIGH_START) { | ||
85 | /* Less than 200 mA, so set 90mA (turn only Low Bit off) */ | ||
86 | u8 reg_data = 0x0 << CHGCTRL4_MBCICHWRCL_SHIFT; | ||
87 | return max14577_update_reg(rdev->regmap, | ||
88 | MAX14577_CHG_REG_CHG_CTRL4, | ||
89 | CHGCTRL4_MBCICHWRCL_MASK, reg_data); | ||
90 | } | ||
91 | |||
92 | /* max_uA is in range: <LIMIT_HIGH_START, inifinite>, so search for | ||
93 | * valid current starting from LIMIT_MAX. */ | ||
94 | for (i = MAX14577_REGULATOR_CURRENT_LIMIT_MAX; | ||
95 | i >= MAX14577_REGULATOR_CURRENT_LIMIT_HIGH_START; | ||
96 | i -= MAX14577_REGULATOR_CURRENT_LIMIT_HIGH_STEP) { | ||
97 | if (i <= max_uA) | ||
98 | break; | ||
99 | current_bits--; | ||
100 | } | ||
101 | BUG_ON(current_bits < 0); /* Cannot happen */ | ||
102 | /* Turn Low Bit on (use range 200mA-950 mA) */ | ||
103 | reg_data = 0x1 << CHGCTRL4_MBCICHWRCL_SHIFT; | ||
104 | /* and set proper High Bits */ | ||
105 | reg_data |= current_bits << CHGCTRL4_MBCICHWRCH_SHIFT; | ||
106 | |||
107 | return max14577_update_reg(rdev->regmap, MAX14577_CHG_REG_CHG_CTRL4, | ||
108 | CHGCTRL4_MBCICHWRCL_MASK | CHGCTRL4_MBCICHWRCH_MASK, | ||
109 | reg_data); | ||
110 | } | ||
111 | |||
112 | static struct regulator_ops max14577_safeout_ops = { | ||
113 | .is_enabled = regulator_is_enabled_regmap, | ||
114 | .enable = regulator_enable_regmap, | ||
115 | .disable = regulator_disable_regmap, | ||
116 | .list_voltage = regulator_list_voltage_linear, | ||
117 | }; | ||
118 | |||
119 | static struct regulator_ops max14577_charger_ops = { | ||
120 | .is_enabled = max14577_reg_is_enabled, | ||
121 | .enable = regulator_enable_regmap, | ||
122 | .disable = regulator_disable_regmap, | ||
123 | .get_current_limit = max14577_reg_get_current_limit, | ||
124 | .set_current_limit = max14577_reg_set_current_limit, | ||
125 | }; | ||
126 | |||
127 | static const struct regulator_desc supported_regulators[] = { | ||
128 | [MAX14577_SAFEOUT] = { | ||
129 | .name = "SAFEOUT", | ||
130 | .id = MAX14577_SAFEOUT, | ||
131 | .ops = &max14577_safeout_ops, | ||
132 | .type = REGULATOR_VOLTAGE, | ||
133 | .owner = THIS_MODULE, | ||
134 | .n_voltages = 1, | ||
135 | .min_uV = MAX14577_REGULATOR_SAFEOUT_VOLTAGE, | ||
136 | .enable_reg = MAX14577_REG_CONTROL2, | ||
137 | .enable_mask = CTRL2_SFOUTORD_MASK, | ||
138 | }, | ||
139 | [MAX14577_CHARGER] = { | ||
140 | .name = "CHARGER", | ||
141 | .id = MAX14577_CHARGER, | ||
142 | .ops = &max14577_charger_ops, | ||
143 | .type = REGULATOR_CURRENT, | ||
144 | .owner = THIS_MODULE, | ||
145 | .enable_reg = MAX14577_CHG_REG_CHG_CTRL2, | ||
146 | .enable_mask = CHGCTRL2_MBCHOSTEN_MASK, | ||
147 | }, | ||
148 | }; | ||
149 | |||
150 | #ifdef CONFIG_OF | ||
151 | static struct of_regulator_match max14577_regulator_matches[] = { | ||
152 | { .name = "SAFEOUT", }, | ||
153 | { .name = "CHARGER", }, | ||
154 | }; | ||
155 | |||
156 | static int max14577_regulator_dt_parse_pdata(struct platform_device *pdev) | ||
157 | { | ||
158 | int ret; | ||
159 | struct device_node *np; | ||
160 | |||
161 | np = of_get_child_by_name(pdev->dev.parent->of_node, "regulators"); | ||
162 | if (!np) { | ||
163 | dev_err(&pdev->dev, "Failed to get child OF node for regulators\n"); | ||
164 | return -EINVAL; | ||
165 | } | ||
166 | |||
167 | ret = of_regulator_match(&pdev->dev, np, max14577_regulator_matches, | ||
168 | MAX14577_REG_MAX); | ||
169 | if (ret < 0) { | ||
170 | dev_err(&pdev->dev, "Error parsing regulator init data: %d\n", ret); | ||
171 | return ret; | ||
172 | } | ||
173 | |||
174 | return 0; | ||
175 | } | ||
176 | |||
177 | static inline struct regulator_init_data *match_init_data(int index) | ||
178 | { | ||
179 | return max14577_regulator_matches[index].init_data; | ||
180 | } | ||
181 | |||
182 | static inline struct device_node *match_of_node(int index) | ||
183 | { | ||
184 | return max14577_regulator_matches[index].of_node; | ||
185 | } | ||
186 | #else /* CONFIG_OF */ | ||
187 | static int max14577_regulator_dt_parse_pdata(struct platform_device *pdev) | ||
188 | { | ||
189 | return 0; | ||
190 | } | ||
191 | static inline struct regulator_init_data *match_init_data(int index) | ||
192 | { | ||
193 | return NULL; | ||
194 | } | ||
195 | |||
196 | static inline struct device_node *match_of_node(int index) | ||
197 | { | ||
198 | return NULL; | ||
199 | } | ||
200 | #endif /* CONFIG_OF */ | ||
201 | |||
202 | |||
203 | static int max14577_regulator_probe(struct platform_device *pdev) | ||
204 | { | ||
205 | struct max14577 *max14577 = dev_get_drvdata(pdev->dev.parent); | ||
206 | struct max14577_platform_data *pdata = dev_get_platdata(max14577->dev); | ||
207 | int i, ret; | ||
208 | struct regulator_config config = {}; | ||
209 | |||
210 | ret = max14577_regulator_dt_parse_pdata(pdev); | ||
211 | if (ret) | ||
212 | return ret; | ||
213 | |||
214 | config.dev = &pdev->dev; | ||
215 | config.regmap = max14577->regmap; | ||
216 | |||
217 | for (i = 0; i < ARRAY_SIZE(supported_regulators); i++) { | ||
218 | struct regulator_dev *regulator; | ||
219 | /* | ||
220 | * Index of supported_regulators[] is also the id and must | ||
221 | * match index of pdata->regulators[]. | ||
222 | */ | ||
223 | if (pdata && pdata->regulators) { | ||
224 | config.init_data = pdata->regulators[i].initdata; | ||
225 | config.of_node = pdata->regulators[i].of_node; | ||
226 | } else { | ||
227 | config.init_data = match_init_data(i); | ||
228 | config.of_node = match_of_node(i); | ||
229 | } | ||
230 | |||
231 | regulator = devm_regulator_register(&pdev->dev, | ||
232 | &supported_regulators[i], &config); | ||
233 | if (IS_ERR(regulator)) { | ||
234 | ret = PTR_ERR(regulator); | ||
235 | dev_err(&pdev->dev, | ||
236 | "Regulator init failed for ID %d with error: %d\n", | ||
237 | i, ret); | ||
238 | return ret; | ||
239 | } | ||
240 | } | ||
241 | |||
242 | return ret; | ||
243 | } | ||
244 | |||
245 | static struct platform_driver max14577_regulator_driver = { | ||
246 | .driver = { | ||
247 | .owner = THIS_MODULE, | ||
248 | .name = "max14577-regulator", | ||
249 | }, | ||
250 | .probe = max14577_regulator_probe, | ||
251 | }; | ||
252 | |||
253 | static int __init max14577_regulator_init(void) | ||
254 | { | ||
255 | BUILD_BUG_ON(MAX14577_REGULATOR_CURRENT_LIMIT_HIGH_START + | ||
256 | MAX14577_REGULATOR_CURRENT_LIMIT_HIGH_STEP * 0xf != | ||
257 | MAX14577_REGULATOR_CURRENT_LIMIT_MAX); | ||
258 | BUILD_BUG_ON(ARRAY_SIZE(supported_regulators) != MAX14577_REG_MAX); | ||
259 | |||
260 | return platform_driver_register(&max14577_regulator_driver); | ||
261 | } | ||
262 | subsys_initcall(max14577_regulator_init); | ||
263 | |||
264 | static void __exit max14577_regulator_exit(void) | ||
265 | { | ||
266 | platform_driver_unregister(&max14577_regulator_driver); | ||
267 | } | ||
268 | module_exit(max14577_regulator_exit); | ||
269 | |||
270 | MODULE_AUTHOR("Krzysztof Kozlowski <k.kozlowski@samsung.com>"); | ||
271 | MODULE_DESCRIPTION("MAXIM 14577 regulator driver"); | ||
272 | MODULE_LICENSE("GPL"); | ||
273 | MODULE_ALIAS("platform:max14577-regulator"); | ||
diff --git a/drivers/regulator/max77693.c b/drivers/regulator/max77693.c index feb20bf4ccab..5fb899f461d0 100644 --- a/drivers/regulator/max77693.c +++ b/drivers/regulator/max77693.c | |||
@@ -138,6 +138,7 @@ static struct regulator_ops max77693_charger_ops = { | |||
138 | .n_voltages = 4, \ | 138 | .n_voltages = 4, \ |
139 | .ops = &max77693_safeout_ops, \ | 139 | .ops = &max77693_safeout_ops, \ |
140 | .type = REGULATOR_VOLTAGE, \ | 140 | .type = REGULATOR_VOLTAGE, \ |
141 | .owner = THIS_MODULE, \ | ||
141 | .volt_table = max77693_safeout_table, \ | 142 | .volt_table = max77693_safeout_table, \ |
142 | .vsel_reg = MAX77693_CHG_REG_SAFEOUT_CTRL, \ | 143 | .vsel_reg = MAX77693_CHG_REG_SAFEOUT_CTRL, \ |
143 | .vsel_mask = SAFEOUT_CTRL_SAFEOUT##_num##_MASK, \ | 144 | .vsel_mask = SAFEOUT_CTRL_SAFEOUT##_num##_MASK, \ |
diff --git a/drivers/regulator/mc13892-regulator.c b/drivers/regulator/mc13892-regulator.c index 96c9f80d9550..f374fa57220f 100644 --- a/drivers/regulator/mc13892-regulator.c +++ b/drivers/regulator/mc13892-regulator.c | |||
@@ -274,25 +274,25 @@ static struct mc13xxx_regulator mc13892_regulators[] = { | |||
274 | MC13892_SW_DEFINE(SW4, SWITCHERS3, SWITCHERS3, mc13892_sw), | 274 | MC13892_SW_DEFINE(SW4, SWITCHERS3, SWITCHERS3, mc13892_sw), |
275 | MC13892_FIXED_DEFINE(SWBST, SWITCHERS5, mc13892_swbst), | 275 | MC13892_FIXED_DEFINE(SWBST, SWITCHERS5, mc13892_swbst), |
276 | MC13892_FIXED_DEFINE(VIOHI, REGULATORMODE0, mc13892_viohi), | 276 | MC13892_FIXED_DEFINE(VIOHI, REGULATORMODE0, mc13892_viohi), |
277 | MC13892_DEFINE_REGU(VPLL, REGULATORMODE0, REGULATORSETTING0, \ | 277 | MC13892_DEFINE_REGU(VPLL, REGULATORMODE0, REGULATORSETTING0, |
278 | mc13892_vpll), | 278 | mc13892_vpll), |
279 | MC13892_DEFINE_REGU(VDIG, REGULATORMODE0, REGULATORSETTING0, \ | 279 | MC13892_DEFINE_REGU(VDIG, REGULATORMODE0, REGULATORSETTING0, |
280 | mc13892_vdig), | 280 | mc13892_vdig), |
281 | MC13892_DEFINE_REGU(VSD, REGULATORMODE1, REGULATORSETTING1, \ | 281 | MC13892_DEFINE_REGU(VSD, REGULATORMODE1, REGULATORSETTING1, |
282 | mc13892_vsd), | 282 | mc13892_vsd), |
283 | MC13892_DEFINE_REGU(VUSB2, REGULATORMODE0, REGULATORSETTING0, \ | 283 | MC13892_DEFINE_REGU(VUSB2, REGULATORMODE0, REGULATORSETTING0, |
284 | mc13892_vusb2), | 284 | mc13892_vusb2), |
285 | MC13892_DEFINE_REGU(VVIDEO, REGULATORMODE1, REGULATORSETTING1, \ | 285 | MC13892_DEFINE_REGU(VVIDEO, REGULATORMODE1, REGULATORSETTING1, |
286 | mc13892_vvideo), | 286 | mc13892_vvideo), |
287 | MC13892_DEFINE_REGU(VAUDIO, REGULATORMODE1, REGULATORSETTING1, \ | 287 | MC13892_DEFINE_REGU(VAUDIO, REGULATORMODE1, REGULATORSETTING1, |
288 | mc13892_vaudio), | 288 | mc13892_vaudio), |
289 | MC13892_DEFINE_REGU(VCAM, REGULATORMODE1, REGULATORSETTING0, \ | 289 | MC13892_DEFINE_REGU(VCAM, REGULATORMODE1, REGULATORSETTING0, |
290 | mc13892_vcam), | 290 | mc13892_vcam), |
291 | MC13892_DEFINE_REGU(VGEN1, REGULATORMODE0, REGULATORSETTING0, \ | 291 | MC13892_DEFINE_REGU(VGEN1, REGULATORMODE0, REGULATORSETTING0, |
292 | mc13892_vgen1), | 292 | mc13892_vgen1), |
293 | MC13892_DEFINE_REGU(VGEN2, REGULATORMODE0, REGULATORSETTING0, \ | 293 | MC13892_DEFINE_REGU(VGEN2, REGULATORMODE0, REGULATORSETTING0, |
294 | mc13892_vgen2), | 294 | mc13892_vgen2), |
295 | MC13892_DEFINE_REGU(VGEN3, REGULATORMODE1, REGULATORSETTING0, \ | 295 | MC13892_DEFINE_REGU(VGEN3, REGULATORMODE1, REGULATORSETTING0, |
296 | mc13892_vgen3), | 296 | mc13892_vgen3), |
297 | MC13892_FIXED_DEFINE(VUSB, USB1, mc13892_vusb), | 297 | MC13892_FIXED_DEFINE(VUSB, USB1, mc13892_vusb), |
298 | MC13892_GPO_DEFINE(GPO1, POWERMISC, mc13892_gpo), | 298 | MC13892_GPO_DEFINE(GPO1, POWERMISC, mc13892_gpo), |
@@ -476,8 +476,8 @@ static int mc13892_sw_regulator_set_voltage_sel(struct regulator_dev *rdev, | |||
476 | } | 476 | } |
477 | 477 | ||
478 | mc13xxx_lock(priv->mc13xxx); | 478 | mc13xxx_lock(priv->mc13xxx); |
479 | ret = mc13xxx_reg_rmw(priv->mc13xxx, mc13892_regulators[id].vsel_reg, mask, | 479 | ret = mc13xxx_reg_rmw(priv->mc13xxx, mc13892_regulators[id].vsel_reg, |
480 | reg_value); | 480 | mask, reg_value); |
481 | mc13xxx_unlock(priv->mc13xxx); | 481 | mc13xxx_unlock(priv->mc13xxx); |
482 | 482 | ||
483 | return ret; | 483 | return ret; |
diff --git a/drivers/regulator/pcf50633-regulator.c b/drivers/regulator/pcf50633-regulator.c index d7da1c15a6da..134f90ec9ca1 100644 --- a/drivers/regulator/pcf50633-regulator.c +++ b/drivers/regulator/pcf50633-regulator.c | |||
@@ -105,7 +105,7 @@ static int pcf50633_regulator_probe(struct platform_device *pdev) | |||
105 | 105 | ||
106 | static struct platform_driver pcf50633_regulator_driver = { | 106 | static struct platform_driver pcf50633_regulator_driver = { |
107 | .driver = { | 107 | .driver = { |
108 | .name = "pcf50633-regltr", | 108 | .name = "pcf50633-regulator", |
109 | }, | 109 | }, |
110 | .probe = pcf50633_regulator_probe, | 110 | .probe = pcf50633_regulator_probe, |
111 | }; | 111 | }; |
diff --git a/drivers/regulator/pfuze100-regulator.c b/drivers/regulator/pfuze100-regulator.c index c31e0485de25..ab174f20ca11 100644 --- a/drivers/regulator/pfuze100-regulator.c +++ b/drivers/regulator/pfuze100-regulator.c | |||
@@ -309,14 +309,17 @@ static int pfuze_identify(struct pfuze_chip *pfuze_chip) | |||
309 | return ret; | 309 | return ret; |
310 | 310 | ||
311 | switch (value & 0x0f) { | 311 | switch (value & 0x0f) { |
312 | /* Freescale misprogrammed 1-3% of parts prior to week 8 of 2013 as ID=8 */ | 312 | /* |
313 | case 0x8: | 313 | * Freescale misprogrammed 1-3% of parts prior to week 8 of 2013 |
314 | dev_info(pfuze_chip->dev, "Assuming misprogrammed ID=0x8"); | 314 | * as ID=8 |
315 | case 0x0: | 315 | */ |
316 | break; | 316 | case 0x8: |
317 | default: | 317 | dev_info(pfuze_chip->dev, "Assuming misprogrammed ID=0x8"); |
318 | dev_warn(pfuze_chip->dev, "Illegal ID: %x\n", value); | 318 | case 0x0: |
319 | return -ENODEV; | 319 | break; |
320 | default: | ||
321 | dev_warn(pfuze_chip->dev, "Illegal ID: %x\n", value); | ||
322 | return -ENODEV; | ||
320 | } | 323 | } |
321 | 324 | ||
322 | ret = regmap_read(pfuze_chip->regmap, PFUZE100_REVID, &value); | 325 | ret = regmap_read(pfuze_chip->regmap, PFUZE100_REVID, &value); |
@@ -408,31 +411,18 @@ static int pfuze100_regulator_probe(struct i2c_client *client, | |||
408 | config.driver_data = pfuze_chip; | 411 | config.driver_data = pfuze_chip; |
409 | config.of_node = match_of_node(i); | 412 | config.of_node = match_of_node(i); |
410 | 413 | ||
411 | pfuze_chip->regulators[i] = regulator_register(desc, &config); | 414 | pfuze_chip->regulators[i] = |
415 | devm_regulator_register(&client->dev, desc, &config); | ||
412 | if (IS_ERR(pfuze_chip->regulators[i])) { | 416 | if (IS_ERR(pfuze_chip->regulators[i])) { |
413 | dev_err(&client->dev, "register regulator%s failed\n", | 417 | dev_err(&client->dev, "register regulator%s failed\n", |
414 | pfuze100_regulators[i].desc.name); | 418 | pfuze100_regulators[i].desc.name); |
415 | ret = PTR_ERR(pfuze_chip->regulators[i]); | 419 | return PTR_ERR(pfuze_chip->regulators[i]); |
416 | while (--i >= 0) | ||
417 | regulator_unregister(pfuze_chip->regulators[i]); | ||
418 | return ret; | ||
419 | } | 420 | } |
420 | } | 421 | } |
421 | 422 | ||
422 | return 0; | 423 | return 0; |
423 | } | 424 | } |
424 | 425 | ||
425 | static int pfuze100_regulator_remove(struct i2c_client *client) | ||
426 | { | ||
427 | int i; | ||
428 | struct pfuze_chip *pfuze_chip = i2c_get_clientdata(client); | ||
429 | |||
430 | for (i = 0; i < PFUZE100_MAX_REGULATOR; i++) | ||
431 | regulator_unregister(pfuze_chip->regulators[i]); | ||
432 | |||
433 | return 0; | ||
434 | } | ||
435 | |||
436 | static struct i2c_driver pfuze_driver = { | 426 | static struct i2c_driver pfuze_driver = { |
437 | .id_table = pfuze_device_id, | 427 | .id_table = pfuze_device_id, |
438 | .driver = { | 428 | .driver = { |
@@ -441,7 +431,6 @@ static struct i2c_driver pfuze_driver = { | |||
441 | .of_match_table = pfuze_dt_ids, | 431 | .of_match_table = pfuze_dt_ids, |
442 | }, | 432 | }, |
443 | .probe = pfuze100_regulator_probe, | 433 | .probe = pfuze100_regulator_probe, |
444 | .remove = pfuze100_regulator_remove, | ||
445 | }; | 434 | }; |
446 | module_i2c_driver(pfuze_driver); | 435 | module_i2c_driver(pfuze_driver); |
447 | 436 | ||