drivers/power/supply/cros_charge-control.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *  ChromeOS EC driver for charge control
   4  *
   5  *  Copyright (C) 2024 Thomas Weißschuh <linux@weissschuh.net>
   6  */
   7 #include <acpi/battery.h>
   8 #include <linux/container_of.h>
   9 #include <linux/dmi.h>
  10 #include <linux/mod_devicetable.h>
  11 #include <linux/module.h>
  12 #include <linux/platform_data/cros_ec_commands.h>
  13 #include <linux/platform_data/cros_ec_proto.h>
  14 #include <linux/platform_device.h>
  15 #include <linux/types.h>
  16
  17 #define EC_CHARGE_CONTROL_BEHAVIOURS    (BIT(POWER_SUPPLY_CHARGE_BEHAVIOUR_AUTO)             | \
  18                                          BIT(POWER_SUPPLY_CHARGE_BEHAVIOUR_INHIBIT_CHARGE)   | \
  19                                          BIT(POWER_SUPPLY_CHARGE_BEHAVIOUR_FORCE_DISCHARGE))
  20
  21 enum CROS_CHCTL_ATTR {
  22         CROS_CHCTL_ATTR_START_THRESHOLD,
  23         CROS_CHCTL_ATTR_END_THRESHOLD,
  24         CROS_CHCTL_ATTR_CHARGE_BEHAVIOUR,
  25         _CROS_CHCTL_ATTR_COUNT
  26 };
  27
  28 /*
  29  * Semantics of data *returned* from the EC API and Linux sysfs differ
  30  * slightly, also the v1 API can not return any data.
  31  * To match the expected sysfs API, data is never read back from the EC but
  32  * cached in the driver.
  33  *
  34  * Changes to the EC bypassing the driver will not be reflected in sysfs.
  35  * Any change to "charge_behaviour" will synchronize the EC with the driver state.
  36  */
  37
  38 struct cros_chctl_priv {
  39         struct cros_ec_device *cros_ec;
  40         struct acpi_battery_hook battery_hook;
  41         struct power_supply *hooked_battery;
  42         u8 cmd_version;
  43
  44         /* The callbacks need to access this priv structure.
  45          * As neither the struct device nor power_supply are under the drivers
  46          * control, embed the attributes within priv to use with container_of().
  47          */
  48         struct device_attribute device_attrs[_CROS_CHCTL_ATTR_COUNT];
  49         struct attribute *attributes[_CROS_CHCTL_ATTR_COUNT];
  50         struct attribute_group group;
  51
  52         enum power_supply_charge_behaviour current_behaviour;
  53         u8 current_start_threshold, current_end_threshold;
  54 };
  55
  56 static int cros_chctl_send_charge_control_cmd(struct cros_ec_device *cros_ec,
  57                                               u8 cmd_version, struct ec_params_charge_control *req)
  58 {
  59         static const u8 outsizes[] = {
  60                 [1] = offsetof(struct ec_params_charge_control, cmd),
  61                 [2] = sizeof(struct ec_params_charge_control),
  62                 [3] = sizeof(struct ec_params_charge_control),
  63         };
  64
  65         struct {
  66                 struct cros_ec_command msg;
  67                 union {
  68                         struct ec_params_charge_control req;
  69                         struct ec_response_charge_control resp;
  70                 } __packed data;
  71         } __packed buf = {
  72                 .msg = {
  73                         .command = EC_CMD_CHARGE_CONTROL,
  74                         .version = cmd_version,
  75                         .insize  = 0,
  76                         .outsize = outsizes[cmd_version],
  77                 },
  78                 .data.req = *req,
  79         };
  80
  81         return cros_ec_cmd_xfer_status(cros_ec, &buf.msg);
  82 }
  83
  84 static int cros_chctl_configure_ec(struct cros_chctl_priv *priv)
  85 {
  86         struct ec_params_charge_control req = {};
  87
  88         req.cmd = EC_CHARGE_CONTROL_CMD_SET;
  89
  90         switch (priv->current_behaviour) {
  91         case POWER_SUPPLY_CHARGE_BEHAVIOUR_AUTO:
  92                 req.mode = CHARGE_CONTROL_NORMAL;
  93                 break;
  94         case POWER_SUPPLY_CHARGE_BEHAVIOUR_INHIBIT_CHARGE:
  95                 req.mode = CHARGE_CONTROL_IDLE;
  96                 break;
  97         case POWER_SUPPLY_CHARGE_BEHAVIOUR_FORCE_DISCHARGE:
  98                 req.mode = CHARGE_CONTROL_DISCHARGE;
  99                 break;
 100         default:
 101                 return -EINVAL;
 102         }
 103
 104         if (priv->current_behaviour == POWER_SUPPLY_CHARGE_BEHAVIOUR_AUTO &&
 105             !(priv->current_start_threshold == 0 && priv->current_end_threshold == 100)) {
 106                 req.sustain_soc.lower = priv->current_start_threshold;
 107                 req.sustain_soc.upper = priv->current_end_threshold;
 108         } else {
 109                 /* Disable charging limits */
 110                 req.sustain_soc.lower = -1;
 111                 req.sustain_soc.upper = -1;
 112         }
 113
 114         return cros_chctl_send_charge_control_cmd(priv->cros_ec, priv->cmd_version, &req);
 115 }
 116
 117 static struct cros_chctl_priv *cros_chctl_attr_to_priv(struct attribute *attr,
 118                                                        enum CROS_CHCTL_ATTR idx)
 119 {
 120         struct device_attribute *dev_attr = container_of(attr, struct device_attribute, attr);
 121
 122         return container_of(dev_attr, struct cros_chctl_priv, device_attrs[idx]);
 123 }
 124
 125 static ssize_t cros_chctl_store_threshold(struct device *dev, struct cros_chctl_priv *priv,
 126                                           int is_end_threshold, const char *buf, size_t count)
 127 {
 128         int ret, val;
 129
 130         ret = kstrtoint(buf, 10, &val);
 131         if (ret < 0)
 132                 return ret;
 133         if (val < 0 || val > 100)
 134                 return -EINVAL;
 135
 136         if (is_end_threshold) {
 137                 if (val <= priv->current_start_threshold)
 138                         return -EINVAL;
 139                 priv->current_end_threshold = val;
 140         } else {
 141                 if (val >= priv->current_end_threshold)
 142                         return -EINVAL;
 143                 priv->current_start_threshold = val;
 144         }
 145
 146         if (priv->current_behaviour == POWER_SUPPLY_CHARGE_BEHAVIOUR_AUTO) {
 147                 ret = cros_chctl_configure_ec(priv);
 148                 if (ret < 0)
 149                         return ret;
 150         }
 151
 152         return count;
 153 }
 154
 155 static ssize_t charge_control_start_threshold_show(struct device *dev,
 156                                                    struct device_attribute *attr,
 157                                                    char *buf)
 158 {
 159         struct cros_chctl_priv *priv = cros_chctl_attr_to_priv(&attr->attr,
 160                                                                CROS_CHCTL_ATTR_START_THRESHOLD);
 161
 162         return sysfs_emit(buf, "%u\n", (unsigned int)priv->current_start_threshold);
 163 }
 164
 165 static ssize_t charge_control_start_threshold_store(struct device *dev,
 166                                                     struct device_attribute *attr,
 167                                                     const char *buf, size_t count)
 168 {
 169         struct cros_chctl_priv *priv = cros_chctl_attr_to_priv(&attr->attr,
 170                                                                CROS_CHCTL_ATTR_START_THRESHOLD);
 171
 172         return cros_chctl_store_threshold(dev, priv, 0, buf, count);
 173 }
 174
 175 static ssize_t charge_control_end_threshold_show(struct device *dev, struct device_attribute *attr,
 176                                                  char *buf)
 177 {
 178         struct cros_chctl_priv *priv = cros_chctl_attr_to_priv(&attr->attr,
 179                                                                CROS_CHCTL_ATTR_END_THRESHOLD);
 180
 181         return sysfs_emit(buf, "%u\n", (unsigned int)priv->current_end_threshold);
 182 }
 183
 184 static ssize_t charge_control_end_threshold_store(struct device *dev, struct device_attribute *attr,
 185                                                   const char *buf, size_t count)
 186 {
 187         struct cros_chctl_priv *priv = cros_chctl_attr_to_priv(&attr->attr,
 188                                                                CROS_CHCTL_ATTR_END_THRESHOLD);
 189
 190         return cros_chctl_store_threshold(dev, priv, 1, buf, count);
 191 }
 192
 193 static ssize_t charge_behaviour_show(struct device *dev, struct device_attribute *attr, char *buf)
 194 {
 195         struct cros_chctl_priv *priv = cros_chctl_attr_to_priv(&attr->attr,
 196                                                                CROS_CHCTL_ATTR_CHARGE_BEHAVIOUR);
 197
 198         return power_supply_charge_behaviour_show(dev, EC_CHARGE_CONTROL_BEHAVIOURS,
 199                                                   priv->current_behaviour, buf);
 200 }
 201
 202 static ssize_t charge_behaviour_store(struct device *dev, struct device_attribute *attr,
 203                                       const char *buf, size_t count)
 204 {
 205         struct cros_chctl_priv *priv = cros_chctl_attr_to_priv(&attr->attr,
 206                                                                CROS_CHCTL_ATTR_CHARGE_BEHAVIOUR);
 207         int ret;
 208
 209         ret = power_supply_charge_behaviour_parse(EC_CHARGE_CONTROL_BEHAVIOURS, buf);
 210         if (ret < 0)
 211                 return ret;
 212
 213         priv->current_behaviour = ret;
 214
 215         ret = cros_chctl_configure_ec(priv);
 216         if (ret < 0)
 217                 return ret;
 218
 219         return count;
 220 }
 221
 222 static umode_t cros_chtl_attr_is_visible(struct kobject *kobj, struct attribute *attr, int n)
 223 {
 224         struct cros_chctl_priv *priv = cros_chctl_attr_to_priv(attr, n);
 225
 226         if (priv->cmd_version < 2) {
 227                 if (n == CROS_CHCTL_ATTR_START_THRESHOLD)
 228                         return 0;
 229                 if (n == CROS_CHCTL_ATTR_END_THRESHOLD)
 230                         return 0;
 231         }
 232
 233         return attr->mode;
 234 }
 235
 236 static int cros_chctl_add_battery(struct power_supply *battery, struct acpi_battery_hook *hook)
 237 {
 238         struct cros_chctl_priv *priv = container_of(hook, struct cros_chctl_priv, battery_hook);
 239
 240         if (priv->hooked_battery)
 241                 return 0;
 242
 243         priv->hooked_battery = battery;
 244         return device_add_group(&battery->dev, &priv->group);
 245 }
 246
 247 static int cros_chctl_remove_battery(struct power_supply *battery, struct acpi_battery_hook *hook)
 248 {
 249         struct cros_chctl_priv *priv = container_of(hook, struct cros_chctl_priv, battery_hook);
 250
 251         if (priv->hooked_battery == battery) {
 252                 device_remove_group(&battery->dev, &priv->group);
 253                 priv->hooked_battery = NULL;
 254         }
 255
 256         return 0;
 257 }
 258
 259 static bool probe_with_fwk_charge_control;
 260 module_param(probe_with_fwk_charge_control, bool, 0644);
 261 MODULE_PARM_DESC(probe_with_fwk_charge_control,
 262                  "Probe the driver in the presence of the custom Framework EC charge control");
 263
 264 static int cros_chctl_fwk_charge_control_versions(struct cros_ec_device *cros_ec)
 265 {
 266         if (!dmi_match(DMI_SYS_VENDOR, "Framework"))
 267                 return 0;
 268
 269         return cros_ec_get_cmd_versions(cros_ec, 0x3E03 /* FW_EC_CMD_CHARGE_LIMIT */);
 270 }
 271
 272 static int cros_chctl_probe(struct platform_device *pdev)
 273 {
 274         struct device *dev = &pdev->dev;
 275         struct cros_ec_dev *ec_dev = dev_get_drvdata(dev->parent);
 276         struct cros_ec_device *cros_ec = ec_dev->ec_dev;
 277         struct cros_chctl_priv *priv;
 278         size_t i;
 279         int ret;
 280
 281         ret = cros_chctl_fwk_charge_control_versions(cros_ec);
 282         if (ret < 0)
 283                 return ret;
 284         if (ret > 0 && !probe_with_fwk_charge_control) {
 285                 dev_info(dev, "Framework charge control detected, preventing load\n");
 286                 return -ENODEV;
 287         }
 288
 289         priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
 290         if (!priv)
 291                 return -ENOMEM;
 292
 293         ret = cros_ec_get_cmd_versions(cros_ec, EC_CMD_CHARGE_CONTROL);
 294         if (ret < 0)
 295                 return ret;
 296         else if (ret & EC_VER_MASK(3))
 297                 priv->cmd_version = 3;
 298         else if (ret & EC_VER_MASK(2))
 299                 priv->cmd_version = 2;
 300         else if (ret & EC_VER_MASK(1))
 301                 priv->cmd_version = 1;
 302         else
 303                 return -ENODEV;
 304
 305         dev_dbg(dev, "Command version: %u\n", (unsigned int)priv->cmd_version);
 306
 307         priv->cros_ec = cros_ec;
 308         priv->device_attrs[CROS_CHCTL_ATTR_START_THRESHOLD] =
 309                 (struct device_attribute)__ATTR_RW(charge_control_start_threshold);
 310         priv->device_attrs[CROS_CHCTL_ATTR_END_THRESHOLD] =
 311                 (struct device_attribute)__ATTR_RW(charge_control_end_threshold);
 312         priv->device_attrs[CROS_CHCTL_ATTR_CHARGE_BEHAVIOUR] =
 313                 (struct device_attribute)__ATTR_RW(charge_behaviour);
 314         for (i = 0; i < _CROS_CHCTL_ATTR_COUNT; i++) {
 315                 sysfs_attr_init(&priv->device_attrs[i].attr);
 316                 priv->attributes[i] = &priv->device_attrs[i].attr;
 317         }
 318         priv->group.is_visible = cros_chtl_attr_is_visible;
 319         priv->group.attrs = priv->attributes;
 320
 321         priv->battery_hook.name = dev_name(dev);
 322         priv->battery_hook.add_battery = cros_chctl_add_battery;
 323         priv->battery_hook.remove_battery = cros_chctl_remove_battery;
 324
 325         priv->current_behaviour = POWER_SUPPLY_CHARGE_BEHAVIOUR_AUTO;
 326         priv->current_start_threshold = 0;
 327         priv->current_end_threshold = 100;
 328
 329         /* Bring EC into well-known state */
 330         ret = cros_chctl_configure_ec(priv);
 331         if (ret < 0)
 332                 return ret;
 333
 334         return devm_battery_hook_register(dev, &priv->battery_hook);
 335 }
 336
 337 static const struct platform_device_id cros_chctl_id[] = {
 338         { "cros-charge-control", 0 },
 339         {}
 340 };
 341
 342 static struct platform_driver cros_chctl_driver = {
 343         .driver.name    = "cros-charge-control",
 344         .probe          = cros_chctl_probe,
 345         .id_table       = cros_chctl_id,
 346 };
 347 module_platform_driver(cros_chctl_driver);
 348
 349 MODULE_DEVICE_TABLE(platform, cros_chctl_id);
 350 MODULE_DESCRIPTION("ChromeOS EC charge control");
 351 MODULE_AUTHOR("Thomas Weißschuh <linux@weissschuh.net>");
 352 MODULE_LICENSE("GPL");