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/gpio-charger.c

  1 /*
  2  *  Copyright (C) 2010, Lars-Peter Clausen <lars@metafoo.de>
  3  *  Driver for chargers which report their online status through a GPIO pin
  4  *
  5  *  This program is free software; you can redistribute it and/or modify it
  6  *  under  the terms of the GNU General  Public License as published by the
  7  *  Free Software Foundation;  either version 2 of the License, or (at your
  8  *  option) any later version.
  9  *
 10  *  You should have received a copy of the GNU General Public License along
 11  *  with this program; if not, write to the Free Software Foundation, Inc.,
 12  *  675 Mass Ave, Cambridge, MA 02139, USA.
 13  *
 14  */
 15 
 16 #include <linux/device.h>
 17 #include <linux/gpio.h>
 18 #include <linux/init.h>
 19 #include <linux/interrupt.h>
 20 #include <linux/kernel.h>
 21 #include <linux/module.h>
 22 #include <linux/platform_device.h>
 23 #include <linux/power_supply.h>
 24 #include <linux/slab.h>
 25 #include <linux/of.h>
 26 #include <linux/of_gpio.h>
 27 
 28 #include <linux/power/gpio-charger.h>
 29 
 30 struct gpio_charger {
 31         const struct gpio_charger_platform_data *pdata;
 32         unsigned int irq;
 33         bool wakeup_enabled;
 34 
 35         struct power_supply *charger;
 36         struct power_supply_desc charger_desc;
 37 };
 38 
 39 static irqreturn_t gpio_charger_irq(int irq, void *devid)
 40 {
 41         struct power_supply *charger = devid;
 42 
 43         power_supply_changed(charger);
 44 
 45         return IRQ_HANDLED;
 46 }
 47 
 48 static inline struct gpio_charger *psy_to_gpio_charger(struct power_supply *psy)
 49 {
 50         return power_supply_get_drvdata(psy);
 51 }
 52 
 53 static int gpio_charger_get_property(struct power_supply *psy,
 54                 enum power_supply_property psp, union power_supply_propval *val)
 55 {
 56         struct gpio_charger *gpio_charger = psy_to_gpio_charger(psy);
 57         const struct gpio_charger_platform_data *pdata = gpio_charger->pdata;
 58 
 59         switch (psp) {
 60         case POWER_SUPPLY_PROP_ONLINE:
 61                 val->intval = !!gpio_get_value_cansleep(pdata->gpio);
 62                 val->intval ^= pdata->gpio_active_low;
 63                 break;
 64         default:
 65                 return -EINVAL;
 66         }
 67 
 68         return 0;
 69 }
 70 
 71 static enum power_supply_property gpio_charger_properties[] = {
 72         POWER_SUPPLY_PROP_ONLINE,
 73 };
 74 
 75 static
 76 struct gpio_charger_platform_data *gpio_charger_parse_dt(struct device *dev)
 77 {
 78         struct device_node *np = dev->of_node;
 79         struct gpio_charger_platform_data *pdata;
 80         const char *chargetype;
 81         enum of_gpio_flags flags;
 82         int ret;
 83 
 84         if (!np)
 85                 return ERR_PTR(-ENOENT);
 86 
 87         pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
 88         if (!pdata)
 89                 return ERR_PTR(-ENOMEM);
 90 
 91         pdata->name = np->name;
 92 
 93         pdata->gpio = of_get_gpio_flags(np, 0, &flags);
 94         if (pdata->gpio < 0) {
 95                 if (pdata->gpio != -EPROBE_DEFER)
 96                         dev_err(dev, "could not get charger gpio\n");
 97                 return ERR_PTR(pdata->gpio);
 98         }
 99 
100         pdata->gpio_active_low = !!(flags & OF_GPIO_ACTIVE_LOW);
101 
102         pdata->type = POWER_SUPPLY_TYPE_UNKNOWN;
103         ret = of_property_read_string(np, "charger-type", &chargetype);
104         if (ret >= 0) {
105                 if (!strncmp("unknown", chargetype, 7))
106                         pdata->type = POWER_SUPPLY_TYPE_UNKNOWN;
107                 else if (!strncmp("battery", chargetype, 7))
108                         pdata->type = POWER_SUPPLY_TYPE_BATTERY;
109                 else if (!strncmp("ups", chargetype, 3))
110                         pdata->type = POWER_SUPPLY_TYPE_UPS;
111                 else if (!strncmp("mains", chargetype, 5))
112                         pdata->type = POWER_SUPPLY_TYPE_MAINS;
113                 else if (!strncmp("usb-sdp", chargetype, 7))
114                         pdata->type = POWER_SUPPLY_TYPE_USB;
115                 else if (!strncmp("usb-dcp", chargetype, 7))
116                         pdata->type = POWER_SUPPLY_TYPE_USB_DCP;
117                 else if (!strncmp("usb-cdp", chargetype, 7))
118                         pdata->type = POWER_SUPPLY_TYPE_USB_CDP;
119                 else if (!strncmp("usb-aca", chargetype, 7))
120                         pdata->type = POWER_SUPPLY_TYPE_USB_ACA;
121                 else
122                         dev_warn(dev, "unknown charger type %s\n", chargetype);
123         }
124 
125         return pdata;
126 }
127 
128 static int gpio_charger_probe(struct platform_device *pdev)
129 {
130         const struct gpio_charger_platform_data *pdata = pdev->dev.platform_data;
131         struct power_supply_config psy_cfg = {};
132         struct gpio_charger *gpio_charger;
133         struct power_supply_desc *charger_desc;
134         int ret;
135         int irq;
136 
137         if (!pdata) {
138                 pdata = gpio_charger_parse_dt(&pdev->dev);
139                 if (IS_ERR(pdata)) {
140                         ret = PTR_ERR(pdata);
141                         if (ret != -EPROBE_DEFER)
142                                 dev_err(&pdev->dev, "No platform data\n");
143                         return ret;
144                 }
145         }
146 
147         if (!gpio_is_valid(pdata->gpio)) {
148                 dev_err(&pdev->dev, "Invalid gpio pin\n");
149                 return -EINVAL;
150         }
151 
152         gpio_charger = devm_kzalloc(&pdev->dev, sizeof(*gpio_charger),
153                                         GFP_KERNEL);
154         if (!gpio_charger) {
155                 dev_err(&pdev->dev, "Failed to alloc driver structure\n");
156                 return -ENOMEM;
157         }
158 
159         charger_desc = &gpio_charger->charger_desc;
160 
161         charger_desc->name = pdata->name ? pdata->name : "gpio-charger";
162         charger_desc->type = pdata->type;
163         charger_desc->properties = gpio_charger_properties;
164         charger_desc->num_properties = ARRAY_SIZE(gpio_charger_properties);
165         charger_desc->get_property = gpio_charger_get_property;
166 
167         psy_cfg.supplied_to = pdata->supplied_to;
168         psy_cfg.num_supplicants = pdata->num_supplicants;
169         psy_cfg.of_node = pdev->dev.of_node;
170         psy_cfg.drv_data = gpio_charger;
171 
172         ret = gpio_request(pdata->gpio, dev_name(&pdev->dev));
173         if (ret) {
174                 dev_err(&pdev->dev, "Failed to request gpio pin: %d\n", ret);
175                 goto err_free;
176         }
177         ret = gpio_direction_input(pdata->gpio);
178         if (ret) {
179                 dev_err(&pdev->dev, "Failed to set gpio to input: %d\n", ret);
180                 goto err_gpio_free;
181         }
182 
183         gpio_charger->pdata = pdata;
184 
185         gpio_charger->charger = power_supply_register(&pdev->dev,
186                                                       charger_desc, &psy_cfg);
187         if (IS_ERR(gpio_charger->charger)) {
188                 ret = PTR_ERR(gpio_charger->charger);
189                 dev_err(&pdev->dev, "Failed to register power supply: %d\n",
190                         ret);
191                 goto err_gpio_free;
192         }
193 
194         irq = gpio_to_irq(pdata->gpio);
195         if (irq > 0) {
196                 ret = request_any_context_irq(irq, gpio_charger_irq,
197                                 IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
198                                 dev_name(&pdev->dev), gpio_charger->charger);
199                 if (ret < 0)
200                         dev_warn(&pdev->dev, "Failed to request irq: %d\n", ret);
201                 else
202                         gpio_charger->irq = irq;
203         }
204 
205         platform_set_drvdata(pdev, gpio_charger);
206 
207         device_init_wakeup(&pdev->dev, 1);
208 
209         return 0;
210 
211 err_gpio_free:
212         gpio_free(pdata->gpio);
213 err_free:
214         return ret;
215 }
216 
217 static int gpio_charger_remove(struct platform_device *pdev)
218 {
219         struct gpio_charger *gpio_charger = platform_get_drvdata(pdev);
220 
221         if (gpio_charger->irq)
222                 free_irq(gpio_charger->irq, gpio_charger->charger);
223 
224         power_supply_unregister(gpio_charger->charger);
225 
226         gpio_free(gpio_charger->pdata->gpio);
227 
228         return 0;
229 }
230 
231 #ifdef CONFIG_PM_SLEEP
232 static int gpio_charger_suspend(struct device *dev)
233 {
234         struct gpio_charger *gpio_charger = dev_get_drvdata(dev);
235 
236         if (device_may_wakeup(dev))
237                 gpio_charger->wakeup_enabled =
238                         !enable_irq_wake(gpio_charger->irq);
239 
240         return 0;
241 }
242 
243 static int gpio_charger_resume(struct device *dev)
244 {
245         struct platform_device *pdev = to_platform_device(dev);
246         struct gpio_charger *gpio_charger = platform_get_drvdata(pdev);
247 
248         if (device_may_wakeup(dev) && gpio_charger->wakeup_enabled)
249                 disable_irq_wake(gpio_charger->irq);
250         power_supply_changed(gpio_charger->charger);
251 
252         return 0;
253 }
254 #endif
255 
256 static SIMPLE_DEV_PM_OPS(gpio_charger_pm_ops,
257                 gpio_charger_suspend, gpio_charger_resume);
258 
259 static const struct of_device_id gpio_charger_match[] = {
260         { .compatible = "gpio-charger" },
261         { }
262 };
263 MODULE_DEVICE_TABLE(of, gpio_charger_match);
264 
265 static struct platform_driver gpio_charger_driver = {
266         .probe = gpio_charger_probe,
267         .remove = gpio_charger_remove,
268         .driver = {
269                 .name = "gpio-charger",
270                 .pm = &gpio_charger_pm_ops,
271                 .of_match_table = gpio_charger_match,
272         },
273 };
274 
275 module_platform_driver(gpio_charger_driver);
276 
277 MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
278 MODULE_DESCRIPTION("Driver for chargers which report their online status through a GPIO");
279 MODULE_LICENSE("GPL");
280 MODULE_ALIAS("platform:gpio-charger");
281 

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