Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  *  Copyright (C) 2010, Lars-Peter Clausen <lars@metafoo.de>
0004  *  Driver for chargers which report their online status through a GPIO pin
0005  */
0006 
0007 #include <linux/device.h>
0008 #include <linux/init.h>
0009 #include <linux/interrupt.h>
0010 #include <linux/kernel.h>
0011 #include <linux/module.h>
0012 #include <linux/platform_device.h>
0013 #include <linux/power_supply.h>
0014 #include <linux/slab.h>
0015 #include <linux/of.h>
0016 #include <linux/gpio/consumer.h>
0017 
0018 #include <linux/power/gpio-charger.h>
0019 
0020 struct gpio_mapping {
0021     u32 limit_ua;
0022     u32 gpiodata;
0023 } __packed;
0024 
0025 struct gpio_charger {
0026     struct device *dev;
0027     unsigned int irq;
0028     unsigned int charge_status_irq;
0029     bool wakeup_enabled;
0030 
0031     struct power_supply *charger;
0032     struct power_supply_desc charger_desc;
0033     struct gpio_desc *gpiod;
0034     struct gpio_desc *charge_status;
0035 
0036     struct gpio_descs *current_limit_gpios;
0037     struct gpio_mapping *current_limit_map;
0038     u32 current_limit_map_size;
0039     u32 charge_current_limit;
0040 };
0041 
0042 static irqreturn_t gpio_charger_irq(int irq, void *devid)
0043 {
0044     struct power_supply *charger = devid;
0045 
0046     power_supply_changed(charger);
0047 
0048     return IRQ_HANDLED;
0049 }
0050 
0051 static inline struct gpio_charger *psy_to_gpio_charger(struct power_supply *psy)
0052 {
0053     return power_supply_get_drvdata(psy);
0054 }
0055 
0056 static int set_charge_current_limit(struct gpio_charger *gpio_charger, int val)
0057 {
0058     struct gpio_mapping mapping;
0059     int ndescs = gpio_charger->current_limit_gpios->ndescs;
0060     struct gpio_desc **gpios = gpio_charger->current_limit_gpios->desc;
0061     int i;
0062 
0063     if (!gpio_charger->current_limit_map_size)
0064         return -EINVAL;
0065 
0066     for (i = 0; i < gpio_charger->current_limit_map_size; i++) {
0067         if (gpio_charger->current_limit_map[i].limit_ua <= val)
0068             break;
0069     }
0070     mapping = gpio_charger->current_limit_map[i];
0071 
0072     for (i = 0; i < ndescs; i++) {
0073         bool val = (mapping.gpiodata >> i) & 1;
0074         gpiod_set_value_cansleep(gpios[ndescs-i-1], val);
0075     }
0076 
0077     gpio_charger->charge_current_limit = mapping.limit_ua;
0078 
0079     dev_dbg(gpio_charger->dev, "set charge current limit to %d (requested: %d)\n",
0080         gpio_charger->charge_current_limit, val);
0081 
0082     return 0;
0083 }
0084 
0085 static int gpio_charger_get_property(struct power_supply *psy,
0086         enum power_supply_property psp, union power_supply_propval *val)
0087 {
0088     struct gpio_charger *gpio_charger = psy_to_gpio_charger(psy);
0089 
0090     switch (psp) {
0091     case POWER_SUPPLY_PROP_ONLINE:
0092         val->intval = gpiod_get_value_cansleep(gpio_charger->gpiod);
0093         break;
0094     case POWER_SUPPLY_PROP_STATUS:
0095         if (gpiod_get_value_cansleep(gpio_charger->charge_status))
0096             val->intval = POWER_SUPPLY_STATUS_CHARGING;
0097         else
0098             val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
0099         break;
0100     case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
0101         val->intval = gpio_charger->charge_current_limit;
0102         break;
0103     default:
0104         return -EINVAL;
0105     }
0106 
0107     return 0;
0108 }
0109 
0110 static int gpio_charger_set_property(struct power_supply *psy,
0111     enum power_supply_property psp, const union power_supply_propval *val)
0112 {
0113     struct gpio_charger *gpio_charger = psy_to_gpio_charger(psy);
0114 
0115     switch (psp) {
0116     case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
0117         return set_charge_current_limit(gpio_charger, val->intval);
0118     default:
0119         return -EINVAL;
0120     }
0121 
0122     return 0;
0123 }
0124 
0125 static int gpio_charger_property_is_writeable(struct power_supply *psy,
0126                           enum power_supply_property psp)
0127 {
0128     switch (psp) {
0129     case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
0130         return 1;
0131     default:
0132         break;
0133     }
0134 
0135     return 0;
0136 }
0137 
0138 static enum power_supply_type gpio_charger_get_type(struct device *dev)
0139 {
0140     const char *chargetype;
0141 
0142     if (!device_property_read_string(dev, "charger-type", &chargetype)) {
0143         if (!strcmp("unknown", chargetype))
0144             return POWER_SUPPLY_TYPE_UNKNOWN;
0145         if (!strcmp("battery", chargetype))
0146             return POWER_SUPPLY_TYPE_BATTERY;
0147         if (!strcmp("ups", chargetype))
0148             return POWER_SUPPLY_TYPE_UPS;
0149         if (!strcmp("mains", chargetype))
0150             return POWER_SUPPLY_TYPE_MAINS;
0151         if (!strcmp("usb-sdp", chargetype))
0152             return POWER_SUPPLY_TYPE_USB;
0153         if (!strcmp("usb-dcp", chargetype))
0154             return POWER_SUPPLY_TYPE_USB;
0155         if (!strcmp("usb-cdp", chargetype))
0156             return POWER_SUPPLY_TYPE_USB;
0157         if (!strcmp("usb-aca", chargetype))
0158             return POWER_SUPPLY_TYPE_USB;
0159     }
0160     dev_warn(dev, "unknown charger type %s\n", chargetype);
0161 
0162     return POWER_SUPPLY_TYPE_UNKNOWN;
0163 }
0164 
0165 static int gpio_charger_get_irq(struct device *dev, void *dev_id,
0166                 struct gpio_desc *gpio)
0167 {
0168     int ret, irq = gpiod_to_irq(gpio);
0169 
0170     if (irq > 0) {
0171         ret = devm_request_any_context_irq(dev, irq, gpio_charger_irq,
0172                            IRQF_TRIGGER_RISING |
0173                            IRQF_TRIGGER_FALLING,
0174                            dev_name(dev),
0175                            dev_id);
0176         if (ret < 0) {
0177             dev_warn(dev, "Failed to request irq: %d\n", ret);
0178             irq = 0;
0179         }
0180     }
0181 
0182     return irq;
0183 }
0184 
0185 static int init_charge_current_limit(struct device *dev,
0186                     struct gpio_charger *gpio_charger)
0187 {
0188     int i, len;
0189     u32 cur_limit = U32_MAX;
0190 
0191     gpio_charger->current_limit_gpios = devm_gpiod_get_array_optional(dev,
0192         "charge-current-limit", GPIOD_OUT_LOW);
0193     if (IS_ERR(gpio_charger->current_limit_gpios)) {
0194         dev_err(dev, "error getting current-limit GPIOs\n");
0195         return PTR_ERR(gpio_charger->current_limit_gpios);
0196     }
0197 
0198     if (!gpio_charger->current_limit_gpios)
0199         return 0;
0200 
0201     len = device_property_read_u32_array(dev, "charge-current-limit-mapping",
0202         NULL, 0);
0203     if (len < 0)
0204         return len;
0205 
0206     if (len == 0 || len % 2) {
0207         dev_err(dev, "invalid charge-current-limit-mapping length\n");
0208         return -EINVAL;
0209     }
0210 
0211     gpio_charger->current_limit_map = devm_kmalloc_array(dev,
0212         len / 2, sizeof(*gpio_charger->current_limit_map), GFP_KERNEL);
0213     if (!gpio_charger->current_limit_map)
0214         return -ENOMEM;
0215 
0216     gpio_charger->current_limit_map_size = len / 2;
0217 
0218     len = device_property_read_u32_array(dev, "charge-current-limit-mapping",
0219         (u32*) gpio_charger->current_limit_map, len);
0220     if (len < 0)
0221         return len;
0222 
0223     for (i=0; i < gpio_charger->current_limit_map_size; i++) {
0224         if (gpio_charger->current_limit_map[i].limit_ua > cur_limit) {
0225             dev_err(dev, "charge-current-limit-mapping not sorted by current in descending order\n");
0226             return -EINVAL;
0227         }
0228 
0229         cur_limit = gpio_charger->current_limit_map[i].limit_ua;
0230     }
0231 
0232     /* default to smallest current limitation for safety reasons */
0233     len = gpio_charger->current_limit_map_size - 1;
0234     set_charge_current_limit(gpio_charger,
0235         gpio_charger->current_limit_map[len].limit_ua);
0236 
0237     return 0;
0238 }
0239 
0240 /*
0241  * The entries will be overwritten by driver's probe routine depending
0242  * on the available features. This list ensures, that the array is big
0243  * enough for all optional features.
0244  */
0245 static enum power_supply_property gpio_charger_properties[] = {
0246     POWER_SUPPLY_PROP_ONLINE,
0247     POWER_SUPPLY_PROP_STATUS,
0248     POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX,
0249 };
0250 
0251 static int gpio_charger_probe(struct platform_device *pdev)
0252 {
0253     struct device *dev = &pdev->dev;
0254     const struct gpio_charger_platform_data *pdata = dev->platform_data;
0255     struct power_supply_config psy_cfg = {};
0256     struct gpio_charger *gpio_charger;
0257     struct power_supply_desc *charger_desc;
0258     struct gpio_desc *charge_status;
0259     int charge_status_irq;
0260     int ret;
0261     int num_props = 0;
0262 
0263     if (!pdata && !dev->of_node) {
0264         dev_err(dev, "No platform data\n");
0265         return -ENOENT;
0266     }
0267 
0268     gpio_charger = devm_kzalloc(dev, sizeof(*gpio_charger), GFP_KERNEL);
0269     if (!gpio_charger)
0270         return -ENOMEM;
0271     gpio_charger->dev = dev;
0272 
0273     /*
0274      * This will fetch a GPIO descriptor from device tree, ACPI or
0275      * boardfile descriptor tables. It's good to try this first.
0276      */
0277     gpio_charger->gpiod = devm_gpiod_get_optional(dev, NULL, GPIOD_IN);
0278     if (IS_ERR(gpio_charger->gpiod)) {
0279         /* Just try again if this happens */
0280         return dev_err_probe(dev, PTR_ERR(gpio_charger->gpiod),
0281                      "error getting GPIO descriptor\n");
0282     }
0283 
0284     if (gpio_charger->gpiod) {
0285         gpio_charger_properties[num_props] = POWER_SUPPLY_PROP_ONLINE;
0286         num_props++;
0287     }
0288 
0289     charge_status = devm_gpiod_get_optional(dev, "charge-status", GPIOD_IN);
0290     if (IS_ERR(charge_status))
0291         return PTR_ERR(charge_status);
0292     if (charge_status) {
0293         gpio_charger->charge_status = charge_status;
0294         gpio_charger_properties[num_props] = POWER_SUPPLY_PROP_STATUS;
0295         num_props++;
0296     }
0297 
0298     ret = init_charge_current_limit(dev, gpio_charger);
0299     if (ret < 0)
0300         return ret;
0301     if (gpio_charger->current_limit_map) {
0302         gpio_charger_properties[num_props] =
0303             POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX;
0304         num_props++;
0305     }
0306 
0307     charger_desc = &gpio_charger->charger_desc;
0308     charger_desc->properties = gpio_charger_properties;
0309     charger_desc->num_properties = num_props;
0310     charger_desc->get_property = gpio_charger_get_property;
0311     charger_desc->set_property = gpio_charger_set_property;
0312     charger_desc->property_is_writeable =
0313                     gpio_charger_property_is_writeable;
0314 
0315     psy_cfg.of_node = dev->of_node;
0316     psy_cfg.drv_data = gpio_charger;
0317 
0318     if (pdata) {
0319         charger_desc->name = pdata->name;
0320         charger_desc->type = pdata->type;
0321         psy_cfg.supplied_to = pdata->supplied_to;
0322         psy_cfg.num_supplicants = pdata->num_supplicants;
0323     } else {
0324         charger_desc->name = dev->of_node->name;
0325         charger_desc->type = gpio_charger_get_type(dev);
0326     }
0327 
0328     if (!charger_desc->name)
0329         charger_desc->name = pdev->name;
0330 
0331     gpio_charger->charger = devm_power_supply_register(dev, charger_desc,
0332                                &psy_cfg);
0333     if (IS_ERR(gpio_charger->charger)) {
0334         ret = PTR_ERR(gpio_charger->charger);
0335         dev_err(dev, "Failed to register power supply: %d\n", ret);
0336         return ret;
0337     }
0338 
0339     gpio_charger->irq = gpio_charger_get_irq(dev, gpio_charger->charger,
0340                          gpio_charger->gpiod);
0341 
0342     charge_status_irq = gpio_charger_get_irq(dev, gpio_charger->charger,
0343                          gpio_charger->charge_status);
0344     gpio_charger->charge_status_irq = charge_status_irq;
0345 
0346     platform_set_drvdata(pdev, gpio_charger);
0347 
0348     device_init_wakeup(dev, 1);
0349 
0350     return 0;
0351 }
0352 
0353 #ifdef CONFIG_PM_SLEEP
0354 static int gpio_charger_suspend(struct device *dev)
0355 {
0356     struct gpio_charger *gpio_charger = dev_get_drvdata(dev);
0357 
0358     if (device_may_wakeup(dev))
0359         gpio_charger->wakeup_enabled =
0360             !enable_irq_wake(gpio_charger->irq);
0361 
0362     return 0;
0363 }
0364 
0365 static int gpio_charger_resume(struct device *dev)
0366 {
0367     struct gpio_charger *gpio_charger = dev_get_drvdata(dev);
0368 
0369     if (device_may_wakeup(dev) && gpio_charger->wakeup_enabled)
0370         disable_irq_wake(gpio_charger->irq);
0371     power_supply_changed(gpio_charger->charger);
0372 
0373     return 0;
0374 }
0375 #endif
0376 
0377 static SIMPLE_DEV_PM_OPS(gpio_charger_pm_ops,
0378         gpio_charger_suspend, gpio_charger_resume);
0379 
0380 static const struct of_device_id gpio_charger_match[] = {
0381     { .compatible = "gpio-charger" },
0382     { }
0383 };
0384 MODULE_DEVICE_TABLE(of, gpio_charger_match);
0385 
0386 static struct platform_driver gpio_charger_driver = {
0387     .probe = gpio_charger_probe,
0388     .driver = {
0389         .name = "gpio-charger",
0390         .pm = &gpio_charger_pm_ops,
0391         .of_match_table = gpio_charger_match,
0392     },
0393 };
0394 
0395 module_platform_driver(gpio_charger_driver);
0396 
0397 MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
0398 MODULE_DESCRIPTION("Driver for chargers only communicating via GPIO(s)");
0399 MODULE_LICENSE("GPL");
0400 MODULE_ALIAS("platform:gpio-charger");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!