1 // SPDX-License-Identifier: GPL-2.0-or-later
2
3 #include <linux/devm-helpers.h>
4 #include <linux/delay.h>
5 #include <linux/device.h>
6 #include <linux/err.h>
7 #include <linux/extcon.h>
8 #include <linux/i2c.h>
9 #include <linux/of_graph.h>
10 #include <linux/property.h>
11 #include <linux/interrupt.h>
12 #include <linux/module.h>
13 #include <linux/pm.h>
14 #include <linux/power_supply.h>
15 #include <linux/regmap.h>
16 #include <linux/sysfs.h>
17 #include <linux/types.h>
18
19 #define MAX8971_REG_CHGINT 0x0f
20 #define MAX8971_REG_CHG_RST BIT(0)
21 #define MAX8971_REG_CHGINT_MASK 0x01
22 #define MAX8971_AICL_MASK BIT(7)
23 #define MAX8971_REG_CHG_STAT 0x02
24 #define MAX8971_CHG_MASK BIT(3)
25 #define MAX8971_REG_DETAILS1 0x03
26 #define MAX8971_REG_DETAILS2 0x04
27 #define MAX8971_REG_CHGCNTL1 0x05
28 #define MAX8971_REG_FCHGCRNT 0x06
29 #define MAX8971_REG_DCCRNT 0x07
30 #define MAX8971_CHGRSTRT_MASK BIT(6)
31 #define MAX8971_REG_TOPOFF 0x08
32 #define MAX8971_REG_TEMPREG 0x09
33 #define MAX8971_REG_PROTCMD 0x0a
34 #define MAX8971_CHGPROT_LOCKED 0x00
35 #define MAX8971_CHGPROT_UNLOCKED 0x03
36
37 #define MAX8971_FCHGT_DEFAULT 2
38 #define MAX8971_TOPOFFT_DEFAULT 3
39
40 static const char *max8971_manufacturer = "Maxim Integrated";
41 static const char *max8971_model = "MAX8971";
42
43 enum max8971_charging_state {
44 MAX8971_CHARGING_DEAD_BATTERY,
45 MAX8971_CHARGING_PREQUALIFICATION,
46 MAX8971_CHARGING_FAST_CONST_CURRENT,
47 MAX8971_CHARGING_FAST_CONST_VOLTAGE,
48 MAX8971_CHARGING_TOP_OFF,
49 MAX8971_CHARGING_DONE,
50 MAX8971_CHARGING_TIMER_FAULT,
51 MAX8971_CHARGING_SUSPENDED_THERMAL,
52 MAX8971_CHARGING_OFF,
53 MAX8971_CHARGING_THERMAL_LOOP,
54 };
55
56 enum max8971_health_state {
57 MAX8971_HEALTH_UNKNOWN,
58 MAX8971_HEALTH_COLD,
59 MAX8971_HEALTH_COOL,
60 MAX8971_HEALTH_WARM,
61 MAX8971_HEALTH_HOT,
62 MAX8971_HEALTH_OVERHEAT,
63 };
64
65 /* Fast-Charge current limit, 250..1550 mA, 50 mA steps */
66 #define MAX8971_CHG_CC_STEP 50000U
67 #define MAX8971_CHG_CC_MIN 250000U
68 #define MAX8971_CHG_CC_MAX 1550000U
69
70 /* Input current limit, 250..1500 mA, 25 mA steps */
71 #define MAX8971_DCILMT_STEP 25000U
72 #define MAX8971_DCILMT_MIN 250000U
73 #define MAX8971_DCILMT_MAX 1500000U
74
75 enum max8971_field_idx {
76 THM_DTLS, /* DETAILS1 */
77 BAT_DTLS, CHG_DTLS, /* DETAILS2 */
78 CHG_CC, FCHG_T, /* FCHGCRNT */
79 DCI_LMT, /* DCCRNT */
80 TOPOFF_T, TOPOFF_S, /* TOPOFF */
81 CPROT, /* PROTCMD */
82 MAX8971_N_REGMAP_FIELDS
83 };
84
85 static const struct reg_field max8971_reg_field[MAX8971_N_REGMAP_FIELDS] = {
86 [THM_DTLS] = REG_FIELD(MAX8971_REG_DETAILS1, 0, 2),
87 [BAT_DTLS] = REG_FIELD(MAX8971_REG_DETAILS2, 4, 5),
88 [CHG_DTLS] = REG_FIELD(MAX8971_REG_DETAILS2, 0, 3),
89 [CHG_CC] = REG_FIELD(MAX8971_REG_FCHGCRNT, 0, 4),
90 [FCHG_T] = REG_FIELD(MAX8971_REG_FCHGCRNT, 5, 7),
91 [DCI_LMT] = REG_FIELD(MAX8971_REG_DCCRNT, 0, 5),
92 [TOPOFF_T] = REG_FIELD(MAX8971_REG_TOPOFF, 5, 7),
93 [TOPOFF_S] = REG_FIELD(MAX8971_REG_TOPOFF, 2, 3),
94 [CPROT] = REG_FIELD(MAX8971_REG_PROTCMD, 2, 3),
95 };
96
97 static const struct regmap_config max8971_regmap_config = {
98 .reg_bits = 8,
99 .val_bits = 8,
100 .max_register = MAX8971_REG_CHGINT,
101 };
102
103 struct max8971_data {
104 struct device *dev;
105 struct power_supply *psy_mains;
106
107 struct extcon_dev *edev;
108 struct notifier_block extcon_nb;
109 struct delayed_work extcon_work;
110
111 struct regmap *regmap;
112 struct regmap_field *rfield[MAX8971_N_REGMAP_FIELDS];
113
114 enum power_supply_usb_type usb_type;
115
116 u32 fchgt;
117 u32 tofft;
118 u32 toffs;
119
120 bool present;
121 };
122
max8971_get_status(struct max8971_data * priv,int * val)123 static int max8971_get_status(struct max8971_data *priv, int *val)
124 {
125 u32 regval;
126 int err;
127
128 err = regmap_field_read(priv->rfield[CHG_DTLS], ®val);
129 if (err)
130 return err;
131
132 switch (regval) {
133 case MAX8971_CHARGING_DEAD_BATTERY:
134 case MAX8971_CHARGING_PREQUALIFICATION:
135 case MAX8971_CHARGING_FAST_CONST_CURRENT:
136 case MAX8971_CHARGING_FAST_CONST_VOLTAGE:
137 case MAX8971_CHARGING_TOP_OFF:
138 case MAX8971_CHARGING_THERMAL_LOOP:
139 *val = POWER_SUPPLY_STATUS_CHARGING;
140 break;
141 case MAX8971_CHARGING_DONE:
142 *val = POWER_SUPPLY_STATUS_FULL;
143 break;
144 case MAX8971_CHARGING_TIMER_FAULT:
145 *val = POWER_SUPPLY_STATUS_NOT_CHARGING;
146 break;
147 case MAX8971_CHARGING_OFF:
148 case MAX8971_CHARGING_SUSPENDED_THERMAL:
149 *val = POWER_SUPPLY_STATUS_DISCHARGING;
150 break;
151 default:
152 *val = POWER_SUPPLY_STATUS_UNKNOWN;
153 }
154
155 return 0;
156 }
157
max8971_get_charge_type(struct max8971_data * priv,int * val)158 static int max8971_get_charge_type(struct max8971_data *priv, int *val)
159 {
160 u32 regval;
161 int err;
162
163 err = regmap_field_read(priv->rfield[CHG_DTLS], ®val);
164 if (err)
165 return err;
166
167 switch (regval) {
168 case MAX8971_CHARGING_DEAD_BATTERY:
169 case MAX8971_CHARGING_PREQUALIFICATION:
170 *val = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
171 break;
172 case MAX8971_CHARGING_FAST_CONST_CURRENT:
173 case MAX8971_CHARGING_FAST_CONST_VOLTAGE:
174 *val = POWER_SUPPLY_CHARGE_TYPE_FAST;
175 break;
176 case MAX8971_CHARGING_TOP_OFF:
177 case MAX8971_CHARGING_THERMAL_LOOP:
178 *val = POWER_SUPPLY_CHARGE_TYPE_STANDARD;
179 break;
180 case MAX8971_CHARGING_DONE:
181 case MAX8971_CHARGING_TIMER_FAULT:
182 case MAX8971_CHARGING_SUSPENDED_THERMAL:
183 case MAX8971_CHARGING_OFF:
184 *val = POWER_SUPPLY_CHARGE_TYPE_NONE;
185 break;
186 default:
187 *val = POWER_SUPPLY_CHARGE_TYPE_UNKNOWN;
188 }
189
190 return 0;
191 }
192
max8971_get_health(struct max8971_data * priv,int * val)193 static int max8971_get_health(struct max8971_data *priv, int *val)
194 {
195 u32 regval;
196 int err;
197
198 err = regmap_field_read(priv->rfield[THM_DTLS], ®val);
199 if (err)
200 return err;
201
202 switch (regval) {
203 case MAX8971_HEALTH_COLD:
204 *val = POWER_SUPPLY_HEALTH_COLD;
205 break;
206 case MAX8971_HEALTH_COOL:
207 *val = POWER_SUPPLY_HEALTH_COOL;
208 break;
209 case MAX8971_HEALTH_WARM:
210 *val = POWER_SUPPLY_HEALTH_GOOD;
211 break;
212 case MAX8971_HEALTH_HOT:
213 *val = POWER_SUPPLY_HEALTH_HOT;
214 break;
215 case MAX8971_HEALTH_OVERHEAT:
216 *val = POWER_SUPPLY_HEALTH_OVERHEAT;
217 break;
218 case MAX8971_HEALTH_UNKNOWN:
219 default:
220 *val = POWER_SUPPLY_HEALTH_UNKNOWN;
221 }
222
223 return 0;
224 }
225
max8971_get_online(struct max8971_data * priv,int * val)226 static int max8971_get_online(struct max8971_data *priv, int *val)
227 {
228 u32 regval;
229 int err;
230
231 err = regmap_read(priv->regmap, MAX8971_REG_CHG_STAT, ®val);
232 if (err)
233 return err;
234
235 if (priv->present)
236 /* CHG_OK bit is 0 when charger is online */
237 *val = !(regval & MAX8971_CHG_MASK);
238 else
239 *val = priv->present;
240
241 return 0;
242 }
243
max8971_get_integer(struct max8971_data * priv,enum max8971_field_idx fidx,u32 clamp_min,u32 clamp_max,u32 mult,int * val)244 static int max8971_get_integer(struct max8971_data *priv, enum max8971_field_idx fidx,
245 u32 clamp_min, u32 clamp_max, u32 mult, int *val)
246 {
247 u32 regval;
248 int err;
249
250 err = regmap_field_read(priv->rfield[fidx], ®val);
251 if (err)
252 return err;
253
254 *val = clamp_val(regval * mult, clamp_min, clamp_max);
255
256 return 0;
257 }
258
max8971_set_integer(struct max8971_data * priv,enum max8971_field_idx fidx,u32 clamp_min,u32 clamp_max,u32 div,int val)259 static int max8971_set_integer(struct max8971_data *priv, enum max8971_field_idx fidx,
260 u32 clamp_min, u32 clamp_max, u32 div, int val)
261 {
262 u32 regval;
263
264 regval = clamp_val(val, clamp_min, clamp_max) / div;
265
266 return regmap_field_write(priv->rfield[fidx], regval);
267 }
268
max8971_get_property(struct power_supply * psy,enum power_supply_property psp,union power_supply_propval * val)269 static int max8971_get_property(struct power_supply *psy, enum power_supply_property psp,
270 union power_supply_propval *val)
271 {
272 struct max8971_data *priv = power_supply_get_drvdata(psy);
273 int err = 0;
274
275 switch (psp) {
276 case POWER_SUPPLY_PROP_STATUS:
277 err = max8971_get_status(priv, &val->intval);
278 break;
279 case POWER_SUPPLY_PROP_CHARGE_TYPE:
280 err = max8971_get_charge_type(priv, &val->intval);
281 break;
282 case POWER_SUPPLY_PROP_USB_TYPE:
283 val->intval = priv->usb_type;
284 break;
285 case POWER_SUPPLY_PROP_HEALTH:
286 err = max8971_get_health(priv, &val->intval);
287 break;
288 case POWER_SUPPLY_PROP_ONLINE:
289 err = max8971_get_online(priv, &val->intval);
290 break;
291 case POWER_SUPPLY_PROP_PRESENT:
292 val->intval = priv->present;
293 break;
294 case POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT_MAX:
295 val->intval = MAX8971_CHG_CC_MAX;
296 break;
297 case POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT:
298 err = max8971_get_integer(priv, CHG_CC, MAX8971_CHG_CC_MIN, MAX8971_CHG_CC_MAX,
299 MAX8971_CHG_CC_STEP, &val->intval);
300 break;
301 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
302 err = max8971_get_integer(priv, DCI_LMT, MAX8971_DCILMT_MIN, MAX8971_DCILMT_MAX,
303 MAX8971_DCILMT_STEP, &val->intval);
304 break;
305 case POWER_SUPPLY_PROP_MODEL_NAME:
306 val->strval = max8971_model;
307 break;
308 case POWER_SUPPLY_PROP_MANUFACTURER:
309 val->strval = max8971_manufacturer;
310 break;
311 default:
312 err = -EINVAL;
313 }
314
315 return err;
316 }
317
max8971_set_property(struct power_supply * psy,enum power_supply_property psp,const union power_supply_propval * val)318 static int max8971_set_property(struct power_supply *psy, enum power_supply_property psp,
319 const union power_supply_propval *val)
320 {
321 struct max8971_data *priv = power_supply_get_drvdata(psy);
322 int err = 0;
323
324 switch (psp) {
325 case POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT:
326 err = max8971_set_integer(priv, CHG_CC, MAX8971_CHG_CC_MIN, MAX8971_CHG_CC_MAX,
327 MAX8971_CHG_CC_STEP, val->intval);
328 break;
329 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
330 err = max8971_set_integer(priv, DCI_LMT, MAX8971_DCILMT_MIN, MAX8971_DCILMT_MAX,
331 MAX8971_DCILMT_STEP, val->intval);
332 break;
333 default:
334 err = -EINVAL;
335 }
336
337 return err;
338 };
339
max8971_property_is_writeable(struct power_supply * psy,enum power_supply_property psp)340 static int max8971_property_is_writeable(struct power_supply *psy,
341 enum power_supply_property psp)
342 {
343 switch (psp) {
344 case POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT:
345 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
346 return true;
347 default:
348 return false;
349 }
350 }
351
352 static enum power_supply_property max8971_properties[] = {
353 POWER_SUPPLY_PROP_STATUS,
354 POWER_SUPPLY_PROP_CHARGE_TYPE,
355 POWER_SUPPLY_PROP_USB_TYPE,
356 POWER_SUPPLY_PROP_HEALTH,
357 POWER_SUPPLY_PROP_ONLINE,
358 POWER_SUPPLY_PROP_PRESENT,
359 POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT,
360 POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT_MAX,
361 POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT,
362 POWER_SUPPLY_PROP_MODEL_NAME,
363 POWER_SUPPLY_PROP_MANUFACTURER,
364 };
365
366 static const struct power_supply_desc max8971_charger_desc = {
367 .name = "max8971-charger",
368 .type = POWER_SUPPLY_TYPE_USB,
369 .usb_types = BIT(POWER_SUPPLY_USB_TYPE_UNKNOWN) |
370 BIT(POWER_SUPPLY_USB_TYPE_SDP) |
371 BIT(POWER_SUPPLY_USB_TYPE_DCP) |
372 BIT(POWER_SUPPLY_USB_TYPE_CDP) |
373 BIT(POWER_SUPPLY_USB_TYPE_ACA),
374 .properties = max8971_properties,
375 .num_properties = ARRAY_SIZE(max8971_properties),
376 .get_property = max8971_get_property,
377 .set_property = max8971_set_property,
378 .property_is_writeable = max8971_property_is_writeable,
379 };
380
max8971_update_config(struct max8971_data * priv)381 static void max8971_update_config(struct max8971_data *priv)
382 {
383 regmap_field_write(priv->rfield[CPROT], MAX8971_CHGPROT_UNLOCKED);
384
385 if (priv->fchgt != MAX8971_FCHGT_DEFAULT)
386 regmap_field_write(priv->rfield[FCHG_T], priv->fchgt);
387
388 regmap_write_bits(priv->regmap, MAX8971_REG_DCCRNT, MAX8971_CHGRSTRT_MASK,
389 MAX8971_CHGRSTRT_MASK);
390
391 if (priv->tofft != MAX8971_TOPOFFT_DEFAULT)
392 regmap_field_write(priv->rfield[TOPOFF_T], priv->tofft);
393
394 if (priv->toffs)
395 regmap_field_write(priv->rfield[TOPOFF_S], priv->toffs);
396
397 regmap_field_write(priv->rfield[CPROT], MAX8971_CHGPROT_LOCKED);
398 }
399
fast_charge_timer_show(struct device * dev,struct device_attribute * attr,char * buf)400 static ssize_t fast_charge_timer_show(struct device *dev, struct device_attribute *attr,
401 char *buf)
402 {
403 struct power_supply *psy = to_power_supply(dev);
404 struct max8971_data *priv = power_supply_get_drvdata(psy);
405 u32 regval;
406 int err;
407
408 err = regmap_field_read(priv->rfield[FCHG_T], ®val);
409 if (err)
410 return err;
411
412 switch (regval) {
413 case 0x1 ... 0x7:
414 /* Time is off by 3 hours comparing to value */
415 regval += 3;
416 break;
417 case 0x0:
418 default:
419 regval = 0;
420 break;
421 }
422
423 return sysfs_emit(buf, "%u\n", regval);
424 }
425
fast_charge_timer_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)426 static ssize_t fast_charge_timer_store(struct device *dev, struct device_attribute *attr,
427 const char *buf, size_t count)
428 {
429 struct power_supply *psy = to_power_supply(dev);
430 struct max8971_data *priv = power_supply_get_drvdata(psy);
431 unsigned long hours;
432 int val, err;
433
434 err = kstrtoul(buf, 10, &hours);
435 if (err)
436 return err;
437
438 val = hours - 3;
439 if (val <= 0 || val > 7)
440 priv->fchgt = 0;
441 else
442 priv->fchgt = val;
443
444 max8971_update_config(priv);
445
446 return count;
447 }
448
top_off_threshold_current_show(struct device * dev,struct device_attribute * attr,char * buf)449 static ssize_t top_off_threshold_current_show(struct device *dev,
450 struct device_attribute *attr,
451 char *buf)
452 {
453 struct power_supply *psy = to_power_supply(dev);
454 struct max8971_data *priv = power_supply_get_drvdata(psy);
455 u32 regval, val;
456 int err;
457
458 err = regmap_field_read(priv->rfield[TOPOFF_S], ®val);
459 if (err)
460 return err;
461
462 /* 50uA start with 50uA step */
463 val = regval * 50 + 50;
464 val *= 1000;
465
466 return sysfs_emit(buf, "%u\n", val);
467 }
468
top_off_threshold_current_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)469 static ssize_t top_off_threshold_current_store(struct device *dev,
470 struct device_attribute *attr,
471 const char *buf, size_t count)
472 {
473 struct power_supply *psy = to_power_supply(dev);
474 struct max8971_data *priv = power_supply_get_drvdata(psy);
475 unsigned long uamp;
476 int err;
477
478 err = kstrtoul(buf, 10, &uamp);
479 if (err)
480 return err;
481
482 if (uamp < 50000 || uamp > 200000)
483 return -EINVAL;
484
485 priv->toffs = uamp / 50000 - 1;
486
487 max8971_update_config(priv);
488
489 return count;
490 }
491
top_off_timer_show(struct device * dev,struct device_attribute * attr,char * buf)492 static ssize_t top_off_timer_show(struct device *dev, struct device_attribute *attr,
493 char *buf)
494 {
495 struct power_supply *psy = to_power_supply(dev);
496 struct max8971_data *priv = power_supply_get_drvdata(psy);
497 u32 regval;
498 int err;
499
500 err = regmap_field_read(priv->rfield[TOPOFF_T], ®val);
501 if (err)
502 return err;
503
504 /* 10 min intervals */
505 regval *= 10;
506
507 return sysfs_emit(buf, "%u\n", regval);
508 }
509
top_off_timer_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)510 static ssize_t top_off_timer_store(struct device *dev, struct device_attribute *attr,
511 const char *buf, size_t count)
512 {
513 struct power_supply *psy = to_power_supply(dev);
514 struct max8971_data *priv = power_supply_get_drvdata(psy);
515 unsigned long minutes;
516 int err;
517
518 err = kstrtoul(buf, 10, &minutes);
519 if (err)
520 return err;
521
522 if (minutes > 70)
523 return -EINVAL;
524
525 priv->tofft = minutes / 10;
526
527 max8971_update_config(priv);
528
529 return count;
530 }
531
532 static DEVICE_ATTR_RW(fast_charge_timer);
533 static DEVICE_ATTR_RW(top_off_threshold_current);
534 static DEVICE_ATTR_RW(top_off_timer);
535
536 static struct attribute *max8971_attrs[] = {
537 &dev_attr_fast_charge_timer.attr,
538 &dev_attr_top_off_threshold_current.attr,
539 &dev_attr_top_off_timer.attr,
540 NULL
541 };
542 ATTRIBUTE_GROUPS(max8971);
543
max8971_extcon_evt_worker(struct work_struct * work)544 static void max8971_extcon_evt_worker(struct work_struct *work)
545 {
546 struct max8971_data *priv =
547 container_of(work, struct max8971_data, extcon_work.work);
548 struct device *dev = priv->dev;
549 struct extcon_dev *edev = priv->edev;
550 u32 chgcc, dcilmt;
551
552 if (extcon_get_state(edev, EXTCON_CHG_USB_SDP) > 0) {
553 dev_dbg(dev, "USB SDP charger is connected\n");
554 priv->usb_type = POWER_SUPPLY_USB_TYPE_SDP;
555 chgcc = 500000;
556 dcilmt = 500000;
557 } else if (extcon_get_state(edev, EXTCON_USB) > 0) {
558 dev_dbg(dev, "USB charger is connected\n");
559 priv->usb_type = POWER_SUPPLY_USB_TYPE_SDP;
560 chgcc = 500000;
561 dcilmt = 500000;
562 } else if (extcon_get_state(edev, EXTCON_DISP_MHL) > 0) {
563 dev_dbg(dev, "MHL plug is connected\n");
564 priv->usb_type = POWER_SUPPLY_USB_TYPE_SDP;
565 chgcc = 500000;
566 dcilmt = 500000;
567 } else if (extcon_get_state(edev, EXTCON_CHG_USB_DCP) > 0) {
568 dev_dbg(dev, "USB DCP charger is connected\n");
569 priv->usb_type = POWER_SUPPLY_USB_TYPE_DCP;
570 chgcc = 900000;
571 dcilmt = 1200000;
572 } else if (extcon_get_state(edev, EXTCON_CHG_USB_FAST) > 0) {
573 dev_dbg(dev, "USB FAST charger is connected\n");
574 priv->usb_type = POWER_SUPPLY_USB_TYPE_ACA;
575 chgcc = 900000;
576 dcilmt = 1200000;
577 } else if (extcon_get_state(edev, EXTCON_CHG_USB_SLOW) > 0) {
578 dev_dbg(dev, "USB SLOW charger is connected\n");
579 priv->usb_type = POWER_SUPPLY_USB_TYPE_ACA;
580 chgcc = 900000;
581 dcilmt = 1200000;
582 } else if (extcon_get_state(edev, EXTCON_CHG_USB_CDP) > 0) {
583 dev_dbg(dev, "USB CDP charger is connected\n");
584 priv->usb_type = POWER_SUPPLY_USB_TYPE_CDP;
585 chgcc = 900000;
586 dcilmt = 1200000;
587 } else {
588 dev_dbg(dev, "USB state is unknown\n");
589 priv->usb_type = POWER_SUPPLY_USB_TYPE_UNKNOWN;
590 return;
591 }
592
593 regmap_field_write(priv->rfield[CPROT], MAX8971_CHGPROT_UNLOCKED);
594
595 max8971_set_integer(priv, CHG_CC, MAX8971_CHG_CC_MIN, MAX8971_CHG_CC_MAX,
596 MAX8971_CHG_CC_STEP, chgcc);
597 max8971_set_integer(priv, DCI_LMT, MAX8971_DCILMT_MIN, MAX8971_DCILMT_MAX,
598 MAX8971_DCILMT_STEP, dcilmt);
599
600 regmap_field_write(priv->rfield[CPROT], MAX8971_CHGPROT_LOCKED);
601 }
602
extcon_get_charger_type(struct notifier_block * nb,unsigned long state,void * data)603 static int extcon_get_charger_type(struct notifier_block *nb,
604 unsigned long state, void *data)
605 {
606 struct max8971_data *priv =
607 container_of(nb, struct max8971_data, extcon_nb);
608 schedule_delayed_work(&priv->extcon_work, 0);
609
610 return NOTIFY_OK;
611 }
612
max8971_interrupt(int irq,void * dev_id)613 static irqreturn_t max8971_interrupt(int irq, void *dev_id)
614 {
615 struct max8971_data *priv = dev_id;
616 struct device *dev = priv->dev;
617 int err, state;
618
619 err = regmap_read(priv->regmap, MAX8971_REG_CHGINT, &state);
620 if (err)
621 dev_err(dev, "interrupt reg read failed %d\n", err);
622
623 err = regmap_write_bits(priv->regmap, MAX8971_REG_CHGINT_MASK,
624 MAX8971_AICL_MASK, MAX8971_AICL_MASK);
625 if (err)
626 dev_err(dev, "failed to mask IRQ\n");
627
628 /* set presence prop */
629 priv->present = state & MAX8971_REG_CHG_RST;
630
631 /* on every plug chip resets to default */
632 if (priv->present)
633 max8971_update_config(priv);
634
635 /* update supply status */
636 power_supply_changed(priv->psy_mains);
637
638 return IRQ_HANDLED;
639 }
640
max8971_probe(struct i2c_client * client)641 static int max8971_probe(struct i2c_client *client)
642 {
643 struct device *dev = &client->dev;
644 struct max8971_data *priv;
645 struct device_node *extcon;
646 struct power_supply_config cfg = { };
647 int err, i;
648
649 priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
650 if (!priv)
651 return -ENOMEM;
652
653 priv->dev = dev;
654 priv->usb_type = POWER_SUPPLY_USB_TYPE_UNKNOWN;
655
656 i2c_set_clientdata(client, priv);
657
658 priv->regmap = devm_regmap_init_i2c(client, &max8971_regmap_config);
659 if (IS_ERR(priv->regmap))
660 return dev_err_probe(dev, PTR_ERR(priv->regmap), "cannot allocate regmap\n");
661
662 for (i = 0; i < MAX8971_N_REGMAP_FIELDS; i++) {
663 priv->rfield[i] = devm_regmap_field_alloc(dev, priv->regmap, max8971_reg_field[i]);
664 if (IS_ERR(priv->rfield[i]))
665 return dev_err_probe(dev, PTR_ERR(priv->rfield[i]),
666 "cannot allocate regmap field\n");
667 }
668
669 cfg.attr_grp = max8971_groups;
670 cfg.drv_data = priv;
671 cfg.fwnode = dev_fwnode(dev);
672
673 priv->psy_mains = devm_power_supply_register(dev, &max8971_charger_desc, &cfg);
674 if (IS_ERR(priv->psy_mains))
675 return dev_err_probe(dev, PTR_ERR(priv->psy_mains),
676 "failed to register mains supply\n");
677
678 err = regmap_write_bits(priv->regmap, MAX8971_REG_CHGINT_MASK, MAX8971_AICL_MASK,
679 MAX8971_AICL_MASK);
680 if (err)
681 return dev_err_probe(dev, err, "failed to mask IRQ\n");
682
683 err = devm_request_threaded_irq(dev, client->irq, NULL, &max8971_interrupt,
684 IRQF_ONESHOT | IRQF_SHARED, client->name, priv);
685 if (err)
686 return err;
687
688 extcon = of_graph_get_remote_node(dev->of_node, -1, -1);
689 if (!extcon)
690 return 0;
691
692 priv->edev = extcon_find_edev_by_node(extcon);
693 of_node_put(extcon);
694 if (IS_ERR(priv->edev))
695 return dev_err_probe(dev, PTR_ERR(priv->edev), "failed to find extcon\n");
696
697 err = devm_delayed_work_autocancel(dev, &priv->extcon_work,
698 max8971_extcon_evt_worker);
699 if (err)
700 return dev_err_probe(dev, err, "failed to add extcon evt stop action\n");
701
702 priv->extcon_nb.notifier_call = extcon_get_charger_type;
703
704 err = devm_extcon_register_notifier_all(dev, priv->edev, &priv->extcon_nb);
705 if (err)
706 return dev_err_probe(dev, err, "failed to register notifier\n");
707
708 /* Initial configuration work with 1 sec delay */
709 schedule_delayed_work(&priv->extcon_work, msecs_to_jiffies(1000));
710
711 return 0;
712 }
713
max8971_resume(struct device * dev)714 static int __maybe_unused max8971_resume(struct device *dev)
715 {
716 struct i2c_client *client = to_i2c_client(dev);
717 struct max8971_data *priv = i2c_get_clientdata(client);
718
719 irq_wake_thread(client->irq, priv);
720
721 return 0;
722 }
723
724 static SIMPLE_DEV_PM_OPS(max8971_pm_ops, NULL, max8971_resume);
725
726 static const struct of_device_id max8971_match_ids[] = {
727 { .compatible = "maxim,max8971" },
728 { /* sentinel */ }
729 };
730 MODULE_DEVICE_TABLE(of, max8971_match_ids);
731
732 static const struct i2c_device_id max8971_i2c_id[] = {
733 { .name = "max8971" },
734 { }
735 };
736 MODULE_DEVICE_TABLE(i2c, max8971_i2c_id);
737
738 static struct i2c_driver max8971_driver = {
739 .driver = {
740 .name = "max8971-charger",
741 .of_match_table = max8971_match_ids,
742 .pm = &max8971_pm_ops,
743 },
744 .probe = max8971_probe,
745 .id_table = max8971_i2c_id,
746 };
747 module_i2c_driver(max8971_driver);
748
749 MODULE_AUTHOR("Svyatoslav Ryhel <clamor95@gmail.com>");
750 MODULE_DESCRIPTION("MAX8971 Charger Driver");
751 MODULE_LICENSE("GPL");
752