1 | // SPDX-License-Identifier: GPL-2.0+ |
2 | // |
3 | // max14577_charger.c - Battery charger driver for the Maxim 14577/77836 |
4 | // |
5 | // Copyright (C) 2013,2014 Samsung Electronics |
6 | // Krzysztof Kozlowski <krzk@kernel.org> |
7 | |
8 | #include <linux/module.h> |
9 | #include <linux/platform_device.h> |
10 | #include <linux/power_supply.h> |
11 | #include <linux/mfd/max14577-private.h> |
12 | #include <linux/mfd/max14577.h> |
13 | |
14 | struct max14577_charger { |
15 | struct device *dev; |
16 | struct max14577 *max14577; |
17 | struct power_supply *charger; |
18 | |
19 | struct max14577_charger_platform_data *pdata; |
20 | }; |
21 | |
22 | /* |
23 | * Helper function for mapping values of STATUS2/CHGTYP register on max14577 |
24 | * and max77836 chipsets to enum maxim_muic_charger_type. |
25 | */ |
26 | static enum max14577_muic_charger_type maxim_get_charger_type( |
27 | enum maxim_device_type dev_type, u8 val) { |
28 | switch (val) { |
29 | case MAX14577_CHARGER_TYPE_NONE: |
30 | case MAX14577_CHARGER_TYPE_USB: |
31 | case MAX14577_CHARGER_TYPE_DOWNSTREAM_PORT: |
32 | case MAX14577_CHARGER_TYPE_DEDICATED_CHG: |
33 | case MAX14577_CHARGER_TYPE_SPECIAL_500MA: |
34 | case MAX14577_CHARGER_TYPE_SPECIAL_1A: |
35 | return val; |
36 | case MAX14577_CHARGER_TYPE_DEAD_BATTERY: |
37 | case MAX14577_CHARGER_TYPE_RESERVED: |
38 | if (dev_type == MAXIM_DEVICE_TYPE_MAX77836) |
39 | val |= 0x8; |
40 | return val; |
41 | default: |
42 | WARN_ONCE(1, "max14577: Unsupported chgtyp register value 0x%02x" , val); |
43 | return val; |
44 | } |
45 | } |
46 | |
47 | static int max14577_get_charger_state(struct max14577_charger *chg, int *val) |
48 | { |
49 | struct regmap *rmap = chg->max14577->regmap; |
50 | int ret; |
51 | u8 reg_data; |
52 | |
53 | /* |
54 | * Charging occurs only if: |
55 | * - CHGCTRL2/MBCHOSTEN == 1 |
56 | * - STATUS2/CGMBC == 1 |
57 | * |
58 | * TODO: |
59 | * - handle FULL after Top-off timer (EOC register may be off |
60 | * and the charger won't be charging although MBCHOSTEN is on) |
61 | * - handle properly dead-battery charging (respect timer) |
62 | * - handle timers (fast-charge and prequal) /MBCCHGERR/ |
63 | */ |
64 | ret = max14577_read_reg(map: rmap, reg: MAX14577_CHG_REG_CHG_CTRL2, dest: ®_data); |
65 | if (ret < 0) |
66 | goto out; |
67 | |
68 | if ((reg_data & CHGCTRL2_MBCHOSTEN_MASK) == 0) { |
69 | *val = POWER_SUPPLY_STATUS_DISCHARGING; |
70 | goto out; |
71 | } |
72 | |
73 | ret = max14577_read_reg(map: rmap, reg: MAX14577_CHG_REG_STATUS3, dest: ®_data); |
74 | if (ret < 0) |
75 | goto out; |
76 | |
77 | if (reg_data & STATUS3_CGMBC_MASK) { |
78 | /* Charger or USB-cable is connected */ |
79 | if (reg_data & STATUS3_EOC_MASK) |
80 | *val = POWER_SUPPLY_STATUS_FULL; |
81 | else |
82 | *val = POWER_SUPPLY_STATUS_CHARGING; |
83 | goto out; |
84 | } |
85 | |
86 | *val = POWER_SUPPLY_STATUS_DISCHARGING; |
87 | |
88 | out: |
89 | return ret; |
90 | } |
91 | |
92 | /* |
93 | * Supported charge types: |
94 | * - POWER_SUPPLY_CHARGE_TYPE_NONE |
95 | * - POWER_SUPPLY_CHARGE_TYPE_FAST |
96 | */ |
97 | static int max14577_get_charge_type(struct max14577_charger *chg, int *val) |
98 | { |
99 | int ret, charging; |
100 | |
101 | /* |
102 | * TODO: CHARGE_TYPE_TRICKLE (VCHGR_RC or EOC)? |
103 | * As spec says: |
104 | * [after reaching EOC interrupt] |
105 | * "When the battery is fully charged, the 30-minute (typ) |
106 | * top-off timer starts. The device continues to trickle |
107 | * charge the battery until the top-off timer runs out." |
108 | */ |
109 | ret = max14577_get_charger_state(chg, val: &charging); |
110 | if (ret < 0) |
111 | return ret; |
112 | |
113 | if (charging == POWER_SUPPLY_STATUS_CHARGING) |
114 | *val = POWER_SUPPLY_CHARGE_TYPE_FAST; |
115 | else |
116 | *val = POWER_SUPPLY_CHARGE_TYPE_NONE; |
117 | |
118 | return 0; |
119 | } |
120 | |
121 | static int max14577_get_online(struct max14577_charger *chg, int *val) |
122 | { |
123 | struct regmap *rmap = chg->max14577->regmap; |
124 | u8 reg_data; |
125 | int ret; |
126 | enum max14577_muic_charger_type chg_type; |
127 | |
128 | ret = max14577_read_reg(map: rmap, reg: MAX14577_MUIC_REG_STATUS2, dest: ®_data); |
129 | if (ret < 0) |
130 | return ret; |
131 | |
132 | reg_data = ((reg_data & STATUS2_CHGTYP_MASK) >> STATUS2_CHGTYP_SHIFT); |
133 | chg_type = maxim_get_charger_type(dev_type: chg->max14577->dev_type, val: reg_data); |
134 | switch (chg_type) { |
135 | case MAX14577_CHARGER_TYPE_USB: |
136 | case MAX14577_CHARGER_TYPE_DEDICATED_CHG: |
137 | case MAX14577_CHARGER_TYPE_SPECIAL_500MA: |
138 | case MAX14577_CHARGER_TYPE_SPECIAL_1A: |
139 | case MAX14577_CHARGER_TYPE_DEAD_BATTERY: |
140 | case MAX77836_CHARGER_TYPE_SPECIAL_BIAS: |
141 | *val = 1; |
142 | break; |
143 | case MAX14577_CHARGER_TYPE_NONE: |
144 | case MAX14577_CHARGER_TYPE_DOWNSTREAM_PORT: |
145 | case MAX14577_CHARGER_TYPE_RESERVED: |
146 | case MAX77836_CHARGER_TYPE_RESERVED: |
147 | default: |
148 | *val = 0; |
149 | } |
150 | |
151 | return 0; |
152 | } |
153 | |
154 | /* |
155 | * Supported health statuses: |
156 | * - POWER_SUPPLY_HEALTH_DEAD |
157 | * - POWER_SUPPLY_HEALTH_OVERVOLTAGE |
158 | * - POWER_SUPPLY_HEALTH_GOOD |
159 | */ |
160 | static int max14577_get_battery_health(struct max14577_charger *chg, int *val) |
161 | { |
162 | struct regmap *rmap = chg->max14577->regmap; |
163 | int ret; |
164 | u8 reg_data; |
165 | enum max14577_muic_charger_type chg_type; |
166 | |
167 | ret = max14577_read_reg(map: rmap, reg: MAX14577_MUIC_REG_STATUS2, dest: ®_data); |
168 | if (ret < 0) |
169 | goto out; |
170 | |
171 | reg_data = ((reg_data & STATUS2_CHGTYP_MASK) >> STATUS2_CHGTYP_SHIFT); |
172 | chg_type = maxim_get_charger_type(dev_type: chg->max14577->dev_type, val: reg_data); |
173 | if (chg_type == MAX14577_CHARGER_TYPE_DEAD_BATTERY) { |
174 | *val = POWER_SUPPLY_HEALTH_DEAD; |
175 | goto out; |
176 | } |
177 | |
178 | ret = max14577_read_reg(map: rmap, reg: MAX14577_CHG_REG_STATUS3, dest: ®_data); |
179 | if (ret < 0) |
180 | goto out; |
181 | |
182 | if (reg_data & STATUS3_OVP_MASK) { |
183 | *val = POWER_SUPPLY_HEALTH_OVERVOLTAGE; |
184 | goto out; |
185 | } |
186 | |
187 | /* Not dead, not overvoltage */ |
188 | *val = POWER_SUPPLY_HEALTH_GOOD; |
189 | |
190 | out: |
191 | return ret; |
192 | } |
193 | |
194 | /* |
195 | * Always returns 1. |
196 | * The max14577 chip doesn't report any status of battery presence. |
197 | * Lets assume that it will always be used with some battery. |
198 | */ |
199 | static int max14577_get_present(struct max14577_charger *chg, int *val) |
200 | { |
201 | *val = 1; |
202 | |
203 | return 0; |
204 | } |
205 | |
206 | static int max14577_set_fast_charge_timer(struct max14577_charger *chg, |
207 | unsigned long hours) |
208 | { |
209 | u8 reg_data; |
210 | |
211 | switch (hours) { |
212 | case 5 ... 7: |
213 | reg_data = hours - 3; |
214 | break; |
215 | case 0: |
216 | /* Disable */ |
217 | reg_data = 0x7; |
218 | break; |
219 | default: |
220 | dev_err(chg->dev, "Wrong value for Fast-Charge Timer: %lu\n" , |
221 | hours); |
222 | return -EINVAL; |
223 | } |
224 | reg_data <<= CHGCTRL1_TCHW_SHIFT; |
225 | |
226 | return max14577_update_reg(map: chg->max14577->regmap, |
227 | reg: MAX14577_REG_CHGCTRL1, CHGCTRL1_TCHW_MASK, val: reg_data); |
228 | } |
229 | |
230 | static int max14577_init_constant_voltage(struct max14577_charger *chg, |
231 | unsigned int uvolt) |
232 | { |
233 | u8 reg_data; |
234 | |
235 | if (uvolt < MAXIM_CHARGER_CONSTANT_VOLTAGE_MIN || |
236 | uvolt > MAXIM_CHARGER_CONSTANT_VOLTAGE_MAX) |
237 | return -EINVAL; |
238 | |
239 | if (uvolt == 4200000) |
240 | reg_data = 0x0; |
241 | else if (uvolt == MAXIM_CHARGER_CONSTANT_VOLTAGE_MAX) |
242 | reg_data = 0x1f; |
243 | else if (uvolt <= 4280000) { |
244 | unsigned int val = uvolt; |
245 | |
246 | val -= MAXIM_CHARGER_CONSTANT_VOLTAGE_MIN; |
247 | val /= MAXIM_CHARGER_CONSTANT_VOLTAGE_STEP; |
248 | if (uvolt <= 4180000) |
249 | reg_data = 0x1 + val; |
250 | else |
251 | reg_data = val; /* Fix for gap between 4.18V and 4.22V */ |
252 | } else |
253 | return -EINVAL; |
254 | |
255 | reg_data <<= CHGCTRL3_MBCCVWRC_SHIFT; |
256 | |
257 | return max14577_write_reg(map: chg->max14577->regmap, |
258 | reg: MAX14577_CHG_REG_CHG_CTRL3, value: reg_data); |
259 | } |
260 | |
261 | static int max14577_init_eoc(struct max14577_charger *chg, |
262 | unsigned int uamp) |
263 | { |
264 | unsigned int current_bits; |
265 | u8 reg_data; |
266 | |
267 | switch (chg->max14577->dev_type) { |
268 | case MAXIM_DEVICE_TYPE_MAX77836: |
269 | if (uamp < 5000) |
270 | return -EINVAL; /* Requested current is too low */ |
271 | |
272 | if (uamp >= 7500 && uamp < 10000) |
273 | current_bits = 0x0; |
274 | else if (uamp <= 50000) { |
275 | /* <5000, 7499> and <10000, 50000> */ |
276 | current_bits = uamp / 5000; |
277 | } else { |
278 | uamp = min(uamp, 100000U) - 50000U; |
279 | current_bits = 0xa + uamp / 10000; |
280 | } |
281 | break; |
282 | |
283 | case MAXIM_DEVICE_TYPE_MAX14577: |
284 | default: |
285 | if (uamp < MAX14577_CHARGER_EOC_CURRENT_LIMIT_MIN) |
286 | return -EINVAL; /* Requested current is too low */ |
287 | |
288 | uamp = min(uamp, MAX14577_CHARGER_EOC_CURRENT_LIMIT_MAX); |
289 | uamp -= MAX14577_CHARGER_EOC_CURRENT_LIMIT_MIN; |
290 | current_bits = uamp / MAX14577_CHARGER_EOC_CURRENT_LIMIT_STEP; |
291 | break; |
292 | } |
293 | |
294 | reg_data = current_bits << CHGCTRL5_EOCS_SHIFT; |
295 | |
296 | return max14577_update_reg(map: chg->max14577->regmap, |
297 | reg: MAX14577_CHG_REG_CHG_CTRL5, CHGCTRL5_EOCS_MASK, |
298 | val: reg_data); |
299 | } |
300 | |
301 | static int max14577_init_fast_charge(struct max14577_charger *chg, |
302 | unsigned int uamp) |
303 | { |
304 | u8 reg_data; |
305 | int ret; |
306 | const struct maxim_charger_current *limits = |
307 | &maxim_charger_currents[chg->max14577->dev_type]; |
308 | |
309 | ret = maxim_charger_calc_reg_current(limits, min_ua: uamp, max_ua: uamp, dst: ®_data); |
310 | if (ret) { |
311 | dev_err(chg->dev, "Wrong value for fast charge: %u\n" , uamp); |
312 | return ret; |
313 | } |
314 | |
315 | return max14577_update_reg(map: chg->max14577->regmap, |
316 | reg: MAX14577_CHG_REG_CHG_CTRL4, |
317 | CHGCTRL4_MBCICHWRCL_MASK | CHGCTRL4_MBCICHWRCH_MASK, |
318 | val: reg_data); |
319 | } |
320 | |
321 | /* |
322 | * Sets charger registers to proper and safe default values. |
323 | * Some of these values are equal to defaults in MAX14577E |
324 | * data sheet but there are minor differences. |
325 | */ |
326 | static int max14577_charger_reg_init(struct max14577_charger *chg) |
327 | { |
328 | struct regmap *rmap = chg->max14577->regmap; |
329 | u8 reg_data; |
330 | int ret; |
331 | |
332 | /* |
333 | * Charger-Type Manual Detection, default off (set CHGTYPMAN to 0) |
334 | * Charger-Detection Enable, default on (set CHGDETEN to 1) |
335 | * Combined mask of CHGDETEN and CHGTYPMAN will zero the CHGTYPMAN bit |
336 | */ |
337 | reg_data = 0x1 << CDETCTRL1_CHGDETEN_SHIFT; |
338 | max14577_update_reg(map: rmap, reg: MAX14577_REG_CDETCTRL1, |
339 | CDETCTRL1_CHGDETEN_MASK | CDETCTRL1_CHGTYPMAN_MASK, |
340 | val: reg_data); |
341 | |
342 | /* |
343 | * Wall-Adapter Rapid Charge, default on |
344 | * Battery-Charger, default on |
345 | */ |
346 | reg_data = 0x1 << CHGCTRL2_VCHGR_RC_SHIFT; |
347 | reg_data |= 0x1 << CHGCTRL2_MBCHOSTEN_SHIFT; |
348 | max14577_write_reg(map: rmap, reg: MAX14577_REG_CHGCTRL2, value: reg_data); |
349 | |
350 | /* Auto Charging Stop, default off */ |
351 | reg_data = 0x0 << CHGCTRL6_AUTOSTOP_SHIFT; |
352 | max14577_write_reg(map: rmap, reg: MAX14577_REG_CHGCTRL6, value: reg_data); |
353 | |
354 | ret = max14577_init_constant_voltage(chg, uvolt: chg->pdata->constant_uvolt); |
355 | if (ret) |
356 | return ret; |
357 | |
358 | ret = max14577_init_eoc(chg, uamp: chg->pdata->eoc_uamp); |
359 | if (ret) |
360 | return ret; |
361 | |
362 | ret = max14577_init_fast_charge(chg, uamp: chg->pdata->fast_charge_uamp); |
363 | if (ret) |
364 | return ret; |
365 | |
366 | ret = max14577_set_fast_charge_timer(chg, |
367 | MAXIM_CHARGER_FAST_CHARGE_TIMER_DEFAULT); |
368 | if (ret) |
369 | return ret; |
370 | |
371 | /* Initialize Overvoltage-Protection Threshold */ |
372 | switch (chg->pdata->ovp_uvolt) { |
373 | case 7500000: |
374 | reg_data = 0x0; |
375 | break; |
376 | case 6000000: |
377 | case 6500000: |
378 | case 7000000: |
379 | reg_data = 0x1 + (chg->pdata->ovp_uvolt - 6000000) / 500000; |
380 | break; |
381 | default: |
382 | dev_err(chg->dev, "Wrong value for OVP: %u\n" , |
383 | chg->pdata->ovp_uvolt); |
384 | return -EINVAL; |
385 | } |
386 | reg_data <<= CHGCTRL7_OTPCGHCVS_SHIFT; |
387 | max14577_write_reg(map: rmap, reg: MAX14577_REG_CHGCTRL7, value: reg_data); |
388 | |
389 | return 0; |
390 | } |
391 | |
392 | /* Support property from charger */ |
393 | static enum power_supply_property max14577_charger_props[] = { |
394 | POWER_SUPPLY_PROP_STATUS, |
395 | POWER_SUPPLY_PROP_CHARGE_TYPE, |
396 | POWER_SUPPLY_PROP_HEALTH, |
397 | POWER_SUPPLY_PROP_PRESENT, |
398 | POWER_SUPPLY_PROP_ONLINE, |
399 | POWER_SUPPLY_PROP_MODEL_NAME, |
400 | POWER_SUPPLY_PROP_MANUFACTURER, |
401 | }; |
402 | |
403 | static const char * const model_names[] = { |
404 | [MAXIM_DEVICE_TYPE_UNKNOWN] = "MAX14577-like" , |
405 | [MAXIM_DEVICE_TYPE_MAX14577] = "MAX14577" , |
406 | [MAXIM_DEVICE_TYPE_MAX77836] = "MAX77836" , |
407 | }; |
408 | static const char *manufacturer = "Maxim Integrated" ; |
409 | |
410 | static int max14577_charger_get_property(struct power_supply *psy, |
411 | enum power_supply_property psp, |
412 | union power_supply_propval *val) |
413 | { |
414 | struct max14577_charger *chg = power_supply_get_drvdata(psy); |
415 | int ret = 0; |
416 | |
417 | switch (psp) { |
418 | case POWER_SUPPLY_PROP_STATUS: |
419 | ret = max14577_get_charger_state(chg, val: &val->intval); |
420 | break; |
421 | case POWER_SUPPLY_PROP_CHARGE_TYPE: |
422 | ret = max14577_get_charge_type(chg, val: &val->intval); |
423 | break; |
424 | case POWER_SUPPLY_PROP_HEALTH: |
425 | ret = max14577_get_battery_health(chg, val: &val->intval); |
426 | break; |
427 | case POWER_SUPPLY_PROP_PRESENT: |
428 | ret = max14577_get_present(chg, val: &val->intval); |
429 | break; |
430 | case POWER_SUPPLY_PROP_ONLINE: |
431 | ret = max14577_get_online(chg, val: &val->intval); |
432 | break; |
433 | case POWER_SUPPLY_PROP_MODEL_NAME: |
434 | BUILD_BUG_ON(ARRAY_SIZE(model_names) != MAXIM_DEVICE_TYPE_NUM); |
435 | val->strval = model_names[chg->max14577->dev_type]; |
436 | break; |
437 | case POWER_SUPPLY_PROP_MANUFACTURER: |
438 | val->strval = manufacturer; |
439 | break; |
440 | default: |
441 | return -EINVAL; |
442 | } |
443 | |
444 | return ret; |
445 | } |
446 | |
447 | static const struct power_supply_desc max14577_charger_desc = { |
448 | .name = "max14577-charger" , |
449 | .type = POWER_SUPPLY_TYPE_BATTERY, |
450 | .properties = max14577_charger_props, |
451 | .num_properties = ARRAY_SIZE(max14577_charger_props), |
452 | .get_property = max14577_charger_get_property, |
453 | }; |
454 | |
455 | #ifdef CONFIG_OF |
456 | static struct max14577_charger_platform_data *max14577_charger_dt_init( |
457 | struct platform_device *pdev) |
458 | { |
459 | struct max14577_charger_platform_data *pdata; |
460 | struct device_node *np = pdev->dev.of_node; |
461 | int ret; |
462 | |
463 | if (!np) { |
464 | dev_err(&pdev->dev, "No charger OF node\n" ); |
465 | return ERR_PTR(error: -EINVAL); |
466 | } |
467 | |
468 | pdata = devm_kzalloc(dev: &pdev->dev, size: sizeof(*pdata), GFP_KERNEL); |
469 | if (!pdata) |
470 | return ERR_PTR(error: -ENOMEM); |
471 | |
472 | ret = of_property_read_u32(np, propname: "maxim,constant-uvolt" , |
473 | out_value: &pdata->constant_uvolt); |
474 | if (ret) { |
475 | dev_err(&pdev->dev, "Cannot parse maxim,constant-uvolt field from DT\n" ); |
476 | return ERR_PTR(error: ret); |
477 | } |
478 | |
479 | ret = of_property_read_u32(np, propname: "maxim,fast-charge-uamp" , |
480 | out_value: &pdata->fast_charge_uamp); |
481 | if (ret) { |
482 | dev_err(&pdev->dev, "Cannot parse maxim,fast-charge-uamp field from DT\n" ); |
483 | return ERR_PTR(error: ret); |
484 | } |
485 | |
486 | ret = of_property_read_u32(np, propname: "maxim,eoc-uamp" , out_value: &pdata->eoc_uamp); |
487 | if (ret) { |
488 | dev_err(&pdev->dev, "Cannot parse maxim,eoc-uamp field from DT\n" ); |
489 | return ERR_PTR(error: ret); |
490 | } |
491 | |
492 | ret = of_property_read_u32(np, propname: "maxim,ovp-uvolt" , out_value: &pdata->ovp_uvolt); |
493 | if (ret) { |
494 | dev_err(&pdev->dev, "Cannot parse maxim,ovp-uvolt field from DT\n" ); |
495 | return ERR_PTR(error: ret); |
496 | } |
497 | |
498 | return pdata; |
499 | } |
500 | #else /* CONFIG_OF */ |
501 | static struct max14577_charger_platform_data *max14577_charger_dt_init( |
502 | struct platform_device *pdev) |
503 | { |
504 | return NULL; |
505 | } |
506 | #endif /* CONFIG_OF */ |
507 | |
508 | static ssize_t show_fast_charge_timer(struct device *dev, |
509 | struct device_attribute *attr, char *buf) |
510 | { |
511 | struct max14577_charger *chg = dev_get_drvdata(dev); |
512 | u8 reg_data; |
513 | int ret; |
514 | unsigned int val; |
515 | |
516 | ret = max14577_read_reg(map: chg->max14577->regmap, reg: MAX14577_REG_CHGCTRL1, |
517 | dest: ®_data); |
518 | if (ret) |
519 | return ret; |
520 | |
521 | reg_data &= CHGCTRL1_TCHW_MASK; |
522 | reg_data >>= CHGCTRL1_TCHW_SHIFT; |
523 | switch (reg_data) { |
524 | case 0x2 ... 0x4: |
525 | val = reg_data + 3; |
526 | break; |
527 | case 0x7: |
528 | val = 0; |
529 | break; |
530 | default: |
531 | val = 5; |
532 | break; |
533 | } |
534 | |
535 | return sysfs_emit(buf, fmt: "%u\n" , val); |
536 | } |
537 | |
538 | static ssize_t store_fast_charge_timer(struct device *dev, |
539 | struct device_attribute *attr, const char *buf, size_t count) |
540 | { |
541 | struct max14577_charger *chg = dev_get_drvdata(dev); |
542 | unsigned long val; |
543 | int ret; |
544 | |
545 | ret = kstrtoul(s: buf, base: 10, res: &val); |
546 | if (ret) |
547 | return ret; |
548 | |
549 | ret = max14577_set_fast_charge_timer(chg, hours: val); |
550 | if (ret) |
551 | return ret; |
552 | |
553 | return count; |
554 | } |
555 | |
556 | static DEVICE_ATTR(fast_charge_timer, S_IRUGO | S_IWUSR, |
557 | show_fast_charge_timer, store_fast_charge_timer); |
558 | |
559 | static int max14577_charger_probe(struct platform_device *pdev) |
560 | { |
561 | struct max14577_charger *chg; |
562 | struct power_supply_config psy_cfg = {}; |
563 | struct max14577 *max14577 = dev_get_drvdata(dev: pdev->dev.parent); |
564 | int ret; |
565 | |
566 | chg = devm_kzalloc(dev: &pdev->dev, size: sizeof(*chg), GFP_KERNEL); |
567 | if (!chg) |
568 | return -ENOMEM; |
569 | |
570 | platform_set_drvdata(pdev, data: chg); |
571 | chg->dev = &pdev->dev; |
572 | chg->max14577 = max14577; |
573 | |
574 | chg->pdata = max14577_charger_dt_init(pdev); |
575 | if (IS_ERR_OR_NULL(ptr: chg->pdata)) |
576 | return PTR_ERR(ptr: chg->pdata); |
577 | |
578 | ret = max14577_charger_reg_init(chg); |
579 | if (ret) |
580 | return ret; |
581 | |
582 | ret = device_create_file(device: &pdev->dev, entry: &dev_attr_fast_charge_timer); |
583 | if (ret) { |
584 | dev_err(&pdev->dev, "failed: create sysfs entry\n" ); |
585 | return ret; |
586 | } |
587 | |
588 | psy_cfg.drv_data = chg; |
589 | chg->charger = power_supply_register(parent: &pdev->dev, desc: &max14577_charger_desc, |
590 | cfg: &psy_cfg); |
591 | if (IS_ERR(ptr: chg->charger)) { |
592 | dev_err(&pdev->dev, "failed: power supply register\n" ); |
593 | ret = PTR_ERR(ptr: chg->charger); |
594 | goto err; |
595 | } |
596 | |
597 | /* Check for valid values for charger */ |
598 | BUILD_BUG_ON(MAX14577_CHARGER_EOC_CURRENT_LIMIT_MIN + |
599 | MAX14577_CHARGER_EOC_CURRENT_LIMIT_STEP * 0xf != |
600 | MAX14577_CHARGER_EOC_CURRENT_LIMIT_MAX); |
601 | return 0; |
602 | |
603 | err: |
604 | device_remove_file(dev: &pdev->dev, attr: &dev_attr_fast_charge_timer); |
605 | |
606 | return ret; |
607 | } |
608 | |
609 | static void max14577_charger_remove(struct platform_device *pdev) |
610 | { |
611 | struct max14577_charger *chg = platform_get_drvdata(pdev); |
612 | |
613 | device_remove_file(dev: &pdev->dev, attr: &dev_attr_fast_charge_timer); |
614 | power_supply_unregister(psy: chg->charger); |
615 | } |
616 | |
617 | static const struct platform_device_id max14577_charger_id[] = { |
618 | { "max14577-charger" , MAXIM_DEVICE_TYPE_MAX14577, }, |
619 | { "max77836-charger" , MAXIM_DEVICE_TYPE_MAX77836, }, |
620 | { } |
621 | }; |
622 | MODULE_DEVICE_TABLE(platform, max14577_charger_id); |
623 | |
624 | static const struct of_device_id of_max14577_charger_dt_match[] = { |
625 | { .compatible = "maxim,max14577-charger" , |
626 | .data = (void *)MAXIM_DEVICE_TYPE_MAX14577, }, |
627 | { .compatible = "maxim,max77836-charger" , |
628 | .data = (void *)MAXIM_DEVICE_TYPE_MAX77836, }, |
629 | { }, |
630 | }; |
631 | MODULE_DEVICE_TABLE(of, of_max14577_charger_dt_match); |
632 | |
633 | static struct platform_driver max14577_charger_driver = { |
634 | .driver = { |
635 | .name = "max14577-charger" , |
636 | .of_match_table = of_max14577_charger_dt_match, |
637 | }, |
638 | .probe = max14577_charger_probe, |
639 | .remove_new = max14577_charger_remove, |
640 | .id_table = max14577_charger_id, |
641 | }; |
642 | module_platform_driver(max14577_charger_driver); |
643 | |
644 | MODULE_AUTHOR("Krzysztof Kozlowski <krzk@kernel.org>" ); |
645 | MODULE_DESCRIPTION("Maxim 14577/77836 charger driver" ); |
646 | MODULE_LICENSE("GPL" ); |
647 | |