aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--Documentation/ABI/testing/sysfs-class-power14
-rw-r--r--Documentation/devicetree/bindings/mfd/max14577.txt146
-rw-r--r--drivers/mfd/max14577.c100
-rw-r--r--drivers/power/Kconfig5
-rw-r--r--drivers/power/max14577_charger.c370
-rw-r--r--drivers/power/max17040_battery.c3
-rw-r--r--drivers/regulator/max14577.c80
-rw-r--r--include/linux/mfd/max14577-private.h95
-rw-r--r--include/linux/mfd/max14577.h30
9 files changed, 704 insertions, 139 deletions
diff --git a/Documentation/ABI/testing/sysfs-class-power b/Documentation/ABI/testing/sysfs-class-power
index 78c7baca3587..ad4fb90ab23d 100644
--- a/Documentation/ABI/testing/sysfs-class-power
+++ b/Documentation/ABI/testing/sysfs-class-power
@@ -18,3 +18,17 @@ Description:
18 This file is writeable and can be used to set the assumed 18 This file is writeable and can be used to set the assumed
19 battery 'full level'. As batteries age, this value has to be 19 battery 'full level'. As batteries age, this value has to be
20 amended over time. 20 amended over time.
21
22What: /sys/class/power_supply/max14577-charger/device/fast_charge_timer
23Date: July 2014
24KernelVersion: 3.18.0
25Contact: Krzysztof Kozlowski <k.kozlowski@samsung.com>
26Description:
27 This entry shows and sets the maximum time the max14577
28 charger operates in fast-charge mode. When the timer expires
29 the device will terminate fast-charge mode (charging current
30 will drop to 0 A) and will trigger interrupt.
31
32 Valid values:
33 - 5, 6 or 7 (hours),
34 - 0: disabled.
diff --git a/Documentation/devicetree/bindings/mfd/max14577.txt b/Documentation/devicetree/bindings/mfd/max14577.txt
new file mode 100644
index 000000000000..236264c10b92
--- /dev/null
+++ b/Documentation/devicetree/bindings/mfd/max14577.txt
@@ -0,0 +1,146 @@
1Maxim MAX14577/77836 Multi-Function Device
2
3MAX14577 is a Multi-Function Device with Micro-USB Interface Circuit, Li+
4Battery Charger and SFOUT LDO output for powering USB devices. It is
5interfaced to host controller using I2C.
6
7MAX77836 additionally contains PMIC (with two LDO regulators) and Fuel Gauge.
8
9
10Required properties:
11- compatible : Must be "maxim,max14577" or "maxim,max77836".
12- reg : I2C slave address for the max14577 chip (0x25 for max14577/max77836)
13- interrupts : IRQ line for the chip.
14- interrupt-parent : The parent interrupt controller.
15
16
17Required nodes:
18 - charger :
19 Node for configuring the charger driver.
20 Required properties:
21 - compatible : "maxim,max14577-charger"
22 or "maxim,max77836-charger"
23 - maxim,fast-charge-uamp : Current in uA for Fast Charge;
24 Valid values:
25 - for max14577: 90000 - 950000;
26 - for max77836: 45000 - 475000;
27 - maxim,eoc-uamp : Current in uA for End-Of-Charge mode;
28 Valid values:
29 - for max14577: 50000 - 200000;
30 - for max77836: 5000 - 100000;
31 - maxim,ovp-uvolt : OverVoltage Protection Threshold in uV;
32 In an overvoltage condition, INT asserts and charging
33 stops. Valid values:
34 - 6000000, 6500000, 7000000, 7500000;
35 - maxim,constant-uvolt : Battery Constant Voltage in uV;
36 Valid values:
37 - 4000000 - 4280000 (step by 20000);
38 - 4350000;
39
40
41Optional nodes:
42- max14577-muic/max77836-muic :
43 Node used only by extcon consumers.
44 Required properties:
45 - compatible : "maxim,max14577-muic" or "maxim,max77836-muic"
46
47- regulators :
48 Required properties:
49 - compatible : "maxim,max14577-regulator"
50 or "maxim,max77836-regulator"
51
52 May contain a sub-node per regulator from the list below. Each
53 sub-node should contain the constraints and initialization information
54 for that regulator. See regulator.txt for a description of standard
55 properties for these sub-nodes.
56
57 List of valid regulator names:
58 - for max14577: CHARGER, SAFEOUT.
59 - for max77836: CHARGER, SAFEOUT, LDO1, LDO2.
60
61 The SAFEOUT is a fixed voltage regulator so there is no need to specify
62 voltages for it.
63
64
65Example:
66
67#include <dt-bindings/interrupt-controller/irq.h>
68
69max14577@25 {
70 compatible = "maxim,max14577";
71 reg = <0x25>;
72 interrupt-parent = <&gpx1>;
73 interrupts = <5 IRQ_TYPE_NONE>;
74
75 muic: max14577-muic {
76 compatible = "maxim,max14577-muic";
77 };
78
79 regulators {
80 compatible = "maxim,max14577-regulator";
81
82 SAFEOUT {
83 regulator-name = "SAFEOUT";
84 };
85 CHARGER {
86 regulator-name = "CHARGER";
87 regulator-min-microamp = <90000>;
88 regulator-max-microamp = <950000>;
89 regulator-boot-on;
90 };
91 };
92
93 charger {
94 compatible = "maxim,max14577-charger";
95
96 maxim,constant-uvolt = <4350000>;
97 maxim,fast-charge-uamp = <450000>;
98 maxim,eoc-uamp = <50000>;
99 maxim,ovp-uvolt = <6500000>;
100 };
101};
102
103
104max77836@25 {
105 compatible = "maxim,max77836";
106 reg = <0x25>;
107 interrupt-parent = <&gpx1>;
108 interrupts = <5 IRQ_TYPE_NONE>;
109
110 muic: max77836-muic {
111 compatible = "maxim,max77836-muic";
112 };
113
114 regulators {
115 compatible = "maxim,max77836-regulator";
116
117 SAFEOUT {
118 regulator-name = "SAFEOUT";
119 };
120 CHARGER {
121 regulator-name = "CHARGER";
122 regulator-min-microamp = <90000>;
123 regulator-max-microamp = <950000>;
124 regulator-boot-on;
125 };
126 LDO1 {
127 regulator-name = "LDO1";
128 regulator-min-microvolt = <2700000>;
129 regulator-max-microvolt = <2700000>;
130 };
131 LDO2 {
132 regulator-name = "LDO2";
133 regulator-min-microvolt = <800000>;
134 regulator-max-microvolt = <3950000>;
135 };
136 };
137
138 charger {
139 compatible = "maxim,max77836-charger";
140
141 maxim,constant-uvolt = <4350000>;
142 maxim,fast-charge-uamp = <225000>;
143 maxim,eoc-uamp = <7500>;
144 maxim,ovp-uvolt = <6500000>;
145 };
146};
diff --git a/drivers/mfd/max14577.c b/drivers/mfd/max14577.c
index 4a5e885383f8..b8af263be594 100644
--- a/drivers/mfd/max14577.c
+++ b/drivers/mfd/max14577.c
@@ -26,6 +26,87 @@
26#include <linux/mfd/max14577.h> 26#include <linux/mfd/max14577.h>
27#include <linux/mfd/max14577-private.h> 27#include <linux/mfd/max14577-private.h>
28 28
29/*
30 * Table of valid charger currents for different Maxim chipsets.
31 * It is placed here because it is used by both charger and regulator driver.
32 */
33const struct maxim_charger_current maxim_charger_currents[] = {
34 [MAXIM_DEVICE_TYPE_UNKNOWN] = { 0, 0, 0, 0 },
35 [MAXIM_DEVICE_TYPE_MAX14577] = {
36 .min = MAX14577_CHARGER_CURRENT_LIMIT_MIN,
37 .high_start = MAX14577_CHARGER_CURRENT_LIMIT_HIGH_START,
38 .high_step = MAX14577_CHARGER_CURRENT_LIMIT_HIGH_STEP,
39 .max = MAX14577_CHARGER_CURRENT_LIMIT_MAX,
40 },
41 [MAXIM_DEVICE_TYPE_MAX77836] = {
42 .min = MAX77836_CHARGER_CURRENT_LIMIT_MIN,
43 .high_start = MAX77836_CHARGER_CURRENT_LIMIT_HIGH_START,
44 .high_step = MAX77836_CHARGER_CURRENT_LIMIT_HIGH_STEP,
45 .max = MAX77836_CHARGER_CURRENT_LIMIT_MAX,
46 },
47};
48EXPORT_SYMBOL_GPL(maxim_charger_currents);
49
50/*
51 * maxim_charger_calc_reg_current - Calculate register value for current
52 * @limits: constraints for charger, matching the MBCICHWRC register
53 * @min_ua: minimal requested current, micro Amps
54 * @max_ua: maximum requested current, micro Amps
55 * @dst: destination to store calculated register value
56 *
57 * Calculates the value of MBCICHWRC (Fast Battery Charge Current) register
58 * for given current and stores it under pointed 'dst'. The stored value
59 * combines low bit (MBCICHWRCL) and high bits (MBCICHWRCH). It is also
60 * properly shifted.
61 *
62 * The calculated register value matches the current which:
63 * - is always between <limits.min, limits.max>;
64 * - is always less or equal to max_ua;
65 * - is the highest possible value;
66 * - may be lower than min_ua.
67 *
68 * On success returns 0. On error returns -EINVAL (requested min/max current
69 * is outside of given charger limits) and 'dst' is not set.
70 */
71int maxim_charger_calc_reg_current(const struct maxim_charger_current *limits,
72 unsigned int min_ua, unsigned int max_ua, u8 *dst)
73{
74 unsigned int current_bits = 0xf;
75
76 if (min_ua > max_ua)
77 return -EINVAL;
78
79 if (min_ua > limits->max || max_ua < limits->min)
80 return -EINVAL;
81
82 if (max_ua < limits->high_start) {
83 /*
84 * Less than high_start, so set the minimal current
85 * (turn Low Bit off, 0 as high bits).
86 */
87 *dst = 0x0;
88 return 0;
89 }
90
91 /* max_ua is in range: <high_start, infinite>, cut it to limits.max */
92 max_ua = min(limits->max, max_ua);
93 max_ua -= limits->high_start;
94 /*
95 * There is no risk of overflow 'max_ua' here because:
96 * - max_ua >= limits.high_start
97 * - BUILD_BUG checks that 'limits' are: max >= high_start + high_step
98 */
99 current_bits = max_ua / limits->high_step;
100
101 /* Turn Low Bit on (use range <limits.high_start, limits.max>) ... */
102 *dst = 0x1 << CHGCTRL4_MBCICHWRCL_SHIFT;
103 /* and set proper High Bits */
104 *dst |= current_bits << CHGCTRL4_MBCICHWRCH_SHIFT;
105
106 return 0;
107}
108EXPORT_SYMBOL_GPL(maxim_charger_calc_reg_current);
109
29static const struct mfd_cell max14577_devs[] = { 110static const struct mfd_cell max14577_devs[] = {
30 { 111 {
31 .name = "max14577-muic", 112 .name = "max14577-muic",
@@ -35,7 +116,10 @@ static const struct mfd_cell max14577_devs[] = {
35 .name = "max14577-regulator", 116 .name = "max14577-regulator",
36 .of_compatible = "maxim,max14577-regulator", 117 .of_compatible = "maxim,max14577-regulator",
37 }, 118 },
38 { .name = "max14577-charger", }, 119 {
120 .name = "max14577-charger",
121 .of_compatible = "maxim,max14577-charger",
122 },
39}; 123};
40 124
41static const struct mfd_cell max77836_devs[] = { 125static const struct mfd_cell max77836_devs[] = {
@@ -463,6 +547,20 @@ static int __init max14577_i2c_init(void)
463 BUILD_BUG_ON(ARRAY_SIZE(max14577_i2c_id) != MAXIM_DEVICE_TYPE_NUM); 547 BUILD_BUG_ON(ARRAY_SIZE(max14577_i2c_id) != MAXIM_DEVICE_TYPE_NUM);
464 BUILD_BUG_ON(ARRAY_SIZE(max14577_dt_match) != MAXIM_DEVICE_TYPE_NUM); 548 BUILD_BUG_ON(ARRAY_SIZE(max14577_dt_match) != MAXIM_DEVICE_TYPE_NUM);
465 549
550 /* Valid charger current values must be provided for each chipset */
551 BUILD_BUG_ON(ARRAY_SIZE(maxim_charger_currents) != MAXIM_DEVICE_TYPE_NUM);
552
553 /* Check for valid values for charger */
554 BUILD_BUG_ON(MAX14577_CHARGER_CURRENT_LIMIT_HIGH_START +
555 MAX14577_CHARGER_CURRENT_LIMIT_HIGH_STEP * 0xf !=
556 MAX14577_CHARGER_CURRENT_LIMIT_MAX);
557 BUILD_BUG_ON(MAX14577_CHARGER_CURRENT_LIMIT_HIGH_STEP == 0);
558
559 BUILD_BUG_ON(MAX77836_CHARGER_CURRENT_LIMIT_HIGH_START +
560 MAX77836_CHARGER_CURRENT_LIMIT_HIGH_STEP * 0xf !=
561 MAX77836_CHARGER_CURRENT_LIMIT_MAX);
562 BUILD_BUG_ON(MAX77836_CHARGER_CURRENT_LIMIT_HIGH_STEP == 0);
563
466 return i2c_add_driver(&max14577_i2c_driver); 564 return i2c_add_driver(&max14577_i2c_driver);
467} 565}
468subsys_initcall(max14577_i2c_init); 566subsys_initcall(max14577_i2c_init);
diff --git a/drivers/power/Kconfig b/drivers/power/Kconfig
index 73cfcdf28a36..04e1d2fe2201 100644
--- a/drivers/power/Kconfig
+++ b/drivers/power/Kconfig
@@ -325,11 +325,12 @@ config CHARGER_MANAGER
325 with help of suspend_again support. 325 with help of suspend_again support.
326 326
327config CHARGER_MAX14577 327config CHARGER_MAX14577
328 tristate "Maxim MAX14577 MUIC battery charger driver" 328 tristate "Maxim MAX14577/77836 battery charger driver"
329 depends on MFD_MAX14577 329 depends on MFD_MAX14577
330 select SYSFS
330 help 331 help
331 Say Y to enable support for the battery charger control sysfs and 332 Say Y to enable support for the battery charger control sysfs and
332 platform data of MAX14577 MUICs. 333 platform data of MAX14577/77836 MUICs.
333 334
334config CHARGER_MAX8997 335config CHARGER_MAX8997
335 tristate "Maxim MAX8997/MAX8966 PMIC battery charger driver" 336 tristate "Maxim MAX8997/MAX8966 PMIC battery charger driver"
diff --git a/drivers/power/max14577_charger.c b/drivers/power/max14577_charger.c
index fad2a75b3604..0a2bc7277026 100644
--- a/drivers/power/max14577_charger.c
+++ b/drivers/power/max14577_charger.c
@@ -1,7 +1,7 @@
1/* 1/*
2 * Battery charger driver for the Maxim 14577 2 * max14577_charger.c - Battery charger driver for the Maxim 14577/77836
3 * 3 *
4 * Copyright (C) 2013 Samsung Electronics 4 * Copyright (C) 2013,2014 Samsung Electronics
5 * Krzysztof Kozlowski <k.kozlowski@samsung.com> 5 * Krzysztof Kozlowski <k.kozlowski@samsung.com>
6 * 6 *
7 * This program is free software; you can redistribute it and/or modify 7 * This program is free software; you can redistribute it and/or modify
@@ -19,16 +19,44 @@
19#include <linux/platform_device.h> 19#include <linux/platform_device.h>
20#include <linux/power_supply.h> 20#include <linux/power_supply.h>
21#include <linux/mfd/max14577-private.h> 21#include <linux/mfd/max14577-private.h>
22#include <linux/mfd/max14577.h>
22 23
23struct max14577_charger { 24struct max14577_charger {
24 struct device *dev; 25 struct device *dev;
25 struct max14577 *max14577; 26 struct max14577 *max14577;
26 struct power_supply charger; 27 struct power_supply charger;
27 28
28 unsigned int charging_state; 29 unsigned int charging_state;
29 unsigned int battery_state; 30 unsigned int battery_state;
31
32 struct max14577_charger_platform_data *pdata;
30}; 33};
31 34
35/*
36 * Helper function for mapping values of STATUS2/CHGTYP register on max14577
37 * and max77836 chipsets to enum maxim_muic_charger_type.
38 */
39static enum max14577_muic_charger_type maxim_get_charger_type(
40 enum maxim_device_type dev_type, u8 val) {
41 switch (val) {
42 case MAX14577_CHARGER_TYPE_NONE:
43 case MAX14577_CHARGER_TYPE_USB:
44 case MAX14577_CHARGER_TYPE_DOWNSTREAM_PORT:
45 case MAX14577_CHARGER_TYPE_DEDICATED_CHG:
46 case MAX14577_CHARGER_TYPE_SPECIAL_500MA:
47 case MAX14577_CHARGER_TYPE_SPECIAL_1A:
48 return val;
49 case MAX14577_CHARGER_TYPE_DEAD_BATTERY:
50 case MAX14577_CHARGER_TYPE_RESERVED:
51 if (dev_type == MAXIM_DEVICE_TYPE_MAX77836)
52 val |= 0x8;
53 return val;
54 default:
55 WARN_ONCE(1, "max14577: Unsupported chgtyp register value 0x%02x", val);
56 return val;
57 }
58}
59
32static int max14577_get_charger_state(struct max14577_charger *chg) 60static int max14577_get_charger_state(struct max14577_charger *chg)
33{ 61{
34 struct regmap *rmap = chg->max14577->regmap; 62 struct regmap *rmap = chg->max14577->regmap;
@@ -89,19 +117,23 @@ static int max14577_get_online(struct max14577_charger *chg)
89{ 117{
90 struct regmap *rmap = chg->max14577->regmap; 118 struct regmap *rmap = chg->max14577->regmap;
91 u8 reg_data; 119 u8 reg_data;
120 enum max14577_muic_charger_type chg_type;
92 121
93 max14577_read_reg(rmap, MAX14577_MUIC_REG_STATUS2, &reg_data); 122 max14577_read_reg(rmap, MAX14577_MUIC_REG_STATUS2, &reg_data);
94 reg_data = ((reg_data & STATUS2_CHGTYP_MASK) >> STATUS2_CHGTYP_SHIFT); 123 reg_data = ((reg_data & STATUS2_CHGTYP_MASK) >> STATUS2_CHGTYP_SHIFT);
95 switch (reg_data) { 124 chg_type = maxim_get_charger_type(chg->max14577->dev_type, reg_data);
125 switch (chg_type) {
96 case MAX14577_CHARGER_TYPE_USB: 126 case MAX14577_CHARGER_TYPE_USB:
97 case MAX14577_CHARGER_TYPE_DEDICATED_CHG: 127 case MAX14577_CHARGER_TYPE_DEDICATED_CHG:
98 case MAX14577_CHARGER_TYPE_SPECIAL_500MA: 128 case MAX14577_CHARGER_TYPE_SPECIAL_500MA:
99 case MAX14577_CHARGER_TYPE_SPECIAL_1A: 129 case MAX14577_CHARGER_TYPE_SPECIAL_1A:
100 case MAX14577_CHARGER_TYPE_DEAD_BATTERY: 130 case MAX14577_CHARGER_TYPE_DEAD_BATTERY:
131 case MAX77836_CHARGER_TYPE_SPECIAL_BIAS:
101 return 1; 132 return 1;
102 case MAX14577_CHARGER_TYPE_NONE: 133 case MAX14577_CHARGER_TYPE_NONE:
103 case MAX14577_CHARGER_TYPE_DOWNSTREAM_PORT: 134 case MAX14577_CHARGER_TYPE_DOWNSTREAM_PORT:
104 case MAX14577_CHARGER_TYPE_RESERVED: 135 case MAX14577_CHARGER_TYPE_RESERVED:
136 case MAX77836_CHARGER_TYPE_RESERVED:
105 default: 137 default:
106 return 0; 138 return 0;
107 } 139 }
@@ -118,10 +150,12 @@ static int max14577_get_battery_health(struct max14577_charger *chg)
118 struct regmap *rmap = chg->max14577->regmap; 150 struct regmap *rmap = chg->max14577->regmap;
119 int state = POWER_SUPPLY_HEALTH_GOOD; 151 int state = POWER_SUPPLY_HEALTH_GOOD;
120 u8 reg_data; 152 u8 reg_data;
153 enum max14577_muic_charger_type chg_type;
121 154
122 max14577_read_reg(rmap, MAX14577_MUIC_REG_STATUS2, &reg_data); 155 max14577_read_reg(rmap, MAX14577_MUIC_REG_STATUS2, &reg_data);
123 reg_data = ((reg_data & STATUS2_CHGTYP_MASK) >> STATUS2_CHGTYP_SHIFT); 156 reg_data = ((reg_data & STATUS2_CHGTYP_MASK) >> STATUS2_CHGTYP_SHIFT);
124 if (reg_data == MAX14577_CHARGER_TYPE_DEAD_BATTERY) { 157 chg_type = maxim_get_charger_type(chg->max14577->dev_type, reg_data);
158 if (chg_type == MAX14577_CHARGER_TYPE_DEAD_BATTERY) {
125 state = POWER_SUPPLY_HEALTH_DEAD; 159 state = POWER_SUPPLY_HEALTH_DEAD;
126 goto state_set; 160 goto state_set;
127 } 161 }
@@ -147,15 +181,131 @@ static int max14577_get_present(struct max14577_charger *chg)
147 return 1; 181 return 1;
148} 182}
149 183
184static int max14577_set_fast_charge_timer(struct max14577_charger *chg,
185 unsigned long hours)
186{
187 u8 reg_data;
188
189 switch (hours) {
190 case 5 ... 7:
191 reg_data = hours - 3;
192 break;
193 case 0:
194 /* Disable */
195 reg_data = 0x7;
196 break;
197 default:
198 dev_err(chg->dev, "Wrong value for Fast-Charge Timer: %lu\n",
199 hours);
200 return -EINVAL;
201 }
202 reg_data <<= CHGCTRL1_TCHW_SHIFT;
203
204 return max14577_update_reg(chg->max14577->regmap,
205 MAX14577_REG_CHGCTRL1, CHGCTRL1_TCHW_MASK, reg_data);
206}
207
208static int max14577_init_constant_voltage(struct max14577_charger *chg,
209 unsigned int uvolt)
210{
211 u8 reg_data;
212
213 if (uvolt < MAXIM_CHARGER_CONSTANT_VOLTAGE_MIN ||
214 uvolt > MAXIM_CHARGER_CONSTANT_VOLTAGE_MAX)
215 return -EINVAL;
216
217 if (uvolt == 4200000)
218 reg_data = 0x0;
219 else if (uvolt == MAXIM_CHARGER_CONSTANT_VOLTAGE_MAX)
220 reg_data = 0x1f;
221 else if (uvolt <= 4280000) {
222 unsigned int val = uvolt;
223
224 val -= MAXIM_CHARGER_CONSTANT_VOLTAGE_MIN;
225 val /= MAXIM_CHARGER_CONSTANT_VOLTAGE_STEP;
226 if (uvolt <= 4180000)
227 reg_data = 0x1 + val;
228 else
229 reg_data = val; /* Fix for gap between 4.18V and 4.22V */
230 } else
231 return -EINVAL;
232
233 reg_data <<= CHGCTRL3_MBCCVWRC_SHIFT;
234
235 return max14577_write_reg(chg->max14577->regmap,
236 MAX14577_CHG_REG_CHG_CTRL3, reg_data);
237}
238
239static int max14577_init_eoc(struct max14577_charger *chg,
240 unsigned int uamp)
241{
242 unsigned int current_bits = 0xf;
243 u8 reg_data;
244
245 switch (chg->max14577->dev_type) {
246 case MAXIM_DEVICE_TYPE_MAX77836:
247 if (uamp < 5000)
248 return -EINVAL; /* Requested current is too low */
249
250 if (uamp >= 7500 && uamp < 10000)
251 current_bits = 0x0;
252 else if (uamp <= 50000) {
253 /* <5000, 7499> and <10000, 50000> */
254 current_bits = uamp / 5000;
255 } else {
256 uamp = min(uamp, 100000U) - 50000U;
257 current_bits = 0xa + uamp / 10000;
258 }
259 break;
260
261 case MAXIM_DEVICE_TYPE_MAX14577:
262 default:
263 if (uamp < MAX14577_CHARGER_EOC_CURRENT_LIMIT_MIN)
264 return -EINVAL; /* Requested current is too low */
265
266 uamp = min(uamp, MAX14577_CHARGER_EOC_CURRENT_LIMIT_MAX);
267 uamp -= MAX14577_CHARGER_EOC_CURRENT_LIMIT_MIN;
268 current_bits = uamp / MAX14577_CHARGER_EOC_CURRENT_LIMIT_STEP;
269 break;
270 }
271
272 reg_data = current_bits << CHGCTRL5_EOCS_SHIFT;
273
274 return max14577_update_reg(chg->max14577->regmap,
275 MAX14577_CHG_REG_CHG_CTRL5, CHGCTRL5_EOCS_MASK,
276 reg_data);
277}
278
279static int max14577_init_fast_charge(struct max14577_charger *chg,
280 unsigned int uamp)
281{
282 u8 reg_data;
283 int ret;
284 const struct maxim_charger_current *limits =
285 &maxim_charger_currents[chg->max14577->dev_type];
286
287 ret = maxim_charger_calc_reg_current(limits, uamp, uamp, &reg_data);
288 if (ret) {
289 dev_err(chg->dev, "Wrong value for fast charge: %u\n", uamp);
290 return ret;
291 }
292
293 return max14577_update_reg(chg->max14577->regmap,
294 MAX14577_CHG_REG_CHG_CTRL4,
295 CHGCTRL4_MBCICHWRCL_MASK | CHGCTRL4_MBCICHWRCH_MASK,
296 reg_data);
297}
298
150/* 299/*
151 * Sets charger registers to proper and safe default values. 300 * Sets charger registers to proper and safe default values.
152 * Some of these values are equal to defaults in MAX14577E 301 * Some of these values are equal to defaults in MAX14577E
153 * data sheet but there are minor differences. 302 * data sheet but there are minor differences.
154 */ 303 */
155static void max14577_charger_reg_init(struct max14577_charger *chg) 304static int max14577_charger_reg_init(struct max14577_charger *chg)
156{ 305{
157 struct regmap *rmap = chg->max14577->regmap; 306 struct regmap *rmap = chg->max14577->regmap;
158 u8 reg_data; 307 u8 reg_data;
308 int ret;
159 309
160 /* 310 /*
161 * Charger-Type Manual Detection, default off (set CHGTYPMAN to 0) 311 * Charger-Type Manual Detection, default off (set CHGTYPMAN to 0)
@@ -167,10 +317,6 @@ static void max14577_charger_reg_init(struct max14577_charger *chg)
167 CDETCTRL1_CHGDETEN_MASK | CDETCTRL1_CHGTYPMAN_MASK, 317 CDETCTRL1_CHGDETEN_MASK | CDETCTRL1_CHGTYPMAN_MASK,
168 reg_data); 318 reg_data);
169 319
170 /* Battery Fast-Charge Timer, from SM-V700: 6hrs */
171 reg_data = 0x3 << CHGCTRL1_TCHW_SHIFT;
172 max14577_write_reg(rmap, MAX14577_REG_CHGCTRL1, reg_data);
173
174 /* 320 /*
175 * Wall-Adapter Rapid Charge, default on 321 * Wall-Adapter Rapid Charge, default on
176 * Battery-Charger, default on 322 * Battery-Charger, default on
@@ -179,29 +325,46 @@ static void max14577_charger_reg_init(struct max14577_charger *chg)
179 reg_data |= 0x1 << CHGCTRL2_MBCHOSTEN_SHIFT; 325 reg_data |= 0x1 << CHGCTRL2_MBCHOSTEN_SHIFT;
180 max14577_write_reg(rmap, MAX14577_REG_CHGCTRL2, reg_data); 326 max14577_write_reg(rmap, MAX14577_REG_CHGCTRL2, reg_data);
181 327
182 /* Battery-Charger Constant Voltage (CV) Mode, from SM-V700: 4.35V */
183 reg_data = 0xf << CHGCTRL3_MBCCVWRC_SHIFT;
184 max14577_write_reg(rmap, MAX14577_REG_CHGCTRL3, reg_data);
185
186 /*
187 * Fast Battery-Charge Current Low, default 200-950mA
188 * Fast Battery-Charge Current High, from SM-V700: 450mA
189 */
190 reg_data = 0x1 << CHGCTRL4_MBCICHWRCL_SHIFT;
191 reg_data |= 0x5 << CHGCTRL4_MBCICHWRCH_SHIFT;
192 max14577_write_reg(rmap, MAX14577_REG_CHGCTRL4, reg_data);
193
194 /* End-of-Charge Current, from SM-V700: 50mA */
195 reg_data = 0x0 << CHGCTRL5_EOCS_SHIFT;
196 max14577_write_reg(rmap, MAX14577_REG_CHGCTRL5, reg_data);
197
198 /* Auto Charging Stop, default off */ 328 /* Auto Charging Stop, default off */
199 reg_data = 0x0 << CHGCTRL6_AUTOSTOP_SHIFT; 329 reg_data = 0x0 << CHGCTRL6_AUTOSTOP_SHIFT;
200 max14577_write_reg(rmap, MAX14577_REG_CHGCTRL6, reg_data); 330 max14577_write_reg(rmap, MAX14577_REG_CHGCTRL6, reg_data);
201 331
202 /* Overvoltage-Protection Threshold, from SM-V700: 6.5V */ 332 ret = max14577_init_constant_voltage(chg, chg->pdata->constant_uvolt);
203 reg_data = 0x2 << CHGCTRL7_OTPCGHCVS_SHIFT; 333 if (ret)
334 return ret;
335
336 ret = max14577_init_eoc(chg, chg->pdata->eoc_uamp);
337 if (ret)
338 return ret;
339
340 ret = max14577_init_fast_charge(chg, chg->pdata->fast_charge_uamp);
341 if (ret)
342 return ret;
343
344 ret = max14577_set_fast_charge_timer(chg,
345 MAXIM_CHARGER_FAST_CHARGE_TIMER_DEFAULT);
346 if (ret)
347 return ret;
348
349 /* Initialize Overvoltage-Protection Threshold */
350 switch (chg->pdata->ovp_uvolt) {
351 case 7500000:
352 reg_data = 0x0;
353 break;
354 case 6000000:
355 case 6500000:
356 case 7000000:
357 reg_data = 0x1 + (chg->pdata->ovp_uvolt - 6000000) / 500000;
358 break;
359 default:
360 dev_err(chg->dev, "Wrong value for OVP: %u\n",
361 chg->pdata->ovp_uvolt);
362 return -EINVAL;
363 }
364 reg_data <<= CHGCTRL7_OTPCGHCVS_SHIFT;
204 max14577_write_reg(rmap, MAX14577_REG_CHGCTRL7, reg_data); 365 max14577_write_reg(rmap, MAX14577_REG_CHGCTRL7, reg_data);
366
367 return 0;
205} 368}
206 369
207/* Support property from charger */ 370/* Support property from charger */
@@ -215,7 +378,11 @@ static enum power_supply_property max14577_charger_props[] = {
215 POWER_SUPPLY_PROP_MANUFACTURER, 378 POWER_SUPPLY_PROP_MANUFACTURER,
216}; 379};
217 380
218static const char *model_name = "MAX14577"; 381static const char * const model_names[] = {
382 [MAXIM_DEVICE_TYPE_UNKNOWN] = "MAX14577-like",
383 [MAXIM_DEVICE_TYPE_MAX14577] = "MAX14577",
384 [MAXIM_DEVICE_TYPE_MAX77836] = "MAX77836",
385};
219static const char *manufacturer = "Maxim Integrated"; 386static const char *manufacturer = "Maxim Integrated";
220 387
221static int max14577_charger_get_property(struct power_supply *psy, 388static int max14577_charger_get_property(struct power_supply *psy,
@@ -244,7 +411,8 @@ static int max14577_charger_get_property(struct power_supply *psy,
244 val->intval = max14577_get_online(chg); 411 val->intval = max14577_get_online(chg);
245 break; 412 break;
246 case POWER_SUPPLY_PROP_MODEL_NAME: 413 case POWER_SUPPLY_PROP_MODEL_NAME:
247 val->strval = model_name; 414 BUILD_BUG_ON(ARRAY_SIZE(model_names) != MAXIM_DEVICE_TYPE_NUM);
415 val->strval = model_names[chg->max14577->dev_type];
248 break; 416 break;
249 case POWER_SUPPLY_PROP_MANUFACTURER: 417 case POWER_SUPPLY_PROP_MANUFACTURER:
250 val->strval = manufacturer; 418 val->strval = manufacturer;
@@ -256,6 +424,110 @@ static int max14577_charger_get_property(struct power_supply *psy,
256 return ret; 424 return ret;
257} 425}
258 426
427#ifdef CONFIG_OF
428static struct max14577_charger_platform_data *max14577_charger_dt_init(
429 struct platform_device *pdev)
430{
431 struct max14577_charger_platform_data *pdata;
432 struct device_node *np = pdev->dev.of_node;
433 int ret;
434
435 if (!np) {
436 dev_err(&pdev->dev, "No charger OF node\n");
437 return ERR_PTR(-EINVAL);
438 }
439
440 pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
441 if (!pdata)
442 return ERR_PTR(-ENOMEM);
443
444 ret = of_property_read_u32(np, "maxim,constant-uvolt",
445 &pdata->constant_uvolt);
446 if (ret) {
447 dev_err(&pdev->dev, "Cannot parse maxim,constant-uvolt field from DT\n");
448 return ERR_PTR(ret);
449 }
450
451 ret = of_property_read_u32(np, "maxim,fast-charge-uamp",
452 &pdata->fast_charge_uamp);
453 if (ret) {
454 dev_err(&pdev->dev, "Cannot parse maxim,fast-charge-uamp field from DT\n");
455 return ERR_PTR(ret);
456 }
457
458 ret = of_property_read_u32(np, "maxim,eoc-uamp", &pdata->eoc_uamp);
459 if (ret) {
460 dev_err(&pdev->dev, "Cannot parse maxim,eoc-uamp field from DT\n");
461 return ERR_PTR(ret);
462 }
463
464 ret = of_property_read_u32(np, "maxim,ovp-uvolt", &pdata->ovp_uvolt);
465 if (ret) {
466 dev_err(&pdev->dev, "Cannot parse maxim,ovp-uvolt field from DT\n");
467 return ERR_PTR(ret);
468 }
469
470 return pdata;
471}
472#else /* CONFIG_OF */
473static struct max14577_charger_platform_data *max14577_charger_dt_init(
474 struct platform_device *pdev)
475{
476 return NULL;
477}
478#endif /* CONFIG_OF */
479
480static ssize_t show_fast_charge_timer(struct device *dev,
481 struct device_attribute *attr, char *buf)
482{
483 struct max14577_charger *chg = dev_get_drvdata(dev);
484 u8 reg_data;
485 int ret;
486 unsigned int val;
487
488 ret = max14577_read_reg(chg->max14577->regmap, MAX14577_REG_CHGCTRL1,
489 &reg_data);
490 if (ret)
491 return ret;
492
493 reg_data &= CHGCTRL1_TCHW_MASK;
494 reg_data >>= CHGCTRL1_TCHW_SHIFT;
495 switch (reg_data) {
496 case 0x2 ... 0x4:
497 val = reg_data + 3;
498 break;
499 case 0x7:
500 val = 0;
501 break;
502 default:
503 val = 5;
504 break;
505 }
506
507 return scnprintf(buf, PAGE_SIZE, "%u\n", val);
508}
509
510static ssize_t store_fast_charge_timer(struct device *dev,
511 struct device_attribute *attr, const char *buf, size_t count)
512{
513 struct max14577_charger *chg = dev_get_drvdata(dev);
514 unsigned long val;
515 int ret;
516
517 ret = kstrtoul(buf, 10, &val);
518 if (ret)
519 return ret;
520
521 ret = max14577_set_fast_charge_timer(chg, val);
522 if (ret)
523 return ret;
524
525 return count;
526}
527
528static DEVICE_ATTR(fast_charge_timer, S_IRUGO | S_IWUSR,
529 show_fast_charge_timer, store_fast_charge_timer);
530
259static int max14577_charger_probe(struct platform_device *pdev) 531static int max14577_charger_probe(struct platform_device *pdev)
260{ 532{
261 struct max14577_charger *chg; 533 struct max14577_charger *chg;
@@ -270,7 +542,13 @@ static int max14577_charger_probe(struct platform_device *pdev)
270 chg->dev = &pdev->dev; 542 chg->dev = &pdev->dev;
271 chg->max14577 = max14577; 543 chg->max14577 = max14577;
272 544
273 max14577_charger_reg_init(chg); 545 chg->pdata = max14577_charger_dt_init(pdev);
546 if (IS_ERR_OR_NULL(chg->pdata))
547 return PTR_ERR(chg->pdata);
548
549 ret = max14577_charger_reg_init(chg);
550 if (ret)
551 return ret;
274 552
275 chg->charger.name = "max14577-charger", 553 chg->charger.name = "max14577-charger",
276 chg->charger.type = POWER_SUPPLY_TYPE_BATTERY, 554 chg->charger.type = POWER_SUPPLY_TYPE_BATTERY,
@@ -278,24 +556,47 @@ static int max14577_charger_probe(struct platform_device *pdev)
278 chg->charger.num_properties = ARRAY_SIZE(max14577_charger_props), 556 chg->charger.num_properties = ARRAY_SIZE(max14577_charger_props),
279 chg->charger.get_property = max14577_charger_get_property, 557 chg->charger.get_property = max14577_charger_get_property,
280 558
559 ret = device_create_file(&pdev->dev, &dev_attr_fast_charge_timer);
560 if (ret) {
561 dev_err(&pdev->dev, "failed: create sysfs entry\n");
562 return ret;
563 }
564
281 ret = power_supply_register(&pdev->dev, &chg->charger); 565 ret = power_supply_register(&pdev->dev, &chg->charger);
282 if (ret) { 566 if (ret) {
283 dev_err(&pdev->dev, "failed: power supply register\n"); 567 dev_err(&pdev->dev, "failed: power supply register\n");
284 return ret; 568 goto err;
285 } 569 }
286 570
571 /* Check for valid values for charger */
572 BUILD_BUG_ON(MAX14577_CHARGER_EOC_CURRENT_LIMIT_MIN +
573 MAX14577_CHARGER_EOC_CURRENT_LIMIT_STEP * 0xf !=
574 MAX14577_CHARGER_EOC_CURRENT_LIMIT_MAX);
287 return 0; 575 return 0;
576
577err:
578 device_remove_file(&pdev->dev, &dev_attr_fast_charge_timer);
579
580 return ret;
288} 581}
289 582
290static int max14577_charger_remove(struct platform_device *pdev) 583static int max14577_charger_remove(struct platform_device *pdev)
291{ 584{
292 struct max14577_charger *chg = platform_get_drvdata(pdev); 585 struct max14577_charger *chg = platform_get_drvdata(pdev);
293 586
587 device_remove_file(&pdev->dev, &dev_attr_fast_charge_timer);
294 power_supply_unregister(&chg->charger); 588 power_supply_unregister(&chg->charger);
295 589
296 return 0; 590 return 0;
297} 591}
298 592
593static const struct platform_device_id max14577_charger_id[] = {
594 { "max14577-charger", MAXIM_DEVICE_TYPE_MAX14577, },
595 { "max77836-charger", MAXIM_DEVICE_TYPE_MAX77836, },
596 { }
597};
598MODULE_DEVICE_TABLE(platform, max14577_charger_id);
599
299static struct platform_driver max14577_charger_driver = { 600static struct platform_driver max14577_charger_driver = {
300 .driver = { 601 .driver = {
301 .owner = THIS_MODULE, 602 .owner = THIS_MODULE,
@@ -303,9 +604,10 @@ static struct platform_driver max14577_charger_driver = {
303 }, 604 },
304 .probe = max14577_charger_probe, 605 .probe = max14577_charger_probe,
305 .remove = max14577_charger_remove, 606 .remove = max14577_charger_remove,
607 .id_table = max14577_charger_id,
306}; 608};
307module_platform_driver(max14577_charger_driver); 609module_platform_driver(max14577_charger_driver);
308 610
309MODULE_AUTHOR("Krzysztof Kozlowski <k.kozlowski@samsung.com>"); 611MODULE_AUTHOR("Krzysztof Kozlowski <k.kozlowski@samsung.com>");
310MODULE_DESCRIPTION("MAXIM 14577 charger driver"); 612MODULE_DESCRIPTION("Maxim 14577/77836 charger driver");
311MODULE_LICENSE("GPL"); 613MODULE_LICENSE("GPL");
diff --git a/drivers/power/max17040_battery.c b/drivers/power/max17040_battery.c
index 0fbac861080d..14d44706327b 100644
--- a/drivers/power/max17040_battery.c
+++ b/drivers/power/max17040_battery.c
@@ -277,7 +277,8 @@ static SIMPLE_DEV_PM_OPS(max17040_pm_ops, max17040_suspend, max17040_resume);
277#endif /* CONFIG_PM_SLEEP */ 277#endif /* CONFIG_PM_SLEEP */
278 278
279static const struct i2c_device_id max17040_id[] = { 279static const struct i2c_device_id max17040_id[] = {
280 { "max17040", 0 }, 280 { "max17040" },
281 { "max77836-battery" },
281 { } 282 { }
282}; 283};
283MODULE_DEVICE_TABLE(i2c, max17040_id); 284MODULE_DEVICE_TABLE(i2c, max17040_id);
diff --git a/drivers/regulator/max14577.c b/drivers/regulator/max14577.c
index 5d9c605cf534..0ff5a20ac958 100644
--- a/drivers/regulator/max14577.c
+++ b/drivers/regulator/max14577.c
@@ -22,42 +22,6 @@
22#include <linux/mfd/max14577-private.h> 22#include <linux/mfd/max14577-private.h>
23#include <linux/regulator/of_regulator.h> 23#include <linux/regulator/of_regulator.h>
24 24
25/*
26 * Valid limits of current for max14577 and max77836 chargers.
27 * They must correspond to MBCICHWRCL and MBCICHWRCH fields in CHGCTRL4
28 * register for given chipset.
29 */
30struct maxim_charger_current {
31 /* Minimal current, set in CHGCTRL4/MBCICHWRCL, uA */
32 unsigned int min;
33 /*
34 * Minimal current when high setting is active,
35 * set in CHGCTRL4/MBCICHWRCH, uA
36 */
37 unsigned int high_start;
38 /* Value of one step in high setting, uA */
39 unsigned int high_step;
40 /* Maximum current of high setting, uA */
41 unsigned int max;
42};
43
44/* Table of valid charger currents for different Maxim chipsets */
45static const struct maxim_charger_current maxim_charger_currents[] = {
46 [MAXIM_DEVICE_TYPE_UNKNOWN] = { 0, 0, 0, 0 },
47 [MAXIM_DEVICE_TYPE_MAX14577] = {
48 .min = MAX14577_REGULATOR_CURRENT_LIMIT_MIN,
49 .high_start = MAX14577_REGULATOR_CURRENT_LIMIT_HIGH_START,
50 .high_step = MAX14577_REGULATOR_CURRENT_LIMIT_HIGH_STEP,
51 .max = MAX14577_REGULATOR_CURRENT_LIMIT_MAX,
52 },
53 [MAXIM_DEVICE_TYPE_MAX77836] = {
54 .min = MAX77836_REGULATOR_CURRENT_LIMIT_MIN,
55 .high_start = MAX77836_REGULATOR_CURRENT_LIMIT_HIGH_START,
56 .high_step = MAX77836_REGULATOR_CURRENT_LIMIT_HIGH_STEP,
57 .max = MAX77836_REGULATOR_CURRENT_LIMIT_MAX,
58 },
59};
60
61static int max14577_reg_is_enabled(struct regulator_dev *rdev) 25static int max14577_reg_is_enabled(struct regulator_dev *rdev)
62{ 26{
63 int rid = rdev_get_id(rdev); 27 int rid = rdev_get_id(rdev);
@@ -103,8 +67,8 @@ static int max14577_reg_get_current_limit(struct regulator_dev *rdev)
103static int max14577_reg_set_current_limit(struct regulator_dev *rdev, 67static int max14577_reg_set_current_limit(struct regulator_dev *rdev,
104 int min_uA, int max_uA) 68 int min_uA, int max_uA)
105{ 69{
106 int i, current_bits = 0xf;
107 u8 reg_data; 70 u8 reg_data;
71 int ret;
108 struct max14577 *max14577 = rdev_get_drvdata(rdev); 72 struct max14577 *max14577 = rdev_get_drvdata(rdev);
109 const struct maxim_charger_current *limits = 73 const struct maxim_charger_current *limits =
110 &maxim_charger_currents[max14577->dev_type]; 74 &maxim_charger_currents[max14577->dev_type];
@@ -112,35 +76,9 @@ static int max14577_reg_set_current_limit(struct regulator_dev *rdev,
112 if (rdev_get_id(rdev) != MAX14577_CHARGER) 76 if (rdev_get_id(rdev) != MAX14577_CHARGER)
113 return -EINVAL; 77 return -EINVAL;
114 78
115 if (min_uA > limits->max || max_uA < limits->min) 79 ret = maxim_charger_calc_reg_current(limits, min_uA, max_uA, &reg_data);
116 return -EINVAL; 80 if (ret)
117 81 return ret;
118 if (max_uA < limits->high_start) {
119 /*
120 * Less than high_start,
121 * so set the minimal current (turn only Low Bit off)
122 */
123 u8 reg_data = 0x0 << CHGCTRL4_MBCICHWRCL_SHIFT;
124 return max14577_update_reg(rdev->regmap,
125 MAX14577_CHG_REG_CHG_CTRL4,
126 CHGCTRL4_MBCICHWRCL_MASK, reg_data);
127 }
128
129 /*
130 * max_uA is in range: <high_start, inifinite>, so search for
131 * valid current starting from maximum current.
132 */
133 for (i = limits->max; i >= limits->high_start; i -= limits->high_step) {
134 if (i <= max_uA)
135 break;
136 current_bits--;
137 }
138 BUG_ON(current_bits < 0); /* Cannot happen */
139
140 /* Turn Low Bit on (use range high_start-max)... */
141 reg_data = 0x1 << CHGCTRL4_MBCICHWRCL_SHIFT;
142 /* and set proper High Bits */
143 reg_data |= current_bits << CHGCTRL4_MBCICHWRCH_SHIFT;
144 82
145 return max14577_update_reg(rdev->regmap, MAX14577_CHG_REG_CHG_CTRL4, 83 return max14577_update_reg(rdev->regmap, MAX14577_CHG_REG_CHG_CTRL4,
146 CHGCTRL4_MBCICHWRCL_MASK | CHGCTRL4_MBCICHWRCH_MASK, 84 CHGCTRL4_MBCICHWRCL_MASK | CHGCTRL4_MBCICHWRCH_MASK,
@@ -442,16 +380,6 @@ static struct platform_driver max14577_regulator_driver = {
442 380
443static int __init max14577_regulator_init(void) 381static int __init max14577_regulator_init(void)
444{ 382{
445 /* Check for valid values for charger */
446 BUILD_BUG_ON(MAX14577_REGULATOR_CURRENT_LIMIT_HIGH_START +
447 MAX14577_REGULATOR_CURRENT_LIMIT_HIGH_STEP * 0xf !=
448 MAX14577_REGULATOR_CURRENT_LIMIT_MAX);
449 BUILD_BUG_ON(MAX77836_REGULATOR_CURRENT_LIMIT_HIGH_START +
450 MAX77836_REGULATOR_CURRENT_LIMIT_HIGH_STEP * 0xf !=
451 MAX77836_REGULATOR_CURRENT_LIMIT_MAX);
452 /* Valid charger current values must be provided for each chipset */
453 BUILD_BUG_ON(ARRAY_SIZE(maxim_charger_currents) != MAXIM_DEVICE_TYPE_NUM);
454
455 BUILD_BUG_ON(ARRAY_SIZE(max14577_supported_regulators) != MAX14577_REGULATOR_NUM); 383 BUILD_BUG_ON(ARRAY_SIZE(max14577_supported_regulators) != MAX14577_REGULATOR_NUM);
456 BUILD_BUG_ON(ARRAY_SIZE(max77836_supported_regulators) != MAX77836_REGULATOR_NUM); 384 BUILD_BUG_ON(ARRAY_SIZE(max77836_supported_regulators) != MAX77836_REGULATOR_NUM);
457 385
diff --git a/include/linux/mfd/max14577-private.h b/include/linux/mfd/max14577-private.h
index 499253604026..f01c1fae4d84 100644
--- a/include/linux/mfd/max14577-private.h
+++ b/include/linux/mfd/max14577-private.h
@@ -72,15 +72,33 @@ enum max14577_muic_reg {
72 MAX14577_MUIC_REG_END, 72 MAX14577_MUIC_REG_END,
73}; 73};
74 74
75/*
76 * Combined charger types for max14577 and max77836.
77 *
78 * On max14577 three lower bits map to STATUS2/CHGTYP field.
79 * However the max77836 has different two last values of STATUS2/CHGTYP.
80 * To indicate the difference enum has two additional values for max77836.
81 * These values are just a register value bitwise OR with 0x8.
82 */
75enum max14577_muic_charger_type { 83enum max14577_muic_charger_type {
76 MAX14577_CHARGER_TYPE_NONE = 0, 84 MAX14577_CHARGER_TYPE_NONE = 0x0,
77 MAX14577_CHARGER_TYPE_USB, 85 MAX14577_CHARGER_TYPE_USB = 0x1,
78 MAX14577_CHARGER_TYPE_DOWNSTREAM_PORT, 86 MAX14577_CHARGER_TYPE_DOWNSTREAM_PORT = 0x2,
79 MAX14577_CHARGER_TYPE_DEDICATED_CHG, 87 MAX14577_CHARGER_TYPE_DEDICATED_CHG = 0x3,
80 MAX14577_CHARGER_TYPE_SPECIAL_500MA, 88 MAX14577_CHARGER_TYPE_SPECIAL_500MA = 0x4,
81 MAX14577_CHARGER_TYPE_SPECIAL_1A, 89 /* Special 1A or 2A charger */
82 MAX14577_CHARGER_TYPE_RESERVED, 90 MAX14577_CHARGER_TYPE_SPECIAL_1A = 0x5,
83 MAX14577_CHARGER_TYPE_DEAD_BATTERY = 7, 91 /* max14577: reserved, used on max77836 */
92 MAX14577_CHARGER_TYPE_RESERVED = 0x6,
93 /* max14577: dead-battery charing with maximum current 100mA */
94 MAX14577_CHARGER_TYPE_DEAD_BATTERY = 0x7,
95 /*
96 * max77836: special charger (bias on D+/D-),
97 * matches register value of 0x6
98 */
99 MAX77836_CHARGER_TYPE_SPECIAL_BIAS = 0xe,
100 /* max77836: reserved, register value 0x7 */
101 MAX77836_CHARGER_TYPE_RESERVED = 0xf,
84}; 102};
85 103
86/* MAX14577 interrupts */ 104/* MAX14577 interrupts */
@@ -121,13 +139,15 @@ enum max14577_muic_charger_type {
121#define STATUS2_CHGTYP_SHIFT 0 139#define STATUS2_CHGTYP_SHIFT 0
122#define STATUS2_CHGDETRUN_SHIFT 3 140#define STATUS2_CHGDETRUN_SHIFT 3
123#define STATUS2_DCDTMR_SHIFT 4 141#define STATUS2_DCDTMR_SHIFT 4
124#define STATUS2_DBCHG_SHIFT 5 142#define MAX14577_STATUS2_DBCHG_SHIFT 5
143#define MAX77836_STATUS2_DXOVP_SHIFT 5
125#define STATUS2_VBVOLT_SHIFT 6 144#define STATUS2_VBVOLT_SHIFT 6
126#define MAX77836_STATUS2_VIDRM_SHIFT 7 145#define MAX77836_STATUS2_VIDRM_SHIFT 7
127#define STATUS2_CHGTYP_MASK (0x7 << STATUS2_CHGTYP_SHIFT) 146#define STATUS2_CHGTYP_MASK (0x7 << STATUS2_CHGTYP_SHIFT)
128#define STATUS2_CHGDETRUN_MASK BIT(STATUS2_CHGDETRUN_SHIFT) 147#define STATUS2_CHGDETRUN_MASK BIT(STATUS2_CHGDETRUN_SHIFT)
129#define STATUS2_DCDTMR_MASK BIT(STATUS2_DCDTMR_SHIFT) 148#define STATUS2_DCDTMR_MASK BIT(STATUS2_DCDTMR_SHIFT)
130#define STATUS2_DBCHG_MASK BIT(STATUS2_DBCHG_SHIFT) 149#define MAX14577_STATUS2_DBCHG_MASK BIT(MAX14577_STATUS2_DBCHG_SHIFT)
150#define MAX77836_STATUS2_DXOVP_MASK BIT(MAX77836_STATUS2_DXOVP_SHIFT)
131#define STATUS2_VBVOLT_MASK BIT(STATUS2_VBVOLT_SHIFT) 151#define STATUS2_VBVOLT_MASK BIT(STATUS2_VBVOLT_SHIFT)
132#define MAX77836_STATUS2_VIDRM_MASK BIT(MAX77836_STATUS2_VIDRM_SHIFT) 152#define MAX77836_STATUS2_VIDRM_MASK BIT(MAX77836_STATUS2_VIDRM_SHIFT)
133 153
@@ -177,9 +197,11 @@ enum max14577_muic_charger_type {
177#define CTRL3_JIGSET_SHIFT 0 197#define CTRL3_JIGSET_SHIFT 0
178#define CTRL3_BOOTSET_SHIFT 2 198#define CTRL3_BOOTSET_SHIFT 2
179#define CTRL3_ADCDBSET_SHIFT 4 199#define CTRL3_ADCDBSET_SHIFT 4
200#define CTRL3_WBTH_SHIFT 6
180#define CTRL3_JIGSET_MASK (0x3 << CTRL3_JIGSET_SHIFT) 201#define CTRL3_JIGSET_MASK (0x3 << CTRL3_JIGSET_SHIFT)
181#define CTRL3_BOOTSET_MASK (0x3 << CTRL3_BOOTSET_SHIFT) 202#define CTRL3_BOOTSET_MASK (0x3 << CTRL3_BOOTSET_SHIFT)
182#define CTRL3_ADCDBSET_MASK (0x3 << CTRL3_ADCDBSET_SHIFT) 203#define CTRL3_ADCDBSET_MASK (0x3 << CTRL3_ADCDBSET_SHIFT)
204#define CTRL3_WBTH_MASK (0x3 << CTRL3_WBTH_SHIFT)
183 205
184/* Slave addr = 0x4A: Charger */ 206/* Slave addr = 0x4A: Charger */
185enum max14577_charger_reg { 207enum max14577_charger_reg {
@@ -210,16 +232,20 @@ enum max14577_charger_reg {
210#define CDETCTRL1_CHGTYPMAN_SHIFT 1 232#define CDETCTRL1_CHGTYPMAN_SHIFT 1
211#define CDETCTRL1_DCDEN_SHIFT 2 233#define CDETCTRL1_DCDEN_SHIFT 2
212#define CDETCTRL1_DCD2SCT_SHIFT 3 234#define CDETCTRL1_DCD2SCT_SHIFT 3
213#define CDETCTRL1_DCHKTM_SHIFT 4 235#define MAX14577_CDETCTRL1_DCHKTM_SHIFT 4
214#define CDETCTRL1_DBEXIT_SHIFT 5 236#define MAX77836_CDETCTRL1_CDLY_SHIFT 4
237#define MAX14577_CDETCTRL1_DBEXIT_SHIFT 5
238#define MAX77836_CDETCTRL1_DCDCPL_SHIFT 5
215#define CDETCTRL1_DBIDLE_SHIFT 6 239#define CDETCTRL1_DBIDLE_SHIFT 6
216#define CDETCTRL1_CDPDET_SHIFT 7 240#define CDETCTRL1_CDPDET_SHIFT 7
217#define CDETCTRL1_CHGDETEN_MASK BIT(CDETCTRL1_CHGDETEN_SHIFT) 241#define CDETCTRL1_CHGDETEN_MASK BIT(CDETCTRL1_CHGDETEN_SHIFT)
218#define CDETCTRL1_CHGTYPMAN_MASK BIT(CDETCTRL1_CHGTYPMAN_SHIFT) 242#define CDETCTRL1_CHGTYPMAN_MASK BIT(CDETCTRL1_CHGTYPMAN_SHIFT)
219#define CDETCTRL1_DCDEN_MASK BIT(CDETCTRL1_DCDEN_SHIFT) 243#define CDETCTRL1_DCDEN_MASK BIT(CDETCTRL1_DCDEN_SHIFT)
220#define CDETCTRL1_DCD2SCT_MASK BIT(CDETCTRL1_DCD2SCT_SHIFT) 244#define CDETCTRL1_DCD2SCT_MASK BIT(CDETCTRL1_DCD2SCT_SHIFT)
221#define CDETCTRL1_DCHKTM_MASK BIT(CDETCTRL1_DCHKTM_SHIFT) 245#define MAX14577_CDETCTRL1_DCHKTM_MASK BIT(MAX14577_CDETCTRL1_DCHKTM_SHIFT)
222#define CDETCTRL1_DBEXIT_MASK BIT(CDETCTRL1_DBEXIT_SHIFT) 246#define MAX77836_CDETCTRL1_CDDLY_MASK BIT(MAX77836_CDETCTRL1_CDDLY_SHIFT)
247#define MAX14577_CDETCTRL1_DBEXIT_MASK BIT(MAX14577_CDETCTRL1_DBEXIT_SHIFT)
248#define MAX77836_CDETCTRL1_DCDCPL_MASK BIT(MAX77836_CDETCTRL1_DCDCPL_SHIFT)
223#define CDETCTRL1_DBIDLE_MASK BIT(CDETCTRL1_DBIDLE_SHIFT) 249#define CDETCTRL1_DBIDLE_MASK BIT(CDETCTRL1_DBIDLE_SHIFT)
224#define CDETCTRL1_CDPDET_MASK BIT(CDETCTRL1_CDPDET_SHIFT) 250#define CDETCTRL1_CDPDET_MASK BIT(CDETCTRL1_CDPDET_SHIFT)
225 251
@@ -255,17 +281,36 @@ enum max14577_charger_reg {
255#define CHGCTRL7_OTPCGHCVS_SHIFT 0 281#define CHGCTRL7_OTPCGHCVS_SHIFT 0
256#define CHGCTRL7_OTPCGHCVS_MASK (0x3 << CHGCTRL7_OTPCGHCVS_SHIFT) 282#define CHGCTRL7_OTPCGHCVS_MASK (0x3 << CHGCTRL7_OTPCGHCVS_SHIFT)
257 283
258/* MAX14577 regulator current limits (as in CHGCTRL4 register), uA */ 284/* MAX14577 charger current limits (as in CHGCTRL4 register), uA */
259#define MAX14577_REGULATOR_CURRENT_LIMIT_MIN 90000 285#define MAX14577_CHARGER_CURRENT_LIMIT_MIN 90000U
260#define MAX14577_REGULATOR_CURRENT_LIMIT_HIGH_START 200000 286#define MAX14577_CHARGER_CURRENT_LIMIT_HIGH_START 200000U
261#define MAX14577_REGULATOR_CURRENT_LIMIT_HIGH_STEP 50000 287#define MAX14577_CHARGER_CURRENT_LIMIT_HIGH_STEP 50000U
262#define MAX14577_REGULATOR_CURRENT_LIMIT_MAX 950000 288#define MAX14577_CHARGER_CURRENT_LIMIT_MAX 950000U
263 289
264/* MAX77836 regulator current limits (as in CHGCTRL4 register), uA */ 290/* MAX77836 charger current limits (as in CHGCTRL4 register), uA */
265#define MAX77836_REGULATOR_CURRENT_LIMIT_MIN 45000 291#define MAX77836_CHARGER_CURRENT_LIMIT_MIN 45000U
266#define MAX77836_REGULATOR_CURRENT_LIMIT_HIGH_START 100000 292#define MAX77836_CHARGER_CURRENT_LIMIT_HIGH_START 100000U
267#define MAX77836_REGULATOR_CURRENT_LIMIT_HIGH_STEP 25000 293#define MAX77836_CHARGER_CURRENT_LIMIT_HIGH_STEP 25000U
268#define MAX77836_REGULATOR_CURRENT_LIMIT_MAX 475000 294#define MAX77836_CHARGER_CURRENT_LIMIT_MAX 475000U
295
296/*
297 * MAX14577 charger End-Of-Charge current limits
298 * (as in CHGCTRL5 register), uA
299 */
300#define MAX14577_CHARGER_EOC_CURRENT_LIMIT_MIN 50000U
301#define MAX14577_CHARGER_EOC_CURRENT_LIMIT_STEP 10000U
302#define MAX14577_CHARGER_EOC_CURRENT_LIMIT_MAX 200000U
303
304/*
305 * MAX14577/MAX77836 Battery Constant Voltage
306 * (as in CHGCTRL3 register), uV
307 */
308#define MAXIM_CHARGER_CONSTANT_VOLTAGE_MIN 4000000U
309#define MAXIM_CHARGER_CONSTANT_VOLTAGE_STEP 20000U
310#define MAXIM_CHARGER_CONSTANT_VOLTAGE_MAX 4350000U
311
312/* Default value for fast charge timer, in hours */
313#define MAXIM_CHARGER_FAST_CHARGE_TIMER_DEFAULT 5
269 314
270/* MAX14577 regulator SFOUT LDO voltage, fixed, uV */ 315/* MAX14577 regulator SFOUT LDO voltage, fixed, uV */
271#define MAX14577_REGULATOR_SAFEOUT_VOLTAGE 4900000 316#define MAX14577_REGULATOR_SAFEOUT_VOLTAGE 4900000
diff --git a/include/linux/mfd/max14577.h b/include/linux/mfd/max14577.h
index c83fbed1c7b6..ccfaf952c31b 100644
--- a/include/linux/mfd/max14577.h
+++ b/include/linux/mfd/max14577.h
@@ -54,6 +54,13 @@ struct max14577_regulator_platform_data {
54 struct device_node *of_node; 54 struct device_node *of_node;
55}; 55};
56 56
57struct max14577_charger_platform_data {
58 u32 constant_uvolt;
59 u32 fast_charge_uamp;
60 u32 eoc_uamp;
61 u32 ovp_uvolt;
62};
63
57/* 64/*
58 * MAX14577 MFD platform data 65 * MAX14577 MFD platform data
59 */ 66 */
@@ -74,4 +81,27 @@ struct max14577_platform_data {
74 struct max14577_regulator_platform_data *regulators; 81 struct max14577_regulator_platform_data *regulators;
75}; 82};
76 83
84/*
85 * Valid limits of current for max14577 and max77836 chargers.
86 * They must correspond to MBCICHWRCL and MBCICHWRCH fields in CHGCTRL4
87 * register for given chipset.
88 */
89struct maxim_charger_current {
90 /* Minimal current, set in CHGCTRL4/MBCICHWRCL, uA */
91 unsigned int min;
92 /*
93 * Minimal current when high setting is active,
94 * set in CHGCTRL4/MBCICHWRCH, uA
95 */
96 unsigned int high_start;
97 /* Value of one step in high setting, uA */
98 unsigned int high_step;
99 /* Maximum current of high setting, uA */
100 unsigned int max;
101};
102
103extern const struct maxim_charger_current maxim_charger_currents[];
104extern int maxim_charger_calc_reg_current(const struct maxim_charger_current *limits,
105 unsigned int min_ua, unsigned int max_ua, u8 *dst);
106
77#endif /* __MAX14577_H__ */ 107#endif /* __MAX14577_H__ */
generated by cgit v1.2.2 (git 2.25.0) at 2025-05-27 18:00:22 -0400