1 /* 2 * Battery driver for LEGO MINDSTORMS EV3 3 * 4 * Copyright (C) 2017 David Lechner <david@lechnology.com> 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License version 2 as 8 * published by the Free Software Foundation. 9 10 * This program is distributed "as is" WITHOUT ANY WARRANTY of any 11 * kind, whether express or implied; without even the implied warranty 12 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 * GNU General Public License for more details. 14 */ 15 16 #include <linux/delay.h> 17 #include <linux/err.h> 18 #include <linux/gpio/consumer.h> 19 #include <linux/iio/consumer.h> 20 #include <linux/iio/types.h> 21 #include <linux/kernel.h> 22 #include <linux/module.h> 23 #include <linux/mod_devicetable.h> 24 #include <linux/platform_device.h> 25 #include <linux/power_supply.h> 26 27 struct lego_ev3_battery { 28 struct iio_channel *iio_v; 29 struct iio_channel *iio_i; 30 struct gpio_desc *rechargeable_gpio; 31 struct power_supply *psy; 32 int technology; 33 int v_max; 34 int v_min; 35 }; 36 37 static int lego_ev3_battery_get_property(struct power_supply *psy, 38 enum power_supply_property psp, 39 union power_supply_propval *val) 40 { 41 struct lego_ev3_battery *batt = power_supply_get_drvdata(psy); 42 int ret, val2; 43 44 switch (psp) { 45 case POWER_SUPPLY_PROP_TECHNOLOGY: 46 val->intval = batt->technology; 47 break; 48 case POWER_SUPPLY_PROP_VOLTAGE_NOW: 49 /* battery voltage is iio channel * 2 + Vce of transistor */ 50 ret = iio_read_channel_processed(batt->iio_v, &val->intval); 51 if (ret) 52 return ret; 53 54 val->intval *= 2000; 55 val->intval += 50000; 56 57 /* plus adjust for shunt resistor drop */ 58 ret = iio_read_channel_processed(batt->iio_i, &val2); 59 if (ret) 60 return ret; 61 62 val2 *= 1000; 63 val2 /= 15; 64 val->intval += val2; 65 break; 66 case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN: 67 val->intval = batt->v_max; 68 break; 69 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN: 70 val->intval = batt->v_min; 71 break; 72 case POWER_SUPPLY_PROP_CURRENT_NOW: 73 /* battery current is iio channel / 15 / 0.05 ohms */ 74 ret = iio_read_channel_processed(batt->iio_i, &val->intval); 75 if (ret) 76 return ret; 77 78 val->intval *= 20000; 79 val->intval /= 15; 80 break; 81 case POWER_SUPPLY_PROP_SCOPE: 82 val->intval = POWER_SUPPLY_SCOPE_SYSTEM; 83 break; 84 default: 85 return -EINVAL; 86 } 87 88 return 0; 89 } 90 91 static int lego_ev3_battery_set_property(struct power_supply *psy, 92 enum power_supply_property psp, 93 const union power_supply_propval *val) 94 { 95 struct lego_ev3_battery *batt = power_supply_get_drvdata(psy); 96 97 switch (psp) { 98 case POWER_SUPPLY_PROP_TECHNOLOGY: 99 /* 100 * Only allow changing technology from Unknown to NiMH. Li-ion 101 * batteries are automatically detected and should not be 102 * overridden. Rechargeable AA batteries, on the other hand, 103 * cannot be automatically detected, and so must be manually 104 * specified. This should only be set once during system init, 105 * so there is no mechanism to go back to Unknown. 106 */ 107 if (batt->technology != POWER_SUPPLY_TECHNOLOGY_UNKNOWN) 108 return -EINVAL; 109 switch (val->intval) { 110 case POWER_SUPPLY_TECHNOLOGY_NiMH: 111 batt->technology = POWER_SUPPLY_TECHNOLOGY_NiMH; 112 batt->v_max = 7800000; 113 batt->v_min = 5400000; 114 break; 115 default: 116 return -EINVAL; 117 } 118 break; 119 default: 120 return -EINVAL; 121 } 122 123 return 0; 124 } 125 126 static int lego_ev3_battery_property_is_writeable(struct power_supply *psy, 127 enum power_supply_property psp) 128 { 129 struct lego_ev3_battery *batt = power_supply_get_drvdata(psy); 130 131 return psp == POWER_SUPPLY_PROP_TECHNOLOGY && 132 batt->technology == POWER_SUPPLY_TECHNOLOGY_UNKNOWN; 133 } 134 135 static enum power_supply_property lego_ev3_battery_props[] = { 136 POWER_SUPPLY_PROP_TECHNOLOGY, 137 POWER_SUPPLY_PROP_VOLTAGE_NOW, 138 POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN, 139 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN, 140 POWER_SUPPLY_PROP_CURRENT_NOW, 141 POWER_SUPPLY_PROP_SCOPE, 142 }; 143 144 static const struct power_supply_desc lego_ev3_battery_desc = { 145 .name = "lego-ev3-battery", 146 .type = POWER_SUPPLY_TYPE_BATTERY, 147 .properties = lego_ev3_battery_props, 148 .num_properties = ARRAY_SIZE(lego_ev3_battery_props), 149 .get_property = lego_ev3_battery_get_property, 150 .set_property = lego_ev3_battery_set_property, 151 .property_is_writeable = lego_ev3_battery_property_is_writeable, 152 }; 153 154 static int lego_ev3_battery_probe(struct platform_device *pdev) 155 { 156 struct device *dev = &pdev->dev; 157 struct lego_ev3_battery *batt; 158 struct power_supply_config psy_cfg = {}; 159 int err; 160 161 batt = devm_kzalloc(dev, sizeof(*batt), GFP_KERNEL); 162 if (!batt) 163 return -ENOMEM; 164 165 platform_set_drvdata(pdev, batt); 166 167 batt->iio_v = devm_iio_channel_get(dev, "voltage"); 168 err = PTR_ERR_OR_ZERO(batt->iio_v); 169 if (err) 170 return dev_err_probe(dev, err, 171 "Failed to get voltage iio channel\n"); 172 173 batt->iio_i = devm_iio_channel_get(dev, "current"); 174 err = PTR_ERR_OR_ZERO(batt->iio_i); 175 if (err) 176 return dev_err_probe(dev, err, 177 "Failed to get current iio channel\n"); 178 179 batt->rechargeable_gpio = devm_gpiod_get(dev, "rechargeable", GPIOD_IN); 180 err = PTR_ERR_OR_ZERO(batt->rechargeable_gpio); 181 if (err) 182 return dev_err_probe(dev, err, 183 "Failed to get rechargeable gpio\n"); 184 185 /* 186 * The rechargeable battery indication switch cannot be changed without 187 * removing the battery, so we only need to read it once. 188 */ 189 if (gpiod_get_value(batt->rechargeable_gpio)) { 190 /* 2-cell Li-ion, 7.4V nominal */ 191 batt->technology = POWER_SUPPLY_TECHNOLOGY_LION; 192 batt->v_max = 84000000; 193 batt->v_min = 60000000; 194 } else { 195 /* 6x AA Alkaline, 9V nominal */ 196 batt->technology = POWER_SUPPLY_TECHNOLOGY_UNKNOWN; 197 batt->v_max = 90000000; 198 batt->v_min = 48000000; 199 } 200 201 psy_cfg.of_node = pdev->dev.of_node; 202 psy_cfg.drv_data = batt; 203 204 batt->psy = devm_power_supply_register(dev, &lego_ev3_battery_desc, 205 &psy_cfg); 206 err = PTR_ERR_OR_ZERO(batt->psy); 207 if (err) { 208 dev_err(dev, "failed to register power supply\n"); 209 return err; 210 } 211 212 return 0; 213 } 214 215 static const struct of_device_id of_lego_ev3_battery_match[] = { 216 { .compatible = "lego,ev3-battery", }, 217 { } 218 }; 219 MODULE_DEVICE_TABLE(of, of_lego_ev3_battery_match); 220 221 static struct platform_driver lego_ev3_battery_driver = { 222 .driver = { 223 .name = "lego-ev3-battery", 224 .of_match_table = of_lego_ev3_battery_match, 225 }, 226 .probe = lego_ev3_battery_probe, 227 }; 228 module_platform_driver(lego_ev3_battery_driver); 229 230 MODULE_LICENSE("GPL"); 231 MODULE_AUTHOR("David Lechner <david@lechnology.com>"); 232 MODULE_DESCRIPTION("LEGO MINDSTORMS EV3 Battery Driver"); 233