1 /*
2 * max77693_charger.c - Battery charger driver for the Maxim 77693
3 *
4 * Copyright (C) 2014 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/power_supply.h>
21 #include <linux/regmap.h>
22 #include <linux/mfd/max77693.h>
23 #include <linux/mfd/max77693-private.h>
24
25 #define MAX77693_CHARGER_NAME "max77693-charger"
26 static const char *max77693_charger_model = "MAX77693";
27 static const char *max77693_charger_manufacturer = "Maxim Integrated";
28
29 struct max77693_charger {
30 struct device *dev;
31 struct max77693_dev *max77693;
32 struct power_supply *charger;
33
34 u32 constant_volt;
35 u32 min_system_volt;
36 u32 thermal_regulation_temp;
37 u32 batttery_overcurrent;
38 u32 charge_input_threshold_volt;
39 };
40
max77693_get_charger_state(struct regmap * regmap,int * val)41 static int max77693_get_charger_state(struct regmap *regmap, int *val)
42 {
43 int ret;
44 unsigned int data;
45
46 ret = regmap_read(regmap, MAX77693_CHG_REG_CHG_DETAILS_01, &data);
47 if (ret < 0)
48 return ret;
49
50 data &= CHG_DETAILS_01_CHG_MASK;
51 data >>= CHG_DETAILS_01_CHG_SHIFT;
52
53 switch (data) {
54 case MAX77693_CHARGING_PREQUALIFICATION:
55 case MAX77693_CHARGING_FAST_CONST_CURRENT:
56 case MAX77693_CHARGING_FAST_CONST_VOLTAGE:
57 case MAX77693_CHARGING_TOP_OFF:
58 /* In high temp the charging current is reduced, but still charging */
59 case MAX77693_CHARGING_HIGH_TEMP:
60 *val = POWER_SUPPLY_STATUS_CHARGING;
61 break;
62 case MAX77693_CHARGING_DONE:
63 *val = POWER_SUPPLY_STATUS_FULL;
64 break;
65 case MAX77693_CHARGING_TIMER_EXPIRED:
66 case MAX77693_CHARGING_THERMISTOR_SUSPEND:
67 *val = POWER_SUPPLY_STATUS_NOT_CHARGING;
68 break;
69 case MAX77693_CHARGING_OFF:
70 case MAX77693_CHARGING_OVER_TEMP:
71 case MAX77693_CHARGING_WATCHDOG_EXPIRED:
72 *val = POWER_SUPPLY_STATUS_DISCHARGING;
73 break;
74 case MAX77693_CHARGING_RESERVED:
75 default:
76 *val = POWER_SUPPLY_STATUS_UNKNOWN;
77 }
78
79 return 0;
80 }
81
max77693_get_charge_type(struct regmap * regmap,int * val)82 static int max77693_get_charge_type(struct regmap *regmap, int *val)
83 {
84 int ret;
85 unsigned int data;
86
87 ret = regmap_read(regmap, MAX77693_CHG_REG_CHG_DETAILS_01, &data);
88 if (ret < 0)
89 return ret;
90
91 data &= CHG_DETAILS_01_CHG_MASK;
92 data >>= CHG_DETAILS_01_CHG_SHIFT;
93
94 switch (data) {
95 case MAX77693_CHARGING_PREQUALIFICATION:
96 /*
97 * Top-off: trickle or fast? In top-off the current varies between
98 * 100 and 250 mA. It is higher than prequalification current.
99 */
100 case MAX77693_CHARGING_TOP_OFF:
101 *val = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
102 break;
103 case MAX77693_CHARGING_FAST_CONST_CURRENT:
104 case MAX77693_CHARGING_FAST_CONST_VOLTAGE:
105 /* In high temp the charging current is reduced, but still charging */
106 case MAX77693_CHARGING_HIGH_TEMP:
107 *val = POWER_SUPPLY_CHARGE_TYPE_FAST;
108 break;
109 case MAX77693_CHARGING_DONE:
110 case MAX77693_CHARGING_TIMER_EXPIRED:
111 case MAX77693_CHARGING_THERMISTOR_SUSPEND:
112 case MAX77693_CHARGING_OFF:
113 case MAX77693_CHARGING_OVER_TEMP:
114 case MAX77693_CHARGING_WATCHDOG_EXPIRED:
115 *val = POWER_SUPPLY_CHARGE_TYPE_NONE;
116 break;
117 case MAX77693_CHARGING_RESERVED:
118 default:
119 *val = POWER_SUPPLY_CHARGE_TYPE_UNKNOWN;
120 }
121
122 return 0;
123 }
124
125 /*
126 * Supported health statuses:
127 * - POWER_SUPPLY_HEALTH_DEAD
128 * - POWER_SUPPLY_HEALTH_GOOD
129 * - POWER_SUPPLY_HEALTH_OVERVOLTAGE
130 * - POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE
131 * - POWER_SUPPLY_HEALTH_UNKNOWN
132 * - POWER_SUPPLY_HEALTH_UNSPEC_FAILURE
133 */
max77693_get_battery_health(struct regmap * regmap,int * val)134 static int max77693_get_battery_health(struct regmap *regmap, int *val)
135 {
136 int ret;
137 unsigned int data;
138
139 ret = regmap_read(regmap, MAX77693_CHG_REG_CHG_DETAILS_01, &data);
140 if (ret < 0)
141 return ret;
142
143 data &= CHG_DETAILS_01_BAT_MASK;
144 data >>= CHG_DETAILS_01_BAT_SHIFT;
145
146 switch (data) {
147 case MAX77693_BATTERY_NOBAT:
148 *val = POWER_SUPPLY_HEALTH_DEAD;
149 break;
150 case MAX77693_BATTERY_PREQUALIFICATION:
151 case MAX77693_BATTERY_GOOD:
152 case MAX77693_BATTERY_LOWVOLTAGE:
153 *val = POWER_SUPPLY_HEALTH_GOOD;
154 break;
155 case MAX77693_BATTERY_TIMER_EXPIRED:
156 /*
157 * Took longer to charge than expected, charging suspended.
158 * Damaged battery?
159 */
160 *val = POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE;
161 break;
162 case MAX77693_BATTERY_OVERVOLTAGE:
163 *val = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
164 break;
165 case MAX77693_BATTERY_OVERCURRENT:
166 *val = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
167 break;
168 case MAX77693_BATTERY_RESERVED:
169 default:
170 *val = POWER_SUPPLY_HEALTH_UNKNOWN;
171 break;
172 }
173
174 return 0;
175 }
176
max77693_get_present(struct regmap * regmap,int * val)177 static int max77693_get_present(struct regmap *regmap, int *val)
178 {
179 unsigned int data;
180 int ret;
181
182 /*
183 * Read CHG_INT_OK register. High DETBAT bit here should be
184 * equal to value 0x0 in CHG_DETAILS_01/BAT field.
185 */
186 ret = regmap_read(regmap, MAX77693_CHG_REG_CHG_INT_OK, &data);
187 if (ret < 0)
188 return ret;
189
190 *val = (data & CHG_INT_OK_DETBAT_MASK) ? 0 : 1;
191
192 return 0;
193 }
194
max77693_get_online(struct regmap * regmap,int * val)195 static int max77693_get_online(struct regmap *regmap, int *val)
196 {
197 unsigned int data;
198 int ret;
199
200 ret = regmap_read(regmap, MAX77693_CHG_REG_CHG_INT_OK, &data);
201 if (ret < 0)
202 return ret;
203
204 *val = (data & CHG_INT_OK_CHGIN_MASK) ? 1 : 0;
205
206 return 0;
207 }
208
209 static enum power_supply_property max77693_charger_props[] = {
210 POWER_SUPPLY_PROP_STATUS,
211 POWER_SUPPLY_PROP_CHARGE_TYPE,
212 POWER_SUPPLY_PROP_HEALTH,
213 POWER_SUPPLY_PROP_PRESENT,
214 POWER_SUPPLY_PROP_ONLINE,
215 POWER_SUPPLY_PROP_MODEL_NAME,
216 POWER_SUPPLY_PROP_MANUFACTURER,
217 };
218
max77693_charger_get_property(struct power_supply * psy,enum power_supply_property psp,union power_supply_propval * val)219 static int max77693_charger_get_property(struct power_supply *psy,
220 enum power_supply_property psp,
221 union power_supply_propval *val)
222 {
223 struct max77693_charger *chg = power_supply_get_drvdata(psy);
224 struct regmap *regmap = chg->max77693->regmap;
225 int ret = 0;
226
227 switch (psp) {
228 case POWER_SUPPLY_PROP_STATUS:
229 ret = max77693_get_charger_state(regmap, &val->intval);
230 break;
231 case POWER_SUPPLY_PROP_CHARGE_TYPE:
232 ret = max77693_get_charge_type(regmap, &val->intval);
233 break;
234 case POWER_SUPPLY_PROP_HEALTH:
235 ret = max77693_get_battery_health(regmap, &val->intval);
236 break;
237 case POWER_SUPPLY_PROP_PRESENT:
238 ret = max77693_get_present(regmap, &val->intval);
239 break;
240 case POWER_SUPPLY_PROP_ONLINE:
241 ret = max77693_get_online(regmap, &val->intval);
242 break;
243 case POWER_SUPPLY_PROP_MODEL_NAME:
244 val->strval = max77693_charger_model;
245 break;
246 case POWER_SUPPLY_PROP_MANUFACTURER:
247 val->strval = max77693_charger_manufacturer;
248 break;
249 default:
250 return -EINVAL;
251 }
252
253 return ret;
254 }
255
256 static const struct power_supply_desc max77693_charger_desc = {
257 .name = MAX77693_CHARGER_NAME,
258 .type = POWER_SUPPLY_TYPE_BATTERY,
259 .properties = max77693_charger_props,
260 .num_properties = ARRAY_SIZE(max77693_charger_props),
261 .get_property = max77693_charger_get_property,
262 };
263
device_attr_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count,int (* fn)(struct max77693_charger *,unsigned long))264 static ssize_t device_attr_store(struct device *dev,
265 struct device_attribute *attr, const char *buf, size_t count,
266 int (*fn)(struct max77693_charger *, unsigned long))
267 {
268 struct max77693_charger *chg = dev_get_drvdata(dev);
269 unsigned long val;
270 int ret;
271
272 ret = kstrtoul(buf, 10, &val);
273 if (ret)
274 return ret;
275
276 ret = fn(chg, val);
277 if (ret)
278 return ret;
279
280 return count;
281 }
282
fast_charge_timer_show(struct device * dev,struct device_attribute * attr,char * buf)283 static ssize_t fast_charge_timer_show(struct device *dev,
284 struct device_attribute *attr, char *buf)
285 {
286 struct max77693_charger *chg = dev_get_drvdata(dev);
287 unsigned int data, val;
288 int ret;
289
290 ret = regmap_read(chg->max77693->regmap, MAX77693_CHG_REG_CHG_CNFG_01,
291 &data);
292 if (ret < 0)
293 return ret;
294
295 data &= CHG_CNFG_01_FCHGTIME_MASK;
296 data >>= CHG_CNFG_01_FCHGTIME_SHIFT;
297 switch (data) {
298 case 0x1 ... 0x7:
299 /* Starting from 4 hours, step by 2 hours */
300 val = 4 + (data - 1) * 2;
301 break;
302 case 0x0:
303 default:
304 val = 0;
305 break;
306 }
307
308 return scnprintf(buf, PAGE_SIZE, "%u\n", val);
309 }
310
max77693_set_fast_charge_timer(struct max77693_charger * chg,unsigned long hours)311 static int max77693_set_fast_charge_timer(struct max77693_charger *chg,
312 unsigned long hours)
313 {
314 unsigned int data;
315
316 /*
317 * 0x00 - disable
318 * 0x01 - 4h
319 * 0x02 - 6h
320 * ...
321 * 0x07 - 16h
322 * Round down odd values.
323 */
324 switch (hours) {
325 case 4 ... 16:
326 data = (hours - 4) / 2 + 1;
327 break;
328 case 0:
329 /* Disable */
330 data = 0;
331 break;
332 default:
333 return -EINVAL;
334 }
335 data <<= CHG_CNFG_01_FCHGTIME_SHIFT;
336
337 return regmap_update_bits(chg->max77693->regmap,
338 MAX77693_CHG_REG_CHG_CNFG_01,
339 CHG_CNFG_01_FCHGTIME_MASK, data);
340 }
341
fast_charge_timer_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)342 static ssize_t fast_charge_timer_store(struct device *dev,
343 struct device_attribute *attr, const char *buf, size_t count)
344 {
345 return device_attr_store(dev, attr, buf, count,
346 max77693_set_fast_charge_timer);
347 }
348
top_off_threshold_current_show(struct device * dev,struct device_attribute * attr,char * buf)349 static ssize_t top_off_threshold_current_show(struct device *dev,
350 struct device_attribute *attr, char *buf)
351 {
352 struct max77693_charger *chg = dev_get_drvdata(dev);
353 unsigned int data, val;
354 int ret;
355
356 ret = regmap_read(chg->max77693->regmap, MAX77693_CHG_REG_CHG_CNFG_03,
357 &data);
358 if (ret < 0)
359 return ret;
360
361 data &= CHG_CNFG_03_TOITH_MASK;
362 data >>= CHG_CNFG_03_TOITH_SHIFT;
363
364 if (data <= 0x04)
365 val = 100000 + data * 25000;
366 else
367 val = data * 50000;
368
369 return scnprintf(buf, PAGE_SIZE, "%u\n", val);
370 }
371
max77693_set_top_off_threshold_current(struct max77693_charger * chg,unsigned long uamp)372 static int max77693_set_top_off_threshold_current(struct max77693_charger *chg,
373 unsigned long uamp)
374 {
375 unsigned int data;
376
377 if (uamp < 100000 || uamp > 350000)
378 return -EINVAL;
379
380 if (uamp <= 200000)
381 data = (uamp - 100000) / 25000;
382 else
383 /* (200000, 350000> */
384 data = uamp / 50000;
385
386 data <<= CHG_CNFG_03_TOITH_SHIFT;
387
388 return regmap_update_bits(chg->max77693->regmap,
389 MAX77693_CHG_REG_CHG_CNFG_03,
390 CHG_CNFG_03_TOITH_MASK, data);
391 }
392
top_off_threshold_current_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)393 static ssize_t top_off_threshold_current_store(struct device *dev,
394 struct device_attribute *attr, const char *buf, size_t count)
395 {
396 return device_attr_store(dev, attr, buf, count,
397 max77693_set_top_off_threshold_current);
398 }
399
top_off_timer_show(struct device * dev,struct device_attribute * attr,char * buf)400 static ssize_t top_off_timer_show(struct device *dev,
401 struct device_attribute *attr, char *buf)
402 {
403 struct max77693_charger *chg = dev_get_drvdata(dev);
404 unsigned int data, val;
405 int ret;
406
407 ret = regmap_read(chg->max77693->regmap, MAX77693_CHG_REG_CHG_CNFG_03,
408 &data);
409 if (ret < 0)
410 return ret;
411
412 data &= CHG_CNFG_03_TOTIME_MASK;
413 data >>= CHG_CNFG_03_TOTIME_SHIFT;
414
415 val = data * 10;
416
417 return scnprintf(buf, PAGE_SIZE, "%u\n", val);
418 }
419
max77693_set_top_off_timer(struct max77693_charger * chg,unsigned long minutes)420 static int max77693_set_top_off_timer(struct max77693_charger *chg,
421 unsigned long minutes)
422 {
423 unsigned int data;
424
425 if (minutes > 70)
426 return -EINVAL;
427
428 data = minutes / 10;
429 data <<= CHG_CNFG_03_TOTIME_SHIFT;
430
431 return regmap_update_bits(chg->max77693->regmap,
432 MAX77693_CHG_REG_CHG_CNFG_03,
433 CHG_CNFG_03_TOTIME_MASK, data);
434 }
435
top_off_timer_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)436 static ssize_t top_off_timer_store(struct device *dev,
437 struct device_attribute *attr, const char *buf, size_t count)
438 {
439 return device_attr_store(dev, attr, buf, count,
440 max77693_set_top_off_timer);
441 }
442
443 static DEVICE_ATTR_RW(fast_charge_timer);
444 static DEVICE_ATTR_RW(top_off_threshold_current);
445 static DEVICE_ATTR_RW(top_off_timer);
446
max77693_set_constant_volt(struct max77693_charger * chg,unsigned int uvolt)447 static int max77693_set_constant_volt(struct max77693_charger *chg,
448 unsigned int uvolt)
449 {
450 unsigned int data;
451
452 /*
453 * 0x00 - 3.650 V
454 * 0x01 - 3.675 V
455 * ...
456 * 0x1b - 4.325 V
457 * 0x1c - 4.340 V
458 * 0x1d - 4.350 V
459 * 0x1e - 4.375 V
460 * 0x1f - 4.400 V
461 */
462 if (uvolt >= 3650000 && uvolt < 4340000)
463 data = (uvolt - 3650000) / 25000;
464 else if (uvolt >= 4340000 && uvolt < 4350000)
465 data = 0x1c;
466 else if (uvolt >= 4350000 && uvolt <= 4400000)
467 data = 0x1d + (uvolt - 4350000) / 25000;
468 else {
469 dev_err(chg->dev, "Wrong value for charging constant voltage\n");
470 return -EINVAL;
471 }
472
473 data <<= CHG_CNFG_04_CHGCVPRM_SHIFT;
474
475 dev_dbg(chg->dev, "Charging constant voltage: %u (0x%x)\n", uvolt,
476 data);
477
478 return regmap_update_bits(chg->max77693->regmap,
479 MAX77693_CHG_REG_CHG_CNFG_04,
480 CHG_CNFG_04_CHGCVPRM_MASK, data);
481 }
482
max77693_set_min_system_volt(struct max77693_charger * chg,unsigned int uvolt)483 static int max77693_set_min_system_volt(struct max77693_charger *chg,
484 unsigned int uvolt)
485 {
486 unsigned int data;
487
488 if (uvolt < 3000000 || uvolt > 3700000) {
489 dev_err(chg->dev, "Wrong value for minimum system regulation voltage\n");
490 return -EINVAL;
491 }
492
493 data = (uvolt - 3000000) / 100000;
494
495 data <<= CHG_CNFG_04_MINVSYS_SHIFT;
496
497 dev_dbg(chg->dev, "Minimum system regulation voltage: %u (0x%x)\n",
498 uvolt, data);
499
500 return regmap_update_bits(chg->max77693->regmap,
501 MAX77693_CHG_REG_CHG_CNFG_04,
502 CHG_CNFG_04_MINVSYS_MASK, data);
503 }
504
max77693_set_thermal_regulation_temp(struct max77693_charger * chg,unsigned int cels)505 static int max77693_set_thermal_regulation_temp(struct max77693_charger *chg,
506 unsigned int cels)
507 {
508 unsigned int data;
509
510 switch (cels) {
511 case 70:
512 case 85:
513 case 100:
514 case 115:
515 data = (cels - 70) / 15;
516 break;
517 default:
518 dev_err(chg->dev, "Wrong value for thermal regulation loop temperature\n");
519 return -EINVAL;
520 }
521
522 data <<= CHG_CNFG_07_REGTEMP_SHIFT;
523
524 dev_dbg(chg->dev, "Thermal regulation loop temperature: %u (0x%x)\n",
525 cels, data);
526
527 return regmap_update_bits(chg->max77693->regmap,
528 MAX77693_CHG_REG_CHG_CNFG_07,
529 CHG_CNFG_07_REGTEMP_MASK, data);
530 }
531
max77693_set_batttery_overcurrent(struct max77693_charger * chg,unsigned int uamp)532 static int max77693_set_batttery_overcurrent(struct max77693_charger *chg,
533 unsigned int uamp)
534 {
535 unsigned int data;
536
537 if (uamp && (uamp < 2000000 || uamp > 3500000)) {
538 dev_err(chg->dev, "Wrong value for battery overcurrent\n");
539 return -EINVAL;
540 }
541
542 if (uamp)
543 data = ((uamp - 2000000) / 250000) + 1;
544 else
545 data = 0; /* disable */
546
547 data <<= CHG_CNFG_12_B2SOVRC_SHIFT;
548
549 dev_dbg(chg->dev, "Battery overcurrent: %u (0x%x)\n", uamp, data);
550
551 return regmap_update_bits(chg->max77693->regmap,
552 MAX77693_CHG_REG_CHG_CNFG_12,
553 CHG_CNFG_12_B2SOVRC_MASK, data);
554 }
555
max77693_set_charge_input_threshold_volt(struct max77693_charger * chg,unsigned int uvolt)556 static int max77693_set_charge_input_threshold_volt(struct max77693_charger *chg,
557 unsigned int uvolt)
558 {
559 unsigned int data;
560
561 switch (uvolt) {
562 case 4300000:
563 data = 0x0;
564 break;
565 case 4700000:
566 case 4800000:
567 case 4900000:
568 data = (uvolt - 4700000) / 100000;
569 default:
570 dev_err(chg->dev, "Wrong value for charge input voltage regulation threshold\n");
571 return -EINVAL;
572 }
573
574 data <<= CHG_CNFG_12_VCHGINREG_SHIFT;
575
576 dev_dbg(chg->dev, "Charge input voltage regulation threshold: %u (0x%x)\n",
577 uvolt, data);
578
579 return regmap_update_bits(chg->max77693->regmap,
580 MAX77693_CHG_REG_CHG_CNFG_12,
581 CHG_CNFG_12_VCHGINREG_MASK, data);
582 }
583
584 /*
585 * Sets charger registers to proper and safe default values.
586 */
max77693_reg_init(struct max77693_charger * chg)587 static int max77693_reg_init(struct max77693_charger *chg)
588 {
589 int ret;
590 unsigned int data;
591
592 /* Unlock charger register protection */
593 data = (0x3 << CHG_CNFG_06_CHGPROT_SHIFT);
594 ret = regmap_update_bits(chg->max77693->regmap,
595 MAX77693_CHG_REG_CHG_CNFG_06,
596 CHG_CNFG_06_CHGPROT_MASK, data);
597 if (ret) {
598 dev_err(chg->dev, "Error unlocking registers: %d\n", ret);
599 return ret;
600 }
601
602 ret = max77693_set_fast_charge_timer(chg, DEFAULT_FAST_CHARGE_TIMER);
603 if (ret)
604 return ret;
605
606 ret = max77693_set_top_off_threshold_current(chg,
607 DEFAULT_TOP_OFF_THRESHOLD_CURRENT);
608 if (ret)
609 return ret;
610
611 ret = max77693_set_top_off_timer(chg, DEFAULT_TOP_OFF_TIMER);
612 if (ret)
613 return ret;
614
615 ret = max77693_set_constant_volt(chg, chg->constant_volt);
616 if (ret)
617 return ret;
618
619 ret = max77693_set_min_system_volt(chg, chg->min_system_volt);
620 if (ret)
621 return ret;
622
623 ret = max77693_set_thermal_regulation_temp(chg,
624 chg->thermal_regulation_temp);
625 if (ret)
626 return ret;
627
628 ret = max77693_set_batttery_overcurrent(chg, chg->batttery_overcurrent);
629 if (ret)
630 return ret;
631
632 return max77693_set_charge_input_threshold_volt(chg,
633 chg->charge_input_threshold_volt);
634 }
635
636 #ifdef CONFIG_OF
max77693_dt_init(struct device * dev,struct max77693_charger * chg)637 static int max77693_dt_init(struct device *dev, struct max77693_charger *chg)
638 {
639 struct device_node *np = dev->of_node;
640
641 if (!np) {
642 dev_err(dev, "no charger OF node\n");
643 return -EINVAL;
644 }
645
646 if (of_property_read_u32(np, "maxim,constant-microvolt",
647 &chg->constant_volt))
648 chg->constant_volt = DEFAULT_CONSTANT_VOLT;
649
650 if (of_property_read_u32(np, "maxim,min-system-microvolt",
651 &chg->min_system_volt))
652 chg->min_system_volt = DEFAULT_MIN_SYSTEM_VOLT;
653
654 if (of_property_read_u32(np, "maxim,thermal-regulation-celsius",
655 &chg->thermal_regulation_temp))
656 chg->thermal_regulation_temp = DEFAULT_THERMAL_REGULATION_TEMP;
657
658 if (of_property_read_u32(np, "maxim,battery-overcurrent-microamp",
659 &chg->batttery_overcurrent))
660 chg->batttery_overcurrent = DEFAULT_BATTERY_OVERCURRENT;
661
662 if (of_property_read_u32(np, "maxim,charge-input-threshold-microvolt",
663 &chg->charge_input_threshold_volt))
664 chg->charge_input_threshold_volt =
665 DEFAULT_CHARGER_INPUT_THRESHOLD_VOLT;
666
667 return 0;
668 }
669 #else /* CONFIG_OF */
max77693_dt_init(struct device * dev,struct max77693_charger * chg)670 static int max77693_dt_init(struct device *dev, struct max77693_charger *chg)
671 {
672 return 0;
673 }
674 #endif /* CONFIG_OF */
675
max77693_charger_probe(struct platform_device * pdev)676 static int max77693_charger_probe(struct platform_device *pdev)
677 {
678 struct max77693_charger *chg;
679 struct power_supply_config psy_cfg = {};
680 struct max77693_dev *max77693 = dev_get_drvdata(pdev->dev.parent);
681 int ret;
682
683 chg = devm_kzalloc(&pdev->dev, sizeof(*chg), GFP_KERNEL);
684 if (!chg)
685 return -ENOMEM;
686
687 platform_set_drvdata(pdev, chg);
688 chg->dev = &pdev->dev;
689 chg->max77693 = max77693;
690
691 ret = max77693_dt_init(&pdev->dev, chg);
692 if (ret)
693 return ret;
694
695 ret = max77693_reg_init(chg);
696 if (ret)
697 return ret;
698
699 psy_cfg.drv_data = chg;
700
701 ret = device_create_file(&pdev->dev, &dev_attr_fast_charge_timer);
702 if (ret) {
703 dev_err(&pdev->dev, "failed: create fast charge timer sysfs entry\n");
704 goto err;
705 }
706
707 ret = device_create_file(&pdev->dev,
708 &dev_attr_top_off_threshold_current);
709 if (ret) {
710 dev_err(&pdev->dev, "failed: create top off current sysfs entry\n");
711 goto err;
712 }
713
714 ret = device_create_file(&pdev->dev, &dev_attr_top_off_timer);
715 if (ret) {
716 dev_err(&pdev->dev, "failed: create top off timer sysfs entry\n");
717 goto err;
718 }
719
720 chg->charger = power_supply_register(&pdev->dev,
721 &max77693_charger_desc,
722 &psy_cfg);
723 if (IS_ERR(chg->charger)) {
724 dev_err(&pdev->dev, "failed: power supply register\n");
725 ret = PTR_ERR(chg->charger);
726 goto err;
727 }
728
729 return 0;
730
731 err:
732 device_remove_file(&pdev->dev, &dev_attr_top_off_timer);
733 device_remove_file(&pdev->dev, &dev_attr_top_off_threshold_current);
734 device_remove_file(&pdev->dev, &dev_attr_fast_charge_timer);
735
736 return ret;
737 }
738
max77693_charger_remove(struct platform_device * pdev)739 static int max77693_charger_remove(struct platform_device *pdev)
740 {
741 struct max77693_charger *chg = platform_get_drvdata(pdev);
742
743 device_remove_file(&pdev->dev, &dev_attr_top_off_timer);
744 device_remove_file(&pdev->dev, &dev_attr_top_off_threshold_current);
745 device_remove_file(&pdev->dev, &dev_attr_fast_charge_timer);
746
747 power_supply_unregister(chg->charger);
748
749 return 0;
750 }
751
752 static const struct platform_device_id max77693_charger_id[] = {
753 { "max77693-charger", 0, },
754 { }
755 };
756 MODULE_DEVICE_TABLE(platform, max77693_charger_id);
757
758 static struct platform_driver max77693_charger_driver = {
759 .driver = {
760 .name = "max77693-charger",
761 },
762 .probe = max77693_charger_probe,
763 .remove = max77693_charger_remove,
764 .id_table = max77693_charger_id,
765 };
766 module_platform_driver(max77693_charger_driver);
767
768 MODULE_AUTHOR("Krzysztof Kozlowski <k.kozlowski@samsung.com>");
769 MODULE_DESCRIPTION("Maxim 77693 charger driver");
770 MODULE_LICENSE("GPL");
771