drivers/power/supply/lego_ev3_battery.c

   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/of_device.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");