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