1 // SPDX-License-Identifier: GPL-2.0 2 // 3 // Copyright (C) 2018 BayLibre SAS 4 // Author: Bartosz Golaszewski <bgolaszewski@baylibre.com> 5 // 6 // Battery charger driver for MAXIM 77650/77651 charger/power-supply. 7 8 #include <linux/i2c.h> 9 #include <linux/interrupt.h> 10 #include <linux/mfd/max77650.h> 11 #include <linux/module.h> 12 #include <linux/platform_device.h> 13 #include <linux/power_supply.h> 14 #include <linux/regmap.h> 15 16 #define MAX77650_CHARGER_ENABLED BIT(0) 17 #define MAX77650_CHARGER_DISABLED 0x00 18 #define MAX77650_CHARGER_CHG_EN_MASK BIT(0) 19 20 #define MAX77650_CHG_DETAILS_MASK GENMASK(7, 4) 21 #define MAX77650_CHG_DETAILS_BITS(_reg) \ 22 (((_reg) & MAX77650_CHG_DETAILS_MASK) >> 4) 23 24 /* Charger is OFF. */ 25 #define MAX77650_CHG_OFF 0x00 26 /* Charger is in prequalification mode. */ 27 #define MAX77650_CHG_PREQ 0x01 28 /* Charger is in fast-charge constant current mode. */ 29 #define MAX77650_CHG_ON_CURR 0x02 30 /* Charger is in JEITA modified fast-charge constant-current mode. */ 31 #define MAX77650_CHG_ON_CURR_JEITA 0x03 32 /* Charger is in fast-charge constant-voltage mode. */ 33 #define MAX77650_CHG_ON_VOLT 0x04 34 /* Charger is in JEITA modified fast-charge constant-voltage mode. */ 35 #define MAX77650_CHG_ON_VOLT_JEITA 0x05 36 /* Charger is in top-off mode. */ 37 #define MAX77650_CHG_ON_TOPOFF 0x06 38 /* Charger is in JEITA modified top-off mode. */ 39 #define MAX77650_CHG_ON_TOPOFF_JEITA 0x07 40 /* Charger is done. */ 41 #define MAX77650_CHG_DONE 0x08 42 /* Charger is JEITA modified done. */ 43 #define MAX77650_CHG_DONE_JEITA 0x09 44 /* Charger is suspended due to a prequalification timer fault. */ 45 #define MAX77650_CHG_SUSP_PREQ_TIM_FAULT 0x0a 46 /* Charger is suspended due to a fast-charge timer fault. */ 47 #define MAX77650_CHG_SUSP_FAST_CHG_TIM_FAULT 0x0b 48 /* Charger is suspended due to a battery temperature fault. */ 49 #define MAX77650_CHG_SUSP_BATT_TEMP_FAULT 0x0c 50 51 #define MAX77650_CHGIN_DETAILS_MASK GENMASK(3, 2) 52 #define MAX77650_CHGIN_DETAILS_BITS(_reg) \ 53 (((_reg) & MAX77650_CHGIN_DETAILS_MASK) >> 2) 54 55 #define MAX77650_CHGIN_UNDERVOLTAGE_LOCKOUT 0x00 56 #define MAX77650_CHGIN_OVERVOLTAGE_LOCKOUT 0x01 57 #define MAX77650_CHGIN_OKAY 0x11 58 59 #define MAX77650_CHARGER_CHG_MASK BIT(1) 60 #define MAX77650_CHARGER_CHG_CHARGING(_reg) \ 61 (((_reg) & MAX77650_CHARGER_CHG_MASK) > 1) 62 63 #define MAX77650_CHARGER_VCHGIN_MIN_MASK 0xc0 64 #define MAX77650_CHARGER_VCHGIN_MIN_SHIFT(_val) ((_val) << 5) 65 66 #define MAX77650_CHARGER_ICHGIN_LIM_MASK 0x1c 67 #define MAX77650_CHARGER_ICHGIN_LIM_SHIFT(_val) ((_val) << 2) 68 69 struct max77650_charger_data { 70 struct regmap *map; 71 struct device *dev; 72 }; 73 74 static enum power_supply_property max77650_charger_properties[] = { 75 POWER_SUPPLY_PROP_STATUS, 76 POWER_SUPPLY_PROP_ONLINE, 77 POWER_SUPPLY_PROP_CHARGE_TYPE 78 }; 79 80 static const unsigned int max77650_charger_vchgin_min_table[] = { 81 4000000, 4100000, 4200000, 4300000, 4400000, 4500000, 4600000, 4700000 82 }; 83 84 static const unsigned int max77650_charger_ichgin_lim_table[] = { 85 95000, 190000, 285000, 380000, 475000 86 }; 87 88 static int max77650_charger_set_vchgin_min(struct max77650_charger_data *chg, 89 unsigned int val) 90 { 91 int i, rv; 92 93 for (i = 0; i < ARRAY_SIZE(max77650_charger_vchgin_min_table); i++) { 94 if (val == max77650_charger_vchgin_min_table[i]) { 95 rv = regmap_update_bits(chg->map, 96 MAX77650_REG_CNFG_CHG_B, 97 MAX77650_CHARGER_VCHGIN_MIN_MASK, 98 MAX77650_CHARGER_VCHGIN_MIN_SHIFT(i)); 99 if (rv) 100 return rv; 101 102 return 0; 103 } 104 } 105 106 return -EINVAL; 107 } 108 109 static int max77650_charger_set_ichgin_lim(struct max77650_charger_data *chg, 110 unsigned int val) 111 { 112 int i, rv; 113 114 for (i = 0; i < ARRAY_SIZE(max77650_charger_ichgin_lim_table); i++) { 115 if (val == max77650_charger_ichgin_lim_table[i]) { 116 rv = regmap_update_bits(chg->map, 117 MAX77650_REG_CNFG_CHG_B, 118 MAX77650_CHARGER_ICHGIN_LIM_MASK, 119 MAX77650_CHARGER_ICHGIN_LIM_SHIFT(i)); 120 if (rv) 121 return rv; 122 123 return 0; 124 } 125 } 126 127 return -EINVAL; 128 } 129 130 static int max77650_charger_enable(struct max77650_charger_data *chg) 131 { 132 int rv; 133 134 rv = regmap_update_bits(chg->map, 135 MAX77650_REG_CNFG_CHG_B, 136 MAX77650_CHARGER_CHG_EN_MASK, 137 MAX77650_CHARGER_ENABLED); 138 if (rv) 139 dev_err(chg->dev, "unable to enable the charger: %d\n", rv); 140 141 return rv; 142 } 143 144 static int max77650_charger_disable(struct max77650_charger_data *chg) 145 { 146 int rv; 147 148 rv = regmap_update_bits(chg->map, 149 MAX77650_REG_CNFG_CHG_B, 150 MAX77650_CHARGER_CHG_EN_MASK, 151 MAX77650_CHARGER_DISABLED); 152 if (rv) 153 dev_err(chg->dev, "unable to disable the charger: %d\n", rv); 154 155 return rv; 156 } 157 158 static irqreturn_t max77650_charger_check_status(int irq, void *data) 159 { 160 struct max77650_charger_data *chg = data; 161 int rv, reg; 162 163 rv = regmap_read(chg->map, MAX77650_REG_STAT_CHG_B, ®); 164 if (rv) { 165 dev_err(chg->dev, 166 "unable to read the charger status: %d\n", rv); 167 return IRQ_HANDLED; 168 } 169 170 switch (MAX77650_CHGIN_DETAILS_BITS(reg)) { 171 case MAX77650_CHGIN_UNDERVOLTAGE_LOCKOUT: 172 dev_err(chg->dev, "undervoltage lockout detected, disabling charger\n"); 173 max77650_charger_disable(chg); 174 break; 175 case MAX77650_CHGIN_OVERVOLTAGE_LOCKOUT: 176 dev_err(chg->dev, "overvoltage lockout detected, disabling charger\n"); 177 max77650_charger_disable(chg); 178 break; 179 case MAX77650_CHGIN_OKAY: 180 max77650_charger_enable(chg); 181 break; 182 default: 183 /* May be 0x10 - debouncing */ 184 break; 185 } 186 187 return IRQ_HANDLED; 188 } 189 190 static int max77650_charger_get_property(struct power_supply *psy, 191 enum power_supply_property psp, 192 union power_supply_propval *val) 193 { 194 struct max77650_charger_data *chg = power_supply_get_drvdata(psy); 195 int rv, reg; 196 197 switch (psp) { 198 case POWER_SUPPLY_PROP_STATUS: 199 rv = regmap_read(chg->map, MAX77650_REG_STAT_CHG_B, ®); 200 if (rv) 201 return rv; 202 203 if (MAX77650_CHARGER_CHG_CHARGING(reg)) { 204 val->intval = POWER_SUPPLY_STATUS_CHARGING; 205 break; 206 } 207 208 switch (MAX77650_CHG_DETAILS_BITS(reg)) { 209 case MAX77650_CHG_OFF: 210 case MAX77650_CHG_SUSP_PREQ_TIM_FAULT: 211 case MAX77650_CHG_SUSP_FAST_CHG_TIM_FAULT: 212 case MAX77650_CHG_SUSP_BATT_TEMP_FAULT: 213 val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING; 214 break; 215 case MAX77650_CHG_PREQ: 216 case MAX77650_CHG_ON_CURR: 217 case MAX77650_CHG_ON_CURR_JEITA: 218 case MAX77650_CHG_ON_VOLT: 219 case MAX77650_CHG_ON_VOLT_JEITA: 220 case MAX77650_CHG_ON_TOPOFF: 221 case MAX77650_CHG_ON_TOPOFF_JEITA: 222 val->intval = POWER_SUPPLY_STATUS_CHARGING; 223 break; 224 case MAX77650_CHG_DONE: 225 val->intval = POWER_SUPPLY_STATUS_FULL; 226 break; 227 default: 228 val->intval = POWER_SUPPLY_STATUS_UNKNOWN; 229 } 230 break; 231 case POWER_SUPPLY_PROP_ONLINE: 232 rv = regmap_read(chg->map, MAX77650_REG_STAT_CHG_B, ®); 233 if (rv) 234 return rv; 235 236 val->intval = MAX77650_CHARGER_CHG_CHARGING(reg); 237 break; 238 case POWER_SUPPLY_PROP_CHARGE_TYPE: 239 rv = regmap_read(chg->map, MAX77650_REG_STAT_CHG_B, ®); 240 if (rv) 241 return rv; 242 243 if (!MAX77650_CHARGER_CHG_CHARGING(reg)) { 244 val->intval = POWER_SUPPLY_CHARGE_TYPE_NONE; 245 break; 246 } 247 248 switch (MAX77650_CHG_DETAILS_BITS(reg)) { 249 case MAX77650_CHG_PREQ: 250 case MAX77650_CHG_ON_CURR: 251 case MAX77650_CHG_ON_CURR_JEITA: 252 case MAX77650_CHG_ON_VOLT: 253 case MAX77650_CHG_ON_VOLT_JEITA: 254 val->intval = POWER_SUPPLY_CHARGE_TYPE_FAST; 255 break; 256 case MAX77650_CHG_ON_TOPOFF: 257 case MAX77650_CHG_ON_TOPOFF_JEITA: 258 val->intval = POWER_SUPPLY_CHARGE_TYPE_TRICKLE; 259 break; 260 default: 261 val->intval = POWER_SUPPLY_CHARGE_TYPE_UNKNOWN; 262 } 263 break; 264 default: 265 return -EINVAL; 266 } 267 268 return 0; 269 } 270 271 static const struct power_supply_desc max77650_battery_desc = { 272 .name = "max77650", 273 .type = POWER_SUPPLY_TYPE_USB, 274 .get_property = max77650_charger_get_property, 275 .properties = max77650_charger_properties, 276 .num_properties = ARRAY_SIZE(max77650_charger_properties), 277 }; 278 279 static int max77650_charger_probe(struct platform_device *pdev) 280 { 281 struct power_supply_config pscfg = {}; 282 struct max77650_charger_data *chg; 283 struct power_supply *battery; 284 struct device *dev, *parent; 285 int rv, chg_irq, chgin_irq; 286 unsigned int prop; 287 288 dev = &pdev->dev; 289 parent = dev->parent; 290 291 chg = devm_kzalloc(dev, sizeof(*chg), GFP_KERNEL); 292 if (!chg) 293 return -ENOMEM; 294 295 platform_set_drvdata(pdev, chg); 296 297 chg->map = dev_get_regmap(parent, NULL); 298 if (!chg->map) 299 return -ENODEV; 300 301 chg->dev = dev; 302 303 pscfg.of_node = dev->of_node; 304 pscfg.drv_data = chg; 305 306 chg_irq = platform_get_irq_byname(pdev, "CHG"); 307 if (chg_irq < 0) 308 return chg_irq; 309 310 chgin_irq = platform_get_irq_byname(pdev, "CHGIN"); 311 if (chgin_irq < 0) 312 return chgin_irq; 313 314 rv = devm_request_any_context_irq(dev, chg_irq, 315 max77650_charger_check_status, 316 IRQF_ONESHOT, "chg", chg); 317 if (rv < 0) 318 return rv; 319 320 rv = devm_request_any_context_irq(dev, chgin_irq, 321 max77650_charger_check_status, 322 IRQF_ONESHOT, "chgin", chg); 323 if (rv < 0) 324 return rv; 325 326 battery = devm_power_supply_register(dev, 327 &max77650_battery_desc, &pscfg); 328 if (IS_ERR(battery)) 329 return PTR_ERR(battery); 330 331 rv = of_property_read_u32(dev->of_node, 332 "input-voltage-min-microvolt", &prop); 333 if (rv == 0) { 334 rv = max77650_charger_set_vchgin_min(chg, prop); 335 if (rv) 336 return rv; 337 } 338 339 rv = of_property_read_u32(dev->of_node, 340 "input-current-limit-microamp", &prop); 341 if (rv == 0) { 342 rv = max77650_charger_set_ichgin_lim(chg, prop); 343 if (rv) 344 return rv; 345 } 346 347 return max77650_charger_enable(chg); 348 } 349 350 static int max77650_charger_remove(struct platform_device *pdev) 351 { 352 struct max77650_charger_data *chg = platform_get_drvdata(pdev); 353 354 return max77650_charger_disable(chg); 355 } 356 357 static const struct of_device_id max77650_charger_of_match[] = { 358 { .compatible = "maxim,max77650-charger" }, 359 { } 360 }; 361 MODULE_DEVICE_TABLE(of, max77650_charger_of_match); 362 363 static struct platform_driver max77650_charger_driver = { 364 .driver = { 365 .name = "max77650-charger", 366 .of_match_table = max77650_charger_of_match, 367 }, 368 .probe = max77650_charger_probe, 369 .remove = max77650_charger_remove, 370 }; 371 module_platform_driver(max77650_charger_driver); 372 373 MODULE_DESCRIPTION("MAXIM 77650/77651 charger driver"); 374 MODULE_AUTHOR("Bartosz Golaszewski <bgolaszewski@baylibre.com>"); 375 MODULE_LICENSE("GPL v2"); 376 MODULE_ALIAS("platform:max77650-charger"); 377