1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Dumb driver for LiIon batteries using TWL4030 madc. 4 * 5 * Copyright 2013 Golden Delicious Computers 6 * Lukas Märdian <lukas@goldelico.com> 7 * 8 * Based on dumb driver for gta01 battery 9 * Copyright 2009 Openmoko, Inc 10 * Balaji Rao <balajirrao@openmoko.org> 11 */ 12 13 #include <linux/module.h> 14 #include <linux/param.h> 15 #include <linux/delay.h> 16 #include <linux/workqueue.h> 17 #include <linux/platform_device.h> 18 #include <linux/power_supply.h> 19 #include <linux/slab.h> 20 #include <linux/sort.h> 21 #include <linux/power/twl4030_madc_battery.h> 22 #include <linux/iio/consumer.h> 23 24 struct twl4030_madc_battery { 25 struct power_supply *psy; 26 struct twl4030_madc_bat_platform_data *pdata; 27 struct iio_channel *channel_temp; 28 struct iio_channel *channel_ichg; 29 struct iio_channel *channel_vbat; 30 }; 31 32 static enum power_supply_property twl4030_madc_bat_props[] = { 33 POWER_SUPPLY_PROP_PRESENT, 34 POWER_SUPPLY_PROP_STATUS, 35 POWER_SUPPLY_PROP_TECHNOLOGY, 36 POWER_SUPPLY_PROP_VOLTAGE_NOW, 37 POWER_SUPPLY_PROP_CURRENT_NOW, 38 POWER_SUPPLY_PROP_CAPACITY, 39 POWER_SUPPLY_PROP_CHARGE_FULL, 40 POWER_SUPPLY_PROP_CHARGE_NOW, 41 POWER_SUPPLY_PROP_TEMP, 42 POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW, 43 }; 44 45 static int madc_read(struct iio_channel *channel) 46 { 47 int val, err; 48 err = iio_read_channel_processed(channel, &val); 49 if (err < 0) 50 return err; 51 52 return val; 53 } 54 55 static int twl4030_madc_bat_get_charging_status(struct twl4030_madc_battery *bt) 56 { 57 return (madc_read(bt->channel_ichg) > 0) ? 1 : 0; 58 } 59 60 static int twl4030_madc_bat_get_voltage(struct twl4030_madc_battery *bt) 61 { 62 return madc_read(bt->channel_vbat); 63 } 64 65 static int twl4030_madc_bat_get_current(struct twl4030_madc_battery *bt) 66 { 67 return madc_read(bt->channel_ichg) * 1000; 68 } 69 70 static int twl4030_madc_bat_get_temp(struct twl4030_madc_battery *bt) 71 { 72 return madc_read(bt->channel_temp) * 10; 73 } 74 75 static int twl4030_madc_bat_voltscale(struct twl4030_madc_battery *bat, 76 int volt) 77 { 78 struct twl4030_madc_bat_calibration *calibration; 79 int i, res = 0; 80 81 /* choose charging curve */ 82 if (twl4030_madc_bat_get_charging_status(bat)) 83 calibration = bat->pdata->charging; 84 else 85 calibration = bat->pdata->discharging; 86 87 if (volt > calibration[0].voltage) { 88 res = calibration[0].level; 89 } else { 90 for (i = 0; calibration[i+1].voltage >= 0; i++) { 91 if (volt <= calibration[i].voltage && 92 volt >= calibration[i+1].voltage) { 93 /* interval found - interpolate within range */ 94 res = calibration[i].level - 95 ((calibration[i].voltage - volt) * 96 (calibration[i].level - 97 calibration[i+1].level)) / 98 (calibration[i].voltage - 99 calibration[i+1].voltage); 100 break; 101 } 102 } 103 } 104 return res; 105 } 106 107 static int twl4030_madc_bat_get_property(struct power_supply *psy, 108 enum power_supply_property psp, 109 union power_supply_propval *val) 110 { 111 struct twl4030_madc_battery *bat = power_supply_get_drvdata(psy); 112 113 switch (psp) { 114 case POWER_SUPPLY_PROP_STATUS: 115 if (twl4030_madc_bat_voltscale(bat, 116 twl4030_madc_bat_get_voltage(bat)) > 95) 117 val->intval = POWER_SUPPLY_STATUS_FULL; 118 else { 119 if (twl4030_madc_bat_get_charging_status(bat)) 120 val->intval = POWER_SUPPLY_STATUS_CHARGING; 121 else 122 val->intval = POWER_SUPPLY_STATUS_DISCHARGING; 123 } 124 break; 125 case POWER_SUPPLY_PROP_VOLTAGE_NOW: 126 val->intval = twl4030_madc_bat_get_voltage(bat) * 1000; 127 break; 128 case POWER_SUPPLY_PROP_TECHNOLOGY: 129 val->intval = POWER_SUPPLY_TECHNOLOGY_LION; 130 break; 131 case POWER_SUPPLY_PROP_CURRENT_NOW: 132 val->intval = twl4030_madc_bat_get_current(bat); 133 break; 134 case POWER_SUPPLY_PROP_PRESENT: 135 /* assume battery is always present */ 136 val->intval = 1; 137 break; 138 case POWER_SUPPLY_PROP_CHARGE_NOW: { 139 int percent = twl4030_madc_bat_voltscale(bat, 140 twl4030_madc_bat_get_voltage(bat)); 141 val->intval = (percent * bat->pdata->capacity) / 100; 142 break; 143 } 144 case POWER_SUPPLY_PROP_CAPACITY: 145 val->intval = twl4030_madc_bat_voltscale(bat, 146 twl4030_madc_bat_get_voltage(bat)); 147 break; 148 case POWER_SUPPLY_PROP_CHARGE_FULL: 149 val->intval = bat->pdata->capacity; 150 break; 151 case POWER_SUPPLY_PROP_TEMP: 152 val->intval = twl4030_madc_bat_get_temp(bat); 153 break; 154 case POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW: { 155 int percent = twl4030_madc_bat_voltscale(bat, 156 twl4030_madc_bat_get_voltage(bat)); 157 /* in mAh */ 158 int chg = (percent * (bat->pdata->capacity/1000))/100; 159 160 /* assume discharge with 400 mA (ca. 1.5W) */ 161 val->intval = (3600l * chg) / 400; 162 break; 163 } 164 default: 165 return -EINVAL; 166 } 167 168 return 0; 169 } 170 171 static void twl4030_madc_bat_ext_changed(struct power_supply *psy) 172 { 173 power_supply_changed(psy); 174 } 175 176 static const struct power_supply_desc twl4030_madc_bat_desc = { 177 .name = "twl4030_battery", 178 .type = POWER_SUPPLY_TYPE_BATTERY, 179 .properties = twl4030_madc_bat_props, 180 .num_properties = ARRAY_SIZE(twl4030_madc_bat_props), 181 .get_property = twl4030_madc_bat_get_property, 182 .external_power_changed = twl4030_madc_bat_ext_changed, 183 184 }; 185 186 static int twl4030_cmp(const void *a, const void *b) 187 { 188 return ((struct twl4030_madc_bat_calibration *)b)->voltage - 189 ((struct twl4030_madc_bat_calibration *)a)->voltage; 190 } 191 192 static int twl4030_madc_battery_probe(struct platform_device *pdev) 193 { 194 struct twl4030_madc_battery *twl4030_madc_bat; 195 struct twl4030_madc_bat_platform_data *pdata = pdev->dev.platform_data; 196 struct power_supply_config psy_cfg = {}; 197 int ret = 0; 198 199 twl4030_madc_bat = devm_kzalloc(&pdev->dev, sizeof(*twl4030_madc_bat), 200 GFP_KERNEL); 201 if (!twl4030_madc_bat) 202 return -ENOMEM; 203 204 twl4030_madc_bat->channel_temp = iio_channel_get(&pdev->dev, "temp"); 205 if (IS_ERR(twl4030_madc_bat->channel_temp)) { 206 ret = PTR_ERR(twl4030_madc_bat->channel_temp); 207 goto err; 208 } 209 210 twl4030_madc_bat->channel_ichg = iio_channel_get(&pdev->dev, "ichg"); 211 if (IS_ERR(twl4030_madc_bat->channel_ichg)) { 212 ret = PTR_ERR(twl4030_madc_bat->channel_ichg); 213 goto err_temp; 214 } 215 216 twl4030_madc_bat->channel_vbat = iio_channel_get(&pdev->dev, "vbat"); 217 if (IS_ERR(twl4030_madc_bat->channel_vbat)) { 218 ret = PTR_ERR(twl4030_madc_bat->channel_vbat); 219 goto err_ichg; 220 } 221 222 /* sort charging and discharging calibration data */ 223 sort(pdata->charging, pdata->charging_size, 224 sizeof(struct twl4030_madc_bat_calibration), 225 twl4030_cmp, NULL); 226 sort(pdata->discharging, pdata->discharging_size, 227 sizeof(struct twl4030_madc_bat_calibration), 228 twl4030_cmp, NULL); 229 230 twl4030_madc_bat->pdata = pdata; 231 platform_set_drvdata(pdev, twl4030_madc_bat); 232 psy_cfg.drv_data = twl4030_madc_bat; 233 twl4030_madc_bat->psy = power_supply_register(&pdev->dev, 234 &twl4030_madc_bat_desc, 235 &psy_cfg); 236 if (IS_ERR(twl4030_madc_bat->psy)) { 237 ret = PTR_ERR(twl4030_madc_bat->psy); 238 goto err_vbat; 239 } 240 241 return 0; 242 243 err_vbat: 244 iio_channel_release(twl4030_madc_bat->channel_vbat); 245 err_ichg: 246 iio_channel_release(twl4030_madc_bat->channel_ichg); 247 err_temp: 248 iio_channel_release(twl4030_madc_bat->channel_temp); 249 err: 250 return ret; 251 } 252 253 static int twl4030_madc_battery_remove(struct platform_device *pdev) 254 { 255 struct twl4030_madc_battery *bat = platform_get_drvdata(pdev); 256 257 power_supply_unregister(bat->psy); 258 259 iio_channel_release(bat->channel_vbat); 260 iio_channel_release(bat->channel_ichg); 261 iio_channel_release(bat->channel_temp); 262 263 return 0; 264 } 265 266 static struct platform_driver twl4030_madc_battery_driver = { 267 .driver = { 268 .name = "twl4030_madc_battery", 269 }, 270 .probe = twl4030_madc_battery_probe, 271 .remove = twl4030_madc_battery_remove, 272 }; 273 module_platform_driver(twl4030_madc_battery_driver); 274 275 MODULE_LICENSE("GPL"); 276 MODULE_AUTHOR("Lukas Märdian <lukas@goldelico.com>"); 277 MODULE_DESCRIPTION("twl4030_madc battery driver"); 278 MODULE_ALIAS("platform:twl4030_madc_battery"); 279