2 * sabresd_battery.c - Maxim 8903 USB/Adapter Charger Driver
4 * Copyright (C) 2011 Samsung Electronics
5 * Copyright (C) 2011-2013 Freescale Semiconductor, Inc.
6 * Based on max8903_charger.c
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.
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.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 #include <linux/delay.h>
24 #include <linux/gpio.h>
25 #include <linux/interrupt.h>
26 #include <linux/module.h>
28 #include <linux/of_device.h>
29 #include <linux/of_gpio.h>
30 #include <linux/power_supply.h>
31 #include <linux/platform_device.h>
32 #include <linux/power/sabresd_battery.h>
33 #include <linux/slab.h>
35 #define BATTERY_UPDATE_INTERVAL 5 /*seconds*/
36 #define LOW_VOLT_THRESHOLD 2800000
37 #define HIGH_VOLT_THRESHOLD 4200000
38 #define ADC_SAMPLE_COUNT 6
41 struct max8903_pdata *pdata;
43 struct power_supply psy;
44 struct power_supply usb;
49 struct delayed_work work;
50 unsigned int interval;
51 unsigned short thermal_raw;
56 int charger_voltage_uV;
60 int usb_charger_online;
61 int first_delay_count;
62 struct power_supply bat;
63 struct power_supply detect_usb;
69 } battery_capacity , *pbattery_capacity;
71 static int offset_discharger;
72 static int offset_charger;
73 static int offset_usb_charger;
75 static battery_capacity chargingTable[] = {
116 static battery_capacity dischargingTable[] = {
158 u32 calibrate_battery_capability_percent(struct max8903_data *data)
161 pbattery_capacity pTable;
164 if (data->battery_status == POWER_SUPPLY_STATUS_DISCHARGING) {
165 pTable = dischargingTable;
166 tableSize = sizeof(dischargingTable)/
167 sizeof(dischargingTable[0]);
169 pTable = chargingTable;
170 tableSize = sizeof(chargingTable)/
171 sizeof(chargingTable[0]);
173 for (i = 0; i < tableSize; i++) {
174 if (data->voltage_uV >= pTable[i].voltage)
175 return pTable[i].percent;
181 static enum power_supply_property max8903_charger_props[] = {
182 POWER_SUPPLY_PROP_ONLINE,
185 static enum power_supply_property max8903_battery_props[] = {
186 POWER_SUPPLY_PROP_VOLTAGE_NOW,
187 POWER_SUPPLY_PROP_STATUS,
188 POWER_SUPPLY_PROP_PRESENT,
189 POWER_SUPPLY_PROP_CAPACITY,
190 POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN,
191 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
192 POWER_SUPPLY_PROP_HEALTH,
193 POWER_SUPPLY_PROP_CAPACITY_LEVEL,
196 extern u32 max11801_read_adc(void);
198 static void max8903_charger_update_status(struct max8903_data *data)
201 data->charger_online = 1;
202 } else if (data->usb_in) {
203 data->usb_charger_online = 1;
205 data->charger_online = 0;
206 data->usb_charger_online = 0;
209 if (!data->charger_online && !data->usb_charger_online) {
210 data->battery_status = POWER_SUPPLY_STATUS_DISCHARGING;
211 } else if (gpio_get_value(data->pdata->chg) == 0) {
212 data->battery_status = POWER_SUPPLY_STATUS_CHARGING;
213 } else if ((data->ta_in || data->usb_in) &&
214 gpio_get_value(data->pdata->chg) > 0) {
215 if (!data->pdata->feature_flag) {
216 if (data->percent >= 99)
217 data->battery_status = POWER_SUPPLY_STATUS_FULL;
219 data->battery_status =
220 POWER_SUPPLY_STATUS_NOT_CHARGING;
222 data->battery_status = POWER_SUPPLY_STATUS_FULL;
227 u32 calibration_voltage(struct max8903_data *data)
229 u32 voltage_data = 0;
233 if (!data->charger_online && !data->usb_charger_online)
234 offset = offset_discharger;
235 else if (data->usb_charger_online)
236 offset = offset_usb_charger;
237 else if (data->charger_online)
238 offset = offset_charger;
241 for (i = 0; i < ADC_SAMPLE_COUNT; i++)
242 voltage_data += max11801_read_adc()-offset;
243 voltage_data = voltage_data / ADC_SAMPLE_COUNT;
244 dev_dbg(data->dev, "volt: %d\n", voltage_data);
249 static void max8903_battery_update_status(struct max8903_data *data)
251 if (!data->pdata->feature_flag) {
252 data->voltage_uV = calibration_voltage(data);
253 data->percent = calibrate_battery_capability_percent(data);
254 if (data->percent != data->old_percent) {
255 data->old_percent = data->percent;
256 power_supply_changed(&data->bat);
259 * because boot time gap between led framwork and charger
260 * framwork,when system boots with charger attatched,
261 * charger led framwork loses the first charger online event,
262 * add once extra power_supply_changed can fix this issure
264 if (data->first_delay_count < 200) {
265 data->first_delay_count = data->first_delay_count + 1;
266 power_supply_changed(&data->bat);
271 static int max8903_battery_get_property(struct power_supply *bat,
272 enum power_supply_property psp,
273 union power_supply_propval *val)
275 struct max8903_data *di = container_of(bat, struct max8903_data, bat);
278 case POWER_SUPPLY_PROP_STATUS:
279 val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
280 if (gpio_get_value(di->pdata->chg) == 0) {
281 di->battery_status = POWER_SUPPLY_STATUS_CHARGING;
282 } else if ((di->ta_in || di->usb_in) &&
283 gpio_get_value(di->pdata->chg) > 0) {
284 if (!di->pdata->feature_flag) {
285 if (di->percent >= 99)
287 POWER_SUPPLY_STATUS_FULL;
290 POWER_SUPPLY_STATUS_NOT_CHARGING;
292 di->battery_status = POWER_SUPPLY_STATUS_FULL;
295 val->intval = di->battery_status;
302 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
303 val->intval = di->voltage_uV;
305 case POWER_SUPPLY_PROP_CHARGE_NOW:
308 case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
309 val->intval = HIGH_VOLT_THRESHOLD;
311 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
312 val->intval = LOW_VOLT_THRESHOLD;
314 case POWER_SUPPLY_PROP_PRESENT:
317 case POWER_SUPPLY_PROP_CAPACITY:
318 val->intval = di->percent < 0 ? 0 :
319 (di->percent > 100 ? 100 : di->percent);
321 case POWER_SUPPLY_PROP_HEALTH:
322 val->intval = POWER_SUPPLY_HEALTH_GOOD;
324 val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
326 case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
327 if (di->battery_status == POWER_SUPPLY_STATUS_FULL)
328 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_FULL;
329 else if (di->percent <= 15)
330 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_LOW;
332 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
341 static int max8903_get_property(struct power_supply *psy,
342 enum power_supply_property psp,
343 union power_supply_propval *val)
345 struct max8903_data *data = container_of(psy,
346 struct max8903_data, psy);
349 case POWER_SUPPLY_PROP_ONLINE:
353 data->charger_online = val->intval;
362 static int max8903_get_usb_property(struct power_supply *usb,
363 enum power_supply_property psp,
364 union power_supply_propval *val)
366 struct max8903_data *data = container_of(usb,
367 struct max8903_data, usb);
370 case POWER_SUPPLY_PROP_ONLINE:
374 data->usb_charger_online = val->intval;
383 static irqreturn_t max8903_dcin(int irq, void *_data)
385 struct max8903_data *data = _data;
386 struct max8903_pdata *pdata = data->pdata;
390 ta_in = gpio_get_value(pdata->dok) ? false : true;
392 if (ta_in == data->ta_in)
396 dev_info(data->dev, "TA(DC-IN) Charger %s.\n", ta_in ?
397 "Connected" : "Disconnected");
398 max8903_charger_update_status(data);
399 power_supply_changed(&data->psy);
400 power_supply_changed(&data->bat);
405 static irqreturn_t max8903_usbin(int irq, void *_data)
407 struct max8903_data *data = _data;
408 struct max8903_pdata *pdata = data->pdata;
412 usb_in = gpio_get_value(pdata->uok) ? false : true;
413 if (usb_in == data->usb_in)
415 data->usb_in = usb_in;
416 dev_info(data->dev, "USB Charger %s.\n", usb_in ?
417 "Connected" : "Disconnected");
418 max8903_charger_update_status(data);
419 power_supply_changed(&data->bat);
420 power_supply_changed(&data->usb);
425 static irqreturn_t max8903_fault(int irq, void *_data)
427 struct max8903_data *data = _data;
428 struct max8903_pdata *pdata = data->pdata;
431 fault = gpio_get_value(pdata->flt) ? false : true;
433 if (fault == data->fault)
438 dev_err(data->dev, "Charger suffers a fault and stops.\n");
440 dev_err(data->dev, "Charger recovered from a fault.\n");
441 max8903_charger_update_status(data);
442 power_supply_changed(&data->psy);
443 power_supply_changed(&data->bat);
444 power_supply_changed(&data->usb);
449 static irqreturn_t max8903_chg(int irq, void *_data)
451 struct max8903_data *data = _data;
452 struct max8903_pdata *pdata = data->pdata;
455 chg_state = gpio_get_value(pdata->chg) ? false : true;
457 if (chg_state == data->chg_state)
459 data->chg_state = chg_state;
460 max8903_charger_update_status(data);
461 power_supply_changed(&data->psy);
462 power_supply_changed(&data->bat);
463 power_supply_changed(&data->usb);
468 static void max8903_battery_work(struct work_struct *work)
470 struct max8903_data *data;
472 data = container_of(work, struct max8903_data, work.work);
473 data->interval = HZ * BATTERY_UPDATE_INTERVAL;
475 max8903_charger_update_status(data);
476 max8903_battery_update_status(data);
477 dev_dbg(data->dev, "battery voltage: %4d mV\n", data->voltage_uV);
478 dev_dbg(data->dev, "charger online status: %d\n",
479 data->charger_online);
480 dev_dbg(data->dev, "battery status : %d\n" , data->battery_status);
481 dev_dbg(data->dev, "battery capacity percent: %3d\n", data->percent);
482 dev_dbg(data->dev, "data->usb_in: %x , data->ta_in: %x\n",
483 data->usb_in, data->ta_in);
484 /* reschedule for the next time */
485 schedule_delayed_work(&data->work, data->interval);
488 static ssize_t max8903_voltage_offset_discharger_show(struct device *dev,
489 struct device_attribute *attr, char *buf)
491 return sprintf(buf, "read offset_discharger:%04d\n",
495 static ssize_t max8903_voltage_offset_discharger_store(struct device *dev,
496 struct device_attribute *attr, const char *buf,
502 ret = strict_strtoul(buf, 10, &data);
503 offset_discharger = (int)data;
504 pr_info("read offset_discharger:%04d\n", offset_discharger);
509 static ssize_t max8903_voltage_offset_charger_show(struct device *dev,
510 struct device_attribute *attr, char *buf)
512 return sprintf(buf, "read offset_charger:%04d\n",
516 static ssize_t max8903_voltage_offset_charger_store(struct device *dev,
517 struct device_attribute *attr, const char *buf,
523 ret = strict_strtoul(buf, 10, &data);
524 offset_charger = (int)data;
525 pr_info("read offset_charger:%04d\n", offset_charger);
529 static ssize_t max8903_voltage_offset_usb_charger_show(struct device *dev,
530 struct device_attribute *attr, char *buf)
532 return sprintf(buf, "read offset_usb_charger:%04d\n",
536 static ssize_t max8903_voltage_offset_usb_charger_store(struct device *dev,
537 struct device_attribute *attr, const char *buf,
543 ret = strict_strtoul(buf, 10, &data);
544 offset_usb_charger = (int)data;
545 pr_info("read offset_charger:%04d\n", offset_usb_charger);
550 static struct device_attribute max8903_discharger_dev_attr = {
552 .name = "max8903_ctl_offset_discharger",
553 .mode = S_IRUSR | S_IWUSR,
555 .show = max8903_voltage_offset_discharger_show,
556 .store = max8903_voltage_offset_discharger_store,
559 static struct device_attribute max8903_charger_dev_attr = {
561 .name = "max8903_ctl_offset_charger",
562 .mode = S_IRUSR | S_IWUSR,
564 .show = max8903_voltage_offset_charger_show,
565 .store = max8903_voltage_offset_charger_store,
568 static struct device_attribute max8903_usb_charger_dev_attr = {
570 .name = "max8903_ctl_offset_usb_charger",
571 .mode = S_IRUSR | S_IWUSR,
573 .show = max8903_voltage_offset_usb_charger_show,
574 .store = max8903_voltage_offset_usb_charger_store,
577 #if defined(CONFIG_OF)
578 static const struct of_device_id max8903_dt_ids[] = {
579 { .compatible = "fsl,max8903-charger", },
582 MODULE_DEVICE_TABLE(of, max8903_dt_ids);
584 static struct max8903_pdata *max8903_of_populate_pdata(
587 struct device_node *of_node = dev->of_node;
588 struct max8903_pdata *pdata = dev->platform_data;
590 if (!of_node || pdata)
593 pdata = devm_kzalloc(dev, sizeof(struct max8903_pdata),
598 if (of_get_property(of_node, "fsl,dcm_always_high", NULL))
599 pdata->dcm_always_high = true;
600 if (of_get_property(of_node, "fsl,dc_valid", NULL))
601 pdata->dc_valid = true;
602 if (of_get_property(of_node, "fsl,usb_valid", NULL))
603 pdata->usb_valid = true;
604 if (of_get_property(of_node, "fsl,adc_disable", NULL))
605 pdata->feature_flag = true;
607 if (pdata->dc_valid) {
608 pdata->dok = of_get_named_gpio(of_node, "dok_input", 0);
609 if (!gpio_is_valid(pdata->dok)) {
610 dev_err(dev, "pin pdata->dok: invalid gpio %d\n", pdata->dok);
614 if (pdata->usb_valid) {
615 pdata->uok = of_get_named_gpio(of_node, "uok_input", 0);
616 if (!gpio_is_valid(pdata->uok)) {
617 dev_err(dev, "pin pdata->uok: invalid gpio %d\n", pdata->uok);
621 pdata->chg = of_get_named_gpio(of_node, "chg_input", 0);
622 if (!gpio_is_valid(pdata->chg)) {
623 dev_err(dev, "pin pdata->chg: invalid gpio %d\n", pdata->chg);
626 pdata->flt = of_get_named_gpio(of_node, "flt_input", 0);
627 if (!gpio_is_valid(pdata->flt)) {
628 dev_err(dev, "pin pdata->flt: invalid gpio %d\n", pdata->flt);
631 /* no need check offset without adc converter */
632 if (!pdata->feature_flag) {
633 if (of_property_read_u32(of_node, "offset-charger",
635 dev_err(dev, "Not setting offset-charger in dts!\n");
637 if (of_property_read_u32(of_node, "offset-discharger",
639 dev_err(dev, "Not setting offset-discharger in dts!\n");
641 if (of_property_read_u32(of_node, "offset-usb-charger",
642 &offset_usb_charger))
643 dev_err(dev, "Not setting offset-usb-charger in dts!\n");
650 static int max8903_probe(struct platform_device *pdev)
652 struct max8903_data *data;
653 struct device *dev = &pdev->dev;
654 struct max8903_pdata *pdata = pdev->dev.platform_data;
661 data = devm_kzalloc(dev, sizeof(struct max8903_data), GFP_KERNEL);
665 pdata = pdev->dev.platform_data;
667 pdata = max8903_of_populate_pdata(&pdev->dev);
672 data->first_delay_count = 0;
677 platform_set_drvdata(pdev, data);
679 if (pdata->dc_valid == false && pdata->usb_valid == false) {
680 dev_err(dev, "No valid power sources.\n");
684 if (pdata->dc_valid) {
685 if (pdata->dok && pdata->dcm_always_high) {
687 ret = gpio_request_one(gpio, GPIOF_IN, "max8903-DOK");
689 dev_err(dev, "request max8903-DOK error!!\n");
692 ta_in = gpio_get_value(gpio) ? 0 : 1;
694 dev_err(dev, "When DC is wired, DOK and DCM should be"
695 " wired as well or set dcm always high!\n");
701 if (pdata->usb_valid) {
704 ret = gpio_request_one(gpio, GPIOF_IN, "max8903-UOK");
706 dev_err(dev, "request max8903-UOK error!!\n");
709 usb_in = gpio_get_value(gpio) ? 0 : 1;
711 dev_err(dev, "When USB is wired, UOK should be wired"
719 ret = gpio_request_one(pdata->chg, GPIOF_IN, "max8903-CHG");
721 dev_err(dev, "request max8903-CHG error!!\n");
727 ret = gpio_request_one(pdata->flt, GPIOF_IN, "max8903-FLT");
729 dev_err(dev, "request max8903-FLT error!!\n");
736 data->usb_in = usb_in;
737 data->psy.name = "max8903-ac";
738 data->psy.type = POWER_SUPPLY_TYPE_MAINS;
739 data->psy.get_property = max8903_get_property;
740 data->psy.properties = max8903_charger_props;
741 data->psy.num_properties = ARRAY_SIZE(max8903_charger_props);
742 ret = power_supply_register(dev, &data->psy);
744 dev_err(dev, "failed: power supply register.\n");
748 data->usb.name = "max8903-usb";
749 data->usb.type = POWER_SUPPLY_TYPE_USB;
750 data->usb.get_property = max8903_get_usb_property;
751 data->usb.properties = max8903_charger_props;
752 data->usb.num_properties = ARRAY_SIZE(max8903_charger_props);
753 ret = power_supply_register(dev, &data->usb);
755 dev_err(dev, "failed: power supply register.\n");
759 data->bat.name = "max8903-charger";
760 data->bat.type = POWER_SUPPLY_TYPE_BATTERY;
761 data->bat.properties = max8903_battery_props;
762 data->bat.num_properties = ARRAY_SIZE(max8903_battery_props);
763 data->bat.get_property = max8903_battery_get_property;
764 data->bat.use_for_apm = 1;
765 retval = power_supply_register(&pdev->dev, &data->bat);
767 dev_err(data->dev, "failed to register battery\n");
771 INIT_DELAYED_WORK(&data->work, max8903_battery_work);
772 schedule_delayed_work(&data->work, data->interval);
774 if (pdata->dc_valid) {
775 ret = request_threaded_irq(gpio_to_irq(pdata->dok), NULL,
776 max8903_dcin, IRQF_TRIGGER_FALLING |
777 IRQF_TRIGGER_RISING | IRQF_ONESHOT, "MAX8903 DC IN",
780 dev_err(dev, "Cannot request irq %d for DC (%d)\n",
781 gpio_to_irq(pdata->dok), ret);
786 if (pdata->usb_valid) {
787 ret = request_threaded_irq(gpio_to_irq(pdata->uok), NULL,
788 max8903_usbin, IRQF_TRIGGER_FALLING |
789 IRQF_TRIGGER_RISING | IRQF_ONESHOT, "MAX8903 USB IN",
792 dev_err(dev, "Cannot request irq %d for USB (%d)\n",
793 gpio_to_irq(pdata->uok), ret);
799 ret = request_threaded_irq(gpio_to_irq(pdata->flt), NULL,
800 max8903_fault, IRQF_TRIGGER_FALLING |
801 IRQF_TRIGGER_RISING | IRQF_ONESHOT, "MAX8903 Fault",
804 dev_err(dev, "Cannot request irq %d for Fault (%d)\n",
805 gpio_to_irq(pdata->flt), ret);
811 ret = request_threaded_irq(gpio_to_irq(pdata->chg), NULL,
812 max8903_chg, IRQF_TRIGGER_FALLING |
813 IRQF_TRIGGER_RISING | IRQF_ONESHOT, "MAX8903 Status",
816 dev_err(dev, "Cannot request irq %d for Status (%d)\n",
817 gpio_to_irq(pdata->flt), ret);
822 ret = device_create_file(&pdev->dev, &max8903_discharger_dev_attr);
824 dev_err(&pdev->dev, "create device file failed!\n");
825 ret = device_create_file(&pdev->dev, &max8903_charger_dev_attr);
827 dev_err(&pdev->dev, "create device file failed!\n");
828 ret = device_create_file(&pdev->dev, &max8903_usb_charger_dev_attr);
830 dev_err(&pdev->dev, "create device file failed!\n");
832 device_set_wakeup_capable(&pdev->dev, true);
834 max8903_charger_update_status(data);
835 max8903_battery_update_status(data);
839 power_supply_unregister(&data->psy);
841 power_supply_unregister(&data->bat);
843 if (pdata->usb_valid)
844 free_irq(gpio_to_irq(pdata->uok), data);
845 cancel_delayed_work(&data->work);
848 free_irq(gpio_to_irq(pdata->dok), data);
849 cancel_delayed_work(&data->work);
851 if (pdata->usb_valid)
852 free_irq(gpio_to_irq(pdata->uok), data);
853 cancel_delayed_work(&data->work);
856 free_irq(gpio_to_irq(pdata->dok), data);
857 cancel_delayed_work(&data->work);
860 gpio_free(pdata->uok);
862 gpio_free(pdata->dok);
864 gpio_free(pdata->flt);
866 gpio_free(pdata->chg);
870 static int max8903_remove(struct platform_device *pdev)
872 struct max8903_data *data = platform_get_drvdata(pdev);
874 struct max8903_pdata *pdata = data->pdata;
876 cancel_delayed_work_sync(&data->work);
877 power_supply_unregister(&data->psy);
878 power_supply_unregister(&data->usb);
879 power_supply_unregister(&data->bat);
882 free_irq(gpio_to_irq(pdata->flt), data);
883 gpio_free(pdata->flt);
885 if (pdata->usb_valid && pdata->uok) {
886 free_irq(gpio_to_irq(pdata->uok), data);
887 gpio_free(pdata->uok);
889 if (pdata->dc_valid) {
891 free_irq(gpio_to_irq(pdata->dok), data);
892 gpio_free(pdata->dok);
893 } else if (pdata->chg) {
894 free_irq(gpio_to_irq(pdata->chg), data);
895 gpio_free(pdata->chg);
899 device_remove_file(&pdev->dev, &max8903_discharger_dev_attr);
900 device_remove_file(&pdev->dev, &max8903_charger_dev_attr);
901 device_remove_file(&pdev->dev, &max8903_usb_charger_dev_attr);
903 platform_set_drvdata(pdev, NULL);
910 static int max8903_suspend(struct platform_device *pdev,
913 struct max8903_data *data = platform_get_drvdata(pdev);
916 struct max8903_pdata *pdata = data->pdata;
918 if (pdata->dc_valid && device_may_wakeup(&pdev->dev)) {
919 irq = gpio_to_irq(pdata->dok);
920 enable_irq_wake(irq);
923 if (pdata->usb_valid && device_may_wakeup(&pdev->dev)) {
924 irq = gpio_to_irq(pdata->uok);
925 enable_irq_wake(irq);
927 cancel_delayed_work(&data->work);
933 static int max8903_resume(struct platform_device *pdev)
935 struct max8903_data *data = platform_get_drvdata(pdev);
941 struct max8903_pdata *pdata = data->pdata;
945 ta_in = gpio_get_value(pdata->dok) ? false : true;
947 usb_in = gpio_get_value(pdata->uok) ? false : true;
949 if (ta_in != data->ta_in) {
951 dev_info(data->dev, "TA(DC-IN) Charger %s.\n", ta_in ?
952 "Connected" : "Disconnected");
953 max8903_charger_update_status(data);
954 power_supply_changed(&data->psy);
957 if (usb_in != data->usb_in) {
958 data->usb_in = usb_in;
959 dev_info(data->dev, "USB Charger %s.\n", usb_in ?
960 "Connected" : "Disconnected");
961 max8903_charger_update_status(data);
962 power_supply_changed(&data->usb);
965 if (pdata->dc_valid && device_may_wakeup(&pdev->dev)) {
966 irq = gpio_to_irq(pdata->dok);
967 disable_irq_wake(irq);
969 if (pdata->usb_valid && device_may_wakeup(&pdev->dev)) {
970 irq = gpio_to_irq(pdata->uok);
971 disable_irq_wake(irq);
974 schedule_delayed_work(&data->work,
975 BATTERY_UPDATE_INTERVAL);
982 static struct platform_driver max8903_driver = {
983 .probe = max8903_probe,
984 .remove = max8903_remove,
985 .suspend = max8903_suspend,
986 .resume = max8903_resume,
988 .name = "max8903-charger",
989 .owner = THIS_MODULE,
990 .of_match_table = max8903_dt_ids,
993 module_platform_driver(max8903_driver);
995 MODULE_LICENSE("GPL v2");
996 MODULE_AUTHOR("Freescale Semiconductor, Inc.");
997 MODULE_DESCRIPTION("Sabresd Battery Driver");
998 MODULE_ALIAS("sabresd_battery");