Version:  2.0.40 2.2.26 2.4.37 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1

Linux/drivers/power/max14577_charger.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us