1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * max8903_charger.c - Maxim 8903 USB/Adapter Charger Driver 4 * 5 * Copyright (C) 2011 Samsung Electronics 6 * MyungJoo Ham <myungjoo.ham@samsung.com> 7 */ 8 9 #include <linux/gpio/consumer.h> 10 #include <linux/interrupt.h> 11 #include <linux/module.h> 12 #include <linux/of.h> 13 #include <linux/of_device.h> 14 #include <linux/slab.h> 15 #include <linux/power_supply.h> 16 #include <linux/platform_device.h> 17 18 struct max8903_data { 19 struct device *dev; 20 struct power_supply *psy; 21 struct power_supply_desc psy_desc; 22 /* 23 * GPIOs 24 * chg, flt, dcm and usus are optional. 25 * dok or uok must be present. 26 * If dok is present, cen must be present. 27 */ 28 struct gpio_desc *cen; /* Charger Enable input */ 29 struct gpio_desc *dok; /* DC (Adapter) Power OK output */ 30 struct gpio_desc *uok; /* USB Power OK output */ 31 struct gpio_desc *chg; /* Charger status output */ 32 struct gpio_desc *flt; /* Fault output */ 33 struct gpio_desc *dcm; /* Current-Limit Mode input (1: DC, 2: USB) */ 34 struct gpio_desc *usus; /* USB Suspend Input (1: suspended) */ 35 bool fault; 36 bool usb_in; 37 bool ta_in; 38 }; 39 40 static enum power_supply_property max8903_charger_props[] = { 41 POWER_SUPPLY_PROP_STATUS, /* Charger status output */ 42 POWER_SUPPLY_PROP_ONLINE, /* External power source */ 43 POWER_SUPPLY_PROP_HEALTH, /* Fault or OK */ 44 }; 45 46 static int max8903_get_property(struct power_supply *psy, 47 enum power_supply_property psp, 48 union power_supply_propval *val) 49 { 50 struct max8903_data *data = power_supply_get_drvdata(psy); 51 52 switch (psp) { 53 case POWER_SUPPLY_PROP_STATUS: 54 val->intval = POWER_SUPPLY_STATUS_UNKNOWN; 55 if (data->chg) { 56 if (gpiod_get_value(data->chg)) 57 /* CHG asserted */ 58 val->intval = POWER_SUPPLY_STATUS_CHARGING; 59 else if (data->usb_in || data->ta_in) 60 val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING; 61 else 62 val->intval = POWER_SUPPLY_STATUS_DISCHARGING; 63 } 64 break; 65 case POWER_SUPPLY_PROP_ONLINE: 66 val->intval = 0; 67 if (data->usb_in || data->ta_in) 68 val->intval = 1; 69 break; 70 case POWER_SUPPLY_PROP_HEALTH: 71 val->intval = POWER_SUPPLY_HEALTH_GOOD; 72 if (data->fault) 73 val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE; 74 break; 75 default: 76 return -EINVAL; 77 } 78 79 return 0; 80 } 81 82 static irqreturn_t max8903_dcin(int irq, void *_data) 83 { 84 struct max8903_data *data = _data; 85 bool ta_in; 86 enum power_supply_type old_type; 87 88 /* 89 * This means the line is asserted. 90 * 91 * The signal is active low, but the inversion is handled in the GPIO 92 * library as the line should be flagged GPIO_ACTIVE_LOW in the device 93 * tree. 94 */ 95 ta_in = gpiod_get_value(data->dok); 96 97 if (ta_in == data->ta_in) 98 return IRQ_HANDLED; 99 100 data->ta_in = ta_in; 101 102 /* Set Current-Limit-Mode 1:DC 0:USB */ 103 if (data->dcm) 104 gpiod_set_value(data->dcm, ta_in); 105 106 /* Charger Enable / Disable */ 107 if (data->cen) { 108 int val; 109 110 if (ta_in) 111 /* Certainly enable if DOK is asserted */ 112 val = 1; 113 else if (data->usb_in) 114 /* Enable if the USB charger is enabled */ 115 val = 1; 116 else 117 /* Else default-disable */ 118 val = 0; 119 120 gpiod_set_value(data->cen, val); 121 } 122 123 dev_dbg(data->dev, "TA(DC-IN) Charger %s.\n", ta_in ? 124 "Connected" : "Disconnected"); 125 126 old_type = data->psy_desc.type; 127 128 if (data->ta_in) 129 data->psy_desc.type = POWER_SUPPLY_TYPE_MAINS; 130 else if (data->usb_in) 131 data->psy_desc.type = POWER_SUPPLY_TYPE_USB; 132 else 133 data->psy_desc.type = POWER_SUPPLY_TYPE_BATTERY; 134 135 if (old_type != data->psy_desc.type) 136 power_supply_changed(data->psy); 137 138 return IRQ_HANDLED; 139 } 140 141 static irqreturn_t max8903_usbin(int irq, void *_data) 142 { 143 struct max8903_data *data = _data; 144 bool usb_in; 145 enum power_supply_type old_type; 146 147 /* 148 * This means the line is asserted. 149 * 150 * The signal is active low, but the inversion is handled in the GPIO 151 * library as the line should be flagged GPIO_ACTIVE_LOW in the device 152 * tree. 153 */ 154 usb_in = gpiod_get_value(data->uok); 155 156 if (usb_in == data->usb_in) 157 return IRQ_HANDLED; 158 159 data->usb_in = usb_in; 160 161 /* Do not touch Current-Limit-Mode */ 162 163 /* Charger Enable / Disable */ 164 if (data->cen) { 165 int val; 166 167 if (usb_in) 168 /* Certainly enable if UOK is asserted */ 169 val = 1; 170 else if (data->ta_in) 171 /* Enable if the DC charger is enabled */ 172 val = 1; 173 else 174 /* Else default-disable */ 175 val = 0; 176 177 gpiod_set_value(data->cen, val); 178 } 179 180 dev_dbg(data->dev, "USB Charger %s.\n", usb_in ? 181 "Connected" : "Disconnected"); 182 183 old_type = data->psy_desc.type; 184 185 if (data->ta_in) 186 data->psy_desc.type = POWER_SUPPLY_TYPE_MAINS; 187 else if (data->usb_in) 188 data->psy_desc.type = POWER_SUPPLY_TYPE_USB; 189 else 190 data->psy_desc.type = POWER_SUPPLY_TYPE_BATTERY; 191 192 if (old_type != data->psy_desc.type) 193 power_supply_changed(data->psy); 194 195 return IRQ_HANDLED; 196 } 197 198 static irqreturn_t max8903_fault(int irq, void *_data) 199 { 200 struct max8903_data *data = _data; 201 bool fault; 202 203 /* 204 * This means the line is asserted. 205 * 206 * The signal is active low, but the inversion is handled in the GPIO 207 * library as the line should be flagged GPIO_ACTIVE_LOW in the device 208 * tree. 209 */ 210 fault = gpiod_get_value(data->flt); 211 212 if (fault == data->fault) 213 return IRQ_HANDLED; 214 215 data->fault = fault; 216 217 if (fault) 218 dev_err(data->dev, "Charger suffers a fault and stops.\n"); 219 else 220 dev_err(data->dev, "Charger recovered from a fault.\n"); 221 222 return IRQ_HANDLED; 223 } 224 225 static int max8903_setup_gpios(struct platform_device *pdev) 226 { 227 struct max8903_data *data = platform_get_drvdata(pdev); 228 struct device *dev = &pdev->dev; 229 bool ta_in = false; 230 bool usb_in = false; 231 enum gpiod_flags flags; 232 233 data->dok = devm_gpiod_get_optional(dev, "dok", GPIOD_IN); 234 if (IS_ERR(data->dok)) 235 return dev_err_probe(dev, PTR_ERR(data->dok), 236 "failed to get DOK GPIO"); 237 if (data->dok) { 238 gpiod_set_consumer_name(data->dok, data->psy_desc.name); 239 /* 240 * The DC OK is pulled up to 1 and goes low when a charger 241 * is plugged in (active low) but in the device tree the 242 * line is marked as GPIO_ACTIVE_LOW so we get a 1 (asserted) 243 * here if the DC charger is plugged in. 244 */ 245 ta_in = gpiod_get_value(data->dok); 246 } 247 248 data->uok = devm_gpiod_get_optional(dev, "uok", GPIOD_IN); 249 if (IS_ERR(data->uok)) 250 return dev_err_probe(dev, PTR_ERR(data->uok), 251 "failed to get UOK GPIO"); 252 if (data->uok) { 253 gpiod_set_consumer_name(data->uok, data->psy_desc.name); 254 /* 255 * The USB OK is pulled up to 1 and goes low when a USB charger 256 * is plugged in (active low) but in the device tree the 257 * line is marked as GPIO_ACTIVE_LOW so we get a 1 (asserted) 258 * here if the USB charger is plugged in. 259 */ 260 usb_in = gpiod_get_value(data->uok); 261 } 262 263 /* Either DC OK or USB OK must be provided */ 264 if (!data->dok && !data->uok) { 265 dev_err(dev, "no valid power source\n"); 266 return -EINVAL; 267 } 268 269 /* 270 * If either charger is already connected at this point, 271 * assert the CEN line and enable charging from the start. 272 * 273 * The line is active low but also marked with GPIO_ACTIVE_LOW 274 * in the device tree, so when we assert the line with 275 * GPIOD_OUT_HIGH the line will be driven low. 276 */ 277 flags = (ta_in || usb_in) ? GPIOD_OUT_HIGH : GPIOD_OUT_LOW; 278 /* 279 * If DC OK is provided, Charger Enable CEN is compulsory 280 * so this is not optional here. 281 */ 282 data->cen = devm_gpiod_get(dev, "cen", flags); 283 if (IS_ERR(data->cen)) 284 return dev_err_probe(dev, PTR_ERR(data->cen), 285 "failed to get CEN GPIO"); 286 gpiod_set_consumer_name(data->cen, data->psy_desc.name); 287 288 /* 289 * If the DC charger is connected, then select it. 290 * 291 * The DCM line should be marked GPIO_ACTIVE_HIGH in the 292 * device tree. Driving it high will enable the DC charger 293 * input over the USB charger input. 294 */ 295 flags = ta_in ? GPIOD_OUT_HIGH : GPIOD_OUT_LOW; 296 data->dcm = devm_gpiod_get_optional(dev, "dcm", flags); 297 if (IS_ERR(data->dcm)) 298 return dev_err_probe(dev, PTR_ERR(data->dcm), 299 "failed to get DCM GPIO"); 300 gpiod_set_consumer_name(data->dcm, data->psy_desc.name); 301 302 data->chg = devm_gpiod_get_optional(dev, "chg", GPIOD_IN); 303 if (IS_ERR(data->chg)) 304 return dev_err_probe(dev, PTR_ERR(data->chg), 305 "failed to get CHG GPIO"); 306 gpiod_set_consumer_name(data->chg, data->psy_desc.name); 307 308 data->flt = devm_gpiod_get_optional(dev, "flt", GPIOD_IN); 309 if (IS_ERR(data->flt)) 310 return dev_err_probe(dev, PTR_ERR(data->flt), 311 "failed to get FLT GPIO"); 312 gpiod_set_consumer_name(data->flt, data->psy_desc.name); 313 314 data->usus = devm_gpiod_get_optional(dev, "usus", GPIOD_IN); 315 if (IS_ERR(data->usus)) 316 return dev_err_probe(dev, PTR_ERR(data->usus), 317 "failed to get USUS GPIO"); 318 gpiod_set_consumer_name(data->usus, data->psy_desc.name); 319 320 data->fault = false; 321 data->ta_in = ta_in; 322 data->usb_in = usb_in; 323 324 return 0; 325 } 326 327 static int max8903_probe(struct platform_device *pdev) 328 { 329 struct max8903_data *data; 330 struct device *dev = &pdev->dev; 331 struct power_supply_config psy_cfg = {}; 332 int ret = 0; 333 334 data = devm_kzalloc(dev, sizeof(struct max8903_data), GFP_KERNEL); 335 if (!data) 336 return -ENOMEM; 337 338 data->dev = dev; 339 platform_set_drvdata(pdev, data); 340 341 ret = max8903_setup_gpios(pdev); 342 if (ret) 343 return ret; 344 345 data->psy_desc.name = "max8903_charger"; 346 data->psy_desc.type = (data->ta_in) ? POWER_SUPPLY_TYPE_MAINS : 347 ((data->usb_in) ? POWER_SUPPLY_TYPE_USB : 348 POWER_SUPPLY_TYPE_BATTERY); 349 data->psy_desc.get_property = max8903_get_property; 350 data->psy_desc.properties = max8903_charger_props; 351 data->psy_desc.num_properties = ARRAY_SIZE(max8903_charger_props); 352 353 psy_cfg.of_node = dev->of_node; 354 psy_cfg.drv_data = data; 355 356 data->psy = devm_power_supply_register(dev, &data->psy_desc, &psy_cfg); 357 if (IS_ERR(data->psy)) { 358 dev_err(dev, "failed: power supply register.\n"); 359 return PTR_ERR(data->psy); 360 } 361 362 if (data->dok) { 363 ret = devm_request_threaded_irq(dev, gpiod_to_irq(data->dok), 364 NULL, max8903_dcin, 365 IRQF_TRIGGER_FALLING | 366 IRQF_TRIGGER_RISING | IRQF_ONESHOT, 367 "MAX8903 DC IN", data); 368 if (ret) { 369 dev_err(dev, "Cannot request irq %d for DC (%d)\n", 370 gpiod_to_irq(data->dok), ret); 371 return ret; 372 } 373 } 374 375 if (data->uok) { 376 ret = devm_request_threaded_irq(dev, gpiod_to_irq(data->uok), 377 NULL, max8903_usbin, 378 IRQF_TRIGGER_FALLING | 379 IRQF_TRIGGER_RISING | IRQF_ONESHOT, 380 "MAX8903 USB IN", data); 381 if (ret) { 382 dev_err(dev, "Cannot request irq %d for USB (%d)\n", 383 gpiod_to_irq(data->uok), ret); 384 return ret; 385 } 386 } 387 388 if (data->flt) { 389 ret = devm_request_threaded_irq(dev, gpiod_to_irq(data->flt), 390 NULL, max8903_fault, 391 IRQF_TRIGGER_FALLING | 392 IRQF_TRIGGER_RISING | IRQF_ONESHOT, 393 "MAX8903 Fault", data); 394 if (ret) { 395 dev_err(dev, "Cannot request irq %d for Fault (%d)\n", 396 gpiod_to_irq(data->flt), ret); 397 return ret; 398 } 399 } 400 401 return 0; 402 } 403 404 static const struct of_device_id max8903_match_ids[] = { 405 { .compatible = "maxim,max8903", }, 406 { /* sentinel */ } 407 }; 408 MODULE_DEVICE_TABLE(of, max8903_match_ids); 409 410 static struct platform_driver max8903_driver = { 411 .probe = max8903_probe, 412 .driver = { 413 .name = "max8903-charger", 414 .of_match_table = max8903_match_ids 415 }, 416 }; 417 418 module_platform_driver(max8903_driver); 419 420 MODULE_LICENSE("GPL"); 421 MODULE_DESCRIPTION("MAX8903 Charger Driver"); 422 MODULE_AUTHOR("MyungJoo Ham <myungjoo.ham@samsung.com>"); 423 MODULE_ALIAS("platform:max8903-charger"); 424