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