1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Copyright (C) 2010, Lars-Peter Clausen <lars@metafoo.de> 4 * Driver for chargers which report their online status through a GPIO pin 5 */ 6 7 #include <linux/device.h> 8 #include <linux/init.h> 9 #include <linux/interrupt.h> 10 #include <linux/kernel.h> 11 #include <linux/module.h> 12 #include <linux/platform_device.h> 13 #include <linux/power_supply.h> 14 #include <linux/slab.h> 15 #include <linux/of.h> 16 #include <linux/gpio/consumer.h> 17 18 #include <linux/power/gpio-charger.h> 19 20 struct gpio_mapping { 21 u32 limit_ua; 22 u32 gpiodata; 23 } __packed; 24 25 struct gpio_charger { 26 struct device *dev; 27 unsigned int irq; 28 unsigned int charge_status_irq; 29 bool wakeup_enabled; 30 31 struct power_supply *charger; 32 struct power_supply_desc charger_desc; 33 struct gpio_desc *gpiod; 34 struct gpio_desc *charge_status; 35 36 struct gpio_descs *current_limit_gpios; 37 struct gpio_mapping *current_limit_map; 38 u32 current_limit_map_size; 39 u32 charge_current_limit; 40 }; 41 42 static irqreturn_t gpio_charger_irq(int irq, void *devid) 43 { 44 struct power_supply *charger = devid; 45 46 power_supply_changed(charger); 47 48 return IRQ_HANDLED; 49 } 50 51 static inline struct gpio_charger *psy_to_gpio_charger(struct power_supply *psy) 52 { 53 return power_supply_get_drvdata(psy); 54 } 55 56 static int set_charge_current_limit(struct gpio_charger *gpio_charger, int val) 57 { 58 struct gpio_mapping mapping; 59 int ndescs = gpio_charger->current_limit_gpios->ndescs; 60 struct gpio_desc **gpios = gpio_charger->current_limit_gpios->desc; 61 int i; 62 63 if (!gpio_charger->current_limit_map_size) 64 return -EINVAL; 65 66 for (i = 0; i < gpio_charger->current_limit_map_size; i++) { 67 if (gpio_charger->current_limit_map[i].limit_ua <= val) 68 break; 69 } 70 71 /* 72 * If a valid charge current limit isn't found, default to smallest 73 * current limitation for safety reasons. 74 */ 75 if (i >= gpio_charger->current_limit_map_size) 76 i = gpio_charger->current_limit_map_size - 1; 77 78 mapping = gpio_charger->current_limit_map[i]; 79 80 for (i = 0; i < ndescs; i++) { 81 bool val = (mapping.gpiodata >> i) & 1; 82 83 gpiod_set_value_cansleep(gpios[ndescs - i - 1], val); 84 } 85 86 gpio_charger->charge_current_limit = mapping.limit_ua; 87 88 dev_dbg(gpio_charger->dev, "set charge current limit to %d (requested: %d)\n", 89 gpio_charger->charge_current_limit, val); 90 91 return 0; 92 } 93 94 static int gpio_charger_get_property(struct power_supply *psy, 95 enum power_supply_property psp, union power_supply_propval *val) 96 { 97 struct gpio_charger *gpio_charger = psy_to_gpio_charger(psy); 98 99 switch (psp) { 100 case POWER_SUPPLY_PROP_ONLINE: 101 val->intval = gpiod_get_value_cansleep(gpio_charger->gpiod); 102 break; 103 case POWER_SUPPLY_PROP_STATUS: 104 if (gpiod_get_value_cansleep(gpio_charger->charge_status)) 105 val->intval = POWER_SUPPLY_STATUS_CHARGING; 106 else 107 val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING; 108 break; 109 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX: 110 val->intval = gpio_charger->charge_current_limit; 111 break; 112 default: 113 return -EINVAL; 114 } 115 116 return 0; 117 } 118 119 static int gpio_charger_set_property(struct power_supply *psy, 120 enum power_supply_property psp, const union power_supply_propval *val) 121 { 122 struct gpio_charger *gpio_charger = psy_to_gpio_charger(psy); 123 124 switch (psp) { 125 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX: 126 return set_charge_current_limit(gpio_charger, val->intval); 127 default: 128 return -EINVAL; 129 } 130 131 return 0; 132 } 133 134 static int gpio_charger_property_is_writeable(struct power_supply *psy, 135 enum power_supply_property psp) 136 { 137 switch (psp) { 138 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX: 139 return 1; 140 default: 141 break; 142 } 143 144 return 0; 145 } 146 147 static enum power_supply_type gpio_charger_get_type(struct device *dev) 148 { 149 const char *chargetype; 150 151 if (!device_property_read_string(dev, "charger-type", &chargetype)) { 152 if (!strcmp("unknown", chargetype)) 153 return POWER_SUPPLY_TYPE_UNKNOWN; 154 if (!strcmp("battery", chargetype)) 155 return POWER_SUPPLY_TYPE_BATTERY; 156 if (!strcmp("ups", chargetype)) 157 return POWER_SUPPLY_TYPE_UPS; 158 if (!strcmp("mains", chargetype)) 159 return POWER_SUPPLY_TYPE_MAINS; 160 if (!strcmp("usb-sdp", chargetype)) 161 return POWER_SUPPLY_TYPE_USB; 162 if (!strcmp("usb-dcp", chargetype)) 163 return POWER_SUPPLY_TYPE_USB; 164 if (!strcmp("usb-cdp", chargetype)) 165 return POWER_SUPPLY_TYPE_USB; 166 if (!strcmp("usb-aca", chargetype)) 167 return POWER_SUPPLY_TYPE_USB; 168 } 169 dev_warn(dev, "unknown charger type %s\n", chargetype); 170 171 return POWER_SUPPLY_TYPE_UNKNOWN; 172 } 173 174 static int gpio_charger_get_irq(struct device *dev, void *dev_id, 175 struct gpio_desc *gpio) 176 { 177 int ret, irq = gpiod_to_irq(gpio); 178 179 if (irq > 0) { 180 ret = devm_request_any_context_irq(dev, irq, gpio_charger_irq, 181 IRQF_TRIGGER_RISING | 182 IRQF_TRIGGER_FALLING, 183 dev_name(dev), 184 dev_id); 185 if (ret < 0) { 186 dev_warn(dev, "Failed to request irq: %d\n", ret); 187 irq = 0; 188 } 189 } 190 191 return irq; 192 } 193 194 static int init_charge_current_limit(struct device *dev, 195 struct gpio_charger *gpio_charger) 196 { 197 int i, len; 198 u32 cur_limit = U32_MAX; 199 bool set_def_limit; 200 u32 def_limit; 201 202 gpio_charger->current_limit_gpios = devm_gpiod_get_array_optional(dev, 203 "charge-current-limit", GPIOD_OUT_LOW); 204 if (IS_ERR(gpio_charger->current_limit_gpios)) { 205 dev_err(dev, "error getting current-limit GPIOs\n"); 206 return PTR_ERR(gpio_charger->current_limit_gpios); 207 } 208 209 if (!gpio_charger->current_limit_gpios) 210 return 0; 211 212 len = device_property_read_u32_array(dev, "charge-current-limit-mapping", 213 NULL, 0); 214 if (len < 0) 215 return len; 216 217 if (len == 0 || len % 2) { 218 dev_err(dev, "invalid charge-current-limit-mapping length\n"); 219 return -EINVAL; 220 } 221 222 gpio_charger->current_limit_map = devm_kmalloc_array(dev, 223 len / 2, sizeof(*gpio_charger->current_limit_map), GFP_KERNEL); 224 if (!gpio_charger->current_limit_map) 225 return -ENOMEM; 226 227 gpio_charger->current_limit_map_size = len / 2; 228 229 len = device_property_read_u32_array(dev, "charge-current-limit-mapping", 230 (u32 *) gpio_charger->current_limit_map, len); 231 if (len < 0) 232 return len; 233 234 set_def_limit = !device_property_read_u32(dev, 235 "charge-current-limit-default-microamp", 236 &def_limit); 237 for (i = 0; i < gpio_charger->current_limit_map_size; i++) { 238 if (gpio_charger->current_limit_map[i].limit_ua > cur_limit) { 239 dev_err(dev, "charge-current-limit-mapping not sorted by current in descending order\n"); 240 return -EINVAL; 241 } 242 243 cur_limit = gpio_charger->current_limit_map[i].limit_ua; 244 if (set_def_limit && def_limit == cur_limit) { 245 set_charge_current_limit(gpio_charger, cur_limit); 246 return 0; 247 } 248 } 249 250 if (set_def_limit) 251 dev_warn(dev, "charge-current-limit-default-microamp %u not listed in charge-current-limit-mapping\n", 252 def_limit); 253 254 /* default to smallest current limitation for safety reasons */ 255 len = gpio_charger->current_limit_map_size - 1; 256 set_charge_current_limit(gpio_charger, 257 gpio_charger->current_limit_map[len].limit_ua); 258 259 return 0; 260 } 261 262 /* 263 * The entries will be overwritten by driver's probe routine depending 264 * on the available features. This list ensures, that the array is big 265 * enough for all optional features. 266 */ 267 static enum power_supply_property gpio_charger_properties[] = { 268 POWER_SUPPLY_PROP_ONLINE, 269 POWER_SUPPLY_PROP_STATUS, 270 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX, 271 }; 272 273 static int gpio_charger_probe(struct platform_device *pdev) 274 { 275 struct device *dev = &pdev->dev; 276 const struct gpio_charger_platform_data *pdata = dev->platform_data; 277 struct power_supply_config psy_cfg = {}; 278 struct gpio_charger *gpio_charger; 279 struct power_supply_desc *charger_desc; 280 struct gpio_desc *charge_status; 281 int charge_status_irq; 282 int ret; 283 int num_props = 0; 284 285 if (!pdata && !dev->of_node) { 286 dev_err(dev, "No platform data\n"); 287 return -ENOENT; 288 } 289 290 gpio_charger = devm_kzalloc(dev, sizeof(*gpio_charger), GFP_KERNEL); 291 if (!gpio_charger) 292 return -ENOMEM; 293 gpio_charger->dev = dev; 294 295 /* 296 * This will fetch a GPIO descriptor from device tree, ACPI or 297 * boardfile descriptor tables. It's good to try this first. 298 */ 299 gpio_charger->gpiod = devm_gpiod_get_optional(dev, NULL, GPIOD_IN); 300 if (IS_ERR(gpio_charger->gpiod)) { 301 /* Just try again if this happens */ 302 return dev_err_probe(dev, PTR_ERR(gpio_charger->gpiod), 303 "error getting GPIO descriptor\n"); 304 } 305 306 if (gpio_charger->gpiod) { 307 gpio_charger_properties[num_props] = POWER_SUPPLY_PROP_ONLINE; 308 num_props++; 309 } 310 311 charge_status = devm_gpiod_get_optional(dev, "charge-status", GPIOD_IN); 312 if (IS_ERR(charge_status)) 313 return PTR_ERR(charge_status); 314 if (charge_status) { 315 gpio_charger->charge_status = charge_status; 316 gpio_charger_properties[num_props] = POWER_SUPPLY_PROP_STATUS; 317 num_props++; 318 } 319 320 ret = init_charge_current_limit(dev, gpio_charger); 321 if (ret < 0) 322 return ret; 323 if (gpio_charger->current_limit_map) { 324 gpio_charger_properties[num_props] = 325 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX; 326 num_props++; 327 } 328 329 charger_desc = &gpio_charger->charger_desc; 330 charger_desc->properties = gpio_charger_properties; 331 charger_desc->num_properties = num_props; 332 charger_desc->get_property = gpio_charger_get_property; 333 charger_desc->set_property = gpio_charger_set_property; 334 charger_desc->property_is_writeable = 335 gpio_charger_property_is_writeable; 336 337 psy_cfg.fwnode = dev_fwnode(dev); 338 psy_cfg.drv_data = gpio_charger; 339 340 if (pdata) { 341 charger_desc->name = pdata->name; 342 charger_desc->type = pdata->type; 343 psy_cfg.supplied_to = pdata->supplied_to; 344 psy_cfg.num_supplicants = pdata->num_supplicants; 345 } else { 346 charger_desc->name = dev->of_node->name; 347 charger_desc->type = gpio_charger_get_type(dev); 348 } 349 350 if (!charger_desc->name) 351 charger_desc->name = pdev->name; 352 353 gpio_charger->charger = devm_power_supply_register(dev, charger_desc, 354 &psy_cfg); 355 if (IS_ERR(gpio_charger->charger)) { 356 ret = PTR_ERR(gpio_charger->charger); 357 dev_err(dev, "Failed to register power supply: %d\n", ret); 358 return ret; 359 } 360 361 gpio_charger->irq = gpio_charger_get_irq(dev, gpio_charger->charger, 362 gpio_charger->gpiod); 363 364 charge_status_irq = gpio_charger_get_irq(dev, gpio_charger->charger, 365 gpio_charger->charge_status); 366 gpio_charger->charge_status_irq = charge_status_irq; 367 368 platform_set_drvdata(pdev, gpio_charger); 369 370 ret = devm_device_init_wakeup(dev); 371 if (ret) 372 return dev_err_probe(dev, ret, "Failed to init wakeup\n"); 373 374 return 0; 375 } 376 377 #ifdef CONFIG_PM_SLEEP 378 static int gpio_charger_suspend(struct device *dev) 379 { 380 struct gpio_charger *gpio_charger = dev_get_drvdata(dev); 381 382 if (device_may_wakeup(dev)) 383 gpio_charger->wakeup_enabled = 384 !enable_irq_wake(gpio_charger->irq); 385 386 return 0; 387 } 388 389 static int gpio_charger_resume(struct device *dev) 390 { 391 struct gpio_charger *gpio_charger = dev_get_drvdata(dev); 392 393 if (device_may_wakeup(dev) && gpio_charger->wakeup_enabled) 394 disable_irq_wake(gpio_charger->irq); 395 power_supply_changed(gpio_charger->charger); 396 397 return 0; 398 } 399 #endif 400 401 static SIMPLE_DEV_PM_OPS(gpio_charger_pm_ops, 402 gpio_charger_suspend, gpio_charger_resume); 403 404 static const struct of_device_id gpio_charger_match[] = { 405 { .compatible = "gpio-charger" }, 406 { } 407 }; 408 MODULE_DEVICE_TABLE(of, gpio_charger_match); 409 410 static struct platform_driver gpio_charger_driver = { 411 .probe = gpio_charger_probe, 412 .driver = { 413 .name = "gpio-charger", 414 .pm = &gpio_charger_pm_ops, 415 .of_match_table = gpio_charger_match, 416 }, 417 }; 418 419 module_platform_driver(gpio_charger_driver); 420 421 MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>"); 422 MODULE_DESCRIPTION("Driver for chargers only communicating via GPIO(s)"); 423 MODULE_LICENSE("GPL"); 424 MODULE_ALIAS("platform:gpio-charger"); 425